AI-powered virtual executive team — a single coherent executive persona backed by 8 specialist agents (FastAPI + Next.js).
fix(briefing): stop calling sent drafts unsent and stop echoing the reader's chats (#585)
Rufus36f45ddb73af
diff --git a/packages/core/openexecutive/api/routes/today.py b/packages/core/openexecutive/api/routes/today.pyindex 7a0ba857..242e2716 100644--- a/packages/core/openexecutive/api/routes/today.py+++ b/packages/core/openexecutive/api/routes/today.py@@ -2049,6 +2049,27 @@ async def refresh_principal_narrative() -> bool:return False+# How often the principal opening the page settles their chat drafts (and+# rewrites the header when that moved it). The scheduler's own pass runs only+# every BRIEFING_NARRATIVE_REFRESH_MINUTES in daytime, and not at all when+# they turned that background job off; without this a draft they sent from+# their mailbox kept being called unsent on the page in between.+_VIEW_SETTLE_EVERY = timedelta(minutes=2)+_view_settled_at: datetime | None = None+++def _maybe_settle_on_view(background_tasks: BackgroundTasks, now: datetime | None = None) -> bool:+ """Queue ``refresh_principal_narrative`` after the response, at most once+ per ``_VIEW_SETTLE_EVERY``. True when queued."""+ global _view_settled_at+ now = now or datetime.now(UTC)+ if _view_settled_at is not None and now - _view_settled_at < _VIEW_SETTLE_EVERY:+ return False+ _view_settled_at = now+ background_tasks.add_task(refresh_principal_narrative)+ return True++def _is_principal(caller_person_id: int | None) -> bool:"""Whether the resolved caller is the principal. Fails closed."""from openexecutive.people.store import is_principal_or_self@@ -2082,6 +2103,7 @@ async def get_today(request: Request, background_tasks: BackgroundTasks) -> Todabackground_tasks=background_tasks,)if principal:+ _maybe_settle_on_view(background_tasks)response.held_back = _held_back(datetime.now(UTC))response.first_week_card = _first_week_card()response.first_week = response.first_week_card is not Nonediff --git a/packages/core/openexecutive/architecture/architecture-facts.yaml b/packages/core/openexecutive/architecture/architecture-facts.yamlindex a6d860c0..6ce632ae 100644--- a/packages/core/openexecutive/architecture/architecture-facts.yaml+++ b/packages/core/openexecutive/architecture/architecture-facts.yaml@@ -5066,7 +5066,7 @@ today:module: openexecutive.api.routes.todayendpoints:- "GET /today — JSON aggregation. Returns TodayResponse(departments, people, proposals, narrative, in_flight, awaiting, caller_person_id). `departments` rolls up each department's goal counts (total, at_risk, off_track) and awaiting workflow count, PLUS `attention_goals` — the actual off_track/at_risk Goal rows themselves (worst first, capped at 3), each carrying `key_result`, `current`, `target`, and `status`, so the briefing's Department card is insightful at rest (shows which goal is off and how far) instead of a count you must click into; empty for healthy/inactive departments and additive (older clients ignore it). `people` is an attention-ranked roster: each person carries the original preferred channel, awaiting-action count and soonest SLA PLUS enrichment signals — `status` (on_leave | needs_reply | awaiting | clear), `awaiting_reply_count`/`oldest_awaiting_reply_at` (open scheduled_action commitments we're waiting on THEM to answer, mirroring the nudge engine's awaiting_response_since set), `on_leave_until`, `reachable_now`/`next_window_at` (from people.channel availability windows), `authority_scope`, `department_slugs`, `last_contact_at` (most recent done outbound assigned to them), `overdue` (any SLA or awaited reply past deadline), `priority` (server sort key — overdue replies/work float to top, on-leave sinks), and `insight` (a one-line utility-fast note, see people.insights — null until the background cache warms). Rows are returned sorted by (-priority, full_name). `proposals` is the org-wide set of ALL unread alerts (workflow approvals, triage-classified inbound, Executive-created operational signals, and research artifacts the Executive flagged for review via `draft_artifact` — source=`artifact`, tagged `artifact`, which the UI renders as a Markdown document card rather than a terse proposal — and which also persist into the dedicated artifacts section (`/artifacts`, labelled Documents in the UI) so they remain browsable after they leave this unread queue — anything in the alerts table with status='unread'); the UI splits it into 'mine' vs 'across the team' using `caller_person_id` plus a 'principal owns unrouted' rule (alerts with `routed_to_person_id == null` fall to the principal's queue by default). Each proposal also carries presentation signals from `openexecutive.briefing.ranking`: `score` (attention sort key — severity-weighted, with a bonus for routed alerts) and `category` ('action' = a human should look, vs 'monitoring' = passive watchlist/external signals that are unrouted and not high/urgent), plus `surfaced_reason` (a short human note, null for most items) — set only when an external/watchlist signal was pulled into the 'action' lane *by its severity* (the high/urgent escape hatch in `categorize`, e.g. a ≥5% stock move), so the UI can render a per-item explanation of why a normally-Monitoring signal is in 'Needs you'. A proposal also carries `decision_instance_id` (parsed from a `decision_instance:{id}` topic tag), non-null only for gated calendar bookings surfaced from the decision ledger (source=`decision_scheduling`); the UI routes those cards' Approve/Reject to the /decisions endpoints (which book or cancel server-side and clear this alert) instead of the ack-and-hand-off-to-chat flow, so meeting bookings are reviewed in the briefing itself (the standalone proposals page was removed). `_build_today` sorts action items first (by score), monitoring last; the UI collapses the 'monitoring' tail into a separate section so it stops crowding the 'Needs you' queue. `narrative` is a PER-VIEWER Executive-voice 'what's going on' header (see `openexecutive.briefing.narrative` + `today._attach_narrative`). It is a SYNTHESIS, not a re-list: the actionable items render as cards below it, so the narrative gives the connective tissue a list can't (how items relate, what's most urgent and why, the single recommended focus) and deliberately does NOT enumerate a 'Needs you' section that would duplicate the cards. The resolved principal gets the whole-company synthesis in cache scope `principal` (which may carry their private rows), and an unrostered/unresolved caller the same synthesis in the shared scope `company` (never a private row), over ALL action-category proposals (mine + across the team; monitoring/watchlist noise is excluded) plus company-wide at-risk depts + activity; each non-principal teammate gets a role-scoped synthesis (cache scope `person:<id>`) over ONLY the action items routed to them + their departments' goal health + their department activity, written in their perspective. Synthesized by `synthesize_briefing_narrative`, which also produces the standalone morning_brief DM but via a DIFFERENT prompt (`standalone=True` → an enumerated brief with a 'Needs you' section, since the DM has no cards beside it to carry the list; the EoD digest still has its own prompt); the /today header path uses the synthesis prompt and never re-lists. Served from the per-scope `briefing_narrative` cache (`openexecutive.briefing.narrative_cache`, keyed by a hash of the viewer's scoped state + the activity rows the narrative reasons over + scope + the principal's LOCAL date (`narrative_cache.local_today`) + `NARRATIVE_PROMPT_VERSION`, the last so a prompt rewrite invalidates every cached narrative on the next view). The key is a hash of the RENDERED context string itself (`today._narrative_context` builds it once; the hot path hashes it, the background task hands that same string to the model as `rendered_context`). So the key is a function of the model's input: everything the prompt renders is covered, nothing it omits can cause a regeneration, and both properties survive edits to `render_briefing_context` with no field list to maintain. Hand-picked field lists broke one half or the other each time — proposal headlines alone left the rendered activity block uncovered (the header then described a rail that had moved on), while the proposals' review fields (review_verdict / review_note / why_now / recommended_move / due_at) are NEVER rendered by this header (the `since is None` branch prints headline[:160] and nothing else) yet `alerts.review` rewrites them with fresh LLM prose on every pass INCLUDING its 'still relevant, nothing changed' path, so keying on them regenerated every viewer's narrative several times a day to re-synthesize byte-identical input. A quiet board keys off the fixed `narrative_cache.QUIET_CONTEXT` sentinel and builds no activity at all, so a moving rail cannot re-key an entry whose text is a constant. The narrative's activity is built with `include_alert_raised=False`, dropping that source entirely: closed alerts read as settled work, and live ones are already the proposal cards (`is_live` IS the `list_live_alerts` predicate) that the header prompt forbids re-listing — the `/today/activity` rail keeps them. It is a source opt-out rather than a post-pull filter so `recent_alerts` cannot burn its pool on closed rows. `render_briefing_context` only labels that block 'SINCE LAST BRIEF' when the caller bounded it with `since`; an unbounded rail is labelled 'RECENT OE ACTIVITY' and explicitly marked as not a delta. When the viewer's slice has no action proposal, no at-risk/off-track department and nobody awaiting, the regen writes a fixed quiet line and spends NO model call — that, not the hash, is what keeps a frozen header from recurring. Together these stop a fully-dismissed board from yielding a confident header synthesized entirely out of closed items. Served from cache on the hot path and regenerated per-viewer in a FastAPI BackgroundTask when that viewer's hash moves; null on a cold cache. `in_flight` is the Executive's upcoming user-facing commitments — pending scheduled_actions (follow-ups, nudges) from `episodic.list_pending_scheduled_actions` (excludes the `__internal__` channel and `nudge_scan` heartbeat, the same set the activity feed hides), each with the resolved recipient `target` (person name via the shared channel→name lookup, or department/raw ref), `kind`, `run_at`, and `overdue` (run_at already passed). `awaiting` is the people we're waiting on a reply from, derived from the same open-commitment set behind each person's `awaiting_reply_count` (name, role, count, oldest_at, overdue), sorted most-overdue/oldest first. Together they power the briefing's 'In flight' section so cross-team work in progress is visible without opening the Scheduled Actions page. Both are additive and default to empty. `caller_person_id` is the signed-in caller resolved from `x-caller-email` via chat._resolve_caller_person_id; null when no caller could be resolved (unrostered signed-in user, or a CLI hit without the header). The route is async: it serves insight notes from the person_insights cache and, after resolving the caller, attaches the viewer-scoped narrative via `_attach_narrative`, scheduling regeneration of stale entries as FastAPI BackgroundTasks so the request never blocks on an LLM call. `_build_today()` stays synchronous and caller-agnostic — no insight regen and NO narrative (that is attached per-viewer by the endpoints) — for the morning_brief workflow and the deprecated /morning-brief alias that call it directly; the alias resolves the caller and serves the cached narrative but cannot schedule a regen. RIGHT NOW: the header is rewritten through the day, so Home shows it as a Right now card rather than a 'today's brief' link. `briefing.right_now.split_narrative` splits the served text into `narrative_lead`, `narrative_points` [{text, since}] and `narrative_move`; `since` is when the point (keyed by its bold subject) first appeared today, kept in `briefing_point_seen` (written beside each header write, earlier days pruned then). `narrative_seen_at` is the reader's last look per scope (`briefing_reader_seen`, set by POST /today/seen); the page holds it as the visit's baseline and counts only a look from earlier the same day. For the principal, `morning_brief` (today's delivered morning brief) and `calendar_next` (up to 3 meetings still ahead from the cached calendar read, no fresh call) fill the side panel. No model call on this path."- - "Live header (briefing.live_signals) — the whole-company narrative scopes (`principal`, `company`) open their context with the principal's world as it is happening, under a NOW line bucketed to the local hour: INBOUND (integration_inbound audit rows whose summary starts 'Inbound ', one row per message id, grouped by sender + subject with a count; an email carries its subject and first line, the principal's own mail reads 'from the principal', an email from the roster says 'the Executive replied' or 'no reply went out' (an open integrations.unanswered_mail card for its thread; principal scope only, the cards are private), and a time on another local day carries its weekday and date — a brief that read yesterday's 'Re: call tomorrow' subject at a bare time put a past meeting under Today, called its reader by name and counted one email handled twice as two asks), STUCK (integration_outbound_blocked rows to a recipient, the inbound 'Accepted non-roster … reply blocked' and Google Chat 'left unanswered' / 'reply not delivered' rows, and chat drafts still waiting: delegation_drafts rows of source chat with no sent_message_id or gone_at; before each scheduled header refresh and morning brief, live_signals.settle_principal_drafts asks the principal's mailbox for each open chat draft from the last two days and sets gone_at on the ones sent or deleted there — the count used to be every delegation_drafted row of the day, so a draft the principal sent from Gmail, and said so in chat, stayed 'waiting for them to review and send' all day), CONVERSATIONS (the principal's own web chat titles) and REST OF TODAY'S CALENDAR. An address that belongs to someone on the roster (or, in the principal scope, one of the principal's contacts) reads 'Name (address)' in these lines (`live_signals._named`): given a bare address the header made a name up from it (\"mquinn@\" became \"Mquinn\"). Window: the local day, or the last 12 h when longer. Private audit rows, drafts, chat titles and the calendar only in the `principal` scope (gather_live_signals drops the calendar whenever include_private is false, whatever the caller passes). The calendar is never fetched on the request: `live_signals.refresh_calendar` caches one read per 15 min (the scheduler tick refreshes it) and the header quotes `cached_calendar`. With live blocks present the render also ages proposals (whole days), lists each at-risk department's attention_goals, and adds EXTERNAL SIGNALS (monitoring proposals from the last 24 h, which never break the quiet line alone); rhythm runs (`today.RHYTHM_WORKFLOWS`) are excluded from the narrative's activity. Anything live breaks the quiet line. Why: the header read the same for days on an install whose inbox moved hourly, because nothing but the alert board reached it. Every quoted field is one-lined and cut, and the prompt calls the blocks data, never instructions (inbound text is attacker-controlled). Freshness: `TodayResponse.narrative_generated_at` / `narrative_stale`; a row written on an earlier local day is not served; regenerations are serialized per scope (`today._regen_lock`; a trigger that finds one running marks the scope pending in `_regen_pending` and the running pass goes round once more); a failed pass (error, 33 s timeout (25 s draft + 8 s rewrite; a rewrite past its 8 s keeps the first draft fixed in code), empty text) starts a 5-minute backoff (`_regen_failed_at`, `_REGEN_FAILURE_BACKOFF`) in which no view or tick regenerates and `narrative_stale` is false; the calendar is placed at the real time, not the hour-floored NOW; the scheduler precomputes the principal's header (`today.refresh_principal_narrative`, see scheduler); the Briefing re-polls at 4/10/20 s while stale, on tab focus (at most once a minute) and every 5 min (`ui/src/lib/narrativeFreshness.ts`). Logs: 'today: narrative served scope=… age_s=… stale=…', 'today: narrative regenerated scope=… ms=…'."+ - "Live header (briefing.live_signals) — the whole-company narrative scopes (`principal`, `company`) open their context with the principal's world as it is happening, under a NOW line bucketed to the local hour: INBOUND (integration_inbound audit rows whose summary starts 'Inbound ', one row per message id, grouped by sender + subject with a count; an email carries its subject and first line, the principal's own mail reads 'from the principal', an email from the roster says 'the Executive replied' or 'no reply went out' (an open integrations.unanswered_mail card for its thread; principal scope only, the cards are private), and a time on another local day carries its weekday and date — a brief that read yesterday's 'Re: call tomorrow' subject at a bare time put a past meeting under Today, called its reader by name and counted one email handled twice as two asks), STUCK (integration_outbound_blocked rows to a recipient, the inbound 'Accepted non-roster … reply blocked' and Google Chat 'left unanswered' / 'reply not delivered' rows, and chat drafts still waiting: delegation_drafts rows of source chat with no sent_message_id or gone_at; before each scheduled header refresh, each morning brief and the principal's /today view (at most every 2 minutes, today._maybe_settle_on_view, so it holds with the background refresh slowed or off), live_signals.settle_principal_drafts asks the principal's mailbox for each open chat draft from the last two days and sets gone_at on the ones sent or deleted there, or sent another way (one read of their latest 15 sent messages while a draft is left: same subject, one of the same recipients, sent after the draft — a redraft whose other version went out); one draft's failure no longer stops the pass — the count used to be every delegation_drafted row of the day, so a draft the principal sent from Gmail, and said so in chat, stayed 'waiting for them to review and send' all day), CONVERSATIONS (the principal's own web chat titles, without times; a header that still reports the reader's chats or asks back — narrative.own_echoes — is sent back once for a rewrite) and REST OF TODAY'S CALENDAR. An address that belongs to someone on the roster (or, in the principal scope, one of the principal's contacts) reads 'Name (address)' in these lines (`live_signals._named`): given a bare address the header made a name up from it (\"mquinn@\" became \"Mquinn\"). Window: the local day, or the last 12 h when longer. Private audit rows, drafts, chat titles and the calendar only in the `principal` scope (gather_live_signals drops the calendar whenever include_private is false, whatever the caller passes). The calendar is never fetched on the request: `live_signals.refresh_calendar` caches one read per 15 min (the scheduler tick refreshes it) and the header quotes `cached_calendar`. With live blocks present the render also ages proposals (whole days), lists each at-risk department's attention_goals, and adds EXTERNAL SIGNALS (monitoring proposals from the last 24 h, which never break the quiet line alone); rhythm runs (`today.RHYTHM_WORKFLOWS`) are excluded from the narrative's activity. Anything live breaks the quiet line. Why: the header read the same for days on an install whose inbox moved hourly, because nothing but the alert board reached it. Every quoted field is one-lined and cut, and the prompt calls the blocks data, never instructions (inbound text is attacker-controlled). Freshness: `TodayResponse.narrative_generated_at` / `narrative_stale`; a row written on an earlier local day is not served; regenerations are serialized per scope (`today._regen_lock`; a trigger that finds one running marks the scope pending in `_regen_pending` and the running pass goes round once more); a failed pass (error, 33 s timeout (25 s draft + 8 s rewrite; a rewrite past its 8 s keeps the first draft fixed in code), empty text) starts a 5-minute backoff (`_regen_failed_at`, `_REGEN_FAILURE_BACKOFF`) in which no view or tick regenerates and `narrative_stale` is false; the calendar is placed at the real time, not the hour-floored NOW; the scheduler precomputes the principal's header (`today.refresh_principal_narrative`, see scheduler); the Briefing re-polls at 4/10/20 s while stale, on tab focus (at most once a minute) and every 5 min (`ui/src/lib/narrativeFreshness.ts`). Logs: 'today: narrative served scope=… age_s=… stale=…', 'today: narrative regenerated scope=… ms=…'."- "GET /today/activity?limit=N — Returns ActivityResponse(items). Each item is one recent self-initiated Executive action — a fired scheduled_action (DM dispatched, follow-up fired, cadence run, paused workflow resumed) or an extracted decision/advice row. Items carry `kind` (coarse classifier the UI maps to verb + icon — dm_sent, email_sent, nudge_sent, cadence_sent, workflow_resumed, proposal_routed, decision_logged, advice_given, workflow_done, initiative_started, decision_resolved, alert_raised, or action for unclassified), `summary`, `actor` (always Executive for now), `target` (channel ref / person, or null), `department`, `at` (ISO timestamp), and for workflow_done `detail` (one line on what came of the run) and `artifact_id` (`run:<id>` when it kept a write-up); a run's `summary` is its plain name from workflows/run_outcome.py, never its log title. Sources merged — `scheduled_actions` with status=done (excluding `nudge_scan` heartbeat and `__internal__` channel), `decisions`, `advice_given`, completed `workflow_runs` (status=done — briefings/check-ins/research, bucketed at `updated_at`), `initiatives` (kicked-off projects, at `created_at`), resolved `decision_instances` (terminal gated-decision outcomes — approved/rejected/reversed, at `resolved_at`; pending ones stay in `proposals`, not the rail), and `alerts` raised (excluding source=`decision_scheduling`, which is the companion alert for a gated booking already represented by its `decision_resolved` row). `_build_activity(..., include_alert_raised=False)` omits this source entirely. The rail keeps it (history is the point there); only the briefing narrative opts out. This broadens the feed beyond the original messaging-heavy three sources so it reflects all self-initiated Executive activity, not just dispatched messages. Actions on `propose_only` departments are reclassified to `proposal_routed` because the runner marks them done without dispatching (the proposal is surfaced via /today's `proposals` field; the activity rail shows it as 'proposed to <approver>' rather than implying a DM was sent). Sorted by `at DESC`, then capped at `limit` (default 20, clamped to 1..100 via FastAPI Query validation — 422 on out-of-range). The Pulse page polls this endpoint (limit=100) every ~20s so new activity streams into the 'Recent activity' card without a reload; the card scrolls internally at a fixed max-height rather than growing the page."- "GET /today/activity/daily?days=N — Returns DailyActivityResponse(days), the per-day counts behind the Pulse page's 'heartbeat' heatmap (the GitHub-contributions-style grid at `/memories`). Same source set and exclusions as /today/activity — the union of `decisions`, `advice_given`, status=done `scheduled_actions` (excluding the `nudge_scan` heartbeat and `__internal__` channel), completed `workflow_runs`, `initiatives`, resolved `decision_instances`, and `alerts` — but bucketed by calendar day (UTC) in `episodic.count_activity_by_day` rather than returned as individual items — decisions/advice by their `timestamp`, fired actions by `run_at` (fire time, not `created_at` queue time, so a cadence queued the night before counts on the day it fires), workflow runs by `updated_at` (completion), initiatives by `created_at`, resolved decisions by `resolved_at`, alerts by `created_at`. The `workflow_runs` and `alerts` tables are owned by other stores (not `episodic.initialize_db`), so each UNION arm is included only when its table exists — `count_activity_by_day` checks `sqlite_master` and still counts the sources episodic owns on a DB initialised by episodic alone. The response is DENSE: every calendar day in the window is present (count 0 when nothing fired), oldest→newest, so the UI renders a gap-free grid without client-side fill. A decision instance whose proposed payload is private (`\"private\": true`) and an alert tagged `private:principal` are not counted, as the feed leaves them out. `days` defaults to 90, clamped to 1..365 via FastAPI Query validation (422 on out-of-range). Read-only, unauthenticated (matches /today/activity and /memories/*), uncached."- "GET /today/top-three — solo only, principal only. Returns TopThreeToday {items: [{key, kind, text, why, slot}]} or null: null in team mode (effective_workspace_mode) and for anyone the stricter principal-only-run rule (`workflows._caller_is_the_principal`: own email on a non-archived principal entry, or no x-caller-email; never an unclaimed roster) does not admit. Built from the morning brief's own inputs and code — `open_loops.principal_due_soon()` handed to `briefing.top_three.build_top_three` — so the items, order and free slots match the solo brief. `slot` is the free block ('10:00–11:00', the user's zone), '' when no block is left, null when no calendar was read (none connected, a failure or the 4 s timeout, a non-business day). A separate route, never part of GET /today, so the Briefing never waits on the calendar read; the UI loads it after /today."diff --git a/packages/core/openexecutive/architecture/prebuilt/today.json b/packages/core/openexecutive/architecture/prebuilt/today.jsonindex f5220584..c041f268 100644--- a/packages/core/openexecutive/architecture/prebuilt/today.json+++ b/packages/core/openexecutive/architecture/prebuilt/today.json@@ -1,7 +1,7 @@{"section_id": "today","title": "Today / Morning Brief",- "markdown": "`openexecutive.api.routes.today` serves the morning brief — a one-screen, read-only view of what is happening across the org. It is the default landing surface (the Next.js root renders `<Briefing>`). Every signed-in page shares one sidebar (`AppSidebar`). Its Recent list is capped at the 7 newest web chats. The full history, including Slack, Telegram and Discord conversations (recognised by their session-id prefix), lives on `/chats`. A chat opens from any page through `/?session=<id>`.\n\n`GET /today` returns `TodayResponse` assembled by `_build_today()`, which is synchronous and caller-agnostic:\n\n- **`departments`** — per-department goal health, rolling up each department's goal counts (`total`, `at_risk`, `off_track`) plus its awaiting-workflow count, and `attention_goals`: the actual off-track/at-risk goals (worst first, capped at 3) with `key_result`, `current`, `target`, and `status`, so the briefing's Department card shows *which* goal is off and how far without a click. Empty for healthy/inactive departments.\n- **Private cards.** An alert tagged `private:principal` (`alerts.models.PRIVATE_ALERT_TAG` — raised on a turn about mail from one of the principal's contacts or mail they forwarded, or a meeting proposal with a contact) is in `proposals` only when the caller is the principal. The chat's alert digest (`briefing.context.render_and_trust`) shows it, and the roster requests, only on the principal's own verified turn, never in a web chat they shared with others, where everyone reads the reply. `_build_today` leaves it out by default, so the end-of-day digest, the reflection and Discord's `/today` never see it, and the morning brief reads it only on a run for the principal (the scheduler's, or the principal's own verified chat turn in a conversation only they can read — see Workflows). The narrative is written from one only in the principal's own `principal` scope, which nobody else is served; the shared `company` scope an unresolved caller gets, and a teammate's scope, never are. The activity rail skips it, and the chat digest includes it only on the principal's own verified turn.\n- **Raised by a team member.** An alert a team member raised from chat (`AlertEvent.raised_by`, source `team_member`) has its body led by \"Raised by <name>.\" and never goes out on `company_broadcast`: the pipeline drops that channel after `resolve_channels`, so it reaches a person or a department room only. One team member's alert never coalesces into another's (the dedup key is prefixed with who raised it). A team member's saved workflow raises alerts as its creator (`action_step` binds `dynamic_store.get_owner` around `oe__create_alert`). Alerts from email, watches and other sources are unchanged.\n- **Who clears a card.** `POST /alerts/{id}/ack` with `ack` or `dismissed` answers 403 to a team member unless the alert is routed to them (`read` is open to anyone who can see it); only the principal's dismiss applies `mute_topic`, since a mute silences the topic for everyone. `POST /alerts/bulk-ack` from a team member clears only the listed ids routed to them and refuses an `older_than_days` sweep. The principal, or anyone before a principal is set up, clears anything. `ack_alert` in chat follows the same rule.\n- **Roster-request cards.** When someone not on the People list writes in (see Org and Integrations), `people.roster_requests.surface_card` raises an alert of source `roster_request` (medium, tagged `roster_request:<id>` and `private:principal`, routed to the principal), so it follows every private-card rule above. `GET /today` attaches `roster_request` to that proposal (`_roster_request_card`: channel, address or account id, the sender's sanitised and unverified name, profile email, company-domain flag, suggested kind and person, message count, whether they were acknowledged, first seen, and the held messages' first lines) while the request is still pending. The Briefing renders it as its own card (`RosterRequestCard`: add as a new person with a name and an explicit team/contact choice — pre-filled as team on a company domain — or \"someone already on the list\", with a replace-account option for a chat id, or Ignore), which calls `/people/requests/{id}` directly and never hands off to chat, so what a stranger wrote never seeds a turn. The card is kept out of everything that could close it without answering it or put the stranger's words in front of a model: the narrative (`_action_proposals` drops it), the chat's open-alert digest (`<briefing>` — the principal's verified turn gets a separate `<roster_requests>` block instead; see Agents), `ack_alert`, a single ack (`POST /alerts/{id}/ack` is a 409), the \"Dismiss N older than 7 days\" count and the server's bulk ack, reopen, the TTL sweep and the alert review (`roster_request` is in `lifecycle.TTL_EXEMPT_SOURCES`). It ends when the request does: answered (`ack`, or `dismissed` on a decline) or expired after `ROSTER_REQUEST_TTL_DAYS`.\n- **`people`** — an attention-ranked roster of the **team** (the principal's contacts are never listed, and get no insight note). Each person carries `awaiting_action` count, soonest SLA, a `status` (`on_leave` / `needs_reply` / `awaiting` / `clear`), reachability, `overdue`, a server `priority` sort key, and a cached one-line `insight`. Sorted by `(-priority, full_name)`. Stale insight notes are regenerated in the background only when the roster has more than one person: the UI shows the People sidebar only for more than one, so a one-person install (solo, or a team before anyone else is added) does not pay a daily model and peer-memory call for a note nobody sees. Cached notes are still served.\n- **`proposals`** — the *live* unread alerts (workflow approvals, triage-classified inbound, Executive signals, flagged artifacts, and gated calendar bookings; an artifact is listed only to its owner (`alerts.models.visible_alert`; every other build of the board — the briefs, the reflection, the review, the chat digest on anyone else's turn, the activity rail — leaves drafted artifacts out) and carries `artifact_format` / `artifact_url` and a `body` already rendered to Markdown for its format, so the card badges it as a web page, Word doc, spreadsheet or link and offers *Open artifact*): unread, inside their category TTL, not snoozed — see *Alert lifecycle* below. Each carries `score`, `category` (`action` vs `monitoring`), `surfaced_reason` from `openexecutive.briefing.ranking`, the lifecycle fields (`occurrence_count`, `last_seen_at`, `last_reviewed_at`, `review_verdict`, `review_note`, `recommended_move`, `why_now`, `due_at`, `superseded_count`, `suggested_workflow`), and `decision_instance_id` (set only when the proposal is backed by a decision-ledger row — a calendar booking awaiting approval). `failed_run_id` is set only on a `workflow_failed` card (a scheduled run that ended in error, see Scheduler): its main button is **Run again** (`POST /workflows/runs/{id}/rerun`, which also closes the card) and its ⋯ opens the run; it has no Approve. The response also carries `held_back` for the principal alone: the lines grounding left out of the morning brief or end-of-day digest in the last day, which Home lists under **Left out of your brief** (the brief's note names it; Hide is remembered in that browser). The UI splits them into 'mine' vs 'across the team' using `caller_person_id`. Approve is carried out on the server for every card. For decision-backed proposals the card's Approve/Reject call the `/decisions` endpoints (which book or cancel the event server-side and clear the alert), so meeting bookings are reviewed in the briefing itself rather than on a separate page. Every other proposal is approved at `POST /alerts/{id}/approve` (`alerts.approvals`): it records who approved the card and when (an `alert_approvals` row plus `alert_approved`, then `alert_approval_done` / `alert_approval_failed`, audit rows), claims the card in one transaction so a double click or a second approver gets a 409 and the work runs once, then does the work. A card the scheduler filed for a department-gated action is bound to it server-side (`alert_held_actions`, written only as the card is filed, never read from the card's tags or text, which a model reading inbound mail can write), and approving it queues that exact action again with no department, the approval being the consent the gate waited for. Any other proposal runs one Executive turn as the approver in a new chat on the server (`chat.start_background_turn`, the machinery behind `POST /chat/background`), with the edited text verbatim for Edit & approve; it keeps going if the page closes. Only the card's routed person or the principal may approve a routed card, and only the principal an unrouted one (403 otherwise); the card's text reaches the turn as quoted data, not instructions. A row at the top of Needs you follows the approval (`GET /alerts/approvals/{id}`): working on it with a link to the chat, then done, or didn't work with Try again; a card whose last approval failed can be approved again, and one still running at a restart is marked failed on boot. The page no longer acks the card and seeds a chat turn with the proposal, which left no record of the approval and did nothing if the tab closed first.\n- **`narrative`** — a per-viewer Executive-voice header (\"What's going on\") synthesized by `synthesize_briefing_narrative`, cached per scope in `briefing_narrative`: the resolved principal gets the whole-company `principal` scope (which may carry what is private to them), a caller who resolves to no roster row the shared `company` scope (written from what everyone may see), and each teammate a role-scoped `person:<id>` one. `narrative_generated_at` says when the served text was written and `narrative_stale` whether a fresher one is being written now. Home shows it as **Right now**, a card above Needs you, because the text is rewritten through the day: `briefing.right_now.split_narrative` splits the served text into `narrative_lead` (the bold opener), `narrative_points` (`{text, since}`) and `narrative_move`. `since` is when that point first appeared today, kept per scope and local day in `briefing_point_seen` (keyed by the point's bold subject, so a reworded point keeps its time; recorded when a header is written, earlier days pruned then). `narrative_seen_at` is when this reader last looked, from `briefing_reader_seen`, set by `POST /today/seen` (same scope resolution as `GET /today`; the shared `company` scope of unrostered callers keeps no look, so one stranger's visit never resets another's); the page fixes it as the baseline for the visit, marks points after it with a green dot and *N new since …*, and only counts a look from earlier the same day. For the principal the response also carries `morning_brief` (`{at, text}`, today's delivered morning brief from `brief_state.last_delivered`) and `calendar_next` (up to 3 meetings still ahead today from the cached calendar read, never a fresh call), which the side panel shows under the points and Move today. Nothing here calls a model. In the web UI each bullet of this narrative is a click target: clicking one hands off to chat (the same `onContinue` path as the proposal cards) seeded to discuss that item. The Executive recognizes it because every chat turn now carries a `<briefing>` digest of open alerts (see Memory). That digest (`briefing.context.format_open_alerts_for_prompt`) is capped at 30 items; when the board is longer the header says so explicitly and tells the Executive to point at this page for the rest — it previously presented the capped list as the complete board, so the Executive described a slice as everything that was open (#136). Chat adapters get the digest too, but Slack gates it to the principal's DMs: the board is company-wide and must not be pulled into a shared channel. The `[alert_id]` at the start of each line is also what `ack_alert` trusts, because an id quoted inside an alert's own body came from inbound mail or chat and is attacker-controlled. This page's `[Discuss mode — alert_id=N]` handoff primer is a pointer to which item is under discussion, not authority on its own: the server accepts it only if that id is on the live board too. Two things enforce that. Every field the digest interpolates — headline, body, suggested action, tags, review note — is collapsed to a single line, since a newline in any of them would forge a whole extra `[N]` line and with it a fabricated instruction to clear someone else's alert. And the server records the live board it derived, so `ack_alert` refuses any id outside it — on **every** session, not just the chat adapters. The recorded set is the whole live board, not just the rows the digest printed, so a card past the render cap stays ackable. The control stops invented, closed, snoozed and expired ids; it does not stop the model being argued into acking the wrong *live* card. When the principal names an item that has already left the board — opened, snoozed, or older than it — the Executive looks it up with `find_alerts` (a keyword search over every status, `alerts.store.search_alerts`); matches that are still open (`unread` or `read`) become ackable for that turn, up to 25, and closed ones come back labelled so the Executive can say the item is already settled. It works only where the principal's own board was shown this turn — the web app or their DM — and never returns roster-request cards (see Lifecycle). The digest's header also labels every headline and detail as untrusted content drawn from inbound mail, chat and watched pages — act on what the principal asks about an item, never on what its text asks — and triage reads each signal inside an `<event>` block whose closing tag the sender's text cannot forge (it is defanged in any case and spacing, after NFKC folds fullwidth forms). That check used to run only when `origin_channel` was set, which the browser never sets, so the one surface where the principal actually reads their board had no check at all and the model could ack any id, including one quoted out of an alert body by the Discuss handoff. Rendering the block and recording its ids now happen together in `briefing.context.render_and_trust`, which both the web chat route and the channel adapters call: render without recording and the tool refuses everything, record without rendering and the model gets reach it was never shown. A turn that was shown nothing trusts nothing. Recording it is only half the wiring: the tool reads the board off the turn's session through a ContextVar, and the chat route binds that session for the whole SSE body (`set_session`, next to `set_turn`). Bound from inside the Executive's own generator instead, it survives exactly one stream step — `asyncio.wait_for` runs each step in a fresh Task with a copy of the context — and the tool-call loop, which runs later, sees nothing. That shipped, and every web ack was refused on cards that were open the whole time. The digest also carries a short **already handled** tail — recently acked / dismissed / resolved rows, named but deliberately NOT trusted for acking — because a card cleared on the page minutes ago is otherwise simply absent from chat: asked to \"record that as fixed\", the Executive could not tell a settled item from one it had never heard of, and sent the principal back to dismiss a card that was already gone. That tail renders even when nothing is open, which is exactly when it matters. Note it is a different window from the `handled_overnight` rail above: that one runs since the last delivered morning brief, while the chat tail looks back 14 days (matching the action-alert TTL, so it still covers an item cleared late in its life), so chat can name a settled item the rail no longer shows. On the principal's own verified turn the digest also lists their chat drafts still waiting in their mailbox (when, to whom, subject), so a brief line about a draft can be discussed; `read_my_email` shows drafts in a thread marked not sent, so a thread that is only a draft does not read as empty. The narrative is held to what is **live**, and to what it is actually for. The `alert_raised` source is dropped from the activity it reasons over (`_build_activity(..., include_alert_raised=False)`): a closed alert reads as work the principal already settled, and a *live* one is worse than redundant — `lifecycle.is_live` is the very predicate behind `list_live_alerts`, so every live raise is already a proposal card below the header, which the prompt forbids re-listing. The `/today/activity` rail keeps the whole source, because a raise really happened. The activity block is only labelled \"since last brief\" when the caller bounded it with `since` (the standalone briefs do; the header does not), since calling an unbounded history rail a delta made the header present weeks-old rows as overnight news. When the viewer's slice holds nothing that wants a decision — no action proposal, no at-risk/off-track department, nobody awaiting — the regen skips the model call entirely and writes the fixed quiet line (`Quiet right now — nothing pressing.`, or `… nothing needs you.` for a teammate). **The cache key is a hash of the rendered context itself** (`today._narrative_context` builds it once and both the hot path and the background task key off that one string, which is also handed to the model verbatim). That makes the key a function of the model's input: everything the prompt renders is covered, and nothing it omits can trigger a regeneration. Keying on hand-picked fields broke one half or the other each time — headlines alone left the rendered activity block uncovered, while the proposals' review fields are never rendered by this header yet are rewritten with fresh prose by every `alerts.review` pass, so they regenerated each viewer's narrative several times a day to re-synthesize identical input. A quiet board keys off a fixed sentinel instead, so a moving rail cannot re-key an entry whose text is constant. Together: on a fully dismissed board every other input was empty, the rail became the only context, and the model synthesized a confident header out of closed items.\n\n **Live, not just the board.** The header used to reason over the alert board, goal health and the Executive's own bookkeeping only — mail and chat handled that day, replies the gate held and the next meeting never reached it, so it read the same for days while the principal's day moved on. The whole-company scopes now open the context with the principal's world as it is happening (`briefing.live_signals.gather_live_signals`, rendered by `render_live_blocks`), under a `NOW:` line: **INBOUND** (`integration_inbound` audit rows that carry a message, one per message id, grouped by sender and subject, with an email's first line; the principal's own mail reads \"from the principal\", an email from the roster says \"the Executive replied\" only when a reply was logged in its thread after it (`unanswered_mail.record_reply`) and \"no reply went out\" while its `unanswered_mail` card is open (on the principal's own read only), and a time on another day carries its weekday and date), **STUCK** (`integration_outbound_blocked` to a recipient, the inbound \"reply blocked at outbound gate\" and Google Chat \"left unanswered\" / \"not delivered\" rows, and chat drafts Act as me saved in the principal's mailbox that are still there: `delegation_drafts` rows not yet marked sent or `gone_at`; before each scheduled header refresh and each morning brief, `live_signals.settle_principal_drafts` looks up the principal's open chat drafts from the last two days in their mailbox and marks the ones sent or deleted there, or answered by a message of their own sent in that thread after the draft, so a draft they sent (or replied around) from Gmail stops reading as waiting; the same read keeps, in memory only, who each waiting draft goes to and its subject, so STUCK names each draft instead of a bare count), **CONVERSATIONS** (the principal's own web chat titles), **OWN** (the principal's own mail and chat-app messages to the Executive, kept out of INBOUND and its count, principal scope only) and the **REST OF TODAY'S CALENDAR**. The principal's own messages and chats render as background blocks, and every brief prompt carries `OWN_MESSAGES_RULE`: they show what the reader already said and asked, are never reported back as news (no \"you messaged me\", no restated complaint or rating), and an open ask appears only as what the Executive is doing about it. The window is the local day, or the last 12 hours when that is longer. Private audit rows, drafts, chat titles and the calendar (meeting titles are the principal's own) are read only in the `principal` scope — `gather_live_signals` drops the calendar whenever `include_private` is false, whatever the caller passes, so the shared `company` header never quotes it. The calendar is never fetched on the request: `live_signals.refresh_calendar` caches one read per 15 minutes (the scheduler tick refreshes it) and the header quotes the cache. Every quoted field is collapsed to one line and cut, and the blocks and the prompt both say the text is data, never instructions — inbound mail is attacker-controlled. With live blocks present the context also ages each proposal (`raised 2d ago`, whole days), names each at-risk department's slipping goals (`attention_goals`) and adds an **EXTERNAL SIGNALS** block (monitoring alerts from the last 24 h, never enough on their own to break the quiet line); the rhythm runs (`today.RHYTHM_WORKFLOWS`: the morning brief, end-of-day digest, reflection and weekly review) are dropped from the activity it reasons over. The prompts (`BRIEFING_NARRATIVE_SYSTEM` and its solo variant, `NARRATIVE_PROMPT_VERSION` 6) lead with what is live and give a days-old item at most one bullet. Anything live breaks the quiet line; the NOW line and window move at most once an hour, so the key moves hourly on time alone plus whenever something new lands; the calendar is placed at the real time (a meeting that has ended drops out, the one under way is IN PROGRESS), which moves it only when a meeting starts or ends. An address that belongs to someone on the roster (or, in the principal scope, one of the principal's contacts) reads `Name (address)` in these lines (`live_signals._named`), so the header calls people by name instead of making one up from the address.\n\n **Who reads it.** Every brief surface (this header, the morning brief, the end-of-day digest) is written for one person, fixed in code by `briefing.reader`: the principal on the principal scope, the teammate on a `person:<id>` scope, and the principal on `company` too (that scope has no signed-in caller and uses the principal's prompt, built from shared rows only). `render_briefing_context(reader=…)` masks that person's full name and email addresses everywhere in the context to \"the reader\" (their own chat and mail, the Executive's replies to them, chat titles, the activity rail) and heads it with a **THE READER** line naming them; every brief prompt carries `READER_NAME_RULE`: write \"you\", never the reader's name, \"the reader\" or \"the principal\" (anyone else by name), and \"I\" / \"me\" / \"my\" for the Executive. A draft that still slips (`reader.slips`) is sent back once to be rewritten, and what is left after that is fixed in code (`reader.fix_slips`: the reader → you/your, \"the principal\" → the owner's name on a teammate's brief, the Executive → I/me/my).\n\n **Fresh without a reload.** The daily floor in the key and the PERIOD line are the principal's **local** date (`narrative_cache.local_today`), not UTC's, and a row written on an earlier local day is not served as today's. Regenerations are serialized per scope; a trigger that finds one running marks the scope pending and the running pass goes round once more (it built its context before that trigger's news landed), and after a failed pass (model error, the 33 s timeout: 25 s for the draft and 8 s for a rewrite, empty text) no view or tick starts another for 5 minutes and `narrative_stale` reads false, so the page drops its placeholder instead of spending a model call per view. They log `today: narrative served scope=… age_s=… stale=…` and `today: narrative regenerated scope=… ms=…`, and no longer need a page view: every `BRIEFING_NARRATIVE_REFRESH_MINUTES` (10) between `BRIEFING_NARRATIVE_REFRESH_START_HOUR` and `_END_HOUR` (06–22 local) the scheduler runs `today.refresh_principal_narrative`, which refreshes the calendar cache and rewrites the principal's header only when its key moved (see Scheduler). The Briefing re-polls `/today` at 4, 10 and 20 s while `narrative_stale` is true, re-pulls it when the tab comes back (at most once a minute) and every 5 minutes while visible, shows \"Updated 2:04 PM\" beside the heading, and shows \"Catching up on today…\" while the first header of the day is written (`lib/narrativeFreshness.ts`, tested by `npm test`).\n\n In **solo mode** (one person using Open Executive for themselves) the header speaks to the principal, whatever their role: a solo prompt over a context that lists goals at risk by *area* and has no \"people waiting on you\" block, and the quiet check ignores who is awaiting. The cache key carries the mode for solo only, so solo and team never share a cached narrative while every team key stays exactly what it was — no team cache is invalidated. The response shape does not change. For the principal's own view the solo context also carries a **DUE THIS WEEK** block — the principal's open loops that are overdue or due within 7 days (`today._with_due_soon` → `open_loops.principal_due_soon`, labelled OVERDUE / due today / due <weekday>) — which counts as needing attention in the quiet check and moves the cache key when an item is added, closed or falls due; a teammate's scoped view and team mode never get it. The header never gets the morning brief's *top three today* block — that is the DM brief's (see Workflows); the page shows the same top three in a card of its own (see *Solo focus cards* below). It does get the rest of today's calendar through the live blocks above, from the cached read.\n- **`in_flight`** / **`awaiting`** — upcoming Executive commitments and people we are waiting on.\n- **`handled_overnight`** — the autonomous moves the Executive *completed* since the last delivered morning brief: the alert review's (routed, nudged, escalated, drafted, merged, closed) plus the research watch policy's (`watching` — a watch added on its own because it was grounded in company data; `stopped_watching` — a research watch auto-disabled as noisy or dead; no alert id, re-enable from `/watchlist`). A `changed` verdict (the review rewrote an open alert's headline / body / severity) is deliberately **not** here: the alert is still open in \"Needs you\" and its card carries the note, so the brief reports it under \"what changed\" (a REWRITTEN block) rather than as done. Each row is structured, not just a sentence: `kind`, the audit `summary` (nudge bookkeeping marker stripped), `at`, `alert_id`, `event_type` (for a pre-filtered `/audit` deep link), `headline` (the alert's headline at move time; a watch's slug), `target` (person name for routed / nudged, survivor headline for merged, new severity for escalated, draft title, workflow name), `detail` (the cited evidence or the watch policy's reason), `outcome` (`resolved` | `dismissed` for a close, `proposed` for a route that went through the authority gate), `evidence_ref` (S1 / R2 / A3), `superseded_by_alert_id`, and `status` — the alert's lifecycle state **now** (`open` = live in the queue per `lifecycle.is_live` | `resolved` | `dismissed` | `expired` | `merged` | `acked` | `inactive` for snoozed / past-TTL rows), looked up per row so a close the principal already undid renders as reopened instead of offering a second Undo, and a \"still open\" jump link only appears when there is a card to land on. Audit rows private to the principal (say, one naming their contact) are in this list only on the principal's own `/today`: `brief_state.handled_since` leaves them out unless asked, and the written briefs never ask, since a brief can be read by others. The Pulse heatmap's per-day counts (`GET /today/activity/daily`) likewise leave out a private decision or private alert, as the activity rail does. The morning brief also carries a one-line count of research watch suggestions waiting on `/watchlist`.\n\n**From your chats.** `briefing.brief_requests` holds what the principal asked of their brief in conversation: `leave_out` lines from `leave_out_of_brief` (\"take the Halcyon renewal out of my brief\", kept 14 days) and `raise` lines the conversation review could not fix itself (`raise_in_brief`, kept 2 days), at most 20 live. A line is at most 12 words (leave out) or 30 (raise), with no link, handle, markup, identifier or talk of instructions, and only lines written under the principal's own id render. `render_briefing_context(brief_requests=True)` adds the raise lines before the quiet-day check, so they are raised even on a quiet day, and the leave-out list as the very last block; both sit inside the rendered string the /today header hashes. A teammate's brief or header passes `False`: they are the principal's own words.\n\n**Standing facts.** `render_briefing_context` appends the standing facts (`memory.facts`: corrections kept from chat, a teammate's marked `(per <name>)`) as its last block, after the quiet-day check, so a fact never makes a quiet day look busy. Every brief prompt (this header, the teammate header, the morning brief and the end-of-day digest) carries `narrative.STANDING_FACTS_RULE`: use the facts quietly, never mention one or that it was saved, and leave an item a fact settles out without saying it was dropped. A fact settles only what it plainly says. Without it, a fact saved in chat came back as the header's top point, stretched to an item it never named. The morning brief also carries **TEAMMATE CORRECTIONS SINCE LAST BRIEF** (`facts.render_teammate_changes(since)`: each teammate fact recorded in the window that is in use now, plus — only when the brief is the principal's own private one (`_private_ok`), which then keeps the run out of the shared history — those waiting for their approval, since other teammates may run the brief and never see a proposal that is not theirs) before the quiet check — it is news, the principal's only FYI of it — and in the brief's fingerprint (`build_brief_fingerprint(teammate_changes=)`), so a correction alone un-suppresses an otherwise unchanged brief. Every other caller passes none, so its context is unchanged. The /today header hashes that rendered string as its cache key, so a new or retired fact marks the header stale and it is rewritten with the correction. The morning brief (standalone) and the teammate-scoped header get the same block. On the scheduler's delivery to the owner alone, with their Always in the loop switch on, `render_briefing_context(owner_notes=)` also carries FROM YOUR NOTES — DUE SOON (their own notes of what they promised or asked, overdue to a week ahead; `memory.history_brief`), which counts against a quiet day, enters the fingerprint and marks the run private; both standalone prompts turn it into a **From your notes** section. The /today header never gets it. **The first week.** For seven days from the principal's People row (`briefing.first_week`), `render_briefing_context(getting_started=)` carries a GETTING STARTED block right after the live blocks: the install's goal rows (department, key result, target, period) or, while there are none (setup saves no goal rows, so this is a fresh install's usual case), this year's priorities and north star from the saved profile (`strategic_priorities`, up to five, keys `priority:<text>`), departments with no `head_person_id`, and, on the scheduler's delivery to the principal alone with Act as me and Draft replies to my inbox both on and the mailbox connected (the inbox watcher's consent), up to five people who wrote to their own mailbox in the last 48 hours as sender and subject only (`inbox_message_ids` + headers of `get_message`, bulk and automated mail skipped; the same \"where, never what\" rule as `delegation.mail_reads`) and, with Act as me and Read my calendar on, up to eight of today's events on their own calendar as time and title (declined ones left out). It counts against a quiet day, enters the fingerprint (`getting_started=` keys, no dates; a meeting's key is its event id) and, with the inbox or calendar part, marks the run private. Both standalone prompts open with a **Getting started** section and take the Top call from it (`GETTING_STARTED_RULE`). The /today header does not get the block: in the first week it is the same header as any other day. Home's top slot is instead the **first-week card**, built in code with no model call (`first_week.first_week_card`): `needs_goal` while no goal row exists (fixed ask \"Give me one goal with a date, and I'll track it every day.\" and a **Set a goal** button to `/goals?add=1`, which opens the add form), up to two findings from the latest finished team `executive_research` run (the run history keeps only the artifact, so `executive_research.parse_artifact_findings` reads back its \"Findings reviewed\" lines; most severe and most certain first, headline plus the summary's first sentence) with a line linking `/watchlist`, and `brief_tomorrow` on the setup day until the first morning brief is delivered. No goal still to set and no findings means no card. `GET /today` sets `first_week_card` and `first_week` (whether there is a card) for the principal only; while there is one the Briefing hides the \"Quiet day\" banner and an all-zero summary line reads \"Your first week. Start below.\" The last setup screen (`OnboardDone`) offers one first question built from the saved priorities (`firstQuestion`) and hands it to Home through session storage (`oe.onboard.firstQuestion`, never the URL), which asks it once. A teammate's scoped header never gets it. The alert review's `render_batch` puts the same block ahead of the alerts (read once per pass), so a note, rewrite or routed DM never repeats a figure the principal already corrected.\n\n**When a brief isn't sent.** Above the Briefing, the owner sees a one-line notice when their latest morning brief, end-of-day digest or (in solo mode) weekly review wasn't sent — \"Your morning brief wasn't sent: nothing is set up to send it to you\" — with the day, what fixes it, a link to read the brief on the Artifacts page (left out when the brief couldn't be written at all) and one to Setup status. It comes from `GET /today/brief-delivery` (the scheduler records each run's outcome), shows nothing while briefs go out or while the scheduler is off, and clears once the cause is fixed. When the Executive's mail connection wasn't running (the MCP gateway failed to start and is retrying), the notice says that instead of blaming the owner's setup; a send that failed on every channel names what each channel answered, from the recorded `detail`, with addresses left out. Teammates never see it.\n\n**Replies waiting.** With Act as me's **Draft replies to my inbox** on, the top of the Briefing's left column lists the replies the Executive drafted in the owner's own Gmail for mail that needs them (`RepliesWaiting`, from `GET /delegation/replies` — see Act as Me). They belong to the owner alone: the route answers only the person who can have Act as me, the decisions behind the cards (`delegation_reply`) are principal-only and carry `private: true`, so `/today/activity` and the heatmap leave them out, and none is ever an alert, so nothing of them reaches `GET /today`, the header or the briefs. Each card shows who wrote and who they are to the owner, whether their address was verified, the subject, what they wrote (as plain text), the draft, **Decide before sending** (its open questions) and its warnings, with **Send**, **Edit in Gmail** (the thread in their Gmail) and **Dismiss** (which deletes the draft unless they edited it). **Send** asks first, naming who the reply goes to, then sends the draft exactly as it is in Gmail (`POST /decisions/{id}/approve`); when its recipients changed in Gmail or a newer message arrived, the backend's 409 `confirm` becomes a second question naming them. The card hides itself when nothing is waiting.\n\n**Solo focus cards.** `GET /today/top-three` and `GET /today/weekly-review` feed two solo-only cards, so a principal who only uses the web app — no chat app, no Google Workspace — sees today's top three and the weekly review instead of finding them only in the Workflows run history. Both answer only in solo mode (`effective_workspace_mode`) and only to the principal, by the stricter rule for starting a principal-only run (`workflows._caller_is_the_principal`: the caller's own email on a principal entry that is not archived, or no `x-caller-email` at all — never \"nobody is principal yet\"); a teammate, any other signed-in caller and team mode get null. `top-three` hands `open_loops.principal_due_soon()` to `briefing.top_three.build_top_three` — the morning brief's own inputs and code, so the items, their order and their free slots are the brief's — and returns `{items: [{key, kind, text, why, slot}]}`: `slot` is the free block (\"10:00–11:00\", the user's zone), \"\" when none is left, or null when no calendar was read (none connected, a failure or the 4 s timeout, a weekend); `items` is empty when there is nothing to pick. It is a route of its own, never part of `GET /today`, so the Briefing never waits on the calendar. `weekly-review` returns the latest `weekly_review` run with status `done` (`persistence.list_runs(..., status=\"done\", limit=1)`, newest `updated_at` first; failed and running runs never count) as `{run_id, completed_at, period, top_three, excerpt}`: `weekly_review.summarize_review` reads the artifact's title line and its last *Next week's top 3* section back as plain text, and `excerpt` stands in when that list is empty (the section's own note, else the review's first lines). Null when no review has completed or the run store cannot be read.\n\nThe route resolves the caller from `x-caller-email`, serves the viewer's cached narrative and, when its key moved, rewrites it in a `BackgroundTask` so the request never blocks on an LLM call (the page re-polls while `narrative_stale` is true). `GET /today/activity` returns the recent self-initiated action rail — merged from fired scheduled actions (DMs, follow-ups, nudges, cadences), logged decisions, saved advice, completed workflow runs (briefings/check-ins/research), kicked-off initiatives, resolved gated decisions, and raised alerts, so it reflects all of the Executive's activity rather than just dispatched messages. A brief or digest delivered to its reader (`scheduler.runner._deliver_to_principal`) records its send as kind `brief_delivery` (`schedule_tools.recorded_as`): the outbound guard still counts it, but the rail and the heatmap leave it out, because every later brief reads the rail and used to repeat its own last top call as work done. A completed run is named in plain words, never by its log title (`workflows/run_outcome.py`: \"Researched your market\", \"Checked in with Sales\", or the name it was started with, less any date or how-it-started note), and carries `detail`, one line on what came of it read from its stored artifact (research: updates looked at, messages sent, alerts raised, things now watched; a check-in: actions proposed; the weekly review: next week's top item; other runs: the first sentence; none for briefs and the reflection), and `artifact_id` (`run:<id>`) when it kept a write-up (never for the reflection, which reads the principal's live alerts), so Pulse's Done for you and All activity link **Read it** to `/artifacts/run:<id>`. The Pulse page (`/memories`) polls it (limit 100) every ~20s so new events stream into the 'Recent activity' card, which scrolls internally at a fixed height instead of growing the page. The `morning_brief` workflow calls `_build_today()` directly to build the standalone DM (via a different, enumerated prompt; solo mode has its own, with goals at risk by area and no waiting-on section). `GET /morning-brief` is a deprecated alias.\n\n**Solo mode in the UI.** The response is the same in both modes; the briefing reads the workspace mode from the app-wide `WorkspaceProvider` (which reads team while loading or on error, so a team install never flashes solo) and, in solo, drops the team surfaces: the Departments card, the People card, the \"Across the team\" lane (every action proposal is the one user's, so all of them land in \"Needs you\"), the people-awaiting, people-overdue and departments-at-risk status pills, and the quiet-day \"Set up a check-in\" link. A \"N goals at risk\" pill (at-risk plus off-track goals, from `departments`) links to `/goals` instead, so the strip never reads \"All clear\" over a goal that is slipping. In the Departments card's place, **Your projects** lists the initiatives with status `active` (`GET /memories/initiatives`): **Done** marks one `completed` through `PATCH /memories/initiatives/{id}` (only `completed` takes an initiative out of the Executive's active context), and **Drop** deletes it through `DELETE /memories/initiatives/{id}` after a confirm. Under **Needs you**, a **Due soon** card lists the principal's open loops that are overdue or due within 7 days — their dated commitments and what others asked of them — read from `GET /people/{id}/open-loops` for the principal (the oldest principal in `people`, the backend's rule), labelled by `lib/dueSoon.ts` (tested by `npm test`: \"Overdue since Sep 23\" / \"Due today\" / \"Due Mon, Sep 28\", with a count of anything due later); **Done** closes one through `POST /open-loops/{id}/close`, which also stops the nudge engine chasing it. Above it, **Top three today** numbers the morning brief's three (`GET /today/top-three`) with each one's reason and, when a calendar was read, its free slot (or \"No free time left today\"); at the top of the right-hand column, **This week's review** (`GET /today/weekly-review`) shows the period, when it ran, next week's top three (or the excerpt) and a *Read the review* link to its run page (`/jobs/runs/{id}`). Each card fetches on its own once the Briefing has loaded, so a slow calendar never holds the page up, and renders nothing when the API returns null or an empty list. A commitment in the top three reads as the owner's own (\"Send the proposal\") through `lib/dueSoon.ts`'s `loopText`, as in Due soon; the cards' wording lives in `lib/rhythmCards.ts` (tested by `npm test`). The Pulse page hides its \"Department check-ins\" and \"Awaiting people\" blocks in solo, and its header shows active projects in place of the department check-in count. Team rendering is unchanged.\n\n**Your month (`GET /today/value`).** The owner's own tally of what the Executive did for them, `briefing.value_summary.summarize(period, offset)`: the calendar `month` or `week` (Monday first) in the user's zone, `offset` periods back (0–24), each line beside the period before. Every number is a `COUNT(*)` of rows that prove it happened, never a model's: messages sent for the owner (the DM handlers' own `kind=outbound` sent rows to anyone but the owner, plus Gmail / Outlook send-tool calls that didn't come back with an error, so mail sent from a chat turn counts), replies drafted and sent from the owner's inbox (their Act as me rows), meetings booked (calendar create calls), briefs delivered (the scheduler's `delivered` row), reports (finished team workflow runs, minus the daily rhythm runs and any run a teammate started for themselves, which stays theirs alone; the latest ten listed with links), follow-ups and nudges sent, tasks tracked and closed as done, proposals decided, alerts flagged and requests answered (`chat_turn` out rows). No \"hours saved\" and no cost line: nothing recorded supports the first, and cost next to what the owner got reads as a bill; it has `GET /audit/usage`. The owner's alone (403 for anyone else): it counts rows private to the owner, never a row private to another member. Pulse shows it as the top line of the overview's **Done for you** panel (\"October 2026: 42 messages sent, 6 reports, 3 meetings booked\") and a focused screen, `/memories?tab=value`, with a month / week switch and previous / next. On the first weekday of each month, in daytime (09:00–18:00 local), a scheduler tick hook sends the owner last month's lines and a link (`value_summary.maybe_send_monthly`, claimed once per month under `briefing_narrative` scope `value_summary:YYYY-MM`), in solo and team mode alike; nothing is sent for an empty month. Off with `VALUE_SUMMARY_MONTHLY_ENABLED=false`.\n\n## Alert lifecycle & the Executive review\n\nAlerts used to be write-once: raised, then never looked at again, so the \"Needs you\" queue grew without bound and the briefs re-listed it daily. Four things now keep it live and true:\n\n- **Time-to-live** (`openexecutive.alerts.lifecycle`). Action items expire after `ALERT_TTL_DAYS_ACTION` (14 d), unrouted low/medium monitoring signals after `ALERT_TTL_DAYS_MONITORING` (3 d). Every surface reads `list_live_alerts` (the same predicate the scheduler's 15-minute sweep persists as status `expired`), so `/today` is right even before the sweep runs. Artifacts and decision-backed alerts are exempt. `POST /alerts/{id}/reopen` is the Undo. **Snooze** (a card's ⋯: later today, tomorrow 9:00, Monday 9:00, in the viewer's clock; `POST /alerts/{id}/snooze`) hides a card until `snoozed_until`, with an Undo; the TTL anchor is the latest of `created_at`, `last_seen_at` and `snoozed_until`, so a snoozed card comes back rather than expiring unseen.\n- **Coalescing** (`alerts.pipeline` + `store.coalesce_alert`). A repeat of an open alert with the same `(source, dedup_key)` updates that row — `occurrence_count`, `last_seen_at`, severity max — instead of stacking a second card, and only re-pings when severity rose to high/urgent. Monitoring alerts carry a stable `watch:<slug>` key, so one watch means one card.\n- **Collection tags** (`alerts.pipeline`). A triaged alert never carries a `collection:<name>` tag: the pipeline strips them before inserting. Only an installed extension's own code files a document into its collection (`orchestrator.extensions`), so injected text can't make a card that the extension would treat as its own.\n- **The review** (`openexecutive.alerts.review`, heartbeat `alert_review_scan`, every 6 h and right before the morning brief). For each open alert the Executive sees what changed since it was raised — newer signals from the same watch, related alerts, activity since, the roster with SLAs (team members only — an alert routed to a contact never puts them in the slice, so they are never routed to, nudged or chased; a private card is never reviewed at all, nor used as evidence for another), department authority — and returns a verdict (relevant / changed / resolved / stale) plus a recommended move. Deterministic policy then acts: **route** (assign + DM the owner; `propose_via_alert` for propose-only departments), **nudge**, **escalate** (severity + `due_at` + DM the principal only), **draft** (`draft_artifact`), **suggest a workflow** (a link, never a run), **merge** (`superseded_by_alert_id`), or **resolve** — only on high confidence citing a server-minted evidence ref (a newer signal, a related alert, an activity item shown for that alert); free text never closes a card, and anything weaker is annotated `likely_stale`, demoted 30 ranking points, and left for one click. Everything that came from outside is rendered as inert data inside the review prompt, so an injected email body cannot steer the batch. Board / comp / legal matters only ever go to a scope-holder or the principal and keep their text. Route and escalate are idempotent across passes, every DM carries an \"[Alert review] Re: …\" header, outbound moves are capped per pass, passes are single-flight, `ALERT_REVIEW_ENABLED=false` stops every caller, every move is audited with its evidence and prior state, and a distinct `resolved` status keeps Executive closes separate from `ack` (user approved). A review DM is proactive outreach, so the recipient's notification settings apply: one held for their quiet hours or brief counts as a route made but not as a nudge toward the cap (and no second nudge is held while one waits), and one about an alert whose severity is (or becomes) `urgent` is marked urgent (`notifications.urgent_send`) and gets through when they let urgent things through.\n- **Grounded text** (`openexecutive.briefing.grounding`). Nobody reads an alert's text before it is dispatched, so what the model wrote onto it must be supported by what it read. After triage (`alerts.pipeline._ground_decision`, before coalescing or inserting), a headline naming a person or figure the event does not hold — sources are the event's subject, sender, title and body, the initiatives triage was shown and the company profile — is replaced by the event's own subject, such body sentences are dropped (all of them → the event body cut to 280 chars); both fallbacks are raw event text, so they are made inert first — links masked, Markdown and Slack `<…>` syntax and @-mentions stripped — because a broadcast posts them as written, and such a suggested action is dropped. A review `changed` rewrite is checked against the alert's own text and the evidence it was reviewed with (signals, related alerts, activity, the roster slice), plus the standing facts the batch was shown, so a rewrite that corrects a card to one of the principal's corrections is grounded; an ungrounded rewrite keeps the old text, still applies a severity change, and audits `text_ungrounded`. A name counts as grounded only when one source line holds all of it; a figure only when a source number matches it within the precision it is written with. Each finding writes a `grounding` audit row; `GROUNDING_CHECKS=report` records without changing anything.\n\nOn the page, cards read as decisions: the one-line \"what changed since you last looked\" (`review_note`) leads, the recommended move is the primary control (Nudge <owner> → chat; Run <workflow> → `/jobs/<name>`), with chips for age, seen ×N, why-now / due, folded-in and draft-ready, a \"Reviewed <ago>\" footer, and an amber Likely-stale treatment with one-click Dismiss. \"Needs you\" shows *Start here* + 8 cards + \"Show N more\", a \"Dismiss N older than 7 days\" footer (explicit ids to `POST /alerts/bulk-ack` — never a server-side age sweep, which would hit teammates' routed items), and \"Re-check relevance\" (`POST /alerts/review`). The handled rail (anchor of the \"Executive handled N overnight\" pill) is deliberately one sentence by default: a first-person heading built from counts only — \"Since your last brief: N off your plate (closes still standing, and merges whose survivor is not itself listed; a merge into a listed survivor counts on that survivor's row), N in others' hands (routed / nudged), N waiting on you (escalated)\", plus \"N drafts ready\", \"N workflows suggested\", \"N watch changes\", \"N other moves\" (a kind the UI does not know) and \"N back on your plate\" (a close that is open again) when present — with the rows behind a \"details\" disclosure, and nothing rendered at all when the grouped rows are empty. The pure logic (grouping, headline, links) lives in `packages/ui/src/lib/handled.ts` and is covered by `npm test`. Expanded, it shows one first-person row per alert (\"Resolved *X* — evidence\", \"Dismissed *X* as stale — evidence\", \"Handed *X* to Dana Kim\" / \"Proposed *X* to Dana Kim (awaiting their approval)\", \"Chased Dana Kim on *X*\", \"Raised *X* to high\", \"Drafted *T* from *X*\", \"Folded *X* into *Y*\", \"Started watching *slug*\"), escalations first; rows sharing an alert collapse to the newest move with the others as an \"also …\" trailer — a close always keeps the visible slot (it carries Undo), otherwise an escalation beats routed / nudged / drafted; a merge whose survivor is listed becomes \"N duplicates folded in\" on the survivor. Every row links its `evidence_ref` (or \"evidence\") to `/audit?event_type=…&q=…` (the audit page pre-fills those filters from the query string), a still-open row jumps to its card (`#alert-<id>`), drafted rows link `/artifacts`, watch rows `/watchlist`. Undo is offered only while the close still stands (`status` not `open`); a reverted close shows \"Reopened\". Dismissing a watch-sourced alert lowers that watch's `trust_score` (which discounts ranking and is shown to the review as evidence); the ack body may carry `mute_topic`. Acknowledging or resolving an alert — including the review closing it itself — marks the review's DMs about it `acted` in the Attunement outcome ledger, for the person it is routed to and the principal only; dismissing it, finding it stale or letting it expire voids them (counted neither way). Review DMs are tagged `alert_review` with `alert:<id>`.\n\n## Multi-client practice section\n\nIn multi-client practice mode (2+ client slots — see the Client Companies section), the response gains an additive `practice_clients` list: rollup cards for the **parked** clients (overdue follow-ups, awaiting replies, unread alerts, onboarding due soon, renewal countdowns), each stamped with the save point its data reflects. Single-company installs always receive an empty list and the UI renders nothing.",+ "markdown": "`openexecutive.api.routes.today` serves the morning brief — a one-screen, read-only view of what is happening across the org. It is the default landing surface (the Next.js root renders `<Briefing>`). Every signed-in page shares one sidebar (`AppSidebar`). Its Recent list is capped at the 7 newest web chats. The full history, including Slack, Telegram and Discord conversations (recognised by their session-id prefix), lives on `/chats`. A chat opens from any page through `/?session=<id>`.\n\n`GET /today` returns `TodayResponse` assembled by `_build_today()`, which is synchronous and caller-agnostic:\n\n- **`departments`** — per-department goal health, rolling up each department's goal counts (`total`, `at_risk`, `off_track`) plus its awaiting-workflow count, and `attention_goals`: the actual off-track/at-risk goals (worst first, capped at 3) with `key_result`, `current`, `target`, and `status`, so the briefing's Department card shows *which* goal is off and how far without a click. Empty for healthy/inactive departments.\n- **Private cards.** An alert tagged `private:principal` (`alerts.models.PRIVATE_ALERT_TAG` — raised on a turn about mail from one of the principal's contacts or mail they forwarded, or a meeting proposal with a contact) is in `proposals` only when the caller is the principal. The chat's alert digest (`briefing.context.render_and_trust`) shows it, and the roster requests, only on the principal's own verified turn, never in a web chat they shared with others, where everyone reads the reply. `_build_today` leaves it out by default, so the end-of-day digest, the reflection and Discord's `/today` never see it, and the morning brief reads it only on a run for the principal (the scheduler's, or the principal's own verified chat turn in a conversation only they can read — see Workflows). The narrative is written from one only in the principal's own `principal` scope, which nobody else is served; the shared `company` scope an unresolved caller gets, and a teammate's scope, never are. The activity rail skips it, and the chat digest includes it only on the principal's own verified turn.\n- **Raised by a team member.** An alert a team member raised from chat (`AlertEvent.raised_by`, source `team_member`) has its body led by \"Raised by <name>.\" and never goes out on `company_broadcast`: the pipeline drops that channel after `resolve_channels`, so it reaches a person or a department room only. One team member's alert never coalesces into another's (the dedup key is prefixed with who raised it). A team member's saved workflow raises alerts as its creator (`action_step` binds `dynamic_store.get_owner` around `oe__create_alert`). Alerts from email, watches and other sources are unchanged.\n- **Who clears a card.** `POST /alerts/{id}/ack` with `ack` or `dismissed` answers 403 to a team member unless the alert is routed to them (`read` is open to anyone who can see it); only the principal's dismiss applies `mute_topic`, since a mute silences the topic for everyone. `POST /alerts/bulk-ack` from a team member clears only the listed ids routed to them and refuses an `older_than_days` sweep. The principal, or anyone before a principal is set up, clears anything. `ack_alert` in chat follows the same rule.\n- **Roster-request cards.** When someone not on the People list writes in (see Org and Integrations), `people.roster_requests.surface_card` raises an alert of source `roster_request` (medium, tagged `roster_request:<id>` and `private:principal`, routed to the principal), so it follows every private-card rule above. `GET /today` attaches `roster_request` to that proposal (`_roster_request_card`: channel, address or account id, the sender's sanitised and unverified name, profile email, company-domain flag, suggested kind and person, message count, whether they were acknowledged, first seen, and the held messages' first lines) while the request is still pending. The Briefing renders it as its own card (`RosterRequestCard`: add as a new person with a name and an explicit team/contact choice — pre-filled as team on a company domain — or \"someone already on the list\", with a replace-account option for a chat id, or Ignore), which calls `/people/requests/{id}` directly and never hands off to chat, so what a stranger wrote never seeds a turn. The card is kept out of everything that could close it without answering it or put the stranger's words in front of a model: the narrative (`_action_proposals` drops it), the chat's open-alert digest (`<briefing>` — the principal's verified turn gets a separate `<roster_requests>` block instead; see Agents), `ack_alert`, a single ack (`POST /alerts/{id}/ack` is a 409), the \"Dismiss N older than 7 days\" count and the server's bulk ack, reopen, the TTL sweep and the alert review (`roster_request` is in `lifecycle.TTL_EXEMPT_SOURCES`). It ends when the request does: answered (`ack`, or `dismissed` on a decline) or expired after `ROSTER_REQUEST_TTL_DAYS`.\n- **`people`** — an attention-ranked roster of the **team** (the principal's contacts are never listed, and get no insight note). Each person carries `awaiting_action` count, soonest SLA, a `status` (`on_leave` / `needs_reply` / `awaiting` / `clear`), reachability, `overdue`, a server `priority` sort key, and a cached one-line `insight`. Sorted by `(-priority, full_name)`. Stale insight notes are regenerated in the background only when the roster has more than one person: the UI shows the People sidebar only for more than one, so a one-person install (solo, or a team before anyone else is added) does not pay a daily model and peer-memory call for a note nobody sees. Cached notes are still served.\n- **`proposals`** — the *live* unread alerts (workflow approvals, triage-classified inbound, Executive signals, flagged artifacts, and gated calendar bookings; an artifact is listed only to its owner (`alerts.models.visible_alert`; every other build of the board — the briefs, the reflection, the review, the chat digest on anyone else's turn, the activity rail — leaves drafted artifacts out) and carries `artifact_format` / `artifact_url` and a `body` already rendered to Markdown for its format, so the card badges it as a web page, Word doc, spreadsheet or link and offers *Open artifact*): unread, inside their category TTL, not snoozed — see *Alert lifecycle* below. Each carries `score`, `category` (`action` vs `monitoring`), `surfaced_reason` from `openexecutive.briefing.ranking`, the lifecycle fields (`occurrence_count`, `last_seen_at`, `last_reviewed_at`, `review_verdict`, `review_note`, `recommended_move`, `why_now`, `due_at`, `superseded_count`, `suggested_workflow`), and `decision_instance_id` (set only when the proposal is backed by a decision-ledger row — a calendar booking awaiting approval). `failed_run_id` is set only on a `workflow_failed` card (a scheduled run that ended in error, see Scheduler): its main button is **Run again** (`POST /workflows/runs/{id}/rerun`, which also closes the card) and its ⋯ opens the run; it has no Approve. The response also carries `held_back` for the principal alone: the lines grounding left out of the morning brief or end-of-day digest in the last day, which Home lists under **Left out of your brief** (the brief's note names it; Hide is remembered in that browser). The UI splits them into 'mine' vs 'across the team' using `caller_person_id`. Approve is carried out on the server for every card. For decision-backed proposals the card's Approve/Reject call the `/decisions` endpoints (which book or cancel the event server-side and clear the alert), so meeting bookings are reviewed in the briefing itself rather than on a separate page. Every other proposal is approved at `POST /alerts/{id}/approve` (`alerts.approvals`): it records who approved the card and when (an `alert_approvals` row plus `alert_approved`, then `alert_approval_done` / `alert_approval_failed`, audit rows), claims the card in one transaction so a double click or a second approver gets a 409 and the work runs once, then does the work. A card the scheduler filed for a department-gated action is bound to it server-side (`alert_held_actions`, written only as the card is filed, never read from the card's tags or text, which a model reading inbound mail can write), and approving it queues that exact action again with no department, the approval being the consent the gate waited for. Any other proposal runs one Executive turn as the approver in a new chat on the server (`chat.start_background_turn`, the machinery behind `POST /chat/background`), with the edited text verbatim for Edit & approve; it keeps going if the page closes. Only the card's routed person or the principal may approve a routed card, and only the principal an unrouted one (403 otherwise); the card's text reaches the turn as quoted data, not instructions. A row at the top of Needs you follows the approval (`GET /alerts/approvals/{id}`): working on it with a link to the chat, then done, or didn't work with Try again; a card whose last approval failed can be approved again, and one still running at a restart is marked failed on boot. The page no longer acks the card and seeds a chat turn with the proposal, which left no record of the approval and did nothing if the tab closed first.\n- **`narrative`** — a per-viewer Executive-voice header (\"What's going on\") synthesized by `synthesize_briefing_narrative`, cached per scope in `briefing_narrative`: the resolved principal gets the whole-company `principal` scope (which may carry what is private to them), a caller who resolves to no roster row the shared `company` scope (written from what everyone may see), and each teammate a role-scoped `person:<id>` one. `narrative_generated_at` says when the served text was written and `narrative_stale` whether a fresher one is being written now. Home shows it as **Right now**, a card above Needs you, because the text is rewritten through the day: `briefing.right_now.split_narrative` splits the served text into `narrative_lead` (the bold opener), `narrative_points` (`{text, since}`) and `narrative_move`. `since` is when that point first appeared today, kept per scope and local day in `briefing_point_seen` (keyed by the point's bold subject, so a reworded point keeps its time; recorded when a header is written, earlier days pruned then). `narrative_seen_at` is when this reader last looked, from `briefing_reader_seen`, set by `POST /today/seen` (same scope resolution as `GET /today`; the shared `company` scope of unrostered callers keeps no look, so one stranger's visit never resets another's); the page fixes it as the baseline for the visit, marks points after it with a green dot and *N new since …*, and only counts a look from earlier the same day. For the principal the response also carries `morning_brief` (`{at, text}`, today's delivered morning brief from `brief_state.last_delivered`) and `calendar_next` (up to 3 meetings still ahead today from the cached calendar read, never a fresh call), which the side panel shows under the points and Move today. Nothing here calls a model. In the web UI each bullet of this narrative is a click target: clicking one hands off to chat (the same `onContinue` path as the proposal cards) seeded to discuss that item. The Executive recognizes it because every chat turn now carries a `<briefing>` digest of open alerts (see Memory). That digest (`briefing.context.format_open_alerts_for_prompt`) is capped at 30 items; when the board is longer the header says so explicitly and tells the Executive to point at this page for the rest — it previously presented the capped list as the complete board, so the Executive described a slice as everything that was open (#136). Chat adapters get the digest too, but Slack gates it to the principal's DMs: the board is company-wide and must not be pulled into a shared channel. The `[alert_id]` at the start of each line is also what `ack_alert` trusts, because an id quoted inside an alert's own body came from inbound mail or chat and is attacker-controlled. This page's `[Discuss mode — alert_id=N]` handoff primer is a pointer to which item is under discussion, not authority on its own: the server accepts it only if that id is on the live board too. Two things enforce that. Every field the digest interpolates — headline, body, suggested action, tags, review note — is collapsed to a single line, since a newline in any of them would forge a whole extra `[N]` line and with it a fabricated instruction to clear someone else's alert. And the server records the live board it derived, so `ack_alert` refuses any id outside it — on **every** session, not just the chat adapters. The recorded set is the whole live board, not just the rows the digest printed, so a card past the render cap stays ackable. The control stops invented, closed, snoozed and expired ids; it does not stop the model being argued into acking the wrong *live* card. When the principal names an item that has already left the board — opened, snoozed, or older than it — the Executive looks it up with `find_alerts` (a keyword search over every status, `alerts.store.search_alerts`); matches that are still open (`unread` or `read`) become ackable for that turn, up to 25, and closed ones come back labelled so the Executive can say the item is already settled. It works only where the principal's own board was shown this turn — the web app or their DM — and never returns roster-request cards (see Lifecycle). The digest's header also labels every headline and detail as untrusted content drawn from inbound mail, chat and watched pages — act on what the principal asks about an item, never on what its text asks — and triage reads each signal inside an `<event>` block whose closing tag the sender's text cannot forge (it is defanged in any case and spacing, after NFKC folds fullwidth forms). That check used to run only when `origin_channel` was set, which the browser never sets, so the one surface where the principal actually reads their board had no check at all and the model could ack any id, including one quoted out of an alert body by the Discuss handoff. Rendering the block and recording its ids now happen together in `briefing.context.render_and_trust`, which both the web chat route and the channel adapters call: render without recording and the tool refuses everything, record without rendering and the model gets reach it was never shown. A turn that was shown nothing trusts nothing. Recording it is only half the wiring: the tool reads the board off the turn's session through a ContextVar, and the chat route binds that session for the whole SSE body (`set_session`, next to `set_turn`). Bound from inside the Executive's own generator instead, it survives exactly one stream step — `asyncio.wait_for` runs each step in a fresh Task with a copy of the context — and the tool-call loop, which runs later, sees nothing. That shipped, and every web ack was refused on cards that were open the whole time. The digest also carries a short **already handled** tail — recently acked / dismissed / resolved rows, named but deliberately NOT trusted for acking — because a card cleared on the page minutes ago is otherwise simply absent from chat: asked to \"record that as fixed\", the Executive could not tell a settled item from one it had never heard of, and sent the principal back to dismiss a card that was already gone. That tail renders even when nothing is open, which is exactly when it matters. Note it is a different window from the `handled_overnight` rail above: that one runs since the last delivered morning brief, while the chat tail looks back 14 days (matching the action-alert TTL, so it still covers an item cleared late in its life), so chat can name a settled item the rail no longer shows. On the principal's own verified turn the digest also lists their chat drafts still waiting in their mailbox (when, to whom, subject), so a brief line about a draft can be discussed; `read_my_email` shows drafts in a thread marked not sent, so a thread that is only a draft does not read as empty. The narrative is held to what is **live**, and to what it is actually for. The `alert_raised` source is dropped from the activity it reasons over (`_build_activity(..., include_alert_raised=False)`): a closed alert reads as work the principal already settled, and a *live* one is worse than redundant — `lifecycle.is_live` is the very predicate behind `list_live_alerts`, so every live raise is already a proposal card below the header, which the prompt forbids re-listing. The `/today/activity` rail keeps the whole source, because a raise really happened. The activity block is only labelled \"since last brief\" when the caller bounded it with `since` (the standalone briefs do; the header does not), since calling an unbounded history rail a delta made the header present weeks-old rows as overnight news. When the viewer's slice holds nothing that wants a decision — no action proposal, no at-risk/off-track department, nobody awaiting — the regen skips the model call entirely and writes the fixed quiet line (`Quiet right now — nothing pressing.`, or `… nothing needs you.` for a teammate). **The cache key is a hash of the rendered context itself** (`today._narrative_context` builds it once and both the hot path and the background task key off that one string, which is also handed to the model verbatim). That makes the key a function of the model's input: everything the prompt renders is covered, and nothing it omits can trigger a regeneration. Keying on hand-picked fields broke one half or the other each time — headlines alone left the rendered activity block uncovered, while the proposals' review fields are never rendered by this header yet are rewritten with fresh prose by every `alerts.review` pass, so they regenerated each viewer's narrative several times a day to re-synthesize identical input. A quiet board keys off a fixed sentinel instead, so a moving rail cannot re-key an entry whose text is constant. Together: on a fully dismissed board every other input was empty, the rail became the only context, and the model synthesized a confident header out of closed items.\n\n **Live, not just the board.** The header used to reason over the alert board, goal health and the Executive's own bookkeeping only — mail and chat handled that day, replies the gate held and the next meeting never reached it, so it read the same for days while the principal's day moved on. The whole-company scopes now open the context with the principal's world as it is happening (`briefing.live_signals.gather_live_signals`, rendered by `render_live_blocks`), under a `NOW:` line: **INBOUND** (`integration_inbound` audit rows that carry a message, one per message id, grouped by sender and subject, with an email's first line; the principal's own mail reads \"from the principal\", an email from the roster says \"the Executive replied\" only when a reply was logged in its thread after it (`unanswered_mail.record_reply`) and \"no reply went out\" while its `unanswered_mail` card is open (on the principal's own read only), and a time on another day carries its weekday and date), **STUCK** (`integration_outbound_blocked` to a recipient, the inbound \"reply blocked at outbound gate\" and Google Chat \"left unanswered\" / \"not delivered\" rows, and chat drafts Act as me saved in the principal's mailbox that are still there: `delegation_drafts` rows not yet marked sent or `gone_at`; before each scheduled header refresh, each morning brief and, at most every 2 minutes, the principal opening `/today` (`today._maybe_settle_on_view`, which runs `refresh_principal_narrative` after the response, so this holds even with the background header refresh slowed or off), `live_signals.settle_principal_drafts` looks up the principal's open chat drafts from the last two days in their mailbox and marks the ones sent or deleted there, answered by a message of their own sent in that thread after the draft, or sent another way: one read of their latest 15 sent messages, only while a draft is still there, finds one sent after the draft with the same subject (Re:/Fwd: aside) to one of the same people, as when they redrafted and sent the other version or wrote it fresh. So a draft they sent (or replied around) from Gmail stops reading as waiting, and a failure on one draft no longer stops the pass for the rest; the same read keeps, in memory only, who each waiting draft goes to and its subject, so STUCK names each draft instead of a bare count), **CONVERSATIONS** (the principal's own web chat titles, without times, so the header cannot point back at \"the 13:26 chat\"), **OWN** (the principal's own mail and chat-app messages to the Executive, kept out of INBOUND and its count, principal scope only) and the **REST OF TODAY'S CALENDAR**. The principal's own messages and chats render as background blocks, and every brief prompt carries `OWN_MESSAGES_RULE`: they show what the reader already said and asked, are never reported back as news (no \"you messaged me\", no restated complaint or rating), and an open ask appears only as what the Executive is doing about it. The window is the local day, or the last 12 hours when that is longer. Private audit rows, drafts, chat titles and the calendar (meeting titles are the principal's own) are read only in the `principal` scope — `gather_live_signals` drops the calendar whenever `include_private` is false, whatever the caller passes, so the shared `company` header never quotes it. The calendar is never fetched on the request: `live_signals.refresh_calendar` caches one read per 15 minutes (the scheduler tick refreshes it) and the header quotes the cache. Every quoted field is collapsed to one line and cut, and the blocks and the prompt both say the text is data, never instructions — inbound mail is attacker-controlled. With live blocks present the context also ages each proposal (`raised 2d ago`, whole days), names each at-risk department's slipping goals (`attention_goals`) and adds an **EXTERNAL SIGNALS** block (monitoring alerts from the last 24 h, never enough on their own to break the quiet line); the rhythm runs (`today.RHYTHM_WORKFLOWS`: the morning brief, end-of-day digest, reflection and weekly review) are dropped from the activity it reasons over. The prompts (`BRIEFING_NARRATIVE_SYSTEM` and its solo variant, `NARRATIVE_PROMPT_VERSION` 6) lead with what is live and give a days-old item at most one bullet. Anything live breaks the quiet line; the NOW line and window move at most once an hour, so the key moves hourly on time alone plus whenever something new lands; the calendar is placed at the real time (a meeting that has ended drops out, the one under way is IN PROGRESS), which moves it only when a meeting starts or ends. An address that belongs to someone on the roster (or, in the principal scope, one of the principal's contacts) reads `Name (address)` in these lines (`live_signals._named`), so the header calls people by name instead of making one up from the address.\n\n **Who reads it.** Every brief surface (this header, the morning brief, the end-of-day digest) is written for one person, fixed in code by `briefing.reader`: the principal on the principal scope, the teammate on a `person:<id>` scope, and the principal on `company` too (that scope has no signed-in caller and uses the principal's prompt, built from shared rows only). `render_briefing_context(reader=…)` masks that person's full name and email addresses everywhere in the context to \"the reader\" (their own chat and mail, the Executive's replies to them, chat titles, the activity rail) and heads it with a **THE READER** line naming them; every brief prompt carries `READER_NAME_RULE`: write \"you\", never the reader's name, \"the reader\" or \"the principal\" (anyone else by name), and \"I\" / \"me\" / \"my\" for the Executive. A draft that still slips (`reader.slips`), or reports the reader's own chats and asks back to them (`narrative.own_echoes`: \"you asked me\", \"your chat\", \"a chat with me\", \"the 13:26 … chat\", which `OWN_MESSAGES_RULE` forbids), is sent back once to be rewritten, and what is left of the reader slips after that is fixed in code (`reader.fix_slips`: the reader → you/your, \"the principal\" → the owner's name on a teammate's brief, the Executive → I/me/my).\n\n **Fresh without a reload.** The daily floor in the key and the PERIOD line are the principal's **local** date (`narrative_cache.local_today`), not UTC's, and a row written on an earlier local day is not served as today's. Regenerations are serialized per scope; a trigger that finds one running marks the scope pending and the running pass goes round once more (it built its context before that trigger's news landed), and after a failed pass (model error, the 33 s timeout: 25 s for the draft and 8 s for a rewrite, empty text) no view or tick starts another for 5 minutes and `narrative_stale` reads false, so the page drops its placeholder instead of spending a model call per view. They log `today: narrative served scope=… age_s=… stale=…` and `today: narrative regenerated scope=… ms=…`, and no longer need a page view: every `BRIEFING_NARRATIVE_REFRESH_MINUTES` (10) between `BRIEFING_NARRATIVE_REFRESH_START_HOUR` and `_END_HOUR` (06–22 local) the scheduler runs `today.refresh_principal_narrative`, which refreshes the calendar cache and rewrites the principal's header only when its key moved (see Scheduler). The Briefing re-polls `/today` at 4, 10 and 20 s while `narrative_stale` is true, re-pulls it when the tab comes back (at most once a minute) and every 5 minutes while visible, shows \"Updated 2:04 PM\" beside the heading, and shows \"Catching up on today…\" while the first header of the day is written (`lib/narrativeFreshness.ts`, tested by `npm test`).\n\n In **solo mode** (one person using Open Executive for themselves) the header speaks to the principal, whatever their role: a solo prompt over a context that lists goals at risk by *area* and has no \"people waiting on you\" block, and the quiet check ignores who is awaiting. The cache key carries the mode for solo only, so solo and team never share a cached narrative while every team key stays exactly what it was — no team cache is invalidated. The response shape does not change. For the principal's own view the solo context also carries a **DUE THIS WEEK** block — the principal's open loops that are overdue or due within 7 days (`today._with_due_soon` → `open_loops.principal_due_soon`, labelled OVERDUE / due today / due <weekday>) — which counts as needing attention in the quiet check and moves the cache key when an item is added, closed or falls due; a teammate's scoped view and team mode never get it. The header never gets the morning brief's *top three today* block — that is the DM brief's (see Workflows); the page shows the same top three in a card of its own (see *Solo focus cards* below). It does get the rest of today's calendar through the live blocks above, from the cached read.\n- **`in_flight`** / **`awaiting`** — upcoming Executive commitments and people we are waiting on.\n- **`handled_overnight`** — the autonomous moves the Executive *completed* since the last delivered morning brief: the alert review's (routed, nudged, escalated, drafted, merged, closed) plus the research watch policy's (`watching` — a watch added on its own because it was grounded in company data; `stopped_watching` — a research watch auto-disabled as noisy or dead; no alert id, re-enable from `/watchlist`). A `changed` verdict (the review rewrote an open alert's headline / body / severity) is deliberately **not** here: the alert is still open in \"Needs you\" and its card carries the note, so the brief reports it under \"what changed\" (a REWRITTEN block) rather than as done. Each row is structured, not just a sentence: `kind`, the audit `summary` (nudge bookkeeping marker stripped), `at`, `alert_id`, `event_type` (for a pre-filtered `/audit` deep link), `headline` (the alert's headline at move time; a watch's slug), `target` (person name for routed / nudged, survivor headline for merged, new severity for escalated, draft title, workflow name), `detail` (the cited evidence or the watch policy's reason), `outcome` (`resolved` | `dismissed` for a close, `proposed` for a route that went through the authority gate), `evidence_ref` (S1 / R2 / A3), `superseded_by_alert_id`, and `status` — the alert's lifecycle state **now** (`open` = live in the queue per `lifecycle.is_live` | `resolved` | `dismissed` | `expired` | `merged` | `acked` | `inactive` for snoozed / past-TTL rows), looked up per row so a close the principal already undid renders as reopened instead of offering a second Undo, and a \"still open\" jump link only appears when there is a card to land on. Audit rows private to the principal (say, one naming their contact) are in this list only on the principal's own `/today`: `brief_state.handled_since` leaves them out unless asked, and the written briefs never ask, since a brief can be read by others. The Pulse heatmap's per-day counts (`GET /today/activity/daily`) likewise leave out a private decision or private alert, as the activity rail does. The morning brief also carries a one-line count of research watch suggestions waiting on `/watchlist`.\n\n**From your chats.** `briefing.brief_requests` holds what the principal asked of their brief in conversation: `leave_out` lines from `leave_out_of_brief` (\"take the Halcyon renewal out of my brief\", kept 14 days) and `raise` lines the conversation review could not fix itself (`raise_in_brief`, kept 2 days), at most 20 live. A line is at most 12 words (leave out) or 30 (raise), with no link, handle, markup, identifier or talk of instructions, and only lines written under the principal's own id render. `render_briefing_context(brief_requests=True)` adds the raise lines before the quiet-day check, so they are raised even on a quiet day, and the leave-out list as the very last block; both sit inside the rendered string the /today header hashes. A teammate's brief or header passes `False`: they are the principal's own words.\n\n**Standing facts.** `render_briefing_context` appends the standing facts (`memory.facts`: corrections kept from chat, a teammate's marked `(per <name>)`) as its last block, after the quiet-day check, so a fact never makes a quiet day look busy. Every brief prompt (this header, the teammate header, the morning brief and the end-of-day digest) carries `narrative.STANDING_FACTS_RULE`: use the facts quietly, never mention one or that it was saved, and leave an item a fact settles out without saying it was dropped. A fact settles only what it plainly says. Without it, a fact saved in chat came back as the header's top point, stretched to an item it never named. The morning brief also carries **TEAMMATE CORRECTIONS SINCE LAST BRIEF** (`facts.render_teammate_changes(since)`: each teammate fact recorded in the window that is in use now, plus — only when the brief is the principal's own private one (`_private_ok`), which then keeps the run out of the shared history — those waiting for their approval, since other teammates may run the brief and never see a proposal that is not theirs) before the quiet check — it is news, the principal's only FYI of it — and in the brief's fingerprint (`build_brief_fingerprint(teammate_changes=)`), so a correction alone un-suppresses an otherwise unchanged brief. Every other caller passes none, so its context is unchanged. The /today header hashes that rendered string as its cache key, so a new or retired fact marks the header stale and it is rewritten with the correction. The morning brief (standalone) and the teammate-scoped header get the same block. On the scheduler's delivery to the owner alone, with their Always in the loop switch on, `render_briefing_context(owner_notes=)` also carries FROM YOUR NOTES — DUE SOON (their own notes of what they promised or asked, overdue to a week ahead; `memory.history_brief`), which counts against a quiet day, enters the fingerprint and marks the run private; both standalone prompts turn it into a **From your notes** section. The /today header never gets it. **The first week.** For seven days from the principal's People row (`briefing.first_week`), `render_briefing_context(getting_started=)` carries a GETTING STARTED block right after the live blocks: the install's goal rows (department, key result, target, period) or, while there are none (setup saves no goal rows, so this is a fresh install's usual case), this year's priorities and north star from the saved profile (`strategic_priorities`, up to five, keys `priority:<text>`), departments with no `head_person_id`, and, on the scheduler's delivery to the principal alone with Act as me and Draft replies to my inbox both on and the mailbox connected (the inbox watcher's consent), up to five people who wrote to their own mailbox in the last 48 hours as sender and subject only (`inbox_message_ids` + headers of `get_message`, bulk and automated mail skipped; the same \"where, never what\" rule as `delegation.mail_reads`) and, with Act as me and Read my calendar on, up to eight of today's events on their own calendar as time and title (declined ones left out). It counts against a quiet day, enters the fingerprint (`getting_started=` keys, no dates; a meeting's key is its event id) and, with the inbox or calendar part, marks the run private. Both standalone prompts open with a **Getting started** section and take the Top call from it (`GETTING_STARTED_RULE`). The /today header does not get the block: in the first week it is the same header as any other day. Home's top slot is instead the **first-week card**, built in code with no model call (`first_week.first_week_card`): `needs_goal` while no goal row exists (fixed ask \"Give me one goal with a date, and I'll track it every day.\" and a **Set a goal** button to `/goals?add=1`, which opens the add form), up to two findings from the latest finished team `executive_research` run (the run history keeps only the artifact, so `executive_research.parse_artifact_findings` reads back its \"Findings reviewed\" lines; most severe and most certain first, headline plus the summary's first sentence) with a line linking `/watchlist`, and `brief_tomorrow` on the setup day until the first morning brief is delivered. No goal still to set and no findings means no card. `GET /today` sets `first_week_card` and `first_week` (whether there is a card) for the principal only; while there is one the Briefing hides the \"Quiet day\" banner and an all-zero summary line reads \"Your first week. Start below.\" The last setup screen (`OnboardDone`) offers one first question built from the saved priorities (`firstQuestion`) and hands it to Home through session storage (`oe.onboard.firstQuestion`, never the URL), which asks it once. A teammate's scoped header never gets it. The alert review's `render_batch` puts the same block ahead of the alerts (read once per pass), so a note, rewrite or routed DM never repeats a figure the principal already corrected.\n\n**When a brief isn't sent.** Above the Briefing, the owner sees a one-line notice when their latest morning brief, end-of-day digest or (in solo mode) weekly review wasn't sent — \"Your morning brief wasn't sent: nothing is set up to send it to you\" — with the day, what fixes it, a link to read the brief on the Artifacts page (left out when the brief couldn't be written at all) and one to Setup status. It comes from `GET /today/brief-delivery` (the scheduler records each run's outcome), shows nothing while briefs go out or while the scheduler is off, and clears once the cause is fixed. When the Executive's mail connection wasn't running (the MCP gateway failed to start and is retrying), the notice says that instead of blaming the owner's setup; a send that failed on every channel names what each channel answered, from the recorded `detail`, with addresses left out. Teammates never see it.\n\n**Replies waiting.** With Act as me's **Draft replies to my inbox** on, the top of the Briefing's left column lists the replies the Executive drafted in the owner's own Gmail for mail that needs them (`RepliesWaiting`, from `GET /delegation/replies` — see Act as Me). They belong to the owner alone: the route answers only the person who can have Act as me, the decisions behind the cards (`delegation_reply`) are principal-only and carry `private: true`, so `/today/activity` and the heatmap leave them out, and none is ever an alert, so nothing of them reaches `GET /today`, the header or the briefs. Each card shows who wrote and who they are to the owner, whether their address was verified, the subject, what they wrote (as plain text), the draft, **Decide before sending** (its open questions) and its warnings, with **Send**, **Edit in Gmail** (the thread in their Gmail) and **Dismiss** (which deletes the draft unless they edited it). **Send** asks first, naming who the reply goes to, then sends the draft exactly as it is in Gmail (`POST /decisions/{id}/approve`); when its recipients changed in Gmail or a newer message arrived, the backend's 409 `confirm` becomes a second question naming them. The card hides itself when nothing is waiting.\n\n**Solo focus cards.** `GET /today/top-three` and `GET /today/weekly-review` feed two solo-only cards, so a principal who only uses the web app — no chat app, no Google Workspace — sees today's top three and the weekly review instead of finding them only in the Workflows run history. Both answer only in solo mode (`effective_workspace_mode`) and only to the principal, by the stricter rule for starting a principal-only run (`workflows._caller_is_the_principal`: the caller's own email on a principal entry that is not archived, or no `x-caller-email` at all — never \"nobody is principal yet\"); a teammate, any other signed-in caller and team mode get null. `top-three` hands `open_loops.principal_due_soon()` to `briefing.top_three.build_top_three` — the morning brief's own inputs and code, so the items, their order and their free slots are the brief's — and returns `{items: [{key, kind, text, why, slot}]}`: `slot` is the free block (\"10:00–11:00\", the user's zone), \"\" when none is left, or null when no calendar was read (none connected, a failure or the 4 s timeout, a weekend); `items` is empty when there is nothing to pick. It is a route of its own, never part of `GET /today`, so the Briefing never waits on the calendar. `weekly-review` returns the latest `weekly_review` run with status `done` (`persistence.list_runs(..., status=\"done\", limit=1)`, newest `updated_at` first; failed and running runs never count) as `{run_id, completed_at, period, top_three, excerpt}`: `weekly_review.summarize_review` reads the artifact's title line and its last *Next week's top 3* section back as plain text, and `excerpt` stands in when that list is empty (the section's own note, else the review's first lines). Null when no review has completed or the run store cannot be read.\n\nThe route resolves the caller from `x-caller-email`, serves the viewer's cached narrative and, when its key moved, rewrites it in a `BackgroundTask` so the request never blocks on an LLM call (the page re-polls while `narrative_stale` is true). `GET /today/activity` returns the recent self-initiated action rail — merged from fired scheduled actions (DMs, follow-ups, nudges, cadences), logged decisions, saved advice, completed workflow runs (briefings/check-ins/research), kicked-off initiatives, resolved gated decisions, and raised alerts, so it reflects all of the Executive's activity rather than just dispatched messages. A brief or digest delivered to its reader (`scheduler.runner._deliver_to_principal`) records its send as kind `brief_delivery` (`schedule_tools.recorded_as`): the outbound guard still counts it, but the rail and the heatmap leave it out, because every later brief reads the rail and used to repeat its own last top call as work done. A completed run is named in plain words, never by its log title (`workflows/run_outcome.py`: \"Researched your market\", \"Checked in with Sales\", or the name it was started with, less any date or how-it-started note), and carries `detail`, one line on what came of it read from its stored artifact (research: updates looked at, messages sent, alerts raised, things now watched; a check-in: actions proposed; the weekly review: next week's top item; other runs: the first sentence; none for briefs and the reflection), and `artifact_id` (`run:<id>`) when it kept a write-up (never for the reflection, which reads the principal's live alerts), so Pulse's Done for you and All activity link **Read it** to `/artifacts/run:<id>`. The Pulse page (`/memories`) polls it (limit 100) every ~20s so new events stream into the 'Recent activity' card, which scrolls internally at a fixed height instead of growing the page. The `morning_brief` workflow calls `_build_today()` directly to build the standalone DM (via a different, enumerated prompt; solo mode has its own, with goals at risk by area and no waiting-on section). `GET /morning-brief` is a deprecated alias.\n\n**Solo mode in the UI.** The response is the same in both modes; the briefing reads the workspace mode from the app-wide `WorkspaceProvider` (which reads team while loading or on error, so a team install never flashes solo) and, in solo, drops the team surfaces: the Departments card, the People card, the \"Across the team\" lane (every action proposal is the one user's, so all of them land in \"Needs you\"), the people-awaiting, people-overdue and departments-at-risk status pills, and the quiet-day \"Set up a check-in\" link. A \"N goals at risk\" pill (at-risk plus off-track goals, from `departments`) links to `/goals` instead, so the strip never reads \"All clear\" over a goal that is slipping. In the Departments card's place, **Your projects** lists the initiatives with status `active` (`GET /memories/initiatives`): **Done** marks one `completed` through `PATCH /memories/initiatives/{id}` (only `completed` takes an initiative out of the Executive's active context), and **Drop** deletes it through `DELETE /memories/initiatives/{id}` after a confirm. Under **Needs you**, a **Due soon** card lists the principal's open loops that are overdue or due within 7 days — their dated commitments and what others asked of them — read from `GET /people/{id}/open-loops` for the principal (the oldest principal in `people`, the backend's rule), labelled by `lib/dueSoon.ts` (tested by `npm test`: \"Overdue since Sep 23\" / \"Due today\" / \"Due Mon, Sep 28\", with a count of anything due later); **Done** closes one through `POST /open-loops/{id}/close`, which also stops the nudge engine chasing it. Above it, **Top three today** numbers the morning brief's three (`GET /today/top-three`) with each one's reason and, when a calendar was read, its free slot (or \"No free time left today\"); at the top of the right-hand column, **This week's review** (`GET /today/weekly-review`) shows the period, when it ran, next week's top three (or the excerpt) and a *Read the review* link to its run page (`/jobs/runs/{id}`). Each card fetches on its own once the Briefing has loaded, so a slow calendar never holds the page up, and renders nothing when the API returns null or an empty list. A commitment in the top three reads as the owner's own (\"Send the proposal\") through `lib/dueSoon.ts`'s `loopText`, as in Due soon; the cards' wording lives in `lib/rhythmCards.ts` (tested by `npm test`). The Pulse page hides its \"Department check-ins\" and \"Awaiting people\" blocks in solo, and its header shows active projects in place of the department check-in count. Team rendering is unchanged.\n\n**Your month (`GET /today/value`).** The owner's own tally of what the Executive did for them, `briefing.value_summary.summarize(period, offset)`: the calendar `month` or `week` (Monday first) in the user's zone, `offset` periods back (0–24), each line beside the period before. Every number is a `COUNT(*)` of rows that prove it happened, never a model's: messages sent for the owner (the DM handlers' own `kind=outbound` sent rows to anyone but the owner, plus Gmail / Outlook send-tool calls that didn't come back with an error, so mail sent from a chat turn counts), replies drafted and sent from the owner's inbox (their Act as me rows), meetings booked (calendar create calls), briefs delivered (the scheduler's `delivered` row), reports (finished team workflow runs, minus the daily rhythm runs and any run a teammate started for themselves, which stays theirs alone; the latest ten listed with links), follow-ups and nudges sent, tasks tracked and closed as done, proposals decided, alerts flagged and requests answered (`chat_turn` out rows). No \"hours saved\" and no cost line: nothing recorded supports the first, and cost next to what the owner got reads as a bill; it has `GET /audit/usage`. The owner's alone (403 for anyone else): it counts rows private to the owner, never a row private to another member. Pulse shows it as the top line of the overview's **Done for you** panel (\"October 2026: 42 messages sent, 6 reports, 3 meetings booked\") and a focused screen, `/memories?tab=value`, with a month / week switch and previous / next. On the first weekday of each month, in daytime (09:00–18:00 local), a scheduler tick hook sends the owner last month's lines and a link (`value_summary.maybe_send_monthly`, claimed once per month under `briefing_narrative` scope `value_summary:YYYY-MM`), in solo and team mode alike; nothing is sent for an empty month. Off with `VALUE_SUMMARY_MONTHLY_ENABLED=false`.\n\n## Alert lifecycle & the Executive review\n\nAlerts used to be write-once: raised, then never looked at again, so the \"Needs you\" queue grew without bound and the briefs re-listed it daily. Four things now keep it live and true:\n\n- **Time-to-live** (`openexecutive.alerts.lifecycle`). Action items expire after `ALERT_TTL_DAYS_ACTION` (14 d), unrouted low/medium monitoring signals after `ALERT_TTL_DAYS_MONITORING` (3 d). Every surface reads `list_live_alerts` (the same predicate the scheduler's 15-minute sweep persists as status `expired`), so `/today` is right even before the sweep runs. Artifacts and decision-backed alerts are exempt. `POST /alerts/{id}/reopen` is the Undo. **Snooze** (a card's ⋯: later today, tomorrow 9:00, Monday 9:00, in the viewer's clock; `POST /alerts/{id}/snooze`) hides a card until `snoozed_until`, with an Undo; the TTL anchor is the latest of `created_at`, `last_seen_at` and `snoozed_until`, so a snoozed card comes back rather than expiring unseen.\n- **Coalescing** (`alerts.pipeline` + `store.coalesce_alert`). A repeat of an open alert with the same `(source, dedup_key)` updates that row — `occurrence_count`, `last_seen_at`, severity max — instead of stacking a second card, and only re-pings when severity rose to high/urgent. Monitoring alerts carry a stable `watch:<slug>` key, so one watch means one card.\n- **Collection tags** (`alerts.pipeline`). A triaged alert never carries a `collection:<name>` tag: the pipeline strips them before inserting. Only an installed extension's own code files a document into its collection (`orchestrator.extensions`), so injected text can't make a card that the extension would treat as its own.\n- **The review** (`openexecutive.alerts.review`, heartbeat `alert_review_scan`, every 6 h and right before the morning brief). For each open alert the Executive sees what changed since it was raised — newer signals from the same watch, related alerts, activity since, the roster with SLAs (team members only — an alert routed to a contact never puts them in the slice, so they are never routed to, nudged or chased; a private card is never reviewed at all, nor used as evidence for another), department authority — and returns a verdict (relevant / changed / resolved / stale) plus a recommended move. Deterministic policy then acts: **route** (assign + DM the owner; `propose_via_alert` for propose-only departments), **nudge**, **escalate** (severity + `due_at` + DM the principal only), **draft** (`draft_artifact`), **suggest a workflow** (a link, never a run), **merge** (`superseded_by_alert_id`), or **resolve** — only on high confidence citing a server-minted evidence ref (a newer signal, a related alert, an activity item shown for that alert); free text never closes a card, and anything weaker is annotated `likely_stale`, demoted 30 ranking points, and left for one click. Everything that came from outside is rendered as inert data inside the review prompt, so an injected email body cannot steer the batch. Board / comp / legal matters only ever go to a scope-holder or the principal and keep their text. Route and escalate are idempotent across passes, every DM carries an \"[Alert review] Re: …\" header, outbound moves are capped per pass, passes are single-flight, `ALERT_REVIEW_ENABLED=false` stops every caller, every move is audited with its evidence and prior state, and a distinct `resolved` status keeps Executive closes separate from `ack` (user approved). A review DM is proactive outreach, so the recipient's notification settings apply: one held for their quiet hours or brief counts as a route made but not as a nudge toward the cap (and no second nudge is held while one waits), and one about an alert whose severity is (or becomes) `urgent` is marked urgent (`notifications.urgent_send`) and gets through when they let urgent things through.\n- **Grounded text** (`openexecutive.briefing.grounding`). Nobody reads an alert's text before it is dispatched, so what the model wrote onto it must be supported by what it read. After triage (`alerts.pipeline._ground_decision`, before coalescing or inserting), a headline naming a person or figure the event does not hold — sources are the event's subject, sender, title and body, the initiatives triage was shown and the company profile — is replaced by the event's own subject, such body sentences are dropped (all of them → the event body cut to 280 chars); both fallbacks are raw event text, so they are made inert first — links masked, Markdown and Slack `<…>` syntax and @-mentions stripped — because a broadcast posts them as written, and such a suggested action is dropped. A review `changed` rewrite is checked against the alert's own text and the evidence it was reviewed with (signals, related alerts, activity, the roster slice), plus the standing facts the batch was shown, so a rewrite that corrects a card to one of the principal's corrections is grounded; an ungrounded rewrite keeps the old text, still applies a severity change, and audits `text_ungrounded`. A name counts as grounded only when one source line holds all of it; a figure only when a source number matches it within the precision it is written with. Each finding writes a `grounding` audit row; `GROUNDING_CHECKS=report` records without changing anything.\n\nOn the page, cards read as decisions: the one-line \"what changed since you last looked\" (`review_note`) leads, the recommended move is the primary control (Nudge <owner> → chat; Run <workflow> → `/jobs/<name>`), with chips for age, seen ×N, why-now / due, folded-in and draft-ready, a \"Reviewed <ago>\" footer, and an amber Likely-stale treatment with one-click Dismiss. \"Needs you\" shows *Start here* + 8 cards + \"Show N more\", a \"Dismiss N older than 7 days\" footer (explicit ids to `POST /alerts/bulk-ack` — never a server-side age sweep, which would hit teammates' routed items), and \"Re-check relevance\" (`POST /alerts/review`). The handled rail (anchor of the \"Executive handled N overnight\" pill) is deliberately one sentence by default: a first-person heading built from counts only — \"Since your last brief: N off your plate (closes still standing, and merges whose survivor is not itself listed; a merge into a listed survivor counts on that survivor's row), N in others' hands (routed / nudged), N waiting on you (escalated)\", plus \"N drafts ready\", \"N workflows suggested\", \"N watch changes\", \"N other moves\" (a kind the UI does not know) and \"N back on your plate\" (a close that is open again) when present — with the rows behind a \"details\" disclosure, and nothing rendered at all when the grouped rows are empty. The pure logic (grouping, headline, links) lives in `packages/ui/src/lib/handled.ts` and is covered by `npm test`. Expanded, it shows one first-person row per alert (\"Resolved *X* — evidence\", \"Dismissed *X* as stale — evidence\", \"Handed *X* to Dana Kim\" / \"Proposed *X* to Dana Kim (awaiting their approval)\", \"Chased Dana Kim on *X*\", \"Raised *X* to high\", \"Drafted *T* from *X*\", \"Folded *X* into *Y*\", \"Started watching *slug*\"), escalations first; rows sharing an alert collapse to the newest move with the others as an \"also …\" trailer — a close always keeps the visible slot (it carries Undo), otherwise an escalation beats routed / nudged / drafted; a merge whose survivor is listed becomes \"N duplicates folded in\" on the survivor. Every row links its `evidence_ref` (or \"evidence\") to `/audit?event_type=…&q=…` (the audit page pre-fills those filters from the query string), a still-open row jumps to its card (`#alert-<id>`), drafted rows link `/artifacts`, watch rows `/watchlist`. Undo is offered only while the close still stands (`status` not `open`); a reverted close shows \"Reopened\". Dismissing a watch-sourced alert lowers that watch's `trust_score` (which discounts ranking and is shown to the review as evidence); the ack body may carry `mute_topic`. Acknowledging or resolving an alert — including the review closing it itself — marks the review's DMs about it `acted` in the Attunement outcome ledger, for the person it is routed to and the principal only; dismissing it, finding it stale or letting it expire voids them (counted neither way). Review DMs are tagged `alert_review` with `alert:<id>`.\n\n## Multi-client practice section\n\nIn multi-client practice mode (2+ client slots — see the Client Companies section), the response gains an additive `practice_clients` list: rollup cards for the **parked** clients (overdue follow-ups, awaiting replies, unread alerts, onboarding due soon, renewal countdowns), each stamped with the save point its data reflects. Single-company installs always receive an empty list and the UI renders nothing.","mermaid": "flowchart TD\n REQ[\"GET /today\"]\n BUILD[\"_build_today()\"]\n DEPTS[\"departments<br/>(per-dept goal health)\"]\n ROSTER[\"people<br/>(attention-ranked roster)\"]\n PROPS[\"proposals<br/>(unread alerts, routed)\"]\n INFLIGHT[\"in_flight<br/>(pending follow-ups / nudges)\"]\n AWAIT[\"awaiting<br/>(replies we await)\"]\n NARR[\"viewer-scoped narrative (BackgroundTask)\"]\n MB[\"morning_brief workflow\"]\n TOP3[\"GET /today/top-three<br/>(solo, principal only)\"]\n PICK[\"build_top_three()<br/>(calendar read, 4 s cap)\"]\n WREV[\"GET /today/weekly-review<br/>(solo, principal only)\"]\n RUNS[\"workflow_runs<br/>(latest done weekly_review)\"]\n LIVE[\"live_signals<br/>(inbound / held replies / chats,<br/>cached calendar)\"]\n TICK[\"scheduler tick<br/>(every 10 min, 06–22 local)\"]\n CACHE[\"briefing_narrative<br/>(principal / company / person:id)\"]\n REQ --> BUILD\n BUILD --> DEPTS\n BUILD --> ROSTER\n BUILD --> PROPS\n BUILD --> INFLIGHT\n BUILD --> AWAIT\n REQ -->|\"resolve caller, attach\"| NARR\n LIVE --> NARR\n TICK -->|\"refresh_principal_narrative\"| NARR\n NARR --> CACHE\n MB -->|\"since last brief\"| LIVE\n MB -->|\"calls directly for standalone DM\"| BUILD\n MB -->|\"same pick for the DM\"| PICK\n TOP3 --> PICK\n WREV --> RUNS\n class REQ entry\n class BUILD compute\n class DEPTS storage\n class ROSTER storage\n class PROPS storage\n class INFLIGHT storage\n class AWAIT storage\n class NARR compute\n class MB compute\n class TOP3 entry\n class PICK compute\n class WREV entry\n class RUNS storage\n class LIVE compute\n class TICK entry\n class CACHE storage",- "generated_at": "2026-10-19T17:58:25.845404+00:00"+ "generated_at": "2026-10-20T18:00:00Z"}diff --git a/packages/core/openexecutive/briefing/live_signals.py b/packages/core/openexecutive/briefing/live_signals.pyindex af9955a9..7a64fee0 100644--- a/packages/core/openexecutive/briefing/live_signals.py+++ b/packages/core/openexecutive/briefing/live_signals.py@@ -487,7 +487,8 @@ def _conversations(title = _one_line(row["title"], 100)if title.lower() in _UNTITLED:continue- lines.append(f"[{_local_hhmm(row['updated_at'], tz, now)}] {title}")+ # No time: the header pointed back at "the 13:26 chat" by it.+ lines.append(title)keys.append(title.lower())if len(lines) >= _CONVERSATIONS_MAX:breakdiff --git a/packages/core/openexecutive/briefing/narrative.py b/packages/core/openexecutive/briefing/narrative.pyindex 2d05095a..7ed27ede 100644--- a/packages/core/openexecutive/briefing/narrative.py+++ b/packages/core/openexecutive/briefing/narrative.py@@ -17,6 +17,7 @@ from __future__ import annotationsimport asyncioimport logging+import refrom datetime import UTC, date, datetimefrom typing import TYPE_CHECKING, Any@@ -83,7 +84,9 @@ OWN_MESSAGES_RULE = ("they show what the reader already knows, decided and asked for. Never ""report them back: never write that the reader messaged, emailed or ""chatted with you, how much, or that they asked, complained, pushed "- "back, thanked you or rated an answer, and never open with one. A "+ "back, thanked you or rated an answer, and never open with one. Never "+ "point to one of their chats by its title or its time (e.g. 'the 13:26 "+ "chat'), and never write 'you asked me'. A ""figure or decision in them may be stated as a fact of the day. A ""request of theirs earns a line only while it is still open, written as ""what you are doing about it (e.g. 'I'm setting the offer tracker to "@@ -828,19 +831,63 @@ async def synthesize_briefing_narrative(return fix_slips(text, reader)text = draftnamed = slips(text, reader)- if not named:+ echoed = own_echoes(text)+ if attempt == 1 and echoed:+ logger.warning("briefing_narrative: rewrite still reports the reader's chats back")+ if not named and (attempt == 1 or not echoed):return textif attempt == 0:- logger.info("briefing_narrative: draft named its reader (%d slips); rewriting", len(named))+ logger.info(+ "briefing_narrative: draft named its reader (%d slips) or echoed their chats (%d); rewriting",+ len(named), len(echoed),+ )messages = [*messages,{"role": "assistant", "content": text},- {"role": "user", "content": rewrite_request(named, reader)},+ {"role": "user", "content": _rewrite_note(named, echoed, reader)},]logger.warning("briefing_narrative: rewrite still named its reader; fixed in code")return fix_slips(text, reader)+# Ways a draft reports the reader's own chats and asks back to them, which+# OWN_MESSAGES_RULE forbids: "you asked me to", "your chat", "a chat with me", "the 13:26 alert+# chat". Caught in code because the rule alone did not hold (the /today header+# wrote "the 13:26 alert chat shows the noise you asked me to deal with").+_OWN_ECHO_RE = re.compile(+ r"\byou\s+(?:asked|wanted|told|reminded)\s+me\b"+ r"|\byou\s+asked\s+(?:for|about)\b"+ r"|\b(?:(?:our|your)\s+chats?|our\s+conversations?)\b(?!\s+(?:rates?\b|with\s+(?!me\b)))"+ r"|\b(?:chats?|conversations?)\s+with\s+me\b"+ r"|\bthe\s+\d{1,2}:\d{2}\s*(?:[ap]\.?m\.?\s+)?(?:[\w-]+\s+){0,3}?(?:chats?|conversations?)\b",+ re.IGNORECASE,+)+++def own_echoes(text: str) -> list[str]:+ """The phrases in ``text`` that report the reader's own chats or asks+ back to them, as written."""+ return sorted({m.group(0) for m in _OWN_ECHO_RE.finditer(text)})+++def _rewrite_note(named: list[str], echoed: list[str], reader: Reader | None) -> str:+ """The note that sends a draft back for its reader slips and its echoes+ of their own chats."""+ notes = []+ if echoed:+ notes.append(+ "Leave out every mention of the reader's own chats and asks to you ("+ + ", ".join(f"'{e}'" for e in echoed)+ + "): never which chat, its time, or that they asked. An ask still "+ "open may stay only as what you are doing about it."+ )+ notes.append(+ rewrite_request(named, reader) if named+ else "Rewrite that accordingly. Change nothing else, and output only the rewrite."+ )+ return " ".join(notes)++__all__ = ["BRIEFING_NARRATIVE_SOLO_SYSTEM","GETTING_STARTED_RULE",diff --git a/packages/core/openexecutive/delegation/drafts.py b/packages/core/openexecutive/delegation/drafts.pyindex 9e4605ef..a3944856 100644--- a/packages/core/openexecutive/delegation/drafts.py+++ b/packages/core/openexecutive/delegation/drafts.py@@ -17,6 +17,7 @@ briefs can name the draft.from __future__ import annotationsimport logging+import reimport sqlite3from dataclasses import dataclassfrom datetime import UTC, datetime, timedelta@@ -37,6 +38,10 @@ _SOURCES = frozenset({SOURCE_CHAT, SOURCE_INBOX})SETTLE_WINDOW = timedelta(days=2)# At most this many Gmail reads per settle pass._SETTLE_MAX = 20+# How many of their latest sent messages a pass reads to find a draft they+# sent another way (``_sent_another_way``); only when a draft is still there.+_SENT_LOOKBACK = 15+_SUBJECT_PREFIX_RE = re.compile(r"^\s*(?:re|fwd?|aw|wg)\s*:\s*", re.IGNORECASE)@dataclass(frozen=True)@@ -277,8 +282,10 @@ async def settle_waiting(stop calling them waiting. Nothing records a send made in the mailboxitself, and the chat drafts have no card for the inbox watcher to settle.A reply draft also stops waiting once they sent their own message in- that thread after it was saved: they answered without it, so it is not- theirs to review any more (the draft itself stays in their mailbox).+ that thread after it was saved, and any draft once their sent mail has+ the same email sent after it (another version of it, or a copy written+ fresh): they answered without it, so it is not theirs to review any more+ (the draft itself stays in their mailbox).Reads only; returns how many it marked. Never raises."""person_id = getattr(person, "id", None)email = str(getattr(person, "email", "") or "").strip().lower()@@ -304,6 +311,8 @@ async def settle_waiting(# Outlook ids are longer than Gmail's: ask the client which it takes.valid_id = getattr(client, "valid_id", gmail_id)gone = 0+ # Still in their Drafts: (row id, created_at, every recipient, subject).+ present: list[tuple[int, str, tuple[str, ...], str]] = []for row_id, draft_id, created_at, thread_id in waiting:if not valid_id(draft_id):continue # nothing to look up@@ -314,8 +323,9 @@ async def settle_waiting():message = getattr(found, "message", None)recipients = [*getattr(message, "to", []), *getattr(message, "cc", [])]- to = tuple(str(a) for a in recipients[:5] if a)- _seen[(pid, row_id)] = (to, str(getattr(message, "subject", "") or ""))+ subject = str(getattr(message, "subject", "") or "")+ _seen[(pid, row_id)] = (tuple(str(a) for a in recipients[:5] if a), subject)+ present.append((row_id, created_at, tuple(str(a) for a in recipients if a), subject))continue_seen.pop((pid, row_id), None)mark_gone(row_id, now, db_path=db_path)@@ -324,13 +334,77 @@ async def settle_waiting(# Not connected, a sign-in problem, the service down: the draft# counts as waiting until a later pass can tell.logger.info("delegation.drafts: couldn't check a draft (%s)", type(exc).__name__)- break+ return goneexcept Exception:+ # Something about this one draft: the others still get checked.logger.warning("delegation.drafts: checking a draft failed", exc_info=True)- break+ for row_id in await _sent_another_way(client, present):+ _seen.pop((pid, row_id), None)+ mark_gone(row_id, now, db_path=db_path)+ gone += 1return gone+def _same_subject(subject: str) -> str:+ """A subject without its "Re:" / "Fwd:" prefixes, casefolded."""+ text = subject.strip()+ while True:+ stripped = _SUBJECT_PREFIX_RE.sub("", text, count=1)+ if stripped == text:+ break+ text = stripped+ return " ".join(text.split()).casefold()+++async def _sent_another_way(+ client: Any, present: list[tuple[int, str, tuple[str, ...], str]]+) -> list[int]:+ """The drafts in ``present`` whose email they have sent anyway: a message+ of their own sent after the draft was saved, with the same subject, to+ one of the same people. They sent another version of it (a later redraft,+ a copy written fresh) and left this one in Drafts. One read of their sent+ mail, none when no draft is left. Never raises."""+ present = [p for p in present if p[2] and _same_subject(p[3])]+ if not present:+ return []+ list_sent = getattr(client, "list_sent", None)+ if list_sent is None:+ return []+ try:+ sent = await list_sent(_SENT_LOOKBACK)+ except Exception:+ logger.info("delegation.drafts: couldn't read sent mail", exc_info=True)+ return []+ out = []+ for row_id, created_at, recipients, subject in present:+ saved = _aware(created_at)+ if saved is None:+ continue+ people = {a.strip().lower() for a in recipients}+ for m in sent:+ when = _aware(getattr(m, "received_at", "") or "")+ if (+ when is not None and when > saved+ and _same_subject(str(getattr(m, "subject", "") or "")) == _same_subject(subject)+ and people & {+ str(a).strip().lower()+ for field in ("to", "cc", "bcc")+ for a in (getattr(m, field, None) or [])+ }+ ):+ out.append(row_id)+ break+ return out+++def _aware(iso: str) -> datetime | None:+ try:+ when = datetime.fromisoformat(iso)+ except ValueError:+ return None+ return when if when.tzinfo is not None else when.replace(tzinfo=UTC)++async def _answered_since(client: Any, thread_id: str, own: str, created_at: str) -> bool:"""Whether ``own`` sent a message of their own in ``thread_id`` after``created_at`` (a draft is never one)."""diff --git a/packages/core/tests/unit/test_brief_reader.py b/packages/core/tests/unit/test_brief_reader.pyindex be4919bb..893b8cc0 100644--- a/packages/core/tests/unit/test_brief_reader.py+++ b/packages/core/tests/unit/test_brief_reader.py@@ -254,3 +254,52 @@ def test_the_executive_as_a_noun_phrase_is_left_alone() -> None:text = "The Executive team met; the Executive office closed and the Executive replied."assert fix_slips(text, PAT) == "The Executive team met; the Executive office closed and I replied."+++def test_own_echoes_find_their_chats_and_asks_reported_back() -> None:+ from openexecutive.briefing.narrative import own_echoes++ text = (+ "- **Offer drafts** — both versions are waiting, and the 13:26 alert chat "+ "shows the duplicate-alert noise you asked me to deal with."+ )+ assert own_echoes(text) == ["the 13:26 alert chat", "you asked me"]+ assert own_echoes("As you wanted me to, I moved it after your chat.") == ["you wanted me", "your chat"]+ assert own_echoes("In the chat with me you settled it.") == ["chat with me"]+ # Someone else's chats, and a fact of the day, are not echoes.+ assert own_echoes("Dana wrote in your Google Chat space that the lease is signed.") == []+ assert own_echoes("Your customer conversations with Acme went well.") == []+ assert own_echoes("Your team's chat channel and your sales conversations are quiet.") == []+ assert own_echoes("After your conversation with the board, our conversation rate dropped.") == []+ assert own_echoes("Your chat with Dana settled it.") == []+ assert own_echoes("As our conversation showed, it moved.") == ["our conversation"]+ assert own_echoes("**You're clear today.** I'm muting the duplicate alerts.") == []+++async def test_a_draft_that_reports_their_chat_back_is_rewritten_once(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ text, provider = await _synth(monkeypatch, [+ "- **Alerts** — the 13:26 alert chat shows the noise you asked me to deal with.",+ "- **Alerts** — I'm muting the duplicate alerts.",+ ])++ assert text == "- **Alerts** — I'm muting the duplicate alerts."+ assert len(provider.calls) == 2+ note = provider.calls[1]["messages"][2]["content"]+ assert "'the 13:26 alert chat'" in note and "'you asked me'" in note+ assert note.endswith("output only the rewrite.")+++async def test_a_rewrite_that_still_echoes_is_kept_after_one_try(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ text, provider = await _synth(monkeypatch, [+ "**You asked me to mute alerts.**",+ "**You asked me to mute alerts; done.**",+ ])++ assert text == "**You asked me to mute alerts; done.**"+ assert len(provider.calls) == 2diff --git a/packages/core/tests/unit/test_delegation_drafts.py b/packages/core/tests/unit/test_delegation_drafts.pyindex ecc85fb2..3c67ee09 100644--- a/packages/core/tests/unit/test_delegation_drafts.py+++ b/packages/core/tests/unit/test_delegation_drafts.py@@ -243,6 +243,80 @@ async def test_a_mailbox_error_leaves_drafts_waiting() -> None:assert drafts.count_waiting(1, NOW.replace(hour=0)) == 1+def _sent(subject: str, to: list[str], at: datetime) -> SimpleNamespace:+ return SimpleNamespace(subject=subject, to=to, cc=[], bcc=[], received_at=at.isoformat())+++class _Versions:+ """Two versions of one email still in Drafts, and their sent mail."""++ def __init__(self, sent: list[SimpleNamespace], subjects: dict[str, str] | None = None) -> None:+ self.sent = sent+ self.subjects = subjects or {}+ self.sent_reads = 0++ async def get_draft(self, draft_id: str) -> Any:+ subject = self.subjects.get(draft_id, "2027 budget")+ message = SimpleNamespace(to=["[email protected]"], cc=[], subject=subject)+ return SimpleNamespace(draft_id=draft_id, message=message)++ async def list_sent(self, limit: int = 40) -> list[SimpleNamespace]:+ self.sent_reads += 1+ return self.sent+++async def test_a_draft_sent_as_another_version_stops_waiting() -> None:+ """They redrafted it, sent one version (or wrote it fresh) and left the+ other in Drafts: both stop waiting once the sent copy is there."""+ _record(1, drafts.SOURCE_CHAT, None, "d1", when=NOW - timedelta(hours=3))+ _record(1, drafts.SOURCE_CHAT, None, "d2", when=NOW - timedelta(hours=2, minutes=50))+ box = _Versions([_sent("RE: 2027 Budget", ["[email protected]"], NOW - timedelta(hours=2))])++ assert await drafts.settle_waiting(PERSON, now=NOW, gmail=box) == 2+ assert drafts.count_waiting(1, NOW.replace(hour=0)) == 0+ assert box.sent_reads == 1+++async def test_a_sent_email_that_is_not_the_draft_leaves_it_waiting() -> None:+ _record(1, drafts.SOURCE_CHAT, None, "d1", when=NOW - timedelta(hours=3))+ box = _Versions([+ _sent("2027 budget", ["[email protected]"], NOW - timedelta(hours=4)), # before the draft+ _sent("2027 budget", ["[email protected]"], NOW - timedelta(hours=1)), # someone else+ _sent("Lunch", ["[email protected]"], NOW - timedelta(hours=1)), # another subject+ SimpleNamespace(subject="2027 budget", to=None, received_at=NOW.isoformat()), # no fields+ ])++ assert await drafts.settle_waiting(PERSON, now=NOW, gmail=box) == 0+ assert drafts.count_waiting(1, NOW.replace(hour=0)) == 1+++async def test_sent_mail_is_not_read_when_every_draft_is_gone() -> None:+ _record(1, drafts.SOURCE_CHAT, None, "d1")++ class Box(_Versions):+ async def get_draft(self, draft_id: str) -> Any:+ return None++ box = Box([])+ assert await drafts.settle_waiting(PERSON, now=NOW, gmail=box) == 1+ assert box.sent_reads == 0+++async def test_one_drafts_failure_does_not_stop_the_pass() -> None:+ _record(1, drafts.SOURCE_CHAT, None, "d1", when=NOW - timedelta(hours=1))+ _record(1, drafts.SOURCE_CHAT, None, "d2", when=NOW - timedelta(hours=2))++ class Box:+ async def get_draft(self, draft_id: str) -> Any:+ if draft_id == "d2":+ raise ValueError("unexpected reply")+ return None++ # Newest first: d2's failure comes first, and d1 is still checked.+ assert await drafts.settle_waiting(PERSON, now=NOW, gmail=Box()) == 1+ assert [d for _, d in drafts._waiting(1, NOW - timedelta(days=1), None)] == ["d2"]++def test_an_older_table_gets_the_gone_at_column(tmp_path: Path) -> None:import sqlite3diff --git a/packages/core/tests/unit/test_live_signals.py b/packages/core/tests/unit/test_live_signals.pyindex ae53eeca..20739d63 100644--- a/packages/core/tests/unit/test_live_signals.py+++ b/packages/core/tests/unit/test_live_signals.py@@ -206,7 +206,7 @@ def test_conversations_are_the_principals_titled_sessions(own = live_signals.gather_live_signals(_since(), include_private=True)shared = live_signals.gather_live_signals(_since(), include_private=False)- assert [line.split("] ", 1)[1] for line in own.conversations] == ["Vendor renewal question"]+ assert own.conversations == ("Vendor renewal question",)assert shared.conversations == () # chat titles are the principal's owndiff --git a/packages/core/tests/unit/test_narrative_refresh_tick.py b/packages/core/tests/unit/test_narrative_refresh_tick.pyindex 0d6a88d1..7e3d4b21 100644--- a/packages/core/tests/unit/test_narrative_refresh_tick.py+++ b/packages/core/tests/unit/test_narrative_refresh_tick.py@@ -84,3 +84,23 @@ async def test_a_running_refresh_is_not_doubled(gate.set()task: Any = runner._narrative_taskawait task+++def test_the_principal_opening_today_settles_drafts_at_most_every_two_minutes(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """The scheduler's pass can be 30 minutes apart, or off: opening the+ page also settles the drafts (a draft sent from the mailbox stops being+ called unsent), throttled."""+ from fastapi import BackgroundTasks++ from openexecutive.api.routes import today++ monkeypatch.setattr(today, "_view_settled_at", None)+ t0 = datetime(2026, 9, 30, 15, 0, tzinfo=UTC)+ tasks = BackgroundTasks()++ assert today._maybe_settle_on_view(tasks, t0) is True+ assert today._maybe_settle_on_view(tasks, t0 + timedelta(seconds=90)) is False+ assert today._maybe_settle_on_view(tasks, t0 + timedelta(minutes=2)) is True+ assert [t.func for t in tasks.tasks] == [today.refresh_principal_narrative] * 2