AI-powered virtual executive team — a single coherent executive persona backed by 8 specialist agents (FastAPI + Next.js).
feat(people): reach people in the chat app they last talked in (#544)
Rufus45ad76578442
diff --git a/packages/core/openexecutive/architecture/architecture-facts.yaml b/packages/core/openexecutive/architecture/architecture-facts.yamlindex cca541d0..0db4ae05 100644--- a/packages/core/openexecutive/architecture/architecture-facts.yaml+++ b/packages/core/openexecutive/architecture/architecture-facts.yaml@@ -4512,10 +4512,26 @@ people:openexecutive.people.channel — resolves a person to a deliverable(channel, channel_ref) pair. Uses the person's explicitpreferred_channel when set; when preferred_channel is "any",- falls back to email → slack → discord → telegram in that order.+ takes the first channel in people.reach.reach_order.`prefer_channel_for()` also enforces availability windows (returnsNone if the person is on leave or outside all configured windows;no windows means always-on).+ reach: |+ openexecutive.people.reach — one order for every message the+ Executive sends a person (reach_order): preferred_channel; with "any",+ last_channel, the chat app they last talked in; then slack → discord →+ telegram; then email as the backup (first when preferred). Used by+ scheduler.runner.delivery_order (briefs), schedule_tools.message_person+ and _dm_channel_for (messages, follow-ups) and people.channel+ (nudges). note_talked runs from Executive.chat on a chat app turn and+ writes people.last_channel / last_channel_at (store.note_last_channel,+ at most hourly for the same app, updated_at untouched) only when the+ turn's channel ref is the person's own stored Slack / Discord id or+ private (positive) Telegram chat id, and for Telegram only on a+ webhook only Telegram can call (channel_cards.telegram_proves_taps).+ A Telegram group id is left out of the order except for+ message_person (telegram_groups=True). last_channel_at is not+ serialised (Field exclude).notification_settings: |Each team member sets their own on Settings → Notifications(GET/PUT /notifications/settings, api.routes.notifications; callerdiff --git a/packages/core/openexecutive/architecture/prebuilt/org.json b/packages/core/openexecutive/architecture/prebuilt/org.jsonindex 8e381000..b2f1b56c 100644--- a/packages/core/openexecutive/architecture/prebuilt/org.json+++ b/packages/core/openexecutive/architecture/prebuilt/org.json@@ -1,7 +1,7 @@{"section_id": "org","title": "Org Structure (Departments & People)",- "markdown": "The org model has two persistent registries backed by SQLite (both share `episodic_memory.db`): **departments** and **people**. A new install starts with **no departments**: nothing is created at boot. Setup's commit creates only the departments its draft names (none for a solo workspace or a team that names none), and the Executive's `create_goal` tool creates one when a goal names an area that has none. A department named after one of the eight catalogue areas in `departments/charters` (Strategy, Finance, People & Talent, Legal, Operations, Marketing, Product, Board & Investor Comms) starts from that area's charter, and setup and `create_goal` wire it to the matching specialist (at most one department per specialist). Workspaces created before this keep the departments they have. `seed_default_departments` still inserts the full catalogue once per database (tracked by a `default_departments_seeded` sentinel in `departments_meta`), but only tests and tooling call it.\n\n### Company setup (onboarding)\nBoth registries are first populated by **conversational onboarding** at\n`/onboard`. The user describes their business in their own words (optionally\nattaching a deck or one-pager); the `onboarding_interviewer` agent — Council-\nvisible but outside `SPECIALIST_REGISTRY`, so the Executive cannot reach it via\n`consult_specialist` — asks up to 5 clarifying questions, then emits a draft\ncompany profile, a leadership roster, and a department list. The user reviews\nand edits that draft inline (the same section editors `/company-profile` uses)\nbefore anything is written. Until a profile exists the owner (the principal)\nis sent to `/onboard` from Home and every shell page except Settings, unless\nthey chose \"I'll do this later\"; after the save and the voice step a last\nscreen shows what was kept and the two accounts worth connecting (the\nExecutive's own mailbox, and the owner's own for Act as me), and Home's\nbanner slot carries a getting-started checklist (profile, first question,\nthe two mailboxes, the team) until every required row is done or it is hidden\n(`ui/src/lib/firstRun.ts`).\n\nTwo properties matter here. First, **the interview never writes the profile**:\nthe exchange lives in a TTL'd session (2 h, 50 at most) that the API process\nholds and also writes through to the `onboarding_interviews` table of the\nepisodic SQLite database after every turn (`onboarding/interview_store.py`),\nso a restart or another worker finds it again (a newer stored row replaces\na held copy, so two workers never overwrite each other) and the browser,\nwhich keeps only the session id, resumes at the same question or draft via\n`GET /onboard/interview/{id}`. A session answers only to the caller who\nstarted it; anyone else gets the 404 an unknown id gets. Every answer stays on screen with an Edit link, on the draft review too: `POST /onboard/interview/revise` replaces one earlier answer (an edited description keeps its attached files), drops everything after it, resets the question count to what was asked before it, and runs the interviewer again, so it asks again from there or redrafts. A failed turn leaves the session as it was. Start over (on the \"Picking up where you left off\" banner) deletes the session at once with `DELETE /onboard/interview/{id}`. The single profile write happens at\n`POST /onboard/interview/commit`, so a rejected save leaves the draft editable\nand retryable, and a successful one deletes the stored transcript at once (it\ncarries the company's financials). Second, **the department step is additive** — drafted\ndepartments are matched onto existing ones by slug or title and updated in\nplace, unmatched ones are created, and nothing is ever deleted. That is\ndeliberately unlike the fixture loader's `_seed_departments`, which DELETEs\nevery row first: doing that here would drop departments the workspace already\nhas, with their goals and `specialist_key` wiring, on a re-run of setup. A\ndrafted department that matches nothing is created, wired to the specialist\nwhose area it is named after (`specialist_key_for_area`) unless another\ndepartment already has that specialist. Matching goes through\n`departments.store.match_department` (slug as given or as the store would slug\nit, else case-insensitive title), the same rule the `create_goal` chat tool uses. `profile.org_structure` is derived from the reviewed\npeople and department tables at commit time, so it cannot drift from them.\n\nExactly one person is marked `is_principal` and receives `WILDCARD` authority;\nno contact details are imported, even if the user volunteers them, because\nchannels and handles are a deliberate action on the People page. The one\nexception is the owner's own sign-in email: the review screen has a separate\nfield for it, pre-filled with the current owner's email on a re-run and with the\nsigned-in user's on a first setup. The commit checks it before writing anything\n(malformed, already another person's — as their address or one of their\naliases — or different from the owner's existing\nemail is a 422 — setup only fills in a missing one) and then saves it on the\nprincipal's row. One case is adopted rather than rejected: when the address is\nthe one the caller signed in with and sits on the current principal's row\nunder another name (a hosted sign-up seeds that row from the address when no\nname was given), `adopt_owner_row` renames that row to the drafted name\nbefore the roster upsert, so the first save updates the owner's entry instead\nof failing with \"use the owner's name exactly as on the People page\". Without it the signed-in owner matched no Person,\nso their chat history stayed empty until they found the People page. With\nlocal login (`make dev` without Google or SSO sign-in) the field is optional: that\nsession carries no email, which the backend already reads as the principal.\nBecause the save demotes the old principal, only the current owner may draft\nsomeone else as \"This is me\" when setup is re-run (403 otherwise); a re-run\nthat keeps the owner, or a first setup, is open to anyone who can sign in. On such a re-run, someone who isn't the owner may fill in the owner's missing email only with the address they signed in with (403 otherwise): the roster is the sign-in allow-list, so any other address would let them sign in as the owner. That keeps the way in for an owner whose entry has no email, which is also where Setup status and the Executive send them, since the People page refuses anyone it can't recognise as the owner. Re-running setup stays open to everyone deliberately: the Company Profile and Departments pages already let anyone signed in change the same things. The original\n12-step form wizard remains available at `/onboard?mode=form` and backs the\n`openexecutive onboard` CLI. It adds people with their emails, so once there is an owner only they can save it.\n\nA first setup opens on one free-text box: the user describes their work in their own words, optionally attaching a one-pager. `POST /onboard/interview/understand` reads that text once (no session, nothing stored) and reports what it already says: Personal or Team, the principal's role (owner / founder, an executive inside an organisation, independent or fractional, or other), title, who they report to, the company and this year's focus. The next screen shows those for a quick confirm, with Personal / Team as the one required answer; confirming writes `PUT /workspace` (mode, the browser's time zone and, for Personal, the role) and then starts the interview with the same text, so it asks only about what is still missing, at most five questions. If the read fails the text is kept and the user simply picks. A re-run over an existing profile skips these steps; they are changed in Settings. The tone question comes last, after the draft is saved. In solo the interviewer's first user turn carries a short\nhint, one static constant per role kind (`onboarding.interview.solo_hint`):\nalways draft only the principal, as principal, and no departments; an owner is\nasked about the offer, customers, pricing, cash and runway; an in-house\nexecutive about their organisation (the company profile is their employer),\ntheir function and remit, their manager, their team size as context rather\nthan a roster, and what they are measured on; an independent about their\npractice, clients and pricing; with no role given, the role-neutral hint asks\nwhich of these they are. Each also asks their top goals. The hint never\ncarries the principal's own text, and it rides in the user turn, so the cached\nsystem prompt is the same constant in both modes. The solo review screen shows only **You**\n(name and role) and the sign-in email, and commits that one principal with no\ndepartments — the existing departments stay, as the areas goals are grouped\nby. The form wizard (and the CLI) read the mode when a session starts and skip\nthe Team Size, Team Members and Fractional Executives steps in solo; each\nstatus response numbers the steps it actually asks and flags whether the\ncurrent one is `optional`.\n\n### Departments\nEach department carries a charter, `Goal` rows, `ChecklistItem`s, and named cadences. Cadence specs (`daily@HH:MM`, `weekly@DOW@HH:MM`, `quarterly@DD-HH:MM`, UTC) run a `department_check_in` workflow when due (never in solo mode, below), then chain the next occurrence. A new department starts with `check_in: weekly@mon@09:00` (`DEFAULT_CHECK_IN_CADENCE`; it was daily, and departments created before keep theirs). An empty spec turns the check-in off. `PATCH /departments/{slug}` rejects a spec that does not parse with a 422, and a changed `check_in` re-times the department at once (`cadence.reschedule_check_in` cancels the pending check-in and queues the next one on the new schedule, or none when it is off). The department page offers Daily / Weekly (day and time) / Off rather than the raw spec, and shows the next check-in from `next_check_in_at`. The check-in is skipped (and still chained) when the department has no specialist, no Goals, or nothing new since its Goals were last reviewed (a row private to the principal does not count as new: whether it runs is visible to the department). An idle initiative is chased with the department's head, or with the principal when there is none. A department may map to a specialist agent via `specialist_key`, or stay informational. No department is seeded for the `sales` specialist (existing installs keep their departments unchanged), so its consults skip the department-memory prefetch and the Honcho department sync, as `triage`'s do. An assigned head gets a generated department-head voice persona.\n\n**Goals from chat.** Besides the goal routes and the UI, the Executive keeps goals current from a chat turn: `update_department_goal` records reported progress, and `create_goal` starts tracking a new goal the principal states (\"20 paying clients by the end of Q4\"). Only the principal, on a surface that verified it is them (`people_tools.is_principal_on_verified_surface`, the roster tools' rule: the web chat, their own Slack or Discord, a private Telegram chat with a valid webhook secret), may call it: a goal renders in every turn's org block as one of the principal's own, so a goal from an inbound email, Google Chat, a teammate or an unattended run would be text carrying their authority. Anyone else gets a refusal (audited with the caller and surface) and nothing is written. `create_goal` names the area as free text — a slug or a title, resolved by `match_department` — so its schema is static and adding an area never changes the cached tool prefix. When nothing matches it creates the area (`create_department`), giving it a specialist only when the title is obviously one's domain (`specialist_key_for_area`: the default departments' slugs and titles, plus Sales) and no department holds that specialist yet; anything else is informational. It refuses a goal the area already tracks (pointing at `update_department_goal`), caps a turn at 5 new goals (a sweep is not a stated goal) and an area at 8 (common practice keeps 3–5 key results per objective, and every goal renders in the 4000-character org block, so one area cannot crowd the others out), returns only the exception type on a store failure, is audited with its rationale, and is never offered to an unattended run (`schedule_tools.UNATTENDED_WITHHELD_TOOLS`: reflection, research and the scheduler's proactive trigger). The solo persona teaches it; team mode learns it from the tool description, so the team persona stays byte-identical.\n\nA department can also list **watched entities** (`watched_entities`, edited one per line on its page): vendors it is evaluating, competitors in its lane, tickers it tracks. The research watch policy treats them as strong grounding — a proposal about one can be added to the watch list on its own — and routes the resulting watch, its alerts and any suggestion cards to the department and its head rather than the principal (see External monitoring).\n\n### Solo and team mode\nAn install is either a **team** (the default) or **solo** — one person using Open Executive just for themselves. The mode lives with the user's time zone in its own one-row table, `workspace_settings` (`openexecutive.memory.workspace_settings`, `GET`/`PUT /workspace`), not on the company profile, because onboarding's commit and the form wizard rebuild the profile from scratch and would wipe it. Changing it is the principal's call (open while no principal exists, so first-run setup can choose).\n\nThe same row holds the **principal's role** (`PrincipalRole`, every field nullable): `role_kind` (`owner`, `in_house`, `independent` or `other`), `role_title`, `reports_to` (free text, e.g. \"VP of Operations, Dana Ruiz\"), `remit` (what they are responsible for) and `measured_on` (what they are judged on). Solo is about who uses Open Executive, not the principal's level — a business owner, an executive inside a larger organisation, an independent or fractional executive — and this is the context the solo persona reads the role from. Only solo mode reads it; a mode switch keeps it. `GET /workspace` returns it only to the principal (nulls for anyone else). The columns are added to an existing table additively, and a read of an older table (no role columns yet) never migrates it and reads the role as unset.\n\nSolo also changes how the Executive speaks and what it can do. It works for one person — the principal — without assuming their role (an owner, an executive inside a larger organisation, or an independent); the people in their world are contacts it helps them work with, not a team it routes to. The cached org block becomes the principal's own line (\"Your Principal\") — followed by their role lines when a role is set (a fixed lead-in marking the role private to the principal — use it to tailor advice and drafts, share it with no one else — then `- Role: <title> — <kind in plain words>`, `- Reports to:`, `- Responsible for:`, `- Measured on:`, each only when set, sanitized and capped) — plus their goals grouped by **area** (a department row is an area; no authority levels, heads, cadences, channels or roster), and posting to a department room, broadcasting to the company and assigning a department head are not offered. Specialists never see that block, so each consult in a solo turn also carries a `<principal_role>` tag in its user turn (kind, title and remit). The role is pinned on the session for the turn with the mode (`pin_turn_principal_role`), so the org block, the tag and any workflow the turn starts agree even if the role is edited mid-turn, so a VP inside a large company is told to make the case to their CFO rather than to raise a round. A follow-up the Executive schedules to the principal goes straight to them — its department and scope are dropped, so the authority gate never files a card asking the principal to approve a message to themselves. Meeting bookings are gated on the `meeting_scheduling` class mode, not a department (see below).\n\nSolo turns the department rhythm off without touching the org: switching to solo cancels every pending `dept_cadence` row, `bootstrap_cadences` does nothing (the check sits inside it, so boot, the fixture reset and client-slot activation all honour it), and the scheduler cancels any stray check-in without running or chaining it, and a check-in already running across the switch schedules no successor. Department and people rows are kept, so switching back to team re-schedules the check-ins at once. The boot-time org-completeness warnings (departments with no head) are skipped in solo. A chat `Session` can carry an explicit `workspace_mode` override (read through `effective_workspace_mode`), so a caller that runs many conversations on one Executive — evals, for one — can pick the mode per session instead of flipping the install-wide setting; a `principal_role` override (read through `effective_principal_role`: the override, then the turn's pin, then the setting) does the same for the role.\n\nIn the UI, a `WorkspaceProvider` in the root layout reads the mode and role once (and again after Settings changes them) and reads **team** while loading or on error, so a team install never flashes the solo UI. Solo swaps the sidebar's Company group for **You** — Goals, People and the profile — where `/goals` lists every goal grouped by area (a department row) and adds, edits and deletes them through the slug-scoped goal routes. Team mode lists Goals in the Company group too, after Departments, and the page says \"department\" instead of \"area\". Adding a goal asks only for the goal itself: the timeframe is a one-click chip (this quarter by default, filled with the current period's label), target and current are optional, and a new goal starts `on_track` until the check-in grades it. The profile entry follows the principal's role kind: **Business profile** for an owner, **Your work** for anyone else, including an unset role or one `GET /workspace` hides from a non-principal. One rule (`profileWording(mode, roleKind)` in `navConfig.ts`) also words the `/company-profile` breadcrumb, intro and section headings, the form wizard and the draft review; it is copy only, so no profile field is renamed, and team wording is unchanged. `/departments` and `/people` stay reachable by URL.\n\nThe setting is per company: a blank client slot starts on the defaults, a saved slot keeps its own (restoring one runs the additive column migration), a fixture load resets it and applies the fixture's optional `workspace.yaml` (`mode`, `timezone` and the optional role keys; read and validated before anything is swapped; a bad value is skipped, never a failed load; the load and unload responses report the mode and zone only, never the role), and the factory reset returns it to team with no zone and no role. The user's own settings survive a demo: the backup a fixture load takes (or reuses) always gets the live settings written to its `workspace.yaml` while the live state is the user's, and an unload from an older backup without one leaves the settings as they are. A zone that cannot be loaded is never fatal — the API answers 422, and a stored one reads as unset.\n\n### Authority gate\nEach department declares an `AuthorityLevel`, which `departments.authority.gate_action` checks whenever a department-scoped scheduled action comes due. The check-in cadence is the exception: it sends nothing itself, and each action it proposes is run through the gate and shown with its verdict in the report — so a propose-only department's check-ins actually run instead of becoming a one-shot approval card. `auto_execute` (autonomous) fires directly. `propose_only` turns the action into an approval card for an approver (`propose_via_alert`) and sends nothing, deferring the card to the approver's next availability window when they are outside it. `escalate` also sends nothing until someone approves: it raises an urgent `[ESCALATION]` card (severity high) right away, never deferred — filed unrouted when nobody holds the scope and no principal is set, since the Briefing lists every unread card — what the Departments page promises (\"the specialist will not act — it forwards everything to a human\"). It used to raise the card *and* dispatch, so approving the card sent the action a second time. The scheduler records which action each card holds (`alert_held_actions`, written only as it files the card), so approving one (`POST /alerts/{id}/approve`, see Today) queues that exact action again without its department, the approval being the consent the gate waited for, and records who approved it. Calendar bookings follow the same rule in team mode. **A team member's chat turn goes through the gate too** (`orchestrator.department_gate`). On a turn whose caller is a team member other than the principal (attended, not private to the principal), every send or edit is checked before it runs: Take the lead's acting tools less `assign_open_loop` and `run_workflow` (`GATED_TOOLS`), and every connected tool `take_the_lead.mcp_tool_acts` flags, the Gmail send or a Docs edit among them (that check fails closed: only a name that starts with a read verb passes). The level is the strictest of the speaker's departments; no department reads as `propose_only`. `auto_execute` runs it. `propose_only` runs it when the speaker could approve it themselves (they hold a People approval range for every kind it touches, money, a contract, a people decision or the board, or wildcard), else holds it. `escalate` always holds it, for someone other than the speaker. A held action is a `department_action` decision with a card on its approver's Today (high severity when escalated; the principal's when it reaches someone outside the team), audited `department_action_held` with the speaker as actor; the model is told it waits and not to retry. Its card shows every field of the call in full and only then offers Approve, which makes that exact call on the server. Under `escalate`, putting someone on the chase and starting a workflow are refused, since they lead to sends later and can't wait on a card. Someone signed in on the web but on no People entry, or a chat-channel sender matched to no one (in practice Google Chat, the one channel that does not turn unmatched senders away), is gated like someone in no department. Google Chat matches its sender by the Google account email on its signed event and hands that entry to the gate alone (`Session.gate_sender_person_id`, never `caller_person_id`), so the principal's own sends there go and a teammate gets their department's authority; email is left to the mailbox's own gates. A gate that can't be read holds. Before this only unattended work and `propose_meeting` met the gate, so a propose-only or escalate department held nothing its own people asked for in chat. The principal's own turns are not gated, nor are unattended runs (Take the lead's gate and this section's scheduler gate cover those). In solo mode there is no operations department to consult: the booking is decided by the `meeting_scheduling` class mode — `propose` puts it on the briefing for whoever holds the **Meetings** approval range on People (`meeting_scheduling`), else the principal — a booking with a contact on it always stays the principal's — and `auto_execute` books right away only when the principal started the turn on a surface that verified it is them (the roster-write rule: the web chat, their own Slack or Discord, or a private Telegram chat with the webhook secret set). A booking asked for in an inbound email, by a contact, or by an unattended run is proposed to the principal instead, so text someone else wrote cannot put a meeting on their calendar. The principal sets it with `GET`/`PUT /decisions/classes/meeting_scheduling` (`{\"decision_class\": \"meeting_scheduling\", \"mode\": \"propose\" | \"auto_execute\"}`; the PUT is principal-only and audited). The approver is chosen by `AuthorityScope` — a scheduled action's `required_scope` (e.g. `vendor_onboarding`, `spend_lt_10k`) feeds `find_approvers(scope)`, which ranks non-principal scope-holders ahead of `WILDCARD` holders. A null/unknown scope falls back to `WILDCARD` (the principal).\n\n### People & channels\nThe people registry resolves each `Person` to a `(channel, channel_ref)` pair via `prefer_channel_for()`, honoring `preferred_channel` (falling back email → slack → discord → telegram) and availability windows. The principal briefs use their own order — the preferred channel, then Slack → Discord → Telegram, then email as the backup for every preference (first for an `email` one); see Scheduler. Departments can also set `slack_channel_id` / `discord_channel_id` / `telegram_chat_id` to broadcast to a team room instead of DMing the head.\n\nEach person's page also lists their **open loops** (see Attunement) — what they committed to or were asked for in conversation — with a *Mark done* action; archiving a person closes their open loops, since an archived person can no longer be chased. The list is the principal's or that person's only; `people.store.is_principal_or_self` is the one check behind it, the close action and reply feedback.\n\nThe Executive can change the roster from a chat turn (`upsert_person`, `archive_person`, `set_department_head`) only when the principal asks, from the web chat, their own Slack or Discord, or a private Telegram chat when `TELEGRAM_WEBHOOK_SECRET` is set to a value Telegram can send. A teammate, an email (even one from the principal's address), Google Chat, the CLI, the MCP server and unattended runs are refused, because a team member's People row is also the web sign-in allow-list, the outbound-email allow-list and approval routing. The People page follows the same rule: adding, editing and archiving people (`POST`/`PATCH /people`, `POST /people/{id}/archive`) are the principal's alone, or anyone's while no one is principal yet, so a first setup can add its owner (`chat._caller_is_principal_or_unclaimed`). Anyone else gets 403. That includes a teammate editing their own entry: its email and chat ids are how they sign in and how the Executive reaches them, and the rest decides their approvals and how they are chased. Their working style and open loops stay theirs. A signed-in owner whose email is on no People entry is refused too; they sign in with the email on their entry, or re-run the setup interview, which fills a missing one with the email they signed in with. The one roster change that can come from an email is the principal's tokened reply to a roster-request email, and the one a chat turn can make beyond these tools is `resolve_roster_request` — both below, both the principal's alone.\n\n### Each person's notifications\n\nEvery team member sets their own on Settings → Notifications (`GET`/`PUT /notifications/settings`, see API), stored one row per person in `person_notification_settings` (`people.notifications`): **quiet hours** (off by default; from–to in their zone, which may cross midnight; every day, or weekdays with the weekend quiet all day), **delivery** — *As they happen* (the default) or *In my briefs* — and **Let urgent things through** (on by default). No row means the defaults, which hold nothing back.\n\nThey apply only to the Executive's **own** outreach: a DM sent while a proactive source is tagged (`attunement.outcomes.tag_proactive` — the scheduler's nudge dispatch, the reflection, research findings, alert review). Replies in a conversation, a message someone asked for in chat, a follow-up someone scheduled (it was asked for at a time), the briefs themselves and reminders a person set are never held. Quiet hours are deliberately not part of the outbound guard's availability check, which runs on every DM — the brief included — and would refuse a brief scheduled inside the person's own quiet hours.\n\nTwo places apply them. **Nudge routing** asks `people.channel` with `quiet_hours=True` (`is_within_availability`, `next_window_for`, `prefer_channel_for`, `next_available_window`), so the nudge engine and the scheduler's `proactive_nudge` re-check defer a nudge to the end of quiet hours exactly as they defer to an availability window — nothing is written at 3am. **Every other proactive DM** meets `outbound_guard.check_hold` in the send handlers once the anti-spam guard has allowed it: if the recipient is in quiet hours, or chose *In my briefs*, the text is stored in `held_messages` (`people.held_messages`) and the tool returns `{\"status\": \"held\"}`; `message_person` stops there instead of trying another channel; alert review counts a route as made but not a nudge toward its cap, and holds no second nudge about an alert while one waits. If it can't be stored it is sent. A scheduler dispatch whose message was held is audited as `held`, not `delivered`. Quiet-hours rows go out when quiet hours end, as one *While you were away* message (see Scheduler); brief rows ride the principal's next morning brief or end-of-day digest as one *While you were away* block, and anyone else's go out on their own when those briefs run, since only the principal has a brief. Switching back to *As they happen* releases what waited. Whoever sends a row claims it first, so a brief and a release pass never both send it. Someone on leave or outside their availability windows is postponed to when that ends; any other failed delivery backs off (2, 4, 8 … minutes, at most an hour). Rows are capped at 50 per person and dropped after 7 days undelivered, each drop audited privately to the person as a count; a brief row with no brief to carry it for 36 hours goes on its own.\n\n**Urgent** messages — approval nudges (`nudge_stalled`) and alert-review DMs about a critical (`urgent`-severity) alert (`notifications.urgent_send`) — get through when the person lets urgent things through. A workflow approval question (`gate_delivery`, `notifications.approval_send`) is never held, whatever the setting, since only a reply to it resolves the gate. If quiet hours cover every availability window, a nudge falls back to the next window rather than being dropped. Not covered: nudges on the email channel (the MCP mail tool bypasses the send handlers, so routing defers them for quiet hours but they are never held for a brief), department channel broadcasts, and the alert dispatcher's own channels (the web stream, a self-addressed email, and a Slack DM that is still a stub). Department check-ins send no DM: what they propose becomes approval cards.\n\n### Team and contacts\nA `Person` is either on the **team** (`kind = \"team\"`, the default) or a **contact** (`kind = \"contact\"`): a client, contractor or advisor the Executive may need to email or invite but who must not get what a team row grants. Before contacts existed, emailing a client meant adding them as a Person, which also let them sign in and talk to the bot.\n\nContacts are **denied by default**. `people.store.list_people`, every `find_person_by_*` (and `find_person_by_channel_ref`), and the `people.registry` cache return team members only unless the caller passes `include_contacts=True`; `find_approvers` has no opt-in at all. So a contact is never in the web sign-in list (`GET /auth/allowed-emails`), the Slack / Telegram / Discord inbound gates, approvers, the alert review's roster slice, `/today`'s people list and insights, open-loop owners (an ask of a contact opens no loop, so the nudge engine never chases them), a workflow gate's approver or cadence recipient, the recap DM after a meeting, or a department head (`set_department_head` and `PATCH /departments/{slug}` refuse one). `get_person(id)` returns either kind and its security-relevant callers check `kind`.\n\nThe roster reads that **opt in** are few: the Executive's egress checks (Gmail, Calendar and Drive in the MCP gateway, calendar attendee resolution, and the chat DM tools), the People page's listing (`GET /people?include_contacts=true`), the chat `list_people` tool (both kinds, with `kind`), the org prompt block, and the roster-request intake (which looks a sender up with contacts included only to leave a contact out). Even there, reaching a contact needs **the principal's own turn**: `people_tools.contacts_reachable_now()` is true only on a turn the principal started on a surface that verified them — the same rule as roster writes above — or inside `grant_contact_egress()`, which the decisions approve route uses when the approver resolves to the principal. An inbound email (even from the principal's address), a teammate's turn, and unattended runs (scheduler, workflows, alert review) can still reach the team but not contacts. A workflow resumed by `apply_resolution`'s kick runs with no chat session, like the resumer's poll loop, so it never inherits the approver's turn.\n\n**Contacts are private to the principal.** A solo user may be an executive whose contacts include their boss, reports, board and clients, so nobody else using the install sees one. The rule is `contacts_reachable_now()` again: off the principal's own verified turn a contact does not exist — `list_people` returns the team with the same count, a contact's id or address gets exactly the error an unknown one gets (never a contact-specific refusal), and the org prompt block has no Contacts section. The API applies the same rule by caller (`people.caller_is_principal`: the signed-in email is the principal's, or no `x-caller-email` — CLI, local login; unlike the owner rule above, nobody is while no one is principal yet): `?include_contacts=true` is ignored for anyone else, a contact's id is a 404 on `GET /people/{id}` and its open loops exactly like a missing one (editing and archiving are already a 403 before any lookup), only the principal may create a contact or turn someone into one (403, a first setup with no principal included), and `GET /people/me` tells the UI whether to offer contacts at all.\n\nWhatever the Executive raises about a contact stays with the principal too. A meeting with a contact is proposed to the principal (not the scope's approver), its decision is hidden from everyone else's `/decisions` (404 by id), and its card carries `alerts.models.PRIVATE_ALERT_TAG`. So does an alert raised on a turn about the principal's private mail (`Session.private_to_principal`, set by the email poller for mail from a contact and for mail the principal forwards): the pipeline routes it to the principal, stores it without a live push or broadcast, and dedups it only against other private alerts. Private alerts appear on the principal's own `/today` and chat digest only — never a teammate's, the activity rail, the narrative, the morning brief, the end-of-day digest, the reflection or the alert review — and a teammate's ack, reopen or bulk sweep cannot touch one (404). A private turn itself reaches the principal and nobody else (email, DMs, invites). It is not offered, and cannot run, the tools that post to other people, publish where the team reads (artifacts, goal updates, saved workflows, skill drafts) or start work outside the turn (`schedule_tools.PRIVATE_TURN_WITHHELD_TOOLS`), and of the MCP tools it may use only Google Workspace reads and the Gmail send the gateway narrows to the principal. Its audit rows are the principal's alone, as is any row on the principal's own turn that names one of their contacts (see Audit Log). DMs to a contact stay off the activity rail.\n\n`upsert_person` takes `kind`: explicit wins; an update that omits it keeps the row's kind (the store's full-row UPDATE preserves it, so nothing promotes a contact to the team by accident); a new person defaults to `team`, or to `contact` in solo mode. On the principal's own verified turn the org prompt block lists contacts in a short `## Contacts` section after the team block (or, in solo, after `## Your Principal` and their goals) — name, role/company and whether an email is on file, capped at 25 — in both modes. Every other turn gets the team block, byte-identical to an install with no contacts, so the 5-minute cached block has two stable variants.\n\nOn the **People page** the principal sees **Team** and **Contacts** tabs; anyone else sees the team only (no Contacts tab, no kind selector). Solo mode opens on Contacts, and its Team tab shows only the principal. The add form has a kind selector and hides authority scopes, reply SLA and the principal checkbox for a contact; a contact's page hides scopes, SLA, availability windows, open loops, outreach and working style. Adding a team member in solo offers to switch the workspace to team mode, or keep solo.\n\n### Addresses: aliases and company domains\nA `Person` has one **primary** address (`email`) — the one they sign in with — and up to 10 **aliases** (`email_aliases`, the `person_emails` table: `email_norm` unique across the roster, `source` `manual` / `chat_tool` / `roster_request`, deleted with the person or when they are archived, so an archived person never blocks the address). An alias matches their mail and may be emailed, but **is never a login**: `find_person_by_email` stays primary-only and is what web sign-in and `/auth/allowed-emails` read; mail goes through `find_person_by_address` (primary or alias, case-insensitive, the team row winning over a contact) and `people.identity.resolve_email_sender`. Aliases are edited on the person's page (\"Other addresses\") and by `upsert_person`'s `email_aliases` (the full list, replacing the current one); an address that is already someone else's primary or alias is refused (`AddressInUseError`, a 409 on the API), and so is a new primary that is someone's alias. Onboarding still imports no addresses beyond the owner's own sign-in email, and an alias counts as taken there too.\n\nOn top of exact matches, `resolve_email_sender` applies a **company-domain rule, team only**: on one of the company's own domains an address's local part (lowercased, `+tag` dropped) matches a teammate whose own address on any company domain has that local part — `[email protected]` is the Anna whose address is `[email protected]`. A domain alone proves nothing: an unknown local part on the company domain matches nobody (it becomes a roster request, pre-filled as a teammate), and when two teammates would match, nobody does. The company's domains are the `company_domains` workspace setting (Settings → Workspace, `PUT /workspace`, at most 10), or, when that is unset, the domains of the principal's own addresses — never a free-mail provider's (`identity.FREEMAIL_DOMAINS`: gmail.com, outlook.com and the like, refused as a setting too), where a local part says nothing about who someone is. The outbound gates build `RosterAllow` from the same rule, so the Executive may email exactly the addresses inbound mail would match (see Integrations).\n\n### New senders: roster requests\nWhen someone not on the roster — and not one of the principal's contacts — writes in (an email address, a Slack or Discord user, a private verified Telegram chat), their message is held as a **roster request** (`people.roster_requests`: tables `roster_requests`, `roster_request_messages`, `roster_ack_log`) instead of being dropped; they get a fixed acknowledgement (an email sender only when Gmail authenticated them — see Integrations) and the principal gets a private card on `/today`, which says whether they were actually told (`surface_card(acknowledged=...)`, from `ack_sent_at` after the acknowledgement is attempted) and, for a chat or company-domain sender, a prompt on their delivery channel (the per-channel mechanics are in Integrations). A request holds at most 10 messages (later ones only count), is one per `(channel, sender)` while pending, and suggests a match only from a chat account whose profile email is already someone's (never from a display name, which the sender chooses) — and `suggested_kind = team` for an address (or a chat profile email) on a company domain.\n\nThe principal answers one of three ways, all ending in `roster_requests.resolve` (a claim on the row, so two answers race and one wins; nothing is written unless it succeeds):\n\n- **approve** — add them as a new Person with this address or chat id, `team` or `contact`;\n- **link** — they are someone already on the list writing from somewhere new: an email becomes that person's alias — never their primary, even if they had none, so a link never creates a login, a chat id fills that person's field (replacing a different one only when the principal says so; otherwise `ChannelIdConflict`);\n- **decline** — leave them off; they are not raised again for 30 days.\n\nOnly the principal answers, and only where they are verified: the **web card** (`POST /people/requests/{id}/approve|decline`, which requires an explicit team/contact choice), their **own Slack or Discord DM or verified private Telegram chat** (the `resolve_roster_request` chat tool, which answers only ids the server showed that turn in its `<roster_requests>` block — see Agents), or an **email reply from their own primary address** (not an alias) carrying the request's one-time token, which the gateway hides from every other read of the Executive's mailbox so no model turn can copy it. When the chat or email answer does not say team or contact, the default is team for a sender on a company domain, else contact — the least access. Whoever answers, the held messages are then replayed as if the sender had been on the roster all along (a new contact gets only held email, on the private contact path); a decline drops them. A roster write outside a request — the People page (`POST`/`PATCH /people`) or `upsert_person` — reconciles too: any pending request whose sender now matches someone closes as `superseded` and replays.\n\nUnanswered requests expire after `ROSTER_REQUEST_TTL_DAYS` (14). A held message's text is kept only until the request is resolved or expires (then purged, even on decline), its card, routes and audit rows are private to the principal (404 for anyone else), and the tables are wiped with the rest of the People data on a company swap or fixture load.\n",+ "markdown": "The org model has two persistent registries backed by SQLite (both share `episodic_memory.db`): **departments** and **people**. A new install starts with **no departments**: nothing is created at boot. Setup's commit creates only the departments its draft names (none for a solo workspace or a team that names none), and the Executive's `create_goal` tool creates one when a goal names an area that has none. A department named after one of the eight catalogue areas in `departments/charters` (Strategy, Finance, People & Talent, Legal, Operations, Marketing, Product, Board & Investor Comms) starts from that area's charter, and setup and `create_goal` wire it to the matching specialist (at most one department per specialist). Workspaces created before this keep the departments they have. `seed_default_departments` still inserts the full catalogue once per database (tracked by a `default_departments_seeded` sentinel in `departments_meta`), but only tests and tooling call it.\n\n### Company setup (onboarding)\nBoth registries are first populated by **conversational onboarding** at\n`/onboard`. The user describes their business in their own words (optionally\nattaching a deck or one-pager); the `onboarding_interviewer` agent — Council-\nvisible but outside `SPECIALIST_REGISTRY`, so the Executive cannot reach it via\n`consult_specialist` — asks up to 5 clarifying questions, then emits a draft\ncompany profile, a leadership roster, and a department list. The user reviews\nand edits that draft inline (the same section editors `/company-profile` uses)\nbefore anything is written. Until a profile exists the owner (the principal)\nis sent to `/onboard` from Home and every shell page except Settings, unless\nthey chose \"I'll do this later\"; after the save and the voice step a last\nscreen shows what was kept and the two accounts worth connecting (the\nExecutive's own mailbox, and the owner's own for Act as me), and Home's\nbanner slot carries a getting-started checklist (profile, first question,\nthe two mailboxes, the team) until every required row is done or it is hidden\n(`ui/src/lib/firstRun.ts`).\n\nTwo properties matter here. First, **the interview never writes the profile**:\nthe exchange lives in a TTL'd session (2 h, 50 at most) that the API process\nholds and also writes through to the `onboarding_interviews` table of the\nepisodic SQLite database after every turn (`onboarding/interview_store.py`),\nso a restart or another worker finds it again (a newer stored row replaces\na held copy, so two workers never overwrite each other) and the browser,\nwhich keeps only the session id, resumes at the same question or draft via\n`GET /onboard/interview/{id}`. A session answers only to the caller who\nstarted it; anyone else gets the 404 an unknown id gets. Every answer stays on screen with an Edit link, on the draft review too: `POST /onboard/interview/revise` replaces one earlier answer (an edited description keeps its attached files), drops everything after it, resets the question count to what was asked before it, and runs the interviewer again, so it asks again from there or redrafts. A failed turn leaves the session as it was. Start over (on the \"Picking up where you left off\" banner) deletes the session at once with `DELETE /onboard/interview/{id}`. The single profile write happens at\n`POST /onboard/interview/commit`, so a rejected save leaves the draft editable\nand retryable, and a successful one deletes the stored transcript at once (it\ncarries the company's financials). Second, **the department step is additive** — drafted\ndepartments are matched onto existing ones by slug or title and updated in\nplace, unmatched ones are created, and nothing is ever deleted. That is\ndeliberately unlike the fixture loader's `_seed_departments`, which DELETEs\nevery row first: doing that here would drop departments the workspace already\nhas, with their goals and `specialist_key` wiring, on a re-run of setup. A\ndrafted department that matches nothing is created, wired to the specialist\nwhose area it is named after (`specialist_key_for_area`) unless another\ndepartment already has that specialist. Matching goes through\n`departments.store.match_department` (slug as given or as the store would slug\nit, else case-insensitive title), the same rule the `create_goal` chat tool uses. `profile.org_structure` is derived from the reviewed\npeople and department tables at commit time, so it cannot drift from them.\n\nExactly one person is marked `is_principal` and receives `WILDCARD` authority;\nno contact details are imported, even if the user volunteers them, because\nchannels and handles are a deliberate action on the People page. The one\nexception is the owner's own sign-in email: the review screen has a separate\nfield for it, pre-filled with the current owner's email on a re-run and with the\nsigned-in user's on a first setup. The commit checks it before writing anything\n(malformed, already another person's — as their address or one of their\naliases — or different from the owner's existing\nemail is a 422 — setup only fills in a missing one) and then saves it on the\nprincipal's row. One case is adopted rather than rejected: when the address is\nthe one the caller signed in with and sits on the current principal's row\nunder another name (a hosted sign-up seeds that row from the address when no\nname was given), `adopt_owner_row` renames that row to the drafted name\nbefore the roster upsert, so the first save updates the owner's entry instead\nof failing with \"use the owner's name exactly as on the People page\". Without it the signed-in owner matched no Person,\nso their chat history stayed empty until they found the People page. With\nlocal login (`make dev` without Google or SSO sign-in) the field is optional: that\nsession carries no email, which the backend already reads as the principal.\nBecause the save demotes the old principal, only the current owner may draft\nsomeone else as \"This is me\" when setup is re-run (403 otherwise); a re-run\nthat keeps the owner, or a first setup, is open to anyone who can sign in. On such a re-run, someone who isn't the owner may fill in the owner's missing email only with the address they signed in with (403 otherwise): the roster is the sign-in allow-list, so any other address would let them sign in as the owner. That keeps the way in for an owner whose entry has no email, which is also where Setup status and the Executive send them, since the People page refuses anyone it can't recognise as the owner. Re-running setup stays open to everyone deliberately: the Company Profile and Departments pages already let anyone signed in change the same things. The original\n12-step form wizard remains available at `/onboard?mode=form` and backs the\n`openexecutive onboard` CLI. It adds people with their emails, so once there is an owner only they can save it.\n\nA first setup opens on one free-text box: the user describes their work in their own words, optionally attaching a one-pager. `POST /onboard/interview/understand` reads that text once (no session, nothing stored) and reports what it already says: Personal or Team, the principal's role (owner / founder, an executive inside an organisation, independent or fractional, or other), title, who they report to, the company and this year's focus. The next screen shows those for a quick confirm, with Personal / Team as the one required answer; confirming writes `PUT /workspace` (mode, the browser's time zone and, for Personal, the role) and then starts the interview with the same text, so it asks only about what is still missing, at most five questions. If the read fails the text is kept and the user simply picks. A re-run over an existing profile skips these steps; they are changed in Settings. The tone question comes last, after the draft is saved. In solo the interviewer's first user turn carries a short\nhint, one static constant per role kind (`onboarding.interview.solo_hint`):\nalways draft only the principal, as principal, and no departments; an owner is\nasked about the offer, customers, pricing, cash and runway; an in-house\nexecutive about their organisation (the company profile is their employer),\ntheir function and remit, their manager, their team size as context rather\nthan a roster, and what they are measured on; an independent about their\npractice, clients and pricing; with no role given, the role-neutral hint asks\nwhich of these they are. Each also asks their top goals. The hint never\ncarries the principal's own text, and it rides in the user turn, so the cached\nsystem prompt is the same constant in both modes. The solo review screen shows only **You**\n(name and role) and the sign-in email, and commits that one principal with no\ndepartments — the existing departments stay, as the areas goals are grouped\nby. The form wizard (and the CLI) read the mode when a session starts and skip\nthe Team Size, Team Members and Fractional Executives steps in solo; each\nstatus response numbers the steps it actually asks and flags whether the\ncurrent one is `optional`.\n\n### Departments\nEach department carries a charter, `Goal` rows, `ChecklistItem`s, and named cadences. Cadence specs (`daily@HH:MM`, `weekly@DOW@HH:MM`, `quarterly@DD-HH:MM`, UTC) run a `department_check_in` workflow when due (never in solo mode, below), then chain the next occurrence. A new department starts with `check_in: weekly@mon@09:00` (`DEFAULT_CHECK_IN_CADENCE`; it was daily, and departments created before keep theirs). An empty spec turns the check-in off. `PATCH /departments/{slug}` rejects a spec that does not parse with a 422, and a changed `check_in` re-times the department at once (`cadence.reschedule_check_in` cancels the pending check-in and queues the next one on the new schedule, or none when it is off). The department page offers Daily / Weekly (day and time) / Off rather than the raw spec, and shows the next check-in from `next_check_in_at`. The check-in is skipped (and still chained) when the department has no specialist, no Goals, or nothing new since its Goals were last reviewed (a row private to the principal does not count as new: whether it runs is visible to the department). An idle initiative is chased with the department's head, or with the principal when there is none. A department may map to a specialist agent via `specialist_key`, or stay informational. No department is seeded for the `sales` specialist (existing installs keep their departments unchanged), so its consults skip the department-memory prefetch and the Honcho department sync, as `triage`'s do. An assigned head gets a generated department-head voice persona.\n\n**Goals from chat.** Besides the goal routes and the UI, the Executive keeps goals current from a chat turn: `update_department_goal` records reported progress, and `create_goal` starts tracking a new goal the principal states (\"20 paying clients by the end of Q4\"). Only the principal, on a surface that verified it is them (`people_tools.is_principal_on_verified_surface`, the roster tools' rule: the web chat, their own Slack or Discord, a private Telegram chat with a valid webhook secret), may call it: a goal renders in every turn's org block as one of the principal's own, so a goal from an inbound email, Google Chat, a teammate or an unattended run would be text carrying their authority. Anyone else gets a refusal (audited with the caller and surface) and nothing is written. `create_goal` names the area as free text — a slug or a title, resolved by `match_department` — so its schema is static and adding an area never changes the cached tool prefix. When nothing matches it creates the area (`create_department`), giving it a specialist only when the title is obviously one's domain (`specialist_key_for_area`: the default departments' slugs and titles, plus Sales) and no department holds that specialist yet; anything else is informational. It refuses a goal the area already tracks (pointing at `update_department_goal`), caps a turn at 5 new goals (a sweep is not a stated goal) and an area at 8 (common practice keeps 3–5 key results per objective, and every goal renders in the 4000-character org block, so one area cannot crowd the others out), returns only the exception type on a store failure, is audited with its rationale, and is never offered to an unattended run (`schedule_tools.UNATTENDED_WITHHELD_TOOLS`: reflection, research and the scheduler's proactive trigger). The solo persona teaches it; team mode learns it from the tool description, so the team persona stays byte-identical.\n\nA department can also list **watched entities** (`watched_entities`, edited one per line on its page): vendors it is evaluating, competitors in its lane, tickers it tracks. The research watch policy treats them as strong grounding — a proposal about one can be added to the watch list on its own — and routes the resulting watch, its alerts and any suggestion cards to the department and its head rather than the principal (see External monitoring).\n\n### Solo and team mode\nAn install is either a **team** (the default) or **solo** — one person using Open Executive just for themselves. The mode lives with the user's time zone in its own one-row table, `workspace_settings` (`openexecutive.memory.workspace_settings`, `GET`/`PUT /workspace`), not on the company profile, because onboarding's commit and the form wizard rebuild the profile from scratch and would wipe it. Changing it is the principal's call (open while no principal exists, so first-run setup can choose).\n\nThe same row holds the **principal's role** (`PrincipalRole`, every field nullable): `role_kind` (`owner`, `in_house`, `independent` or `other`), `role_title`, `reports_to` (free text, e.g. \"VP of Operations, Dana Ruiz\"), `remit` (what they are responsible for) and `measured_on` (what they are judged on). Solo is about who uses Open Executive, not the principal's level — a business owner, an executive inside a larger organisation, an independent or fractional executive — and this is the context the solo persona reads the role from. Only solo mode reads it; a mode switch keeps it. `GET /workspace` returns it only to the principal (nulls for anyone else). The columns are added to an existing table additively, and a read of an older table (no role columns yet) never migrates it and reads the role as unset.\n\nSolo also changes how the Executive speaks and what it can do. It works for one person — the principal — without assuming their role (an owner, an executive inside a larger organisation, or an independent); the people in their world are contacts it helps them work with, not a team it routes to. The cached org block becomes the principal's own line (\"Your Principal\") — followed by their role lines when a role is set (a fixed lead-in marking the role private to the principal — use it to tailor advice and drafts, share it with no one else — then `- Role: <title> — <kind in plain words>`, `- Reports to:`, `- Responsible for:`, `- Measured on:`, each only when set, sanitized and capped) — plus their goals grouped by **area** (a department row is an area; no authority levels, heads, cadences, channels or roster), and posting to a department room, broadcasting to the company and assigning a department head are not offered. Specialists never see that block, so each consult in a solo turn also carries a `<principal_role>` tag in its user turn (kind, title and remit). The role is pinned on the session for the turn with the mode (`pin_turn_principal_role`), so the org block, the tag and any workflow the turn starts agree even if the role is edited mid-turn, so a VP inside a large company is told to make the case to their CFO rather than to raise a round. A follow-up the Executive schedules to the principal goes straight to them — its department and scope are dropped, so the authority gate never files a card asking the principal to approve a message to themselves. Meeting bookings are gated on the `meeting_scheduling` class mode, not a department (see below).\n\nSolo turns the department rhythm off without touching the org: switching to solo cancels every pending `dept_cadence` row, `bootstrap_cadences` does nothing (the check sits inside it, so boot, the fixture reset and client-slot activation all honour it), and the scheduler cancels any stray check-in without running or chaining it, and a check-in already running across the switch schedules no successor. Department and people rows are kept, so switching back to team re-schedules the check-ins at once. The boot-time org-completeness warnings (departments with no head) are skipped in solo. A chat `Session` can carry an explicit `workspace_mode` override (read through `effective_workspace_mode`), so a caller that runs many conversations on one Executive — evals, for one — can pick the mode per session instead of flipping the install-wide setting; a `principal_role` override (read through `effective_principal_role`: the override, then the turn's pin, then the setting) does the same for the role.\n\nIn the UI, a `WorkspaceProvider` in the root layout reads the mode and role once (and again after Settings changes them) and reads **team** while loading or on error, so a team install never flashes the solo UI. Solo swaps the sidebar's Company group for **You** — Goals, People and the profile — where `/goals` lists every goal grouped by area (a department row) and adds, edits and deletes them through the slug-scoped goal routes. Team mode lists Goals in the Company group too, after Departments, and the page says \"department\" instead of \"area\". Adding a goal asks only for the goal itself: the timeframe is a one-click chip (this quarter by default, filled with the current period's label), target and current are optional, and a new goal starts `on_track` until the check-in grades it. The profile entry follows the principal's role kind: **Business profile** for an owner, **Your work** for anyone else, including an unset role or one `GET /workspace` hides from a non-principal. One rule (`profileWording(mode, roleKind)` in `navConfig.ts`) also words the `/company-profile` breadcrumb, intro and section headings, the form wizard and the draft review; it is copy only, so no profile field is renamed, and team wording is unchanged. `/departments` and `/people` stay reachable by URL.\n\nThe setting is per company: a blank client slot starts on the defaults, a saved slot keeps its own (restoring one runs the additive column migration), a fixture load resets it and applies the fixture's optional `workspace.yaml` (`mode`, `timezone` and the optional role keys; read and validated before anything is swapped; a bad value is skipped, never a failed load; the load and unload responses report the mode and zone only, never the role), and the factory reset returns it to team with no zone and no role. The user's own settings survive a demo: the backup a fixture load takes (or reuses) always gets the live settings written to its `workspace.yaml` while the live state is the user's, and an unload from an older backup without one leaves the settings as they are. A zone that cannot be loaded is never fatal — the API answers 422, and a stored one reads as unset.\n\n### Authority gate\nEach department declares an `AuthorityLevel`, which `departments.authority.gate_action` checks whenever a department-scoped scheduled action comes due. The check-in cadence is the exception: it sends nothing itself, and each action it proposes is run through the gate and shown with its verdict in the report — so a propose-only department's check-ins actually run instead of becoming a one-shot approval card. `auto_execute` (autonomous) fires directly. `propose_only` turns the action into an approval card for an approver (`propose_via_alert`) and sends nothing, deferring the card to the approver's next availability window when they are outside it. `escalate` also sends nothing until someone approves: it raises an urgent `[ESCALATION]` card (severity high) right away, never deferred — filed unrouted when nobody holds the scope and no principal is set, since the Briefing lists every unread card — what the Departments page promises (\"the specialist will not act — it forwards everything to a human\"). It used to raise the card *and* dispatch, so approving the card sent the action a second time. The scheduler records which action each card holds (`alert_held_actions`, written only as it files the card), so approving one (`POST /alerts/{id}/approve`, see Today) queues that exact action again without its department, the approval being the consent the gate waited for, and records who approved it. Calendar bookings follow the same rule in team mode. **A team member's chat turn goes through the gate too** (`orchestrator.department_gate`). On a turn whose caller is a team member other than the principal (attended, not private to the principal), every send or edit is checked before it runs: Take the lead's acting tools less `assign_open_loop` and `run_workflow` (`GATED_TOOLS`), and every connected tool `take_the_lead.mcp_tool_acts` flags, the Gmail send or a Docs edit among them (that check fails closed: only a name that starts with a read verb passes). The level is the strictest of the speaker's departments; no department reads as `propose_only`. `auto_execute` runs it. `propose_only` runs it when the speaker could approve it themselves (they hold a People approval range for every kind it touches, money, a contract, a people decision or the board, or wildcard), else holds it. `escalate` always holds it, for someone other than the speaker. A held action is a `department_action` decision with a card on its approver's Today (high severity when escalated; the principal's when it reaches someone outside the team), audited `department_action_held` with the speaker as actor; the model is told it waits and not to retry. Its card shows every field of the call in full and only then offers Approve, which makes that exact call on the server. Under `escalate`, putting someone on the chase and starting a workflow are refused, since they lead to sends later and can't wait on a card. Someone signed in on the web but on no People entry, or a chat-channel sender matched to no one (in practice Google Chat, the one channel that does not turn unmatched senders away), is gated like someone in no department. Google Chat matches its sender by the Google account email on its signed event and hands that entry to the gate alone (`Session.gate_sender_person_id`, never `caller_person_id`), so the principal's own sends there go and a teammate gets their department's authority; email is left to the mailbox's own gates. A gate that can't be read holds. Before this only unattended work and `propose_meeting` met the gate, so a propose-only or escalate department held nothing its own people asked for in chat. The principal's own turns are not gated, nor are unattended runs (Take the lead's gate and this section's scheduler gate cover those). In solo mode there is no operations department to consult: the booking is decided by the `meeting_scheduling` class mode — `propose` puts it on the briefing for whoever holds the **Meetings** approval range on People (`meeting_scheduling`), else the principal — a booking with a contact on it always stays the principal's — and `auto_execute` books right away only when the principal started the turn on a surface that verified it is them (the roster-write rule: the web chat, their own Slack or Discord, or a private Telegram chat with the webhook secret set). A booking asked for in an inbound email, by a contact, or by an unattended run is proposed to the principal instead, so text someone else wrote cannot put a meeting on their calendar. The principal sets it with `GET`/`PUT /decisions/classes/meeting_scheduling` (`{\"decision_class\": \"meeting_scheduling\", \"mode\": \"propose\" | \"auto_execute\"}`; the PUT is principal-only and audited). The approver is chosen by `AuthorityScope` — a scheduled action's `required_scope` (e.g. `vendor_onboarding`, `spend_lt_10k`) feeds `find_approvers(scope)`, which ranks non-principal scope-holders ahead of `WILDCARD` holders. A null/unknown scope falls back to `WILDCARD` (the principal).\n\n### People & channels\nOne rule (`people/reach.py` `reach_order`) orders the channels the Executive reaches a person on, for briefs (`runner.delivery_order`), messages (`message_person` and the follow-up channel pick) and nudges (`prefer_channel_for()`, which also honours availability windows): their `preferred_channel`; with `any`, the chat app they last talked in (`last_channel`, written by `note_talked` at most hourly on a Slack, Discord or private Telegram turn from their own stored id); then Slack → Discord → Telegram; then email as the backup (first for an `email` preference). Each caller still skips a channel that isn't set up or an id it can't use. Departments can also set `slack_channel_id` / `discord_channel_id` / `telegram_chat_id` to broadcast to a team room instead of DMing the head.\n\nEach person's page also lists their **open loops** (see Attunement) — what they committed to or were asked for in conversation — with a *Mark done* action; archiving a person closes their open loops, since an archived person can no longer be chased. The list is the principal's or that person's only; `people.store.is_principal_or_self` is the one check behind it, the close action and reply feedback.\n\nThe Executive can change the roster from a chat turn (`upsert_person`, `archive_person`, `set_department_head`) only when the principal asks, from the web chat, their own Slack or Discord, or a private Telegram chat when `TELEGRAM_WEBHOOK_SECRET` is set to a value Telegram can send. A teammate, an email (even one from the principal's address), Google Chat, the CLI, the MCP server and unattended runs are refused, because a team member's People row is also the web sign-in allow-list, the outbound-email allow-list and approval routing. The People page follows the same rule: adding, editing and archiving people (`POST`/`PATCH /people`, `POST /people/{id}/archive`) are the principal's alone, or anyone's while no one is principal yet, so a first setup can add its owner (`chat._caller_is_principal_or_unclaimed`). Anyone else gets 403. That includes a teammate editing their own entry: its email and chat ids are how they sign in and how the Executive reaches them, and the rest decides their approvals and how they are chased. Their working style and open loops stay theirs. A signed-in owner whose email is on no People entry is refused too; they sign in with the email on their entry, or re-run the setup interview, which fills a missing one with the email they signed in with. The one roster change that can come from an email is the principal's tokened reply to a roster-request email, and the one a chat turn can make beyond these tools is `resolve_roster_request` — both below, both the principal's alone.\n\n### Each person's notifications\n\nEvery team member sets their own on Settings → Notifications (`GET`/`PUT /notifications/settings`, see API), stored one row per person in `person_notification_settings` (`people.notifications`): **quiet hours** (off by default; from–to in their zone, which may cross midnight; every day, or weekdays with the weekend quiet all day), **delivery** — *As they happen* (the default) or *In my briefs* — and **Let urgent things through** (on by default). No row means the defaults, which hold nothing back.\n\nThey apply only to the Executive's **own** outreach: a DM sent while a proactive source is tagged (`attunement.outcomes.tag_proactive` — the scheduler's nudge dispatch, the reflection, research findings, alert review). Replies in a conversation, a message someone asked for in chat, a follow-up someone scheduled (it was asked for at a time), the briefs themselves and reminders a person set are never held. Quiet hours are deliberately not part of the outbound guard's availability check, which runs on every DM — the brief included — and would refuse a brief scheduled inside the person's own quiet hours.\n\nTwo places apply them. **Nudge routing** asks `people.channel` with `quiet_hours=True` (`is_within_availability`, `next_window_for`, `prefer_channel_for`, `next_available_window`), so the nudge engine and the scheduler's `proactive_nudge` re-check defer a nudge to the end of quiet hours exactly as they defer to an availability window — nothing is written at 3am. **Every other proactive DM** meets `outbound_guard.check_hold` in the send handlers once the anti-spam guard has allowed it: if the recipient is in quiet hours, or chose *In my briefs*, the text is stored in `held_messages` (`people.held_messages`) and the tool returns `{\"status\": \"held\"}`; `message_person` stops there instead of trying another channel; alert review counts a route as made but not a nudge toward its cap, and holds no second nudge about an alert while one waits. If it can't be stored it is sent. A scheduler dispatch whose message was held is audited as `held`, not `delivered`. Quiet-hours rows go out when quiet hours end, as one *While you were away* message (see Scheduler); brief rows ride the principal's next morning brief or end-of-day digest as one *While you were away* block, and anyone else's go out on their own when those briefs run, since only the principal has a brief. Switching back to *As they happen* releases what waited. Whoever sends a row claims it first, so a brief and a release pass never both send it. Someone on leave or outside their availability windows is postponed to when that ends; any other failed delivery backs off (2, 4, 8 … minutes, at most an hour). Rows are capped at 50 per person and dropped after 7 days undelivered, each drop audited privately to the person as a count; a brief row with no brief to carry it for 36 hours goes on its own.\n\n**Urgent** messages — approval nudges (`nudge_stalled`) and alert-review DMs about a critical (`urgent`-severity) alert (`notifications.urgent_send`) — get through when the person lets urgent things through. A workflow approval question (`gate_delivery`, `notifications.approval_send`) is never held, whatever the setting, since only a reply to it resolves the gate. If quiet hours cover every availability window, a nudge falls back to the next window rather than being dropped. Not covered: nudges on the email channel (the MCP mail tool bypasses the send handlers, so routing defers them for quiet hours but they are never held for a brief), department channel broadcasts, and the alert dispatcher's own channels (the web stream, a self-addressed email, and a Slack DM that is still a stub). Department check-ins send no DM: what they propose becomes approval cards.\n\n### Team and contacts\nA `Person` is either on the **team** (`kind = \"team\"`, the default) or a **contact** (`kind = \"contact\"`): a client, contractor or advisor the Executive may need to email or invite but who must not get what a team row grants. Before contacts existed, emailing a client meant adding them as a Person, which also let them sign in and talk to the bot.\n\nContacts are **denied by default**. `people.store.list_people`, every `find_person_by_*` (and `find_person_by_channel_ref`), and the `people.registry` cache return team members only unless the caller passes `include_contacts=True`; `find_approvers` has no opt-in at all. So a contact is never in the web sign-in list (`GET /auth/allowed-emails`), the Slack / Telegram / Discord inbound gates, approvers, the alert review's roster slice, `/today`'s people list and insights, open-loop owners (an ask of a contact opens no loop, so the nudge engine never chases them), a workflow gate's approver or cadence recipient, the recap DM after a meeting, or a department head (`set_department_head` and `PATCH /departments/{slug}` refuse one). `get_person(id)` returns either kind and its security-relevant callers check `kind`.\n\nThe roster reads that **opt in** are few: the Executive's egress checks (Gmail, Calendar and Drive in the MCP gateway, calendar attendee resolution, and the chat DM tools), the People page's listing (`GET /people?include_contacts=true`), the chat `list_people` tool (both kinds, with `kind`), the org prompt block, and the roster-request intake (which looks a sender up with contacts included only to leave a contact out). Even there, reaching a contact needs **the principal's own turn**: `people_tools.contacts_reachable_now()` is true only on a turn the principal started on a surface that verified them — the same rule as roster writes above — or inside `grant_contact_egress()`, which the decisions approve route uses when the approver resolves to the principal. An inbound email (even from the principal's address), a teammate's turn, and unattended runs (scheduler, workflows, alert review) can still reach the team but not contacts. A workflow resumed by `apply_resolution`'s kick runs with no chat session, like the resumer's poll loop, so it never inherits the approver's turn.\n\n**Contacts are private to the principal.** A solo user may be an executive whose contacts include their boss, reports, board and clients, so nobody else using the install sees one. The rule is `contacts_reachable_now()` again: off the principal's own verified turn a contact does not exist — `list_people` returns the team with the same count, a contact's id or address gets exactly the error an unknown one gets (never a contact-specific refusal), and the org prompt block has no Contacts section. The API applies the same rule by caller (`people.caller_is_principal`: the signed-in email is the principal's, or no `x-caller-email` — CLI, local login; unlike the owner rule above, nobody is while no one is principal yet): `?include_contacts=true` is ignored for anyone else, a contact's id is a 404 on `GET /people/{id}` and its open loops exactly like a missing one (editing and archiving are already a 403 before any lookup), only the principal may create a contact or turn someone into one (403, a first setup with no principal included), and `GET /people/me` tells the UI whether to offer contacts at all.\n\nWhatever the Executive raises about a contact stays with the principal too. A meeting with a contact is proposed to the principal (not the scope's approver), its decision is hidden from everyone else's `/decisions` (404 by id), and its card carries `alerts.models.PRIVATE_ALERT_TAG`. So does an alert raised on a turn about the principal's private mail (`Session.private_to_principal`, set by the email poller for mail from a contact and for mail the principal forwards): the pipeline routes it to the principal, stores it without a live push or broadcast, and dedups it only against other private alerts. Private alerts appear on the principal's own `/today` and chat digest only — never a teammate's, the activity rail, the narrative, the morning brief, the end-of-day digest, the reflection or the alert review — and a teammate's ack, reopen or bulk sweep cannot touch one (404). A private turn itself reaches the principal and nobody else (email, DMs, invites). It is not offered, and cannot run, the tools that post to other people, publish where the team reads (artifacts, goal updates, saved workflows, skill drafts) or start work outside the turn (`schedule_tools.PRIVATE_TURN_WITHHELD_TOOLS`), and of the MCP tools it may use only Google Workspace reads and the Gmail send the gateway narrows to the principal. Its audit rows are the principal's alone, as is any row on the principal's own turn that names one of their contacts (see Audit Log). DMs to a contact stay off the activity rail.\n\n`upsert_person` takes `kind`: explicit wins; an update that omits it keeps the row's kind (the store's full-row UPDATE preserves it, so nothing promotes a contact to the team by accident); a new person defaults to `team`, or to `contact` in solo mode. On the principal's own verified turn the org prompt block lists contacts in a short `## Contacts` section after the team block (or, in solo, after `## Your Principal` and their goals) — name, role/company and whether an email is on file, capped at 25 — in both modes. Every other turn gets the team block, byte-identical to an install with no contacts, so the 5-minute cached block has two stable variants.\n\nOn the **People page** the principal sees **Team** and **Contacts** tabs; anyone else sees the team only (no Contacts tab, no kind selector). Solo mode opens on Contacts, and its Team tab shows only the principal. The add form has a kind selector and hides authority scopes, reply SLA and the principal checkbox for a contact; a contact's page hides scopes, SLA, availability windows, open loops, outreach and working style. Adding a team member in solo offers to switch the workspace to team mode, or keep solo.\n\n### Addresses: aliases and company domains\nA `Person` has one **primary** address (`email`) — the one they sign in with — and up to 10 **aliases** (`email_aliases`, the `person_emails` table: `email_norm` unique across the roster, `source` `manual` / `chat_tool` / `roster_request`, deleted with the person or when they are archived, so an archived person never blocks the address). An alias matches their mail and may be emailed, but **is never a login**: `find_person_by_email` stays primary-only and is what web sign-in and `/auth/allowed-emails` read; mail goes through `find_person_by_address` (primary or alias, case-insensitive, the team row winning over a contact) and `people.identity.resolve_email_sender`. Aliases are edited on the person's page (\"Other addresses\") and by `upsert_person`'s `email_aliases` (the full list, replacing the current one); an address that is already someone else's primary or alias is refused (`AddressInUseError`, a 409 on the API), and so is a new primary that is someone's alias. Onboarding still imports no addresses beyond the owner's own sign-in email, and an alias counts as taken there too.\n\nOn top of exact matches, `resolve_email_sender` applies a **company-domain rule, team only**: on one of the company's own domains an address's local part (lowercased, `+tag` dropped) matches a teammate whose own address on any company domain has that local part — `[email protected]` is the Anna whose address is `[email protected]`. A domain alone proves nothing: an unknown local part on the company domain matches nobody (it becomes a roster request, pre-filled as a teammate), and when two teammates would match, nobody does. The company's domains are the `company_domains` workspace setting (Settings → Workspace, `PUT /workspace`, at most 10), or, when that is unset, the domains of the principal's own addresses — never a free-mail provider's (`identity.FREEMAIL_DOMAINS`: gmail.com, outlook.com and the like, refused as a setting too), where a local part says nothing about who someone is. The outbound gates build `RosterAllow` from the same rule, so the Executive may email exactly the addresses inbound mail would match (see Integrations).\n\n### New senders: roster requests\nWhen someone not on the roster — and not one of the principal's contacts — writes in (an email address, a Slack or Discord user, a private verified Telegram chat), their message is held as a **roster request** (`people.roster_requests`: tables `roster_requests`, `roster_request_messages`, `roster_ack_log`) instead of being dropped; they get a fixed acknowledgement (an email sender only when Gmail authenticated them — see Integrations) and the principal gets a private card on `/today`, which says whether they were actually told (`surface_card(acknowledged=...)`, from `ack_sent_at` after the acknowledgement is attempted) and, for a chat or company-domain sender, a prompt on their delivery channel (the per-channel mechanics are in Integrations). A request holds at most 10 messages (later ones only count), is one per `(channel, sender)` while pending, and suggests a match only from a chat account whose profile email is already someone's (never from a display name, which the sender chooses) — and `suggested_kind = team` for an address (or a chat profile email) on a company domain.\n\nThe principal answers one of three ways, all ending in `roster_requests.resolve` (a claim on the row, so two answers race and one wins; nothing is written unless it succeeds):\n\n- **approve** — add them as a new Person with this address or chat id, `team` or `contact`;\n- **link** — they are someone already on the list writing from somewhere new: an email becomes that person's alias — never their primary, even if they had none, so a link never creates a login, a chat id fills that person's field (replacing a different one only when the principal says so; otherwise `ChannelIdConflict`);\n- **decline** — leave them off; they are not raised again for 30 days.\n\nOnly the principal answers, and only where they are verified: the **web card** (`POST /people/requests/{id}/approve|decline`, which requires an explicit team/contact choice), their **own Slack or Discord DM or verified private Telegram chat** (the `resolve_roster_request` chat tool, which answers only ids the server showed that turn in its `<roster_requests>` block — see Agents), or an **email reply from their own primary address** (not an alias) carrying the request's one-time token, which the gateway hides from every other read of the Executive's mailbox so no model turn can copy it. When the chat or email answer does not say team or contact, the default is team for a sender on a company domain, else contact — the least access. Whoever answers, the held messages are then replayed as if the sender had been on the roster all along (a new contact gets only held email, on the private contact path); a decline drops them. A roster write outside a request — the People page (`POST`/`PATCH /people`) or `upsert_person` — reconciles too: any pending request whose sender now matches someone closes as `superseded` and replays.\n\nUnanswered requests expire after `ROSTER_REQUEST_TTL_DAYS` (14). A held message's text is kept only until the request is resolved or expires (then purged, even on decline), its card, routes and audit rows are private to the principal (404 for anyone else), and the tables are wiped with the rest of the People data on a company swap or fixture load.\n","mermaid": "flowchart TD\n People[\"People registry (Person, is_principal, kind)\"]\n Contacts[\"Contacts (kind = contact): egress only on the principal's turn\"]\n Req[\"Roster requests (new senders held for the principal)\"]\n Dept[\"Departments (8 seeded once)\"]\n GC[\"Goals / checklists / cadences\"]\n Head[\"Head + voice persona\"]\n Gate[\"Authority gate (propose_only vs autonomous)\"]\n Scope[\"AuthorityScope to find_approvers\"]\n Chan[\"Channel resolution (Discord / Telegram / email)\"]\n Dept --> GC\n Dept --> Head\n Dept -->|proposes action| Gate\n Gate -->|required_scope| Scope\n Scope -->|ranks approvers| People\n People --> Chan\n People -. include_contacts .-> Contacts\n Req -->|approve / link| People\n Dept -->|team room| Chan\n class People storage\n class Contacts storage\n class Req storage\n class Dept storage\n class GC storage\n class Gate compute\n class Scope compute\n class Chan compute\n class Head compute","generated_at": "2026-10-17T15:32:01Z"}diff --git a/packages/core/openexecutive/architecture/prebuilt/scheduler.json b/packages/core/openexecutive/architecture/prebuilt/scheduler.jsonindex cf332dea..20e6d3b2 100644--- a/packages/core/openexecutive/architecture/prebuilt/scheduler.json+++ b/packages/core/openexecutive/architecture/prebuilt/scheduler.json@@ -1,7 +1,7 @@{"section_id": "scheduler","title": "Scheduler & Cadences",- "markdown": "The scheduler is an asyncio task started in the FastAPI lifespan (`openexecutive.scheduler.runner.run_scheduler`). It polls every 30s and reads due rows from `scheduled_actions` (in `episodic_memory.db`). The due query uses `claim_due_actions`, an UPDATE…RETURNING claim, so each row fires at most once per process — this assumes a single scheduler instance per database. Each due row runs in its own task, started with no audit scope (`audit.context.unscoped_audit_rows`): a scheduled action is unattended and never part of the turn that scheduled it, so its audit rows follow the ordinary rule. Polls are gated on an active company profile via `_company_profile_active()`; before onboarding, due rows stay `pending`.\n\n### Operator pause\n\nA global pause switch (`openexecutive.scheduler.pause`, one row in the `executive_control` table) stops everything the Executive starts on its own. It is the first check of every scheduler tick: while paused the tick does nothing — no alert/watchlist sweep, no claim — so due rows stay `pending` and fire on the first tick after resume. Actions already claimed when the pause lands run to completion; pausing holds work, it never cancels it. The same check gates the Gmail poller (the inbox is left unread) and the workflow resumer (no `wait_for_human` timeouts or resumes, and `apply_resolution` records a reply without kicking the run). Inbound conversations — web chat, Slack, Discord, Telegram, Google Chat — are deliberately not gated. The switch is set from the sidebar, the paused banner or Settings in the UI, or via `POST /executive/pause` / `POST /executive/resume`; each flip writes an `executive_paused` / `executive_resumed` audit row. Any signed-in caller may pause (it only holds work); resuming releases every held action at once, so it is the principal's alone (open only while no principal is on the roster). The state persists across restarts (boot logs a warning while paused) and across client-slot switches. `is_paused()` is read-only: a DB file or table that does not exist yet reads as \"running\", but a read error on an existing DB reads as \"paused\" — the brake fails closed, so a storage fault holds work rather than silently releasing it while the UI still shows \"paused\" (the UI shows \"status unknown\" when it cannot read the state).\n\n### Liveness heartbeat\n\nEvery tick ends by recording when it finished and what it did — `ran`, `paused`, `waiting_for_company`, `rotating`, or `failed` when the tick raised — and `run_scheduler` notes when it started. `scheduler_heartbeat()` returns both; they live in process memory, not the database. Settings → Setup status (`GET /setup/status`) reads them: no start means the task isn't running; no tick five minutes after starting, or none for three poll intervals (at least 90 s), means the loop has stopped; `failed` and `waiting_for_company` get their own light. Liveness is judged before the pause switch, because a paused scheduler still ticks: one that has stopped shows as stopped, where the Resume button wouldn't help. A restart clears the previous run's last tick. Due actions run as their own tasks, so a slow brief never ages the heartbeat.\n\n### A teammate's scheduled rows\n\n`schedule_followup` and `suggest_workflow` keep the speaker on the row (`scheduled_actions.created_by_person_id`, from `Session.caller_person_id`). A due row whose creator is the principal, or that has no creator (the system's own rows, rows from before the column), takes the ordinary dispatch. A row a teammate queued runs as that teammate (`runner._run_teammate_followup`), because its intent is their own text: it is cancelled unless the creator is still an active team member and the row's address is one of their own; the Executive only writes the message, on an unattended session with `run_for_person_id` naming the teammate, which makes it read-only like a turn from another AI app that may not act (`schedule_tools.read_only_turn`: none of `MCP_CLIENT_WITHHELD_TOOLS` and only the gateway reads in `MCP_CLIENT_MCP_TOOLS`); its context is the decisions and advice of the conversation that queued it (nothing when there is none), never the company-wide list; and the runner sends the text to the teammate's own address on the row's channel (`_send_on_plan`), retrying on a failed send. A fork that limits what a teammate's turns may use applies the same limit to the run through `run_for_person_id`.\n\n**A follow-up overtaken by events.** An ad hoc follow-up back to the person who set it (the row's creator, else its conversation's owner, the principal when it has none; and only when its address is their own, `runner._followup_owner`) fires with what they wrote in chat since it was set: up to 30 of their own messages, 300 characters each, across all their conversations (`session_store.own_messages_since`; only their words, never a reply or someone else's line), in `<since_scheduled>` tags as data. The run is asked first whether that shows it is already done or no longer needed, and if so to send nothing and answer `ALREADY_HANDLED: <why>`. The runner then records the row `cancelled` with `skipped: already handled (<why>)` and a `scheduled_action` audit row with phase `skipped`, instead of `done`. A teammate's row gets the same block and check before the runner sends what it wrote. A follow-up to anyone else, or with no chat since, fires exactly as before.\n\n### Cadence DSL\n\n`openexecutive.departments.cadence` supports, all in UTC for department and workflow cadences:\n\n- `daily@HH:MM`\n- `weekly@DOW@HH:MM` or `weekly@DOW-HH:MM` (DOW is a 3-letter day, e.g. `weekly@thu@09:00`)\n- `quarterly@DD-HH:MM`\n\n`PATCH /departments/{slug}` rejects a spec that does not parse (bad format, unknown DOW, out-of-range time) with a 422 naming the valid formats, so a typo is caught at save time instead of silently never firing. An empty spec means no cadence (the department page's **Off**). A new department starts weekly, `weekly@mon@09:00`. Changing a department's `check_in` through that route re-times it at once: `cadence.reschedule_check_in()` cancels its pending `dept_cadence` row and queues the next occurrence of the new spec (nothing when it is off or in solo); a check-in already running finishes, and its chain adds nothing because the new row is pending.\n\nWhen a department cadence is due, the runner invokes the `department_check_in` workflow and chains the following occurrence via `cadence.enqueue_next()`. The fire is not passed through the authority gate: the check-in sends nothing (it grades Goals, writes one audit row and a Honcho note), and every action it proposes carries its own `gate_action` verdict in the report. Before creating a run the runner applies a skip rule (`department_check_in.needs_check_in`): the check-in is skipped when the department has no specialist agent, has no Goals, or nothing is new since its Goals were last reviewed — no decision or audit row tagged to the department (the check-in's own review row aside) since the oldest Goal's `last_reviewed_at`, and no Goal edited after it was graded. A Goal never reviewed always runs it. A skip leaves no run in the activity rail, is recorded as `cancelled` with its reason (`skipped: …` in `last_error`) rather than `done` — a done cadence row means \"the check-in ran\" to the nudge engine — and still chains the next occurrence; so does a check-in that fails once its retries are spent, so one broken department does not fall out of its cycle. That final failure also files one Home card, \"*Finance* check-in didn't finish\" (`workflows.failure_alerts`, source `workflow_failed`, tagged `failed_run:<run id>`; repeats of the same check-in coalesce into it), because nobody watches a scheduled run; a scheduled saved workflow (`dynamic_workflow`) that fails files the same card, routed to the person it delivers to. The card's **Run again** (`POST /workflows/runs/{run_id}/rerun`) queues the same action, due now, with `scope_key` `rerun:<run id>`: it skips the skip rule and does not chain another occurrence, and re-timing the check-in leaves it queued (the dept chain is idempotent anyway; a saved workflow's `schedule_dynamic_workflow_cadence` is skipped). Chaining is idempotent: while a next occurrence for the department is already pending nothing is added, so a row that chained and then failed to record its outcome never leaves two. Seeded departments start with no Goals, so their weekly check-ins cost nothing until someone adds one. Deleting a department cancels its pending `dept_cadence` rows, and `cancel_orphaned_cadences()` sweeps orphans on boot.\n\nIn **solo mode** (one person using Open Executive just for themselves; see Org) there are no department check-ins: `bootstrap_cadences()` is a no-op, switching to solo cancels every pending `dept_cadence` row, a row that was already pending is marked `cancelled` by the runner without running and without chaining — ahead of the authority gate, so a `propose_only` department cannot turn it into an approval card, and cancelled rather than done because the nudge engine reads a done check-in as a recent department pulse — and a check-in already running across the switch finishes without `enqueue_next` scheduling another. Switching back to team re-bootstraps them. Solo has one kind of its own, the **weekly review** (`principal_weekly_review`, below): switching to solo seeds it (`seed_weekly_review`), switching to team cancels its pending row (`cancel_weekly_reviews`), and one that fires while the stored mode is team is marked `cancelled` without running or chaining. That check reads the mode strictly (`workspace_settings.read_stored_mode`) and fails open: a mode that can't be read (a locked database) is not taken for team, so one bad read neither retires the review nor breaks its chain — the next run checks again.\n\nThe parser also takes a zone: `_parse_cadence_spec(spec, after, tz=UTC)` builds the wall-clock time in `tz` and only then converts to UTC, so a local schedule stays at the same local time across daylight-saving changes (a time the spring-forward gap skips fires once, just after the jump; a time the fall-back repeats fires at its first occurrence).\n\n### The principal's rhythm\n\nThe morning brief (`principal_brief_morning`, 08:00), end-of-day digest (`principal_brief_eod`, 18:00) and reflection (`executive_reflection`, 07:30) are seeded once per database by `seed_principal_briefs()` and each chains its next occurrence when it fires. In a solo workspace it also seeds the **weekly review** (`principal_weekly_review`, Friday 16:00 local by default), which runs the `weekly_review` workflow and is delivered like the briefs; its `PRINCIPAL_WEEKLY_REVIEW_TIME` takes a whole weekly spec (`weekly@fri@16:00`), read as UTC when valid, like the pinned times below, and it chains only while the workspace is still solo — and never when a weekly row is already pending, so a switch to solo while a review finishes cannot leave two. Their default times are local to the user's zone — `memory.workspace_settings.get_user_timezone()`: the zone set through `PUT /workspace`, else `USER_TIMEZONE`, else UTC — computed with the cadence parser above. An operator who pinned a valid `HH:MM` in `PRINCIPAL_BRIEF_MORNING_TIME` / `PRINCIPAL_BRIEF_EOD_TIME` / `PRINCIPAL_REFLECTION_TIME` keeps that time read as UTC, as before zones existed, so a pinned time never moves; a malformed value is logged and treated as unset. An install that set `USER_TIMEZONE` but pinned nothing does move to that zone, from each kind's first fire after the upgrade (a row seeded before it keeps its old UTC time once). When the zone in effect changes, `reschedule_principal_rhythm()` re-times each kind's pending, not-yet-due row **in place** — it only updates `run_at` (guarded on the row being unchanged since it was read), never inserts or cancels, so it cannot race a chain into a duplicate. The new time is the next occurrence in the new zone after `max(now, last fired run + 12h)`, so a kind never runs twice within 12 hours; and if that is more than 12 hours later than the row's current time — moving would skip a day, as when someone switches to Europe/London at 07:59 UTC with the 08:00 UTC brief a minute away — the row keeps its time once. A kind with no such row is left alone: a row that is running, one between being marked done and its chain insert, or a due row held by a pause or a missing company profile. Its chain times the next one in the new zone, and the chain itself starts from `max(now, fired run + 12h)`, so a zone change while a brief runs cannot put a second brief a few hours after it. The weekly review follows the same rules with a 3.5-day gap (`_min_gap`) in place of 12 hours, so a zone change can neither run it twice in a week nor skip one.\n\nUser-created (dynamic) workflows can carry the same cadence DSL. A cadence-enabled definition enqueues a `dynamic_workflow` action (`workflows.dynamic_cadence`); when due, the runner runs the stored `DynamicWorkflow`, DMs the artifact to the definition's `cadence_person_id`, and re-chains the next occurrence. Saving/updating/deleting the definition reconciles its pending `dynamic_workflow` rows. A cadence definition may not contain an approval gate — a cron fire has no human to ask — with one exception, the **held-writes** pause: when an action step holds a write to a new target, the runner checkpoints the run (`checkpoint_gate`, the owner is DMed), still marks the row done and re-chains the cadence, and stamps `deliver_to_person_id` on the resume payload so the resumer DMs the artifact to the cadence recipient once the owner answers (or the 48 h timeout skips the held writes). Any other gate is still refused at execution: it calls `workflows.gate.ensure_workflow_event`, which raises on a gate so the run is recorded as failed. It previously ignored the gate and stored a completed run with `\"(no artifact)\"` as its body, which looked like a success every period.\n\n**Monthly tally.** On the first weekday of each month, in daytime (09:00–18:00 local), a tick hook beside the reminders (`_maybe_send_monthly_value` → `briefing.value_summary.maybe_send_monthly`, checked every 15 minutes) sends the owner last month's counted lines and a link to Pulse → Your month through `_deliver_to_principal`, in solo and team mode alike. It is claimed once per month (`briefing_narrative` scope `value_summary:YYYY-MM`, never released, so one try), skipped for an empty month, audited `value_summary_sent` / `value_summary_not_sent`, and off with `VALUE_SUMMARY_MONTHLY_ENABLED=false`. It is not a `scheduled_actions` row.\n\n### Department authority & cancelling\n\nA department-scoped row passes the authority gate (`departments.authority.gate_action`, see Org) before it is dispatched: `auto_execute` dispatches; `propose_only` raises an approval card and marks the row done without dispatching (deferred to the approver's next availability window when they are outside it); `escalate` raises an urgent `[ESCALATION]` card (severity high) straight away — never deferred — and likewise does not dispatch, because approving the card is what sends it. As that card is the action's only trace it always lands: unrouted when there is no approver and no principal, and deduped on the whole action (kind, channel, recipient and intent) rather than the summary's first 60 characters, so another escalation sharing an opening — or the same text for someone else — cannot swallow it. An identical escalation folds into a still-open card and gets a fresh one once that card was handled, and a card that cannot be written retries the row with backoff and, once the retries are spent, marks it `failed` — never `done`. (It used to raise the card *and* dispatch.) The runner records which action each card holds (`alert_held_actions`, server-side only, never a tag a model could write): approving one (`POST /alerts/{id}/approve`) queues a copy of that exact action with no department, so it goes out on the next tick without meeting the gate again. A `dept_cadence` row is not gated at all — gating it turned every check-in on a propose-only department (all eight seeded ones) into a one-shot card, and the row never chained its next occurrence. Nudge-engine rows carry no department and bypass the gate.\n\nA `pending` row can be cancelled with `DELETE /scheduled/{id}` — the Pulse page's Cancel; the update only moves a row that is still `pending`, so one the scheduler has just claimed is never overwritten. Cancelling only stops work, so, like pause, any signed-in user may: the route accepts a signed-in caller through the UI proxy (its `x-caller-email`, trusted only alongside the `BACKEND_SHARED_SECRET` `x-api-key`), a matching `X-Admin-Token` (`SCHEDULED_ADMIN_TOKEN`, for scripts), or a loopback caller when no token is set — otherwise 401 (token set) or 503. Each cancel is audited as `scheduled_action_cancelled` with who did it.\n\n### Channel routing & nudges\n\nThe delivery channel lives on the `scheduled_actions` row (`channel` / `channel_ref`); the runner dispatches through whichever was set at enqueue time — `telegram`, `slack_dm`, `discord_dm`, `email`, or `__internal__` (workflow steps and heartbeats bypass outbound dispatch). Rows left pending by the removed staff-onboarding kinds drain through that same `__internal__` short-circuit (marked done, no dispatch); the removed talent workflows' *ad-hoc* reminders sat on the principal's real DM channel instead, so a one-shot startup sweep (`memory.episodic.cancel_orphaned_talent_reminders`) cancels them — `ad_hoc`, no department, `pending` or `running`, matching the five generated reminder shapes (outreach, interview coordination, reference checks, onboarding check-in, offer expiry) — and clears the awaiting-reply flag on delivered ones so the nudge engine stops chasing them. The marker row in `app_migrations` is claimed first with `INSERT OR IGNORE` in the same transaction, so concurrent boots cannot double-run or crash. The nudge engine (`scheduler.nudge_engine`, default 15 min) scans stalled `awaiting_human` runs, stale commitments, and idle initiatives, then emits `proactive_nudge` rows routed via `people.channel.prefer_channel_for` — honouring each Person's preferred (last-used) channel and availability windows, deferring those outside their window and skipping those with no reachable channel. Emission is capped per `scope_key` (`NUDGE_MAX_PER_SCOPE`, default 3 delivered nudges) so a parked item is not chased forever.\n\nAn idle initiative is chased with its department's head; with no head to resolve — no department (what the episodic extractor stores), an unknown department, or no head set — the principal owns it. That source used to skip every initiative without a head, so in practice it never fired. The principal gets self-addressed wording (\"<title>\" has not moved since <date> — still active, done, or dropped?). If channel routing cannot reach the principal (no channel configured, or unreachable beyond `NUDGE_MAX_DEFER_DAYS`), the nudge becomes an unrouted Briefing card instead, keyed on the initiative and the ISO week: at most one card per initiative per week, and while one is still unread the scan leaves it alone rather than refreshing it every 15 minutes. The emitted nudge still carries no department, and the usual caps and cooldowns apply. A department-tagged initiative is still skipped while its department's check-in actually ran inside the idle window; a skipped check-in does not count.\n\nThe stale-commitment source also chases **open loops** (see Attunement): `scheduled_actions` rows with `kind='open_loop'`, recorded `done` on the `__internal__` channel so the runner never dispatches them, whose `awaiting_response_since` is the loop's *due time*. They are chased as soon as they are overdue — not after `NUDGE_COMMITMENT_STALE_DAYS` — with a check-in intent addressed to the loop's owner (which quotes only the owner's own verbatim words and tells the dispatching turn to treat them as data), through the same `prefer_channel_for` routing, availability windows and outbound guard. Until open loops existed nothing in production set `awaiting_response_since`, so this source had nothing to chase. Each scan first closes loops older than `ATTUNEMENT_LOOP_TTL_DAYS` (21) as `expired`, then marks proactive outreach nobody answered within `ATTUNEMENT_IGNORE_AFTER_HOURS` as `ignored` in the outcome ledger. Ranking uses that ledger: a candidate whose person left their last five resolved nudges of that kind unanswered ranks after all others and waits three times its cooldown; a single answer lifts it. Approving a stalled run (however it's approved) and updating an initiative count as acting on the nudges that chased them. The generic dispatch path tags each send with its source (`_outreach_source`) so the ledger can attribute it.\n\n### Alert lifecycle: expiry sweep and the review heartbeat\n\nTwo alert-maintenance jobs live here. The **expiry sweep** is loop-level, not a heartbeat row: `_maybe_sweep_alerts` runs `alerts.lifecycle.expire_stale_alerts` (and, on the same 15-minute throttle, `monitoring.research.watch_policy.sweep` — expiring unreviewed research watch suggestions, auto-disabling research-added watches that proved noisy or dead, and filing one `watchlist_suggestions` nudge when ≥3 suggestions have waited ≥7 days; see External monitoring) once at boot and every 15 minutes at the top of the tick — before the company-profile and rotation gates, so an old backlog expires even before onboarding completes, flipping `unread` alerts past their category TTL to `expired` and auditing `alert_sweep`. Pure DB hygiene, no model call, reversible via `POST /alerts/{id}/reopen`. The same throttled call also deletes Always in the loop notes past their expiry (`memory.history.sweep_expired`; reads already skip them, and it never raises). Each tick also calls `_maybe_remind_notes` → `memory.history_reminders.maybe_remind` (its own 15-minute throttle, 09:00–18:00 local, one task at a time): a person whose notes say something they promised by email is due today gets one message saying how many, through `deliver_to_person` — the brief's own channel order for any Person, never a shared channel (`delivery_order` now skips a Telegram group id, for the briefs too), with the senders' audit rows private to that person. A hook rather than a `scheduled_actions` row, which `/scheduled` would show to everyone (see Memory).\n\nThe **Executive alert review** is a real heartbeat — kind `alert_review_scan`, `__internal__` channel, bootstrapped idempotently at startup when `ALERT_REVIEW_ENABLED` and chained every `ALERT_REVIEW_INTERVAL_HOURS` (6) with the same crash-resilient run → mark-done → chain shape as `nudge_scan`. `_run_principal_brief` also runs a `pre_brief` pass right before the morning brief (a review failure never blocks the brief). Each pass re-examines open alerts with evidence and, within department authority and the privacy rule, routes, nudges, escalates, drafts, merges or resolves them — see the Today section for the policy. The moves go through the real handlers (`message_person`, `draft_artifact`), so the outbound anti-spam guard applies, and `ALERT_REVIEW_MAX_MOVES_PER_SCAN` bounds side effects per pass.\n\nThe /today **\"What's going on\" header** is kept current from the tick too, so it is fresh before anyone opens the page. `_maybe_refresh_narrative` is a throttled call inside the loop, like the alert sweep — no `scheduled_actions` row. It runs after the pause, company-profile and rotation gates, every `BRIEFING_NARRATIVE_REFRESH_MINUTES` (10; 0 turns it off) and only between `BRIEFING_NARRATIVE_REFRESH_START_HOUR` and `_END_HOUR` (06–22) in the user's zone. It starts `today.refresh_principal_narrative` as its own task, so a slow model call never holds the tick, and never starts a second while one runs. That refreshes the cached calendar read (`live_signals.refresh_calendar`, at most once per 15 minutes) and rewrites the principal's header only when its key moved — new mail, a held reply, a proposal, the hour — with the route's own per-scope lock, so a page view and the tick never write the same header twice (see Today).\n\nAct as me's **reminders** are loop-level too: `_maybe_send_reminders` starts `delegation.reminders.maybe_send` at most once a minute, which claims each due `delegation_reminders` row once (due times are stored in UTC, so they compare in order) (compare-and-set on `claimed_at`) and sends its stored text, prefixed \"Reminder you set on <date>:\", to the person who set it alone through `deliver_to_person`. No model and no tool run; a reminder missed by more than two days is dropped rather than sent late, and one due in the person's quiet hours or leave waits, unclaimed, until they end; audit rows are private to the person. They are not `scheduled_actions` rows for the same reason as the scan below: that list is everyone's, and its rows run an Executive turn when they fire.\n\n**Held messages** are loop-level as well: `_maybe_release_held` starts `people.held_messages.maybe_release` at most once a minute, which sends each person whatever is due to them — messages held for their quiet hours once those end, and brief-held messages made due when the briefs run — as one *While you were away* message through `deliver_to_person`, claims each row first so a brief can't send it too, marks them sent only once that went, postpones a person back in quiet hours, on leave or outside their windows to when that ends, backs off 2, 4, 8 … minutes (at most an hour) after any other failure, and audits every drop (too old, over the cap) privately as a count, and writes audit rows private to the person. The principal-brief handler appends the principal's brief-held messages to the morning brief or end-of-day digest it delivers (`_with_held_messages`; the stored run artifact is unchanged), claims them, marks them sent only when the brief went (otherwise frees the claim), then makes everyone else's due (`_release_others_digests`). The `proactive_nudge` re-check calls `prefer_channel_for` / `next_available_window` with `quiet_hours=True` (urgent for a `nudge:stalled:` scope key), so a nudge due in the person's quiet hours is deferred to their end like one outside an availability window. A dispatch whose message was held is audited `held`, not `delivered`. See Org for the notification settings.\n\nAct as me's **inbox watcher** is loop-level the same way: `_maybe_scan_inbox`, after the same gates, starts the due scans (`delegation.inbox.maybe_scan`) as one task and never a second while one runs. A person is due every `DELEGATION_INBOX_POLL_MINUTES` (default 5) once their **Draft replies to my inbox** switch is on, unless a Gmail failure set a back-off; nobody is scanned while a client slot is active. It is deliberately not a `scheduled_actions` row: those are listed on `/scheduled` for everyone and anyone may cancel them, and a scan reads the owner's own mail. Every row a scan writes is private to the principal (see Act as Me).\n\n### Principal briefs\n\nThe `principal_brief_morning` / `principal_brief_eod` / `principal_weekly_review` rows (and the client-rotation digest) are delivered by `_deliver_to_principal`, not through a row channel. The principal's `preferred_channel` (`slack` / `discord` / `telegram` / `email` / `any`) is tried first, then the other chat channels they have an id for (Slack → Discord → Telegram). Email goes through the active MCP gateway: first when the preference is `email`, and otherwise last, as the backup after every chat channel. Before planning, the delivery asks the gateway supervisor for a start if the gateway is down (`runner.ensure_email_ready` → `mcp_gateway.ensure_active_gateway`, the lazy re-check), and a row action resolves the gateway at execution time rather than from what boot had, so a gateway that failed at boot and came up on a retry carries the brief. The outcome names what happened: `gateway_down` when email is set up but the gateway is not running (the Executive's fault, with the start failure, never `no_channel`, which blamed the owner's setup), and a `send_failed` detail that quotes each channel's own error (`email: invalid_grant …`, `slack_dm: channel_not_found`), stored with the outcome (`brief_state.record_delivery_outcome(detail=…)`) and shown on the Briefing notice and the Setup page's *Daily brief* light, whose fix says to reconnect when the detail shows a dead grant. Delivery stops at the first channel that sends, so an owner linked by email at setup keeps their Slack delivery without extra email, and gets the brief by email only when Slack is missing or fails. The email is formatted HTML (`utils.markdown_email`: raw HTML and images off, unsafe link schemes dropped) with a subject dated in the user's zone (\"Morning Brief — Fri 25 Sep\"). Email counts as ready only when the MCP gateway runs the Google Workspace server. Every run's outcome — delivered, no owner, nowhere to send it, every send failed, or the brief couldn't be written at all (the workflow failed or produced nothing) — is recorded with the channel's name (never an address) under `brief_state`, for the Briefing's notice and the Setup status \"Daily brief\" light (the weekly review's outcome too — `brief_state.DELIVERY_KINDS` — so a weekly review that wasn't sent is reported the same way). The light also turns amber when a brief got through only on a backup channel, naming the one that failed. `_run_principal_brief` sets `morning_brief.PRINCIPAL_DELIVERY` for the run, because it goes to the principal alone: only then (or on the principal's own verified chat turn) does the morning brief read what is private to them. When the workflow reports `private_to_principal` on its `result` event — it did read such a row — the run history keeps `persistence.PRIVATE_RUN_ARTIFACT` in place of the text (`stored_artifact`), since `/workflows/runs` is readable by everyone signed in; the principal gets the full text where it is delivered. When no channel can deliver at all (a web-only principal, or email with no gateway), the brief is still generated and stored as a run with its artifact — a web-only principal reads it on the Artifacts page — it is just not delivered, and the next occurrence is chained; see Workflows.\n\n## Client rotation claim pause\n\nThe `client_rotation` kind (multi-client practice mode, opt-in via `CLIENT_ROTATION_ENABLED`) adds one loop-level behavior: while a rotation's `.rotation_in_progress` marker exists, the scheduler **skips claiming entirely** for that tick. Rotation switches the live company context between parked clients; claiming during the window would fire the just-activated client's overdue outbound follow-ups from a context nobody is watching. Everything due fires on the first tick after the original client is restored. Stale markers (crash mid-rotation) are reconciled at scheduler startup, and the rotation row is idempotently re-seeded both at boot and after every slot activation (scheduled rows swap with the client). See the Client Companies section for the rotation's full design.\n\nAn optional `notion_sync_scan` heartbeat (`NOTION_SYNC_ENABLED`, off by default) incrementally re-indexes Notion pages the workspace integration can see into the isolated `notion_wiki` collection (not COMPANY), reconciles un-shared pages, then chains the next tick. An optional `drive_sync_scan` heartbeat (`DRIVE_SYNC_ENABLED`, off by default, bootstrapped in the lifespan beside it) does the same for the configured Google Drive folders, into the isolated `drive_docs` collection (see RAG). An optional `onedrive_sync_scan` heartbeat (`ONEDRIVE_SYNC_ENABLED`, off by default) does the same for the configured OneDrive folders, into `onedrive_docs`. An optional `confluence_sync_scan` heartbeat (`CONFLUENCE_SYNC_ENABLED`, off by default, bootstrapped in the lifespan the same way) re-indexes the changed pages of the configured Confluence spaces into the isolated `confluence_wiki` collection, leaving out restricted pages, and purges pages that were deleted, moved out or restricted.\n\n**Take the lead wakes.** With Take the lead as the Executive on, a turn from a channel (mail, Slack, Discord, Telegram, Google Chat) calls `take_the_lead.wake`, which inserts one `take_the_lead_wake` `__internal__` action five minutes out. It does nothing while one is pending or running, and nothing within 30 minutes of the last wake. The runner's `_run_take_the_lead_wake` runs the same reflection as the daily rhythm (`_reflect`, shared with `_run_executive_reflection`), only if the switch is still on, and never chains. The pause holds it like every claim.\n\n**Conversation reviews.** A kept chat turn (`memory.chat_review.record_turn`) makes sure one `chat_review` `__internal__` action is waiting for that conversation (`channel_ref` = session id), 30 minutes (`CHAT_REVIEW_QUIET_MINUTES`) out. `_run_chat_review` marks it done, then `chat_review.run_scheduled` either schedules a fresh one for 30 minutes after the newest turn (the chat is still going) or reviews the turns not yet reviewed. It never chains, and the pause holds it like every claim.\n\n**Replay of the misses.** The `chat_replay` kind (`memory.replay`) is seeded with the briefs by `seed_principal_briefs()` and chains its next occurrence like the reflection (`_run_chat_replay`; `CHAT_REPLAY_TIME`, 03:30 in the user's zone, pinned as UTC when set). It replays the turns the conversation review graded a miss with the lessons and facts in force today, in a dry run, judges each, and records the night (`chat_review_replay_runs`) whether or not anything was due; a failed night still marks done and chains. The pause holds it like every claim.",+ "markdown": "The scheduler is an asyncio task started in the FastAPI lifespan (`openexecutive.scheduler.runner.run_scheduler`). It polls every 30s and reads due rows from `scheduled_actions` (in `episodic_memory.db`). The due query uses `claim_due_actions`, an UPDATE…RETURNING claim, so each row fires at most once per process — this assumes a single scheduler instance per database. Each due row runs in its own task, started with no audit scope (`audit.context.unscoped_audit_rows`): a scheduled action is unattended and never part of the turn that scheduled it, so its audit rows follow the ordinary rule. Polls are gated on an active company profile via `_company_profile_active()`; before onboarding, due rows stay `pending`.\n\n### Operator pause\n\nA global pause switch (`openexecutive.scheduler.pause`, one row in the `executive_control` table) stops everything the Executive starts on its own. It is the first check of every scheduler tick: while paused the tick does nothing — no alert/watchlist sweep, no claim — so due rows stay `pending` and fire on the first tick after resume. Actions already claimed when the pause lands run to completion; pausing holds work, it never cancels it. The same check gates the Gmail poller (the inbox is left unread) and the workflow resumer (no `wait_for_human` timeouts or resumes, and `apply_resolution` records a reply without kicking the run). Inbound conversations — web chat, Slack, Discord, Telegram, Google Chat — are deliberately not gated. The switch is set from the sidebar, the paused banner or Settings in the UI, or via `POST /executive/pause` / `POST /executive/resume`; each flip writes an `executive_paused` / `executive_resumed` audit row. Any signed-in caller may pause (it only holds work); resuming releases every held action at once, so it is the principal's alone (open only while no principal is on the roster). The state persists across restarts (boot logs a warning while paused) and across client-slot switches. `is_paused()` is read-only: a DB file or table that does not exist yet reads as \"running\", but a read error on an existing DB reads as \"paused\" — the brake fails closed, so a storage fault holds work rather than silently releasing it while the UI still shows \"paused\" (the UI shows \"status unknown\" when it cannot read the state).\n\n### Liveness heartbeat\n\nEvery tick ends by recording when it finished and what it did — `ran`, `paused`, `waiting_for_company`, `rotating`, or `failed` when the tick raised — and `run_scheduler` notes when it started. `scheduler_heartbeat()` returns both; they live in process memory, not the database. Settings → Setup status (`GET /setup/status`) reads them: no start means the task isn't running; no tick five minutes after starting, or none for three poll intervals (at least 90 s), means the loop has stopped; `failed` and `waiting_for_company` get their own light. Liveness is judged before the pause switch, because a paused scheduler still ticks: one that has stopped shows as stopped, where the Resume button wouldn't help. A restart clears the previous run's last tick. Due actions run as their own tasks, so a slow brief never ages the heartbeat.\n\n### A teammate's scheduled rows\n\n`schedule_followup` and `suggest_workflow` keep the speaker on the row (`scheduled_actions.created_by_person_id`, from `Session.caller_person_id`). A due row whose creator is the principal, or that has no creator (the system's own rows, rows from before the column), takes the ordinary dispatch. A row a teammate queued runs as that teammate (`runner._run_teammate_followup`), because its intent is their own text: it is cancelled unless the creator is still an active team member and the row's address is one of their own; the Executive only writes the message, on an unattended session with `run_for_person_id` naming the teammate, which makes it read-only like a turn from another AI app that may not act (`schedule_tools.read_only_turn`: none of `MCP_CLIENT_WITHHELD_TOOLS` and only the gateway reads in `MCP_CLIENT_MCP_TOOLS`); its context is the decisions and advice of the conversation that queued it (nothing when there is none), never the company-wide list; and the runner sends the text to the teammate's own address on the row's channel (`_send_on_plan`), retrying on a failed send. A fork that limits what a teammate's turns may use applies the same limit to the run through `run_for_person_id`.\n\n**A follow-up overtaken by events.** An ad hoc follow-up back to the person who set it (the row's creator, else its conversation's owner, the principal when it has none; and only when its address is their own, `runner._followup_owner`) fires with what they wrote in chat since it was set: up to 30 of their own messages, 300 characters each, across all their conversations (`session_store.own_messages_since`; only their words, never a reply or someone else's line), in `<since_scheduled>` tags as data. The run is asked first whether that shows it is already done or no longer needed, and if so to send nothing and answer `ALREADY_HANDLED: <why>`. The runner then records the row `cancelled` with `skipped: already handled (<why>)` and a `scheduled_action` audit row with phase `skipped`, instead of `done`. A teammate's row gets the same block and check before the runner sends what it wrote. A follow-up to anyone else, or with no chat since, fires exactly as before.\n\n### Cadence DSL\n\n`openexecutive.departments.cadence` supports, all in UTC for department and workflow cadences:\n\n- `daily@HH:MM`\n- `weekly@DOW@HH:MM` or `weekly@DOW-HH:MM` (DOW is a 3-letter day, e.g. `weekly@thu@09:00`)\n- `quarterly@DD-HH:MM`\n\n`PATCH /departments/{slug}` rejects a spec that does not parse (bad format, unknown DOW, out-of-range time) with a 422 naming the valid formats, so a typo is caught at save time instead of silently never firing. An empty spec means no cadence (the department page's **Off**). A new department starts weekly, `weekly@mon@09:00`. Changing a department's `check_in` through that route re-times it at once: `cadence.reschedule_check_in()` cancels its pending `dept_cadence` row and queues the next occurrence of the new spec (nothing when it is off or in solo); a check-in already running finishes, and its chain adds nothing because the new row is pending.\n\nWhen a department cadence is due, the runner invokes the `department_check_in` workflow and chains the following occurrence via `cadence.enqueue_next()`. The fire is not passed through the authority gate: the check-in sends nothing (it grades Goals, writes one audit row and a Honcho note), and every action it proposes carries its own `gate_action` verdict in the report. Before creating a run the runner applies a skip rule (`department_check_in.needs_check_in`): the check-in is skipped when the department has no specialist agent, has no Goals, or nothing is new since its Goals were last reviewed — no decision or audit row tagged to the department (the check-in's own review row aside) since the oldest Goal's `last_reviewed_at`, and no Goal edited after it was graded. A Goal never reviewed always runs it. A skip leaves no run in the activity rail, is recorded as `cancelled` with its reason (`skipped: …` in `last_error`) rather than `done` — a done cadence row means \"the check-in ran\" to the nudge engine — and still chains the next occurrence; so does a check-in that fails once its retries are spent, so one broken department does not fall out of its cycle. That final failure also files one Home card, \"*Finance* check-in didn't finish\" (`workflows.failure_alerts`, source `workflow_failed`, tagged `failed_run:<run id>`; repeats of the same check-in coalesce into it), because nobody watches a scheduled run; a scheduled saved workflow (`dynamic_workflow`) that fails files the same card, routed to the person it delivers to. The card's **Run again** (`POST /workflows/runs/{run_id}/rerun`) queues the same action, due now, with `scope_key` `rerun:<run id>`: it skips the skip rule and does not chain another occurrence, and re-timing the check-in leaves it queued (the dept chain is idempotent anyway; a saved workflow's `schedule_dynamic_workflow_cadence` is skipped). Chaining is idempotent: while a next occurrence for the department is already pending nothing is added, so a row that chained and then failed to record its outcome never leaves two. Seeded departments start with no Goals, so their weekly check-ins cost nothing until someone adds one. Deleting a department cancels its pending `dept_cadence` rows, and `cancel_orphaned_cadences()` sweeps orphans on boot.\n\nIn **solo mode** (one person using Open Executive just for themselves; see Org) there are no department check-ins: `bootstrap_cadences()` is a no-op, switching to solo cancels every pending `dept_cadence` row, a row that was already pending is marked `cancelled` by the runner without running and without chaining — ahead of the authority gate, so a `propose_only` department cannot turn it into an approval card, and cancelled rather than done because the nudge engine reads a done check-in as a recent department pulse — and a check-in already running across the switch finishes without `enqueue_next` scheduling another. Switching back to team re-bootstraps them. Solo has one kind of its own, the **weekly review** (`principal_weekly_review`, below): switching to solo seeds it (`seed_weekly_review`), switching to team cancels its pending row (`cancel_weekly_reviews`), and one that fires while the stored mode is team is marked `cancelled` without running or chaining. That check reads the mode strictly (`workspace_settings.read_stored_mode`) and fails open: a mode that can't be read (a locked database) is not taken for team, so one bad read neither retires the review nor breaks its chain — the next run checks again.\n\nThe parser also takes a zone: `_parse_cadence_spec(spec, after, tz=UTC)` builds the wall-clock time in `tz` and only then converts to UTC, so a local schedule stays at the same local time across daylight-saving changes (a time the spring-forward gap skips fires once, just after the jump; a time the fall-back repeats fires at its first occurrence).\n\n### The principal's rhythm\n\nThe morning brief (`principal_brief_morning`, 08:00), end-of-day digest (`principal_brief_eod`, 18:00) and reflection (`executive_reflection`, 07:30) are seeded once per database by `seed_principal_briefs()` and each chains its next occurrence when it fires. In a solo workspace it also seeds the **weekly review** (`principal_weekly_review`, Friday 16:00 local by default), which runs the `weekly_review` workflow and is delivered like the briefs; its `PRINCIPAL_WEEKLY_REVIEW_TIME` takes a whole weekly spec (`weekly@fri@16:00`), read as UTC when valid, like the pinned times below, and it chains only while the workspace is still solo — and never when a weekly row is already pending, so a switch to solo while a review finishes cannot leave two. Their default times are local to the user's zone — `memory.workspace_settings.get_user_timezone()`: the zone set through `PUT /workspace`, else `USER_TIMEZONE`, else UTC — computed with the cadence parser above. An operator who pinned a valid `HH:MM` in `PRINCIPAL_BRIEF_MORNING_TIME` / `PRINCIPAL_BRIEF_EOD_TIME` / `PRINCIPAL_REFLECTION_TIME` keeps that time read as UTC, as before zones existed, so a pinned time never moves; a malformed value is logged and treated as unset. An install that set `USER_TIMEZONE` but pinned nothing does move to that zone, from each kind's first fire after the upgrade (a row seeded before it keeps its old UTC time once). When the zone in effect changes, `reschedule_principal_rhythm()` re-times each kind's pending, not-yet-due row **in place** — it only updates `run_at` (guarded on the row being unchanged since it was read), never inserts or cancels, so it cannot race a chain into a duplicate. The new time is the next occurrence in the new zone after `max(now, last fired run + 12h)`, so a kind never runs twice within 12 hours; and if that is more than 12 hours later than the row's current time — moving would skip a day, as when someone switches to Europe/London at 07:59 UTC with the 08:00 UTC brief a minute away — the row keeps its time once. A kind with no such row is left alone: a row that is running, one between being marked done and its chain insert, or a due row held by a pause or a missing company profile. Its chain times the next one in the new zone, and the chain itself starts from `max(now, fired run + 12h)`, so a zone change while a brief runs cannot put a second brief a few hours after it. The weekly review follows the same rules with a 3.5-day gap (`_min_gap`) in place of 12 hours, so a zone change can neither run it twice in a week nor skip one.\n\nUser-created (dynamic) workflows can carry the same cadence DSL. A cadence-enabled definition enqueues a `dynamic_workflow` action (`workflows.dynamic_cadence`); when due, the runner runs the stored `DynamicWorkflow`, DMs the artifact to the definition's `cadence_person_id`, and re-chains the next occurrence. Saving/updating/deleting the definition reconciles its pending `dynamic_workflow` rows. A cadence definition may not contain an approval gate — a cron fire has no human to ask — with one exception, the **held-writes** pause: when an action step holds a write to a new target, the runner checkpoints the run (`checkpoint_gate`, the owner is DMed), still marks the row done and re-chains the cadence, and stamps `deliver_to_person_id` on the resume payload so the resumer DMs the artifact to the cadence recipient once the owner answers (or the 48 h timeout skips the held writes). Any other gate is still refused at execution: it calls `workflows.gate.ensure_workflow_event`, which raises on a gate so the run is recorded as failed. It previously ignored the gate and stored a completed run with `\"(no artifact)\"` as its body, which looked like a success every period.\n\n**Monthly tally.** On the first weekday of each month, in daytime (09:00–18:00 local), a tick hook beside the reminders (`_maybe_send_monthly_value` → `briefing.value_summary.maybe_send_monthly`, checked every 15 minutes) sends the owner last month's counted lines and a link to Pulse → Your month through `_deliver_to_principal`, in solo and team mode alike. It is claimed once per month (`briefing_narrative` scope `value_summary:YYYY-MM`, never released, so one try), skipped for an empty month, audited `value_summary_sent` / `value_summary_not_sent`, and off with `VALUE_SUMMARY_MONTHLY_ENABLED=false`. It is not a `scheduled_actions` row.\n\n### Department authority & cancelling\n\nA department-scoped row passes the authority gate (`departments.authority.gate_action`, see Org) before it is dispatched: `auto_execute` dispatches; `propose_only` raises an approval card and marks the row done without dispatching (deferred to the approver's next availability window when they are outside it); `escalate` raises an urgent `[ESCALATION]` card (severity high) straight away — never deferred — and likewise does not dispatch, because approving the card is what sends it. As that card is the action's only trace it always lands: unrouted when there is no approver and no principal, and deduped on the whole action (kind, channel, recipient and intent) rather than the summary's first 60 characters, so another escalation sharing an opening — or the same text for someone else — cannot swallow it. An identical escalation folds into a still-open card and gets a fresh one once that card was handled, and a card that cannot be written retries the row with backoff and, once the retries are spent, marks it `failed` — never `done`. (It used to raise the card *and* dispatch.) The runner records which action each card holds (`alert_held_actions`, server-side only, never a tag a model could write): approving one (`POST /alerts/{id}/approve`) queues a copy of that exact action with no department, so it goes out on the next tick without meeting the gate again. A `dept_cadence` row is not gated at all — gating it turned every check-in on a propose-only department (all eight seeded ones) into a one-shot card, and the row never chained its next occurrence. Nudge-engine rows carry no department and bypass the gate.\n\nA `pending` row can be cancelled with `DELETE /scheduled/{id}` — the Pulse page's Cancel; the update only moves a row that is still `pending`, so one the scheduler has just claimed is never overwritten. Cancelling only stops work, so, like pause, any signed-in user may: the route accepts a signed-in caller through the UI proxy (its `x-caller-email`, trusted only alongside the `BACKEND_SHARED_SECRET` `x-api-key`), a matching `X-Admin-Token` (`SCHEDULED_ADMIN_TOKEN`, for scripts), or a loopback caller when no token is set — otherwise 401 (token set) or 503. Each cancel is audited as `scheduled_action_cancelled` with who did it.\n\n### Channel routing & nudges\n\nThe delivery channel lives on the `scheduled_actions` row (`channel` / `channel_ref`); the runner dispatches through whichever was set at enqueue time — `telegram`, `slack_dm`, `discord_dm`, `email`, or `__internal__` (workflow steps and heartbeats bypass outbound dispatch). Rows left pending by the removed staff-onboarding kinds drain through that same `__internal__` short-circuit (marked done, no dispatch); the removed talent workflows' *ad-hoc* reminders sat on the principal's real DM channel instead, so a one-shot startup sweep (`memory.episodic.cancel_orphaned_talent_reminders`) cancels them — `ad_hoc`, no department, `pending` or `running`, matching the five generated reminder shapes (outreach, interview coordination, reference checks, onboarding check-in, offer expiry) — and clears the awaiting-reply flag on delivered ones so the nudge engine stops chasing them. The marker row in `app_migrations` is claimed first with `INSERT OR IGNORE` in the same transaction, so concurrent boots cannot double-run or crash. The nudge engine (`scheduler.nudge_engine`, default 15 min) scans stalled `awaiting_human` runs, stale commitments, and idle initiatives, then emits `proactive_nudge` rows routed via `people.channel.prefer_channel_for` — honouring each Person's preferred (last-used) channel and availability windows, deferring those outside their window and skipping those with no reachable channel. Emission is capped per `scope_key` (`NUDGE_MAX_PER_SCOPE`, default 3 delivered nudges) so a parked item is not chased forever.\n\nAn idle initiative is chased with its department's head; with no head to resolve — no department (what the episodic extractor stores), an unknown department, or no head set — the principal owns it. That source used to skip every initiative without a head, so in practice it never fired. The principal gets self-addressed wording (\"<title>\" has not moved since <date> — still active, done, or dropped?). If channel routing cannot reach the principal (no channel configured, or unreachable beyond `NUDGE_MAX_DEFER_DAYS`), the nudge becomes an unrouted Briefing card instead, keyed on the initiative and the ISO week: at most one card per initiative per week, and while one is still unread the scan leaves it alone rather than refreshing it every 15 minutes. The emitted nudge still carries no department, and the usual caps and cooldowns apply. A department-tagged initiative is still skipped while its department's check-in actually ran inside the idle window; a skipped check-in does not count.\n\nThe stale-commitment source also chases **open loops** (see Attunement): `scheduled_actions` rows with `kind='open_loop'`, recorded `done` on the `__internal__` channel so the runner never dispatches them, whose `awaiting_response_since` is the loop's *due time*. They are chased as soon as they are overdue — not after `NUDGE_COMMITMENT_STALE_DAYS` — with a check-in intent addressed to the loop's owner (which quotes only the owner's own verbatim words and tells the dispatching turn to treat them as data), through the same `prefer_channel_for` routing, availability windows and outbound guard. Until open loops existed nothing in production set `awaiting_response_since`, so this source had nothing to chase. Each scan first closes loops older than `ATTUNEMENT_LOOP_TTL_DAYS` (21) as `expired`, then marks proactive outreach nobody answered within `ATTUNEMENT_IGNORE_AFTER_HOURS` as `ignored` in the outcome ledger. Ranking uses that ledger: a candidate whose person left their last five resolved nudges of that kind unanswered ranks after all others and waits three times its cooldown; a single answer lifts it. Approving a stalled run (however it's approved) and updating an initiative count as acting on the nudges that chased them. The generic dispatch path tags each send with its source (`_outreach_source`) so the ledger can attribute it.\n\n### Alert lifecycle: expiry sweep and the review heartbeat\n\nTwo alert-maintenance jobs live here. The **expiry sweep** is loop-level, not a heartbeat row: `_maybe_sweep_alerts` runs `alerts.lifecycle.expire_stale_alerts` (and, on the same 15-minute throttle, `monitoring.research.watch_policy.sweep` — expiring unreviewed research watch suggestions, auto-disabling research-added watches that proved noisy or dead, and filing one `watchlist_suggestions` nudge when ≥3 suggestions have waited ≥7 days; see External monitoring) once at boot and every 15 minutes at the top of the tick — before the company-profile and rotation gates, so an old backlog expires even before onboarding completes, flipping `unread` alerts past their category TTL to `expired` and auditing `alert_sweep`. Pure DB hygiene, no model call, reversible via `POST /alerts/{id}/reopen`. The same throttled call also deletes Always in the loop notes past their expiry (`memory.history.sweep_expired`; reads already skip them, and it never raises). Each tick also calls `_maybe_remind_notes` → `memory.history_reminders.maybe_remind` (its own 15-minute throttle, 09:00–18:00 local, one task at a time): a person whose notes say something they promised by email is due today gets one message saying how many, through `deliver_to_person` — the brief's own channel order for any Person, never a shared channel (`delivery_order` now skips a Telegram group id, for the briefs too), with the senders' audit rows private to that person. A hook rather than a `scheduled_actions` row, which `/scheduled` would show to everyone (see Memory).\n\nThe **Executive alert review** is a real heartbeat — kind `alert_review_scan`, `__internal__` channel, bootstrapped idempotently at startup when `ALERT_REVIEW_ENABLED` and chained every `ALERT_REVIEW_INTERVAL_HOURS` (6) with the same crash-resilient run → mark-done → chain shape as `nudge_scan`. `_run_principal_brief` also runs a `pre_brief` pass right before the morning brief (a review failure never blocks the brief). Each pass re-examines open alerts with evidence and, within department authority and the privacy rule, routes, nudges, escalates, drafts, merges or resolves them — see the Today section for the policy. The moves go through the real handlers (`message_person`, `draft_artifact`), so the outbound anti-spam guard applies, and `ALERT_REVIEW_MAX_MOVES_PER_SCAN` bounds side effects per pass.\n\nThe /today **\"What's going on\" header** is kept current from the tick too, so it is fresh before anyone opens the page. `_maybe_refresh_narrative` is a throttled call inside the loop, like the alert sweep — no `scheduled_actions` row. It runs after the pause, company-profile and rotation gates, every `BRIEFING_NARRATIVE_REFRESH_MINUTES` (10; 0 turns it off) and only between `BRIEFING_NARRATIVE_REFRESH_START_HOUR` and `_END_HOUR` (06–22) in the user's zone. It starts `today.refresh_principal_narrative` as its own task, so a slow model call never holds the tick, and never starts a second while one runs. That refreshes the cached calendar read (`live_signals.refresh_calendar`, at most once per 15 minutes) and rewrites the principal's header only when its key moved — new mail, a held reply, a proposal, the hour — with the route's own per-scope lock, so a page view and the tick never write the same header twice (see Today).\n\nAct as me's **reminders** are loop-level too: `_maybe_send_reminders` starts `delegation.reminders.maybe_send` at most once a minute, which claims each due `delegation_reminders` row once (due times are stored in UTC, so they compare in order) (compare-and-set on `claimed_at`) and sends its stored text, prefixed \"Reminder you set on <date>:\", to the person who set it alone through `deliver_to_person`. No model and no tool run; a reminder missed by more than two days is dropped rather than sent late, and one due in the person's quiet hours or leave waits, unclaimed, until they end; audit rows are private to the person. They are not `scheduled_actions` rows for the same reason as the scan below: that list is everyone's, and its rows run an Executive turn when they fire.\n\n**Held messages** are loop-level as well: `_maybe_release_held` starts `people.held_messages.maybe_release` at most once a minute, which sends each person whatever is due to them — messages held for their quiet hours once those end, and brief-held messages made due when the briefs run — as one *While you were away* message through `deliver_to_person`, claims each row first so a brief can't send it too, marks them sent only once that went, postpones a person back in quiet hours, on leave or outside their windows to when that ends, backs off 2, 4, 8 … minutes (at most an hour) after any other failure, and audits every drop (too old, over the cap) privately as a count, and writes audit rows private to the person. The principal-brief handler appends the principal's brief-held messages to the morning brief or end-of-day digest it delivers (`_with_held_messages`; the stored run artifact is unchanged), claims them, marks them sent only when the brief went (otherwise frees the claim), then makes everyone else's due (`_release_others_digests`). The `proactive_nudge` re-check calls `prefer_channel_for` / `next_available_window` with `quiet_hours=True` (urgent for a `nudge:stalled:` scope key), so a nudge due in the person's quiet hours is deferred to their end like one outside an availability window. A dispatch whose message was held is audited `held`, not `delivered`. See Org for the notification settings.\n\nAct as me's **inbox watcher** is loop-level the same way: `_maybe_scan_inbox`, after the same gates, starts the due scans (`delegation.inbox.maybe_scan`) as one task and never a second while one runs. A person is due every `DELEGATION_INBOX_POLL_MINUTES` (default 5) once their **Draft replies to my inbox** switch is on, unless a Gmail failure set a back-off; nobody is scanned while a client slot is active. It is deliberately not a `scheduled_actions` row: those are listed on `/scheduled` for everyone and anyone may cancel them, and a scan reads the owner's own mail. Every row a scan writes is private to the principal (see Act as Me).\n\n### Principal briefs\n\nThe `principal_brief_morning` / `principal_brief_eod` / `principal_weekly_review` rows (and the client-rotation digest) are delivered by `_deliver_to_principal`, not through a row channel. The principal's `preferred_channel` (`slack` / `discord` / `telegram` / `email` / `any`, where `any` means the chat app they last talked in) is tried first, then the other chat channels they have an id for (Slack → Discord → Telegram), by `people.reach.reach_order`. Email goes through the active MCP gateway: first when the preference is `email`, and otherwise last, as the backup after every chat channel. Before planning, the delivery asks the gateway supervisor for a start if the gateway is down (`runner.ensure_email_ready` → `mcp_gateway.ensure_active_gateway`, the lazy re-check), and a row action resolves the gateway at execution time rather than from what boot had, so a gateway that failed at boot and came up on a retry carries the brief. The outcome names what happened: `gateway_down` when email is set up but the gateway is not running (the Executive's fault, with the start failure, never `no_channel`, which blamed the owner's setup), and a `send_failed` detail that quotes each channel's own error (`email: invalid_grant …`, `slack_dm: channel_not_found`), stored with the outcome (`brief_state.record_delivery_outcome(detail=…)`) and shown on the Briefing notice and the Setup page's *Daily brief* light, whose fix says to reconnect when the detail shows a dead grant. Delivery stops at the first channel that sends, so an owner linked by email at setup keeps their Slack delivery without extra email, and gets the brief by email only when Slack is missing or fails. The email is formatted HTML (`utils.markdown_email`: raw HTML and images off, unsafe link schemes dropped) with a subject dated in the user's zone (\"Morning Brief — Fri 25 Sep\"). Email counts as ready only when the MCP gateway runs the Google Workspace server. Every run's outcome — delivered, no owner, nowhere to send it, every send failed, or the brief couldn't be written at all (the workflow failed or produced nothing) — is recorded with the channel's name (never an address) under `brief_state`, for the Briefing's notice and the Setup status \"Daily brief\" light (the weekly review's outcome too — `brief_state.DELIVERY_KINDS` — so a weekly review that wasn't sent is reported the same way). The light also turns amber when a brief got through only on a backup channel, naming the one that failed. `_run_principal_brief` sets `morning_brief.PRINCIPAL_DELIVERY` for the run, because it goes to the principal alone: only then (or on the principal's own verified chat turn) does the morning brief read what is private to them. When the workflow reports `private_to_principal` on its `result` event — it did read such a row — the run history keeps `persistence.PRIVATE_RUN_ARTIFACT` in place of the text (`stored_artifact`), since `/workflows/runs` is readable by everyone signed in; the principal gets the full text where it is delivered. When no channel can deliver at all (a web-only principal, or email with no gateway), the brief is still generated and stored as a run with its artifact — a web-only principal reads it on the Artifacts page — it is just not delivered, and the next occurrence is chained; see Workflows.\n\n## Client rotation claim pause\n\nThe `client_rotation` kind (multi-client practice mode, opt-in via `CLIENT_ROTATION_ENABLED`) adds one loop-level behavior: while a rotation's `.rotation_in_progress` marker exists, the scheduler **skips claiming entirely** for that tick. Rotation switches the live company context between parked clients; claiming during the window would fire the just-activated client's overdue outbound follow-ups from a context nobody is watching. Everything due fires on the first tick after the original client is restored. Stale markers (crash mid-rotation) are reconciled at scheduler startup, and the rotation row is idempotently re-seeded both at boot and after every slot activation (scheduled rows swap with the client). See the Client Companies section for the rotation's full design.\n\nAn optional `notion_sync_scan` heartbeat (`NOTION_SYNC_ENABLED`, off by default) incrementally re-indexes Notion pages the workspace integration can see into the isolated `notion_wiki` collection (not COMPANY), reconciles un-shared pages, then chains the next tick. An optional `drive_sync_scan` heartbeat (`DRIVE_SYNC_ENABLED`, off by default, bootstrapped in the lifespan beside it) does the same for the configured Google Drive folders, into the isolated `drive_docs` collection (see RAG). An optional `onedrive_sync_scan` heartbeat (`ONEDRIVE_SYNC_ENABLED`, off by default) does the same for the configured OneDrive folders, into `onedrive_docs`. An optional `confluence_sync_scan` heartbeat (`CONFLUENCE_SYNC_ENABLED`, off by default, bootstrapped in the lifespan the same way) re-indexes the changed pages of the configured Confluence spaces into the isolated `confluence_wiki` collection, leaving out restricted pages, and purges pages that were deleted, moved out or restricted.\n\n**Take the lead wakes.** With Take the lead as the Executive on, a turn from a channel (mail, Slack, Discord, Telegram, Google Chat) calls `take_the_lead.wake`, which inserts one `take_the_lead_wake` `__internal__` action five minutes out. It does nothing while one is pending or running, and nothing within 30 minutes of the last wake. The runner's `_run_take_the_lead_wake` runs the same reflection as the daily rhythm (`_reflect`, shared with `_run_executive_reflection`), only if the switch is still on, and never chains. The pause holds it like every claim.\n\n**Conversation reviews.** A kept chat turn (`memory.chat_review.record_turn`) makes sure one `chat_review` `__internal__` action is waiting for that conversation (`channel_ref` = session id), 30 minutes (`CHAT_REVIEW_QUIET_MINUTES`) out. `_run_chat_review` marks it done, then `chat_review.run_scheduled` either schedules a fresh one for 30 minutes after the newest turn (the chat is still going) or reviews the turns not yet reviewed. It never chains, and the pause holds it like every claim.\n\n**Replay of the misses.** The `chat_replay` kind (`memory.replay`) is seeded with the briefs by `seed_principal_briefs()` and chains its next occurrence like the reflection (`_run_chat_replay`; `CHAT_REPLAY_TIME`, 03:30 in the user's zone, pinned as UTC when set). It replays the turns the conversation review graded a miss with the lessons and facts in force today, in a dry run, judges each, and records the night (`chat_review_replay_runs`) whether or not anything was due; a failed night still marks done and chains. The pause holds it like every claim.","mermaid": "flowchart TD\n Loop[\"run_scheduler<br/>poll every 30s\"]\n Pause{\"is_paused()?<br/>(executive_control)\"}\n Claim[\"claim_due_actions<br/>(status=pending, by kind)\"]\n Table[(\"scheduled_actions\")]\n Dispatch[\"dispatch via row channel<br/>(ad_hoc / proactive_nudge)\"]\n Dept[\"dept_cadence →<br/>department_check_in<br/>(skipped when nothing is new)\"]\n Solo[\"solo workspace →<br/>cancelled, no chain\"]\n Nudge[\"nudge_scan →<br/>nudge_engine scan\"]\n Brief[\"principal_brief_morning / _eod →<br/>morning_brief / end_of_day_digest<br/>(user's local time)\"]\n Weekly[\"principal_weekly_review (solo) →<br/>weekly_review, Fri 16:00 local\"]\n Reflect[\"executive_reflection →<br/>reflection (artifact only)\"]\n ExtMon[\"external_monitor_scan →<br/>monitoring pipeline\"]\n Research[\"watchlist_research_scan →<br/>executive_research (skip-if-unchanged)\"]\n Notion[\"notion_sync_scan →<br/>isolated wiki ingest\"]\n Drive[\"drive_sync_scan →<br/>isolated Drive folder ingest\"]\n Confluence[\"confluence_sync_scan →<br/>isolated Confluence space ingest\"]\n Chain[\"enqueue_next<br/>(re-arm recurring tick)\"]\n Prefer[\"prefer_channel_for<br/>(availability + last-used)\"]\n Channels[\"Slack / Discord<br/>Telegram / Email\"]\n Principal[\"DM or email principal\"]\n Alerts[\"alerts pipeline → /today\"]\n Loop --> Pause\n Pause -- \"paused: hold, sleep\" --> Loop\n Pause -- \"running\" --> Claim\n Claim -- \"claim due rows\" --> Table\n Claim -- \"ad_hoc / proactive_nudge\" --> Dispatch\n Claim -- \"dept_cadence\" --> Dept\n Claim -- \"dept_cadence (solo)\" --> Solo\n Claim -- \"nudge_scan\" --> Nudge\n Claim -- \"principal_brief_*\" --> Brief\n Claim -- \"principal_weekly_review\" --> Weekly\n Claim -- \"executive_reflection\" --> Reflect\n Claim -- \"external_monitor_scan\" --> ExtMon\n Claim -- \"watchlist_research_scan\" --> Research\n Claim -- \"notion_sync_scan\" --> Notion\n Claim -- \"drive_sync_scan\" --> Drive\n Claim -- \"confluence_sync_scan\" --> Confluence\n Nudge -- \"prefer_channel_for\" --> Prefer\n Prefer -- \"emits proactive_nudge\" --> Table\n Dispatch --> Channels\n Brief --> Principal\n Weekly --> Principal\n ExtMon --> Alerts\n Dept --> Chain\n Nudge --> Chain\n Brief --> Chain\n Weekly -- \"while solo\" --> Chain\n Reflect --> Chain\n ExtMon --> Chain\n Research --> Chain\n Notion --> Chain\n Drive --> Chain\n Confluence --> Chain\n Chain --> Table\n class Loop entry\n class Claim compute\n class Table storage\n class Dispatch compute\n class Dept compute\n class Solo compute\n class Nudge compute\n class Brief compute\n class Weekly compute\n class Reflect compute\n class ExtMon compute\n class Research compute\n class Notion compute\n class Drive compute\n class Confluence compute\n class Chain compute\n class Prefer compute\n class Channels external\n class Principal external\n class Alerts hot","generated_at": "2026-10-18T19:51:21Z"}diff --git a/packages/core/openexecutive/architecture/prebuilt/schemas.json b/packages/core/openexecutive/architecture/prebuilt/schemas.jsonindex 106f7d8c..24435778 100644--- a/packages/core/openexecutive/architecture/prebuilt/schemas.json+++ b/packages/core/openexecutive/architecture/prebuilt/schemas.json@@ -1,7 +1,7 @@{"section_id": "schemas","title": "Data Schemas",- "markdown": "The shapes below are the load-bearing data structures: episodic SQLite tables (in `episodic_memory.db`) and the Pydantic models for departments and people.\n\n### Episodic tables\n\n| Table | Key columns |\n|---|---|\n| `decisions` | `id`, `timestamp`, `domain`, `summary`, `rationale`, `outcome`, `tags`, `department`, `session_id` |\n| `initiatives` | `id`, `title`, `status`, `created_at`, `updated_at`, `summary`, `department` |\n| `advice_given` | `id`, `timestamp`, `domain`, `query_summary`, `advice_summary`, `department`, `session_id` |\n| `facts` | `id`, `kind` (fact / correction / profile), `subject`, `subject_key`, `statement`, `previous_statement`, `source_quote`, `source_channel`, `session_id`, `turn_id`, `recorded_by_person_id`, `created_at`, `status` (active / superseded / retired), `superseded_by`, `retired_at`, `retired_reason` |\n| `scheduled_actions` | `id`, `created_at`, `run_at`, `channel`, `channel_ref`, `intent_text`, `status`, `attempts`, `kind`, `department`, `assigned_to_person_id`, `awaiting_response_since`, `scope_key`, `required_scope`, `created_by_person_id` |\n| `outbound_context` | `id`, `created_at`, `channel`, `channel_ref`, `recipient_person_id`, `outbound_text`, `originating_session_id`, `outbound_message_id`, `consumed_at`, `status` |\n| `history_reminders` | (`person_id`, `day`) PK, `sent_at` — the days a person was reminded of notes due (`memory.history_reminders`), older days pruned on write |\n| `session_drive_files` | (`session_id`, `person_id`, `file_id`) PK, `name`, `mime_type`, `link`, `summary` (first 600 chars of an opened file), `opened`, `found_by` (the search query), `first_seen_at`, `last_seen_at` — Drive files a conversation found or opened (`memory.drive_reads`) |\n| `session_drive_searches` | `id`, `session_id`, `person_id`, `query`, `result_count`, `searched_at` — every Drive search a conversation ran |\n| `saved_tools` | `name` (PK), `description`, `enabled`, `current_version`, `workflow_version` (the version workflows may run, NULL until the owner turns it on; never set for a Python tool), `kind` (`script` for `run_script`, `python` for a kept `run_python_job`; added with default `script`), `created_at`, `updated_at` — scripts and Python jobs the Executive saved to run again (`workflows.saved_tools`) |\n| `saved_tool_versions` | (`name`, `version`) PK, `description`, `script`, `tools` (JSON: the tools the script called when saved), `origin` (`chat` or `workflow:<name>/<step>`), `created_at` |\n| `saved_tool_runs` | `id`, `name`, `version`, `ok`, `calls`, `duration_ms`, `origin`, `at` — the newest 200 runs per tool |\n| `chat_messages` | `id`, `session_id`, `role`, `content`, `created_at`, `action_chips`, `stopped`, `sender_person_id`, `feedback`, `feedback_note`, `feedback_by_person_id`, `sources` (JSON `{sources: [{kind, title, url}], unavailable: [area]}` — what an assistant reply looked at and which areas it left out; NULL on older rows) |\n| `attunement_usage` | `day` (PK, UTC date), `calls` — the per-day ceiling on open-loop extraction model calls |\n| `attunement_profiles` | `person_id` (PK), `rules` (JSON: up to 8 `{text, basis, evidence}`; basis `feedback`, `stated`, `edited` or `conversation`), `locked`, `updated_at`, `updated_by`, `last_pass_at`, `pass_day`, `passes_today`, `last_message_id` — per-person working style plus pass pacing |\n| `chat_review_turns` | `id`, `session_id`, `person_id`, `surface` (JSON: the verified surface flags), `message` (the speaker's own words), `reply`, `calls` (JSON: tools run, results cut short), `created_at`, `reviewed_at` — a verified speaker's chat turns for the conversation review, kept 7 days |\n| `chat_review_days` | `day` (PK, UTC date), `runs` — the per-day ceiling on conversation reviews |\n| `brief_requests` | `id`, `kind` (`leave_out` / `raise`), `text`, `source_quote`, `person_id`, `session_id`, `created_at`, `expires_at`, `removed_at` — what the principal asked of their brief in chat |\n| `attunement_profile_history` | `id`, `person_id`, `created_at`, `rules`, `locked`, `updated_by` — every change to a working style |\n| `proactive_outcomes` | `id`, `created_at`, `person_id`, `source`, `ref`, `channel`, `channel_ref`, `outbound_context_id`, `outcome` (`replied` / `acted` / `ignored` / `void`, NULL while open), `resolved_at` — one row per proactive DM (Attunement outcome ledger) |\n| `delegation_settings` | `person_id` (PK), `enabled` (default 0), `updated_at`, `updated_by` — Act as me, per person; no row means off |\n| `history_notes` | `id`, `person_id`, `visibility` (`private`), `source` (`approved_reply`), `channel` (`email`), `conversation_key` (a hash of the channel and thread, never the thread id), `counterpart`, `subject`, `kind` (`promised` / `agreed` / `declined` / `answered` / `asked` / `shared`), `summary`, `quote` (the person's own words), `due_date`, `trust`, `occurred_at`, `created_at`, `expires_at` (NULL: until forgotten), `pinned`, `correction`, `corrected_at`, `kept_from` (when the retention clock started: NULL means `occurred_at`; an unpin restarts it) — Always in the loop, one row per note |\n| `history_settings` | `id` (1), `retention_days` (NULL: until forgotten; no row means 90), `updated_at`, `updated_by` — the company retention |\n| `history_person_settings` | `person_id` (PK), `reply_notes` (default 0), `retention_days` (NULL: the company's), `updated_at`, `updated_by` |\n| `history_excluded` | `person_id`, `conversation_key` (PK together), `created_at` — conversations a person asked not to remember |\n| `history_chat_passes` | `person_id`, `day` (PK together, UTC `YYYY-MM-DD`), `passes` — note passes run on a person's chat messages that day, against the daily cap; older days pruned on write |\n| `delegation_voice` | `person_id` (PK), `profile` (JSON: `greetings` per audience, `sign_off`, `signature`, `length`, `formality`, up to 8 `habits`, up to 6 `avoid`, up to 3 `exemplars`), `locked`, `learned_at`, `sample_count`, `updated_at`, `updated_by` — \"How I write\" |\n| `delegation_voice_history` | `id`, `person_id`, `created_at`, `profile`, `locked`, `updated_by` — every change to a writing profile |\n| `delegation_drafts` | `id`, `person_id`, `source` (`chat` \\| `inbox`), `thread_id`, `draft_id`, `message_id`, `sent_message_id`, `created_at`, `gone_at` (a chat draft found missing from their mailbox: sent or deleted there) — one row of ids per draft Act as me saved in someone's Gmail (no address, subject or text): the daily limit counts it, and \"How I write\" skips a chat draft's thread and a sent draft's message |\n| `delegation_inbox_watch` | `person_id` (PK), `enabled`, `watch_since` (reset on every off→on), `last_poll_at`, `status`, `backoff_until`, `failures`, `mailbox_drafts` (also save each reply in their Drafts; default 0, the reply lives on its card alone), `updated_at`, `updated_by` — **Draft replies to my inbox**, per person; no row means off |\n| `delegation_inbox_messages` | `id`, `person_id`, `message_id`, `thread_id`, `received_at`, `sender_key` (a hash of the address, never the address), `relation`, `outcome` (`processing`, `retry` — left for a later scan, `skipped`, `not_needed`, `deferred`, `failed`, `drafted`, `sent`, `dismissed`, `closed`, `expired`), `reason`, `classified`, `attempts`, `draft_id`, `decision_id`, `flags` (JSON), `created_at`, `updated_at`; `UNIQUE(person_id, message_id)` — the inbox watcher's cursor: what happened to each message it looked at |\n| `delegation_handle_it` | `person_id` (PK), `enabled`, `mode` (`careful`, `balanced` or `bold`), `levels` (the per-kind setting `mode` replaced, kept for older rows), `updated_at`, `updated_by` — **Handle it for me**, per person; no row means off. A `training` mode from before per-setting training moves to `balanced` with Replies and Follow-ups in training |\n| `delegation_training` | `person_id`, `setting` (`replies`, `follow_ups`, `actions` or `drafts`), `enabled`, `updated_at`, `updated_by`; primary key `(person_id, setting)` — Act as me settings in training, per person; no row means not in training |\n| `delegation_disclosure` | `person_id` (PK), `handle_it`, `approved_sends` (each NULL = as the install's `AI_DISCLOSURE_HANDLE_IT` / `AI_DISCLOSURE_APPROVED_SENDS`), `updated_at`, `updated_by` — the AI line on replies sent as that person; no row means the install's defaults |\n| `delegation_handled` | `id`, `person_id`, `thread_id`, `decision_id`, `sent_message_id`, `sent_at`; index on `(person_id, sent_at)` — one row per reply or follow-up Handle it for me sent on its own, read for its one-per-thread-a-day and daily limits |\n\n| `dynamic_workflows` | `name` (PK), `definition` (JSON of `DynamicWorkflowDef`), `is_active`, `created_at`, `updated_at`, `owner_person_id` (creator; set on insert only, kept out of the definition JSON) |\n| `workflow_approved_targets` | (`workflow_name`, `value`) PK, `key`, `approved_at`, `run_id` — targets a workflow's tool steps may write to without asking again; cleared when the workflow is deleted |\n| `executive_control` | `id` (PK, always 1), `paused`, `paused_at`, `paused_by`, `reason`, `updated_at` — the operator pause switch (`scheduler.pause`); operator-level, so client-slot switches carry it across |\n| `app_migrations` | `name` (PK), `applied_at` — one-shot data migrations (sweeps that must run exactly once per DB); schema DDL stays idempotent and is not recorded here |\n\n`department` and `session_id` are additive columns (default `''`); `session_id` scopes per-thread recall. `scheduled_actions.status` ∈ pending / running / done / failed / cancelled, and `scheduled_actions.kind` includes `dynamic_workflow` (a cadence-fired user-created workflow run) and `open_loop` (an Attunement open loop: `assigned_to_person_id` is the owner, `awaiting_response_since` the due time — cleared when the loop closes — and `scope_key` `loop:{owner}:{hash}`, unique among open loops via the partial index `idx_scheduled_open_loop_scope`). `chat_messages.sender_person_id` is the resolved rostered sender of a user message (never the session owner's principal fallback; NULL on legacy rows and for unrostered senders); `feedback` is `up` / `down` on an assistant reply. `dynamic_workflows` stores user-created (dynamic) workflow definitions interpreted by the generic `DynamicWorkflow` engine; the JSON `definition` holds free-text input fields and an ordered step list (specialist / approval_gate / synthesis) plus an optional cadence.\n\n### Legacy tables (talent / staff onboarding)\n\nThe talent (executive-search) and staff-onboarding features were removed. Their tables —\n`engagements`, `candidates`, `offers`, `onboarding_templates`, `onboarding_plans`,\n`onboarding_tasks` — are **not dropped**: no code creates, reads or writes them any more,\nbut rows survive on upgraded installs. `clients.slots` still wipes them when a blank client\nslot is activated (existence-guarded, a no-op on fresh installs) so a slot can never inherit\na previous client's candidate data.\n\n### Department / Goal / ChecklistItem\n\n| Model | Fields |\n|---|---|\n| `DepartmentConfig` | `slug`, `title`, `specialist_key`, `charter`, `authority_level`, `head_person_id`, `head_persona_slug`, `cadences`, `slack_channel_id`, `discord_channel_id`, `telegram_chat_id` |\n| `Goal` | `id`, `department_slug`, `period_type`, `period_value`, `key_result`, `target`, `current`, `status`, `created_at`, `updated_at`, `last_reviewed_at` |\n| `DepartmentState` | `config`, `goals`, `headcount`, `budget_usd`, `member_person_ids`, `updated_at` |\n\n`authority_level` ∈ `auto_execute` / `propose_only` / `escalate`; `Goal.status` ∈ `on_track` / `at_risk` / `off_track`.\n\n### Person\n\n| Field group | Fields |\n|---|---|\n| Identity | `id`, `full_name`, `role`, `is_principal`, `kind`, `department_slugs` |\n| Contact | `email`, `email_aliases`, `slack_user_id`, `telegram_chat_id`, `discord_user_id`, `preferred_channel` |\n| Routing | `availability`, `authority_scope`, `response_sla_hours`, `on_leave_until`, `reports_to_person_id` |\n| Lifecycle | `archived`, `created_at`, `updated_at` |\n\nExactly one `Person` should have `is_principal=True` — the fallback approver when no delegated person matches.\n\n`kind` is `team` (the default) or `contact` — someone outside the team, such as a client or contractor. It is an additive column, `kind TEXT NOT NULL DEFAULT 'team'`, added by the same `PRAGMA table_info`-guarded migration as `discord_user_id`, so every existing row is a team member. The principal is always `team`: the store refuses to write a principal contact (`PrincipalContactError`), and `initialize_db` repairs a hand-edited one on boot. A stored value the code does not know reads as `contact`. Every roster read in `people.store` and `people.registry` returns team members only unless it passes `include_contacts=True` (see Org).\n\n`email` is the one address a person signs in with; `email_aliases` (read from the `person_emails` table, up to 10) are other addresses they write from — they match inbound mail and may be emailed, but never sign in (see Org).\n\n### People-side tables\n\nThese live next to `people` (created by `people.store.initialize_db`, which also runs `people.roster_requests.initialize_tables`):\n\n| Table | Key columns |\n|---|---|\n| `person_emails` | `id`, `person_id` (FK → `people`, `ON DELETE CASCADE`), `email`, `email_norm` (trimmed + lowercased, **UNIQUE** across the roster), `source` (`manual` / `chat_tool` / `roster_request`), `roster_request_id`, `created_at` — a person's aliases; deleted when they are archived |\n| `roster_requests` | `id`, `channel` (`email` / `slack` / `discord` / `telegram`), `channel_ref` (the address or chat id), `display_name` (sanitised, unverified), `profile_email`, `on_company_domain`, `suggested_kind`, `suggested_person_id`, `status` (`pending` / `resolving` / `approved` / `linked` / `declined` / `expired` / `superseded`), `resolved_person_id`, `resolved_kind`, `resolved_via` (`web` / `slack` / `discord` / `telegram` / `email` / `people_page`), `resolved_at`, `token_hash` (the email answer token, hashed; cleared on resolve), `confirm_message_id`, `notified_at`, `notified_channel`, `ack_sent_at`, `alert_id`, `message_count`, `first_seen_at`, `last_seen_at`, `expires_at` — one pending row per `(channel, channel_ref)` (partial unique index) |\n| `roster_request_messages` | `id`, `request_id` (FK, cascade), `external_id` (unique per request, so a redelivery is held once), `payload_json` (what the adapter needs to replay it), `preview`, `received_at`, `replay_status` (`held` / `replaying` / `replayed` / `dropped` / `failed` / `unavailable`), `replayed_at` — at most 10 per request; `payload_json` and `preview` are blanked once a message is replayed or dropped |\n| `roster_ack_log` | `id`, `channel`, `channel_ref`, `sent_at` — one row per acknowledgement sent to a new sender, for the per-sender window and the daily cap |\n\n**Take the lead tables** (`orchestrator.take_the_lead`, created on first use, per company in `clients.slots` and `reset_all_state`): `take_the_lead` (`scope` PK: `executive` or `person:<id>`, `enabled`, `training` (added in place on older databases), `updated_at`, `updated_by`; each kind's Ask first is a `decision_class_state` row for `take_the_lead_action:<kind>`); `take_the_lead_rules` (`id`, `scope`: `company` or `person:<id>`, `kind` person|domain|words|amount, `value`, `created_by`, `created_at`); `take_the_lead_log` (`id`, `at`, `scope`, `source` reflection|research|scheduled, `tool`, `summary`, `status` done|waiting|approved|declined|failed, `why`, `decision_id`). A held action is a `decision_instances` row of class `take_the_lead_action` whose payload carries the tool, its input, whether it is an MCP tool, the gate kind or rule, the reason and the summary. `take_the_lead_allowed` (`id`, `key` unique: `<feature>|<action>|<who>`, `label`, `feature`, `example` (JSON of the edited fields, or empty), `uses`, `last_used_at`, `created_by`, `created_at`, `decision_id`, `removed_at`: set by Remove, so only approvals after it count toward a new suggestion, `person_id`: whose it is for a feature that learns per person, Act as me's `act_as_me|person:<id>|<reply|follow_up|message|invite|style>|<who>`, NULL for Take the lead; added in place on older databases): what it may do on its own in training, at most `ALLOWED_MAX` (200) per feature and person.\n\n**`telegram_chats`** (episodic DB, `integrations/telegram_chats.py`) — the Telegram chats the bot has seen, because Telegram cannot list them: `chat_id` (primary key), `chat_type` (`private`, `group` or `supergroup`), `title` (a group's title or a person's name), `username`, `first_seen_at`, `last_seen_at`. The webhook upserts a row per update only when `TELEGRAM_WEBHOOK_SECRET` checked out, drops a group that moved to a supergroup id or that removed the bot, and keeps the 500 most recently seen. Private chats are people picker options and groups are room options (`GET /chat-directory/*`). Reads never create it. A blank client slot wipes it.\n",+ "markdown": "The shapes below are the load-bearing data structures: episodic SQLite tables (in `episodic_memory.db`) and the Pydantic models for departments and people.\n\n### Episodic tables\n\n| Table | Key columns |\n|---|---|\n| `decisions` | `id`, `timestamp`, `domain`, `summary`, `rationale`, `outcome`, `tags`, `department`, `session_id` |\n| `initiatives` | `id`, `title`, `status`, `created_at`, `updated_at`, `summary`, `department` |\n| `advice_given` | `id`, `timestamp`, `domain`, `query_summary`, `advice_summary`, `department`, `session_id` |\n| `facts` | `id`, `kind` (fact / correction / profile), `subject`, `subject_key`, `statement`, `previous_statement`, `source_quote`, `source_channel`, `session_id`, `turn_id`, `recorded_by_person_id`, `created_at`, `status` (active / superseded / retired), `superseded_by`, `retired_at`, `retired_reason` |\n| `scheduled_actions` | `id`, `created_at`, `run_at`, `channel`, `channel_ref`, `intent_text`, `status`, `attempts`, `kind`, `department`, `assigned_to_person_id`, `awaiting_response_since`, `scope_key`, `required_scope`, `created_by_person_id` |\n| `outbound_context` | `id`, `created_at`, `channel`, `channel_ref`, `recipient_person_id`, `outbound_text`, `originating_session_id`, `outbound_message_id`, `consumed_at`, `status` |\n| `history_reminders` | (`person_id`, `day`) PK, `sent_at` — the days a person was reminded of notes due (`memory.history_reminders`), older days pruned on write |\n| `session_drive_files` | (`session_id`, `person_id`, `file_id`) PK, `name`, `mime_type`, `link`, `summary` (first 600 chars of an opened file), `opened`, `found_by` (the search query), `first_seen_at`, `last_seen_at` — Drive files a conversation found or opened (`memory.drive_reads`) |\n| `session_drive_searches` | `id`, `session_id`, `person_id`, `query`, `result_count`, `searched_at` — every Drive search a conversation ran |\n| `saved_tools` | `name` (PK), `description`, `enabled`, `current_version`, `workflow_version` (the version workflows may run, NULL until the owner turns it on; never set for a Python tool), `kind` (`script` for `run_script`, `python` for a kept `run_python_job`; added with default `script`), `created_at`, `updated_at` — scripts and Python jobs the Executive saved to run again (`workflows.saved_tools`) |\n| `saved_tool_versions` | (`name`, `version`) PK, `description`, `script`, `tools` (JSON: the tools the script called when saved), `origin` (`chat` or `workflow:<name>/<step>`), `created_at` |\n| `saved_tool_runs` | `id`, `name`, `version`, `ok`, `calls`, `duration_ms`, `origin`, `at` — the newest 200 runs per tool |\n| `chat_messages` | `id`, `session_id`, `role`, `content`, `created_at`, `action_chips`, `stopped`, `sender_person_id`, `feedback`, `feedback_note`, `feedback_by_person_id`, `sources` (JSON `{sources: [{kind, title, url}], unavailable: [area]}` — what an assistant reply looked at and which areas it left out; NULL on older rows) |\n| `attunement_usage` | `day` (PK, UTC date), `calls` — the per-day ceiling on open-loop extraction model calls |\n| `attunement_profiles` | `person_id` (PK), `rules` (JSON: up to 8 `{text, basis, evidence}`; basis `feedback`, `stated`, `edited` or `conversation`), `locked`, `updated_at`, `updated_by`, `last_pass_at`, `pass_day`, `passes_today`, `last_message_id` — per-person working style plus pass pacing |\n| `chat_review_turns` | `id`, `session_id`, `person_id`, `surface` (JSON: the verified surface flags), `message` (the speaker's own words), `reply`, `calls` (JSON: tools run, results cut short), `created_at`, `reviewed_at` — a verified speaker's chat turns for the conversation review, kept 7 days |\n| `chat_review_days` | `day` (PK, UTC date), `runs` — the per-day ceiling on conversation reviews |\n| `brief_requests` | `id`, `kind` (`leave_out` / `raise`), `text`, `source_quote`, `person_id`, `session_id`, `created_at`, `expires_at`, `removed_at` — what the principal asked of their brief in chat |\n| `attunement_profile_history` | `id`, `person_id`, `created_at`, `rules`, `locked`, `updated_by` — every change to a working style |\n| `proactive_outcomes` | `id`, `created_at`, `person_id`, `source`, `ref`, `channel`, `channel_ref`, `outbound_context_id`, `outcome` (`replied` / `acted` / `ignored` / `void`, NULL while open), `resolved_at` — one row per proactive DM (Attunement outcome ledger) |\n| `delegation_settings` | `person_id` (PK), `enabled` (default 0), `updated_at`, `updated_by` — Act as me, per person; no row means off |\n| `history_notes` | `id`, `person_id`, `visibility` (`private`), `source` (`approved_reply`), `channel` (`email`), `conversation_key` (a hash of the channel and thread, never the thread id), `counterpart`, `subject`, `kind` (`promised` / `agreed` / `declined` / `answered` / `asked` / `shared`), `summary`, `quote` (the person's own words), `due_date`, `trust`, `occurred_at`, `created_at`, `expires_at` (NULL: until forgotten), `pinned`, `correction`, `corrected_at`, `kept_from` (when the retention clock started: NULL means `occurred_at`; an unpin restarts it) — Always in the loop, one row per note |\n| `history_settings` | `id` (1), `retention_days` (NULL: until forgotten; no row means 90), `updated_at`, `updated_by` — the company retention |\n| `history_person_settings` | `person_id` (PK), `reply_notes` (default 0), `retention_days` (NULL: the company's), `updated_at`, `updated_by` |\n| `history_excluded` | `person_id`, `conversation_key` (PK together), `created_at` — conversations a person asked not to remember |\n| `history_chat_passes` | `person_id`, `day` (PK together, UTC `YYYY-MM-DD`), `passes` — note passes run on a person's chat messages that day, against the daily cap; older days pruned on write |\n| `delegation_voice` | `person_id` (PK), `profile` (JSON: `greetings` per audience, `sign_off`, `signature`, `length`, `formality`, up to 8 `habits`, up to 6 `avoid`, up to 3 `exemplars`), `locked`, `learned_at`, `sample_count`, `updated_at`, `updated_by` — \"How I write\" |\n| `delegation_voice_history` | `id`, `person_id`, `created_at`, `profile`, `locked`, `updated_by` — every change to a writing profile |\n| `delegation_drafts` | `id`, `person_id`, `source` (`chat` \\| `inbox`), `thread_id`, `draft_id`, `message_id`, `sent_message_id`, `created_at`, `gone_at` (a chat draft found missing from their mailbox: sent or deleted there) — one row of ids per draft Act as me saved in someone's Gmail (no address, subject or text): the daily limit counts it, and \"How I write\" skips a chat draft's thread and a sent draft's message |\n| `delegation_inbox_watch` | `person_id` (PK), `enabled`, `watch_since` (reset on every off→on), `last_poll_at`, `status`, `backoff_until`, `failures`, `mailbox_drafts` (also save each reply in their Drafts; default 0, the reply lives on its card alone), `updated_at`, `updated_by` — **Draft replies to my inbox**, per person; no row means off |\n| `delegation_inbox_messages` | `id`, `person_id`, `message_id`, `thread_id`, `received_at`, `sender_key` (a hash of the address, never the address), `relation`, `outcome` (`processing`, `retry` — left for a later scan, `skipped`, `not_needed`, `deferred`, `failed`, `drafted`, `sent`, `dismissed`, `closed`, `expired`), `reason`, `classified`, `attempts`, `draft_id`, `decision_id`, `flags` (JSON), `created_at`, `updated_at`; `UNIQUE(person_id, message_id)` — the inbox watcher's cursor: what happened to each message it looked at |\n| `delegation_handle_it` | `person_id` (PK), `enabled`, `mode` (`careful`, `balanced` or `bold`), `levels` (the per-kind setting `mode` replaced, kept for older rows), `updated_at`, `updated_by` — **Handle it for me**, per person; no row means off. A `training` mode from before per-setting training moves to `balanced` with Replies and Follow-ups in training |\n| `delegation_training` | `person_id`, `setting` (`replies`, `follow_ups`, `actions` or `drafts`), `enabled`, `updated_at`, `updated_by`; primary key `(person_id, setting)` — Act as me settings in training, per person; no row means not in training |\n| `delegation_disclosure` | `person_id` (PK), `handle_it`, `approved_sends` (each NULL = as the install's `AI_DISCLOSURE_HANDLE_IT` / `AI_DISCLOSURE_APPROVED_SENDS`), `updated_at`, `updated_by` — the AI line on replies sent as that person; no row means the install's defaults |\n| `delegation_handled` | `id`, `person_id`, `thread_id`, `decision_id`, `sent_message_id`, `sent_at`; index on `(person_id, sent_at)` — one row per reply or follow-up Handle it for me sent on its own, read for its one-per-thread-a-day and daily limits |\n\n| `dynamic_workflows` | `name` (PK), `definition` (JSON of `DynamicWorkflowDef`), `is_active`, `created_at`, `updated_at`, `owner_person_id` (creator; set on insert only, kept out of the definition JSON) |\n| `workflow_approved_targets` | (`workflow_name`, `value`) PK, `key`, `approved_at`, `run_id` — targets a workflow's tool steps may write to without asking again; cleared when the workflow is deleted |\n| `executive_control` | `id` (PK, always 1), `paused`, `paused_at`, `paused_by`, `reason`, `updated_at` — the operator pause switch (`scheduler.pause`); operator-level, so client-slot switches carry it across |\n| `app_migrations` | `name` (PK), `applied_at` — one-shot data migrations (sweeps that must run exactly once per DB); schema DDL stays idempotent and is not recorded here |\n\n`department` and `session_id` are additive columns (default `''`); `session_id` scopes per-thread recall. `scheduled_actions.status` ∈ pending / running / done / failed / cancelled, and `scheduled_actions.kind` includes `dynamic_workflow` (a cadence-fired user-created workflow run) and `open_loop` (an Attunement open loop: `assigned_to_person_id` is the owner, `awaiting_response_since` the due time — cleared when the loop closes — and `scope_key` `loop:{owner}:{hash}`, unique among open loops via the partial index `idx_scheduled_open_loop_scope`). `chat_messages.sender_person_id` is the resolved rostered sender of a user message (never the session owner's principal fallback; NULL on legacy rows and for unrostered senders); `feedback` is `up` / `down` on an assistant reply. `dynamic_workflows` stores user-created (dynamic) workflow definitions interpreted by the generic `DynamicWorkflow` engine; the JSON `definition` holds free-text input fields and an ordered step list (specialist / approval_gate / synthesis) plus an optional cadence.\n\n### Legacy tables (talent / staff onboarding)\n\nThe talent (executive-search) and staff-onboarding features were removed. Their tables —\n`engagements`, `candidates`, `offers`, `onboarding_templates`, `onboarding_plans`,\n`onboarding_tasks` — are **not dropped**: no code creates, reads or writes them any more,\nbut rows survive on upgraded installs. `clients.slots` still wipes them when a blank client\nslot is activated (existence-guarded, a no-op on fresh installs) so a slot can never inherit\na previous client's candidate data.\n\n### Department / Goal / ChecklistItem\n\n| Model | Fields |\n|---|---|\n| `DepartmentConfig` | `slug`, `title`, `specialist_key`, `charter`, `authority_level`, `head_person_id`, `head_persona_slug`, `cadences`, `slack_channel_id`, `discord_channel_id`, `telegram_chat_id` |\n| `Goal` | `id`, `department_slug`, `period_type`, `period_value`, `key_result`, `target`, `current`, `status`, `created_at`, `updated_at`, `last_reviewed_at` |\n| `DepartmentState` | `config`, `goals`, `headcount`, `budget_usd`, `member_person_ids`, `updated_at` |\n\n`authority_level` ∈ `auto_execute` / `propose_only` / `escalate`; `Goal.status` ∈ `on_track` / `at_risk` / `off_track`.\n\n### Person\n\n| Field group | Fields |\n|---|---|\n| Identity | `id`, `full_name`, `role`, `is_principal`, `kind`, `department_slugs` |\n| Contact | `email`, `email_aliases`, `slack_user_id`, `telegram_chat_id`, `discord_user_id`, `preferred_channel`, `last_channel` / `last_channel_at` (the chat app they last talked in, and when) |\n| Routing | `availability`, `authority_scope`, `response_sla_hours`, `on_leave_until`, `reports_to_person_id` |\n| Lifecycle | `archived`, `created_at`, `updated_at` |\n\nExactly one `Person` should have `is_principal=True` — the fallback approver when no delegated person matches.\n\n`kind` is `team` (the default) or `contact` — someone outside the team, such as a client or contractor. It is an additive column, `kind TEXT NOT NULL DEFAULT 'team'`, added by the same `PRAGMA table_info`-guarded migration as `discord_user_id`, so every existing row is a team member. The principal is always `team`: the store refuses to write a principal contact (`PrincipalContactError`), and `initialize_db` repairs a hand-edited one on boot. A stored value the code does not know reads as `contact`. Every roster read in `people.store` and `people.registry` returns team members only unless it passes `include_contacts=True` (see Org).\n\n`email` is the one address a person signs in with; `email_aliases` (read from the `person_emails` table, up to 10) are other addresses they write from — they match inbound mail and may be emailed, but never sign in (see Org).\n\n### People-side tables\n\nThese live next to `people` (created by `people.store.initialize_db`, which also runs `people.roster_requests.initialize_tables`):\n\n| Table | Key columns |\n|---|---|\n| `person_emails` | `id`, `person_id` (FK → `people`, `ON DELETE CASCADE`), `email`, `email_norm` (trimmed + lowercased, **UNIQUE** across the roster), `source` (`manual` / `chat_tool` / `roster_request`), `roster_request_id`, `created_at` — a person's aliases; deleted when they are archived |\n| `roster_requests` | `id`, `channel` (`email` / `slack` / `discord` / `telegram`), `channel_ref` (the address or chat id), `display_name` (sanitised, unverified), `profile_email`, `on_company_domain`, `suggested_kind`, `suggested_person_id`, `status` (`pending` / `resolving` / `approved` / `linked` / `declined` / `expired` / `superseded`), `resolved_person_id`, `resolved_kind`, `resolved_via` (`web` / `slack` / `discord` / `telegram` / `email` / `people_page`), `resolved_at`, `token_hash` (the email answer token, hashed; cleared on resolve), `confirm_message_id`, `notified_at`, `notified_channel`, `ack_sent_at`, `alert_id`, `message_count`, `first_seen_at`, `last_seen_at`, `expires_at` — one pending row per `(channel, channel_ref)` (partial unique index) |\n| `roster_request_messages` | `id`, `request_id` (FK, cascade), `external_id` (unique per request, so a redelivery is held once), `payload_json` (what the adapter needs to replay it), `preview`, `received_at`, `replay_status` (`held` / `replaying` / `replayed` / `dropped` / `failed` / `unavailable`), `replayed_at` — at most 10 per request; `payload_json` and `preview` are blanked once a message is replayed or dropped |\n| `roster_ack_log` | `id`, `channel`, `channel_ref`, `sent_at` — one row per acknowledgement sent to a new sender, for the per-sender window and the daily cap |\n\n**Take the lead tables** (`orchestrator.take_the_lead`, created on first use, per company in `clients.slots` and `reset_all_state`): `take_the_lead` (`scope` PK: `executive` or `person:<id>`, `enabled`, `training` (added in place on older databases), `updated_at`, `updated_by`; each kind's Ask first is a `decision_class_state` row for `take_the_lead_action:<kind>`); `take_the_lead_rules` (`id`, `scope`: `company` or `person:<id>`, `kind` person|domain|words|amount, `value`, `created_by`, `created_at`); `take_the_lead_log` (`id`, `at`, `scope`, `source` reflection|research|scheduled, `tool`, `summary`, `status` done|waiting|approved|declined|failed, `why`, `decision_id`). A held action is a `decision_instances` row of class `take_the_lead_action` whose payload carries the tool, its input, whether it is an MCP tool, the gate kind or rule, the reason and the summary. `take_the_lead_allowed` (`id`, `key` unique: `<feature>|<action>|<who>`, `label`, `feature`, `example` (JSON of the edited fields, or empty), `uses`, `last_used_at`, `created_by`, `created_at`, `decision_id`, `removed_at`: set by Remove, so only approvals after it count toward a new suggestion, `person_id`: whose it is for a feature that learns per person, Act as me's `act_as_me|person:<id>|<reply|follow_up|message|invite|style>|<who>`, NULL for Take the lead; added in place on older databases): what it may do on its own in training, at most `ALLOWED_MAX` (200) per feature and person.\n\n**`telegram_chats`** (episodic DB, `integrations/telegram_chats.py`) — the Telegram chats the bot has seen, because Telegram cannot list them: `chat_id` (primary key), `chat_type` (`private`, `group` or `supergroup`), `title` (a group's title or a person's name), `username`, `first_seen_at`, `last_seen_at`. The webhook upserts a row per update only when `TELEGRAM_WEBHOOK_SECRET` checked out, drops a group that moved to a supergroup id or that removed the bot, and keeps the 500 most recently seen. Private chats are people picker options and groups are room options (`GET /chat-directory/*`). Reads never create it. A blank client slot wipes it.\n","mermaid": null,"generated_at": "2026-10-18T18:00:00+00:00"}diff --git a/packages/core/openexecutive/guide/prebuilt/people.json b/packages/core/openexecutive/guide/prebuilt/people.jsonindex 5b18b21c..b319d931 100644--- a/packages/core/openexecutive/guide/prebuilt/people.json+++ b/packages/core/openexecutive/guide/prebuilt/people.json@@ -1,7 +1,7 @@{"section_id": "people","title": "People",- "markdown": "**What it is:** Everyone the Executive knows about, in two tabs. **Team** is the people who work with you. Each has a response SLA, a preferred channel and the approvals they hold. **Contacts** is everyone outside the team: clients, contractors, advisors, or anyone else you deal with. Contacts are private to you.\n\n**What it does:**\n\n- Add team members with their role, email, and their Slack, Discord and Telegram, picked by name.\n- Set a response SLA so the Executive knows when a reply is overdue.\n- Assign **authority scopes** (e.g. approve spend under $10K, sign off on hiring) so proposals route to the right person.\n- Mark the principal (you) and set availability windows or on-leave dates.\n- Track **open loops**: what each person owes. You can assign someone a task with a due date, and overdue ones are followed up automatically.\n- Show how each team member answers the Executive's messages, and the writing rules it has learned for them.\n- Keep **contacts** so the Executive can email or invite them, only when you ask it to directly (in the web app, or from your own Slack or Discord). A contact can't sign in, can't message the Executive, never approves anything, and is never chased.\n- Keep contacts **private**: only you see them. Nobody else on your team sees the Contacts tab, finds a contact when they ask the Executive, or sees an alert about one.\n\n**Team member or contact?**\n\n| | Team member | Contact |\n|---|---|---|\n| Signs in to Open Executive (with an email) | Yes | No |\n| Messages the Executive on Slack / Discord / Telegram | Yes | No |\n| Approves proposals, gets check-ins and reminders | Yes | No |\n| The Executive emails or invites them | On any task | Only when you ask directly |\n| Who sees them | Everyone on the team | Only you |\n\n**How to use:**\n\n1. Open **Company** in the sidebar (it opens on **People**). Pick the **Team** or **Contacts** tab and click **Add person** (or **Add contact**). Only you, the principal, see the Contacts tab. Each card shows the person's name, role, preferred channel and one status, such as on leave.\n2. Choose **Team member** or **Contact** at the top of the panel. Enter **Full name** (the only required field), **Role** (for a contact, **Role and company**, e.g. *Head of Procurement, Acme*) and **Email**. If this is you, tick **This is me — Primary**. You can only set this when adding someone, and the principal is always on the team.\n3. For a team member, expand **Contact & routing**: **Preferred channel** (any, slack, discord, telegram or email), **Expected reply within *N* hours** (their SLA, default 24; items show as overdue on Home after that), and their **Slack**, **Discord** and **Telegram**. Those are also what lets this person talk to the Executive on those channels. For a contact, they are under **Chat apps**.\n - Pick each one by name: type to search, then click the person. With an email typed, Slack shows **Found by email** with their name already picked; click **Not them?** to choose someone else.\n - **Discord** lists the members of the bot's servers. If it can't (the bot's Server Members intent is off in Discord's developer settings), enter their ID by hand.\n - **Telegram** lists people who have messaged the bot. Not listed? Ask them to send the bot any message.\n - **Enter an ID by hand** under each one takes a raw ID instead. A chat app with no bot set up shows only the ID field.\n4. For a team member, expand **Approval authority** and click each scope they hold:\n\n | Button | They receive |\n |---|---|\n | Spend <$2K / <$10K / >$10K | Proposals for spend in that range |\n | Hiring | Proposals related to hiring decisions |\n | Vendors | Proposals for vendor contracts |\n | Credit | Proposals involving credit or debt |\n | Legal | Proposals with legal implications |\n | Board | Proposals before board communications |\n | Meetings | Meetings the Executive wants to book |\n | All (wildcard) | Anything no one else is scoped for. Usually the principal |\n\n5. Click **Add person** (or **Add contact**).\n\n*A person's page*\n\nClick a card to open the person. The page has up to four tabs:\n\n- **Overview**: email, other addresses, how to reach them, and any leave date. Team members also show **Open loops** here.\n- **Approvals & availability**: what they approve, and their **Availability windows** (days, start and end time, timezone). With no windows, they count as always available.\n- **How they respond**: proactive messages sent to them over the last 30 days, and how many they answered. Kinds of message they reliably ignore are sent less often.\n- **How I work with them**: how replies are written for them, learned from their own 👍/👎 and what they ask for in chats. Click **Edit rules** to type up to 8 rules, one per line; typed rules are always kept. The **⋯** menu has **Lock (stop learning)** / **Unlock (keep learning)** and **Reset what was learned**.\n\nA contact's page has only **Overview**. An archived person has no **How they respond** or **How I work with them** tab.\n\n*Change someone*\n\n1. Click **Edit** at the top of their page. On **Overview** you can change the name, role, **Team member or contact**, email, **Other addresses** (one per line: mail from these reaches them and they can be emailed there; only the main email signs in), preferred channel and SLA. Slack, Discord and Telegram are under **Chat apps**, picked by name as when adding someone (it opens on its own when Slack finds them by email). **On leave until** is under **Advanced**.\n2. To change approvals or availability, switch to **Approvals & availability** while editing: click scopes on or off, and use **Add window** / **Remove window**.\n3. Click **Save**.\n4. **Archive person**, in the **⋯** menu next to **Edit**, takes them off routing and the active roster. They get no new assignments; their history is kept. The principal can't be archived.\n\n*Open loops*\n\n- **Open loops** lists things a person committed to, was asked for in conversation, or was assigned. Overdue ones are followed up automatically. Click **Mark done** to close one.\n- To assign a task, type it in **Assign a task** (up to 200 characters), optionally pick a **Due** date, and click **Assign**. The person is told once on their own channel, and the page says whether it reached them.\n\n**Who can see and change it:**\n\n- Only the principal can add, edit or archive people. Until someone is the principal, whoever sets up first can.\n- Everyone signed in sees the team. Contacts stay yours alone.\n- Anyone on the team can assign a task to anyone on the team. Only the principal and the person themselves see that person's open loops, **How they respond** and **How I work with them**, and only they can close a loop or change the working-style rules.\n\n**Someone new wrote in:** when someone who isn't on People messages the Executive, their messages are held and a card **Who is *name*?** appears on Home. Click **Add them** and choose **Add as a new person** (enter their name and pick team or contact) or **Someone already on the list**. Their waiting messages are answered once they're added. **Ignore** is in the card's **⋯** menu. Only the principal sees these cards.\n\n**Example from chat:** *\"Add Sarah Chen as our fractional CFO — [email protected] — she approves spend under $10k and usually replies within 48 hours.\"* Or: *\"Add Jordan Lee from Acme as a contact — [email protected] — and send them the proposal.\"* Or open **Add person**, press **Ctrl/Cmd + .**, and describe the person. The help panel (the sparkle button at the top right) fills in the panel for you to check and save.\n\n**Forward it to the Executive:** forward an email from a client to the Executive's address and it replies to you, not them, with a summary, a draft reply you can send, any dates or commitments, and an offer to add the sender as a contact. Mail a contact sends the Executive directly is summarised for you, never answered on its own. Either way it stays between you and the Executive: it tells no one else, and any alert it raises is yours alone.\n\n**Just for yourself?** When you use Open Executive just for yourself, setup adds only you, marked as the principal, with authority over everything. **People** sits in the sidebar under **You** and opens on **Contacts**. Anyone you add from chat is a contact unless you say otherwise, and the **Team** tab shows just you. Other team members are hidden in this mode; the page says how many. If you add a team member (or move a contact onto the team), Open Executive asks **Switch to team mode?**: click **Switch to team mode** or **Keep it just for me**. Home doesn't show a People tile in this mode.\n\n*Note: authority scopes are how the Executive figures out who on the team to ask for any given approval.*",+ "markdown": "**What it is:** Everyone the Executive knows about, in two tabs. **Team** is the people who work with you. Each has a response SLA, a preferred channel and the approvals they hold. **Contacts** is everyone outside the team: clients, contractors, advisors, or anyone else you deal with. Contacts are private to you.\n\n**What it does:**\n\n- Add team members with their role, email, and their Slack, Discord and Telegram, picked by name.\n- Set a response SLA so the Executive knows when a reply is overdue.\n- Assign **authority scopes** (e.g. approve spend under $10K, sign off on hiring) so proposals route to the right person.\n- Mark the principal (you) and set availability windows or on-leave dates.\n- Track **open loops**: what each person owes. You can assign someone a task with a due date, and overdue ones are followed up automatically.\n- Show how each team member answers the Executive's messages, and the writing rules it has learned for them.\n- Keep **contacts** so the Executive can email or invite them, only when you ask it to directly (in the web app, or from your own Slack or Discord). A contact can't sign in, can't message the Executive, never approves anything, and is never chased.\n- Keep contacts **private**: only you see them. Nobody else on your team sees the Contacts tab, finds a contact when they ask the Executive, or sees an alert about one.\n\n**Team member or contact?**\n\n| | Team member | Contact |\n|---|---|---|\n| Signs in to Open Executive (with an email) | Yes | No |\n| Messages the Executive on Slack / Discord / Telegram | Yes | No |\n| Approves proposals, gets check-ins and reminders | Yes | No |\n| The Executive emails or invites them | On any task | Only when you ask directly |\n| Who sees them | Everyone on the team | Only you |\n\n**How to use:**\n\n1. Open **Company** in the sidebar (it opens on **People**). Pick the **Team** or **Contacts** tab and click **Add person** (or **Add contact**). Only you, the principal, see the Contacts tab. Each card shows the person's name, role, preferred channel and one status, such as on leave.\n2. Choose **Team member** or **Contact** at the top of the panel. Enter **Full name** (the only required field), **Role** (for a contact, **Role and company**, e.g. *Head of Procurement, Acme*) and **Email**. If this is you, tick **This is me — Primary**. You can only set this when adding someone, and the principal is always on the team.\n3. For a team member, expand **Contact & routing**: **Preferred channel** (**Where they last talked**, Slack, Discord, Telegram or Email; with **Where they last talked** the Executive messages them in the chat app they last used with it, then any other app they have, then email), **Expected reply within *N* hours** (their SLA, default 24; items show as overdue on Home after that), and their **Slack**, **Discord** and **Telegram**. Those are also what lets this person talk to the Executive on those channels. For a contact, they are under **Chat apps**.\n - Pick each one by name: type to search, then click the person. With an email typed, Slack shows **Found by email** with their name already picked; click **Not them?** to choose someone else.\n - **Discord** lists the members of the bot's servers. If it can't (the bot's Server Members intent is off in Discord's developer settings), enter their ID by hand.\n - **Telegram** lists people who have messaged the bot. Not listed? Ask them to send the bot any message.\n - **Enter an ID by hand** under each one takes a raw ID instead. A chat app with no bot set up shows only the ID field.\n4. For a team member, expand **Approval authority** and click each scope they hold:\n\n | Button | They receive |\n |---|---|\n | Spend <$2K / <$10K / >$10K | Proposals for spend in that range |\n | Hiring | Proposals related to hiring decisions |\n | Vendors | Proposals for vendor contracts |\n | Credit | Proposals involving credit or debt |\n | Legal | Proposals with legal implications |\n | Board | Proposals before board communications |\n | Meetings | Meetings the Executive wants to book |\n | All (wildcard) | Anything no one else is scoped for. Usually the principal |\n\n5. Click **Add person** (or **Add contact**).\n\n*A person's page*\n\nClick a card to open the person. The page has up to four tabs:\n\n- **Overview**: email, other addresses, how to reach them, and any leave date. Team members also show **Open loops** here.\n- **Approvals & availability**: what they approve, and their **Availability windows** (days, start and end time, timezone). With no windows, they count as always available.\n- **How they respond**: proactive messages sent to them over the last 30 days, and how many they answered. Kinds of message they reliably ignore are sent less often.\n- **How I work with them**: how replies are written for them, learned from their own 👍/👎 and what they ask for in chats. Click **Edit rules** to type up to 8 rules, one per line; typed rules are always kept. The **⋯** menu has **Lock (stop learning)** / **Unlock (keep learning)** and **Reset what was learned**.\n\nA contact's page has only **Overview**. An archived person has no **How they respond** or **How I work with them** tab.\n\n*Change someone*\n\n1. Click **Edit** at the top of their page. On **Overview** you can change the name, role, **Team member or contact**, email, **Other addresses** (one per line: mail from these reaches them and they can be emailed there; only the main email signs in), preferred channel and SLA. Slack, Discord and Telegram are under **Chat apps**, picked by name as when adding someone (it opens on its own when Slack finds them by email). **On leave until** is under **Advanced**.\n2. To change approvals or availability, switch to **Approvals & availability** while editing: click scopes on or off, and use **Add window** / **Remove window**.\n3. Click **Save**.\n4. **Archive person**, in the **⋯** menu next to **Edit**, takes them off routing and the active roster. They get no new assignments; their history is kept. The principal can't be archived.\n\n*Open loops*\n\n- **Open loops** lists things a person committed to, was asked for in conversation, or was assigned. Overdue ones are followed up automatically. Click **Mark done** to close one.\n- To assign a task, type it in **Assign a task** (up to 200 characters), optionally pick a **Due** date, and click **Assign**. The person is told once on their own channel, and the page says whether it reached them.\n\n**Who can see and change it:**\n\n- Only the principal can add, edit or archive people. Until someone is the principal, whoever sets up first can.\n- Everyone signed in sees the team. Contacts stay yours alone.\n- Anyone on the team can assign a task to anyone on the team. Only the principal and the person themselves see that person's open loops, **How they respond** and **How I work with them**, and only they can close a loop or change the working-style rules.\n\n**Someone new wrote in:** when someone who isn't on People messages the Executive, their messages are held and a card **Who is *name*?** appears on Home. Click **Add them** and choose **Add as a new person** (enter their name and pick team or contact) or **Someone already on the list**. Their waiting messages are answered once they're added. **Ignore** is in the card's **⋯** menu. Only the principal sees these cards.\n\n**Example from chat:** *\"Add Sarah Chen as our fractional CFO — [email protected] — she approves spend under $10k and usually replies within 48 hours.\"* Or: *\"Add Jordan Lee from Acme as a contact — [email protected] — and send them the proposal.\"* Or open **Add person**, press **Ctrl/Cmd + .**, and describe the person. The help panel (the sparkle button at the top right) fills in the panel for you to check and save.\n\n**Forward it to the Executive:** forward an email from a client to the Executive's address and it replies to you, not them, with a summary, a draft reply you can send, any dates or commitments, and an offer to add the sender as a contact. Mail a contact sends the Executive directly is summarised for you, never answered on its own. Either way it stays between you and the Executive: it tells no one else, and any alert it raises is yours alone.\n\n**Just for yourself?** When you use Open Executive just for yourself, setup adds only you, marked as the principal, with authority over everything. **People** sits in the sidebar under **You** and opens on **Contacts**. Anyone you add from chat is a contact unless you say otherwise, and the **Team** tab shows just you. Other team members are hidden in this mode; the page says how many. If you add a team member (or move a contact onto the team), Open Executive asks **Switch to team mode?**: click **Switch to team mode** or **Keep it just for me**. Home doesn't show a People tile in this mode.\n\n*Note: authority scopes are how the Executive figures out who on the team to ask for any given approval.*","mermaid": null,"generated_at": "2026-10-18T18:00:00+00:00"}diff --git a/packages/core/openexecutive/orchestrator/executive.py b/packages/core/openexecutive/orchestrator/executive.pyindex 302c8782..41f4e7e0 100644--- a/packages/core/openexecutive/orchestrator/executive.py+++ b/packages/core/openexecutive/orchestrator/executive.py@@ -3629,6 +3629,12 @@ class Executive:common_kwargs["peer_memory_context"] = peer_memory_contextif standing_facts is not None:common_kwargs["standing_facts"] = standing_facts+ # A chat app turn from the person's own account: messages to them go+ # here next, unless they picked a channel (people.reach).+ if session.origin_channel:+ from openexecutive.people.reach import note_talked++ await asyncio.to_thread(note_talked, session)stream = (self.stream_chat_with_committee(**common_kwargs)if committee_reviewdiff --git a/packages/core/openexecutive/orchestrator/schedule_tools.py b/packages/core/openexecutive/orchestrator/schedule_tools.pyindex d46ab197..1e95f0cf 100644--- a/packages/core/openexecutive/orchestrator/schedule_tools.py+++ b/packages/core/openexecutive/orchestrator/schedule_tools.py@@ -1438,6 +1438,15 @@ async def handle_message_person(tool_input: dict[str, Any]) -> str:return await message_person(tool_input)+def _chat_candidates(person: Any) -> list[tuple[str, str | None]]:+ """The person's chat channels as (channel, stored id) pairs, in+ ``people.reach.reach_order``'s order."""+ from openexecutive.people.reach import channel_id, reach_order++ # A group id stays a candidate here, as before: message_person validates it.+ return [(c, channel_id(person, c)) for c in reach_order(person, email=False, telegram_groups=True)]++async def message_person(tool_input: dict[str, Any], *, alert_fallback: bool = True) -> str:"""Send a DM to a rostered person, resolving the channel + real channel idserver-side from their person_id.@@ -1504,18 +1513,12 @@ async def message_person(tool_input: dict[str, Any], *, alert_fallback: bool = Tconfigured = configured_integrations(get_settings())# Candidate channels for this person, each a (channel, the person's stored- # id for it) pair. Stable-sorted so preferred_channel comes first and the- # rest keep discord > telegram > slack order. We only route to a channel+ # id for it) pair, in people.reach's order (their pick, else where they+ # last talked, then Slack > Discord > Telegram). We only route to a channel# that is configured on this deployment AND that the person has a# well-formed id for (a malformed stored id is skipped, not handed to the# API as a misleading "bad arguments" error from the delegate).- candidates: list[tuple[str, str | None]] = [- ("discord", person.discord_user_id),- ("telegram", person.telegram_chat_id),- ("slack", person.slack_user_id),- ]- preferred = (person.preferred_channel or "").lower()- candidates.sort(key=lambda c: 0 if c[0] == preferred else 1)+ candidates = _chat_candidates(person)# Try each usable channel in turn; a send failure (e.g. Discord 403 when the# bot can't DM that user) falls through to the next channel rather than@@ -1667,15 +1670,7 @@ def resolve_person_scheduled_dm(``slack_dm``) so a caller can enqueue a follow-up the runner will deliver.The two share the channel-validation rules; keep them in sync."""- candidates: list[tuple[str, str | None]] = [- ("discord", getattr(person, "discord_user_id", None)),- ("telegram", getattr(person, "telegram_chat_id", None)),- ("slack", getattr(person, "slack_user_id", None)),- ]- preferred = (getattr(person, "preferred_channel", "") or "").lower()- candidates.sort(key=lambda c: 0 if c[0] == preferred else 1)-- for channel, channel_ref in candidates:+ for channel, channel_ref in _chat_candidates(person):if channel not in configured or not channel_ref:continueif channel == "discord":diff --git a/packages/core/openexecutive/people/channel.py b/packages/core/openexecutive/people/channel.pyindex 95648ab5..04420b9c 100644--- a/packages/core/openexecutive/people/channel.py+++ b/packages/core/openexecutive/people/channel.py@@ -84,28 +84,23 @@ def _in_window(window: AvailabilityWindow, now: datetime) -> bool:def _channel_ref_for(person: Person, channel: str) -> str | None:"""Return the channel reference string for a Person on a given channel."""- if channel == "email":- return person.email- if channel == "slack":- return person.slack_user_id- if channel == "telegram":- return person.telegram_chat_id- if channel == "discord":- return person.discord_user_id- return None+ from openexecutive.people.reach import channel_id+ return channel_id(person, channel)-def _resolve_channel(person: Person) -> tuple[str, str | None]:- """Return (preferred_channel, channel_ref_or_None) for the person.- If preferred_channel is "any", tries email → slack → discord → telegram- in order.+def _resolve_channel(person: Person) -> tuple[str, str | None]:+ """Return (channel, channel_ref_or_None) for the person: the first channel+ in ``people.reach.reach_order`` (their pick, else where they last talked,+ then Slack, Discord, Telegram, then email). A picked channel with no id+ stays the answer, with no ref."""+ from openexecutive.people.reach import reach_order+pref = person.preferred_channelif pref != "any":return pref, _channel_ref_for(person, pref)- # Try in priority order.- for ch in ("email", "slack", "discord", "telegram"):+ for ch in reach_order(person):ref = _channel_ref_for(person, ch)if ref:return ch, refdiff --git a/packages/core/openexecutive/people/models.py b/packages/core/openexecutive/people/models.pyindex 747ac722..1f3a3db8 100644--- a/packages/core/openexecutive/people/models.py+++ b/packages/core/openexecutive/people/models.py@@ -104,6 +104,12 @@ class Person(BaseModel):telegram_chat_id: str | None = Nonediscord_user_id: str | None = Nonepreferred_channel: PreferredChannel = "any"+ # The chat app they last talked to the Executive in, from their own+ # account (``people.reach.note_talked``), and when (ISO, UTC). With+ # ``preferred_channel`` "any", messages go there first.+ last_channel: str | None = None+ # Not serialised: when someone last talked is nobody else's business.+ last_channel_at: str | None = Field(default=None, exclude=True)availability: list[AvailabilityWindow] = Field(default_factory=list)authority_scope: list[AuthorityScope] = Field(default_factory=list)response_sla_hours: int = 24diff --git a/packages/core/openexecutive/people/reach.py b/packages/core/openexecutive/people/reach.pynew file mode 100644index 00000000..38f3111e--- /dev/null+++ b/packages/core/openexecutive/people/reach.py@@ -0,0 +1,104 @@+"""Where the Executive reaches a person: one rule for every message it sends.++``reach_order`` puts the channels a person has an address or id for in the+order to try:++1. Their preferred channel, when they picked one.+2. Otherwise (preference ``any``) the chat app they last talked to the+ Executive in, from their own account (``note_talked``).+3. Then the other chat apps: Slack, Discord, Telegram.+4. Email last, as the backup, unless it was the one picked.++Briefs and reminders (``scheduler.runner.delivery_order``), messages+(``orchestrator.schedule_tools.message_person``), follow-ups and nudges+(``people.channel``) all take their order from here; each still checks that+its channel is set up and the stored id is usable before sending.+"""+from __future__ import annotations++import logging+from typing import Any++from openexecutive.people.models import Person++logger = logging.getLogger(__name__)++CHAT_ORDER: tuple[str, ...] = ("slack", "discord", "telegram")+# The chat apps whose messages can tell where a person last talked.+_TALK_CHANNELS = frozenset(CHAT_ORDER)+++def channel_id(person: Person, channel: str) -> str | None:+ """The person's stored address or id for ``channel``."""+ if channel == "email":+ return person.email+ if channel == "slack":+ return person.slack_user_id+ if channel == "discord":+ return person.discord_user_id+ if channel == "telegram":+ return person.telegram_chat_id+ return None+++def first_choice(person: Person) -> str | None:+ """The channel to try first: the one they picked, else where they last+ talked."""+ pref = (person.preferred_channel or "any").lower()+ if pref != "any":+ return pref+ last = (person.last_channel or "").lower()+ return last if last in _TALK_CHANNELS else None+++def _private_telegram(person: Person) -> bool:+ return str(person.telegram_chat_id or "").isdigit()+++def reach_order(person: Person, *, email: bool = True, telegram_groups: bool = False) -> list[str]:+ """The channels ``person`` has an address or id for, in the order to try+ (see the module docstring). ``email=False`` leaves email out. A Telegram+ group id (negative: everyone in the group reads it) counts only with+ ``telegram_groups``, for a message someone asked to send there."""+ chat = [+ c for c in CHAT_ORDER+ if channel_id(person, c) and (c != "telegram" or telegram_groups or _private_telegram(person))+ ]+ first = first_choice(person)+ order = ([first] if first in chat else []) + [c for c in chat if c != first]+ if email and person.email:+ if first == "email":+ order.insert(0, "email")+ else:+ order.append("email")+ return order+++def note_talked(session: Any) -> bool:+ """Remember the chat app this turn came in on as where its person last+ talked: only when the turn is from their own account there (the stored+ Slack or Discord user id, or their private Telegram chat). Sync (SQLite);+ never raises. True when it recorded it."""+ channel = str(getattr(session, "origin_channel", "") or "")+ person_id = getattr(session, "caller_person_id", None)+ ref = str(getattr(session, "origin_channel_ref", "") or "")+ if channel not in _TALK_CHANNELS or not isinstance(person_id, int) or not ref:+ return False+ try:+ from openexecutive.people.store import get_person, note_last_channel++ person = get_person(person_id)+ if person is None or person.archived or channel_id(person, channel) != ref:+ return False+ if channel == "telegram":+ if not ref.isdigit():+ return False # a group chat isn't theirs alone+ from openexecutive.integrations.channel_cards import telegram_proves_taps++ # Without a valid webhook secret anyone can post a Telegram update.+ if not telegram_proves_taps():+ return False+ return note_last_channel(person_id, channel)+ except Exception:+ logger.warning("reach: couldn't record where person %s last talked", person_id, exc_info=True)+ return Falsediff --git a/packages/core/openexecutive/people/store.py b/packages/core/openexecutive/people/store.pyindex 6800f8fc..d89fb04c 100644--- a/packages/core/openexecutive/people/store.py+++ b/packages/core/openexecutive/people/store.py@@ -23,7 +23,7 @@ import osimport sqlite3from collections.abc import Generatorfrom contextlib import contextmanager-from datetime import UTC, date, datetime+from datetime import UTC, date, datetime, timedeltafrom pathlib import Pathfrom openexecutive.people.models import (@@ -179,6 +179,14 @@ def initialize_db(db_path: Path | None = None) -> None:except sqlite3.OperationalError as exc:if "duplicate column" not in str(exc).lower():raise+ # Additive migration: the chat app each person last talked in.+ for column in ("last_channel", "last_channel_at"):+ if column not in cols:+ try:+ conn.execute(f"ALTER TABLE people ADD COLUMN {column} TEXT")+ except sqlite3.OperationalError as exc:+ if "duplicate column" not in str(exc).lower():+ raise# The principal is never a contact; repair a hand-edited row so every# team-only read keeps finding them.conn.execute(@@ -247,6 +255,15 @@ def _load_aliases(person_id: int, conn: sqlite3.Connection) -> list[str]:return [row["email"] for row in rows]+def _optional(row: sqlite3.Row, column: str) -> str | None:+ """A column ``initialize_db`` may not have migrated yet reads as None."""+ try:+ value = row[column]+ except (IndexError, KeyError):+ return None+ return str(value) if value else None++def _row_to_person(row: sqlite3.Row, conn: sqlite3.Connection) -> Person:person_id = int(row["id"])try:@@ -278,6 +295,8 @@ def _row_to_person(row: sqlite3.Row, conn: sqlite3.Connection) -> Person:telegram_chat_id=row["telegram_chat_id"],discord_user_id=row["discord_user_id"],preferred_channel=row["preferred_channel"],+ last_channel=_optional(row, "last_channel"),+ last_channel_at=_optional(row, "last_channel_at"),response_sla_hours=int(row["response_sla_hours"]),on_leave_until=on_leave,reports_to_person_id=row["reports_to_person_id"],@@ -384,6 +403,29 @@ def upsert_person(return person_id+def note_last_channel(+ person_id: int,+ channel: str,+ *,+ now: datetime | None = None,+ db_path: Path | None = None,+) -> bool:+ """Record that ``person_id`` just talked in ``channel``. Leaves+ ``updated_at`` alone (it isn't an edit of the person), and skips the write+ while the stored channel is the same and under an hour old. True when it+ wrote."""+ stamp = (now or datetime.now(UTC)).astimezone(UTC)+ an_hour_ago = (stamp - timedelta(hours=1)).isoformat()+ with _get_conn(db_path) as conn:+ cur = conn.execute(+ "UPDATE people SET last_channel = ?, last_channel_at = ?"+ " WHERE id = ? AND (last_channel IS NULL OR last_channel != ?"+ " OR last_channel_at IS NULL OR last_channel_at < ?)",+ (channel, stamp.isoformat(), person_id, channel, an_hour_ago),+ )+ return cur.rowcount > 0++def set_authority_scope(person_id: int,scopes: list[AuthorityScope],diff --git a/packages/core/openexecutive/scheduler/runner.py b/packages/core/openexecutive/scheduler/runner.pyindex c7e161b9..ce0cca57 100644--- a/packages/core/openexecutive/scheduler/runner.py+++ b/packages/core/openexecutive/scheduler/runner.py@@ -2106,51 +2106,34 @@ def _delivered_ok(result_json: str) -> bool:)-# `Person.preferred_channel` values (people/models.py PreferredChannel) mapped-# to the delivery channels below. "any" has no entry: it keeps the fallback-# order.-_PREFERRED_TO_DELIVERY: dict[str, str] = {+# ``people.reach`` channel names mapped to the delivery channels below.+_REACH_TO_DELIVERY: dict[str, str] = {"slack": "slack_dm","discord": "discord_dm","telegram": "telegram","email": "email",}-# Chat fallback order after the preferred channel. Email comes after all of-# them unless it is the preference — see `delivery_order`.-_CHAT_DELIVERY_ORDER: tuple[str, ...] = ("slack_dm", "discord_dm", "telegram")def delivery_order(principal: Person | None, *, email_ready: bool) -> list[str]:"""The channels a message can reach ``principal`` on, in the order to try.- Chat channels the principal has an id for come first — the preferred one- ahead of the rest (slack, discord, telegram). Email (it needs the MCP- gateway, ``email_ready``) is tried first when it is the preference, and- otherwise last, as the backup: delivery stops at the first channel that- sends, so an owner linked by email at setup (preference ``any``) with a- working Slack still never gets the briefs by email too — only when every- chat channel is missing or fails.+ The order is ``people.reach.reach_order``: the preferred channel, or with+ no preference the chat app they last talked in, then the other chat apps+ (Slack, Discord, Telegram), then email (it needs the MCP gateway,+ ``email_ready``) as the backup unless it was the one picked. Delivery+ stops at the first channel that sends, so an owner with a working Slack+ never gets the briefs by email too — only when every chat channel is+ missing or fails.Empty when nothing can deliver — e.g. a principal who only uses the web UI."""if principal is None:return []- ids = {- "slack_dm": principal.slack_user_id,- "discord_dm": principal.discord_user_id,- # Only a private chat: a group's id is negative, and everyone in it- # would read the message.- "telegram": principal.telegram_chat_id if str(principal.telegram_chat_id or "").isdigit() else None,- }- chat = [c for c in _CHAT_DELIVERY_ORDER if ids[c]]- pref = (principal.preferred_channel or "any").lower()- preferred = _PREFERRED_TO_DELIVERY.get(pref)- order = ([preferred] if preferred in chat else []) + [c for c in chat if c != preferred]- if email_ready and principal.email:- if pref == "email":- order.insert(0, "email")- else:- order.append("email")- return order+ from openexecutive.people.reach import reach_order++ # Never a Telegram group (reach_order leaves a negative id out): everyone+ # in it would read the message.+ return [_REACH_TO_DELIVERY[c] for c in reach_order(principal, email=email_ready)]def google_workspace_ready() -> bool:diff --git a/packages/core/tests/unit/test_people_channel.py b/packages/core/tests/unit/test_people_channel.pyindex 8b4472f7..3b98d95b 100644--- a/packages/core/tests/unit/test_people_channel.py+++ b/packages/core/tests/unit/test_people_channel.py@@ -186,7 +186,7 @@ def test_prefer_channel_for_returns_channel_inside_window() -> None:assert result == ("slack", "U12345")-def test_prefer_channel_any_tries_email_first() -> None:+def test_prefer_channel_any_tries_chat_apps_before_email() -> None:pid = people_store.upsert_person(full_name="Any Chan",email="[email protected]",@@ -196,7 +196,21 @@ def test_prefer_channel_any_tries_email_first() -> None:people_registry.invalidate()result = prefer_channel_for(pid, now=datetime.now(UTC))assert result is not None- assert result[0] == "email" # email tried first for "any"+ assert result[0] == "slack" # email is the backup for "any"+++def test_prefer_channel_any_goes_where_they_last_talked() -> None:+ pid = people_store.upsert_person(+ full_name="Any Chan",+ email="[email protected]",+ slack_user_id="U999",+ telegram_chat_id="4242",+ preferred_channel="any",+ )+ people_store.note_last_channel(pid, "telegram")+ people_registry.invalidate()+ result = prefer_channel_for(pid, now=datetime.now(UTC))+ assert result is not None and result[0] == "telegram"def test_prefer_channel_returns_none_when_no_ref() -> None:diff --git a/packages/core/tests/unit/test_people_reach.py b/packages/core/tests/unit/test_people_reach.pynew file mode 100644index 00000000..4457d1c3--- /dev/null+++ b/packages/core/tests/unit/test_people_reach.py@@ -0,0 +1,148 @@+"""One rule for where the Executive reaches a person (people/reach.py)."""+from __future__ import annotations++import json+from collections.abc import Iterator+from datetime import UTC, datetime, timedelta+from pathlib import Path+from types import SimpleNamespace+from typing import Any++import pytest++from openexecutive.people import registry as people_registry+from openexecutive.people import store as people_store+from openexecutive.people.models import Person+from openexecutive.people.reach import note_talked, reach_order+from openexecutive.scheduler.runner import delivery_order++[email protected](autouse=True)+def _isolated(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:+ monkeypatch.setattr(people_store, "DB_PATH", tmp_path / "people.db")+ people_registry.invalidate()+ people_store.initialize_db()+ yield+ people_registry.invalidate()+++def _person(**kw: Any) -> Person:+ fields: dict[str, Any] = {+ "full_name": "Ada Example", "email": "[email protected]", "slack_user_id": "U01",+ "discord_user_id": "100000000000000001", "telegram_chat_id": "4242",+ }+ fields.update(kw)+ return Person(**fields)+++def test_chat_apps_come_first_and_email_is_the_backup() -> None:+ assert reach_order(_person()) == ["slack", "discord", "telegram", "email"]+ assert reach_order(_person(), email=False) == ["slack", "discord", "telegram"]+ assert reach_order(_person(slack_user_id=None, discord_user_id=None, telegram_chat_id=None)) == ["email"]+++def test_where_they_last_talked_goes_first_unless_they_picked_one() -> None:+ assert reach_order(_person(last_channel="telegram")) == ["telegram", "slack", "discord", "email"]+ assert reach_order(_person(last_channel="telegram", preferred_channel="discord")) == [+ "discord", "slack", "telegram", "email",+ ]+ assert reach_order(_person(last_channel="telegram", preferred_channel="email"))[0] == "email"+ # A last app they have no id for any more is passed over.+ assert reach_order(_person(last_channel="telegram", telegram_chat_id=None))[0] == "slack"+++def test_briefs_follow_the_same_rule() -> None:+ person = _person(last_channel="telegram")+ assert delivery_order(person, email_ready=True) == ["telegram", "slack_dm", "discord_dm", "email"]+ # A group chat id is never a brief's destination.+ assert delivery_order(_person(telegram_chat_id="-100", last_channel="telegram"), email_ready=False) == [+ "slack_dm", "discord_dm",+ ]+++def _session(channel: str, ref: str, person_id: int | None) -> SimpleNamespace:+ return SimpleNamespace(origin_channel=channel, origin_channel_ref=ref, caller_person_id=person_id)++[email protected](autouse=True)+def _telegram_secured(monkeypatch: pytest.MonkeyPatch) -> None:+ from openexecutive.integrations import channel_cards++ monkeypatch.setattr(channel_cards, "telegram_proves_taps", lambda: True)+++def test_a_turn_from_their_own_account_is_remembered() -> None:+ pid = people_store.upsert_person(full_name="Ada", slack_user_id="U01", telegram_chat_id="4242")++ assert note_talked(_session("telegram", "4242", pid))+ stored = people_store.get_person(pid)+ assert stored is not None and stored.last_channel == "telegram" and stored.last_channel_at++ assert note_talked(_session("slack", "U01", pid))+ stored = people_store.get_person(pid)+ assert stored is not None and stored.last_channel == "slack"+++def test_a_turn_not_from_their_own_account_is_not() -> None:+ pid = people_store.upsert_person(full_name="Ada", slack_user_id="U01", telegram_chat_id="-1001")++ assert not note_talked(_session("slack", "U02", pid)) # someone else's Slack id+ assert not note_talked(_session("telegram", "-1001", pid)) # a group chat+ assert not note_talked(_session("email", "[email protected]", pid)) # not a chat app+ assert not note_talked(_session("slack", "U01", None))+ assert not note_talked(_session("slack", "U01", pid + 99))+ stored = people_store.get_person(pid)+ assert stored is not None and stored.last_channel is None+++def test_a_telegram_turn_without_a_webhook_secret_is_not(monkeypatch: pytest.MonkeyPatch) -> None:+ from openexecutive.integrations import channel_cards++ monkeypatch.setattr(channel_cards, "telegram_proves_taps", lambda: False)+ pid = people_store.upsert_person(full_name="Ada", telegram_chat_id="4242")+ assert not note_talked(_session("telegram", "4242", pid))+++def test_a_telegram_group_is_never_where_they_are_reached() -> None:+ group = _person(slack_user_id=None, discord_user_id=None, telegram_chat_id="-100", last_channel="telegram")+ assert reach_order(group) == ["email"]+ assert reach_order(group, telegram_groups=True) == ["telegram", "email"]+++def test_when_they_last_talked_is_not_serialised() -> None:+ dumped = _person(last_channel="slack", last_channel_at="2026-10-01T09:00:00+00:00").model_dump()+ assert dumped["last_channel"] == "slack" and "last_channel_at" not in dumped+++def test_the_same_app_is_written_at_most_hourly() -> None:+ pid = people_store.upsert_person(full_name="Ada", slack_user_id="U01")+ start = datetime(2026, 10, 1, 9, 0, tzinfo=UTC)++ assert people_store.note_last_channel(pid, "slack", now=start)+ assert not people_store.note_last_channel(pid, "slack", now=start + timedelta(minutes=30))+ assert people_store.note_last_channel(pid, "slack", now=start + timedelta(minutes=61))+ assert people_store.note_last_channel(pid, "discord", now=start + timedelta(minutes=62))+++async def test_message_person_tries_where_they_last_talked_first(monkeypatch: pytest.MonkeyPatch) -> None:+ from openexecutive.orchestrator import schedule_tools++ pid = people_store.upsert_person(full_name="Ada", slack_user_id="U01", telegram_chat_id="4242")+ people_store.note_last_channel(pid, "telegram")+ people_registry.invalidate()+ sent: list[str] = []++ async def telegram(args: dict[str, Any]) -> str:+ sent.append("telegram")+ return json.dumps({"status": "sent"})++ async def slack(args: dict[str, Any]) -> str:+ sent.append("slack")+ return json.dumps({"status": "sent"})++ monkeypatch.setattr(schedule_tools, "handle_send_telegram_message", telegram)+ monkeypatch.setattr(schedule_tools, "handle_send_slack_dm", slack)+ monkeypatch.setattr(schedule_tools, "configured_integrations", lambda settings: {"slack", "telegram"})++ result = json.loads(await schedule_tools.message_person({"person_id": pid, "text": "hi"}))+ assert result["status"] == "sent" and sent == ["telegram"]diff --git a/packages/ui/scripts/personReach.test.mjs b/packages/ui/scripts/personReach.test.mjsindex 7169b71c..60e02033 100644--- a/packages/ui/scripts/personReach.test.mjs+++ b/packages/ui/scripts/personReach.test.mjs@@ -1,6 +1,6 @@import assert from "node:assert/strict";import test from "node:test";-import { availableChannels, onLeaveLine, reachLine } from "../src/lib/personReach.ts";+import { availableChannels, onLeaveLine, reachLine, reachOrder } from "../src/lib/personReach.ts";const base = {email: null,@@ -16,17 +16,26 @@ test("a preferred channel is named with the reply time", () => {assert.equal(reachLine(p), "Reaches them on Discord, replies within 12h");});-test("any channel lists what they have, email first", () => {+test("any channel lists chat apps first, email last", () => {const p = { ...base, email: "[email protected]", telegram_chat_id: "123" };assert.deepEqual(availableChannels(p), ["email", "telegram"]);- assert.equal(reachLine(p, { self: true }), "Reaches you by email or Telegram, replies within 24h");+ assert.equal(reachLine(p, { self: true }), "Reaches you on Telegram or by email, replies within 24h");const three = { ...p, slack_user_id: "U01" };- assert.equal(reachLine(three), "Reaches them by email, Slack or Telegram, replies within 24h");+ assert.equal(reachLine(three), "Reaches them on Slack, Telegram or by email, replies within 24h");+});++test("any channel goes where they last talked first", () => {+ const p = { ...base, email: "[email protected]", slack_user_id: "U01", telegram_chat_id: "123", last_channel: "telegram" };+ assert.deepEqual(reachOrder(p), ["telegram", "slack", "email"]);+ assert.equal(reachLine(p), "Reaches them on Telegram, where they last talked, replies within 24h");+ assert.equal(reachLine(p, { self: true, contact: true }), "Reaches you on Telegram, where you last talked");+ // A pick wins over where they last talked.+ assert.deepEqual(reachOrder({ ...p, preferred_channel: "slack" }), ["slack", "telegram", "email"]);});test("a preferred channel with no id falls back to what they have", () => {- const p = { ...base, email: "[email protected]", preferred_channel: "slack" };- assert.equal(reachLine(p), "Reaches them by email, replies within 24h");+ const p = { ...base, email: "[email protected]", telegram_chat_id: "123", preferred_channel: "slack" };+ assert.equal(reachLine(p), "Reaches them on Telegram or by email, replies within 24h");});test("a contact has no reply time", () => {diff --git a/packages/ui/src/app/people/[id]/page.tsx b/packages/ui/src/app/people/[id]/page.tsxindex 5258f7a0..e7243487 100644--- a/packages/ui/src/app/people/[id]/page.tsx+++ b/packages/ui/src/app/people/[id]/page.tsx@@ -53,7 +53,7 @@ const ALL_SCOPES = [];const CHANNELS = [- { value: "any", label: "Any channel" },+ { value: "any", label: "Where they last talked" },{ value: "email", label: "Email" },{ value: "slack", label: "Slack" },{ value: "discord", label: "Discord" },@@ -903,7 +903,7 @@ export default function PersonDetailPage() {</select></label><p className={HINT_CLS}>- Proposals routed to this person are sent via {form.preferred_channel === "any" ? "any available channel" : (CHANNELS.find((c) => c.value === form.preferred_channel)?.label ?? form.preferred_channel)}.+ Proposals routed to this person are sent via {form.preferred_channel === "any" ? "the app they last talked in, then any other" : (CHANNELS.find((c) => c.value === form.preferred_channel)?.label ?? form.preferred_channel)}.</p></div>{!formContact && (diff --git a/packages/ui/src/app/people/page.tsx b/packages/ui/src/app/people/page.tsxindex 64b57c92..de741b89 100644--- a/packages/ui/src/app/people/page.tsx+++ b/packages/ui/src/app/people/page.tsx@@ -60,7 +60,7 @@ const KINDS: PersonKind[] = ["team", "contact"];const TONE_DOT = { ok: "bg-emerald-500", warn: "bg-amber-500", muted: "bg-fg-subtle" } as const;function channelLabel(channel: string): string {- return channel === "any" ? "Any channel" : channel.charAt(0).toUpperCase() + channel.slice(1);+ return channel === "any" ? "Where they last talked" : channel.charAt(0).toUpperCase() + channel.slice(1);}function PersonCard({ person, today }: { person: Person; today: string }) {@@ -486,7 +486,7 @@ function AddPersonModal({ initialKind, canAddContacts, onCreated, onClose }: Add</select></label><p className={HINT_CLS}>- Proposals routed to this person are sent via {form.preferred_channel === "any" ? "any available channel" : form.preferred_channel}.+ Proposals routed to this person are sent via {form.preferred_channel === "any" ? "the app they last talked in, then any other" : form.preferred_channel}.</p></div><div>diff --git a/packages/ui/src/lib/api.ts b/packages/ui/src/lib/api.tsindex bab99e9f..3ebb88aa 100644--- a/packages/ui/src/lib/api.ts+++ b/packages/ui/src/lib/api.ts@@ -4435,6 +4435,9 @@ export interface Person {telegram_chat_id: string | null;discord_user_id: string | null;preferred_channel: string;+ // The chat app they last talked to the Executive in (slack, discord or+ // telegram); with preferred_channel "any" messages go there first.+ last_channel?: string | null;availability: AvailabilityWindow[];authority_scope: string[];response_sla_hours: number;diff --git a/packages/ui/src/lib/personReach.ts b/packages/ui/src/lib/personReach.tsindex 3f12a6bc..9b5e4104 100644--- a/packages/ui/src/lib/personReach.ts+++ b/packages/ui/src/lib/personReach.ts@@ -9,7 +9,8 @@ import type { Person } from "@/lib/api";type ReachFields = Pick<Person,"email" | "slack_user_id" | "discord_user_id" | "telegram_chat_id" | "preferred_channel" | "response_sla_hours"->;+> &+ Partial<Pick<Person, "last_channel">>;const CHANNEL_NAMES: Record<string, string> = {email: "email",@@ -37,23 +38,42 @@ export function availableChannels(p: ReachFields): string[] {].filter((c): c is string => c !== null);}+/**+ * The order the Executive tries them in, as the server does+ * (people/reach.py): their pick, else the chat app they last talked in, then+ * Slack, Discord, Telegram, then email.+ */+export function reachOrder(p: ReachFields): string[] {+ const have = availableChannels(p);+ const chat = ["slack", "discord", "telegram"].filter((c) => have.includes(c));+ const pref = p.preferred_channel || "any";+ const first = pref !== "any" ? pref : (p.last_channel ?? null);+ const order = [...(first && chat.includes(first) ? [first] : []), ...chat.filter((c) => c !== first)];+ if (have.includes("email")) {+ if (first === "email") order.unshift("email");+ else order.push("email");+ }+ return order;+}+/*** "Reaches them on Discord, replies within 12h". `self` says "you" on your* own card; a contact has no reply time.*/export function reachLine(p: ReachFields, opts: { self?: boolean; contact?: boolean } = {}): string {const who = opts.self ? "you" : "them";- const have = availableChannels(p);+ const order = reachOrder(p);+ if (order.length === 0) return opts.self ? "No email or chat app set for you yet" : "No email or chat app set for them yet";+ const pref = p.preferred_channel || "any";let how: string;- // Delivery tries the preferred channel first among those with an address- // or id, so a preferred channel with nothing set reads like "any".- if (p.preferred_channel && p.preferred_channel !== "any" && have.includes(p.preferred_channel)) {- how = `Reaches ${who} ${channelPhrase(p.preferred_channel)}`;+ if (pref !== "any" && order[0] === pref) {+ how = `Reaches ${who} ${channelPhrase(pref)}`;+ } else if (pref === "any" && p.last_channel && order[0] === p.last_channel) {+ how = `Reaches ${who} ${channelPhrase(p.last_channel)}, where ${opts.self ? "you" : "they"} last talked`;} else {- if (have.length === 0) return opts.self ? "No email or chat app set for you yet" : "No email or chat app set for them yet";- // "by email or Telegram", "on Slack or Discord"- const [first, ...rest] = have;- how = `Reaches ${who} ${joinOr([channelPhrase(first), ...rest.map((c) => CHANNEL_NAMES[c] ?? c)])}`;+ // "on Slack or Telegram", "on Telegram or by email"+ const [first, ...rest] = order;+ how = `Reaches ${who} ${joinOr([channelPhrase(first), ...rest.map((c) => (c === "email" ? "by email" : CHANNEL_NAMES[c] ?? c))])}`;}return opts.contact ? how : `${how}, replies within ${p.response_sla_hours}h`;}