Skip to content

AI-powered virtual executive team — a single coherent executive persona backed by 8 specialist agents (FastAPI + Next.js).

feat(ui): show each Delegate option as steps and rename For my inbox too (#514)

Rufus15734cc27585
diff --git a/packages/core/openexecutive/architecture/prebuilt/delegation.json b/packages/core/openexecutive/architecture/prebuilt/delegation.json
index 0c070219..f4380288 100644
--- a/packages/core/openexecutive/architecture/prebuilt/delegation.json
+++ b/packages/core/openexecutive/architecture/prebuilt/delegation.json
@@ -1,7 +1,7 @@
{
"section_id": "delegation",
"title": "Act as Me (Delegation)",
- "markdown": "The **delegation** module (`openexecutive.delegation`) is **Act as me**: the one place the Executive writes *as* a person instead of as itself. Everywhere else it has its own Google account and bots and signs as itself. Here — when the person asks, or, with a second switch, for mail in their inbox that needs them — it writes an email in their voice and saves it as a **draft in their own mailbox** — Gmail or Outlook — for them to review and send. The one thing it ever sends is one of those inbox drafts, exactly as it is in their mailbox: when the person taps **Send** on its card, or, with a third switch, **Handle it for me**, on its own when plain-code rules allow it (below); chat never sends. The principal can turn it on for themselves, and so can each team member once the owner lets them. It is off by default, and off changes nothing: the prompts, tool lists and prompt caches are byte-identical to an install without it.\n\n## Who can have it, and when it is offered\n\n`delegation.settings.can_delegate(person)` is the single rule for who may turn it on: the principal (a non-archived team member flagged `is_principal`), and any other non-archived team member — never a contact — once team members may have it (`team_members_enabled`). That takes two things: the install allows it (`DELEGATION_TEAM_MEMBERS`, default off, which offers the owner the switch) and the owner turned on **Let team members use it** (`PUT /delegation/team`, principal only, one row in `delegation_team`). Turning the owner's switch off takes it away from every team member from their next message, and their inbox watchers stop at their next check; their own switches, drafts and cards are kept. Everything is keyed by `person_id`. A person turns it on for themselves (`PUT /delegation`); nobody turns it on for anyone else. The setting is one row per person in `delegation_settings`, and a missing, unreadable or zero row all mean off.\n\nAt the start of every chat turn (`Executive.stream_chat` and the committee path) `pin_turn_delegation(session, speaker_text)` runs next to the workspace-mode pin and records a `TurnDelegation` on the session. `ghostwrite_email` is **offered** only when all of these hold:\n\n- the speaker may have it and turned it on — read fresh every turn, so turning it off applies from the next message;\n- the speaker is on a surface that verified it is them — the principal through `people_tools.is_principal_on_verified_surface`, a team member through `teammate_on_verified_surface` (the web app signed in, their own Slack or Discord, never an email turn) — and a web turn also carried a signed-in caller (`Session.web_caller_signed_in`, set from `x-caller-email`) or runs under local login — a request with no caller header is not a sign-in and never gets it (whoever holds the shared secret is trusted as the UI proxy that stamps that header, as on every principal-only route);\n- the conversation is private to the speaker: the web chat, a Slack or Discord DM, a verified private Telegram chat, or a chat its channel adapter verified the sender of and marked private (`Session.speaker_verified` + `Session.private_chat`) — never a shared channel or thread, where the draft's preview or the matching threads would be posted for everyone and other people's messages sit in the model's context;\n- the turn is neither unattended (the scheduler's proactive run) nor private to the principal (the email poller's turns), so inbound text can never reach it. The MCP server, workflows, reflection and research never carry it at all.\n\nThe mailbox connection is deliberately **not** part of the offer: the handler checks it on every call and says how to fix it, so the cached tool prefix never flips when a token lapses. The pin lives in a context variable for the turn's task as well as on the session, so two turns running at once on one session (a second browser tab) each read their own. It also carries the speaker's own words for the turn (a new email may go to an address they just typed — the turn's message joins the history only once the turn ends), a per-turn draft count, and `touched_mail` (see Privacy). `own_words` reads those words back for every own-words check (addresses here, facts and task assignments elsewhere): it first removes the hydrated `<outbound_reply_context>` backstory by its exact, anchored shape, so a look-alike closing tag quoted inside it cannot pass the rest off as the speaker's, then drops other adapter tag blocks, and returns nothing for a message carrying an attachment.\n\n## The tool: `ghostwrite_email`\n\nIt lives in its own registry (`orchestrator.delegation_tools.DELEGATION_TOOLS` / `DELEGATION_TOOL_HANDLERS`), **never** `_ALL_SKILL_TOOLS`, so no other toolkit can carry it. On a turn it is offered to, the agent loop adds it to the pool *before* the sort and builds that turn's handler map from both registries; on any other turn a call to it is an unknown tool. The handler re-checks the pin and the surface anyway, then:\n\n1. **Caps** — at most 5 drafts per turn, and `DELEGATION_MAX_DRAFTS_PER_DAY` (default 50, at most 1000) per person per UTC day, shared with the inbox watcher (`delegation.caps`). It is counted from `delegation_drafts`, one row of ids per draft saved from either place, with a count kept in the process as a floor in case a row was lost. Each slot is taken before the first await — a round's tool calls run concurrently, so otherwise every call in it would pass the caps before any counted — and handed back if nothing was drafted. If the rows can't be read it refuses rather than guess.\n2. **Marks the turn** — sets `TurnDelegation.touched_mail` *before* its first read of the mailbox.\n3. **Checks the mailbox** — `gmail_status` asks Google or Microsoft whose mailbox the credential opens and compares it with the person's People email, on every call: a roster email can change, and a client slot swaps the roster.\n4. **Finds the thread** — by `thread_id` (checked against the mailbox's own id shape), or a Gmail-style search (`find`; on Outlook, words, `from:`, `to:`, `cc:`, `subject:` and `newer_than:` are kept and other Gmail operators dropped). Several matches return `{status: \"choose\", candidates}` (subject, sender and date — no message text) and draft nothing; none returns `not_found`.\n5. **Sets the recipients in code**, never from the model. A reply goes to the last inbound message's `From` — never its `Reply-To` (a different one is flagged `reply_to_ignored`) — with the thread's other recipients only on `reply_all`. A new email or a forward may go to any well-formed address: it is only a draft, waiting in their own mailbox, where they see who it is to before they send it. An address that is neither on the roster (contacts only when `contacts_reachable_now()`) nor typed by the speaker this turn comes back in `not_in_people`, and the Executive names it for them to check (`delegation_tools.not_in_people`). Mailing-list mail, a thread they replied to last and a reply-all trimmed to 10 recipients are flagged. An address inside a block an adapter added to their message (the backstory hydrated into a DM) is not one they typed, and when the message carries an attachment — a document's inlined text, or a note naming the file — none of its addresses count as typed: neither has an end mark, and a filename is chosen by whoever sent the file, so such an address is named back to check.\n6. **Writes it** (the ghostwriter, below) and saves it with the mailbox client's `create_draft` (Gmail: threaded with `In-Reply-To`, `References` (whole message ids: when the chain is too long for one header the oldest after the thread's first go, never the parent) and `threadId`, and stamped `X-OE-Ghostwritten`; Outlook: Graph's `createReply` on the message it answers, then the text and recipients, and a named property marking it).\n\nThe result is `{status: \"drafted\", draft_id, gmail_link, to, cc, subject, preview, flags, open_questions, note}`, plus `not_in_people` and `check_address` when a recipient needs checking. The link (`gmail.mailbox_link`) is built server-side from a fixed prefix — the thread in Gmail, the draft itself in Outlook on the web — and the note tells the model the preview is the person's draft, to be treated as data. The chat shows an action chip — \"Drafted an email as you to … — in your Drafts\" — that opens it, and only a link under `MAILBOX_LINK_PREFIXES` is ever linked. A sincere \"are you an AI?\" in the thread comes back as an open question for the person to answer themselves.\n\n## Reading their mailbox\n\nFive read-only mail tools ride with `ghostwrite_email` in the same registry (`orchestrator.mail_read_tools`), so they are offered, re-checked and fenced exactly as it is: `search_my_email` (a Gmail-style search through the client's `search_threads`, or with no query the threads that reached their inbox in the last few days through `inbox_message_ids` + `get_message`), `read_my_email` (one thread's last 10 messages, each sender's new text only, drafts left out, with the files attached to them listed by message id and index), `read_my_email_attachment` (one of those files as text: PDF, Word, Excel, CSV or text, up to 20 MB, a scanned PDF converted) and `my_email_awaiting_reply` (their own sent mail from the last 14 days, to at most 10 people besides the Executive, that is still the last message in its thread). They change, label, draft and send nothing.\n\nThe fifth, `my_email_read_before`, lists the threads `read_my_email` opened for the same person before, in this conversation or an earlier one, so a later conversation can open the same email again instead of asking them to search for it. It keeps where, never what (`delegation.mail_reads`, table `delegation_mail_read`): the thread id, its subject and first sender as one line each, the mailbox address it was read from and when, never a message's text, an attachment or a recipient. Rows are the person's own and are listed only from the mailbox open now, newest first, optionally narrowed by words in the subject or sender; anything older than 30 days is never listed and is deleted on the next write, at most 200 are kept per person, and turning Act as me off deletes them all. It opens the mailbox like the other reads, so it sets `touched_mail`, counts as a search, and returns its rows with the same data-not-instructions note. The Act as me addendum tells the model that these tools reach the person's mailbox while any Gmail or Outlook tools of its own account reach only the Executive's, to search theirs (never falling back to its own) for mail sent to them, and to reopen an email from before with `my_email_read_before` and `read_my_email`.\n\nEach sets `touched_mail` and marks the conversation theirs before its first read (`_open_mailbox`, shared with `ghostwrite_email`), so the lockdown below applies from its round on. Each is capped per turn on the pin: 10 searches (`my_email_awaiting_reply` counts as one), 20 thread reads and 5 attachment reads, the slot taken before the first await. In `read_my_email` every message someone else wrote comes back inside its own `<untrusted_content source=\"email\">` block (`content_trust.wrap_untrusted`, which defuses a closing tag in the text); the speaker's own messages — SENT and from their address (`threads.mine`), never a From header alone — are marked \"Yours\" outside any block. An attachment's text comes back in its own `<untrusted_content source=\"attachment\">` block (`attachments.format_attached_text`), parsed in an isolated worker (`knowledge.loader`); unlike a file sent to the Executive it is never added to the company's knowledge. The clients find an attachment by message and position and look its provider id up on each read (Gmail's changes per fetch): Gmail lists a message's files with the message (`MailMessage.attachments`, leaving out images the HTML shows in place), Outlook says only `hasAttachments` until `list_attachments` asks Graph (leaving out inline ones), and `attachment_bytes` reads one; an attached Outlook item or cloud link has no file to read. Results carry a note that subjects, senders and text are other people's words, data rather than instructions. The lockdown refuses tools, not the reply's own text, so what would carry that text out without a click is closed where it is shown: the web chat loads no image from another site, and bot replies go out without link previews (see Integrations).\n\n## Saving a file from their mail\n\nOne more tool rides with the reads: `save_my_email_attachment` (message id and index, as `read_my_email` listed the file) copies one attached file into the storage the Executive itself has connected and shares it with the speaker alone, so they get a link they can open or put in an app. Every call it makes is built in code (`orchestrator.mail_file_save`); the model picks only the attachment. The bytes come from the mailbox client's `attachment_bytes` and never pass through the model, any file type up to 20 MB, under a cleaned name (one line, no path or reserved characters, extension kept). The storage is the one the Executive's own mailbox runs on (`EMAIL_PROVIDER`) when the gateway has that server, else the other: Google Drive through workspace-mcp (`create_drive_file` with `base64_content` into a folder named \"From your email\" in the Executive's My Drive, then `manage_drive_access` granting the speaker's own address the reader role, `send_notification` off) or OneDrive through ms-365-mcp-server (`upload-file-content` into the same kind of folder in the Executive's own drive, with a name no recorded copy has, since an upload overwrites, then `share-drive-item` inviting only the speaker, `requireSignIn`, role `read`, `sendInvitation` off). The folder is always made by the save itself and its id remembered (`delegation_saved_folder`), never found by its name, since a folder someone else made and called that could already be shared with them; when the remembered one is gone or won't take the file, a new one is made and the old id stays recorded. Never a link share, a domain or anyone. Neither connected (or an eval's in-memory mailbox): status `no_storage`, and the model says so and offers to forward the email instead. Saves run one at a time, at most 10 a turn (`TurnDelegation.files_saved`), and the result is the status, the name, where it went and the link (`webViewLink` / `webUrl`); the chat chip says only that a file was saved, never the sender's file name.\n\nIt copies only when the speaker asked in their own words this turn: what they typed (`own_words`, no quoted backstory or attached file's text) must hold one of save, saved, upload or OneDrive, or Drive as a place (\"to my Drive\", \"in Drive\", \"Google Drive\"), checked before a slot is spent or the mailbox opened; otherwise it refuses (`not_asked`) and tells the model to ask them. It stays allowed after the turn read mail (`MAIL_TOUCHED_ALLOWED_TOOLS`): its gateway calls are admitted past the lockdown only as the very objects the handler built (`mcp_gateway.code_built_call`, for its seven Drive and OneDrive tools: folder create, file create or upload, the speaker's share, and OneDrive's `list-drives`), so a model's own `call_tool` on that turn is still refused, and every other gateway gate still runs on them (the acting account, URL fetches, sheet formulas, the share gates' roster check, writes kept to the Executive's own drives).\n\nEach copy is recorded before it is shared (`delegation.saved_files`, table `delegation_saved_files`: the person, the storage, the file id, its name and when; never content or the mail it came from), and the folder in `delegation_saved_folder`. The gateway reads that table on every Google Workspace and Microsoft 365 call: on a turn whose speaker is not the file's owner (the owner is the speaker only when Act as me was offered to them, so a shared chat, a workflow or the poller sees none), a call naming a recorded file id, raw or percent-encoded (OneDrive's `download-bytes` path is decoded by Graph), is refused, and a result, filtered against the table as it stands after the call so a copy recorded while a listing ran is caught too, loses each list entry or line naming one, with any id left masked. It matches ids as text, so a result that names such a file without its id (a notification quoting its title) still shows the name, and a copy someone makes is a new file. The folders are guarded harder, on every turn and for every speaker, the owner too: a model call whose arguments name any recorded folder id, or an OneDrive item path through the folder (`root:/From your email/x.pdf:` or `<folder id>:/x.pdf:`), is refused, so nobody can share, move, rename, copy, list or delete the folder from chat, and folder ids are dropped from or masked in every result; only the save's own code-built calls touch it. When a copy is made but its row can't be written, it is not shared, the save reports `failed` and logs an error, and the copy's id is hidden from every turn, the owner's included, for the life of the process. When the table can't be read, the file tools (`_FILE_TOOL_RE`: Drive, folder, file, Docs, Sheets, Slides and presentation tools, attachment bytes) are refused (fail closed) while mail and calendar run. The rows are kept when Act as me is turned off: the copies stay in the Executive's storage, and the rows keep them out of other people's turns.\n\n## Reading their calendar\n\nA third switch under Act as me, **Read my calendar** (`delegation.calendar`, table `delegation_calendar`: one row per person, absent or unreadable meaning off), lets the Executive read the person's own calendar, read-only. It rides on the same per-person sign-in as their mailbox: `calendar.readonly` on Google, `Calendars.Read` on Microsoft, added when they run the connect script with `--calendar` (`scripts/connect-own-gmail.py`, `scripts/connect-own-outlook.py`). Those scopes are optional, so a mail-only sign-in keeps working for mail; the mailbox clients note the scopes the token refresh reports, and `list_events` raises `CalendarNotGranted` before calling the calendar when the scope is missing (or when the calendar answers 403). Only the person turns it on (`PUT /delegation/calendar`), only while Act as me is on and a one-hour read works; a sign-in without the calendar is refused with `calendar_not_granted` and the command to run. Turning Act as me off turns it off. Changes are audited privately (`delegation_calendar_changed`).\n\n`my_calendar` sits with the mailbox reads, offered and fenced the same way: it refuses while the switch is off (before anything is opened), then takes a search slot, opens the mailbox privately (`_open_mailbox`, so `touched_mail` and the lockdown apply: an invite's title is in the words of whoever sent it) and lists the events from `start` (default today) for `days` days (1 to 31) in the workspace time zone, recurring events expanded and cancelled ones left out: title, start, end, all-day, location, organizer, attendees (25 at most) and the person's own answer, each on one line, with a data-not-instructions note. Google's `events.list` on the primary calendar and Graph's `calendarView` (times asked for in UTC) are its only calls; it changes nothing and keeps nothing. The first week's brief also lists today's meetings from it on the principal's own delivery (see Today).\n\n## Forwarding and reminders\n\n`ghostwrite_email` also forwards: with `forward` (a thread id) and `to`, it drafts a forward of the thread's latest message, or of the earlier one `forward_message_id` names (the one with the files, say, when their own reply came after it), `intent` becoming the short note above it (the ghostwriter writes only the note; the forwarded email's subject, someone else's words, is never put in the intent). Recipients follow the new-email rule (`_new_recipients`: the roster, or addresses the speaker typed this turn). Gmail's draft quotes a forward header and the original's own words under the note and attaches the original's files, up to 10 and 20 MB (`FORWARD_MAX_FILES`, `FORWARD_MAX_BYTES`; any left off are flagged `attachments_left_off`); Outlook uses Graph's `createForward`, which keeps the original and its files, with the note as its comment and the body never patched. It is still only a draft.\n\n`remind_me(text, when)` (`orchestrator.reminder_tools`) rides with the same tools and checks, but opens no mailbox, so it never marks or locks a turn (`MAILBOX_TOOL_NAMES` are the ones that do). It stores the text once cleaned — one line, anything a chat app could turn into a link (a URL of any scheme, an address, a domain-like word, a host and port, an IP address) replaced with \"[link]\", at most 300 characters — with its time (stored in UTC) in `delegation_reminders` (5 a turn, 25 waiting, a year ahead, refused when the person has no channel). When it is due the scheduler sends that text to the person alone, as \"Reminder you set on <date>: …\", running nothing (see Scheduler); the Slack and Discord DMs it may go by turn link previews off. The chat chip shows the text as it will be sent. A reminder that comes due in the person's quiet hours or leave (when `OUTBOUND_RESPECT_QUIET_HOURS` is on) waits unclaimed and goes once they end, rather than being suppressed and lost. It is allowed after mail is read and in later turns of that conversation: it reaches only the speaker, as plain text. `schedule_followup`, which runs a turn with tools and is listed to everyone, stays refused there.\n\n## Approval cards\n\nA turn that read someone's mail may not message anyone, invite anyone or change the roster (see the lockdown above), yet what the mail asks for is often right. `propose_actions` (`orchestrator.action_card_tools`) leaves the speaker a card instead: up to five actions, each spelled out exactly as it will happen, done only when they tap Approve. It rides with the other Act as me tools and checks (`_writer`), opens no mailbox, and is allowed after mail is read because it does nothing on the turn.\n\n- **Kinds.** `invite` (a meeting with people on the roster), `message` (a direct message to someone on the roster, as written) and `add_contact` (a new contact; the principal's cards only, since contacts are theirs). A team member's card can't name a contact. Each action is checked when the card is made (`delegation.action_cards.check`) and again when it is carried out, so an archived person or a time that has passed fails that action alone.\n- **Whose.** A card is a `delegation_actions` decision for the speaker, `approver_only` like a reply card: only they see it (`GET /delegation/actions`) or resolve it, a team member's answers 404 to the principal too, and it is never an alert. The same actions still waiting are that card, not a new one. 3 cards a turn, 25 waiting, dropped after 7 days.\n- **Approve.** In the chat, under the reply that left it (the `propose_actions` chip carries the card's `decision_id`, and `ChatActionCards` shows the card while it waits), and on the Briefing's Needs you list, with a box per action. Approve (`POST /decisions/{id}/approve`, `edits.only`) needs the card's person signed in (`verified.caller_refusal`) with Act as me on; the card is claimed first so it runs once, then each ticked action runs as stored with no model call, in an unattended session (the principal's with contact egress) under `rows_for_person`, so every audit row it writes is theirs and nothing reaches the team's activity rail: `message_person` (a direct message or nothing; never its Briefing-alert fallback, which more people read), `create_calendar_event`, or a contact row. Approving also needs the person still allowed Act as me (`can_delegate`) and switched on. An invite is booked straight away when the person approving is the one the meeting gate would ask (`calendar_tools.approved_by`), and otherwise goes to that approver as usual, so a card never widens anyone's authority. Per-action results (`done`, `waiting`, `failed`, `skipped`) are kept on the decision and shown on the card. Dismiss rejects it and does nothing else. With Suggested actions in training the card adds Approve + allow, and a card of actions all allowed is carried out on its own (see In training above).\n- **Channels.** A card can come from any surface Act as me runs on; it is approved in the web app, since the chat apps have no buttons here.\n\n## The ghostwriter\n\n`delegation.ghostwriter.compose` writes the text. The Executive decides *what* to say (`intent`); this call decides *how* the person would say it, and it is deliberately small:\n\n- a constant `GHOSTWRITER_PROMPT` plus the person's voice block as the system prompt;\n- the thread (each message cut to its sender's own words, every line scrubbed, all labelled alike), then the writer's own earlier words in it (`<writer_said>`, from their sent mail only), the intent and the recipients' names in the user turn — no company profile, memory or roster;\n- with Always in the loop on, `<writer_noted>`: what the writer's own notes say they told these same people in earlier Act as me replies (`memory.history_drafts.notes_for_draft`: only notes from mail **every** recipient of the new draft was on, so nothing told to one person reaches another; chat notes name no recipient and never qualify; at most 8, newest first, the person's own words or their correction, with dates). The prompt's rule 6 makes it a consistency check, never content: a draft that contradicts it is still written as the intent says, and the conflict becomes an open question on the card, which only the writer sees. Both the chat tool and the inbox watcher pass it;\n- **no tools** but the forced `compose_reply` return, so text in the thread can ask for anything and there is nothing to do it with.\n\nIt is not a Council agent — the Council's edit routes have no principal check — and runs on `DELEGATION_COMPOSER_MODEL` (default: the default model), logged as `ghostwriter` usage. `lint` then runs in code on what comes back: a link or an email address survives only if it appears in the intent, the signature or the recipients, so a link planted in the thread is removed and flagged; the Executive's own name is flagged; and the body is capped, cut at a paragraph, line or word break in its last fifth. A draft with nothing left after that is refused. The signature from the person's Gmail settings (or the one already stored, for Outlook) is appended.\n\n## How I write\n\n`delegation.voice` learns how a person writes *their own* email (`attunement.style` learns how the Executive should write *to* someone). `POST /delegation/voice/learn` reads up to 40 recent sent messages, keeps only what they wrote (quoted replies stripped with the email poller's `sender_new_text`), skips automatic mail, every thread chat drafted into, and every sent message that began as a draft written for them (`delegation_drafts.sent_message_id`), and makes one forced-tool call (`record_voice_profile`). Code validates every field before it is stored:\n\n- greetings per audience (their team, their contacts, anyone else), a sign-off of at most two lines, and a usual length and tone (a backslash-n the model wrote instead of a line break is read as one, keeping the first lines that fit, which also repairs a profile stored before that rule);\n- up to 8 habits and 6 things to avoid, through the same deny-list as working-style rules — no actions, links, handles, amounts, tool names or names of people; the conversation review (`memory.chat_review`) adds one when the person states how they write in a chat (`add_conversation_rule`, `updated_by=conversation`; never on a locked or full list, and an edit or lock made meanwhile wins);\n- up to 3 short exemplars, each checked to be verbatim from a sample, with addresses and phone numbers masked — and none while a client slot is active, so one client's mail never lands in another's state.\n\nThe signature comes from Gmail's `sendAs` settings, not the model (Outlook gives apps no way to read one, so a learn keeps the stored signature and `POST /delegation/voice/signature` answers 409 `signature_unavailable` rather than clearing it), as plain text with its lines kept (`gmail.html_to_text`: a `<br>` always ends a line, and a block tag, opening or closing, ends one when it has text, so Gmail's layout of a first line followed by one `<div>` per line comes out line by line). `POST /delegation/voice/signature` reads it again without relearning: nothing else changes and a locked profile stays locked, so it picks up a changed Gmail signature and undoes **Don't add my signature**. A person can also describe their style in their own words: `POST /delegation/voice/describe` applies the description to the profile they have through the same forced tool (a separate system prompt, no exemplars) and the same validation, keeps their signature and writing examples, and returns the result with a short sample reply for them to review. It saves nothing and needs no mailbox; Save stores it as an ordinary edit. The person can edit the profile, lock it (a locked profile is never relearned) and reset it, and every change is kept in `delegation_voice_history`. One learn runs at a time per person, and a lock or an edit made while it runs wins: the learned profile is dropped (`changed`).\n\n## Draft replies to my inbox\n\nA second switch under Act as me, **Draft replies to my inbox** (`delegation.inbox`), has the Executive watch the person's own inbox and write a first reply to mail that needs them. The reply waits on a private card on Today; nothing is sent until they tap **Send** (below). Where the reply lives is the person's choice, **Also save replies in my Gmail Drafts** (`mailbox_drafts`, off by default): off, it lives on the card alone (`delegation.card_drafts`: the card keeps the draft's recipients, subject and thread headers as `draft_spec`, and Send makes the mailbox draft from exactly that just before the send-time checks, taking it back out if they refuse), so their Drafts folder doesn't fill with replies they may never send; on, it is also saved in their Drafts as before. The switch is one row per person in `delegation_inbox_watch`. Turning it on needs Act as me on and their mailbox connected, and sets `watch_since` to now every time, so it never drafts for mail that arrived before; turning Act as me off turns it off too. Off means no mailbox call and no row written, with one exception: a send the person started that the mailbox never confirmed is still followed through until it is settled.\n\n### When it looks\n\nA throttled hook in the scheduler tick (`_maybe_scan_inbox`, after the pause, company-profile and rotation gates) checks each person whose switch is on every `DELEGATION_INBOX_POLL_MINUTES` (default 5). It is not a scheduled action, because those are listed on `/scheduled` for everyone and anyone may cancel them. One scan task runs at a time, one scan per person, and none while a client slot is active. **Check now** on the Settings card runs the same scan. Every row a scan writes is private and the person's own (`audit.rows_for_person`: a team member's rows are hidden from the principal too, see Privacy), and the process log carries counts and codes, never an address or a line of mail. The scan never marks mail read or changes a label.\n\n### What it drafts for\n\nA scan first settles the open cards (below), and stops with `backlog_full` once 25 are waiting, counting the ones it makes. It then lists the inbox since `watch_since` (`inbox_message_ids`) — not chats, not mail from the person, and not the promotions, social, updates or forums tabs (on Outlook: the Focused inbox only) — up to 100 messages, and takes the newest message of each thread that still needs a look, at most 10: settled threads and threads with an open card are passed over first, so a burst of mail, or a pause for a limit or a back-off, never hides older threads for good. `delegation_inbox_messages` is its durable cursor: one row per message (`UNIQUE(person_id, message_id)`) with what happened to it, the reason, how many tries it took, and the draft and card ids. It stores a hash of the sender's address, never the address. A message is skipped, with the reason recorded, when:\n\n- it came before `watch_since`, or more than three days ago;\n- it is from the person or one of their send-as addresses, from the Executive, or one of this module's own drafts;\n- it is automatic — `Auto-Submitted`, a bulk or auto-reply `Precedence`, a bounce, a calendar invite or a no-reply sender — or from a mailing list, or in a Gmail tab, spam or trash;\n- the person is not in To or Cc, or it has more than 10 recipients;\n- the person replied last, or a draft already sits in the thread.\n\nThree kinds are left unrecorded, so a later scan looks again: mail under 10 minutes old (mail the person answers straight away never gets a card), mail in a thread whose card is still open, and mail a daily limit holds back.\n\n### Deciding, then writing\n\nTwo model calls, and code decides between them. The classifier (`delegation.inbox_classifier`) is one forced-tool call, `classify_email`, returning whether the email needs a personal reply, what kind it is and how sure it is. It sees a few one-lined header lines and the sender's own new words (at most 3000 characters, every line scrubbed) inside one `<email>` block marked as data, and it has no other tools, context or memory, so an email can ask for anything and there is nothing to do it with. A reply is drafted only for a question, a request, scheduling, an introduction or a follow-up, and only when the confidence clears a bar that rises the less the sender is known: 0.6 for their team or a contact (the principal's contacts count only for the principal: a team member's mail is weighed by the team and their own sent mail), 0.7 for someone they have written to before (`has_written_to`, a search of their sent mail), 0.85 for a stranger. Pitches, notes of thanks, FYIs, notifications, newsletters and phishing get nothing, and so does any failure. An email that also went to other people is drafted for only when the person is in To and it asks them themselves: the classifier is told their name, whether they are in To or Cc and how many others it went to, and lists the names the email greets or asks by name (`asked_names`). Code matches those against the person's name, whole name parts only (\"Alexis\" never counts for \"Alex\", and a nickname misses, which means no draft), so mail that greets someone else (\"Good morning, Brennan, could you sign ...\") is never theirs, whatever the model makes of it as a whole. When it names nobody, the model's `asked_of_them` decides, false for a question to the group at large. One that only copies them is never drafted for. Either is recorded `not_needed` with the reason `asks_someone_else`. It runs on `DELEGATION_CLASSIFIER_MODEL`, else the routing model. A sender whose address Gmail couldn't authenticate is handled as a stranger whatever the roster says — anyone can put a colleague's or a client's address in From — so they get the stranger's bar, a holding reply and the stranger limits; the card still says who they claim to be, and that the address isn't verified.\n\nThe reply is written by the same ghostwriter, in the person's voice, but from a fixed intent the module builds rather than words the person typed. Because the intent lets it restate the person's own earlier words, which words are theirs is never written inside the thread, where a sender could imitate any marker with a look-alike: every message there is labelled alike, and the person's own words come in a separate `<writer_said>` block after the thread, taken only from mail their own mailbox sent. Nothing inside the thread can close the thread block or open another. The intent: acknowledge the sender; say again only what the person's *own* earlier messages in the thread already said; commit to nothing new — no yes or no, date, time, price, fact or promise — and say they will get back to them; and put every question it could not answer from their words in **open questions**. A stranger always gets a short holding reply. The lint still strips any link or address that isn't the person's own. The reply goes to the sender (never `Reply-To`) and, on a group email, to everyone else it went to as Cc (reply to all, never the person's own addresses or the Executive); a stranger's holding reply goes to the sender alone. The card says when others were on the email, and its `draft_to` lists everyone, which Send checks.\n\nThe order: record the message, classify, reserve a slot in the shared daily limit, write, save the draft in Gmail (from the alias the mail went to, when it went to one) and store its id, then create the card (idempotent on the message) and mark it drafted. Nothing that fails along the way loses the message. A failure that may pass — the classifier or the writer failing, Gmail refusing the draft, a card that couldn't be made (its draft is deleted first, so no draft is left without a card), any other error with that one message — leaves it for a later scan (`retry`), and it is given up on only after three tries; one message's trouble never holds up the rest. A daily limit reached while it was being read leaves it for later without counting as a try.\n\n### The reply cards\n\nA card is a `delegation_reply` decision whose class is **its approver's alone** (`DecisionClassSpec.approver_only`): only the person it was drafted for sees or resolves it on any decisions route — a team member's card answers 404 to the principal too — and it is never an alert: alerts feed chat turns, which would put other people's mail into memory. It carries the sender with who they are to the person and whether Gmail could verify the address (SPF/DKIM/DMARC, through `fact_confirmation.headers_authenticated`), the subject, what they wrote, the draft, the open questions and its warnings. `GET /delegation/replies` lists the open ones from the database alone, so Today never waits on Google.\n\n- **Send** approves the card, which sends its draft exactly as it is in their mailbox (see *Send on your tap*). **Edit** changes the reply's words right on the card (`PUT /delegation/replies/{id}/text`, `card_drafts.edit`): only its own person, from a caller the API can tie to them (as for Send), never while it is being sent on its own; a reply in their Drafts is rewritten there too (`update_draft_text`, every header kept), and only while it is still the version the card last saw, so a change made in the mailbox is never overwritten. A card edit counts as edited (`approved_with_edit`, and **Do it like this next time** keeps it). **Open in Gmail** (or **Open in Outlook**), shown only when the reply is in their Drafts, opens it there.\n- **Dismiss** rejects the card; the class's after-reject step then deletes the draft if nobody edited it — its message id is still the one it was saved with, since Gmail gives an edited draft a new one, and the Outlook client makes a draft's message id `<id>.<changeKey>` so an edit there changes it too — and keeps it otherwise. What happened is recorded even when Gmail fails.\n- Each scan first **settles** what Gmail already settled: a draft sent from Gmail, a draft deleted there, a reply the person wrote themselves, a thread that is gone, or a card left for 7 days (its draft stays in Gmail). Each is a compare-and-set close with the reason. A newer message from someone else flags the card instead. A card being sent at that moment is left alone.\n\n### Send on your tap\n\n`delegation.reply_send` is the only thing in Act as me that sends, and all it can send is the draft on a card, by its id: `DelegateGmail.send_draft` posts `{\"id\": …}` to Gmail's `drafts.send`, and `DelegateOutlook.send_draft` posts an empty body to that draft's Graph `send`, and nothing else, so no text, recipient or header is ever passed. It has two doors: `send_approved_reply`, reached only from `POST /decisions/{id}/approve` — a class only the card's own person may resolve — and `send_on_its_own`, reached only from the inbox watcher under Handle it for me (below). AST tests pin both call sites, so no model, chat turn, workflow, scheduled job or MCP call can. A tap is checked like this: At send time it checks everything again:\n\n1. **Who is asking.** The caller is the card's person and the API knows it: signed callers are on and the request carries that person's signed assertion (or the operator's, under local login), or the API runs for local login and answers this computer only. Anything else is a 409 `caller_signing_required` — with only the shared secret, whoever holds it could send as the owner — so on a server Send needs signed sign-ins.\n2. **The switches.** Act as me and Draft replies to my inbox are on, and no client slot is active.\n3. **The mailbox.** Their mailbox is connected.\n4. **The draft.** It still exists, in the same thread, and they haven't replied there themselves since; otherwise the card closes.\n5. **Who it goes to.** To, Cc and Bcc hold between 1 and 10 addresses, never the Executive's own, and it is from one of their own addresses.\n6. **What changed.** Recipients that differ from the card's, or a newer message from someone else, need a second yes: the first tap gets a 409 `confirm` naming the recipients and the reason, and the person approves again with what they were shown.\n\nThen it claims the card (`claim_for_execution`, proposed → executing, a compare-and-set, so a double tap sends once) and reads the draft once more: `drafts.send` sends whatever the draft is when Gmail gets the request, so if it was edited since the checks read it — in another tab, by a delegate — nothing is sent and the card comes back (`draft_changed`). Then it sends, and records the result: `approved_with_edit` when the draft was edited in Gmail, the sent message's id, the draft row's `sent_message_id`, and a private `delegation_reply_sent` row. A refusal that proves nothing went — a 4xx, a lapsed sign-in, a rate limit, a draft already gone — hands the card back. A failure that leaves it unclear — a timeout, a 5xx — leaves it `executing` and says to check the Sent folder, and the next scans ask Gmail: their message in the thread means it was sent; anything else is judged on the second scan that sees it: the draft still there and nothing sent means it was not (Gmail deletes a draft it sends), and the card comes back, flagged; the draft gone and nothing sent means it was deleted. Nothing is ever retried on its own. Sending is the person's own act, so it works while the Executive is paused.\n\n### Limits and failures\n\nAt most 5 drafts a scan; `DELEGATION_INBOX_MAX_DRAFTS_PER_DAY` (default 20) a day, inside the shared `DELEGATION_MAX_DRAFTS_PER_DAY` it shares with chat; 200 classifications, 2 drafts per sender (1 for a stranger) and 10 for strangers in all per day; and never more than 25 open cards. A lapsed Gmail sign-in sets the status and is looked at again every 30 minutes; a rate limit, an error reaching Gmail or a crash backs off from 5 minutes, doubling up to 2 hours. Neither turns the switch off: the Settings card shows the status in plain words.\n\n## Handle it for me\n\nA third switch under Act as me, **Handle it for me** (`delegation.handle_it`), lets the inbox watcher send some of its replies itself instead of leaving them on a card. It is one row per person in `delegation_handle_it` (`enabled`, `mode`); no row means off. One setting says how much goes without them, the way quality does on the Agent Council (`handle_it.RULES`): **Easy ones** (`careful`) sends only replies to people they know (someone on their team, a contact or someone they have written to) of at most 400 characters when the classifier is at least 0.9 sure; **People I know** (`balanced`), where it starts, sends replies to people they know up to 1200 characters at 0.8; **Most mail** (`bold`) also answers strangers, up to 2000 characters, and lets a link or an amount through when the classifier is at least 0.9 sure. Everything else waits on a card as before, so turning it on never drafts less. A table from before the setting gets the `mode` column on its next open (`schema._add_handle_it_mode`): someone who had strangers set to send keeps that as Bold, everyone else gets Balanced. Only the person turns it on (`PUT /delegation/handle-it`), from a session the API knows is theirs: the same rule Send uses (`delegation.verified.caller_refusal`), so with only the shared secret it answers 409 `caller_signing_required`. Turning it on needs Act as me and Draft replies to my inbox on, and turning the inbox watcher off (or Act as me, which turns it off) turns it off too.\n\n**In training** (`delegation.training`). Like someone new, each Act as me job can be put in training on its own, from that job's card on the Act as me page, the way Take the lead has it: **Write drafts as me** and **Handle it for me** each pick Off / In training / On (Handle it's In training is Replies in training, with a *Train follow-ups too* box for Follow-ups), and **Suggested actions** picks Always ask / In training; what it learned is listed on each tab for its own jobs (Act as me: *What it's learned*, drafts and suggested actions; Handle it for me: *Who it's allowed to handle*, replies and follow-ups), each item named by its job (`PUT /delegation/training`, one row per person and setting in `delegation_training`, absent means not in training). In training it asks first and learns who and how from what the person approves; what it learns is a `take_the_lead_allowed` row (feature `act_as_me`, the person's id), theirs alone.\n\n- **Replies.** Every reply waits on its card (`handle_it_reason` `training`) whatever the dial says, and a reply card adds **Send + allow**: it sends that reply on the person's own tap, exactly as Send does, then allows replies to that sender (key `act_as_me|person:<id>|reply|<address>`). While Handle it for me is on, a reply to an allowed sender goes on its own under the dial's limits (a stranger they allowed included) and every check above (the topics that always wait, links and amounts, new recipients, once a thread a day, the daily limit); it's checked again at send time, so a sender removed since waits. Take the lead as you lifts nothing in training: putting Replies or Follow-ups in training turns it off, and it can't be turned on while they are (409 `in_training`).\n- **Follow-ups.** Every follow-up waits (`follow_up_training`); Send + allow on a follow-up card allows follow-ups to exactly the people it went to (`…|follow_up|<sorted addresses>`), whoever they are, under every other follow-up check.\n- **Suggested actions.** An action card (below) adds **Approve + allow**: it does the actions on the tap, then allows each one that happened (a message to that person, `…|message|person:<id>`; a meeting with exactly those people, the person left out, `…|invite|people:<ids>`). A new contact is never allowed. A card proposed later whose every action is allowed is carried out at once, with no tap (`action_cards.run_on_its_own`, `gate_mode` `auto_execute`, status `executed`), only if plain code finds nothing against it (`on_its_own_refusal`): still in training, Act as me on, a server that ties the switch to the person, nothing sensitive, no link or amount, a message of at most 1200 characters, and at most 10 actions carried out this way a day (checked one card at a time); anything refused is handed back to wait on its card as before. An invite carried out this way is never booked as approved by the person: the meeting gate decides as for any meeting nobody tapped, so a time taken from someone's mail can't land on a calendar unasked. The tool result and chip say what was done. The message text in such an action is model-written from the mail and goes without anyone reading it; the allowance covers who and what kind, not the words, which is why sensitive topics, links, amounts and long messages are held back.\n- **Drafts.** Nothing is sent. When the person changes a reply's draft in their mailbox before tapping Send (plain or + allow) and ticks **Do it like this next time**, what they sent is kept (its new text, quoted replies dropped, at most 1000 characters, `…|style|<address>`), and the ghostwriter gets it in its user turn as `<writer_example>` when it next writes to that person, from the inbox, a follow-up or a chat draft to that one person: style only, never its facts, and nothing in it can open or close a tag.\n\nSend + allow and Approve + allow are refused before anything is done unless their setting is in training (422 `cant_allow`) and the person's list has room (409 `learned_full`, at most 200 a person); allowing failing afterwards never undoes the send. Putting Replies or Follow-ups in, or Suggested actions out, of training only holds more back and works without signed sign-ins; anything else needs a caller the API knows is that person. What it learned is the person's alone: listed on `GET /delegation` (`training.learned`, each with its `setting`), removed with `DELETE /delegation/learned/{id}`, and for the owner also in Take the lead's \"What it's learned\" list; it never reaches anyone else's list or Take the lead's prompts. A dial left on In training by an older version (mode `training`) moves to People I know with Replies and Follow-ups in training (`schema._move_training_off_the_dial`).\n\n**No model decides whether a reply goes.** The watcher's two model calls are unchanged and tool-less, so text in an email can at most change the verdict and the draft. After the draft is written, `handle_it.refusal` — plain code — decides, and anything it refuses becomes the usual card with the reason kept on it (`handle_it_reason`). It refuses when:\n\n- it's off, or the sender is a stranger and the setting isn't Bold, or on a server signed sign-ins are off (`signing_ok`: signed callers, or local login);\n- Gmail couldn't authenticate the sender, whatever the roster says;\n- the email isn't a question, request, scheduling, introduction or follow-up, or the classifier was less sure than the setting needs (0.9 on Easy ones, 0.8 otherwise);\n- the reply goes to anyone the email didn't already go to (its From, To and Cc, less the person's own and the Executive's addresses), leaves out the sender, or goes to more than 10;\n- the email's subject, the sender's new words, or the reply touch money, contracts, legal, hiring, pay, layoffs, the board, investors, mergers, the press, health, or credentials and secrets (passwords, logins, tokens, API keys); or the reply carries an amount, a percentage or a link (a scheme, `www.`, a bare host with a path such as `bit.ly/…`, or a bare host on a common top-level domain) unless it's Bold and at least 0.9 sure, or runs over the setting's length (400, 1200 or 2000 characters);\n- the draft carries any flag but *others on the thread* or *Executive on the thread* (they asked if it's an AI, recipients were trimmed, …);\n- it already sent one in this thread in the last day, or the person's last message in the thread was itself sent on its own (no auto-reply ping-pong);\n- the day's limit is reached (`DELEGATION_HANDLE_IT_MAX_SENDS_PER_DAY`, default 20, within the watcher's drafts limit), or it can't be counted. Any error in the rules counts as a refusal.\n\nA reply the rules allow gets a card with `gate_mode` `auto_execute`, and the watcher sends it at once through `reply_send.send_on_its_own`, the second and last door into the send path (an AST test pins both callers: the approve route and the watcher). It runs the same send-time checks as a tap — switches, mailbox, draft, recipients, the claim and the last re-read — with no caller, and adds its own: the card must be `auto_execute`, Handle it for me still on with the setting still allowing that sender (or, for a follow-up, that recipient), signing still on, the once-a-thread-a-day rule and the daily limit counted again, and the draft untouched since it was saved (an edit in Gmail means the person has taken it over: `draft_changed`, the card waits for them). Every refusal hands the card back to the person (`decision_ledger.hand_back`, a compare-and-set to `propose`), with the reason kept on it when there are words for it, and a failure never stops the scan. Every card it left for the person says why on Today (`waited_because` on `GET /delegation/replies`). A reply sent on its own finishes as `executed` (not approved), is recorded in `delegation_handled` (for the per-thread and daily rules) and writes a private `delegation_reply_handled` row; an unconfirmed one is settled by the reconciler the same way. No History note is taken from it, since notes come only from the person's own words. It runs inside the watcher's scan, so it stops while the Executive is paused.\n\n**Follow-ups as you** (`delegation.follow_ups`). While Handle it for me is on, the watcher's scan also looks at the person's own sent mail, at most once an hour (`LOOK_EVERY`), for an email of theirs that asked something (a question mark in their own words), is 3 to 10 days old, went to at most 10 people other than the Executive, and is still the last message in its thread. Plain code picks it; each gets one follow-up ever (its `delegation_inbox_messages` row), at most two a look, within the drafts limit. The ghostwriter, tool-less as always, writes a short nudge in their voice from the thread, saved as a draft in that thread to exactly the people the email went to. `handle_it.follow_up_refusal` — plain code — decides whether it goes: by the setting it never goes on Easy ones, goes to their team and contacts on People I know and to anyone they wrote to on Most mail (`follow_up_refused` otherwise: `follow_up_level`); it also refuses on any change of recipients, a sensitive topic, an amount or a link, more than 600 characters, a flag, and the same per-thread and daily counts as replies. It goes through `send_on_its_own` on an ordinary `delegation_reply` card marked `source: follow_up`, which rechecks the setting for that recipient. A refused one waits on Today as **Follow-up waiting**, and closes by itself (its untouched draft deleted) when anyone answers in the thread first.\n\n**What it sent** is the person's alone: `GET /delegation/handled` lists the last 7 days (who, subject, the reply, the questions it left them and a link to the thread in their mailbox), and the Handle it for me tab shows it with how many went today, under its picker.\n\n### Take the lead as you\n\nOn Settings → Act as me, Handle it for me is one dial: **Off**, **Easy ones**, **People I know**, **Most mail** and, for the owner, **Everything**, which uses **Take the lead** (`PUT /delegation/take-the-lead`, one row `person:<id>` in `take_the_lead`; turning it on turns Handle it for me on). While it is on, `handle_it.refusal` drops the setting's limits: strangers, the classifier's confidence, amounts, and the length up to a 4000-character ceiling. A reply with a link still waits for a tap (refusal `link`). In their place it checks the company's and the person's own added rules (`take_the_lead.reply_hit`, refusal `lead_rule`). Everything Handle it always keeps still holds: signed sign-ins, an authenticated sender, a reply kind, exactly the thread's people, the topics that always wait, draft flags, never twice in a row, one a thread a day and the daily limit. Follow-ups under it may go to anyone the person wrote to, with the same sensitive, amount, link and length checks plus the added rules. `reply_send.send_on_its_own` accepts the card while both switches are on. Each person adds and removes their own rules (`/delegation/take-the-lead/rules`). Removing one needs a caller the API can tie to them.\n\n\n## AI line on replies\n\nReplies written as a person can end with **\"Drafted and sent by my AI assistant.\"** (`delegation.disclosure.LINE`), by two switches that are each person's own (`PUT /delegation/disclosure`, one row per person in `delegation_disclosure`, NULL following the install): **Handle it**, on by default (`AI_DISCLOSURE_HANDLE_IT`), for a reply Handle it for me will send on its own, which nobody reads before it goes; and **Approved sends**, off by default (`AI_DISCLOSURE_APPROVED_SENDS`), for one that waits on a card for them to send, since they read it first. The line is written into the reply when it is drafted (`disclosure.sign`, in `inbox._consider` and `follow_ups`), once the plain-code checks have decided whether it goes on its own, so the card, the mailbox draft and what is sent are the same words and Send's draft-changed checks see them; a switch changed later applies to the next reply, and a reply drafted to go on its own that is handed back keeps its line for the person to edit. `AI_DISCLOSURE` off turns both off and hides the card. Turning a switch on only adds the line, so it needs no signed sign-in; turning one off does. Each tab shows its own switch under Advanced (**AI line on drafts you send** on Act as me, **AI line on replies it sends** on Handle it for me), and turning off the Handle it line asks first.\n\n## The mailbox client\n\n`delegation.gmail.DelegateGmail` talks to the Gmail REST API directly and is **never registered with the MCP gateway**, so the model reaches the mailbox only through the typed handler. The credential is one file per person in `DELEGATION_GOOGLE_CREDENTIALS_DIR`, named from a hash of the address (0600 in a 0700 directory), minted by `scripts/connect-own-gmail.py` on the Executive's own OAuth client with the scopes `gmail.readonly` and `gmail.compose`. It never lives in `WORKSPACE_MCP_CREDENTIALS_DIR`, where workspace-mcp picks a credential by address. Besides reading threads and saving drafts it lists the inbox and checks whether they have written to an address, reads one message or draft, lists the person's send-as addresses and deletes a draft. Its **one send method**, `send_draft`, sends an existing draft by its id and nothing else — never `messages.send`, which sends any text it is given — and unit tests pin the method set, the endpoint, the request body and its single caller. A failed request says whether it may have been carried out anyway (a timeout after connecting, a 5xx), which is what the send path needs to know. A parsed message carries when it arrived, whether it is bulk, a bounce or a calendar invite, and whether Gmail's authentication results vouch for its sender.\n\n`gmail_status` answers `connected`, `not_configured`, `needs_reconnect` (Google refused the saved sign-in — an app in Testing mode has its tokens expire after 7 days; a rate limit, though Gmail may send it as a 403, is an `error` to retry, not a reconnect), `mismatch`, `no_email`, `shared_mailbox` or `error`. `shared_mailbox` means the person's address *is* the Executive's; it is refused before asking Google, because then everything the Executive writes would look like theirs. The gateway closes the other door: every `google_workspace__*` call must act as the Executive's own account, and a `user_google_email` naming anyone else is refused and audited (see Integrations).\n\n### Outlook\n\nA person may connect an Outlook mailbox instead (work, school or personal), with `scripts/connect-own-outlook.py`: a device-code sign-in on the Executive's own Entra app (`MS365_MCP_CLIENT_ID`, tenant `MS365_MCP_TENANT_ID` or `common`) asking for `User.Read`, `Mail.ReadWrite`, `Mail.Send` and `offline_access`. It writes the same per-person file with `\"provider\": \"microsoft\"`, so a person has one mailbox for Act as me, and `gmail_for` hands back `delegation.outlook.DelegateOutlook`, which keeps `DelegateGmail`'s methods, return types and errors, so every caller above runs unchanged. It talks to Microsoft Graph directly, never through the Microsoft 365 MCP server the Executive's own Outlook uses, and is never registered with the gateway. Microsoft rotates the refresh token on use; the new one is written back into the file (atomically, keeping every other key, and only if the file still holds the old one). Graph is asked for immutable ids, so a sent draft keeps its id; a thread is Outlook's `conversationId`. Gmail's labels are mapped onto what the callers read: `SENT` only for mail in their Sent Items folder (a From line set to their address by someone else never counts), `DRAFT`, `INBOX`, and Focused Inbox's Other read as a tab. A sender counts as authenticated only when the topmost `Authentication-Results` — the one Exchange wrote, above anything the sender added — holds exactly one DMARC verdict, a pass for From's own domain, and Exchange Online Protection's own `compauth=` verdict, so a header the sender wrote on mail EOP never stamped doesn't count. `delete_draft` refuses anything that isn't a draft, and deletes with the draft's etag (`If-Match`), so a draft sent in between — it keeps its id — is left alone. No client secret is ever written into a person's file, and Graph has no signature setting to read.\n\n## Privacy\n\nWhat a person's mailbox touches is theirs. For the principal that means private to the principal, as every private row is. For a team member it means theirs alone, the principal included: an audit row carries `private_to_person` (set by `audit.rows_for_person` around the inbox watcher, a card's Send and Dismiss and their settings changes, and by `people_tools.audit_row_owner` on a turn that read their mail) and is left out of every audit read — the log, a session's timeline, a row by id, the brief — with only the usage totals counting it; their reply cards are theirs alone (above); and the owner's view of their use is counts only (drafts and sends in 30 days, and whether their inbox watcher is on). The conversation itself becomes its owner's alone before the mailbox is first read: `ghostwrite_email` marks the session `mail_private` (`session_store.mark_mail_private`, creating a channel adapter's row early, with its owner) and refuses to read the mailbox if that can't be stored or the conversation already belongs to someone else (which it then leaves unmarked); from then on only its owner may open it (`chat._session_access`), and working-style learning skips it. Every later turn there starts private (`settings.pin_turn_delegation` reads the flag and fails closed, setting `touched_mail`), so a follow-up answered from history alone is still private to its owner and teaches no memory, and the web chat's rows before the turn (the inbound message and the knowledge lookup) are theirs too. It does not start locked down: the lockdown is `read_mail`, set only by a turn that reads the mailbox or notes itself, and it is never carried into the next turn, because history keeps only the speaker's words and the Executive's replies, never the mail a tool returned. Their next message is them asking again, having read that reply, so everything runs again there. Anyone else speaking in it is not offered Act as me.\n\nOnce `touched_mail` is set, every audit row the turn writes is private (`people_tools.audit_row_private_to_principal`), and a team member's is theirs alone: the tool row (its input and result redacted, since `ghostwrite` is a sensitive tool name), the reply's `chat_turn` row that carries the preview, the model-call rows, and the background passes, which run under `private_rows`. The Honcho peer and department syncs are skipped, because peer memory is read on other people's turns. No memory is learned from the turn at all: the episodic, open-loop and working-style passes are skipped too, since its reply quotes a draft built from other people's mail. The `delegation_*` audit events are always private and carry metadata only — ids, counts and flags, never the draft or the thread. The inbox watcher is private the same way: every row a scan or a card action writes is its person's alone, and it starts no chat turn, alert, scheduled action or workflow run and teaches no memory.\n\nThe turn also keeps one door shut (`delegation.lockdown`). Anyone can put text in the inbox, and that text could try to steer the model, so from the round that calls `ghostwrite_email` or one of the mailbox reads — a round's tools run together — until the turn ends, the dispatch guard refuses only what opens the open internet or reaches everyone: outside fetches (`read_document`, research, the watchlist, `load_mcp_server`, and any MCP `call_tool` outside the private-turn set of reads and recipient-checked sends), `run_script` and `run_python_job`, workflows (they run later, unattended, and may fetch or script), broadcasts, department messages and alerts, and changes to who is on the roster or holds authority (`archive_person`, `set_department_head`, `resolve_roster_request`), and text that steers later turns (`schedule_followup`, whose intent runs unattended when due, and goals and decision outcomes, shown to every later turn). Everything else the person asks for runs, because it is fenced on its own: DMs and `message_person` reach only the roster, invites name attendees by person id, the Executive's own email checks every recipient against the roster, standing facts and profile edits keep only the person's own words, and a workflow drafted in chat is saved only once a person confirms it. `upsert_person` runs only for a contact the person asked for (`speaker_named_contact`: a contact, never the team, an approval scope or a chat account, with a word of the name in what they typed, in a message that asks to add, save or change someone, a new contact's address one they typed or one that sent the mail the turn read under the contact's name (`TurnDelegation.mail_senders`), never one the mail's text only mentions, and on an update a changed address they typed), since the roster is what the send checks trust. Any other contact add is refused with a pointer to an approval card (`lockdown.CONTACT_REFUSAL`), so the Executive leaves an `add_contact` card in the chat rather than asking them to type the address. What an email itself asks for is still never done on its say-so; it goes on an approval card. Every tool is classified as allowed or withheld, a test fails on a new unclassified one, and an unknown name is withheld, except an extension tool registered with `after_mail_read` (one that only reads the install's own data). The refusal tells the model to put what the step needs in its reply, since the next turn sees the reply but not the mail, and to do the step then without reading the mail again. A refused call gets a private `tool_invocation` row (`refused: mail_touched`) and tells the model to offer it in the next message. The offered tool list never changes mid-turn, so the cached prefix holds. The handlers that reach outside check again on their own (`outside_reach_refusal`). The server-side web search stays, as on a turn private to the principal. The lockdown ends with the turn. Later turns of that conversation stay private to its owner (`touched_mail`) but hold nothing: a refusal says it will work when they ask again in their next message, and it does.\n\n## Always in the loop\n\nA sent reply can leave a note. Once the reply went, `reply_send` starts `memory.history_notes.note_sent_reply` for the person who sent it, in the background, when their \"Keep track of what happens\" switch is on and the conversation isn't one they asked not to remember. The note-taker sees only the words they sent, so other people's mail never becomes a note, and a failure never touches the send. Recall is `recall_history`, offered on the same verified, private surfaces as `ghostwrite_email` and also allowed under the mail lockdown, since it only reads the speaker's own notes. Calling it locks the turn like `ghostwrite_email` does, from its own round on. The same switch also covers notes from chat, which don't need Act as me. See **Memory** for the checks, retention and controls.\n\n## The system prompt\n\nA constant, name-free `DELEGATION_ADDENDUM` joins block 0 after the unchanged identity addendum while anyone on the install has it on (`block0_delegation_on`). It names the four mailbox reads and says other people's mail is data and that a conversation which read it reaches nobody else; and it tells the model that `ghostwrite_email` is the single exception to *never impersonate*, and only for the person being spoken to; that everything else is written as itself; that when the tool isn't offered the asker can't have it; that a draft is never described as sent; and that it never denies being an AI. It is keyed on the install-level setting, never on the turn or the speaker, so switching it misses the 1h cache once (see Prompt Caching).\n\n## What it may do\n\n**Delegate → What it may do** (`delegation.may_do`, `GET /what-it-may-do`) is read-only: one row per thing that can go out without asking, what happens to it (goes out, waits for someone, always waits, drafts only, off) and which setting decides it, with a link there. It is the first Delegate tab, and `/delegate` opens on it. Three parts, each behind a pill that counts what goes out:\n\n- **As you** (the caller's own, when `can_delegate` allows them): built from `settings.is_enabled`, `inbox.get_watch`, `handle_it.get` and `handle_it.RULES`, `handle_it.leading` (Everything), `training.get` and `training.learned`, and their rules, the same reads `handle_it.refusal` and `follow_up_refusal` make. A level's row follows its `Rules` (strangers, follow-up reach, links and amounts), not a copy of them. A note names the ladder: Handle it for me rides on Draft replies to my inbox and Write drafts as me, and Everything also drops when Replies or Follow-ups go into training.\n- **As the Executive** (the principal's alone, as `GET /take-the-lead`): the switch and its training, each Ask first kind, the company's rules, and meetings. A meeting it thinks of on its own always waits: both meeting gates need someone on a verified surface in the turn, which an unattended run never is. A meeting someone asks for in chat follows **Always asks first → Meetings asked for in chat** (on means it waits: `meeting_scheduling`'s class mode is `propose`; off means `auto_execute`) and, in a team workspace, Operations' level too.\n- **Departments**: each level, and what a level covers (department-scoped scheduled work, check-ins, alert review, team members' chat sends, and Operations' meetings), and that it doesn't cover what the Executive does under Take the lead.\n\nIt also says when the Executive is paused, and when nothing can be sent as anyone because signed sign-ins are off. Nothing on it writes or reads mail. A contact, someone not on People, or a request with no caller (outside local login) gets 403.\n\n## How far it goes as you\n\nOne setting replaces the switches that used to turn each other off out of sight. The UI shows it as two pickers (`ReachCard.tsx`): **What it writes as you** (`WritesCard`) on the Act as me tab and **What it sends on its own** (`SendsCard`) on the Handle it for me tab; What it may do links each row to its own picker. Its steps, each adding to the one before: **Off**, **Drafts when I ask** (Write drafts as me), **Drafts for my inbox** (Draft replies to my inbox), then the Handle it for me steps that send, **Easy ones**, **People I know** and **Most mail** (`careful`, `balanced`, `bold`), and for the owner **Everything** (Take the lead as you). Act as me shows the first three as **Off**, **When I ask** and **For my inbox too** (any sending step reads as For my inbox too there). Handle it for me shows **Off** (saved as the inbox step) and the sending steps, and opens only once Act as me is at For my inbox too, with a button that turns that on; moving Act as me below it says Handle it for me stops too. `PUT /delegation/reach` (`{step}`) moves it, and `reach_of` reads the step back from the switches, so the stored switches stay the source of truth and every gate reads them as before.\n\nGoing down turns the switches above the target off, highest first (`_lead_off`, then Handle it, then the inbox watcher, then Write drafts as me), so nothing is ever on above a switch that's off; the UI says what stops and asks before it saves. A lower sending level only holds more back and is set directly, so it needs no signed sign-in. Going up calls each switch's own route in order, so every check it makes still applies: the mailbox connected, signed sign-ins for sending, the owner alone and not in training for Everything. The first that refuses stops the move at a whole step and answers with that route's error. **In training** (Replies and Follow-ups together, with **Train follow-ups too** to split them) and, at Everything, **Your rules** sit under the Handle it for me picker, and **Learn from my edits** (drafts training) under the Act as me one; neither picker changes training.\n\n## Surfaces\n\n- **Settings → Act as me** (`ActAsMeCard`, hidden unless `GET /delegation` answers, so a team member sees it once the owner lets them): the mailbox connection (`provider` says which) with both connect commands (Gmail and Outlook) and **Check again**, **What it writes as you** (above), with the inbox watcher's status under For my inbox too (in plain words, when it last checked, **Check now** and **Also save inbox replies in my Gmail Drafts**), and **How I write**: length and tone, a greeting per audience (`{first}` is their first name), the sign-off, habits and never-rules in fields that grow to show every line, the signature with **Refresh from Gmail** and **Don't add my signature** (or **Add my Gmail signature** when none is added; on Outlook only **Don't add my signature**, with why), and each example quoted with **Remove examples**. The owner also gets **Let team members use it** where the install allows it, with each team member who has it on listed by name and counts only.\n- **Today → Replies waiting** (`RepliesWaiting`, the top of the left column; hidden unless `GET /delegation/replies` answers with cards): each card shows who wrote and who they are to you, whether their address was verified, the subject, **They wrote** as plain text, your draft, **Decide before sending** (the open questions) and its warnings, with **Send** (a confirm naming who it goes to, and a second one when that or the thread changed), **Edit** (a text box on the card with Save and Cancel), **Open in Gmail** or **Open in Outlook** when the reply is in their Drafts, and **Dismiss**.\n- **Setup status**: a **Your own mailbox (Act as me)** light (`your_gmail`), amber while the inbox watcher can't reach the mailbox, is being rate-limited or has 25 replies waiting.\n- **Delegate** (main menu): **What it may do** (above, where `/delegate` lands), **Act as me** (where `/settings/act-as-me` lands), **Handle it for me** (which step the dial is at, with **Change in Act as me**, then **What it sent**: how many went today and what it sent this week, as you) and **Take the lead** (the switch, then **Always asks first**, shown even while the switch is off and ending in **Meetings asked for in chat**, and the company's rules, as the Executive). Each switch that turns another off says so beside it. The pause is on **Settings → Your Executive**.\n- **API**: `GET`/`PUT /delegation`, `GET`/`PUT`/`DELETE /delegation/voice`, `POST /delegation/voice/learn`, `POST /delegation/voice/describe`, `POST /delegation/voice/signature`, `PUT /delegation/inbox` (`{enabled?, mailbox_drafts?}`), `POST /delegation/inbox/check`, `GET /delegation/replies`, `PUT /delegation/replies/{id}/text`, `PUT /delegation/handle-it`, `PUT /delegation/reach` (`{step}`, the dial), `PUT /delegation/training`, `DELETE /delegation/learned/{id}` and `GET /delegation/handled` — the caller's own delegation only — and `PUT /delegation/team`, the owner's switch (see API Reference). `GET /what-it-may-do` is the read-only summary above. Send is `POST /decisions/{id}/approve`; Dismiss is `POST /decisions/{id}/reject`.\n- **Evals**: a scenario's `delegation:` block runs the turn against an in-memory mailbox (`evals.mailbox.ScenarioMailbox`) and hands the saved drafts to the judge (`delegation_001`–`003`). A `type: inbox` scenario runs the watcher's two model calls on one thread: whether it drafts must match the scenario, and a draft is judged on saying nothing the person hadn't, copying no link or address, and listing every open question (`delegation_inbox_001`–`007`; the last checks a draft never claims anything was sent).\n\nActing within rules the person sets and standing in for them are later, separate changes, each behind its own switch, off by default.",
+ "markdown": "The **delegation** module (`openexecutive.delegation`) is **Act as me**: the one place the Executive writes *as* a person instead of as itself. Everywhere else it has its own Google account and bots and signs as itself. Here — when the person asks, or, with a second switch, for mail in their inbox that needs them — it writes an email in their voice and saves it as a **draft in their own mailbox** — Gmail or Outlook — for them to review and send. The one thing it ever sends is one of those inbox drafts, exactly as it is in their mailbox: when the person taps **Send** on its card, or, with a third switch, **Handle it for me**, on its own when plain-code rules allow it (below); chat never sends. The principal can turn it on for themselves, and so can each team member once the owner lets them. It is off by default, and off changes nothing: the prompts, tool lists and prompt caches are byte-identical to an install without it.\n\n## Who can have it, and when it is offered\n\n`delegation.settings.can_delegate(person)` is the single rule for who may turn it on: the principal (a non-archived team member flagged `is_principal`), and any other non-archived team member — never a contact — once team members may have it (`team_members_enabled`). That takes two things: the install allows it (`DELEGATION_TEAM_MEMBERS`, default off, which offers the owner the switch) and the owner turned on **Let team members use it** (`PUT /delegation/team`, principal only, one row in `delegation_team`). Turning the owner's switch off takes it away from every team member from their next message, and their inbox watchers stop at their next check; their own switches, drafts and cards are kept. Everything is keyed by `person_id`. A person turns it on for themselves (`PUT /delegation`); nobody turns it on for anyone else. The setting is one row per person in `delegation_settings`, and a missing, unreadable or zero row all mean off.\n\nAt the start of every chat turn (`Executive.stream_chat` and the committee path) `pin_turn_delegation(session, speaker_text)` runs next to the workspace-mode pin and records a `TurnDelegation` on the session. `ghostwrite_email` is **offered** only when all of these hold:\n\n- the speaker may have it and turned it on — read fresh every turn, so turning it off applies from the next message;\n- the speaker is on a surface that verified it is them — the principal through `people_tools.is_principal_on_verified_surface`, a team member through `teammate_on_verified_surface` (the web app signed in, their own Slack or Discord, never an email turn) — and a web turn also carried a signed-in caller (`Session.web_caller_signed_in`, set from `x-caller-email`) or runs under local login — a request with no caller header is not a sign-in and never gets it (whoever holds the shared secret is trusted as the UI proxy that stamps that header, as on every principal-only route);\n- the conversation is private to the speaker: the web chat, a Slack or Discord DM, a verified private Telegram chat, or a chat its channel adapter verified the sender of and marked private (`Session.speaker_verified` + `Session.private_chat`) — never a shared channel or thread, where the draft's preview or the matching threads would be posted for everyone and other people's messages sit in the model's context;\n- the turn is neither unattended (the scheduler's proactive run) nor private to the principal (the email poller's turns), so inbound text can never reach it. The MCP server, workflows, reflection and research never carry it at all.\n\nThe mailbox connection is deliberately **not** part of the offer: the handler checks it on every call and says how to fix it, so the cached tool prefix never flips when a token lapses. The pin lives in a context variable for the turn's task as well as on the session, so two turns running at once on one session (a second browser tab) each read their own. It also carries the speaker's own words for the turn (a new email may go to an address they just typed — the turn's message joins the history only once the turn ends), a per-turn draft count, and `touched_mail` (see Privacy). `own_words` reads those words back for every own-words check (addresses here, facts and task assignments elsewhere): it first removes the hydrated `<outbound_reply_context>` backstory by its exact, anchored shape, so a look-alike closing tag quoted inside it cannot pass the rest off as the speaker's, then drops other adapter tag blocks, and returns nothing for a message carrying an attachment.\n\n## The tool: `ghostwrite_email`\n\nIt lives in its own registry (`orchestrator.delegation_tools.DELEGATION_TOOLS` / `DELEGATION_TOOL_HANDLERS`), **never** `_ALL_SKILL_TOOLS`, so no other toolkit can carry it. On a turn it is offered to, the agent loop adds it to the pool *before* the sort and builds that turn's handler map from both registries; on any other turn a call to it is an unknown tool. The handler re-checks the pin and the surface anyway, then:\n\n1. **Caps** — at most 5 drafts per turn, and `DELEGATION_MAX_DRAFTS_PER_DAY` (default 50, at most 1000) per person per UTC day, shared with the inbox watcher (`delegation.caps`). It is counted from `delegation_drafts`, one row of ids per draft saved from either place, with a count kept in the process as a floor in case a row was lost. Each slot is taken before the first await — a round's tool calls run concurrently, so otherwise every call in it would pass the caps before any counted — and handed back if nothing was drafted. If the rows can't be read it refuses rather than guess.\n2. **Marks the turn** — sets `TurnDelegation.touched_mail` *before* its first read of the mailbox.\n3. **Checks the mailbox** — `gmail_status` asks Google or Microsoft whose mailbox the credential opens and compares it with the person's People email, on every call: a roster email can change, and a client slot swaps the roster.\n4. **Finds the thread** — by `thread_id` (checked against the mailbox's own id shape), or a Gmail-style search (`find`; on Outlook, words, `from:`, `to:`, `cc:`, `subject:` and `newer_than:` are kept and other Gmail operators dropped). Several matches return `{status: \"choose\", candidates}` (subject, sender and date — no message text) and draft nothing; none returns `not_found`.\n5. **Sets the recipients in code**, never from the model. A reply goes to the last inbound message's `From` — never its `Reply-To` (a different one is flagged `reply_to_ignored`) — with the thread's other recipients only on `reply_all`. A new email or a forward may go to any well-formed address: it is only a draft, waiting in their own mailbox, where they see who it is to before they send it. An address that is neither on the roster (contacts only when `contacts_reachable_now()`) nor typed by the speaker this turn comes back in `not_in_people`, and the Executive names it for them to check (`delegation_tools.not_in_people`). Mailing-list mail, a thread they replied to last and a reply-all trimmed to 10 recipients are flagged. An address inside a block an adapter added to their message (the backstory hydrated into a DM) is not one they typed, and when the message carries an attachment — a document's inlined text, or a note naming the file — none of its addresses count as typed: neither has an end mark, and a filename is chosen by whoever sent the file, so such an address is named back to check.\n6. **Writes it** (the ghostwriter, below) and saves it with the mailbox client's `create_draft` (Gmail: threaded with `In-Reply-To`, `References` (whole message ids: when the chain is too long for one header the oldest after the thread's first go, never the parent) and `threadId`, and stamped `X-OE-Ghostwritten`; Outlook: Graph's `createReply` on the message it answers, then the text and recipients, and a named property marking it).\n\nThe result is `{status: \"drafted\", draft_id, gmail_link, to, cc, subject, preview, flags, open_questions, note}`, plus `not_in_people` and `check_address` when a recipient needs checking. The link (`gmail.mailbox_link`) is built server-side from a fixed prefix — the thread in Gmail, the draft itself in Outlook on the web — and the note tells the model the preview is the person's draft, to be treated as data. The chat shows an action chip — \"Drafted an email as you to … — in your Drafts\" — that opens it, and only a link under `MAILBOX_LINK_PREFIXES` is ever linked. A sincere \"are you an AI?\" in the thread comes back as an open question for the person to answer themselves.\n\n## Reading their mailbox\n\nFive read-only mail tools ride with `ghostwrite_email` in the same registry (`orchestrator.mail_read_tools`), so they are offered, re-checked and fenced exactly as it is: `search_my_email` (a Gmail-style search through the client's `search_threads`, or with no query the threads that reached their inbox in the last few days through `inbox_message_ids` + `get_message`), `read_my_email` (one thread's last 10 messages, each sender's new text only, drafts left out, with the files attached to them listed by message id and index), `read_my_email_attachment` (one of those files as text: PDF, Word, Excel, CSV or text, up to 20 MB, a scanned PDF converted) and `my_email_awaiting_reply` (their own sent mail from the last 14 days, to at most 10 people besides the Executive, that is still the last message in its thread). They change, label, draft and send nothing.\n\nThe fifth, `my_email_read_before`, lists the threads `read_my_email` opened for the same person before, in this conversation or an earlier one, so a later conversation can open the same email again instead of asking them to search for it. It keeps where, never what (`delegation.mail_reads`, table `delegation_mail_read`): the thread id, its subject and first sender as one line each, the mailbox address it was read from and when, never a message's text, an attachment or a recipient. Rows are the person's own and are listed only from the mailbox open now, newest first, optionally narrowed by words in the subject or sender; anything older than 30 days is never listed and is deleted on the next write, at most 200 are kept per person, and turning Act as me off deletes them all. It opens the mailbox like the other reads, so it sets `touched_mail`, counts as a search, and returns its rows with the same data-not-instructions note. The Act as me addendum tells the model that these tools reach the person's mailbox while any Gmail or Outlook tools of its own account reach only the Executive's, to search theirs (never falling back to its own) for mail sent to them, and to reopen an email from before with `my_email_read_before` and `read_my_email`.\n\nEach sets `touched_mail` and marks the conversation theirs before its first read (`_open_mailbox`, shared with `ghostwrite_email`), so the lockdown below applies from its round on. Each is capped per turn on the pin: 10 searches (`my_email_awaiting_reply` counts as one), 20 thread reads and 5 attachment reads, the slot taken before the first await. In `read_my_email` every message someone else wrote comes back inside its own `<untrusted_content source=\"email\">` block (`content_trust.wrap_untrusted`, which defuses a closing tag in the text); the speaker's own messages — SENT and from their address (`threads.mine`), never a From header alone — are marked \"Yours\" outside any block. An attachment's text comes back in its own `<untrusted_content source=\"attachment\">` block (`attachments.format_attached_text`), parsed in an isolated worker (`knowledge.loader`); unlike a file sent to the Executive it is never added to the company's knowledge. The clients find an attachment by message and position and look its provider id up on each read (Gmail's changes per fetch): Gmail lists a message's files with the message (`MailMessage.attachments`, leaving out images the HTML shows in place), Outlook says only `hasAttachments` until `list_attachments` asks Graph (leaving out inline ones), and `attachment_bytes` reads one; an attached Outlook item or cloud link has no file to read. Results carry a note that subjects, senders and text are other people's words, data rather than instructions. The lockdown refuses tools, not the reply's own text, so what would carry that text out without a click is closed where it is shown: the web chat loads no image from another site, and bot replies go out without link previews (see Integrations).\n\n## Saving a file from their mail\n\nOne more tool rides with the reads: `save_my_email_attachment` (message id and index, as `read_my_email` listed the file) copies one attached file into the storage the Executive itself has connected and shares it with the speaker alone, so they get a link they can open or put in an app. Every call it makes is built in code (`orchestrator.mail_file_save`); the model picks only the attachment. The bytes come from the mailbox client's `attachment_bytes` and never pass through the model, any file type up to 20 MB, under a cleaned name (one line, no path or reserved characters, extension kept). The storage is the one the Executive's own mailbox runs on (`EMAIL_PROVIDER`) when the gateway has that server, else the other: Google Drive through workspace-mcp (`create_drive_file` with `base64_content` into a folder named \"From your email\" in the Executive's My Drive, then `manage_drive_access` granting the speaker's own address the reader role, `send_notification` off) or OneDrive through ms-365-mcp-server (`upload-file-content` into the same kind of folder in the Executive's own drive, with a name no recorded copy has, since an upload overwrites, then `share-drive-item` inviting only the speaker, `requireSignIn`, role `read`, `sendInvitation` off). The folder is always made by the save itself and its id remembered (`delegation_saved_folder`), never found by its name, since a folder someone else made and called that could already be shared with them; when the remembered one is gone or won't take the file, a new one is made and the old id stays recorded. Never a link share, a domain or anyone. Neither connected (or an eval's in-memory mailbox): status `no_storage`, and the model says so and offers to forward the email instead. Saves run one at a time, at most 10 a turn (`TurnDelegation.files_saved`), and the result is the status, the name, where it went and the link (`webViewLink` / `webUrl`); the chat chip says only that a file was saved, never the sender's file name.\n\nIt copies only when the speaker asked in their own words this turn: what they typed (`own_words`, no quoted backstory or attached file's text) must hold one of save, saved, upload or OneDrive, or Drive as a place (\"to my Drive\", \"in Drive\", \"Google Drive\"), checked before a slot is spent or the mailbox opened; otherwise it refuses (`not_asked`) and tells the model to ask them. It stays allowed after the turn read mail (`MAIL_TOUCHED_ALLOWED_TOOLS`): its gateway calls are admitted past the lockdown only as the very objects the handler built (`mcp_gateway.code_built_call`, for its seven Drive and OneDrive tools: folder create, file create or upload, the speaker's share, and OneDrive's `list-drives`), so a model's own `call_tool` on that turn is still refused, and every other gateway gate still runs on them (the acting account, URL fetches, sheet formulas, the share gates' roster check, writes kept to the Executive's own drives).\n\nEach copy is recorded before it is shared (`delegation.saved_files`, table `delegation_saved_files`: the person, the storage, the file id, its name and when; never content or the mail it came from), and the folder in `delegation_saved_folder`. The gateway reads that table on every Google Workspace and Microsoft 365 call: on a turn whose speaker is not the file's owner (the owner is the speaker only when Act as me was offered to them, so a shared chat, a workflow or the poller sees none), a call naming a recorded file id, raw or percent-encoded (OneDrive's `download-bytes` path is decoded by Graph), is refused, and a result, filtered against the table as it stands after the call so a copy recorded while a listing ran is caught too, loses each list entry or line naming one, with any id left masked. It matches ids as text, so a result that names such a file without its id (a notification quoting its title) still shows the name, and a copy someone makes is a new file. The folders are guarded harder, on every turn and for every speaker, the owner too: a model call whose arguments name any recorded folder id, or an OneDrive item path through the folder (`root:/From your email/x.pdf:` or `<folder id>:/x.pdf:`), is refused, so nobody can share, move, rename, copy, list or delete the folder from chat, and folder ids are dropped from or masked in every result; only the save's own code-built calls touch it. When a copy is made but its row can't be written, it is not shared, the save reports `failed` and logs an error, and the copy's id is hidden from every turn, the owner's included, for the life of the process. When the table can't be read, the file tools (`_FILE_TOOL_RE`: Drive, folder, file, Docs, Sheets, Slides and presentation tools, attachment bytes) are refused (fail closed) while mail and calendar run. The rows are kept when Act as me is turned off: the copies stay in the Executive's storage, and the rows keep them out of other people's turns.\n\n## Reading their calendar\n\nA third switch under Act as me, **Read my calendar** (`delegation.calendar`, table `delegation_calendar`: one row per person, absent or unreadable meaning off), lets the Executive read the person's own calendar, read-only. It rides on the same per-person sign-in as their mailbox: `calendar.readonly` on Google, `Calendars.Read` on Microsoft, added when they run the connect script with `--calendar` (`scripts/connect-own-gmail.py`, `scripts/connect-own-outlook.py`). Those scopes are optional, so a mail-only sign-in keeps working for mail; the mailbox clients note the scopes the token refresh reports, and `list_events` raises `CalendarNotGranted` before calling the calendar when the scope is missing (or when the calendar answers 403). Only the person turns it on (`PUT /delegation/calendar`), only while Act as me is on and a one-hour read works; a sign-in without the calendar is refused with `calendar_not_granted` and the command to run. Turning Act as me off turns it off. Changes are audited privately (`delegation_calendar_changed`).\n\n`my_calendar` sits with the mailbox reads, offered and fenced the same way: it refuses while the switch is off (before anything is opened), then takes a search slot, opens the mailbox privately (`_open_mailbox`, so `touched_mail` and the lockdown apply: an invite's title is in the words of whoever sent it) and lists the events from `start` (default today) for `days` days (1 to 31) in the workspace time zone, recurring events expanded and cancelled ones left out: title, start, end, all-day, location, organizer, attendees (25 at most) and the person's own answer, each on one line, with a data-not-instructions note. Google's `events.list` on the primary calendar and Graph's `calendarView` (times asked for in UTC) are its only calls; it changes nothing and keeps nothing. The first week's brief also lists today's meetings from it on the principal's own delivery (see Today).\n\n## Forwarding and reminders\n\n`ghostwrite_email` also forwards: with `forward` (a thread id) and `to`, it drafts a forward of the thread's latest message, or of the earlier one `forward_message_id` names (the one with the files, say, when their own reply came after it), `intent` becoming the short note above it (the ghostwriter writes only the note; the forwarded email's subject, someone else's words, is never put in the intent). Recipients follow the new-email rule (`_new_recipients`: the roster, or addresses the speaker typed this turn). Gmail's draft quotes a forward header and the original's own words under the note and attaches the original's files, up to 10 and 20 MB (`FORWARD_MAX_FILES`, `FORWARD_MAX_BYTES`; any left off are flagged `attachments_left_off`); Outlook uses Graph's `createForward`, which keeps the original and its files, with the note as its comment and the body never patched. It is still only a draft.\n\n`remind_me(text, when)` (`orchestrator.reminder_tools`) rides with the same tools and checks, but opens no mailbox, so it never marks or locks a turn (`MAILBOX_TOOL_NAMES` are the ones that do). It stores the text once cleaned — one line, anything a chat app could turn into a link (a URL of any scheme, an address, a domain-like word, a host and port, an IP address) replaced with \"[link]\", at most 300 characters — with its time (stored in UTC) in `delegation_reminders` (5 a turn, 25 waiting, a year ahead, refused when the person has no channel). When it is due the scheduler sends that text to the person alone, as \"Reminder you set on <date>: …\", running nothing (see Scheduler); the Slack and Discord DMs it may go by turn link previews off. The chat chip shows the text as it will be sent. A reminder that comes due in the person's quiet hours or leave (when `OUTBOUND_RESPECT_QUIET_HOURS` is on) waits unclaimed and goes once they end, rather than being suppressed and lost. It is allowed after mail is read and in later turns of that conversation: it reaches only the speaker, as plain text. `schedule_followup`, which runs a turn with tools and is listed to everyone, stays refused there.\n\n## Approval cards\n\nA turn that read someone's mail may not message anyone, invite anyone or change the roster (see the lockdown above), yet what the mail asks for is often right. `propose_actions` (`orchestrator.action_card_tools`) leaves the speaker a card instead: up to five actions, each spelled out exactly as it will happen, done only when they tap Approve. It rides with the other Act as me tools and checks (`_writer`), opens no mailbox, and is allowed after mail is read because it does nothing on the turn.\n\n- **Kinds.** `invite` (a meeting with people on the roster), `message` (a direct message to someone on the roster, as written) and `add_contact` (a new contact; the principal's cards only, since contacts are theirs). A team member's card can't name a contact. Each action is checked when the card is made (`delegation.action_cards.check`) and again when it is carried out, so an archived person or a time that has passed fails that action alone.\n- **Whose.** A card is a `delegation_actions` decision for the speaker, `approver_only` like a reply card: only they see it (`GET /delegation/actions`) or resolve it, a team member's answers 404 to the principal too, and it is never an alert. The same actions still waiting are that card, not a new one. 3 cards a turn, 25 waiting, dropped after 7 days.\n- **Approve.** In the chat, under the reply that left it (the `propose_actions` chip carries the card's `decision_id`, and `ChatActionCards` shows the card while it waits), and on the Briefing's Needs you list, with a box per action. Approve (`POST /decisions/{id}/approve`, `edits.only`) needs the card's person signed in (`verified.caller_refusal`) with Act as me on; the card is claimed first so it runs once, then each ticked action runs as stored with no model call, in an unattended session (the principal's with contact egress) under `rows_for_person`, so every audit row it writes is theirs and nothing reaches the team's activity rail: `message_person` (a direct message or nothing; never its Briefing-alert fallback, which more people read), `create_calendar_event`, or a contact row. Approving also needs the person still allowed Act as me (`can_delegate`) and switched on. An invite is booked straight away when the person approving is the one the meeting gate would ask (`calendar_tools.approved_by`), and otherwise goes to that approver as usual, so a card never widens anyone's authority. Per-action results (`done`, `waiting`, `failed`, `skipped`) are kept on the decision and shown on the card. Dismiss rejects it and does nothing else. With Suggested actions in training the card adds Approve + allow, and a card of actions all allowed is carried out on its own (see In training above).\n- **Channels.** A card can come from any surface Act as me runs on; it is approved in the web app, since the chat apps have no buttons here.\n\n## The ghostwriter\n\n`delegation.ghostwriter.compose` writes the text. The Executive decides *what* to say (`intent`); this call decides *how* the person would say it, and it is deliberately small:\n\n- a constant `GHOSTWRITER_PROMPT` plus the person's voice block as the system prompt;\n- the thread (each message cut to its sender's own words, every line scrubbed, all labelled alike), then the writer's own earlier words in it (`<writer_said>`, from their sent mail only), the intent and the recipients' names in the user turn — no company profile, memory or roster;\n- with Always in the loop on, `<writer_noted>`: what the writer's own notes say they told these same people in earlier Act as me replies (`memory.history_drafts.notes_for_draft`: only notes from mail **every** recipient of the new draft was on, so nothing told to one person reaches another; chat notes name no recipient and never qualify; at most 8, newest first, the person's own words or their correction, with dates). The prompt's rule 6 makes it a consistency check, never content: a draft that contradicts it is still written as the intent says, and the conflict becomes an open question on the card, which only the writer sees. Both the chat tool and the inbox watcher pass it;\n- **no tools** but the forced `compose_reply` return, so text in the thread can ask for anything and there is nothing to do it with.\n\nIt is not a Council agent — the Council's edit routes have no principal check — and runs on `DELEGATION_COMPOSER_MODEL` (default: the default model), logged as `ghostwriter` usage. `lint` then runs in code on what comes back: a link or an email address survives only if it appears in the intent, the signature or the recipients, so a link planted in the thread is removed and flagged; the Executive's own name is flagged; and the body is capped, cut at a paragraph, line or word break in its last fifth. A draft with nothing left after that is refused. The signature from the person's Gmail settings (or the one already stored, for Outlook) is appended.\n\n## How I write\n\n`delegation.voice` learns how a person writes *their own* email (`attunement.style` learns how the Executive should write *to* someone). `POST /delegation/voice/learn` reads up to 40 recent sent messages, keeps only what they wrote (quoted replies stripped with the email poller's `sender_new_text`), skips automatic mail, every thread chat drafted into, and every sent message that began as a draft written for them (`delegation_drafts.sent_message_id`), and makes one forced-tool call (`record_voice_profile`). Code validates every field before it is stored:\n\n- greetings per audience (their team, their contacts, anyone else), a sign-off of at most two lines, and a usual length and tone (a backslash-n the model wrote instead of a line break is read as one, keeping the first lines that fit, which also repairs a profile stored before that rule);\n- up to 8 habits and 6 things to avoid, through the same deny-list as working-style rules — no actions, links, handles, amounts, tool names or names of people; the conversation review (`memory.chat_review`) adds one when the person states how they write in a chat (`add_conversation_rule`, `updated_by=conversation`; never on a locked or full list, and an edit or lock made meanwhile wins);\n- up to 3 short exemplars, each checked to be verbatim from a sample, with addresses and phone numbers masked — and none while a client slot is active, so one client's mail never lands in another's state.\n\nThe signature comes from Gmail's `sendAs` settings, not the model (Outlook gives apps no way to read one, so a learn keeps the stored signature and `POST /delegation/voice/signature` answers 409 `signature_unavailable` rather than clearing it), as plain text with its lines kept (`gmail.html_to_text`: a `<br>` always ends a line, and a block tag, opening or closing, ends one when it has text, so Gmail's layout of a first line followed by one `<div>` per line comes out line by line). `POST /delegation/voice/signature` reads it again without relearning: nothing else changes and a locked profile stays locked, so it picks up a changed Gmail signature and undoes **Don't add my signature**. A person can also describe their style in their own words: `POST /delegation/voice/describe` applies the description to the profile they have through the same forced tool (a separate system prompt, no exemplars) and the same validation, keeps their signature and writing examples, and returns the result with a short sample reply for them to review. It saves nothing and needs no mailbox; Save stores it as an ordinary edit. The person can edit the profile, lock it (a locked profile is never relearned) and reset it, and every change is kept in `delegation_voice_history`. One learn runs at a time per person, and a lock or an edit made while it runs wins: the learned profile is dropped (`changed`).\n\n## Draft replies to my inbox\n\nA second switch under Act as me, **Draft replies to my inbox** (`delegation.inbox`), has the Executive watch the person's own inbox and write a first reply to mail that needs them. The reply waits on a private card on Today; nothing is sent until they tap **Send** (below). Where the reply lives is the person's choice, **Also save replies in my Gmail Drafts** (`mailbox_drafts`, off by default): off, it lives on the card alone (`delegation.card_drafts`: the card keeps the draft's recipients, subject and thread headers as `draft_spec`, and Send makes the mailbox draft from exactly that just before the send-time checks, taking it back out if they refuse), so their Drafts folder doesn't fill with replies they may never send; on, it is also saved in their Drafts as before. The switch is one row per person in `delegation_inbox_watch`. Turning it on needs Act as me on and their mailbox connected, and sets `watch_since` to now every time, so it never drafts for mail that arrived before; turning Act as me off turns it off too. Off means no mailbox call and no row written, with one exception: a send the person started that the mailbox never confirmed is still followed through until it is settled.\n\n### When it looks\n\nA throttled hook in the scheduler tick (`_maybe_scan_inbox`, after the pause, company-profile and rotation gates) checks each person whose switch is on every `DELEGATION_INBOX_POLL_MINUTES` (default 5). It is not a scheduled action, because those are listed on `/scheduled` for everyone and anyone may cancel them. One scan task runs at a time, one scan per person, and none while a client slot is active. **Check now** on the Settings card runs the same scan. Every row a scan writes is private and the person's own (`audit.rows_for_person`: a team member's rows are hidden from the principal too, see Privacy), and the process log carries counts and codes, never an address or a line of mail. The scan never marks mail read or changes a label.\n\n### What it drafts for\n\nA scan first settles the open cards (below), and stops with `backlog_full` once 25 are waiting, counting the ones it makes. It then lists the inbox since `watch_since` (`inbox_message_ids`) — not chats, not mail from the person, and not the promotions, social, updates or forums tabs (on Outlook: the Focused inbox only) — up to 100 messages, and takes the newest message of each thread that still needs a look, at most 10: settled threads and threads with an open card are passed over first, so a burst of mail, or a pause for a limit or a back-off, never hides older threads for good. `delegation_inbox_messages` is its durable cursor: one row per message (`UNIQUE(person_id, message_id)`) with what happened to it, the reason, how many tries it took, and the draft and card ids. It stores a hash of the sender's address, never the address. A message is skipped, with the reason recorded, when:\n\n- it came before `watch_since`, or more than three days ago;\n- it is from the person or one of their send-as addresses, from the Executive, or one of this module's own drafts;\n- it is automatic — `Auto-Submitted`, a bulk or auto-reply `Precedence`, a bounce, a calendar invite or a no-reply sender — or from a mailing list, or in a Gmail tab, spam or trash;\n- the person is not in To or Cc, or it has more than 10 recipients;\n- the person replied last, or a draft already sits in the thread.\n\nThree kinds are left unrecorded, so a later scan looks again: mail under 10 minutes old (mail the person answers straight away never gets a card), mail in a thread whose card is still open, and mail a daily limit holds back.\n\n### Deciding, then writing\n\nTwo model calls, and code decides between them. The classifier (`delegation.inbox_classifier`) is one forced-tool call, `classify_email`, returning whether the email needs a personal reply, what kind it is and how sure it is. It sees a few one-lined header lines and the sender's own new words (at most 3000 characters, every line scrubbed) inside one `<email>` block marked as data, and it has no other tools, context or memory, so an email can ask for anything and there is nothing to do it with. A reply is drafted only for a question, a request, scheduling, an introduction or a follow-up, and only when the confidence clears a bar that rises the less the sender is known: 0.6 for their team or a contact (the principal's contacts count only for the principal: a team member's mail is weighed by the team and their own sent mail), 0.7 for someone they have written to before (`has_written_to`, a search of their sent mail), 0.85 for a stranger. Pitches, notes of thanks, FYIs, notifications, newsletters and phishing get nothing, and so does any failure. An email that also went to other people is drafted for only when the person is in To and it asks them themselves: the classifier is told their name, whether they are in To or Cc and how many others it went to, and lists the names the email greets or asks by name (`asked_names`). Code matches those against the person's name, whole name parts only (\"Alexis\" never counts for \"Alex\", and a nickname misses, which means no draft), so mail that greets someone else (\"Good morning, Brennan, could you sign ...\") is never theirs, whatever the model makes of it as a whole. When it names nobody, the model's `asked_of_them` decides, false for a question to the group at large. One that only copies them is never drafted for. Either is recorded `not_needed` with the reason `asks_someone_else`. It runs on `DELEGATION_CLASSIFIER_MODEL`, else the routing model. A sender whose address Gmail couldn't authenticate is handled as a stranger whatever the roster says — anyone can put a colleague's or a client's address in From — so they get the stranger's bar, a holding reply and the stranger limits; the card still says who they claim to be, and that the address isn't verified.\n\nThe reply is written by the same ghostwriter, in the person's voice, but from a fixed intent the module builds rather than words the person typed. Because the intent lets it restate the person's own earlier words, which words are theirs is never written inside the thread, where a sender could imitate any marker with a look-alike: every message there is labelled alike, and the person's own words come in a separate `<writer_said>` block after the thread, taken only from mail their own mailbox sent. Nothing inside the thread can close the thread block or open another. The intent: acknowledge the sender; say again only what the person's *own* earlier messages in the thread already said; commit to nothing new — no yes or no, date, time, price, fact or promise — and say they will get back to them; and put every question it could not answer from their words in **open questions**. A stranger always gets a short holding reply. The lint still strips any link or address that isn't the person's own. The reply goes to the sender (never `Reply-To`) and, on a group email, to everyone else it went to as Cc (reply to all, never the person's own addresses or the Executive); a stranger's holding reply goes to the sender alone. The card says when others were on the email, and its `draft_to` lists everyone, which Send checks.\n\nThe order: record the message, classify, reserve a slot in the shared daily limit, write, save the draft in Gmail (from the alias the mail went to, when it went to one) and store its id, then create the card (idempotent on the message) and mark it drafted. Nothing that fails along the way loses the message. A failure that may pass — the classifier or the writer failing, Gmail refusing the draft, a card that couldn't be made (its draft is deleted first, so no draft is left without a card), any other error with that one message — leaves it for a later scan (`retry`), and it is given up on only after three tries; one message's trouble never holds up the rest. A daily limit reached while it was being read leaves it for later without counting as a try.\n\n### The reply cards\n\nA card is a `delegation_reply` decision whose class is **its approver's alone** (`DecisionClassSpec.approver_only`): only the person it was drafted for sees or resolves it on any decisions route — a team member's card answers 404 to the principal too — and it is never an alert: alerts feed chat turns, which would put other people's mail into memory. It carries the sender with who they are to the person and whether Gmail could verify the address (SPF/DKIM/DMARC, through `fact_confirmation.headers_authenticated`), the subject, what they wrote, the draft, the open questions and its warnings. `GET /delegation/replies` lists the open ones from the database alone, so Today never waits on Google.\n\n- **Send** approves the card, which sends its draft exactly as it is in their mailbox (see *Send on your tap*). **Edit** changes the reply's words right on the card (`PUT /delegation/replies/{id}/text`, `card_drafts.edit`): only its own person, from a caller the API can tie to them (as for Send), never while it is being sent on its own; a reply in their Drafts is rewritten there too (`update_draft_text`, every header kept), and only while it is still the version the card last saw, so a change made in the mailbox is never overwritten. A card edit counts as edited (`approved_with_edit`, and **Do it like this next time** keeps it). **Open in Gmail** (or **Open in Outlook**), shown only when the reply is in their Drafts, opens it there.\n- **Dismiss** rejects the card; the class's after-reject step then deletes the draft if nobody edited it — its message id is still the one it was saved with, since Gmail gives an edited draft a new one, and the Outlook client makes a draft's message id `<id>.<changeKey>` so an edit there changes it too — and keeps it otherwise. What happened is recorded even when Gmail fails.\n- Each scan first **settles** what Gmail already settled: a draft sent from Gmail, a draft deleted there, a reply the person wrote themselves, a thread that is gone, or a card left for 7 days (its draft stays in Gmail). Each is a compare-and-set close with the reason. A newer message from someone else flags the card instead. A card being sent at that moment is left alone.\n\n### Send on your tap\n\n`delegation.reply_send` is the only thing in Act as me that sends, and all it can send is the draft on a card, by its id: `DelegateGmail.send_draft` posts `{\"id\": …}` to Gmail's `drafts.send`, and `DelegateOutlook.send_draft` posts an empty body to that draft's Graph `send`, and nothing else, so no text, recipient or header is ever passed. It has two doors: `send_approved_reply`, reached only from `POST /decisions/{id}/approve` — a class only the card's own person may resolve — and `send_on_its_own`, reached only from the inbox watcher under Handle it for me (below). AST tests pin both call sites, so no model, chat turn, workflow, scheduled job or MCP call can. A tap is checked like this: At send time it checks everything again:\n\n1. **Who is asking.** The caller is the card's person and the API knows it: signed callers are on and the request carries that person's signed assertion (or the operator's, under local login), or the API runs for local login and answers this computer only. Anything else is a 409 `caller_signing_required` — with only the shared secret, whoever holds it could send as the owner — so on a server Send needs signed sign-ins.\n2. **The switches.** Act as me and Draft replies to my inbox are on, and no client slot is active.\n3. **The mailbox.** Their mailbox is connected.\n4. **The draft.** It still exists, in the same thread, and they haven't replied there themselves since; otherwise the card closes.\n5. **Who it goes to.** To, Cc and Bcc hold between 1 and 10 addresses, never the Executive's own, and it is from one of their own addresses.\n6. **What changed.** Recipients that differ from the card's, or a newer message from someone else, need a second yes: the first tap gets a 409 `confirm` naming the recipients and the reason, and the person approves again with what they were shown.\n\nThen it claims the card (`claim_for_execution`, proposed → executing, a compare-and-set, so a double tap sends once) and reads the draft once more: `drafts.send` sends whatever the draft is when Gmail gets the request, so if it was edited since the checks read it — in another tab, by a delegate — nothing is sent and the card comes back (`draft_changed`). Then it sends, and records the result: `approved_with_edit` when the draft was edited in Gmail, the sent message's id, the draft row's `sent_message_id`, and a private `delegation_reply_sent` row. A refusal that proves nothing went — a 4xx, a lapsed sign-in, a rate limit, a draft already gone — hands the card back. A failure that leaves it unclear — a timeout, a 5xx — leaves it `executing` and says to check the Sent folder, and the next scans ask Gmail: their message in the thread means it was sent; anything else is judged on the second scan that sees it: the draft still there and nothing sent means it was not (Gmail deletes a draft it sends), and the card comes back, flagged; the draft gone and nothing sent means it was deleted. Nothing is ever retried on its own. Sending is the person's own act, so it works while the Executive is paused.\n\n### Limits and failures\n\nAt most 5 drafts a scan; `DELEGATION_INBOX_MAX_DRAFTS_PER_DAY` (default 20) a day, inside the shared `DELEGATION_MAX_DRAFTS_PER_DAY` it shares with chat; 200 classifications, 2 drafts per sender (1 for a stranger) and 10 for strangers in all per day; and never more than 25 open cards. A lapsed Gmail sign-in sets the status and is looked at again every 30 minutes; a rate limit, an error reaching Gmail or a crash backs off from 5 minutes, doubling up to 2 hours. Neither turns the switch off: the Settings card shows the status in plain words.\n\n## Handle it for me\n\nA third switch under Act as me, **Handle it for me** (`delegation.handle_it`), lets the inbox watcher send some of its replies itself instead of leaving them on a card. It is one row per person in `delegation_handle_it` (`enabled`, `mode`); no row means off. One setting says how much goes without them, the way quality does on the Agent Council (`handle_it.RULES`): **Easy ones** (`careful`) sends only replies to people they know (someone on their team, a contact or someone they have written to) of at most 400 characters when the classifier is at least 0.9 sure; **People I know** (`balanced`), where it starts, sends replies to people they know up to 1200 characters at 0.8; **Most mail** (`bold`) also answers strangers, up to 2000 characters, and lets a link or an amount through when the classifier is at least 0.9 sure. Everything else waits on a card as before, so turning it on never drafts less. A table from before the setting gets the `mode` column on its next open (`schema._add_handle_it_mode`): someone who had strangers set to send keeps that as Bold, everyone else gets Balanced. Only the person turns it on (`PUT /delegation/handle-it`), from a session the API knows is theirs: the same rule Send uses (`delegation.verified.caller_refusal`), so with only the shared secret it answers 409 `caller_signing_required`. Turning it on needs Act as me and Draft replies to my inbox on, and turning the inbox watcher off (or Act as me, which turns it off) turns it off too.\n\n**In training** (`delegation.training`). Like someone new, each Act as me job can be put in training on its own, from that job's card on the Act as me page, the way Take the lead has it: **Write drafts as me** and **Handle it for me** each pick Off / In training / On (Handle it's In training is Replies in training, with a *Train follow-ups too* box for Follow-ups), and **Suggested actions** picks Always ask / In training; what it learned is listed on each tab for its own jobs (Act as me: *What it's learned*, drafts and suggested actions; Handle it for me: *Who it's allowed to handle*, replies and follow-ups), each item named by its job (`PUT /delegation/training`, one row per person and setting in `delegation_training`, absent means not in training). In training it asks first and learns who and how from what the person approves; what it learns is a `take_the_lead_allowed` row (feature `act_as_me`, the person's id), theirs alone.\n\n- **Replies.** Every reply waits on its card (`handle_it_reason` `training`) whatever the dial says, and a reply card adds **Send + allow**: it sends that reply on the person's own tap, exactly as Send does, then allows replies to that sender (key `act_as_me|person:<id>|reply|<address>`). While Handle it for me is on, a reply to an allowed sender goes on its own under the dial's limits (a stranger they allowed included) and every check above (the topics that always wait, links and amounts, new recipients, once a thread a day, the daily limit); it's checked again at send time, so a sender removed since waits. Take the lead as you lifts nothing in training: putting Replies or Follow-ups in training turns it off, and it can't be turned on while they are (409 `in_training`).\n- **Follow-ups.** Every follow-up waits (`follow_up_training`); Send + allow on a follow-up card allows follow-ups to exactly the people it went to (`…|follow_up|<sorted addresses>`), whoever they are, under every other follow-up check.\n- **Suggested actions.** An action card (below) adds **Approve + allow**: it does the actions on the tap, then allows each one that happened (a message to that person, `…|message|person:<id>`; a meeting with exactly those people, the person left out, `…|invite|people:<ids>`). A new contact is never allowed. A card proposed later whose every action is allowed is carried out at once, with no tap (`action_cards.run_on_its_own`, `gate_mode` `auto_execute`, status `executed`), only if plain code finds nothing against it (`on_its_own_refusal`): still in training, Act as me on, a server that ties the switch to the person, nothing sensitive, no link or amount, a message of at most 1200 characters, and at most 10 actions carried out this way a day (checked one card at a time); anything refused is handed back to wait on its card as before. An invite carried out this way is never booked as approved by the person: the meeting gate decides as for any meeting nobody tapped, so a time taken from someone's mail can't land on a calendar unasked. The tool result and chip say what was done. The message text in such an action is model-written from the mail and goes without anyone reading it; the allowance covers who and what kind, not the words, which is why sensitive topics, links, amounts and long messages are held back.\n- **Drafts.** Nothing is sent. When the person changes a reply's draft in their mailbox before tapping Send (plain or + allow) and ticks **Do it like this next time**, what they sent is kept (its new text, quoted replies dropped, at most 1000 characters, `…|style|<address>`), and the ghostwriter gets it in its user turn as `<writer_example>` when it next writes to that person, from the inbox, a follow-up or a chat draft to that one person: style only, never its facts, and nothing in it can open or close a tag.\n\nSend + allow and Approve + allow are refused before anything is done unless their setting is in training (422 `cant_allow`) and the person's list has room (409 `learned_full`, at most 200 a person); allowing failing afterwards never undoes the send. Putting Replies or Follow-ups in, or Suggested actions out, of training only holds more back and works without signed sign-ins; anything else needs a caller the API knows is that person. What it learned is the person's alone: listed on `GET /delegation` (`training.learned`, each with its `setting`), removed with `DELETE /delegation/learned/{id}`, and for the owner also in Take the lead's \"What it's learned\" list; it never reaches anyone else's list or Take the lead's prompts. A dial left on In training by an older version (mode `training`) moves to People I know with Replies and Follow-ups in training (`schema._move_training_off_the_dial`).\n\n**No model decides whether a reply goes.** The watcher's two model calls are unchanged and tool-less, so text in an email can at most change the verdict and the draft. After the draft is written, `handle_it.refusal` — plain code — decides, and anything it refuses becomes the usual card with the reason kept on it (`handle_it_reason`). It refuses when:\n\n- it's off, or the sender is a stranger and the setting isn't Bold, or on a server signed sign-ins are off (`signing_ok`: signed callers, or local login);\n- Gmail couldn't authenticate the sender, whatever the roster says;\n- the email isn't a question, request, scheduling, introduction or follow-up, or the classifier was less sure than the setting needs (0.9 on Easy ones, 0.8 otherwise);\n- the reply goes to anyone the email didn't already go to (its From, To and Cc, less the person's own and the Executive's addresses), leaves out the sender, or goes to more than 10;\n- the email's subject, the sender's new words, or the reply touch money, contracts, legal, hiring, pay, layoffs, the board, investors, mergers, the press, health, or credentials and secrets (passwords, logins, tokens, API keys); or the reply carries an amount, a percentage or a link (a scheme, `www.`, a bare host with a path such as `bit.ly/…`, or a bare host on a common top-level domain) unless it's Bold and at least 0.9 sure, or runs over the setting's length (400, 1200 or 2000 characters);\n- the draft carries any flag but *others on the thread* or *Executive on the thread* (they asked if it's an AI, recipients were trimmed, …);\n- it already sent one in this thread in the last day, or the person's last message in the thread was itself sent on its own (no auto-reply ping-pong);\n- the day's limit is reached (`DELEGATION_HANDLE_IT_MAX_SENDS_PER_DAY`, default 20, within the watcher's drafts limit), or it can't be counted. Any error in the rules counts as a refusal.\n\nA reply the rules allow gets a card with `gate_mode` `auto_execute`, and the watcher sends it at once through `reply_send.send_on_its_own`, the second and last door into the send path (an AST test pins both callers: the approve route and the watcher). It runs the same send-time checks as a tap — switches, mailbox, draft, recipients, the claim and the last re-read — with no caller, and adds its own: the card must be `auto_execute`, Handle it for me still on with the setting still allowing that sender (or, for a follow-up, that recipient), signing still on, the once-a-thread-a-day rule and the daily limit counted again, and the draft untouched since it was saved (an edit in Gmail means the person has taken it over: `draft_changed`, the card waits for them). Every refusal hands the card back to the person (`decision_ledger.hand_back`, a compare-and-set to `propose`), with the reason kept on it when there are words for it, and a failure never stops the scan. Every card it left for the person says why on Today (`waited_because` on `GET /delegation/replies`). A reply sent on its own finishes as `executed` (not approved), is recorded in `delegation_handled` (for the per-thread and daily rules) and writes a private `delegation_reply_handled` row; an unconfirmed one is settled by the reconciler the same way. No History note is taken from it, since notes come only from the person's own words. It runs inside the watcher's scan, so it stops while the Executive is paused.\n\n**Follow-ups as you** (`delegation.follow_ups`). While Handle it for me is on, the watcher's scan also looks at the person's own sent mail, at most once an hour (`LOOK_EVERY`), for an email of theirs that asked something (a question mark in their own words), is 3 to 10 days old, went to at most 10 people other than the Executive, and is still the last message in its thread. Plain code picks it; each gets one follow-up ever (its `delegation_inbox_messages` row), at most two a look, within the drafts limit. The ghostwriter, tool-less as always, writes a short nudge in their voice from the thread, saved as a draft in that thread to exactly the people the email went to. `handle_it.follow_up_refusal` — plain code — decides whether it goes: by the setting it never goes on Easy ones, goes to their team and contacts on People I know and to anyone they wrote to on Most mail (`follow_up_refused` otherwise: `follow_up_level`); it also refuses on any change of recipients, a sensitive topic, an amount or a link, more than 600 characters, a flag, and the same per-thread and daily counts as replies. It goes through `send_on_its_own` on an ordinary `delegation_reply` card marked `source: follow_up`, which rechecks the setting for that recipient. A refused one waits on Today as **Follow-up waiting**, and closes by itself (its untouched draft deleted) when anyone answers in the thread first.\n\n**What it sent** is the person's alone: `GET /delegation/handled` lists the last 7 days (who, subject, the reply, the questions it left them and a link to the thread in their mailbox), and the Handle it for me tab shows it with how many went today, under its picker.\n\n### Take the lead as you\n\nOn Settings → Act as me, Handle it for me is one dial: **Off**, **Easy ones**, **People I know**, **Most mail** and, for the owner, **Everything**, which uses **Take the lead** (`PUT /delegation/take-the-lead`, one row `person:<id>` in `take_the_lead`; turning it on turns Handle it for me on). While it is on, `handle_it.refusal` drops the setting's limits: strangers, the classifier's confidence, amounts, and the length up to a 4000-character ceiling. A reply with a link still waits for a tap (refusal `link`). In their place it checks the company's and the person's own added rules (`take_the_lead.reply_hit`, refusal `lead_rule`). Everything Handle it always keeps still holds: signed sign-ins, an authenticated sender, a reply kind, exactly the thread's people, the topics that always wait, draft flags, never twice in a row, one a thread a day and the daily limit. Follow-ups under it may go to anyone the person wrote to, with the same sensitive, amount, link and length checks plus the added rules. `reply_send.send_on_its_own` accepts the card while both switches are on. Each person adds and removes their own rules (`/delegation/take-the-lead/rules`). Removing one needs a caller the API can tie to them.\n\n\n## AI line on replies\n\nReplies written as a person can end with **\"Drafted and sent by my AI assistant.\"** (`delegation.disclosure.LINE`), by two switches that are each person's own (`PUT /delegation/disclosure`, one row per person in `delegation_disclosure`, NULL following the install): **Handle it**, on by default (`AI_DISCLOSURE_HANDLE_IT`), for a reply Handle it for me will send on its own, which nobody reads before it goes; and **Approved sends**, off by default (`AI_DISCLOSURE_APPROVED_SENDS`), for one that waits on a card for them to send, since they read it first. The line is written into the reply when it is drafted (`disclosure.sign`, in `inbox._consider` and `follow_ups`), once the plain-code checks have decided whether it goes on its own, so the card, the mailbox draft and what is sent are the same words and Send's draft-changed checks see them; a switch changed later applies to the next reply, and a reply drafted to go on its own that is handed back keeps its line for the person to edit. `AI_DISCLOSURE` off turns both off and hides the card. Turning a switch on only adds the line, so it needs no signed sign-in; turning one off does. Each tab shows its own switch under Advanced (**AI line on drafts you send** on Act as me, **AI line on replies it sends** on Handle it for me), and turning off the Handle it line asks first.\n\n## The mailbox client\n\n`delegation.gmail.DelegateGmail` talks to the Gmail REST API directly and is **never registered with the MCP gateway**, so the model reaches the mailbox only through the typed handler. The credential is one file per person in `DELEGATION_GOOGLE_CREDENTIALS_DIR`, named from a hash of the address (0600 in a 0700 directory), minted by `scripts/connect-own-gmail.py` on the Executive's own OAuth client with the scopes `gmail.readonly` and `gmail.compose`. It never lives in `WORKSPACE_MCP_CREDENTIALS_DIR`, where workspace-mcp picks a credential by address. Besides reading threads and saving drafts it lists the inbox and checks whether they have written to an address, reads one message or draft, lists the person's send-as addresses and deletes a draft. Its **one send method**, `send_draft`, sends an existing draft by its id and nothing else — never `messages.send`, which sends any text it is given — and unit tests pin the method set, the endpoint, the request body and its single caller. A failed request says whether it may have been carried out anyway (a timeout after connecting, a 5xx), which is what the send path needs to know. A parsed message carries when it arrived, whether it is bulk, a bounce or a calendar invite, and whether Gmail's authentication results vouch for its sender.\n\n`gmail_status` answers `connected`, `not_configured`, `needs_reconnect` (Google refused the saved sign-in — an app in Testing mode has its tokens expire after 7 days; a rate limit, though Gmail may send it as a 403, is an `error` to retry, not a reconnect), `mismatch`, `no_email`, `shared_mailbox` or `error`. `shared_mailbox` means the person's address *is* the Executive's; it is refused before asking Google, because then everything the Executive writes would look like theirs. The gateway closes the other door: every `google_workspace__*` call must act as the Executive's own account, and a `user_google_email` naming anyone else is refused and audited (see Integrations).\n\n### Outlook\n\nA person may connect an Outlook mailbox instead (work, school or personal), with `scripts/connect-own-outlook.py`: a device-code sign-in on the Executive's own Entra app (`MS365_MCP_CLIENT_ID`, tenant `MS365_MCP_TENANT_ID` or `common`) asking for `User.Read`, `Mail.ReadWrite`, `Mail.Send` and `offline_access`. It writes the same per-person file with `\"provider\": \"microsoft\"`, so a person has one mailbox for Act as me, and `gmail_for` hands back `delegation.outlook.DelegateOutlook`, which keeps `DelegateGmail`'s methods, return types and errors, so every caller above runs unchanged. It talks to Microsoft Graph directly, never through the Microsoft 365 MCP server the Executive's own Outlook uses, and is never registered with the gateway. Microsoft rotates the refresh token on use; the new one is written back into the file (atomically, keeping every other key, and only if the file still holds the old one). Graph is asked for immutable ids, so a sent draft keeps its id; a thread is Outlook's `conversationId`. Gmail's labels are mapped onto what the callers read: `SENT` only for mail in their Sent Items folder (a From line set to their address by someone else never counts), `DRAFT`, `INBOX`, and Focused Inbox's Other read as a tab. A sender counts as authenticated only when the topmost `Authentication-Results` — the one Exchange wrote, above anything the sender added — holds exactly one DMARC verdict, a pass for From's own domain, and Exchange Online Protection's own `compauth=` verdict, so a header the sender wrote on mail EOP never stamped doesn't count. `delete_draft` refuses anything that isn't a draft, and deletes with the draft's etag (`If-Match`), so a draft sent in between — it keeps its id — is left alone. No client secret is ever written into a person's file, and Graph has no signature setting to read.\n\n## Privacy\n\nWhat a person's mailbox touches is theirs. For the principal that means private to the principal, as every private row is. For a team member it means theirs alone, the principal included: an audit row carries `private_to_person` (set by `audit.rows_for_person` around the inbox watcher, a card's Send and Dismiss and their settings changes, and by `people_tools.audit_row_owner` on a turn that read their mail) and is left out of every audit read — the log, a session's timeline, a row by id, the brief — with only the usage totals counting it; their reply cards are theirs alone (above); and the owner's view of their use is counts only (drafts and sends in 30 days, and whether their inbox watcher is on). The conversation itself becomes its owner's alone before the mailbox is first read: `ghostwrite_email` marks the session `mail_private` (`session_store.mark_mail_private`, creating a channel adapter's row early, with its owner) and refuses to read the mailbox if that can't be stored or the conversation already belongs to someone else (which it then leaves unmarked); from then on only its owner may open it (`chat._session_access`), and working-style learning skips it. Every later turn there starts private (`settings.pin_turn_delegation` reads the flag and fails closed, setting `touched_mail`), so a follow-up answered from history alone is still private to its owner and teaches no memory, and the web chat's rows before the turn (the inbound message and the knowledge lookup) are theirs too. It does not start locked down: the lockdown is `read_mail`, set only by a turn that reads the mailbox or notes itself, and it is never carried into the next turn, because history keeps only the speaker's words and the Executive's replies, never the mail a tool returned. Their next message is them asking again, having read that reply, so everything runs again there. Anyone else speaking in it is not offered Act as me.\n\nOnce `touched_mail` is set, every audit row the turn writes is private (`people_tools.audit_row_private_to_principal`), and a team member's is theirs alone: the tool row (its input and result redacted, since `ghostwrite` is a sensitive tool name), the reply's `chat_turn` row that carries the preview, the model-call rows, and the background passes, which run under `private_rows`. The Honcho peer and department syncs are skipped, because peer memory is read on other people's turns. No memory is learned from the turn at all: the episodic, open-loop and working-style passes are skipped too, since its reply quotes a draft built from other people's mail. The `delegation_*` audit events are always private and carry metadata only — ids, counts and flags, never the draft or the thread. The inbox watcher is private the same way: every row a scan or a card action writes is its person's alone, and it starts no chat turn, alert, scheduled action or workflow run and teaches no memory.\n\nThe turn also keeps one door shut (`delegation.lockdown`). Anyone can put text in the inbox, and that text could try to steer the model, so from the round that calls `ghostwrite_email` or one of the mailbox reads — a round's tools run together — until the turn ends, the dispatch guard refuses only what opens the open internet or reaches everyone: outside fetches (`read_document`, research, the watchlist, `load_mcp_server`, and any MCP `call_tool` outside the private-turn set of reads and recipient-checked sends), `run_script` and `run_python_job`, workflows (they run later, unattended, and may fetch or script), broadcasts, department messages and alerts, and changes to who is on the roster or holds authority (`archive_person`, `set_department_head`, `resolve_roster_request`), and text that steers later turns (`schedule_followup`, whose intent runs unattended when due, and goals and decision outcomes, shown to every later turn). Everything else the person asks for runs, because it is fenced on its own: DMs and `message_person` reach only the roster, invites name attendees by person id, the Executive's own email checks every recipient against the roster, standing facts and profile edits keep only the person's own words, and a workflow drafted in chat is saved only once a person confirms it. `upsert_person` runs only for a contact the person asked for (`speaker_named_contact`: a contact, never the team, an approval scope or a chat account, with a word of the name in what they typed, in a message that asks to add, save or change someone, a new contact's address one they typed or one that sent the mail the turn read under the contact's name (`TurnDelegation.mail_senders`), never one the mail's text only mentions, and on an update a changed address they typed), since the roster is what the send checks trust. Any other contact add is refused with a pointer to an approval card (`lockdown.CONTACT_REFUSAL`), so the Executive leaves an `add_contact` card in the chat rather than asking them to type the address. What an email itself asks for is still never done on its say-so; it goes on an approval card. Every tool is classified as allowed or withheld, a test fails on a new unclassified one, and an unknown name is withheld, except an extension tool registered with `after_mail_read` (one that only reads the install's own data). The refusal tells the model to put what the step needs in its reply, since the next turn sees the reply but not the mail, and to do the step then without reading the mail again. A refused call gets a private `tool_invocation` row (`refused: mail_touched`) and tells the model to offer it in the next message. The offered tool list never changes mid-turn, so the cached prefix holds. The handlers that reach outside check again on their own (`outside_reach_refusal`). The server-side web search stays, as on a turn private to the principal. The lockdown ends with the turn. Later turns of that conversation stay private to its owner (`touched_mail`) but hold nothing: a refusal says it will work when they ask again in their next message, and it does.\n\n## Always in the loop\n\nA sent reply can leave a note. Once the reply went, `reply_send` starts `memory.history_notes.note_sent_reply` for the person who sent it, in the background, when their \"Keep track of what happens\" switch is on and the conversation isn't one they asked not to remember. The note-taker sees only the words they sent, so other people's mail never becomes a note, and a failure never touches the send. Recall is `recall_history`, offered on the same verified, private surfaces as `ghostwrite_email` and also allowed under the mail lockdown, since it only reads the speaker's own notes. Calling it locks the turn like `ghostwrite_email` does, from its own round on. The same switch also covers notes from chat, which don't need Act as me. See **Memory** for the checks, retention and controls.\n\n## The system prompt\n\nA constant, name-free `DELEGATION_ADDENDUM` joins block 0 after the unchanged identity addendum while anyone on the install has it on (`block0_delegation_on`). It names the four mailbox reads and says other people's mail is data and that a conversation which read it reaches nobody else; and it tells the model that `ghostwrite_email` is the single exception to *never impersonate*, and only for the person being spoken to; that everything else is written as itself; that when the tool isn't offered the asker can't have it; that a draft is never described as sent; and that it never denies being an AI. It is keyed on the install-level setting, never on the turn or the speaker, so switching it misses the 1h cache once (see Prompt Caching).\n\n## What it may do\n\n**Delegate → What it may do** (`delegation.may_do`, `GET /what-it-may-do`) is read-only: one row per thing that can go out without asking, what happens to it (goes out, waits for someone, always waits, drafts only, off) and which setting decides it, with a link there. It is the first Delegate tab, and `/delegate` opens on it. Three parts, each behind a pill that counts what goes out:\n\n- **As you** (the caller's own, when `can_delegate` allows them): built from `settings.is_enabled`, `inbox.get_watch`, `handle_it.get` and `handle_it.RULES`, `handle_it.leading` (Everything), `training.get` and `training.learned`, and their rules, the same reads `handle_it.refusal` and `follow_up_refusal` make. A level's row follows its `Rules` (strangers, follow-up reach, links and amounts), not a copy of them. A note names the ladder: Handle it for me rides on Draft replies to my inbox and Write drafts as me, and Everything also drops when Replies or Follow-ups go into training.\n- **As the Executive** (the principal's alone, as `GET /take-the-lead`): the switch and its training, each Ask first kind, the company's rules, and meetings. A meeting it thinks of on its own always waits: both meeting gates need someone on a verified surface in the turn, which an unattended run never is. A meeting someone asks for in chat follows **Always asks first → Meetings asked for in chat** (on means it waits: `meeting_scheduling`'s class mode is `propose`; off means `auto_execute`) and, in a team workspace, Operations' level too.\n- **Departments**: each level, and what a level covers (department-scoped scheduled work, check-ins, alert review, team members' chat sends, and Operations' meetings), and that it doesn't cover what the Executive does under Take the lead.\n\nIt also says when the Executive is paused, and when nothing can be sent as anyone because signed sign-ins are off. Nothing on it writes or reads mail. A contact, someone not on People, or a request with no caller (outside local login) gets 403.\n\n## How far it goes as you\n\nOne setting replaces the switches that used to turn each other off out of sight. The UI shows it as two pickers (`ReachCard.tsx`): **What it writes as you** (`WritesCard`) on the Act as me tab and **What it sends on its own** (`SendsCard`) on the Handle it for me tab; What it may do links each row to its own picker. Its steps, each adding to the one before: **Off**, **Drafts when I ask** (Write drafts as me), **Drafts for my inbox** (Draft replies to my inbox), then the Handle it for me steps that send, **Easy ones**, **People I know** and **Most mail** (`careful`, `balanced`, `bold`), and for the owner **Everything** (Take the lead as you). Act as me shows the first three as **Off**, **When I ask** and **Draft replies automatically** (any sending step reads as Draft replies automatically there). Handle it for me shows **Off** (saved as the inbox step) and the sending steps, and opens only once Act as me is at Draft replies automatically, with a button that turns that on; moving Act as me below it says Handle it for me stops too. `PUT /delegation/reach` (`{step}`) moves it, and `reach_of` reads the step back from the switches, so the stored switches stay the source of truth and every gate reads them as before.\n\nGoing down turns the switches above the target off, highest first (`_lead_off`, then Handle it, then the inbox watcher, then Write drafts as me), so nothing is ever on above a switch that's off; the UI says what stops and asks before it saves. A lower sending level only holds more back and is set directly, so it needs no signed sign-in. Going up calls each switch's own route in order, so every check it makes still applies: the mailbox connected, signed sign-ins for sending, the owner alone and not in training for Everything. The first that refuses stops the move at a whole step and answers with that route's error. **In training** (Replies and Follow-ups together, with **Train follow-ups too** to split them) and, at Everything, **Your rules** sit under the Handle it for me picker, and **Learn from my edits** (drafts training) under the Act as me one; neither picker changes training.\n\n## Surfaces\n\n- **Settings → Act as me** (`ActAsMeCard`, hidden unless `GET /delegation` answers, so a team member sees it once the owner lets them): the mailbox connection (`provider` says which) with both connect commands (Gmail and Outlook) and **Check again**, **What it writes as you** (above), with the inbox watcher's status under Draft replies automatically (in plain words, when it last checked, **Check now** and **Also save inbox replies in my Gmail Drafts**), and **How I write**: length and tone, a greeting per audience (`{first}` is their first name), the sign-off, habits and never-rules in fields that grow to show every line, the signature with **Refresh from Gmail** and **Don't add my signature** (or **Add my Gmail signature** when none is added; on Outlook only **Don't add my signature**, with why), and each example quoted with **Remove examples**. The owner also gets **Let team members use it** where the install allows it, with each team member who has it on listed by name and counts only.\n- **Today → Replies waiting** (`RepliesWaiting`, the top of the left column; hidden unless `GET /delegation/replies` answers with cards): each card shows who wrote and who they are to you, whether their address was verified, the subject, **They wrote** as plain text, your draft, **Decide before sending** (the open questions) and its warnings, with **Send** (a confirm naming who it goes to, and a second one when that or the thread changed), **Edit** (a text box on the card with Save and Cancel), **Open in Gmail** or **Open in Outlook** when the reply is in their Drafts, and **Dismiss**.\n- **Setup status**: a **Your own mailbox (Act as me)** light (`your_gmail`), amber while the inbox watcher can't reach the mailbox, is being rate-limited or has 25 replies waiting.\n- **Delegate** (main menu): **What it may do** (above, where `/delegate` lands), **Act as me** (where `/settings/act-as-me` lands), **Handle it for me** (which step the dial is at, with **Change in Act as me**, then **What it sent**: how many went today and what it sent this week, as you) and **Take the lead** (the switch, then **Always asks first**, shown even while the switch is off and ending in **Meetings asked for in chat**, and the company's rules, as the Executive). Each switch that turns another off says so beside it. The pause is on **Settings → Your Executive**.\n- **API**: `GET`/`PUT /delegation`, `GET`/`PUT`/`DELETE /delegation/voice`, `POST /delegation/voice/learn`, `POST /delegation/voice/describe`, `POST /delegation/voice/signature`, `PUT /delegation/inbox` (`{enabled?, mailbox_drafts?}`), `POST /delegation/inbox/check`, `GET /delegation/replies`, `PUT /delegation/replies/{id}/text`, `PUT /delegation/handle-it`, `PUT /delegation/reach` (`{step}`, the dial), `PUT /delegation/training`, `DELETE /delegation/learned/{id}` and `GET /delegation/handled` — the caller's own delegation only — and `PUT /delegation/team`, the owner's switch (see API Reference). `GET /what-it-may-do` is the read-only summary above. Send is `POST /decisions/{id}/approve`; Dismiss is `POST /decisions/{id}/reject`.\n- **Evals**: a scenario's `delegation:` block runs the turn against an in-memory mailbox (`evals.mailbox.ScenarioMailbox`) and hands the saved drafts to the judge (`delegation_001`–`003`). A `type: inbox` scenario runs the watcher's two model calls on one thread: whether it drafts must match the scenario, and a draft is judged on saying nothing the person hadn't, copying no link or address, and listing every open question (`delegation_inbox_001`–`007`; the last checks a draft never claims anything was sent).\n\nActing within rules the person sets and standing in for them are later, separate changes, each behind its own switch, off by default.",
"mermaid": "flowchart TD\n Ask[\"Principal or team member, verified<br/>'reply to Dana as me: yes'\"] --> Pin[\"pin_turn_delegation<br/>may have it? on? verified? private? attended?\"]\n Pin -->|\"offered\"| Loop[\"Executive tool loop<br/>with ghostwrite_email\"]\n Pin -->|\"not offered\"| Self[\"writes as itself<br/>(unknown tool this turn)\"]\n Loop --> Tool[\"ghostwrite_email handler<br/>caps, mailbox check, recipients in code\"]\n Tool -->|\"touched_mail\"| Private[\"turn's rows and conversation<br/>theirs alone, no memory\"]\n Tool --> Client[\"DelegateGmail or DelegateOutlook<br/>REST, outside the MCP gateway\"]\n Tick[\"Scheduler tick or Check now<br/>Draft replies to my inbox on\"] --> Scan[\"inbox scan, rows theirs alone<br/>skip rules, limits, ledger\"]\n Scan --> Client\n Client --> Box[(\"The person's own Gmail or Outlook\")]\n Scan --> Classify[\"classifier, no tools<br/>needs a reply? kind, confidence\"]\n Classify -->|\"worth a draft\"| Gw\n Voice[(\"delegation_voice<br/>How I write\")] --> Gw[\"ghostwriter<br/>no tools: voice + intent + thread\"]\n Tool --> Gw\n Gw --> Lint[\"lint: links and addresses<br/>only the person's own\"]\n Lint --> Draft[\"create_draft, threaded\"]\n Draft --> Box\n Draft --> Chip[\"chat chip: open the draft<br/>chat never sends\"]\n Draft --> Card[\"Today: Replies waiting<br/>their own card\"]\n Card -->|\"Send, confirmed\"| SendPath[\"reply_send: checks again,<br/>claim, send the draft by id\"]\n SendPath --> Box\n class Ask entry\n class Pin compute\n class Loop compute\n class Self compute\n class Tool compute\n class Private compute\n class Client compute\n class Tick entry\n class Scan compute\n class Classify compute\n class Box external\n class Voice storage\n class Gw compute\n class Lint compute\n class Draft hot\n class Chip entry\n class Card entry\n class SendPath hot",
"generated_at": "2026-10-15T19:07:34Z"
}
diff --git a/packages/core/openexecutive/guide/prebuilt/delegate.json b/packages/core/openexecutive/guide/prebuilt/delegate.json
index e09cba9e..8c2badc6 100644
--- a/packages/core/openexecutive/guide/prebuilt/delegate.json
+++ b/packages/core/openexecutive/guide/prebuilt/delegate.json
@@ -1,7 +1,7 @@
{
"section_id": "delegate",
"title": "Delegate",
- "markdown": "**What it is:** The place where you decide what the Executive may do without asking you. **Delegate** is in the main menu. It has four tabs: **What it may do**, **Act as me**, **Handle it for me** and **Take the lead**. Clicking **Delegate** opens **What it may do**.\n\n**What it does:**\n\n- **What it may do** lists everything that can go out without asking you, who it goes out as, and the setting that allows it. It only reads. Nothing on it changes a setting.\n- **Act as me** lets the Executive write email drafts *as you*, from your own Gmail or Outlook mailbox. You send them. It can also write first replies to mail in your inbox that needs you.\n- **Handle it for me** lets it send some of those replies, and some follow-ups, on its own from your mailbox.\n- **Take the lead** (the owner only) lets the Executive act in its own name on what it finds, without waiting to be asked.\n- Normally the Executive writes only as itself, from its own email account. Nothing goes out as you unless you set it up here.\n\n**How to use:**\n\n1. Click **Delegate** in the sidebar. (On a phone, open the menu with the button at the top left.)\n2. Read **What it may do** to see what goes out on its own today.\n3. Open **Act as me**, connect your mailbox, and pick what it writes as you.\n4. If you want replies sent for you, open **Handle it for me** and pick how much it sends on its own.\n5. If you are the owner, open **Take the lead** to let the Executive act in its own name.\n\n**What it may do:**\n\n- At the top, **Who writes and who sends** plays a short animation of mail moving between your inbox, the Executive, you and the person it goes to. On its own it plays one scene per tab. Tap any option of **What it writes as you**, **What it sends on its own** or **Take the lead** to see what that option does. Tapping an option there changes no setting. **Hide** folds the card away in this browser, and **Show who writes and who sends** brings it back.\n- Three pills: **As you**, **As the Executive** and **Departments**. The number on each pill is how many things go out without asking.\n- **As you** covers your own mailbox: emails you ask for in chat, inbox replies, what Handle it for me sends, what is in training, what it has learned and your own rules.\n- **As the Executive** covers Take the lead, its Always asks first switches, the company's rules and meetings. Only the owner sees this pill.\n- **Departments** shows each department's authority level and what that level covers.\n- Each row has **What**, **Then** and **Why**. The dot by **Then** shows what happens: green goes out, amber waits for you, red always waits, grey is drafts only or off. **Why** links to the tab or page where the setting lives.\n- While the Executive is paused, a note at the top says nothing runs on its own, with a **Resume** link.\n- Someone who is not on the People list sees \"Only people on the team can see this.\"\n\n**Act as me:**\n\n- Who can use it: the owner. Team members can use it once the owner turns on **Let team members use it** (under **Advanced** on this tab). That switch shows only when the install allows it. Anyone else sees \"Act as me isn't available to you here.\"\n- Each person connects their own mailbox and turns it on for themselves. What it reads in your mail, the drafts it writes and your reply cards are yours alone. The owner sees only each team member's name, how many drafts they had written and sent in the last 30 days, and whether inbox replies are on. A conversation in which it read someone's mail can be opened only by that person.\n- **Your mailbox**: until it is connected, the card shows the command to run on a computer with a browser (one for Gmail and, where the install supports it, one for Outlook). Sign in as yourself, put the file it writes where the API reads it, then click **Check again**. Once connected it shows \"Connected to\" your address. It won't connect the Executive's own address as yours.\n- **What it writes as you**: \"Nothing goes out until you send it.\" Pick one:\n - **Off**: the Executive only writes as itself.\n - **When I ask**: ask in chat, \"reply to Dana as me: yes to the 5th\", and the draft waits in your Gmail or Outlook Drafts.\n - **For my inbox too**: it also writes a first reply to mail that needs you, and puts it on Home.\n- You can't move up from **Off** until your mailbox is connected. Moving down asks first, says what stops, and saves when you click **Move down**. Moving to **When I ask** stops inbox replies. Moving to **Off** stops everything it writes as you and turns **Read my calendar** off. Either one also stops Handle it for me if it was sending.\n- **Learn from my edits** (a checkbox once you are above **Off**): when you change a draft before sending, tick **Do it like this next time** and it learns how you write to that person. Nothing more is sent.\n- **Read my calendar**: a switch. On, it reads your own calendar when you ask about your day or week in chat. It never changes your calendar. It stays off while **What it writes as you** is at **Off**. If your mailbox sign-in doesn't include your calendar, the card shows a command to run once to add it.\n- **Suggested actions**: meeting invites and messages your mail calls for. **Always ask** brings each one to you as a card, every time. **In training** also brings each one as a card; tap **Approve + allow** and it does that kind, with those people, on its own next time.\n- **What it's learned**: what it learned from your edits (drafts) and your approvals (suggested actions). Each item says when, how many times it has been used since, and an example. **Remove** forgets it, and it asks you again.\n- **Advanced** (closed by default) holds **How I write**, **AI line on drafts you send** (shown only when the install adds an AI line to mail) and, for the owner, **Let team members use it**.\n\n**Asking in chat:**\n\n- Ask in the web app (signed in), in a direct message to the Executive on Slack or Discord, or in a private Telegram chat: \"reply to Dana as me: yes to the 5th.\"\n- It saves a draft in your own Drafts and shows a card, \"Drafted an email as you to Dana — in your Drafts\". Asking in chat never sends anything.\n- It does not write as you in a shared channel or thread, on Google Chat, from an email, from a scheduled job or in anyone else's conversation.\n- If it isn't sure about something, it asks you instead of guessing.\n- There is a daily limit on drafts written as one person (50 a day unless the install changes it).\n\n**For my inbox too:**\n\n- About every five minutes it looks at new mail in your inbox. For mail that needs a personal reply from you (a question, a request, a meeting to arrange, an introduction or a follow-up), it writes a first reply and puts it at the top of **Needs you** on Home.\n- It only looks at mail that arrives after you turn it on. It leaves out newsletters, notifications, mailing lists, automatic mail, mail you are not in To or Cc on, mail you've already answered and anything that doesn't need you. Mail you answer within ten minutes never gets a draft.\n- The first reply only acknowledges. It repeats only what you've already said in the thread, commits you to nothing and lists what's left for you to decide. Someone you've never written to gets a short holding reply.\n- Under the picker you see how it is doing (for example, that your mailbox needs connecting again) and when it last looked. Click **Check now** to look straight away.\n- **Also save inbox replies in my Gmail Drafts** (or Outlook): off by default, so replies wait on their cards only. Tick it to keep each reply in your Drafts too.\n- On each card on Home: **Send** asks you to confirm who it goes to, then **Send now**. **Send + allow** (in training) sends it and lets replies to that person go on their own from then on. **Edit** changes the words on the card. **Open in Gmail** opens it when it is in your Drafts. **Dismiss** removes the card.\n- Limits: at most 5 drafts a check and 20 a day unless the install changes it, 2 a day per sender (1 for a stranger), and never more than 25 cards open. A card closes when the draft is sent or deleted in your mailbox, when you reply yourself, or after 7 days.\n\n**How I write (under Advanced):**\n\n- Shows your style as a few sentences, with where it came from (\"Learned from N of your sent emails\", or \"Set by you\") and whether it is locked.\n- **Describe it in your own words**: write how you write, the way you'd tell a new assistant (up to 2,000 characters). Buttons add common phrases, such as \"Short and to the point\" or \"No emojis\". Click **Write my style**; it shows the new style with new lines marked **New** and a sample reply. Click **Save** to keep it or **Change it** to edit your words. Nothing changes until you save.\n- **Learn from my sent mail** (or **Learn again from my sent mail**): reads your recent sent emails once and describes how you write. It needs your mailbox connected and is hidden while the style is locked.\n- **Fine-tune details** opens the fields: **Length** (short, medium, long), **Tone** (casual, neutral, formal), a **Greeting** **To your team**, **To your contacts** and **To anyone else** ({first} becomes their first name), **Sign-off**, **Habits** and **Never** (one per line), your **Signature** and **Examples of your writing**.\n- **Save changes** saves the fields. **Lock** stops it being relearned from your mail (you can still edit it); **Unlock** undoes that. **Reset** starts over. **Remove examples** drops the examples.\n- **Signature**: with Gmail, your signature is added to every draft. **Refresh from Gmail** picks up a change you made in Gmail, **Don't add my signature** stops adding it, and **Add my Gmail signature** brings it back. Outlook doesn't share signatures with apps, so Outlook drafts end with your sign-off.\n- **AI line on drafts you send**: a checkbox for whether drafts you approve and send end with the install's AI line. Off unless the install starts it on. A change applies to the next reply it writes.\n\n**Handle it for me:**\n\n- It sends from your own mailbox, on its own, some of the replies Act as me writes for your inbox, and some follow-ups.\n- It needs **For my inbox too** on the Act as me tab. Until then the card says so and offers **Turn on For my inbox too**, or **Connect your mailbox in Act as me** if your mailbox isn't connected.\n- Someone who can't have Act as me sees that Handle it for me isn't available to them.\n- **What it sends on its own**: pick one:\n - **Off**: every reply waits for you to send.\n - **Easy ones**: only short replies to people you know, when it's very sure. Follow-ups are written for you and wait on Home.\n - **People I know**: replies to people you know. Strangers, links and amounts wait for you. Follow-ups go to your team and contacts when they haven't answered a question of yours in a few days.\n - **Most mail**: also strangers and longer replies, and links or amounts when it's very sure. Follow-ups go to anyone you wrote to who hasn't answered a question of yours in a few days.\n - **Everything** (the owner only): it decides what to send as you. Replies with a link, the topics that always wait and your rules still hold it back.\n- The sending steps need signed sign-ins on the server. Without them they are greyed out with \"Needs signed sign-ins on this server.\" Moving down asks first and saves when you click **Move down**.\n- **In training**: every reply comes to you first. Tap **Send + allow** on a card and it handles that person on its own from then on, within the step you picked. You can tick it at **Off** before moving up. **Train follow-ups too** (shown while in training) keeps follow-ups in training as well; untick it to let follow-ups go out while replies stay in training. **Everything** opens only once it's out of training, and training can't be turned on at **Everything**.\n- Money, contracts, legal, hiring, the press and passwords always wait for you. It never writes to anyone the email didn't go to. A reply that names the Executive waits too.\n- **Your rules** (at **Everything**): replies matching one wait for you, on top of the company's rules. Pick **A person**, **A company**, **Words** or **An amount**, type the value and click **Add rule**. **Remove** deletes one.\n- **What it sent** (while it is on): \"Sent N replies on its own today\", then each reply and follow-up from the last week: who it went to, the subject, **Still yours to answer** for questions it left for you, and **Open in your mailbox**.\n- **Who it's allowed to handle**: the people you allowed with **Send + allow**. **Remove** takes one off, and it asks you again.\n- **AI line on replies it sends** (under **Advanced**, when the install adds an AI line): on by default. Turning it off asks you to confirm with **Turn it off** or **Keep it on**.\n- Limits: 20 replies sent on its own a day unless the install changes it, and one a conversation. Past the limit, replies wait on cards.\n\n**Take the lead:**\n\n- The owner's alone. Anyone else sees \"Only the account owner can turn this on.\"\n- **Off**: when it looks over your day, it tells you what it would do, and you do it.\n- **In training**: everything it would do comes to you as a card on Home first. What you allow, it does on its own from then on.\n- **On**: it acts on what it finds while it looks over your day: it messages people, books meetings and starts workflows. Anything under **Always asks first** waits for a yes.\n- **In training** and **On** need signed sign-ins on the server.\n- **What it's learned**: the actions you allowed with **Approve + allow** on a card, or **Send + allow** on an Act as me reply. **Remove** takes one off. Something you approved unchanged three times shows as a suggestion with **Allow**.\n- **Always asks first**: a switch for each: **Money**, **Contracts and legal**, **Hiring and people decisions**, **Deleting, cancelling or sharing**, **Someone new** and **Big sends** (company-wide or department-wide, or more than five people). These wait for you, or for whoever approves that area, with a card on Home. **Meetings asked for in chat** is the last row: meetings you or a teammate ask it to book (in a team, Operations must also act on its own). A meeting it thinks of itself always waits. While Take the lead is off, only the meetings row applies.\n- Department levels don't hold what it does here. The switches and rules do.\n- **Company rules**: anything matching one always waits for a yes, for the Executive and for everyone's sending as themselves. Add them the same way as **Your rules**.\n- **Pause** on **Settings → Your Executive** stops everything on this tab. Anything you tap **Send** or **Approve** on still goes.\n\n**Example prompts:**\n\n- \"Reply to Dana as me: yes to the 5th, and ask her to send the deck first.\"\n- \"Write to the Acme team as me and push our call to Thursday.\"\n- \"What's on my calendar tomorrow?\" (with **Read my calendar** on)\n",
+ "markdown": "**What it is:** The place where you decide what the Executive may do without asking you. **Delegate** is in the main menu. It has four tabs: **What it may do**, **Act as me**, **Handle it for me** and **Take the lead**. Clicking **Delegate** opens **What it may do**.\n\n**What it does:**\n\n- **What it may do** lists everything that can go out without asking you, who it goes out as, and the setting that allows it. It only reads. Nothing on it changes a setting.\n- **Act as me** lets the Executive write email drafts *as you*, from your own Gmail or Outlook mailbox. You send them. It can also write first replies to mail in your inbox that needs you.\n- **Handle it for me** lets it send some of those replies, and some follow-ups, on its own from your mailbox.\n- **Take the lead** (the owner only) lets the Executive act in its own name on what it finds, without waiting to be asked.\n- Normally the Executive writes only as itself, from its own email account. Nothing goes out as you unless you set it up here.\n\n**How to use:**\n\n1. Click **Delegate** in the sidebar. (On a phone, open the menu with the button at the top left.)\n2. Read **What it may do** to see what goes out on its own today.\n3. Open **Act as me**, connect your mailbox, and pick what it writes as you.\n4. If you want replies sent for you, open **Handle it for me** and pick how much it sends on its own.\n5. If you are the owner, open **Take the lead** to let the Executive act in its own name.\n\n**What it may do:**\n\n- At the top, **Who writes and who sends** shows what happens to your mail under each option. Pick a tab (**Act as me**, **Handle it for me** or **Take the lead**) and one of its options. Three answers sit on top: who writes it, whose name is on it and who presses Send. Under them the steps appear one at a time and stay on screen, for example Dana emails you, you ask in chat, the Executive writes the draft, you tap Send. **Handle it for me** shows the same five emails at every level, each marked **Sent as you** or **Waits for you**, so you can see more go out on their own as you move up. Tapping there changes no setting. **Play again** replays the steps, **Hide** folds the card away in this browser, and **Show who writes and who sends** brings it back.\n- Three pills: **As you**, **As the Executive** and **Departments**. The number on each pill is how many things go out without asking.\n- **As you** covers your own mailbox: emails you ask for in chat, inbox replies, what Handle it for me sends, what is in training, what it has learned and your own rules.\n- **As the Executive** covers Take the lead, its Always asks first switches, the company's rules and meetings. Only the owner sees this pill.\n- **Departments** shows each department's authority level and what that level covers.\n- Each row has **What**, **Then** and **Why**. The dot by **Then** shows what happens: green goes out, amber waits for you, red always waits, grey is drafts only or off. **Why** links to the tab or page where the setting lives.\n- While the Executive is paused, a note at the top says nothing runs on its own, with a **Resume** link.\n- Someone who is not on the People list sees \"Only people on the team can see this.\"\n\n**Act as me:**\n\n- Who can use it: the owner. Team members can use it once the owner turns on **Let team members use it** (under **Advanced** on this tab). That switch shows only when the install allows it. Anyone else sees \"Act as me isn't available to you here.\"\n- Each person connects their own mailbox and turns it on for themselves. What it reads in your mail, the drafts it writes and your reply cards are yours alone. The owner sees only each team member's name, how many drafts they had written and sent in the last 30 days, and whether inbox replies are on. A conversation in which it read someone's mail can be opened only by that person.\n- **Your mailbox**: until it is connected, the card shows the command to run on a computer with a browser (one for Gmail and, where the install supports it, one for Outlook). Sign in as yourself, put the file it writes where the API reads it, then click **Check again**. Once connected it shows \"Connected to\" your address. It won't connect the Executive's own address as yours.\n- **What it writes as you**: \"Nothing goes out until you send it.\" Pick one:\n - **Off**: the Executive only writes as itself.\n - **When I ask**: ask in chat, \"reply to Dana as me: yes to the 5th\", and the draft waits in your Gmail or Outlook Drafts.\n - **Draft replies automatically**: it also writes a first reply to mail that needs you, and puts it on Home.\n- You can't move up from **Off** until your mailbox is connected. Moving down asks first, says what stops, and saves when you click **Move down**. Moving to **When I ask** stops inbox replies. Moving to **Off** stops everything it writes as you and turns **Read my calendar** off. Either one also stops Handle it for me if it was sending.\n- **Learn from my edits** (a checkbox once you are above **Off**): when you change a draft before sending, tick **Do it like this next time** and it learns how you write to that person. Nothing more is sent.\n- **Read my calendar**: a switch. On, it reads your own calendar when you ask about your day or week in chat. It never changes your calendar. It stays off while **What it writes as you** is at **Off**. If your mailbox sign-in doesn't include your calendar, the card shows a command to run once to add it.\n- **Suggested actions**: meeting invites and messages your mail calls for. **Always ask** brings each one to you as a card, every time. **In training** also brings each one as a card; tap **Approve + allow** and it does that kind, with those people, on its own next time.\n- **What it's learned**: what it learned from your edits (drafts) and your approvals (suggested actions). Each item says when, how many times it has been used since, and an example. **Remove** forgets it, and it asks you again.\n- **Advanced** (closed by default) holds **How I write**, **AI line on drafts you send** (shown only when the install adds an AI line to mail) and, for the owner, **Let team members use it**.\n\n**Asking in chat:**\n\n- Ask in the web app (signed in), in a direct message to the Executive on Slack or Discord, or in a private Telegram chat: \"reply to Dana as me: yes to the 5th.\"\n- It saves a draft in your own Drafts and shows a card, \"Drafted an email as you to Dana — in your Drafts\". Asking in chat never sends anything.\n- It does not write as you in a shared channel or thread, on Google Chat, from an email, from a scheduled job or in anyone else's conversation.\n- If it isn't sure about something, it asks you instead of guessing.\n- There is a daily limit on drafts written as one person (50 a day unless the install changes it).\n\n**Draft replies automatically:**\n\n- About every five minutes it looks at new mail in your inbox. For mail that needs a personal reply from you (a question, a request, a meeting to arrange, an introduction or a follow-up), it writes a first reply and puts it at the top of **Needs you** on Home.\n- It only looks at mail that arrives after you turn it on. It leaves out newsletters, notifications, mailing lists, automatic mail, mail you are not in To or Cc on, mail you've already answered and anything that doesn't need you. Mail you answer within ten minutes never gets a draft.\n- The first reply only acknowledges. It repeats only what you've already said in the thread, commits you to nothing and lists what's left for you to decide. Someone you've never written to gets a short holding reply.\n- Under the picker you see how it is doing (for example, that your mailbox needs connecting again) and when it last looked. Click **Check now** to look straight away.\n- **Also save inbox replies in my Gmail Drafts** (or Outlook): off by default, so replies wait on their cards only. Tick it to keep each reply in your Drafts too.\n- On each card on Home: **Send** asks you to confirm who it goes to, then **Send now**. **Send + allow** (in training) sends it and lets replies to that person go on their own from then on. **Edit** changes the words on the card. **Open in Gmail** opens it when it is in your Drafts. **Dismiss** removes the card.\n- Limits: at most 5 drafts a check and 20 a day unless the install changes it, 2 a day per sender (1 for a stranger), and never more than 25 cards open. A card closes when the draft is sent or deleted in your mailbox, when you reply yourself, or after 7 days.\n\n**How I write (under Advanced):**\n\n- Shows your style as a few sentences, with where it came from (\"Learned from N of your sent emails\", or \"Set by you\") and whether it is locked.\n- **Describe it in your own words**: write how you write, the way you'd tell a new assistant (up to 2,000 characters). Buttons add common phrases, such as \"Short and to the point\" or \"No emojis\". Click **Write my style**; it shows the new style with new lines marked **New** and a sample reply. Click **Save** to keep it or **Change it** to edit your words. Nothing changes until you save.\n- **Learn from my sent mail** (or **Learn again from my sent mail**): reads your recent sent emails once and describes how you write. It needs your mailbox connected and is hidden while the style is locked.\n- **Fine-tune details** opens the fields: **Length** (short, medium, long), **Tone** (casual, neutral, formal), a **Greeting** **To your team**, **To your contacts** and **To anyone else** ({first} becomes their first name), **Sign-off**, **Habits** and **Never** (one per line), your **Signature** and **Examples of your writing**.\n- **Save changes** saves the fields. **Lock** stops it being relearned from your mail (you can still edit it); **Unlock** undoes that. **Reset** starts over. **Remove examples** drops the examples.\n- **Signature**: with Gmail, your signature is added to every draft. **Refresh from Gmail** picks up a change you made in Gmail, **Don't add my signature** stops adding it, and **Add my Gmail signature** brings it back. Outlook doesn't share signatures with apps, so Outlook drafts end with your sign-off.\n- **AI line on drafts you send**: a checkbox for whether drafts you approve and send end with the install's AI line. Off unless the install starts it on. A change applies to the next reply it writes.\n\n**Handle it for me:**\n\n- It sends from your own mailbox, on its own, some of the replies Act as me writes for your inbox, and some follow-ups.\n- It needs **Draft replies automatically** on the Act as me tab. Until then the card says so and offers **Turn on Draft replies automatically**, or **Connect your mailbox in Act as me** if your mailbox isn't connected.\n- Someone who can't have Act as me sees that Handle it for me isn't available to them.\n- **What it sends on its own**: pick one:\n - **Off**: every reply waits for you to send.\n - **Easy ones**: only short replies to people you know, when it's very sure. Follow-ups are written for you and wait on Home.\n - **People I know**: replies to people you know. Strangers, links and amounts wait for you. Follow-ups go to your team and contacts when they haven't answered a question of yours in a few days.\n - **Most mail**: also strangers and longer replies, and links or amounts when it's very sure. Follow-ups go to anyone you wrote to who hasn't answered a question of yours in a few days.\n - **Everything** (the owner only): it decides what to send as you. Replies with a link, the topics that always wait and your rules still hold it back.\n- The sending steps need signed sign-ins on the server. Without them they are greyed out with \"Needs signed sign-ins on this server.\" Moving down asks first and saves when you click **Move down**.\n- **In training**: every reply comes to you first. Tap **Send + allow** on a card and it handles that person on its own from then on, within the step you picked. You can tick it at **Off** before moving up. **Train follow-ups too** (shown while in training) keeps follow-ups in training as well; untick it to let follow-ups go out while replies stay in training. **Everything** opens only once it's out of training, and training can't be turned on at **Everything**.\n- Money, contracts, legal, hiring, the press and passwords always wait for you. It never writes to anyone the email didn't go to. A reply that names the Executive waits too.\n- **Your rules** (at **Everything**): replies matching one wait for you, on top of the company's rules. Pick **A person**, **A company**, **Words** or **An amount**, type the value and click **Add rule**. **Remove** deletes one.\n- **What it sent** (while it is on): \"Sent N replies on its own today\", then each reply and follow-up from the last week: who it went to, the subject, **Still yours to answer** for questions it left for you, and **Open in your mailbox**.\n- **Who it's allowed to handle**: the people you allowed with **Send + allow**. **Remove** takes one off, and it asks you again.\n- **AI line on replies it sends** (under **Advanced**, when the install adds an AI line): on by default. Turning it off asks you to confirm with **Turn it off** or **Keep it on**.\n- Limits: 20 replies sent on its own a day unless the install changes it, and one a conversation. Past the limit, replies wait on cards.\n\n**Take the lead:**\n\n- The owner's alone. Anyone else sees \"Only the account owner can turn this on.\"\n- **Off**: when it looks over your day, it tells you what it would do, and you do it.\n- **In training**: everything it would do comes to you as a card on Home first. What you allow, it does on its own from then on.\n- **On**: it acts on what it finds while it looks over your day: it messages people, books meetings and starts workflows. Anything under **Always asks first** waits for a yes.\n- **In training** and **On** need signed sign-ins on the server.\n- **What it's learned**: the actions you allowed with **Approve + allow** on a card, or **Send + allow** on an Act as me reply. **Remove** takes one off. Something you approved unchanged three times shows as a suggestion with **Allow**.\n- **Always asks first**: a switch for each: **Money**, **Contracts and legal**, **Hiring and people decisions**, **Deleting, cancelling or sharing**, **Someone new** and **Big sends** (company-wide or department-wide, or more than five people). These wait for you, or for whoever approves that area, with a card on Home. **Meetings asked for in chat** is the last row: meetings you or a teammate ask it to book (in a team, Operations must also act on its own). A meeting it thinks of itself always waits. While Take the lead is off, only the meetings row applies.\n- Department levels don't hold what it does here. The switches and rules do.\n- **Company rules**: anything matching one always waits for a yes, for the Executive and for everyone's sending as themselves. Add them the same way as **Your rules**.\n- **Pause** on **Settings → Your Executive** stops everything on this tab. Anything you tap **Send** or **Approve** on still goes.\n\n**Example prompts:**\n\n- \"Reply to Dana as me: yes to the 5th, and ask her to send the deck first.\"\n- \"Write to the Acme team as me and push our call to Thursday.\"\n- \"What's on my calendar tomorrow?\" (with **Read my calendar** on)\n",
"mermaid": null,
"generated_at": "2026-10-15T22:17:16Z"
}
diff --git a/packages/core/openexecutive/guide/prebuilt/today.json b/packages/core/openexecutive/guide/prebuilt/today.json
index a1ed27e9..a31c5af4 100644
--- a/packages/core/openexecutive/guide/prebuilt/today.json
+++ b/packages/core/openexecutive/guide/prebuilt/today.json
@@ -1,7 +1,7 @@
{
"section_id": "today",
"title": "Today / Morning Brief",
- "markdown": "**What it is:** A single screen of *what needs you right now* — the proactive digest the Executive prepares so you're not the one chasing status. In the app it's **Home**, the screen the app opens on.\n\n**What it does:**\n\n- Opens with a greeting, one line summing up the day (click a part of it — *2 awaiting reply*, *1 department at risk* — to open that list), and an **Ask your Executive anything…** box that starts a chat. On a quiet day the line names one **Move today:** instead.\n- Puts what's waiting on your call up front under **Needs you**: the first card large, the next two below it, and **Show N more** for the rest.\n- Gathers everything else under **Everything else** as a row of count tiles — **Departments**, **People**, **Across the team** (waiting on someone else), **Under way**, **Handled overnight**, **Monitoring**, and **Across your clients** when you look after client companies — shown only when they have something in them. Click a tile to open its full list in a side panel.\n- The **Departments** tile shows each department's goal health — on-track, at-risk, or off-track — with the at-risk goals called out.\n- The **People** tile lists people with open items, their reply counts, SLA status, and whether they're on leave.\n- **Read today's brief** (next to **Needs you**) opens the written brief — what's going on across the company — in a side panel.\n- If your latest morning brief, end-of-day digest or weekly review couldn't be sent to you, a line at the top says why and what to connect. It goes away once that's fixed.\n- When your morning brief or end-of-day digest left out lines that named people or figures the Executive couldn't match to your data, **Left out of your brief** under **Needs you** lists them for a day. **Hide** clears it.\n- With **Delegate → Act as me → What it writes as you** at **For my inbox too**, the replies the Executive wrote as you for mail that needs you come first in **Needs you**, marked **Reply waiting** (or **Follow-up waiting** when nobody answered an email you sent). Only you see them.\n- Actions the Executive suggested from your email (a meeting, a message to someone, a new contact) appear as cards in **Needs you**, each spelled out with a box to untick. **Approve** does the ticked ones (**Approve N** when you untick some), **Approve + allow** also lets it do that kind of action on its own from now on (shown while it is still learning), and **Dismiss** drops the card. Only you see them.\n- A send or edit a team member asked for in chat that their department held waits as a card marked **Waiting on you**, with the reason and the exact details. **Approve** carries it out as shown; **Decline** drops it.\n- An item a team member asked the Executive to raise starts with **Raised by** and their name. It goes to a person or a department, never to the whole company. Team members can dismiss only items assigned to them; the owner can dismiss any item.\n- Under **Take the lead**, something the Executive wanted to do on its own that you haven't allowed yet comes as a card: **Approve** does it once, **Approve + allow** also lets it do the same thing with the same person from now on, **Edit** changes it first (tick **Do it like this next time** to keep your edit as an example and allow it), and **Decline** drops it.\n- Surfaces proposals and alerts you can click to open a chat thread with full context.\n\n**How to use:**\n\n1. Click **Home** in the sidebar (or the Open Executive logo). On a phone, **Home** is the first button in the bar at the bottom.\n2. Work **Needs you** from the top. Each card has one main button and **Discuss**; everything else is in the card's **⋯** menu:\n - **Approve** — accept the recommendation; the Executive carries it out right away. A line at the top of **Needs you** shows it working and then done, with a link to the chat where it did the work. If it didn't work, **Try again** is on that line. Usually the main button.\n - **Discuss** — open a chat with the context already filled in.\n - **Edit & approve** (in **⋯**) — reword the action first, then **Send approval**; your text is used exactly as written.\n - **Dismiss** (in **⋯**) — drop it and stay on Home. When the Executive thinks a card is stale, **Dismiss** is the main button instead.\n - **Snooze until …** (in **⋯**) — three hours from now (while that is still today), **tomorrow 9:00**, or **Monday 9:00** (not offered on a Sunday). The card leaves Home and comes back on its own then; *Snoozed until …* with **Undo** under **Needs you** brings it back now.\n - **Nudge *name*** — the main button when the best move is chasing someone for a reply; **Run *workflow*** when the best move is a workflow.\n - **Open *name*'s page** (in **⋯**) — the person the item is waiting on.\n - A **Monitoring** signal leads with **Discuss**; its **⋯** has **Dismiss signal**.\n3. Some cards are simpler: when a scheduled run didn't finish (a department check-in, or a workflow you set to run on a schedule), its card's main button is **Run again**, which runs it now and sends the result where it normally goes (**Open the run** in **⋯** shows what went wrong); a document card's main button is **Open document** (**Mark reviewed** is in its **⋯**, and **Open in app** when the document lives in another app), and a calendar-booking card books (or declines) the meeting directly when you click Approve or Dismiss. Only the person a booking was sent to for approval, or the owner, can approve or decline it.\n4. Keep it tidy from the **⋯** next to **Needs you**: **Dismiss N older than 7 days** clears stale items, and **Re-check relevance** asks the Executive to review every open item now.\n5. Open the **Departments** tile and click a department to ask for its status in chat.\n6. Work the replies waiting to be sent (they come first in **Needs you**). Each card shows who wrote (and *Address not verified* when the address couldn't be confirmed), **What they wrote** (click to open), **Your draft** with who it goes to, *Why it waited for you* when Handle it for me left it for you, **Decide before sending** (what the draft leaves for you to answer) and any warnings. The buttons:\n - **Send** asks once, naming who the reply goes to, then **Send now** sends it from your own mailbox (Gmail or Outlook). If the recipients changed or they wrote again since, it asks again, says what changed, and offers **Send anyway**.\n - **Send + allow** (shown while replies are still being learned) sends it and lets replies to that person go on their own from now on while Handle it for me is on.\n - **Edit** changes the words right on the card; **Save** keeps them (and updates the draft in your mailbox when it is kept there too). When it is learning how you write, **Do it like this next time (if you changed it)** appears as you send.\n - **Open in Gmail** (or Outlook) opens the draft there, when it is kept in your Drafts.\n - **Dismiss** drops the card, and deletes the draft from your Drafts unless you changed it there.\n On a server, Send needs signed sign-ins; until they're set up, send from your mailbox. A card goes away on its own once you send or delete the draft in your mailbox, or reply yourself, and after 7 days.\n\n**Example:** in a Discuss thread, just say *\"go ahead\"* to approve the proposal or *\"drop it\"* to dismiss it — no need to go back to the card. (Calendar bookings still need the Approve button. When you asked for the meeting in a chat, its card is under that reply too.)\n\n**Just for yourself?** If you use Open Executive just for yourself (**Settings → Workspace → Personal**), Home leaves out the team parts: there are no Departments, People or Across the team tiles — everything that needs a decision is in **Needs you**. When a goal is slipping, the summary line at the top says how many goals are at risk; click it to open **Goals**. Instead, the tiles are **Due soon**, **Your projects** and **This week's review**, each opening its list in a side panel. **Your projects** lists the projects the Executive is tracking for you. Click **Done** when one is finished, or **Drop** to stop tracking it (it asks first, and removes the project from Pulse). **Due soon** lists what you've promised by a date and what others have asked of you, due in the next week — say *\"I'll send Northwind the proposal by Friday\"* in the web chat or your own Slack or Discord and it shows up here, and the Executive reminds you when it's due. Click **Done** once it's handled; **All open items** opens the full list. **Top three today**, right under **Needs you**, shows the three things to focus on today — the same three your morning brief opens with — each with a free slot in today's working hours when the Executive can read your calendar. **This week's review** shows your latest weekly review: when it ran and next week's top three. Click **Read the review** to see all of it.\n\nYour morning brief also opens with a **top three for today**, picked from what's overdue or due, goals that are slipping and the projects you're driving. When Google Workspace is connected and the Executive can read your calendar (it is your own account, or you shared your calendar with it), each of the three gets a free slot in today's working hours and the brief lists today's meetings; otherwise the three come without times. Every Friday afternoon (in your time zone) a **weekly review** arrives the same way: your goals graded by area, what's due or overdue, projects that went quiet, the week's decisions, a few older decisions to look back on, and next week's top three. Both also show up on Home (see above), so you see them even when no chat app or email is connected. When it asks how an older decision turned out, just tell the Executive in the web chat or your own Slack or Discord and it records the outcome against that decision.\n\n*Note: proposals are routed to the right person automatically based on who has authority over them.*",
+ "markdown": "**What it is:** A single screen of *what needs you right now* — the proactive digest the Executive prepares so you're not the one chasing status. In the app it's **Home**, the screen the app opens on.\n\n**What it does:**\n\n- Opens with a greeting, one line summing up the day (click a part of it — *2 awaiting reply*, *1 department at risk* — to open that list), and an **Ask your Executive anything…** box that starts a chat. On a quiet day the line names one **Move today:** instead.\n- Puts what's waiting on your call up front under **Needs you**: the first card large, the next two below it, and **Show N more** for the rest.\n- Gathers everything else under **Everything else** as a row of count tiles — **Departments**, **People**, **Across the team** (waiting on someone else), **Under way**, **Handled overnight**, **Monitoring**, and **Across your clients** when you look after client companies — shown only when they have something in them. Click a tile to open its full list in a side panel.\n- The **Departments** tile shows each department's goal health — on-track, at-risk, or off-track — with the at-risk goals called out.\n- The **People** tile lists people with open items, their reply counts, SLA status, and whether they're on leave.\n- **Read today's brief** (next to **Needs you**) opens the written brief — what's going on across the company — in a side panel.\n- If your latest morning brief, end-of-day digest or weekly review couldn't be sent to you, a line at the top says why and what to connect. It goes away once that's fixed.\n- When your morning brief or end-of-day digest left out lines that named people or figures the Executive couldn't match to your data, **Left out of your brief** under **Needs you** lists them for a day. **Hide** clears it.\n- With **Delegate → Act as me → What it writes as you** at **Draft replies automatically**, the replies the Executive wrote as you for mail that needs you come first in **Needs you**, marked **Reply waiting** (or **Follow-up waiting** when nobody answered an email you sent). Only you see them.\n- Actions the Executive suggested from your email (a meeting, a message to someone, a new contact) appear as cards in **Needs you**, each spelled out with a box to untick. **Approve** does the ticked ones (**Approve N** when you untick some), **Approve + allow** also lets it do that kind of action on its own from now on (shown while it is still learning), and **Dismiss** drops the card. Only you see them.\n- A send or edit a team member asked for in chat that their department held waits as a card marked **Waiting on you**, with the reason and the exact details. **Approve** carries it out as shown; **Decline** drops it.\n- An item a team member asked the Executive to raise starts with **Raised by** and their name. It goes to a person or a department, never to the whole company. Team members can dismiss only items assigned to them; the owner can dismiss any item.\n- Under **Take the lead**, something the Executive wanted to do on its own that you haven't allowed yet comes as a card: **Approve** does it once, **Approve + allow** also lets it do the same thing with the same person from now on, **Edit** changes it first (tick **Do it like this next time** to keep your edit as an example and allow it), and **Decline** drops it.\n- Surfaces proposals and alerts you can click to open a chat thread with full context.\n\n**How to use:**\n\n1. Click **Home** in the sidebar (or the Open Executive logo). On a phone, **Home** is the first button in the bar at the bottom.\n2. Work **Needs you** from the top. Each card has one main button and **Discuss**; everything else is in the card's **⋯** menu:\n - **Approve** — accept the recommendation; the Executive carries it out right away. A line at the top of **Needs you** shows it working and then done, with a link to the chat where it did the work. If it didn't work, **Try again** is on that line. Usually the main button.\n - **Discuss** — open a chat with the context already filled in.\n - **Edit & approve** (in **⋯**) — reword the action first, then **Send approval**; your text is used exactly as written.\n - **Dismiss** (in **⋯**) — drop it and stay on Home. When the Executive thinks a card is stale, **Dismiss** is the main button instead.\n - **Snooze until …** (in **⋯**) — three hours from now (while that is still today), **tomorrow 9:00**, or **Monday 9:00** (not offered on a Sunday). The card leaves Home and comes back on its own then; *Snoozed until …* with **Undo** under **Needs you** brings it back now.\n - **Nudge *name*** — the main button when the best move is chasing someone for a reply; **Run *workflow*** when the best move is a workflow.\n - **Open *name*'s page** (in **⋯**) — the person the item is waiting on.\n - A **Monitoring** signal leads with **Discuss**; its **⋯** has **Dismiss signal**.\n3. Some cards are simpler: when a scheduled run didn't finish (a department check-in, or a workflow you set to run on a schedule), its card's main button is **Run again**, which runs it now and sends the result where it normally goes (**Open the run** in **⋯** shows what went wrong); a document card's main button is **Open document** (**Mark reviewed** is in its **⋯**, and **Open in app** when the document lives in another app), and a calendar-booking card books (or declines) the meeting directly when you click Approve or Dismiss. Only the person a booking was sent to for approval, or the owner, can approve or decline it.\n4. Keep it tidy from the **⋯** next to **Needs you**: **Dismiss N older than 7 days** clears stale items, and **Re-check relevance** asks the Executive to review every open item now.\n5. Open the **Departments** tile and click a department to ask for its status in chat.\n6. Work the replies waiting to be sent (they come first in **Needs you**). Each card shows who wrote (and *Address not verified* when the address couldn't be confirmed), **What they wrote** (click to open), **Your draft** with who it goes to, *Why it waited for you* when Handle it for me left it for you, **Decide before sending** (what the draft leaves for you to answer) and any warnings. The buttons:\n - **Send** asks once, naming who the reply goes to, then **Send now** sends it from your own mailbox (Gmail or Outlook). If the recipients changed or they wrote again since, it asks again, says what changed, and offers **Send anyway**.\n - **Send + allow** (shown while replies are still being learned) sends it and lets replies to that person go on their own from now on while Handle it for me is on.\n - **Edit** changes the words right on the card; **Save** keeps them (and updates the draft in your mailbox when it is kept there too). When it is learning how you write, **Do it like this next time (if you changed it)** appears as you send.\n - **Open in Gmail** (or Outlook) opens the draft there, when it is kept in your Drafts.\n - **Dismiss** drops the card, and deletes the draft from your Drafts unless you changed it there.\n On a server, Send needs signed sign-ins; until they're set up, send from your mailbox. A card goes away on its own once you send or delete the draft in your mailbox, or reply yourself, and after 7 days.\n\n**Example:** in a Discuss thread, just say *\"go ahead\"* to approve the proposal or *\"drop it\"* to dismiss it — no need to go back to the card. (Calendar bookings still need the Approve button. When you asked for the meeting in a chat, its card is under that reply too.)\n\n**Just for yourself?** If you use Open Executive just for yourself (**Settings → Workspace → Personal**), Home leaves out the team parts: there are no Departments, People or Across the team tiles — everything that needs a decision is in **Needs you**. When a goal is slipping, the summary line at the top says how many goals are at risk; click it to open **Goals**. Instead, the tiles are **Due soon**, **Your projects** and **This week's review**, each opening its list in a side panel. **Your projects** lists the projects the Executive is tracking for you. Click **Done** when one is finished, or **Drop** to stop tracking it (it asks first, and removes the project from Pulse). **Due soon** lists what you've promised by a date and what others have asked of you, due in the next week — say *\"I'll send Northwind the proposal by Friday\"* in the web chat or your own Slack or Discord and it shows up here, and the Executive reminds you when it's due. Click **Done** once it's handled; **All open items** opens the full list. **Top three today**, right under **Needs you**, shows the three things to focus on today — the same three your morning brief opens with — each with a free slot in today's working hours when the Executive can read your calendar. **This week's review** shows your latest weekly review: when it ran and next week's top three. Click **Read the review** to see all of it.\n\nYour morning brief also opens with a **top three for today**, picked from what's overdue or due, goals that are slipping and the projects you're driving. When Google Workspace is connected and the Executive can read your calendar (it is your own account, or you shared your calendar with it), each of the three gets a free slot in today's working hours and the brief lists today's meetings; otherwise the three come without times. Every Friday afternoon (in your time zone) a **weekly review** arrives the same way: your goals graded by area, what's due or overdue, projects that went quiet, the week's decisions, a few older decisions to look back on, and next week's top three. Both also show up on Home (see above), so you see them even when no chat app or email is connected. When it asks how an older decision turned out, just tell the Executive in the web chat or your own Slack or Discord and it records the outcome against that decision.\n\n*Note: proposals are routed to the right person automatically based on who has authority over them.*",
"mermaid": null,
"generated_at": "2026-10-16T16:18:07.481101+00:00"
}
diff --git a/packages/ui/scripts/reach.test.mjs b/packages/ui/scripts/reach.test.mjs
index 3a6a0819..a84b9cb4 100644
--- a/packages/ui/scripts/reach.test.mjs
+++ b/packages/ui/scripts/reach.test.mjs
@@ -18,7 +18,7 @@ test("reachOf reads the dial step from the settings", () => {
assert.equal(reachOf(settings({ handle_it: { enabled: true, mode: "bold", lead: true } })), "everything");
});
-test("writeOf puts every sending step at For my inbox too", () => {
+test("writeOf puts every sending step at Draft replies automatically", () => {
assert.equal(writeOf(settings({ enabled: false })), "off");
assert.equal(writeOf(settings({ inbox: { enabled: false } })), "when_asked");
assert.equal(writeOf(settings({ handle_it: { enabled: false, mode: "balanced" } })), "inbox");
diff --git a/packages/ui/scripts/whoSends.test.mjs b/packages/ui/scripts/whoSends.test.mjs
index 95da22b8..8a835f97 100644
--- a/packages/ui/scripts/whoSends.test.mjs
+++ b/packages/ui/scripts/whoSends.test.mjs
@@ -1,25 +1,20 @@
import assert from "node:assert/strict";
import test from "node:test";
import { HANDLE_IT_MODES } from "../src/lib/reach.ts";
-import {
- LEAD_OPTIONS,
- SCENES,
- SEND_OPTIONS,
- TOUR,
- WRITE_OPTIONS,
- nextInTour,
- sceneFor,
- sceneKey,
-} from "../src/lib/whoSends.ts";
+import { FIRST, MAILS, OPTIONS, SCENES, SEND_OPTIONS, beats, sceneFor, sceneKey } from "../src/lib/whoSends.ts";
-test("every option has its own scene", () => {
- const keys = [
- ...WRITE_OPTIONS.map((o) => sceneKey("writes", o.value)),
- ...SEND_OPTIONS.map((o) => sceneKey("sends", o.value)),
- ...LEAD_OPTIONS.map((o) => sceneKey("lead", o.value)),
- ];
- assert.deepEqual([...keys].sort(), SCENES.map((s) => s.key).sort());
- for (const s of SCENES) assert.ok(s.frames.length >= 2, `${s.key} has frames`);
+test("every option has its own scene, named as its button", () => {
+ const keys = [];
+ for (const [tab, options] of Object.entries(OPTIONS)) {
+ for (const o of options) {
+ const s = sceneFor(sceneKey(tab, o.value));
+ assert.equal(s.key, sceneKey(tab, o.value));
+ assert.equal(s.tab, tab);
+ assert.equal(s.option, o.label);
+ keys.push(s.key);
+ }
+ }
+ assert.deepEqual(keys.sort(), SCENES.map((s) => s.key).sort());
});
test("the sending levels use the names Handle it for me shows", () => {
@@ -27,20 +22,22 @@ test("the sending levels use the names Handle it for me shows", () => {
assert.deepEqual(levels, HANDLE_IT_MODES.map((m) => ({ value: m.mode, label: m.label })));
});
-test("a scene lights the option it plays", () => {
- for (const s of SCENES) {
- const [group, value] = s.key.split(":");
- const lit = { writes: s.writes, sends: s.sends, lead: s.lead }[group];
- assert.equal(lit, value, s.key);
- }
+test("each sending level sends more on its own, and contracts always wait", () => {
+ const counts = SEND_OPTIONS.map((o) => sceneFor(sceneKey("handle", o.value)).sends);
+ assert.equal(counts[0], 0);
+ for (let i = 1; i < counts.length; i++) assert.ok(counts[i] > counts[i - 1], `level ${i}`);
+ assert.ok(counts.at(-1) < MAILS.length);
+ assert.match(MAILS.at(-1).why, /always wait/);
});
-test("anything it sends on its own rides on For my inbox too", () => {
- for (const s of SCENES.filter((x) => x.sends !== "off")) assert.equal(s.writes, "inbox", s.key);
+test("story scenes have steps, and every scene plays at least two beats", () => {
+ for (const s of SCENES) {
+ assert.equal(Boolean(s.steps), s.tab !== "handle", s.key);
+ assert.ok(beats(s) >= 2, s.key);
+ }
});
-test("the tour plays one scene per tab and loops", () => {
- assert.deepEqual(TOUR.map((k) => sceneFor(k).tab), ["act", "handle", "lead"]);
- assert.equal(nextInTour(TOUR[2]), TOUR[0]);
- assert.equal(sceneFor("nope").key, SCENES[0].key);
+test("each tab opens on one of its own options", () => {
+ for (const [tab, value] of Object.entries(FIRST)) assert.equal(sceneFor(sceneKey(tab, value)).tab, tab);
+ assert.equal(sceneFor("nope").key, "writes:when_asked");
});
diff --git a/packages/ui/src/components/delegate/WhoSendsCard.tsx b/packages/ui/src/components/delegate/WhoSendsCard.tsx
index e28c5cd4..93627b6c 100644
--- a/packages/ui/src/components/delegate/WhoSendsCard.tsx
+++ b/packages/ui/src/components/delegate/WhoSendsCard.tsx
@@ -1,59 +1,52 @@
"use client";
-import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { useEffect, useState, useSyncExternalStore } from "react";
-import {
- LEAD_OPTIONS,
- SEND_OPTIONS,
- TAB_NAMES,
- TOUR,
- WRITE_OPTIONS,
- nextInTour,
- sceneFor,
- sceneKey,
- type Frame,
- type Spot,
- type Tab,
-} from "@/lib/whoSends";
+import { FIRST, MAILS, OPTIONS, TAB_NAMES, beats, sceneFor, sceneKey, type Step, type Tab } from "@/lib/whoSends";
-// Delegate → What it may do: "Who writes and who sends", a short animation of
-// mail moving between your inbox, the Executive, you and the person it goes
-// to. It plays one scene per tab in turn; tapping an option plays that
-// option's scene (lib/whoSends.ts). It changes no setting. Hide is
-// remembered in this browser.
+// Delegate → What it may do: "Who writes and who sends". Pick a tab and an
+// option and its scene plays as numbered steps that stay on screen (or, for
+// Handle it for me, the same five emails marked sent or waiting), under
+// three answers: who writes it, whose name is on it, who presses Send
+// (lib/whoSends.ts). It changes no setting. Hide is remembered in this
+// browser.
const HIDDEN_KEY = "oe.whoSends.hidden";
-const STEP_MS = 1500;
-const HOLD_MS = 1900;
+const STEP_MS = 1700;
+const MAIL_MS = 900;
// The feature colours, as on FeatureName.
-const TONE: Record<Tab, { text: string; pill: string; ring: string; chip: string; lit: string }> = {
+const TONE: Record<Tab, { line: string; lit: string; ring: string; dot: string }> = {
act: {
- text: "text-indigo-700 dark:text-indigo-300",
- pill: "bg-indigo-100 dark:bg-indigo-500/15",
- ring: "border-indigo-400 ring-4 ring-indigo-500/15",
- chip: "bg-indigo-200 dark:bg-indigo-300",
+ line: "border-indigo-500 text-fg dark:border-indigo-300",
lit: "bg-indigo-600 border-indigo-600 text-white dark:bg-indigo-300 dark:border-indigo-300 dark:text-indigo-950",
+ ring: "border-indigo-400 ring-4 ring-indigo-500/15",
+ dot: "bg-indigo-600 text-white dark:bg-indigo-300 dark:text-indigo-950",
},
handle: {
- text: "text-emerald-700 dark:text-emerald-300",
- pill: "bg-emerald-100 dark:bg-emerald-500/15",
- ring: "border-emerald-400 ring-4 ring-emerald-500/15",
- chip: "bg-emerald-200 dark:bg-emerald-300",
+ line: "border-emerald-500 text-fg dark:border-emerald-300",
lit: "bg-emerald-600 border-emerald-600 text-white dark:bg-emerald-300 dark:border-emerald-300 dark:text-emerald-950",
+ ring: "border-emerald-400 ring-4 ring-emerald-500/15",
+ dot: "bg-emerald-600 text-white dark:bg-emerald-300 dark:text-emerald-950",
},
lead: {
- text: "text-orange-700 dark:text-orange-300",
- pill: "bg-orange-100 dark:bg-orange-500/15",
- ring: "border-orange-400 ring-4 ring-orange-500/15",
- chip: "bg-orange-200 dark:bg-orange-300",
+ line: "border-orange-500 text-fg dark:border-orange-300",
lit: "bg-orange-600 border-orange-600 text-white dark:bg-orange-300 dark:border-orange-300 dark:text-orange-950",
+ ring: "border-orange-400 ring-4 ring-orange-500/15",
+ dot: "bg-orange-600 text-white dark:bg-orange-300 dark:text-orange-950",
},
};
-// Where each node sits, and where mail lands next to it, in % of the stage.
-const NODE_AT: Record<Spot, [number, number]> = { inbox: [15, 30], exec: [50, 30], you: [50, 76], to: [85, 30] };
-const CHIP_AT: Record<Spot, [number, number]> = { inbox: [15, 11], exec: [50, 8], you: [77, 76], to: [74, 11] };
+const ACTOR: Record<Step["who"], string> = {
+ you: "text-fg",
+ exec: "text-indigo-700 dark:text-indigo-300",
+ them: "text-fg-muted",
+};
+
+const MAIL_AS = {
+ you: "border-indigo-300 bg-indigo-50 dark:border-indigo-400/40 dark:bg-indigo-500/15",
+ exec: "border-orange-300 bg-orange-50 dark:border-orange-400/40 dark:bg-orange-500/15",
+};
// Hide, kept in this browser. Read through useSyncExternalStore so the
// server render (shown) and the first client render agree.
@@ -104,115 +97,129 @@ function useReducedMotion(): boolean {
);
}
-function Node({ spot, label, frame, tone, round }: { spot: Spot; label: string; frame: Frame; tone: Tab; round?: boolean }) {
- const [x, y] = NODE_AT[spot];
- const on = frame.on?.includes(spot);
- const dim = frame.dim?.includes(spot);
+function Steps({ steps, shown, tab }: { steps: Step[]; shown: number; tab: Tab }) {
return (
- <div
- className={`absolute -translate-x-1/2 -translate-y-1/2 grid justify-items-center gap-[.35em] text-center transition-opacity duration-500 ${dim ? "opacity-35" : ""}`}
- style={{ left: `${x}%`, top: `${y}%` }}
+ <ol
+ className="grid gap-5 @min-[640px]:gap-6"
+ style={{ gridTemplateColumns: `repeat(var(--cols), minmax(0, 1fr))` }}
>
- <div
- className={`grid place-items-center border bg-surface-overlay font-semibold text-fg transition-all duration-500 ${
- round ? "h-[6.6em] w-[6.6em] rounded-full font-display" : "h-[4.4em] w-[7.5em] rounded-[.8em]"
- } ${on ? TONE[tone].ring : "border-line"}`}
- >
- {label}
- </div>
- <div className="min-h-[1.3em] whitespace-nowrap text-[.85em] text-fg-muted">{frame.caps?.[spot] ?? ""}</div>
- </div>
+ {steps.map((s, i) => {
+ const seen = i < shown;
+ const now = i === shown - 1;
+ return (
+ <li
+ key={i}
+ className={`relative rounded-xl border p-3 transition-all duration-500 ${
+ seen ? "opacity-100" : "translate-y-1.5 opacity-15"
+ } ${now ? TONE[tab].ring : "border-line"}`}
+ >
+ <div className="flex items-center gap-2">
+ <span
+ className={`grid h-5 w-5 shrink-0 place-items-center rounded-full text-[11px] font-bold ${
+ now ? TONE[tab].dot : "bg-surface-hover text-fg"
+ }`}
+ >
+ {i + 1}
+ </span>
+ <span className={`text-xs font-bold uppercase tracking-wide ${ACTOR[s.who]}`}>{s.name}</span>
+ </div>
+ <p className="mt-1.5 text-sm leading-snug text-fg">{s.does}</p>
+ {i < steps.length - 1 && (
+ <span
+ aria-hidden
+ className="absolute -bottom-5 left-1/2 -translate-x-1/2 text-fg-subtle @min-[640px]:-right-5 @min-[640px]:bottom-auto @min-[640px]:left-auto @min-[640px]:top-1/2 @min-[640px]:-translate-y-1/2 @min-[640px]:translate-x-0"
+ >
+ <span className="@min-[640px]:hidden">↓</span>
+ <span className="hidden @min-[640px]:inline">→</span>
+ </span>
+ )}
+ {s.mail && (
+ <div className={`mt-2 rounded-lg border px-2.5 py-1.5 text-[13px] text-fg ${s.mail.as ? MAIL_AS[s.mail.as] : "border-line bg-surface-overlay"}`}>
+ <span className="block text-[11px] text-fg-muted">{s.mail.from}</span>
+ {s.mail.text}
+ </div>
+ )}
+ </li>
+ );
+ })}
+ </ol>
);
}
-function Options<T extends string>({
- title,
- group,
- options,
- current,
- tone,
- onPick,
-}: {
- title: string;
- group: "writes" | "sends" | "lead";
- options: { value: T; label: string }[];
- current: T;
- tone: Tab;
- onPick: (key: string) => void;
-}) {
+function Sorted({ sends, shown }: { sends: number; shown: number }) {
return (
- <div>
- <h3 className="mb-2 text-xs font-medium uppercase tracking-wider text-fg-subtle">{title}</h3>
- <div className="grid gap-1" style={{ gridTemplateColumns: `repeat(${options.length}, minmax(0, 1fr))` }}>
- {options.map((o) => {
- const lit = o.value === current;
+ <>
+ <ul className="grid gap-2">
+ {MAILS.map((m, i) => {
+ const seen = i < shown;
+ const sent = i < sends;
return (
- <button
- key={o.value}
- type="button"
- aria-pressed={lit}
- onClick={() => onPick(sceneKey(group, o.value))}
- className={`min-w-0 rounded-lg border px-1 py-2 text-center text-xs leading-tight transition-colors sm:text-[13px] focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-fg ${
- lit ? `${TONE[tone].lit} font-semibold` : "border-line text-fg-muted hover:border-line-strong hover:text-fg"
+ <li
+ key={m.from}
+ className={`flex items-center justify-between gap-3 rounded-xl border border-line px-3 py-2 transition-opacity duration-500 ${
+ seen ? "opacity-100" : "opacity-15"
}`}
>
- {o.label}
- </button>
+ <div className="min-w-0">
+ <span className="block text-xs text-fg-muted">{m.from}</span>
+ <span className="text-sm text-fg">{m.text}</span>
+ </div>
+ <span
+ className={`shrink-0 rounded-full px-2.5 py-1 text-right text-[13px] font-semibold transition-all delay-300 duration-300 ${
+ seen ? "opacity-100" : "translate-x-2 opacity-0"
+ } ${
+ sent
+ ? "bg-emerald-100 text-emerald-800 dark:bg-emerald-500/15 dark:text-emerald-300"
+ : "bg-amber-100 text-amber-800 dark:bg-amber-500/15 dark:text-amber-300"
+ }`}
+ >
+ {sent ? "Sent as you" : "Waits for you"}
+ <span className="block text-[11px] font-normal">{m.why}</span>
+ </span>
+ </li>
);
})}
- </div>
- </div>
+ </ul>
+ <p className={`mt-3 flex gap-4 text-sm text-fg-muted transition-opacity duration-500 ${shown >= MAILS.length ? "opacity-100" : "opacity-0"}`}>
+ <span>
+ Sent on its own: <b className="text-fg">{sends}</b>
+ </span>
+ <span>
+ Waits on Home: <b className="text-fg">{MAILS.length - sends}</b>
+ </span>
+ </p>
+ </>
);
}
export default function WhoSendsCard() {
const hidden = useHidden();
- const [key, setKey] = useState(TOUR[0]);
- const [index, setIndex] = useState(0);
- const [tour, setTour] = useState(true);
- const [playing, setPlaying] = useState(true);
- // Mail jumps (no glide) when a scene starts over.
- const [jump, setJump] = useState(true);
const reduced = useReducedMotion();
- const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
+ const [tab, setTab] = useState<Tab>("act");
+ const [option, setOption] = useState(FIRST.act);
+ const [shown, setShown] = useState(1);
- const scene = sceneFor(key);
- const last = scene.frames.length - 1;
- const frame = scene.frames[reduced ? last : Math.min(index, last)];
-
- const start = useCallback((next: string, asTour: boolean) => {
- setKey(next);
- setIndex(0);
- setTour(asTour);
- setJump(true);
- setPlaying(true);
- }, []);
-
- useEffect(() => {
- if (!jump) return;
- const id = requestAnimationFrame(() => setJump(false));
- return () => cancelAnimationFrame(id);
- }, [jump]);
+ const scene = sceneFor(sceneKey(tab, option));
+ const total = beats(scene);
+ const visible = reduced ? total : shown;
useEffect(() => {
- if (hidden || reduced || !playing) return;
- const wait = index === last ? HOLD_MS : STEP_MS;
- timer.current = setTimeout(() => {
- if (index < last) setIndex(index + 1);
- else start(tour ? nextInTour(key) : key, tour);
- }, wait);
- return () => {
- if (timer.current) clearTimeout(timer.current);
- };
- }, [hidden, reduced, playing, index, last, key, tour, start]);
+ if (hidden || reduced || shown >= total) return;
+ const id = setTimeout(() => setShown(shown + 1), scene.steps ? STEP_MS : MAIL_MS);
+ return () => clearTimeout(id);
+ }, [hidden, reduced, shown, total, scene.steps]);
- const toggleHidden = (next: boolean) => writeHidden(next);
+ const play = (nextTab: Tab, nextOption: string) => {
+ setTab(nextTab);
+ setOption(nextOption);
+ setShown(1);
+ };
if (hidden) {
return (
<button
type="button"
- onClick={() => toggleHidden(false)}
+ onClick={() => writeHidden(false)}
className="mt-6 text-sm font-medium text-accent underline-offset-2 hover:underline"
>
Show who writes and who sends
@@ -220,124 +227,100 @@ export default function WhoSendsCard() {
);
}
- const tone = TONE[scene.tab];
- const chip = frame.chip;
- const [cx, cy] = chip ? CHIP_AT[chip.at] : CHIP_AT.inbox;
+ const answers = [
+ ["Who writes it", scene.answers.writes],
+ ["Whose name is on it", scene.answers.name],
+ ["Who presses Send", scene.answers.sends],
+ ];
return (
- <section aria-labelledby="who-sends-title" className="mt-6 rounded-2xl border border-line bg-surface-elevated p-4 sm:p-5">
+ <section aria-labelledby="who-sends-title" className="@container mt-6 rounded-2xl border border-line bg-surface-elevated p-4 sm:p-5">
<div className="flex items-start justify-between gap-3">
<div className="min-w-0">
<h2 id="who-sends-title" className="text-base font-semibold text-fg">
Who writes and who sends
</h2>
- <p className="mt-1 text-sm leading-relaxed text-fg-muted">
- Act as me writes as you, and you send. Handle it for me sends as you on its own. Take the lead sends in
- the Executive&apos;s name.
- </p>
+ <p className="mt-1 text-sm leading-relaxed text-fg-muted">Pick a tab and an option to see what happens to your mail.</p>
</div>
<button
type="button"
- onClick={() => toggleHidden(true)}
+ onClick={() => writeHidden(true)}
className="whitespace-nowrap text-sm font-medium text-fg-muted hover:text-fg"
>
Hide
</button>
</div>
- <div className="@container mt-4">
- <div
- role="img"
- aria-label={`${TAB_NAMES[scene.tab]}, ${scene.option}: ${scene.line}`}
- className="relative aspect-[4/3] w-full overflow-hidden rounded-xl bg-surface-base text-[3.1cqw] @min-[520px]:aspect-[5/2] @min-[520px]:text-[1.9cqw]"
- >
- <svg aria-hidden viewBox="0 0 100 100" preserveAspectRatio="none" className="absolute inset-0 h-full w-full">
- <g className="stroke-line-strong" strokeWidth="1.5" strokeDasharray="5 5">
- <line x1="15" y1="30" x2="85" y2="30" vectorEffect="non-scaling-stroke" />
- <line x1="50" y1="30" x2="50" y2="76" vectorEffect="non-scaling-stroke" />
- <line x1="50" y1="76" x2="85" y2="30" vectorEffect="non-scaling-stroke" />
- </g>
- </svg>
- <Node spot="inbox" label="Inbox" frame={{ ...frame, caps: { ...frame.caps, inbox: "Your mailbox" } }} tone={scene.tab} />
- <Node spot="exec" label="Executive" frame={frame} tone={scene.tab} round />
- <Node spot="you" label="You" frame={frame} tone={scene.tab} />
- <Node spot="to" label={frame.to ?? "Dana"} frame={frame} tone={scene.tab} />
-
- <div
- aria-hidden
- className={`absolute z-10 w-max max-w-[16em] -translate-x-1/2 -translate-y-1/2 rounded-[.6em] px-[.7em] py-[.45em] text-left text-[.9em] font-semibold leading-tight text-neutral-900 shadow-lg ${
- chip?.tint ? tone.chip : "bg-white dark:bg-neutral-100"
- } ${chip ? "opacity-100" : "opacity-0"} ${
- jump ? "" : "transition-[left,top,opacity] duration-1000 ease-[cubic-bezier(.6,0,.3,1)]"
+ <div className="mt-3 flex gap-1 overflow-x-auto border-b border-line">
+ {(Object.keys(TAB_NAMES) as Tab[]).map((t) => (
+ <button
+ key={t}
+ type="button"
+ aria-pressed={t === tab}
+ onClick={() => play(t, FIRST[t])}
+ className={`-mb-px whitespace-nowrap border-b-2 px-3 py-2 text-sm font-semibold transition-colors ${
+ t === tab ? TONE[t].line : "border-transparent text-fg-muted hover:text-fg"
}`}
- style={{ left: `${cx}%`, top: `${cy}%` }}
>
- <span className="block text-[.82em] font-medium text-neutral-600">{chip?.from}</span>
- {chip?.text}
- </div>
+ {TAB_NAMES[t]}
+ </button>
+ ))}
+ </div>
- {[
- ["exec", frame.execSees, 56],
- ["you", frame.youSays, 93],
- ].map(([id, text, top]) => (
- <div
- key={id as string}
- aria-hidden
- className={`absolute z-20 -translate-x-1/2 -translate-y-1/2 whitespace-nowrap rounded-full border px-[.7em] py-[.35em] text-[.85em] font-semibold transition-opacity duration-500 ${tone.text} ${tone.pill} ${
- text ? "opacity-100" : "opacity-0"
+ <div className="mt-3 flex flex-wrap gap-1.5">
+ {OPTIONS[tab].map((o) => {
+ const lit = o.value === option;
+ return (
+ <button
+ key={o.value}
+ type="button"
+ aria-pressed={lit}
+ onClick={() => play(tab, o.value)}
+ className={`min-w-[5.5rem] flex-1 basis-[30%] rounded-lg border px-2 py-2 text-center text-[13px] leading-tight transition-colors @min-[640px]:basis-0 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-fg ${
+ lit ? `${TONE[tab].lit} font-semibold` : "border-line text-fg-muted hover:border-line-strong hover:text-fg"
}`}
- style={{ left: "50%", top: `${top}%`, borderColor: "currentColor" }}
>
- {text}
- </div>
- ))}
-
- <div
- aria-hidden
- className={`absolute bottom-[6%] right-[3%] w-[30%] rounded-[.7em] border border-line bg-surface-overlay px-[.7em] py-[.55em] text-[.82em] transition-opacity duration-500 ${
- frame.sent ? "opacity-100" : "opacity-0"
- }`}
- >
- <b className={`mb-[.2em] block font-display ${TONE.handle.text}`}>What it sent</b>
- <span className="block text-fg">{frame.sent}</span>
- </div>
- </div>
+ {o.label}
+ </button>
+ );
+ })}
</div>
+ <p className="mt-2 text-xs text-fg-subtle">This is a demo. Tapping here doesn&apos;t change your settings.</p>
- <div className="mt-4 min-h-[4.5em]" aria-live={tour ? "off" : "polite"}>
- <span className={`inline-block rounded-full px-2.5 py-0.5 font-display text-[15px] font-bold ${tone.text} ${tone.pill}`}>
- {TAB_NAMES[scene.tab]} · {scene.option}
- </span>
- <p className="mt-1.5 text-[15px] leading-relaxed text-fg">{scene.line}</p>
- </div>
+ <dl className="mt-3 grid grid-cols-3 gap-2">
+ {answers.map(([label, value]) => (
+ <div key={label} className="rounded-xl border border-line bg-surface-base px-2.5 py-2 @min-[640px]:px-3">
+ <dt className="text-[10px] uppercase tracking-wider text-fg-subtle @min-[640px]:text-[11px]">{label}</dt>
+ <dd className="mt-0.5 text-sm font-semibold leading-snug text-fg @min-[640px]:text-[15px]">{value}</dd>
+ </div>
+ ))}
+ </dl>
- <div className="mt-3 space-y-3">
- <Options title="What it writes as you (Act as me)" group="writes" options={WRITE_OPTIONS} current={scene.writes} tone="act" onPick={(k) => start(k, false)} />
- <Options title="What it sends on its own (Handle it for me)" group="sends" options={SEND_OPTIONS} current={scene.sends} tone="handle" onPick={(k) => start(k, false)} />
- <Options title="Take the lead (as the Executive)" group="lead" options={LEAD_OPTIONS} current={scene.lead} tone="lead" onPick={(k) => start(k, false)} />
+ <div className="mt-3 rounded-xl border border-line bg-surface-base p-3 sm:p-4">
+ <p className="mb-3 text-[15px] leading-relaxed text-fg" aria-live="polite">
+ {scene.line}
+ </p>
+ <div
+ className="[--cols:1] @min-[640px]:[--cols:var(--n)]"
+ style={{ ["--n" as string]: String(scene.steps?.length ?? 1) }}
+ >
+ {scene.steps ? (
+ <Steps steps={scene.steps} shown={visible} tab={tab} />
+ ) : (
+ <Sorted sends={scene.sends ?? 0} shown={visible} />
+ )}
+ </div>
</div>
- <div className="mt-4 flex flex-wrap items-center gap-2">
- {!reduced && (
- <button
- type="button"
- onClick={() => setPlaying(!playing)}
- className="rounded-lg border border-line px-3 py-1.5 text-sm font-medium text-fg hover:bg-surface-hover"
- >
- {playing ? "Pause" : "Play"}
- </button>
- )}
- {!tour && (
- <button
- type="button"
- onClick={() => start(TOUR[0], true)}
- className="rounded-lg border border-line px-3 py-1.5 text-sm font-medium text-fg hover:bg-surface-hover"
- >
- Play all
- </button>
- )}
- <span className="text-[13px] text-fg-muted">Tap an option to see what it does.</span>
- </div>
+ {!reduced && (
+ <button
+ type="button"
+ onClick={() => setShown(1)}
+ className="mt-3 rounded-lg border border-line px-3 py-1.5 text-sm font-medium text-fg hover:bg-surface-hover"
+ >
+ Play again
+ </button>
+ )}
</section>
);
}
diff --git a/packages/ui/src/components/settings/ActAsMeCard.tsx b/packages/ui/src/components/settings/ActAsMeCard.tsx
index 5a95cafc..c6e70225 100644
--- a/packages/ui/src/components/settings/ActAsMeCard.tsx
+++ b/packages/ui/src/components/settings/ActAsMeCard.tsx
@@ -32,7 +32,7 @@ import { addPhrase, markNew, STYLE_PHRASES, styleSentences } from "@/lib/voiceSt
// Delegate → Act as me: let the Executive draft email AS you, in your own
// Gmail Drafts, when you ask it to — and, with What it writes as you at
-// For my inbox too, for mail that needs you, which it sends when you tap Send
+// Draft replies automatically, for mail that needs you, which it sends when you tap Send
// on Today (or on its own, under Handle it for me, which has its own tab).
// Backed by GET /delegation, PUT /delegation/reach (WritesCard) and /delegation/voice.
// Not offered to anyone who can't have it (the owner can, and team members
@@ -40,7 +40,7 @@ import { addPhrase, markNew, STYLE_PHRASES, styleSentences } from "@/lib/voiceSt
// it: the hub then shows no tile, and this page says so.
//
// The page body: the mailbox and What it writes as you (with the inbox
-// watcher's status under For my inbox too) up front; How I write, the
+// watcher's status under Draft replies automatically) up front; How I write, the
// page's `advanced` cards and Let team members use it under Advanced.
export const ACT_AS_ME_INTRO =
@@ -326,7 +326,7 @@ function TeamSection({
);
}
-// Inside What it writes as you, under For my inbox too: how the inbox
+// Inside What it writes as you, under Draft replies automatically: how the inbox
// watcher is doing, Check now (POST /delegation/inbox/check) and where its
// replies are kept (PUT /delegation/inbox {mailbox_drafts}).
function InboxSection({
diff --git a/packages/ui/src/components/settings/ReachCard.tsx b/packages/ui/src/components/settings/ReachCard.tsx
index c4af106b..962b88d2 100644
--- a/packages/ui/src/components/settings/ReachCard.tsx
+++ b/packages/ui/src/components/settings/ReachCard.tsx
@@ -34,7 +34,7 @@ import {
// on Delegate → Handle it for me, is the steps that send on their own, with
// In training (delegation/training.py) and Your rules. Handle it for me
// builds on the inbox replies, so SendsCard opens only once WritesCard is at
-// For my inbox too, and moving WritesCard below that says Handle it for me
+// Draft replies automatically, and moving WritesCard below that says Handle it for me
// stops too. Moving either down says what stops before it saves.
type Step<T extends string> = { value: T; label: string; line: string; reason?: string | null };
@@ -195,7 +195,7 @@ function Check({
const WRITE_ORDER: WriteStep[] = ["off", "when_asked", "inbox"];
// Delegate → Act as me: what it writes as you. `inbox` (the inbox watcher's
-// status, Check now and Also save in Drafts) shows under For my inbox too.
+// status, Check now and Also save in Drafts) shows under Draft replies automatically.
export function WritesCard({
settings,
onSettings,
@@ -224,7 +224,7 @@ export function WritesCard({
},
{
value: "inbox",
- label: "For my inbox too",
+ label: "Draft replies automatically",
line: "It also writes a first reply to mail that needs you and puts it on Home.",
reason: needsMailbox,
},
@@ -344,7 +344,7 @@ export function SendsCard({
</p>
{connected ? (
<Button variant="primary" disabled={busy} onClick={() => void save(() => setReach("inbox"))}>
- {busy ? "Turning on…" : "Turn on For my inbox too"}
+ {busy ? "Turning on…" : "Turn on Draft replies automatically"}
</Button>
) : (
<Link
diff --git a/packages/ui/src/lib/reach.ts b/packages/ui/src/lib/reach.ts
index 5eadf69b..4d34e9db 100644
--- a/packages/ui/src/lib/reach.ts
+++ b/packages/ui/src/lib/reach.ts
@@ -2,10 +2,10 @@ import type { DelegationSettings, HandleItMode, ReachStep } from "@/lib/api";
// What it writes and sends as you, from your own mailbox. One setting on the
// server (PUT /delegation/reach), shown as two pickers: What it writes as
-// you on Delegate → Act as me (Off, When I ask, For my inbox too) and What it
+// you on Delegate → Act as me (Off, When I ask, Draft replies automatically) and What it
// sends on its own on Delegate → Handle it for me (Off, then the sending
// steps). Handle it for me builds on the inbox replies Act as me writes, so
-// its picker opens once the first one is at For my inbox too.
+// its picker opens once the first one is at Draft replies automatically.
// Where each picker sits, for links from the other tabs.
export const WRITES_ANCHOR = "writes";
diff --git a/packages/ui/src/lib/whoSends.ts b/packages/ui/src/lib/whoSends.ts
index 6f6de07f..e7588d28 100644
--- a/packages/ui/src/lib/whoSends.ts
+++ b/packages/ui/src/lib/whoSends.ts
@@ -8,38 +8,36 @@ import type { SendStep, WriteStep } from "@/lib/reach";
export type Tab = "act" | "handle" | "lead";
export type LeadStep = "off" | "training" | "on";
-export type Spot = "inbox" | "exec" | "you" | "to";
-
-export type Chip = { at: Spot; from: string; text: string; tint?: boolean };
-
-// One frame is the whole picture at that moment, so any frame can be shown
-// on its own (reduced motion shows the last one).
-export type Frame = {
- chip?: Chip;
- on?: Spot[];
- dim?: Spot[];
- caps?: Partial<Record<Spot, string>>;
- youSays?: string;
- execSees?: string;
- to?: string;
- sent?: string;
+export type Who = "you" | "exec" | "them";
+
+// One numbered step of a scene. Steps appear in turn and stay on screen.
+export type Step = {
+ who: Who;
+ name: string;
+ does: string;
+ mail?: { from: string; text: string; as?: "you" | "exec" };
};
+// The three answers above every scene.
+export type Answers = { writes: string; name: string; sends: string };
+
export type Scene = {
key: string;
tab: Tab;
option: string;
line: string;
- writes: WriteStep;
- sends: SendStep;
- lead: LeadStep;
- frames: Frame[];
+ answers: Answers;
+ // Act as me and Take the lead tell a story in steps. Handle it for me
+ // sorts the same emails (MAILS) every time: the first `sends` of them go
+ // out on their own, the rest wait.
+ steps?: Step[];
+ sends?: number;
};
export const WRITE_OPTIONS: { value: WriteStep; label: string }[] = [
{ value: "off", label: "Off" },
{ value: "when_asked", label: "When I ask" },
- { value: "inbox", label: "For my inbox too" },
+ { value: "inbox", label: "Draft replies automatically" },
];
export const SEND_OPTIONS: { value: SendStep; label: string }[] = [
@@ -62,136 +60,118 @@ export const TAB_NAMES: Record<Tab, string> = {
lead: "Take the lead",
};
-const mail = (from: string, text: string, at: Spot = "inbox", tint = false): Chip => ({ from, text, at, tint });
-
-// Mail it sends on its own: in, written, out, then listed in What it sent.
-function goes(who: string, asked: string, reply: string, to: string): Frame[] {
- return [
- { chip: mail(`From ${who}`, asked), on: ["inbox"], to },
- { chip: mail("Reply as you", reply, "exec", true), on: ["exec"], dim: ["you"], caps: { exec: "Sends it on its own" }, to },
- { chip: mail("From you", reply, "to", true), on: ["to"], dim: ["you"], caps: { to: "Gets it" }, to },
- { on: ["you"], sent: `Replied to ${to} as you`, to },
- ];
-}
+export const OPTIONS: Record<Tab, { value: string; label: string }[]> = {
+ act: WRITE_OPTIONS,
+ handle: SEND_OPTIONS,
+ lead: LEAD_OPTIONS,
+};
-// Mail that waits: in, drafted, then on Home for you to send.
-function waits(who: string, asked: string, reply: string, why: string, to: string): Frame[] {
- return [
- { chip: mail(`From ${who}`, asked), on: ["inbox"], to },
- { chip: mail("Draft as you", reply, "exec", true), on: ["exec"], caps: { exec: why }, to },
- { chip: mail("Draft as you", reply, "you", true), on: ["you"], caps: { you: "On Home" }, youSays: "Waits for you", to },
- ];
-}
+// The option a tab opens on.
+export const FIRST: Record<Tab, string> = { act: "when_asked", handle: "balanced", lead: "training" };
+
+// Handle it for me: the same five emails at every level, so the levels
+// compare. Ordered from the easiest to send to the one that always waits.
+export const MAILS: { from: string; text: string; why: string }[] = [
+ { from: "Dana, a contact", text: "See you Tuesday?", why: "Short reply" },
+ { from: "Lee, a contact", text: "Can you send a summary of where the project stands?", why: "Longer reply" },
+ { from: "Alex, someone new", text: "Are you the right person for partnerships?", why: "New sender" },
+ { from: "Kim, a contact", text: "What would 20 seats cost?", why: "Has an amount" },
+ { from: "Sam, a contact", text: "Can you sign the updated contract?", why: "Contracts always wait" },
+];
-const late = "Sam's Q3 numbers are 3 days late";
-const ask = "Hi Sam, can you send the Q3 numbers?";
+const dana: Step = { who: "them", name: "Dana", does: "Emails you", mail: { from: "From Dana", text: "Can we move to the 5th?" } };
+const yes = "Yes, the 5th works.";
+const notices: Step = { who: "exec", name: "The Executive", does: "Notices Sam's Q3 numbers are 3 days late" };
+const writesToSam: Step = {
+ who: "exec",
+ name: "The Executive",
+ does: "Writes to Sam in its own name",
+ mail: { from: "From the Executive", text: "Hi Sam, can you send the Q3 numbers?", as: "exec" },
+};
+const yours = (writes: string): Answers => ({ writes, name: "Yours", sends: "You" });
export const SCENES: Scene[] = [
{
- key: "writes:off", tab: "act", option: "Off", writes: "off", sends: "off", lead: "off",
- line: "The Executive only writes as itself. You answer your own mail.",
- frames: [
- { chip: mail("From Dana", "Can we move to the 5th?"), on: ["inbox"] },
- { chip: mail("From Dana", "Can we move to the 5th?", "you"), on: ["you"], dim: ["exec"], youSays: "You write the reply" },
- { chip: mail("From you", "Yes, the 5th works.", "to"), on: ["to"], dim: ["exec"], caps: { to: "Gets it" } },
+ key: "writes:off", tab: "act", option: "Off", answers: yours("You"),
+ line: "The Executive doesn't write as you. You answer your own mail.",
+ steps: [
+ dana,
+ { who: "you", name: "You", does: "Write the reply yourself" },
+ { who: "you", name: "You", does: "Tap Send", mail: { from: "From you", text: yes, as: "you" } },
],
},
{
- key: "writes:when_asked", tab: "act", option: "When I ask", writes: "when_asked", sends: "off", lead: "off",
- line: "Ask in chat, “reply to Dana as me: yes to the 5th”, and the draft waits in your Drafts.",
- frames: [
- { on: ["you"], dim: ["inbox"], youSays: "“Reply to Dana as me: yes to the 5th”" },
- { chip: mail("Draft as you", "Yes, the 5th works.", "exec", true), on: ["exec"], dim: ["inbox"], caps: { exec: "Writes it in your voice" } },
- { chip: mail("Draft as you", "Yes, the 5th works.", "you", true), on: ["you"], dim: ["inbox"], caps: { you: "In your Drafts" }, youSays: "You tap Send" },
- { chip: mail("From you", "Yes, the 5th works.", "to", true), on: ["to"], dim: ["inbox"], caps: { to: "Gets it" } },
+ key: "writes:when_asked", tab: "act", option: "When I ask", answers: yours("The Executive"),
+ line: "It writes as you only when you ask in chat.",
+ steps: [
+ dana,
+ { who: "you", name: "You", does: "Ask in chat", mail: { from: "You, in chat", text: "Reply to Dana as me: yes to the 5th" } },
+ { who: "exec", name: "The Executive", does: "Writes the reply in your voice and puts it in your Drafts", mail: { from: "Draft, from you", text: yes, as: "you" } },
+ { who: "you", name: "You", does: "Check it and tap Send. Dana gets it from you." },
],
},
{
- key: "writes:inbox", tab: "act", option: "For my inbox too", writes: "inbox", sends: "off", lead: "off",
- line: "It also writes a first reply to mail that needs you and puts it on Home. You tap Send.",
- frames: [
- { chip: mail("From Dana", "Can we move to the 5th?"), on: ["inbox"] },
- { chip: mail("Draft as you", "Yes, the 5th works.", "exec", true), on: ["exec"], caps: { exec: "Writes a draft" } },
- { chip: mail("Draft as you", "Yes, the 5th works.", "you", true), on: ["you"], caps: { you: "On Home" }, youSays: "You tap Send" },
- { chip: mail("From you", "Yes, the 5th works.", "to", true), on: ["to"], caps: { to: "Gets it" } },
+ key: "writes:inbox", tab: "act", option: "Draft replies automatically", answers: yours("The Executive"),
+ line: "It also drafts replies to mail that needs you, without being asked.",
+ steps: [
+ dana,
+ { who: "exec", name: "The Executive", does: "Writes a reply in your voice", mail: { from: "Draft, from you", text: yes, as: "you" } },
+ { who: "you", name: "You", does: "See the draft on Home" },
+ { who: "you", name: "You", does: "Tap Send. Dana gets it from you." },
],
},
{
- key: "sends:off", tab: "handle", option: "Off", writes: "inbox", sends: "off", lead: "off",
- line: "Every reply waits for you to send.",
- frames: waits("Dana", "Thanks. See you Tuesday?", "Yes, see you Tuesday.", "Writes a draft", "Dana"),
+ key: "sends:off", tab: "handle", option: "Off", answers: yours("The Executive"), sends: 0,
+ line: "Every reply waits on Home for you to send.",
},
{
- key: "sends:careful", tab: "handle", option: "Easy ones", writes: "inbox", sends: "careful", lead: "off",
+ key: "sends:careful", tab: "handle", option: "Easy ones", sends: 1,
+ answers: { writes: "The Executive", name: "Yours", sends: "It or you" },
line: "Only short replies to people you know, when it's very sure.",
- frames: [
- ...goes("Dana, a contact", "Thanks. See you Tuesday?", "Yes, see you Tuesday.", "Dana"),
- ...waits("Lee, a contact", "Can you send the deck and next year's price?", "Here's the deck. The price is…", "Longer reply: waits", "Lee"),
- ],
},
{
- key: "sends:balanced", tab: "handle", option: "People I know", writes: "inbox", sends: "balanced", lead: "off",
- line: "Replies to people you know. Strangers, links and amounts wait for you.",
- frames: [
- ...goes("Lee, a contact", "Can we push the review to Friday?", "Friday works. I'll move the invite.", "Lee"),
- ...waits("someone new", "Hi, are you the right person for partnerships?", "Yes, happy to talk.", "New sender: waits", "Alex"),
- ],
+ key: "sends:balanced", tab: "handle", option: "People I know", sends: 2,
+ answers: { writes: "The Executive", name: "Yours", sends: "It or you" },
+ line: "Replies to people you know, short or long. Strangers and amounts wait for you.",
},
{
- key: "sends:bold", tab: "handle", option: "Most mail", writes: "inbox", sends: "bold", lead: "off",
- line: "Also strangers and longer replies, and links or amounts when it's very sure.",
- frames: [
- ...goes("someone new", "Hi, are you the right person for partnerships?", "Yes, happy to talk. Does Thursday suit?", "Alex"),
- ...waits("Lee, a contact", "Can you sign the updated contract?", "I'll review it and get back to you.", "Contracts always wait", "Lee"),
- ],
+ key: "sends:bold", tab: "handle", option: "Most mail", sends: 3,
+ answers: { writes: "The Executive", name: "Yours", sends: "It or you" },
+ line: "Also people you don't know. Amounts and links only when it's very sure.",
},
{
- key: "sends:everything", tab: "handle", option: "Everything", writes: "inbox", sends: "everything", lead: "off",
- line: "It decides what to send as you. Replies with a link, the topics that always wait and your rules still hold it back.",
- frames: [
- ...goes("someone new", "Could you share your Q3 plan?", "Here's a summary of the plan.", "Alex"),
- ...waits("Lee, a contact", "Where can I download the files?", "Here's the link: …", "Links always wait", "Lee"),
- ],
+ key: "sends:everything", tab: "handle", option: "Everything", sends: 4,
+ answers: { writes: "The Executive", name: "Yours", sends: "It or you" },
+ line: "It decides what to send as you. Links, the topics that always wait and your rules still hold it back.",
},
{
- key: "lead:off", tab: "lead", option: "Off", writes: "inbox", sends: "off", lead: "off",
- line: "It doesn't act in its own name unless you ask.",
- frames: [
- { on: ["exec"], dim: ["inbox"], caps: { exec: "Notices something" }, execSees: late, to: "Sam" },
- { on: ["you"], dim: ["inbox", "to"], caps: { you: "You decide what to do" }, to: "Sam" },
- ],
+ key: "lead:off", tab: "lead", option: "Off", answers: { writes: "You", name: "Yours", sends: "You" },
+ line: "It doesn't act in its own name. It tells you and you decide.",
+ steps: [notices, { who: "exec", name: "The Executive", does: "Tells you on Home" }, { who: "you", name: "You", does: "Decide what to do" }],
},
{
- key: "lead:training", tab: "lead", option: "In training", writes: "inbox", sends: "off", lead: "training",
- line: "It acts in its own name, and people can see it's the Executive. In training, each action waits for your yes on Home.",
- frames: [
- { on: ["exec"], dim: ["inbox"], caps: { exec: "Notices something" }, execSees: late, to: "Sam" },
- { chip: mail("From the Executive", ask, "exec", true), on: ["exec"], dim: ["inbox"], caps: { exec: "Writes in its own name" }, to: "Sam" },
- { chip: mail("From the Executive", ask, "you", true), on: ["you"], dim: ["inbox"], caps: { you: "On Home" }, youSays: "Waits for your yes", to: "Sam" },
- { chip: mail("From the Executive", ask, "to", true), on: ["to"], dim: ["inbox"], caps: { to: "Gets it" }, to: "Sam" },
- ],
+ key: "lead:training", tab: "lead", option: "In training",
+ answers: { writes: "The Executive", name: "The Executive's", sends: "You, with a yes on Home" },
+ line: "It writes in its own name, and each message waits for your yes.",
+ steps: [notices, writesToSam, { who: "you", name: "You", does: "Tap Yes on Home" }, { who: "them", name: "Sam", does: "Gets it from the Executive" }],
},
{
- key: "lead:on", tab: "lead", option: "On", writes: "inbox", sends: "off", lead: "on",
+ key: "lead:on", tab: "lead", option: "On",
+ answers: { writes: "The Executive", name: "The Executive's", sends: "The Executive" },
line: "It acts in its own name without waiting for your yes on Home. Your company's rules and the Always asks first list still hold it back.",
- frames: [
- { on: ["exec"], dim: ["inbox"], caps: { exec: "Notices something" }, execSees: late, to: "Sam" },
- { chip: mail("From the Executive", ask, "exec", true), on: ["exec"], dim: ["inbox", "you"], caps: { exec: "Writes in its own name" }, to: "Sam" },
- { chip: mail("From the Executive", ask, "to", true), on: ["to"], dim: ["inbox", "you"], caps: { to: "Gets it" }, to: "Sam" },
- ],
+ steps: [notices, writesToSam, { who: "them", name: "Sam", does: "Gets it from the Executive" }],
},
];
-export const sceneKey = (group: "writes" | "sends" | "lead", value: string) => `${group}:${value}`;
+const GROUP: Record<Tab, "writes" | "sends" | "lead"> = { act: "writes", handle: "sends", lead: "lead" };
+
+export const sceneKey = (tab: Tab, value: string) => `${GROUP[tab]}:${value}`;
export function sceneFor(key: string): Scene {
- return SCENES.find((s) => s.key === key) ?? SCENES[0];
+ return SCENES.find((s) => s.key === key) ?? SCENES.find((s) => s.key === sceneKey("act", FIRST.act))!;
}
-// Played in turn when nothing has been tapped: one scene per tab.
-export const TOUR = ["writes:inbox", "sends:balanced", "lead:training"];
-
-export function nextInTour(key: string): string {
- const i = TOUR.indexOf(key);
- return TOUR[(i + 1) % TOUR.length];
+// How many beats a scene plays: one per step, or one per email.
+export function beats(scene: Scene): number {
+ return scene.steps ? scene.steps.length : MAILS.length;
}