Omniscio

Inbox alerts (how an agent gets your attention) (part 4)

How an alert card behaves once it is in your inbox — where it sits in the list, the badges it carries, and what acting on one does to the rest.

On this page

What it is

The continuation of part 1, covering the card inside the inbox rather than the card itself.

Where to find it

This is the behavior of the shared inbox list, so it applies wherever an alert appears: the inbox, a project Needs You section, or the Alerts screen.

How it behaves

Inbox behaviour

projectId decides WHICH part of the inbox a card lands in, so it decides whether the operator sees it. It has three states, and null is not the same as leaving it out: a real id files the card under that project; an explicit null raises it GLOBALLY, in the shared Alerts pile the operator scans; omitting it derives the raising session's project. So a card raised from inside a project-bound session and left unscoped lands in that project's own group, mixed among its sessions — which is how a genuine question for the human can sit unread. An agent asking for a decision should send projectId: null explicitly. The card keeps its source session either way, so being global costs no provenance. Honest limit: the Alerts pile is a pile, not an alarm — global makes the ask reachable, not guaranteed to be read.

Alerts surface as amber-dot rows in the unified inbox (integration alert, dotColor: 'bg-amber-400'). When an alert has a projectId that is a real user project, it also surfaces in that project's Needs You attention section (mirroring how doc-token-alert and cron-approval rows work). There it orders by its timestamp, interleaved with the session rows — it is NOT appended after them, so an old alert sits where its age belongs instead of being pinned to the bottom. Every Needs-You row (session or notice) orders by the same key via the one orderNeedsYouItems rule, and the rendered sidebar order equals the keyboard/swipe/next-selection order; see project-needs-you-attention-contract.md (render-order-equals-nav-order / advance-can-land-on-a-notice) and the ordering-parity axis in frontend-inbox-row-contract.md.

Tasks reminders get their own "Tasks" section. A Tasks reminder — raised when a task's due date arrives or a snoozed task comes back — is an ordinary agent alert, but instead of landing in the shared Alerts pile it surfaces in its own "Tasks" inbox section (its own header + task-list icon), so task reminders don't get mixed in with system alerts. Its rows behave like any alert (archive, snooze, its own Dismiss all), and clicking the section header opens the Tasks view. Tasks is a Lab / in-development feature, so this section only appears when Tasks is enabled.

Team Chat messages get their own "Team Chat" section. A team-chat new-message notice is an ordinary agent alert, but instead of landing in the shared Alerts pile it surfaces in its own "Team Chat" inbox section (its own header + chat icon) — the SAME section the connection-request rows already use, so messages and connection requests sit together. Its message rows behave like any alert (archive, snooze, their own Dismiss all — which clears message notices only, never the connection-request approvals in the same section), and clicking the section header opens the Team Chat panel. Team Chat is an in-development feature, so this section only appears when Team Chat is enabled.

A built-in channel's notices file under that channel's own inbox section. The notices raised by the built-in channel pollers — Calendar ("starting soon" reminders, "calendar updated" changes, and a "calendar event alerts stopped" health notice), Gmail ("Gmail is disconnected"), Drive ("Google Drive needs reconnecting"), RSS ("an RSS feed stopped updating"), and Webhooks ("a webhook source is failing") — pass a virtualProjectPath naming their channel's virtual project (e.g. __rss__ / __calendar__). So they group under that channel's inbox section, merging with that channel's other rows (an RSS broken-feed notice sits alongside your RSS feeds), instead of the generic Alerts bucket. resolveProjectId honours virtualProjectPath via the pure isChannelVirtualProject membership check and stores the sentinel folder_path verbatim; it takes precedence over projectId/session resolution and, touching no database, can never fail and swallow the notice. The one-click Reconnect buttons and self-clear-on-recovery behaviour are unchanged (they key on dedupKey, not the project). Calendar and Drive get their inbox-section name + icon + colour from src/renderer/src/features/dashboard/inbox-helpers.ts (they are seeded from CHANNEL_VIRTUAL_PROJECTS, not the integration registry). Calendar goes one step further: the Calendar hub's Calendar tab leads with a "For You" band showing those same rows — the calendar's own live inbox items (starting-soon reminders, event added/changed notices, the day's agenda card, and the alerts-stopped health notice) — read from the one shared inbox list, so opening or dismissing a row there does exactly what it does in the inbox and the row clears on both surfaces together. The band renders nothing when the calendar has nothing waiting, and it hides whenever the Calendar inbox toggle (inboxShowCalendar) hides those rows.

Omniscio's own notices file under your Omniscio project. A notice about Omniscio's own machinery — a Dev Pipeline card (a branch that would not land, a worktree that would not delete, a gate that died, a test baseline that regressed, a workspace that needs you) or an app-internal one (the disk guardian, a background-metadata storm, a cloud pointer that stranded, the folded "background machinery" rollup) — now files under your Omniscio project (the checkout Omniscio runs from, e.g. a row named Omniscio) instead of the generic Alerts pile. The classifier is the dedup key: an exact list plus prefix families for the build → gate → land → workspace lifecycle, unioned with the existing about-Omniscio class. It is the LAST step of the grouping fallback, so anything already carrying a channel, an explicit project or a raising session's project is untouched — a real project always wins. On a machine with no Omniscio checkout the step returns nothing and these notices stay in the pile exactly as before.

This changes where you find those cards, and one thing about how you clear them: a card filed under a project appears in that project's Needs You attention row and is dismissed one at a time — project-scoped alerts deliberately have no "Dismiss all" (that button lives on the unscoped buckets). What did NOT change: the alerts themselves, their dedup keys, their one-click actions, their re-raise cadence and their archive behaviour are all identical. Cards that were already in your pile move on their next re-raise, so the pile empties progressively rather than all at once.

Where a card appears also follows WHO raised it. A card Omniscio's own monitors raise is a real alert and appears everywhere an alert can: the inbox, its project's Needs You when it names one, and the Agent Alerts screen. A card an agent session raises — a crew lead's routed update, any session's POST /alert card, a one-line wait-check card, an email-arrival notice — is a message, and the Agent Alerts screen deliberately does not list it; it keeps its home in the inbox (and in its project's hub) so the conversation around it stays where it belongs. The split is the same predicate that paints the row's colour, and the screen applies it to its dismissed section too, so clearing a card one click later cannot put it back. See Inbox alerts — the lifecycle.

Standard inbox actions apply:

  • Archive (E / middle-click / mobile X / the detail-viewer Archive button) — removes the row from the inbox and optimistically removes it from the store slice; rolls back on IPC failure. Ctrl+Z undoes it: the store's archiveInboxItem arms an undo (once the archive succeeds) that restores the alert via ALERT_UNARCHIVE, so undo works from every archive surface, not just the keyboard. The restore is keyed on the card's IDENTITY (dedup_key), not its row: if the condition re-fired between the dismiss and the undo, a fresh card for it is already in the inbox, so the undo reports success and leaves that live card alone rather than trying to restore a second copy of the same alert.
  • Snooze — routes through the universal inbox_snoozes table (kind 'alert'); the selector gates on isInboxItemSnoozed('alert', id). The server list queries do NOT filter snoozes, so every alert list applies that gate itself — the inbox in alertInboxSelectItems, the Agent Alerts screen in hubVisibleAlerts, and the sidebar badge by counting the filtered list. A snoozed alert therefore disappears from all three until it wakes; before this, the Agent Alerts screen alone kept showing it, which made snoozing look like it had done nothing.
  • Every alert type names the hub it shows in (owner, 2026-10-15). Each type's row in the central alert registry carries one field, hub — alerts (the Agent Alerts screen) or omniscio (the Omniscio hub, the project that is a checkout of Omniscio itself). Left blank, a type goes to the Omniscio hub when it is about Omniscio's own machinery and to Agent Alerts otherwise. Changing that one field moves every new card of that type; cards already on screen stay where they are until cleared or raised again. A card sent to the Omniscio hub shows in that hub's Needs You and leaves the Agent Alerts screen, its badge and its "Recently dismissed" list; on an install with no Omniscio hub it simply stays in Agent Alerts. The GitHub-master, hourly work-output, cloud-step, Overseer-waiting and crew ALARM cards are set to the Omniscio hub. To move a type, ask an agent to change its hub field.
  • Alerts you need to see go to your Omniscio hub (owner, 2026-11-12). Reports and digests, board and crew cards, questions, money and spend, security, people waiting on your reply and possible lost work are listed in the Omniscio hub and leave the general Alerts list — moved, not copied, including cards already open. Machine alarms stay in Alerts, and cards that already have their own hub (Team Chat, Tasks, Cron failures, Training) or their own channel section (Calendar, Gmail, SMS) stay there. Which alerts count is the owner list in src/shared/alert-owner-stay-list.ts. Turn it off with Show my alerts in the Omniscio hub in Settings → Notifications; every card goes straight back. On an install where Omniscio itself is not one of your projects nothing moves.
  • Team-chat notices are the one kind the Agent Alerts screen does not list (owner, 2026-09-30 — a DM notice sat there as a bare sender's name among system alerts). hubVisibleAlerts drops all four notice prefixes: a chat message is a conversation, not a standing condition an agent needs looked at, and it is the one kind with no actions on it. Nothing is lost — a notice keeps the inbox (alertInboxSelectItems is untouched), the channel's unread badge, the OS toast, the phone push and the read-clears-it rule. Both gates live in the same selector, so the screen, the sidebar badge and the nav list can never disagree.
  • Dismiss all — a section with at least one alert shows "Dismiss all N" in its header, on desktop and phone — the alerts twin of the Approvals "Approve all" / "Reject all" dropdown, which covers every pending approval (cron, automation, CLI Pending, recipe, recipe-authoring) bar a few CLI kinds decided one at a time. It clears at once, with no confirm: the section is archived through the per-row Archive, the open row last so the cursor moves once, and a short message appears with an Undo that stays for 10 seconds and puts back exactly the rows it cleared. It shows from a single alert; on the unscoped Alerts bucket and the System, Tasks, Omni (or its custom name) and Mission Control sections, each clearing only its own. Mission Control's board updates count too — the "you were assigned", "status changed", "due soon" and "field changed" rows for your board items are worded "items" and each is cleared by its own Dismiss (a grouped row clears every update behind it, and the message's Undo brings every one of them back); the section's workflow and automation approvals are never swept, so each still needs its own decision. A project-scoped alert in its Needs You is dismissed singly. Plugin groups get it too — a group a plugin fills (GitHub, a newsletter builder, any other) shows the same "Dismiss all N" from one row, on desktop and phone, worded "items" instead of "alerts". Each row is cleared by its own Dismiss exactly as if you had dismissed it by hand; the rows stay hidden when the plugin sends the same list again, the message's Undo (10 seconds) brings back every row that was cleared, Ctrl+Z still brings back one row at a time (the last one cleared first), and one short summary message appears when it finishes. When the plugin has subscribed to dismissals the message adds that the plugin is told too.
  • The number on a plugin's sidebar row opens what it counts — on the desktop sidebar, clicking the number on a plugin's row (instead of opening the plugin) shows a small popover: the plugin's inbox rows each with an x, "Dismiss all N", "Open plugin", and a separate Open line for a real-work count the plugin reports (such as reviews waiting) — that count is never dismissable and never part of Dismiss all. Every dismissal there offers an Undo for 10 seconds, and the popover stays open on "All clear" when the last row goes. A plugin can mark a row quiet: it stays in the Inbox and on the plugin's own screen but adds nothing to the number or the popover. On a phone, tapping the row still opens the plugin.
  • Enter runs the card's one primary action — while you are reading a card, a bare Enter fires its primary button (Update now on a tool-update card, Restart now, Resume sessions, …) exactly as clicking it does, so an action that asks you to confirm first still opens that confirmation. It fires only while the card is what holds the keyboard — if focus is on the inbox list, in a field, on a button, or anywhere else, Enter keeps whatever meaning it has there. A held Enter does not repeat the action, and no modifier combination counts. Optional: make a card the inbox opened for you wait for a click — off by default, so Enter and the card's keys work as soon as a card appears. Turn on Click a card before Enter or X works on it in Settings → Inbox if you would rather be protected from a stray key. While it is on, a card the inbox moved to by itself ignores a bare Enter: after you reply, archive, dismiss or resolve something, or when the session you were viewing starts working, the inbox lands on the next card without your choosing it, and a stray Enter (easy to send by dictation) must not start a session or approve something you never looked at. Enter comes back the moment you click anywhere inside that card, and it always works on a card you opened yourself by clicking its row or moving to it with the keyboard. Tab still reaches the card's buttons, and Enter on a focused button presses it. The same rule covers approvals (Enter approves) and, in the inbox, a session's Allow / Approve card. With that setting on, the card's one-letter keys wait the same way: N (Start session), X (reject or deny), Y (allow), C (continue), W (keep waiting), Shift+R (restart) and a pane's own letter keys do nothing on a card the inbox moved to by itself, until you click inside the card or press Tab to reach one of its buttons. The inbox's own keys for moving between and tidying cards (J / K, E archive, H snooze) are unchanged, and typing in a text box is never affected.
  • Auto-recovery — when you archive an alert (or the one you're reading is removed out from under you — archived from another session, the CLI, a dedup collapse, or a background sweep), the inbox advances to the next item in the list, whatever it is — the next notification or the next session that needs you — rather than stranding you. There is no per-integration filter in that advance: the inbox is one ordered list and "next" is simply the next row (the sidebar order is the nav order). On a heavily loaded machine a worker session can briefly still look like it needs you just after it has gone back to running; if the cursor lands on such a stale session for a moment, the general auto-eject + idle auto-select move you straight on, so the old "blink → empty inbox" can't strand you. That advance only fires for an alert you were already viewing when the list last refreshed — so opening an alert never bounces you back to the list, even if you click it (e.g. going from a session row to a just-arrived alert) while a background refresh is mid-flight: at worst you briefly see Loading alert… until it appears. A refresh that began before your click took its snapshot before the alert was selected, so it can't be trusted to declare the alert "gone"; a later refresh resolves it. The reading pane (AlertInboxViewer) also renders nothing — never a stale "Select an alert to view" message — when no alert is selected, so the panel's close transition can't flash a misleading empty pane (the inbox layout owns the "Select an item" / "All clear" empty state).

Alert routes — a copy to the session that owns the problem

You can send a copy of each new alert of a given type to one session, or to a crew's lead, so the agent that owns that kind of trouble hears about it without you forwarding the card. The routes are the alertSessionRoutes setting, which ships empty. Each row has a match (an alert type key, or the start of a dedup key such as cloud-), a target ({ kind: 'session' | 'crew' | 'owning-crew-of-alert-session', id }) and, optionally, ownerCopy. The list holds up to 400 rows, room for every alert family to have its own; a save past that is refused. Only your global CLI token, or your own settings, can change them: PATCH /settings/alertSessionRoutes with a session's own token answers 403, and on the global token the change may wait on your approval card like any other setting.

Two writers cannot silently delete each other's rows. The routes are saved as a whole list, so a second writer working from an older copy would otherwise drop a row the first one just added. GET /settings/alertSessionRoutes therefore also returns a revision for the list, and PATCH accepts it back as expectedRevision: a write built from an older read answers 409 with a plain instruction to read the list again and resend. A write that would delete a row the saved list still holds is refused the same way when it does not carry that revision, and the error names the rows it would have removed — so add a route, read the list first, or send the revision you read. A write that only adds or edits a row needs no revision and behaves exactly as before.

  • Your card is unchanged by default. It is written, shown and counted exactly as before; a route only adds a copy.
  • ownerCopy: false sends the type there INSTEAD of your inbox. The card is still written and any agent can read it (GET /alert), but it stays out of your inbox list and counts for as long as the route's target has the copy. When several routes match one key, the longest match decides everything — whether your card stays or goes, and who receives the copy: a narrow rule overrides a broader one and the broader row gets no copy at all; only rows matching at that same length both receive, and two equally long rules that disagree send it away. It is never silent past 30 minutes: if nobody can take the copy right now — a paused or stopped target, a busy one, a refused or failed delivery, the per-target cap — the card stays out of your inbox while Omniscio keeps offering the copy (after half a minute, then a minute, two minutes and four, then every five minutes), and it comes back to you only if 30 minutes pass with no one taking it. A copy already waiting in a busy session's queue counts as waiting: it is not sent a second time, and the card comes back if it has not landed within the 30 minutes. A card whose copy can never be taken — a crew with no lead, an archived target, a route that no longer sends it away — comes straight back. Up to 200 cards can wait at once, and quitting the app ends every wait: those cards come back to you on the next start. A card you had already routed away before that delivery receipt existed stays away: upgrading stamps it as delivered instead of handing your whole backlog of routed-away cards back to you. A later re-raise of the same card checks the target is still there and hands the card back if not (a card that is already waiting keeps waiting), and saving a route list that no longer sends a type away hands that type's open cards back. A card that reached your inbox before its rule existed (or one you un-archived) is sent away on its next re-raise, exactly as a new card would be: it leaves your inbox with the copy delivered, and comes back the same way if nobody can take it. A safety alert (account sign-in, backups, a lost git store, memory pressure) can never be sent away: a route that could match one is refused when saved, and such a card always reaches you. A route naming a whole family (cloud-, cloud-alert-, cq-, deploy-fleet-, gcloud-) is not one of those: a family name is a label, not a safety type, so it saves — and the safety cards above still come to you whatever family route you keep. A new route of this kind is also refused when its target has no live lead.
  • A hand-back never builds a wall. While a card is away it is not counted toward the three-cards-per-title limit, so many cards of one type can pile up there. When they come back — a route change, a crew with nobody live, a copy nobody took — each one is held to that same limit: once three cards with its title are already in your inbox, it is folded into the newest of them instead of arriving as its own card. That card's count grows, its text lists the newest 10 reports and says how many there are in total, and the folded card is put away where you can still read it under recently dismissed. Measured 2026-10-25: one crew change handed 48 cards back in 80 seconds, 37 of them three walls of identical titles.
  • owning-crew-of-alert-session finds whoever owns the session the alert is about. Its id is a fallback crew. The copy goes to the lead of the crew that session belongs to, else to the session itself, else to the fallback crew's lead — the first one that can take it. A session that has already ended still belongs to the crew it finished in, so a card raised about finished work (every returned-cloud-work card is raised after its session is archived) reaches that crew's lead instead of the fallback. For the wake-schedule cards (wake-schedule-dead-turns:, wake-heartbeat-governor:) the session is the schedule's target. A dead-turns card never goes to that session itself — not even when it leads its own crew — because its turns are the ones failing: it goes to the session's crew lead, else the fallback crew's lead. The stopped-retry card (session-replay-budget-stopped-crew:) resolves the same way and for the same reason: when a session whose own replay budget is spent belongs to a crew, its card is filed for that crew under its own key and title, and the route carries it to the stopped session's crew lead, else the crew's fallback lead — never to the stopped session. A session in no crew keeps the card the owner has always had, under session-replay-budget-stopped:. The crew a stopped-retry card belongs to also takes in one of the crew's own helpers the app started for it — its memory scribe, promise judge or reviewer — exactly as it takes a member on the roster.
  • The copy is labelled. It arrives as an "Inbox alert (automated mirror)" message that says it is an automated copy and not a request. It carries the card's stored, already-cleaned text, capped at 2,000 characters.
  • Nothing is woken or started. A paused, archived, ended or errored target is skipped, and so is a crew with no live lead.
  • A route whose target is gone is passed over, not obeyed. If a route sends a type away from your inbox to a crew that has ended (nobody is left on it) or to a session that is archived or no longer exists, that row cannot reach anyone, so Omniscio reads your list as if the row were not there. The card then goes the way an alert with no route of yours would — to the crew its type belongs to, or to the crew you named in Crew that receives unclaimed alerts — instead of being hidden and handed straight back to you, and it is counted on the day's summary of what was sent away, like any other alert Omniscio sent on your behalf. Your list is not changed: the log names each such row once per run so you can re-point or remove it. Safety alerts, anything on your keep list and any card that asks you a question still reach you, a route that only keeps your copy is never passed over, and a crew or session that is merely paused still gets its copy, with the card waiting up to 30 minutes for it. A card raised by a crew member's session goes to that crew's lead, as it would with no route of yours; any other card that carries a session id is not handled this way yet and stays with you.
  • What never routes: a card back to the session that raised it, a card a self-heal fixer already owns, a card waiting under the settling or digest hold, and a re-raise that folds into a card already in your inbox — that card gets no second copy, though it is still sent away when its type is routed away and it was never sent away before. A card the Overseer is holding for review does route, because the Overseer holds nearly every new card and the routed agent should hear about it while your copy waits. A route that could only match fixer-owned alerts (for example cloud-build-) is never saved: the CLI refuses it outright, naming the row and the reason, and any other save (the desktop settings, a backup restore) drops just that row — logging which row and why — and keeps every row beside it. A full replace-mode restore swaps the whole settings file in, so it can bring such a route back, but it still never fires: fixer-owned alerts are skipped at delivery.
  • It is bounded and fail-safe. One session gets at most 5 copies per 5 minutes; a copy past that waits for the next window instead of putting the card back in your inbox. If a copy cannot be delivered, that is counted and logged with the card and the reason, and the alert itself is never held up — the card is written at once and any agent can read it.

The crew that owns a type — routing with no row in your list

An alert type can name the crew that owns it, so a new card of that type goes to that crew's lead on its own, before you ever write a route for it. The owning crew is a field on the type's row in the central alert registry, written as the crew's name (lowercased) rather than an id, so the same source works on every machine and a crew that ends and is replaced under the same name keeps receiving. The types whose family your existing routes already send straight to one crew arrive with their owner filled in; nothing in your saved route list is changed or removed.

  • Your own routes always win. The owning crew is only consulted when no row in your route list matches the key — any matching row, however broad, takes precedence and keeps its own target and its own ownerCopy (a row whose target is gone is not a match — see above). While your hand routes are still in place they decide everything, exactly as today; the owning crew takes over for a type once the rows for it are gone.
  • It has its own switch. Settings → Notifications & Inbox → Send new system alerts to the crew that owns them, on by default (alertRegistryOwnerRouting). Turned off, every card behaves exactly as it did before this existed, and any card this rule had already taken out of your inbox comes straight back. It is a plain setting — also settable with PATCH /settings/alertRegistryOwnerRouting on your global token.
  • Only cards Omniscio raises itself. A card a session raised is never sent this way; the type's owner answers "who fixes this kind of trouble", not "who this session's card is about", so a session's own report stays with you.
  • Safety always stays with you. Account sign-in, backups, a lost git store and memory pressure are never routed by it; neither are the cards that exist to reach you and nobody else — the dark-alarm summary, a cloud session trying to read your private data, a blind cloud dispatch trace, an unlanded-branch backup failure, a box holding uncaptured work, the disk-space guardian, and the phone device-approval cards that ask you to confirm or block a sign-in. Those cards stay in your inbox whatever a type says.
  • Only a crew you have already routed to. The crew the name resolves to must be one whose ID already appears in at least one of your alert routes. A brand-new crew that happens to take a retired crew's name gets nothing: the card stays in your inbox and one line is logged naming the type and that crew. A crew's successor lead keeps the crew's ID, so a normal hand-over is never blocked.
  • A crew that is gone changes nothing. If the named crew has no live one at the moment the card is raised, no route is made, the card stays in your inbox, and one line is logged naming the type and the crew. It never throws, never hides a card and never sends a copy nobody took.

Two cards that watch the inbox itself

The app posts two of these cards about the inbox rather than about your work, and both live in the Maintenance category, so either can be switched off like any other alert type.

  • Your inbox jumped from N to M cards. Your own system cards are counted once an hour. When the count grows by more than a quarter AND by at least fifty cards since the previous reading — or by at least two hundred cards, however big the inbox already is — one card appears naming the two counts and the three alert families that grew most. The two-hundred-card clause keeps a big inbox from hiding a flood: without it, a 2,000-card inbox would have to grow by more than five hundred in one hour before anything fired. It updates in place while the flood continues and clears itself once the count falls back under the threshold; a restart never produces a false one, because the first reading after a start only records the baseline. The Inbox Alerts crew receives a copy of it.
  • The alert route table is full. Alert routes are capped at 400. A change that would store more than that is refused whole, and this card tells the Inbox Alerts crew — not you — which count was attempted. It clears itself on the next route change that fits.

The first card of a kind you have never seen

A family of alerts — the part of its key before the first colon — is previewed to you once. The first card ever raised of a family that only a default (an owning crew, or the Inbox Alerts crew for a card nothing owns) would send away also stays in your inbox, while that crew still receives its copy. One extra card per genuinely new kind, then the default takes over.

  • Shown once, and it stays shown. The family is recorded as seen the moment the card is kept, so a restart, a second occurrence or the next day never shows it again. Each card after the first follows the default and leaves your inbox as usual.
  • The card you were shown is not taken back. A later occurrence of the same key updates that same card instead of raising a new one, and it stays with you while it is live — the crew gets the updated copy.
  • A new machine is not a new kind. The family is only the part of the key before its first colon, so a card about a different cloud machine, session or branch of a kind you have already seen is not previewed again.
  • A ruling always wins. If you have already set an alert route for the family, muted the type, or it sits on the stay list, nothing is previewed: your decision decides delivery, exactly as above.
  • An upgrade never floods you. Families already on record when this shipped count as seen, so the first start after the update raises no card for a kind you have lived with for weeks.
  • A burst cannot flood you either. Some producers mint a fresh key per event. Previews stop at twenty per day; past that the defaults decide alone until tomorrow.
  • It is not "sent away". A preview stays in your inbox and never appears on the day's card that lists what went to a crew.
  • It has its own switch. Settings → Notifications & Inbox → Show me the first alert of a new kind before it goes to a crew, on by default (alertOwnerFirstSighting). Turned off, delivery is exactly what the two defaults gave before, and nothing is recorded while it is off — so a family that first appears then is still previewed once if you switch it back on.

Contract: alert-session-routes-contract.md and alert-owner-first-sighting-contract.md.

Last verified 2026-10-20