Omniscio

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

Part 3 of the Inbox alerts page: the Alerts screen and an alert's life after it arrives — the cooldown that keeps a dismissed problem quiet, the recently-dismissed view, starting a session from an alert, automatic remediation, provenance, and the once-a-day digest.

On this page

What it is

This is part 3 of the Inbox alerts page. It covers what happens around an alert rather than what one looks like: how a dismissed problem is kept quiet, where dismissed alerts go, the ways an alert can start work for you, and the daily digest that summarises the lot.

Where to find it

Mostly the Alerts screen, reached from the inbox. It is laid out like any inbox: the alert list — including the recently dismissed ones — sits in a sidebar on the left, and the alert you pick opens on the right while the list stays in view, so you can move from one to the next. The daily digest arrives in the inbox as its own item.

How it behaves

Re-raise cooldown (a dismissed problem alert stays quiet for 24 h by default)

Deduplication keeps a still-open alert to one row; a re-raise cooldown stops a dismissed problem alert from bouncing straight back. Once you archive a problem/advisory alert, the same one (same dedupKey) cannot reappear for 24 hours — enforced once at the shared createAlert chokepoint, so every problem alert inherits it, including ones added later. Within the window a fresh raise is silently suppressed (nothing new in the inbox, no notification); past it, the alert can surface again. 24 h is the default, not the only value — a handful of cards are deliberately slower (see "Cards that wait longer" below).

This generalizes the hand-rolled once-a-day caps the low-memory and AI-cost cards already carried into one floor beneath them — it never fights those (they already cap at 24 h) and it covers the ones that had no cap of their own (prompted by the "low disk space" card, which re-appeared every 15 minutes after each dismissal).

A once-a-day card holds its day, whatever archived it

The cooldown above is anchored on a card a person put away. A card the system withdrew — the producer clearing its own condition, or an agent archiving over POST /alert/:id/archive — deliberately buys no quiet at all, so a genuinely recurring problem is never silenced just because its producer retracted it.

A producer's clear ends the episode, even after you dismissed the card

The two facts above are "you put it away" and "your producer took it back". There is a third, and until 2026-10-10 it had nowhere to be written: the producer's condition goes false after you had already dismissed the card. There is no card left to archive then, so the clear wrote nothing and you were told nothing — the dismissed card went on buying quiet for the rest of the 24 h (or 90 days, for the backup-colocation card), and every raise of a genuinely new occurrence of that condition was refused while its producer was told "suppressed". A condition that ended and later returned reached your inbox only once the window expired.

A clear is now recorded on the dismissed card itself, and a recorded clear is the end of that episode: the same condition coming back pages you like any other new occurrence. So dismissing a card still buys quiet while the problem is still there, and stops buying it the moment the producer proves the problem went away. One clearAlertForDedupKey sits behind every producer's clear, so the rule holds for all of them, not just the one that was measured (inbox-alert-contract I26-anchor).

That leaves a gap for a card whose dedupKey names a content period — "this card IS today's digest", and the card's content does not depend on a condition the producer re-reads. Archive it as anyone other than the person and the next tick posts the period's content a second time, so the card can never be cleared. Cards of that shape (the daily Fleet health digest) therefore hold their own period: once the period's card has left the inbox, nothing posts it again, whoever removed it. While it is still in the inbox it behaves exactly as it always did — the row is refreshed in place. The next period is a new key, so tomorrow still posts. (inbox-alert-contract I39.) Measured 2026-10-02: the day's digest was archived by an agent at 10:23 and re-posted at 11:02, then every hour after that, for the rest of the day.

A day-stamped key alone does not make a card one of these. A producer that stamps the day purely to CAP its own nag rate — the inbox backlog nudge, the low-memory and spend cards — is a condition card, and it withdraws its own card the moment the condition reads false. Its withdrawal is recorded the same way an agent's archive is, so holding the period on it would silence a condition that genuinely came back the same day — the exact bug findLatestCappingByDedupKey exists to prevent (measured 2026-09-17: a morning storm's card was withdrawn on recovery, and the afternoon storm raised nothing). Those producers keep the ordinary cooldown and are deliberately NOT changed.

A small set of persistent-infrastructure cards get a shorter floor instead. A condition that stays broken for days — a stalled auto-lander, a stale test baseline, a red production deploy pipeline — is exactly what a day-long silence hides: the card is swept up in a routine bulk-dismiss and cannot come back until the next day. Most of those families re-raise every 6 hours, and the clock runs from your dismissal, so archiving one always buys the full floor. The exact per-card value is derived, never hand-maintained — the re-raise column in docs/ALERT_CATALOG.generated.md (generated, untracked) is the one authority, rebuilt by the auto-lander after every land (npm run alerts:catalog by hand). A branch never regenerates or commits it.

Every dismissal buys its full quiet, so putting a card away actually quietens the inbox (2026-11-09). The clock used to run from the card's creation, so a card that had stood longer than its own window bought nothing when it was finally put away: the next check put the same words straight back as a brand-new card. A sweep reaches most cards long after that, so the inbox refilled at about 37 cards an hour, nearly all of them unchanged cards coming back. Now the quiet runs from the moment you archive the card, for every kind of card except an alarm (which keeps its own six-hour snooze) — and a system withdrawal, or a card whose condition the app proved false, still anchors nothing at all, so a machine that recovers and breaks again still tells you at once. The one deliberate exception is a fixed-key daily digest (the Fleet pulse, the worktree ledger digest, the QA findings digest, the roadmap end-of-day check-in): its producer raises that same card once a day and nothing in between, so measuring from the dismissal would lose every other day's. A card whose producer POLLS — even a weekly reminder polled every six hours — needs no exemption: after its window it raises on the very next tick. (inbox-alert-contract I26-anchor.)

An alarm comes back 6 hours after you archive it, while its problem is still happening (2026-10-13). A day of silence suits a nag but not a standing fault. Measured the day this changed: the infrastructure monitors raised the same standing faults 71 and 53 times after their cards were archived, and not one raise reached the inbox. So the cards the monitors raise about a standing fault — the infrastructure monitors, the owner-critical and self-repaired conditions, plus the cloud-start failure card, the abandoned-gate card and the observed Anthropic degradation card — stay quiet for 6 hours from the moment you archive them (never longer than 24 hours from the card's creation), and the monitor's next raise after that shows a new card. A card you left up for 10 hours and then archived is quiet for 6 more, not for none. Each dismissal restarts the 6 hours, so a live alarm shows at most four cards a day, and once the monitor stops firing nothing raises and the archived card stays archived. Success notices, readouts and requests (a repair report, the daily digest, a machine waiting for your approval), notices, questions and reminders on a deliberately slower cadence keep the 24-hour quiet. A return the 6 hours released is not counted as a "quietly recurring" problem. A fault card with none of those markers keeps the 24 hours until its alert type declares one. (inbox-alert-contract I26-alarm.)

One card per INCIDENT, not one per condition — the AI-review answer-rate alarm. The cooldown keys on the card's dedupKey, so under a single fixed key a dismissal silences the whole condition. Measured 2026-10-11: a card put away by hand at 02:31Z kept the alarm quiet for a full day while the review service was still answering 94.7% of reviewer seats, so the drop that began after a genuine recovery paged nobody. That alarm now keys its card per episode — <family>:<the instant the sustained drop began> — so a dismissal quiets the incident you actually saw, for the 6 hours an alarm's dismissal buys, while a NEW incident is a different key and raises at once. An episode ends on the rate measurably back at or above the bar, on an engine-scoped card's own engine answering again (below), or on a blind stretch between ticks — the app not running. How long that takes is PER LANE: the burst lane uses its tick-gap bound, the leak lane its own 24-hour window, because a shorter closure leaves that day's seats in the window (nothing has turned over) and ending the episode there would re-mint the key after every restart, putting a repeat row in the inbox of someone who had already dismissed it. Neither an inconclusive reading (a failed read, too few seats) nor a rate still below the bar whose crop of failures is too small to page on can end one — so a condition hovering around a failure floor cannot keep minting fresh, never-dismissed cards, and a dismissal stays honoured until the service really recovers.

What counts as a seat is an ATTEMPT, and the app's own interruptions are not failures (T-317, T-326). A reviewer seat the app re-seated keeps every earlier attempt on its row, so a launch that died is no longer erased by the retry that followed it. Each attempt is sorted once: answered, left out because the APP interrupted it (the app restarted, its reviewer queue was full, or AI review was switched off), or genuinely unanswered. A card counts only the genuinely unanswered ones and prints how many were left out and why, so "seats are not getting answered" can never be said about a rate the app itself caused. That includes a long shutdown: a review whose 45-minute deadline ran out while the app was closed has its unfinished reviewers recorded as app-restart casualties the moment the app starts again, so reopening the app no longer raises this card (measured 2026-11-04: a 2h20m shutdown had read as a 53% answer rate).

The same alarm watches TWO failures — a blow-up and a slow leak (T-215). The bar is 99.9% of reviewer seats answered over a week. The burst lane (the last 60 minutes, at least 20 seats, at least 10 unanswered, under 99%) catches a blow-up, but its ten-miss floor makes it blind to the drip: a couple of missed seats an hour is ~96–98% over a week and never trips it. So a SECOND lane reads the trailing 24 hours and pages when at least 200 seats finished and the rate is under 99.9%. The two lanes are separate families (review-answer-rate-low: and review-answer-rate-leak:) with separate stored episodes, so neither lane's raise, clear or dismissal can silence the other, and each keeps its own Settings switch. While the cooldown holds a card either lane wants to deliver, GET /reviews/answer-rate reports it — alarm.cardWithheldSinceIso and alarm.leakCardWithheldSinceIso — instead of leaving the rate looking unremarkable.

An engine is judged on its own seats, and its card clears only on its own evidence (T-215, T-269, T-270). When the install-wide rate hides a dead engine — one engine answers NOTHING over at least 3 of its own seats in the hour, or 20 over the day on the leak lane, while everyone else answers — the card is raised from that engine's slice and names the engine and its own counts, never the blended ones. The stored episode then remembers WHICH engine opened it, so the card retires only on a positive observation that this engine answered: an install-wide healthy window clears it only when that engine finished a seat and answered it, and an engine that simply stops being seated HOLDS the card — not being seen is not a recovery, and the seats aging out of the window is exactly how a still-dead engine used to look recovered overnight. A widening that is genuinely the whole install — the seats OUTSIDE that engine are themselves below the bar on a sample above the seat floor — raises the card's rung to 2 on the burst lane (the leak lane carries no rung), so it pages past a dismissal the way any materially worse drop does. The rung is fed the INSTALL's rate, and only while the install sample is above its seat floor: a slice's own 0% is not a rung anchor, and a sample the lane's own constants call noise never walks the ladder up.

The readout also says WHY the misses missed. Every bucket — the whole window, each engine, and each seat origin (box, local, unseated) — carries byFailureReason: one count per failure CLASS for the seats that did not answer (capacity, never-spawned, launch-timeout, spawn-failed, seat-check-failed, seat-unavailable, engine-unavailable, request-refused, switched-off, box-unavailable, app-restart, rate-limited, turn-zero-exit, unclassified, timed-out, invalid-answer, could-not-review), zeroed so an absent class is never confused with an unread one. A seat the provider parked on a rate limit is rate-limited and is left OUT of the rate (reported under byExcludedReason), like an app restart or a full reviewer queue — the provider held it, the reviewer did not fail. The total is exactly finished - answered for that bucket, and it carries no review id, no session id and no reason text — the same names-nobody rule the rest of this readout keeps. The classes are the review service's own retry vocabulary, so "why is Claude at 96%" and "what does the retry arm do about it" are one answer, not two.

Every writer names its cause, so unclassified is history (T-236). The classes above are matched against the reason stored on the seat, and five writers used to store prose no rule recognised — a launch that failed with no words, a start that threw, and a session that ended before its first turn. Measured over the 24 hours to 2026-10-20 21:34 ET, 90 of 267 unanswered seats were filed as "an unrecorded cause" that way, 75 of them on DeepSeek, which is precisely the question "is the engine fallback working?" made unanswerable. The launch paths now store REVIEWER_SPAWN_FAILED_MARKER (spawn-failed) and the dead-seat path stores REVIEWER_TURN_ZERO_EXIT_MARKER (turn-zero-exit), each keeping the detail the path already held. Both markers are matched last, so a cause recorded more specifically still wins and no seat changes class or retry behaviour. launch-timeout is a box that was busy, not a reviewer that failed (T-320). A reviewer seat whose launch ran past the app's own hang ceiling is stopped by the app, and its stored reason now carries REVIEWER_LAUNCH_TIMEOUT_MARKER — its own class, so the readout can tell an overloaded machine from a launch that genuinely failed. The class is TRANSIENT and, like the reviewer queue and a failed worktree read, it is a cause that waits itself out: the seat's one re-run is given back at every write that records the stop, including the sweep's spawn-receipt arm (where most stops land, because most seats are queued before their launch). Before this, a single slow start spent the seat's only retry and the second stop was terminal, so a loaded box could settle a round with zero reviewers and the Dev Pipeline would skip a review the owner rule says always runs.

Read turn-zero-exit as "the reviewer session started and then ended without a single turn" — the number to watch when judging whether a fallback engine is picking work up.

Cards that list branches stay quiet for every branch you have already dismissed. The auto-lander's grouped cards ("N branches need a hand to finish landing", "a ready branch is blocked from landing", the stuck card) name their branches. Inside the 6-hour window such a card comes back early only for a branch that was on none of the cards you dismissed in that window (I26-member). The "branches are parked" card is plain visibility and takes the ordinary 6-hour quiet. Until 2026-09-23 the check looked only at your most recent dismissal, so archiving one card could instantly bring back the branches from the card before it — 49 of that day's 96 give-up cards reappeared within 2 minutes of an archive.

An auto-lander card never comes back as a second copy (2026-10-14). Four rules, for every auto-lander card and nothing else:

  • Putting a card away sticks while the problem is the same. The lander sometimes loses sight of a card's branches for one pass — a land finishing late, an app restart. That used to count as "the problem went away" and erase your dismissal, so the same branches came back as a brand-new card minutes later (measured: a card you had started a session from returned two hours later and started a second session on the same work). It no longer does.
  • New commits are news; the same commits are not. A card remembers which commit each branch was at. If a branch gets new commits and gets stuck again, you hear about it at once. If nothing changed on it, you don't.
  • A card you started a session from stays quiet while that session is open — even past the usual 6-hour return and across an app restart. A session counts as open for up to a day after it started, so one you stopped using cannot silence the card for good. Archive the session and the card can return if the branches are still stuck. A branch the card never showed still reaches you.
  • A card that does come back is the same card. Inside its 6-hour window it reopens — unread, at the top, with the same phone alert and short hold a new card gets — instead of appearing twice; dismissing it then buys the full quiet again.

Turn the last two off with the lander switch lander-alert-no-duplicates (AMC_DISABLE_LANDER_ALERT_NO_DUPLICATES=1).

The "needs a hand to finish landing" card is never raised for a branch that is already being handled. A branch that is back in the landing queue — tagged ready at the commit it is on — is left to the lander, however many times it was handed back before. A branch a live session is working (yours, its author's, or the lander's rescue — even mid-rebase) holds the card off while that session stays active; only one that has gone silent escalates. Until 2026-09-24 the card judged all three from stale bookkeeping, and 21 of the 40 branches it had given up on since 09-22 went on to land.

A merge that an earlier rescue left half-finished is finished automatically, not carded. Sometimes a rescue session starts merging the main branch into a stuck branch and then ends before saving the result. That leaves the branch's folder with unsaved changes, and the lander's rule against touching unsaved work used to turn that straight into the "needs a hand to finish landing" card. Since 2026-10-09 the lander checks what those changes are. If they are only that unfinished merge of the main branch, it sends the next rescue into the folder to finish it. Any other unsaved work, a merge of some other branch, or a folder it cannot read is still left alone exactly as before. So is a folder where a session is still working.

A branch whose automatic rescues have run out is set aside quietly, not carded. Each stuck branch gets up to three automatic rescue sessions — two, plus one last attempt that waits for a free slot and a calm machine rather than being skipped. If all three end without landing it and nothing is still working on it, the lander marks the branch blocked with the reason written on it, shows it in the Dev Pipeline panel's couldn't-land list, and raises no inbox card. A branch with no folder of its own can never be rescued, so it is set aside on its first refused rescue rather than after three (2026-10-10). The commits and the worktree are untouched, the daily lifecycle report counts it as handled, and there are two kinds of set-aside with two different ways back. When no rescue could even start — there was no folder to rescue the branch in — nothing was ever measured about the branch, so running /ready-to-merge on it again puts it back in the queue: the fresh check answers for that commit and the set-aside lifts. When a rescue did run and could not finish the branch, that is a finding about the branch rather than a missing folder, so the set-aside is as final as a person's block and /ready-to-merge will not clear it; the branch says so on it, and a person has to look. It is never set aside while a check is still running on it or while it is tagged ready at its current commit. If the blocked tag cannot be written, the card appears as before, and the lander switch lander-giveup-set-aside (AMC_DISABLE_LANDER_GIVEUP_SET_ASIDE=1) brings the card back for every spent branch.

"Auto-landing is off — N finished branches are waiting" means automatic landing has been switched off for at least 30 minutes while finished work waits. It names how many branches are waiting and says nothing is lost: they land as soon as you turn landing back on. It clears itself when landing is turned back on or the queue empties. Since 2026-10-18 it never appears on a computer that publishes its work as GitHub pull requests (a computer not marked as the main one) and whose automatic landing is switched off on purpose, and a card such a computer raised earlier is withdrawn. Before that fix the card came back every six hours on those computers, and each time it started a paid session that found nothing to fix. On the main computer it still appears, because there landing being off means work has really stopped. The lander switch lander-disarmed-alert turns it off.

"The auto-lander has stopped keeping up" means ready work is waiting and the lander is not landing it. It appears when, for 15 minutes in a row, either the lander's landing rate over the last hour has fallen below half its usual rate for the last 6 hours while at least 3 ready branches wait their turn, or its passes keep running out of time before trying a single land. The card says how long it has lasted and which part of the pass took the most time; branches held on purpose (a frozen master, an owner sign-off) never count as waiting. The same card also appears when the lander has landed nothing for 20 minutes while landable work waits — whatever the reason: a drain switch left on, a pass stuck in flight, a long post-land settle. That check runs on the lander's watchdog timer and remembers its start time on disk, so a stuck pass or a restart cannot hide it. That version names why landing is held, in order: a repo the lander is deliberately holding on its last pass (a developer catch-up, master held by another mover, or master sync not keeping up with GitHub), the halt switch and who set it, the Integration Engine's ownership record, the pass in flight and its phase, a long-running settle, then the slowest stage. It clears only when the lander really lands again or the queue is read as empty — and that empty reading has to be taken after the card appeared, so a stale one can never dismiss a live card, while a reading it cannot take never clears it either — and the first version clears as soon as a pass shows the lander keeping up. The lander switch lander-bound-stall-alert (AMC_DISABLE_LANDER_BOUND_STALL_ALERT=1) turns it off.

"Auto-lander has landed nothing for N minutes" means a branch has waited 20 minutes of app running time with no land at all. The 20 minutes count from the later of the last land and the last time the lander saw nothing waiting, so a quiet spell with an empty queue never counts toward it, and a queue emptied another way (an owner-approved merge, a catch-up land, a branch taken back) stops the card from arming. The land that resets it is any land, not only the auto-lander's own — a merge through the owner/hand road, the hourly backstop, or a land reported after the fact all count, because the card asks whether the base is moving rather than who moved it; a repeated report of an old land never resets it, since it keeps the moment that land was first recorded. The clock reads that record directly and falls back to the lander's own last-land stamp only when the record cannot be read. It raises once per stall and clears only when something lands.

It is scoped to genuine problem alerts and never swallows real content:

  • Message / content alerts are exempt. A team-chat "new message" notice reuses one row per channel, so a second message must never be suppressed — those are exempted centrally (isReRaiseThrottleExemptDedupKey). Drip items are exempt too (their own surface). Reused-key status alerts (a broken RSS feed, a failing poll) are not exempt — there, "at most once a day" is exactly what you want. The exception is the pair of alarms just below, exempt for a different reason.
  • Alarms whose fix is to act on the card are exempt. Some alarms describe a condition that is still true while you go and do the thing the card asked for. Archiving one on the way to the fix would otherwise silence it for the rest of the day, so both are exempt from the cooldown and come back on the alarm's own 15-minute check instead. Mute the alert type if you want them gone, rather than archiving them.
  • Urgent alerts bypass it. A genuine spend runaway bypasses both the AI-cost card's own daily cap and the global cooldown (bypassThrottle), so a real money emergency always surfaces — unless you have turned AI cost alerts off, which silences the runaway as well (ai-spend-alerts.md).
  • You can turn it off. Settings → Notifications → Limit repeat problem alerts (problemAlertReRaiseThrottleEnabled, on by default). Off → a dismissed alert can re-appear on its producer's own cadence; the per-card caps (low-memory, spend) still apply.

Like the per-card caps, the cooldown reads the most-recent prior card's timestamp straight from the database (counting a card you already dismissed), so it survives an app restart and a dismiss-then-spike the same day. See inbox-alert-contract.md (I26).

Cards that wait longer than 24 h

A few cards report a standing situation rather than an evolving incident — something you either fix once or knowingly accept. Their producers re-check on a schedule you don't control (every app launch, settings change or boot scan), so the 24 h default would turn each one into a daily nag about a decision you already made — and a card you dismiss on sight is a card you have stopped reading. These get a longer floor in the central cadence registry (alert-reraise-throttle.ts):

Card Waits Why
"Backups are on the same disk as your data" (backup-colocated) 90 days Re-raised each launch and backup-settings change; backup posture is a standing choice. The same key can also read "Your tasks exist only on this computer".
"Task attachments are not in your automatic backup" (backup-task-attachments) 90 days Re-raised each launch while Tasks holds attachments and the Backup Mirror is not fully set up; it cannot be silenced and clears itself once the Backup Mirror is configured.
"Mobile Access is on" (tunnel-public-exposure) 30 days Re-raised each boot auto-start and tunnel re-heal, for a feature you chose to turn on.
"Add your own API key" (pooled-ai-monthly-limit) 30 days Nothing about the card changes on its own — it clears when a key is added or a call succeeds.
"{engine} may be getting too many skills" (skill-budget-over:*) 30 days The scan re-runs ~60 s after every boot; the card itself is titled "Monthly reminder".
The watching-agent leverage recap 7 days Meant to land at most once a week.

Two things this is not. It is not permanent silence — each card returns on its own cadence for as long as the situation lasts. And it never delays the all-clear: fixing the underlying thing (a fully configured Backup Mirror, which carries the database and Tasks; or Cross-Device Sync, which carries the database but no Tasks; never the settings-only Setup Backup to Gmail; turning Mobile Access off) clears the card immediately, because clearing archives the row directly and never goes through the cooldown.

The backup-colocated card covers two exposures under one key. It is raised while the exposure it names is unprotected, and the exposure has two shapes: the local auto-backup ring shares the primary database's volume and no off-machine copy of the database exists, or the install holds Tasks rows and the ring lives on another drive — Tasks are the one data class Cross-Device Sync never carries, because its replica copies no Tasks tables, so neither sync nor a second local drive is an off-machine copy of them. Either shape raises exactly one card, because both describe the same standing choice and the same fix. The title and body change with the shape so the card never claims a disk problem that is not there: an install whose backups already live on another drive of the same computer reads "Your tasks exist only on this computer", while a ring on the database's own volume keeps "Backups are on the same disk as your data" and adds a sentence naming Tasks when it holds any. Which mechanism withdraws the card depends on the shape it is in: the same-disk card clears on any off-machine copy of the database it names, while the Tasks card clears only on the Backup Mirror, and its body names the Backup Mirror alone as the remedy, because an enrolled Cross-Device Sync syncs no Tasks rows. The check runs at launch and again whenever a backup setting changes; an off-machine copy for the shape in question, or an install exposed in neither way, withdraws the card. The same posture also appears as a standing notice at the top of the Tasks view — see off-machine-backup-onboarding.md.

A longer floor also takes that card out of the "a problem alert keeps quietly recurring" meta-notice — for these, being suppressed is the cadence working, not a hidden recurrence.

"A check is running long" — one card per kind of check

What it says. That a check an agent asked for still has no result, and has gone far past how long that kind of check normally takes on this machine. The card names the kind of check, how many are still open, where the oldest one is, and how far over it is ("has not finished in 40m — normally under 20m").

It says "no result yet", not "still running." All the record shows is that no closing entry arrived — an attempt whose owning session has ended looks the same, so the card deliberately does not claim a live process.

Where the number comes from. The last 24 hours of this machine's own runs, per kind of check. The card raises when a running check passes twice the 95th-percentile time for its kind — never sooner than 15 minutes, and never later than 90, so a bad week cannot push the line so high that the card stops speaking.

One card per kind of check (tests, lint, typecheck, gate-launch, guard, …), each carrying its own key, so the card about a stuck typecheck is not hiding behind one about tests.

It clears itself. The card is refreshed in place while the check stays running, and taken down the moment that check finishes. You never have to archive it to make it go away.

It says when it cannot measure. A kind of check with too few recent runs to have a normal time is left alone rather than guessed at, and if the alarm itself stops running — an app restart, a wedged tick — the next card opens by saying how many minutes went unmeasured instead of showing you a stale figure.

It does not confuse a leak for slowness. An attempt whose closing record never arrived is reported as that missing record, counted on the card, and never alarmed on as a slow check.

Its re-raise floor is 6 hours, not the usual 24 — a wedged check is a standing condition, so a day of silence after one dismissal would hide exactly what the card reports while the check is still stuck.

What the Alerts screen lists — and what it does not

The screen lists real alerts only: the cards Omniscio's own monitors raise. A row an agent session raised is a message, not an alert, and it is deliberately not listed here — its home is the inbox (and, when it names one, the project hub its session is working in), where the conversation around it lives. The split is the SAME predicate that paints the row's colour (isAppRaisedAlert: a row carrying a sourceSessionId is a message), applied as a placement rule in one gate both halves of the screen read — the live list and the "Recently dismissed" section below it — so the two can never disagree (alerts-hub-items.ts, hubVisibleAlerts + hubDismissedAlerts; contract inbox-alert-contract.md the-alerts-panel-lists-only-real-alerts).

Omni (or the name you gave it) collects only what Omni itself did or recommends: Ops Engine proposals, trust asks, auto-escalations, shift handoffs, items it moved, deadline forecasts, and its advisor notices. Expect few of them. Every other project-manager card that is not tied to a project (automation notices, due dates, imports, board sync, webhooks, backend status) files under Mission Control, beside the board notifications, and can be dismissed all at once there. A card tied to a project stays in that project. Both headers open Mission Control.

A notice from a project-manager automation reads From automation: <name>. The name is saved on the notice when it is raised, so a renamed or deleted automation still shows the name it had. Notices raised before the name was saved read From an automation.

In the unified inbox the same split decides the SECTION. A projectless card Omniscio raised itself ("The app froze…", "What's new in Omniscio", "Claude Code needs an update") files under its own System section instead of the shared Alerts section, so the app's own notices no longer blend with the cards your sessions send (feature request 310d4871, 2026-10-02). System always sits at the bottom of the inbox — on screen and in keyboard next/previous order — and starts folded (its header still shows the count); open it with its chevron and it stays open until you fold it again. "Collapse all" folds it, "Expand all" opens it, "Dismiss all" works there, and clicking its header opens this Alerts screen. What stays put: a card filed under a project, the Tasks / Team Chat / Cron Jobs sections, a session's own projectless card, the two first-run welcome cards (so a new user's first guidance is never folded away), and any Omniscio card that asks you something — a question or an approve/reject verdict, such as an email waiting on a reply or a workflow approval (alertAsksForAnAnswer); System holds plain information only. Every onboarding tutorial video card the drip sends (other than the welcome tour) gets its own Training Hub section, titled Tutorial: <video name>, and never appears on this Alerts screen (owner decision 2026-10-14; see training-hub). Code: alertInboxGroupId in alert-inbox-group.ts (the SYSTEM_ALERTS_PROJECT_ID group key), the bottom sink in inbox-items.ts, and the default-folded group in inbox-collapse.ts; contract inbox-alert-invariants-2-contract.md app-notices-file-under-system.

Two consequences worth knowing. The sidebar count for the Alerts row reads that same gate, so the number and the rows always agree. And a session's POST /alert card is covered by the same rule, not only a crew lead's — the whole family stopped being announced here: an agent's message belongs in the hub where that agent works.

Recently-dismissed view (the Alerts screen, last 7 days)

The dedicated "Agent Alerts" screen (the Alerts virtual-project row, gated by alertsSidebarEnabled, on by default) keeps its list in a sidebar like every inbox-style integration (AlertsSidebar.tsx). It shows your active alerts at the top — middle-click a row to archive it in place; a live row carries no button of its own, so the row's width belongs to the alert title — and, below them, a collapsed "Recently dismissed (N)" section: agent alerts you archived within the last DISMISSED_ALERT_WINDOW_DAYS = 7 days (alert-types.ts), muted, each with a Restore button that un-dismisses it (through the ALERT_UNARCHIVE chokepoint).

Why the live row has no Dismiss button (owner, 2026-10-24). The shared ListItem draws its actions slot shrink-0 whenever actions != null — the slot is faded on a hover-capable pointer, never removed — so the per-row button permanently reserved its width plus the row gap and truncated every title ~46px early. Middle-click already dismissed the row, so the button bought nothing visible and cost every row space. ListItem itself is unchanged; this call site simply passes no actions on a live row, and must pass undefined rather than an empty node or the reserved space comes straight back. The dismissed row's Restore stays — it is a different action with no middle-click equivalent — and it is deliberately an AsyncButton, never the detail pane's InboxArchiveButton, which publishes itself to the single mobile pinned-archive slot and would fight over it from every row. On a phone, dismissing is still reachable: tapping a row opens the alert, whose pane carries the archive control.

This screen owns that read. It is the only surface that asks for the whole 7-day archive, and it asks when it opens. Nothing else pulls that list to find one row: the update card a mission lead's newest update is drawn on, which lives at the foot of that session's conversation, asks for that lead's own cards only, and only while that session's panel is on screen — so a phone watching one conversation is never handed the archive. The read takes an optional key prefix for exactly that, and the answer is cached per session so opening the Alerts screen is still the one place the full list loads.

The list gate is hubVisibleAlerts — ONE definition shared by this sidebar, the reading pane, the sidebar badge and the nav list that walks it. It drops snoozed rows and, since 2026-09-30, every team-chat notice: a chat message is a conversation rather than a standing alert, and it keeps every surface it had (the inbox, the channel's unread badge, the OS toast, the phone push). The badge counts that same filtered list, so the hub's number always matches the rows it shows.

That sidebar carries two tabs — "Alerts" and "Sessions". The hub is itself a session host, so agents you start in its context run in its own managed workdir (<userData>/alerts-agent) and are listed through the same session list every hub uses. The Sessions tab carries the usual running / waiting-for-you / error count; picking a session opens its chat in the main pane, and the alert reading pane comes back when you switch to Alerts (alerts-session-host.ts; session-host-contract.md).

Clicking an active alert opens the usual viewer (AlertInboxViewer, the same pane the unified inbox uses); clicking a dismissed one opens a read-only copy (AlertsVirtualProject.tsx through the shared ArchivedAlertDetail) — never the live viewer, which resolves only active alerts and would sit on "Loading alert" forever. Its Restore button keeps the alert open, now as a live one. With nothing open the pane says "Select an alert", or "No alerts" when the list is empty. Which dismissed alert is open lives in a small shared store (alerts-hub-selection-store.ts), and selecting any live alert — from the list, keyboard nav, the archive advance, the unified inbox or a deep link — closes it, so one you moved on from can never resurface. On a phone the list is the landing screen and a tap opens the alert full-screen.

In a popped-out Alerts window the list and the pane come along, but no main-window overlay exists there — so the reading pane draws the live alert itself (it asks isMainAppShell()), Go to session opens that session in the main window, and an HTML-file alert shows its normal file card instead of the live preview, whose <webview> a pop-out cannot host. The popped-out list stays live on its own — it starts the alert sync and the snooze cache that only the main window's shell starts — and an alert archived elsewhere while it is open is reconciled instead of spinning on "Loading alert". Its buttons that lead elsewhere open in the main window: a Settings link on the exact page, Open channel on the exact Team Chat channel, any other hub on that hub, and the actions that need the main app (Review updates, Restart, Start session, …) open the alert there. Details: pop-out-project-window.md.

Middle-click dismisses an active row on this screen too, as everywhere else in the inbox (the Archive action above). It routes through the same archiveInboxItem store action, so it inherits the cursor advance, the Ctrl+Z undo and the rollback-on-failure. A row in "Recently dismissed" is already archived, so the gesture is a deliberate no-op there — use Restore.

It is a pure VIEW over data that already persists — archived alerts are NEVER purged (retention skips inbox_alert_items) — backed by the read-only listRecentlyDismissedAlerts (queries-inbox-alerts.ts: source_kind='agent', so it never poaches drip-sourced archived rows, the same liveness filter as listActiveAlerts, archived_at >= cutoff bounded at 200, newest-first) over ALERT_DISMISSED_LIST. The renderer keeps a separate dismissedItems store slice (loadDismissedItems, epoch-guarded) refreshed only AFTER an archive/restore commits, so the active list and its I12 reload-reconcile are untouched. A future retention purge MUST respect this 7-day window. See inbox-alert-contract.md (I24).

Advancing to the next alert on the Alerts screen — the trap

Dismissing an alert from the Agent Alerts screen moves you to the next alert, the way archiving a session moves you to the next one that needs you — so a pile can be cleared without returning to the list between every row. On mobile the detail panel swaps its content in place and only slides back to the list once nothing is left below, so you never land on a blank full-screen detail.

That did not used to work, and the reason is a trap worth knowing before touching any hub. The advance is the ordinary one — advanceInboxCursorAfterDismiss resolves the next row with getNavigableItems(view, 'attention') + findNextItem — but it only advances if it gets a nav list at all. The Alerts screen is a virtual project, so no session carries its UUID, and its rows are alerts whose own projectId is the __alerts__ sentinel (or their source project, or the team-chat / tasks-v2 sentinel) — never this hub's UUID, which is all selectProjectAttentionItems matches on. The generic project path therefore returned an empty list here, and an empty nav list silently disables the advance: findNextItem returns null, the selection is cleared, and on mobile the panel pops back to the list.

The fix is the seam, not the symptom: getNavigableItems recognises the hub (isAlertsHubProject) and walks the hub's own queue from alerts-hub-items.ts — a verbatim projection of the rows the panel renders, in the same updated_at DESC order, so nav order IS rendered order. That one seam also covers keyboard nav in the hub. Deliberately not alertInboxSelectItems: that one additionally drops snoozed rows and desktop-only nudges because the global inbox hides them, and nav must walk exactly what this screen shows. Do not re-derive the queue anywhere else — the single-source wall is nav-group-single-source.test.ts, and the behaviour is pinned by alerts-hub-nav.test.ts.

This is the identical bug the Approvals hub had — see approvals-hub.md § Advancing to the next approval. Any new virtual-project hub that lists its own rows needs the same branch, or it inherits the same silent stranding.

Reading-pane appearance (severity medallion)

Open an alert and the reading pane leads with a tinted icon "medallion" beside the title, and the panel carries a matching thin left accent rail + a whisper-soft header wash — all coloured by the alert's kind:

  • green — an "Omniscio did a cleanup / self-heal" notice (the worktree-lock and install-orphan reapers, Auto-Tidy). An explicit allow-list — a real problem is never shown green. The two lowest-value self-heal FYIs — "cloud-enforce auto-enabled" and "cleared stuck worktree locks" — are silenced by default as noise (the cleanup + its audit log still run; only the FYI card is hidden). Turn on showSelfHealNotices to see them; the genuine stuck-reaper warning is never silenced by it.
  • amber — an "action needed" notice (a reconnect prompt; a low-memory / low-spec / sync-drift / low-power warning; a Tasks reminder).
  • red — an incident (an Anthropic API status incident, a broken cloud base).
  • pink — every other or unrecognised alert that Omniscio raised itself, matching the pink dot that alert wears in the inbox list.
  • neutral accent (indigo) — every other or unrecognised alert that an agent session sent (its inbox dot is amber or blue, never pink).

An alert with a definition chooses its own look. Before the kind classifier runs, the pane asks the alert's definition (its dedupKey) for a style and an icon, and when one answers, those win: the style sets the colour and the icon sets the glyph. The five styles are info (the neutral accent), success (green), warning (amber), critical (red) and question (the blue the app uses for a card waiting on an answer). The style vocabulary — the five names, the colour each one maps to, each style's default glyph and its human label — lives in one shared module, src/shared/alert-style.ts, so the definition author, the inbox list and the reading pane can never disagree about what a style means; it is plain string data with no React import, because it is read on both sides of the app.

A definition's icon is a lucide component name. An unknown name falls back to that style's default glyph rather than drawing nothing, so a typo never shows up as an empty medallion; a name that is not even the right shape (PascalCase) is refused when the definition loads, so that mistake is caught at build time. The five defaults are Info, CheckCircle2, AlertTriangle, XCircle and HelpCircle — the canonical glyph for each meaning, matching the rest of the app.

An alert with no definition keeps the kind classifier's look below, unchanged — including the pink app-raised rule.

The colour + icon for that kind-classified path come from one pure classifier, alert-visuals.ts (getAlertVisual), keyed off the alert's dedupKey and whether a session raised it (sourceSessionId, read through the same isAppRaisedAlert the inbox row dot uses). Colours route through the themeable status-* / accent tokens, so a custom theme recolours the medallions automatically, and the medallion is decorative (screen-reader-hidden) — the title text carries the meaning, so colour is never the only signal. A success tone is an explicit allow-list only: a green "all good" on a real problem is the one mislabel this classifier must never make, so nothing reaches green by arriving unrecognised. The accent is alerts-only: it rides InboxDetailShell's optional, default-off accentRailClass / accentWashClass, so the approval panes and drip items render unchanged. The compact inbox row dot is pink for an alert Omniscio raised and amber/blue for one a session sent, so a pink-dot row always opens on a pink header unless its kind carries a severity (amber/red/green). See inbox-alert-contract.md (I23).

A git-guardrail self-pause card is amber on purpose. The card reports that an agent gave itself a short pass, spending one of a small hourly budget, so it is worth noticing: amber, never green. It is not an alarm either, because the person opted into the feature and nothing is broken, so it is not red. Without its own rule the card would fall through to the raiser-based default, and an agent-raised text card gets the neutral accent. That would draw a green "all good" tile directly above copy saying a pass was burned.

Two brands sit beside the tones. Mission Control's routine notices wear a teal-to-gold accent, and Omni's routine cards wear the Omni look (the Omni icon, cyan tile, rail and wash). alertAccentClasses returns the brand's accent whenever a rule sets brand, so a brand outranks the tone on the rail, tile and wash. Which cards get each brand, and why problem reports never do, is in Mission Control part 4 ("How these cards look").

A cut-off title is tap-to-expand, at every window width. The reading pane clamps the title to 2 lines to keep the header compact, so a long one ("Anthropic API issue: Fable 5…") shows an ellipsis. Tap the title to reveal the whole thing; tap again to re-collapse. A title that already fits stays a plain heading, and it is fully keyboard- and screen-reader-friendly (the full title is always the button's spoken label, even while clamped). This is not only a phone behaviour: a small desktop window clamps a long title too, and a title with no spaces or hyphens to break at now breaks inside the pane instead of running off the edge, then gets the same tap-to-expand. The same title serves a scheduled message's subject, the "drip finished" notice, and the heading of an approval request, a Library document, a scheduled job (cron), a Linear project and a recipe run; on the Library document and scheduled job panes the action buttons drop under the title when the pane is narrow. A released drip item's name is different: it is the link that opens the drip's editor, so it simply wraps to as many lines as it needs. See inbox-alert-contract.md (I25).

Last verified 2026-11-05