The Notification Inbox
The persistent notification inbox: its four tabs, how it survives a restart, threads and Needs attention, where each row came from and going to its source, grouping by project or worktree, per-thread snooze, keyboard navigation, per-entry actions, and the events that reach it from outside the agent loop.
The Notification Inbox
Click the bell in the toolbar, or press Shift-Command-N Control-Shift-N Control-Shift-N , to open the inbox. It lists events whose routing policy records history, newest first, and it keeps recording while delivery is paused. A neutral dot on the bell means something is unread; the bell's tooltip gives the count.
The header carries Mark all read (while anything is unread), Pause notifications (the moon, covered in Do Not Disturb) and a More actions menu with Group by project or worktree, Notification settings… and Clear all…. Under it, a strip explains anything that is holding notifications back; see the "what will fire" summary.
It survives a restart
The inbox is persisted to disk and restored on launch, with age-based retention:
- Read entries age out after 7 days.
- Archived entries persist for 30 days, so looking up how something was resolved still works days later.
- Unread entries do not expire by age, but remain subject to the 200-entry cap. Losing a missed error to a clock is the failure this model exists to prevent.
A 200-entry cap still exists as a backstop, but it is no longer the model. Pruning runs hourly and is a no-op when nothing has expired, so the persistence write does not fire every cycle. The unread count is recomputed on load rather than trusted from disk.
Four tabs
- All: everything that is not archived and not currently snoozed.
- Unread: the same, filtered to entries you have not seen.
- Archived: the "done" surface.
- Snoozed: the "deferred" surface. It appears only while something is actually snoozed, and if the last snooze expires while you are looking at it, the view snaps back to All rather than stranding you on a tab that vanished.
Archived and Snoozed are deliberately not the same idea. An archived entry belonging to a still-snoozed thread stays in Archived: you finished with that one, and finishing is not deferring.
Threads, needs attention, and new-since
Related notifications from one run share a thread and collapse into a single row showing the latest entry, with a count chip for the rest. When a thread's worst-severity icon disagrees with its most recent entry (an error thread whose latest event is a successful recovery), the preview is prefixed with Latest: so the mismatch reads as deliberate.
Unread threads whose worst entry is an error or warning are pinned to a Needs attention section at the top, up to three at a time. An agent asking for input comes first, because a waiting agent is stalled until you answer while a failure has already happened; after that the order is severity, then recency. The pinned rows are compact previews (title, where it came from, any recovery buttons); each thread also appears in full in the list below, which is labelled All notifications while the section is showing. When more than three qualify, the section says +N more below rather than silently dropping them. There is no manual pinning; snoozed threads drop out of the section entirely, because snoozing is an explicit statement that a thread does not need attention right now.
Reopening the inbox puts a New since you last looked divider above the first entry that arrived after you closed it, with an inline Mark these N read button, and an Earlier label where the new entries end. Scroll the divider out of view and a floating Jump to new pill brings you back to it and puts keyboard focus on the first new row. Both are hidden on Archived and Snoozed.
The list carries scroll shadows at its top and bottom edges: soft fades that make it obvious when there is more above or below rather than leaving the list looking like it ends at the panel edge. Scroll-into-view targets are inset by the fade height, so a row the keyboard just focused, or the jump-to-new divider, never lands underneath the gradient.
Where each row came from
Every row has a quiet line under its message naming where it came from: the project and worktree (atlas-ledger · fix/rounding-drift), Daintree for app-level events such as disk space or an update, or Another project for a project you have since removed. In a window on a remote host, the host's name comes first. At fleet volume, "Tests failed" is only half a fact until it says which worktree.
Going to the source
Click a row, or press Enter on it, to go to what it is about. Daintree resolves the address at that moment: the panel, if it still exists outside the trash, otherwise the worktree, if this project view still has it. It selects the worktree first when the panel lives in another one, then focuses the panel, and the inbox closes once you have arrived. It never falls back to a project, because the inbox lives in the current project view and a row from somewhere else has nowhere to land here.
A row with nowhere to go stays readable but does not dress as a link: no pointer cursor, no hover tint, and its source line says why, Panel in trash or Source unavailable. A row from another project already names that project, so it says nothing extra. A row's own buttons (Retry, Open review hub) still do their own thing; from the keyboard the first of them runs with Command-Enter Control-Enter Control-Enter .
Grouping by project or worktree
Group by project or worktree, in the header's More actions menu, splits the list into a section per worktree (or per project, for events that name no worktree). Each section has a sticky header naming the project and worktree, a count, how many of its rows are new since you last looked, and its own Mark read button, which is the fast way to clear one worktree's noise while leaving another's alone. A section whose worktree is gone is marked unavailable. Grouped, there is no single new-since divider: each section marks its own Earlier boundary. The setting persists.
Per-thread snooze
Snooze defers a whole thread, not a single entry: a thread is the unit you actually care about. Four durations are offered, each with the time it will wake beside it:
| Option | Resolves to |
|---|---|
| For 1 hour | One hour from now |
| For 4 hours | Four hours from now |
| Until tomorrow | Tomorrow, 8:00 local |
| Until next week | Next Monday, 8:00 local |
Sub-hour options are deliberately absent: development happens in deep-work blocks, and a 30-minute defer is too granular to be useful. Durations resolve with local date arithmetic, so a daylight-saving transition lands on the wall-clock hour you expected rather than a UTC offset.
A snoozed thread is hidden from All and Unread until it un-snoozes. In the Snoozed tab its row says Snoozed until and the wake time, and its menu offers Unsnooze. As covered on the overview, it resurfaces early if it escalates into an error. Deferring a warning does not defer the failure it turns into.
Keyboard navigation
Opening the inbox puts focus on it, and the first arrow (or j / k) moves into the list. Navigation is suppressed while a row's menu is open so the keys do not fight the menu.
| Key | Action |
|---|---|
| j / ↓ | Next notification |
| k / ↑ | Previous notification |
| Home / End | First / last |
| Enter | Go to the entry's source, like a click |
| Command-Enter Control-Enter Control-Enter | Run the entry's first action button |
| e | Archive the focused row. Does nothing in the Archived tab. |
| u | Toggle the focused row between read and unread. Does nothing in the Archived tab. |
| h | Open the snooze durations for the focused row (thread rows only) |
e, u and h are lowercase only. The shifted forms are reserved for future bulk actions, and h is offered only on rows that belong to a thread, because snooze is a thread-level concept. Enter goes where a click goes rather than running a button, because an action can be a side effect (Retry, Restore) and Enter is the key everyone presses to open a list item.
Per-entry actions
Each row's … menu opens with the full project and worktree name, then carries, depending on what the entry is: Mark as read or Mark as unread (u), Archive (e), Snooze or Unsnooze, Copy correlation ID, Go to source (disabled, with the reason, when there is nowhere to go), Report on GitHub (errors and warnings only), Silence {event kind} (optionally "from this project") and Mute project notifications. The last two are the same actions offered on a toast's menu; see Muting & Silencing.
The × at the end of a row deletes it (a thread row deletes the whole thread). Clear all… in the header's menu asks first, naming how many notifications it will remove, including archived ones and snoozed threads, because it clears every tab rather than the one you are looking at.
Timestamps stay relative while recent and grow specific with age: just now, Nm ago, Nh ago, Yesterday HH:MM, Mon D, then Mon D, YYYY. The full date is always on the tooltip.
The inbox's read state is its own. Pilot's marks for whether you have seen an agent's hand-back are tracked separately, so marking a notification read does not mark a hand-back seen. See Pilot.
Other Events That Reach the Inbox
Agent finished with changes
When an agent finishes and its worktree has more changed files than when that session first started working, Daintree drops a quiet entry: Agent finished with changes, with an Open review hub action that jumps to the diff. Inbox-only, no toast, no OS alert, and only when that changed-file count increased. This is a review hint, not proof that the agent caused every change. A newer run in the same worktree replaces the previous entry rather than stacking. It does not replace the completion notification: a single finish can produce both, one telling you the agent is done and one pointing at what changed. See Review Hub.
Park released
Parking a run in Pilot can gate it on another terminal. When that gate comes free (or its terminal closes) the park is released and a Park released entry names the run, why it was released (its gate came free, or its gate terminal closed), and the note you left on it. An Open action jumps straight to the run.
This is the notification the whole feature exists to earn. A parked run usually lives in a different project, so the row reappearing in Pilot's waiting band is invisible from wherever you have moved on to. The wording stays neutral about the run's own state on purpose: the release says the gate finished, not that the parked run is idle. Re-parking and re-releasing the same run retires the older entry rather than stacking near-duplicates.
Update available and update ready
The Update available toast (Version 1.0.0 is downloading…) is informational and deduplicates itself: dismissing it suppresses that version for 24 hours, though a newer version always breaks through and a manual Check for Updates always shows its result.
The Update ready toast, raised once a download completes, carries two actions: Restart to update and View changelog, which opens the changelog on daintree.org in your browser. It is urgent, so it breaks through a quiet window: an install genuinely being ready outranks a scheduled mute. Two details follow from that:
- Dismissing the "Update ready" toast does not start the 24-hour cooldown. A pending install should keep reminding you.
- If a newer download starts while an "Update ready" toast is still on screen, the toast goes back to the downloading state and both its actions are cleared, so it cannot restart you into a stale build.
See Updates.
Deleted worktree cleanup
Deleted worktrees keep their agent terminals alive for a while on a deleted-worktree card. When that grace expires and the terminals are swept, a burst of deletions produces one inbox entry, Deleted worktrees cleaned up ("Closed 7 terminals left open in 3 worktrees."), rather than one entry per worktree. A burst is armed with the same expiry at the same moment, so all its rows expire on one tick; writing N entries describing one event was noise. The title switches between the singular and plural form, and a multi-worktree sweep carries no worktree attribution at all, because pinning one member's identity would make the entry navigate somewhere arbitrary. It is a low-priority inbox record: the event is unattended by definition, so a toast would interrupt whatever you moved on to.
Idle terminals
Daintree checks background projects periodically and records an entry, Idle terminals in "{project}", when every terminal in a project has been idle past the threshold. "Idle" means no terminal input and no output for longer than the threshold; a terminal with an agent in the working, running, waiting or directing state is not idle even when it is silent.
This is an inbox-only signal: no toast. An idle background terminal is an ignorable, self-recovering state you can keep working through, so it belongs in the durable record rather than in your way. One row per project, and a re-fire retires that project's previous row instead of accumulating near-duplicates. Each row carries two actions: Close them, which closes every terminal in the project and terminates any running processes, and Mute project, which snoozes the project for a while.
On by default, with a 60-minute threshold. Configure it under Settings > General > Hibernation > Background projects (Notify me about idle terminals and Remind after), not under Settings > Notifications. Presets are 30m, 1h, 2h and 4h; the valid range is 15 minutes to 24 hours. If Close idle projects automatically in the same section closes a project for you, that lands here too, as Project suspended.
High system memory use
When the machine itself is short of memory (swap above 80% full, the macOS kernel reporting memory pressure, or the macOS fseventsd process past 8 GB) for three samples in a row, Daintree says what it measured in a quiet row at the top of the sidebar footer. It names readings, never a cause, and clears itself once the readings recover. Its Memory actions menu offers two things:
- Ask agent about memory launches your default agent in the current project with a diagnosis prompt carrying the readings. The prompt asks the agent to check the current state with read-only tools, find what is using the memory, including things outside Daintree such as virtual machines and containers, and not to quit, kill or change anything without asking you first.
- Sleep idle projects, offered when a background project has no agent working (a waiting agent counts as idle), lists those projects with how many terminals and waiting agents will stop, and asks before stopping them. The saved layout, terminal scrollback and resumable agent sessions come back when you reopen each project. Running processes stop.
The inbox keeps an uncounted High system memory use warning with the same Ask agent about memory action, replaced by System memory readings recovered once every reading has stayed below its threshold for three samples in a row. For what Daintree reclaims by itself, see Memory pressure.