@ai-ecoverse/slicc-spectrum 1.75.0 → 1.77.0

package/README.md

@@ -137,7 +137,7 @@ Text is Adobe Clean Spectrum VF, falling back to Adobe Clean, and code is Spectr
 | `<slicc-app>` | The shell: header with the agent picker, status items, the update status, the network indicator, the tray, the View menu and the theme switch, rails, and a `<slicc-dock>`. Saves the dock layout per screen class to `storage` (default `localStorage`) under `layoutKey`. While connected it sets `overscroll-behavior` to `none !important` on the page's `html` and `body`, so only scroll areas inside panels rubber-band. It sets the page's `color-scheme` to its resolved theme, and when the page has a `theme-color` meta per `prefers-color-scheme`, gives every one of them the content of the meta for that theme, so the page and the installed app's title bar follow the app's setting instead of the OS. When the last app on the page is removed, the page's own inline values and `theme-color` contents come back. With a `follow` port, the header shows a `<slicc-follow>` chip, and while the follower connects, waits to be allowed, is unlinked or fails, a `<slicc-follow page>` (`.alone[data-follow]` with the page kind) takes the place of the panels; without Terminal access, the terminal surface and New terminal aren't offered, and open terminals close when it's taken away. |
 | `<slicc-dock>` | Generic. [dockview-core](https://dockview.dev/) 8 with a theme mapped to Spectrum tokens, in its own shadow root. Panels come from `factories` (`name → (params) => HTMLElement`). `open`, `close`, `has`, `content`, `focusPanel`, `cycleGroup`, `cycleTab`, `toJSON`, `restore`, `clear`, and the full `api`. Tabs have a context menu (close, close others, float, maximize). Events: `layout-change`, `active-panel-change`, `panel-close`. |
 | `<slicc-agents>` | A tree (`role="tree"`) of cones, with their scoops hidden under them. A row's first line starts with one circle: its unread count when there are unread messages (`9+` from ten up, white on the accent fill), otherwise a dot coloured by status. Then comes the name; the context fill, when it's high, sits in the top right corner. Every row has up to two lines starting with its status in words (`.state`, such as "Working"), then its conversation title, so the status stays visible when the unread count takes the circle; the accessible name says the status and the exact unread count too. A cone's row also has a ribbon along its bottom with one fixed-width segment per scoop, coloured by status; it's `aria-hidden`, and the cone's `aria-description` sums it up, as in "2 scoops: 1 working, 1 idle". On hover, on keyboard focus of the row, or when <kbd>Tab</kbd> from the selected row reaches its drop or delete button, a strip the full height of the row's right edge holds that button over the text; the context fill stays on top of it, and it hides again once a pointer that clicked it leaves. A click, <kbd>Enter</kbd> or <kbd>Space</kbd> on a cone expands or collapses it, as do <kbd>→</kbd> and <kbd>←</kbd> (<kbd>→</kbd> on an expanded cone moves to its first scoop, <kbd>←</kbd> on a scoop to its cone); only the focused cone is expanded, and its scoops list below it. A cone with scoops carries `aria-expanded`, and `aria-controls` names its scoop rows while they show. Expanding and collapsing have no motion. **New cone** sits at the bottom. The conversation title is also shown in the header's cone picker: `Agent.title`, or else the first line of the first user message, or "No messages yet". When cones share a name, their accessible names and the Delete cone, Freezer and confirmation labels add the title, as in "Delete cone sliccy (Hello from Bedrock)". Selecting one makes it the active agent. |
-| `<slicc-chat>` | One thread's conversation (its `agent`, or the active agent if unset), by day. A message's time shows only when it is at least two minutes newer than the last time shown, and the first one after each day separator always shows; a hidden time stays for screen readers (`time.sr` with `datetime`, or `.sr` on licks and cards), and a meta row left empty isn't rendered. User messages (with attachments and a quiet timestamp, `time.when`, by that rule; the reader's own carry no name or delivery tag, while `data-mode` and `data-delivered` still say how they went; a message from another cone, a follower or a guest says who sent it, and an agent's request carries its name and an Agent badge; a message from another agent, an agent's request or a message `from` a cone (`origin` `agent`, or `from` set without `origin` `follower` or `guest`), is `[data-remote]`: a subtle indigo bubble and a 🤖 pill on its bottom edge, `aria-hidden` since the byline names the sender; people, the reader included, never get it), assistant messages (with the time by that rule, and the model only on the first reply and whenever it changes from the previous one, `.meta .model` with the usage as its tooltip; without a model the usage is the time's tooltip, and with neither it is the reply's own (`.reply[title]`); the turn always carries the usage as its `aria-description`; the cone's name isn't repeated; Markdown with tables, task lists, quotes, code and images; thinking; tool runs, one icon per run (`<slicc-tool-runs>`): three or more runs in a row form a cluster, a strip of icon buttons (`data-action="open-run"`, `data-target` the call's id, named by its `title` and status, `aria-expanded`) that each open one run's card below it, and on the right the model's label for the run, a button (`data-action="open-cluster"`, `aria-expanded`, named "Show all runs" while it has no text) that opens every card; the strip's tooltip and the group's accessible name sum it up, such as "3 commands, 1 read. Done"; prose breaks a run, hidden thinking and source links don't, and a standalone tool message or a done reply with only tool calls continues the run before it on the same day, its `data-id` moving onto its first card (`.tool[data-id]`); a single run is a strip of one, its icon and its `title` as the label, which opens with <kbd>Enter</kbd> or <kbd>Space</kbd> like the strip's buttons. A strip and its cards share one width, the column less a wide margin on each side, so they read as centred, and their edges line up. Icons fill from the start of a space kept for five, so a run that grows doesn't move its strip or its label; past five, the strip shows the newest five and scrolls back to the older ones, with <kbd>Tab</kbd> or a swipe, and returns to the newest when a run is added or the strip comes back into view. The label sits at the end and is cut with an ellipsis before it reaches that space. Under 480 px of column width the label takes a row of its own under the icons, which then show as many whole icons as fit. A cluster's label comes from the agent port's optional `toolLabel(agentId, callIds)`, asked once for each agent port, agent and set of runs; while a growing run waits for its new label, it keeps its last one, and without `toolLabel` the label is empty. A command's icon is the favicon of the site it names when an open browser tab already has a `data:` favicon for it (nothing is fetched; otherwise the globe), else the file browser's icon for the file it names, else the code icon; other tools show their kind's icon. A running run pulses (still, with a dashed ring, under `prefers-reduced-motion`), a done or cancelled one is grey and a failed one red, each with a corner glyph. The card (`.tool[data-tool][data-status][data-kind]`, a `details.run` under a pill and a `div[role=region]` named by its `title` and status under a strip) has no header of its own, no chevron, title, tool name or status: its input (a shell command after `$`), an edit's `diff` shown as a diff view, its output wrapped rather than cut off, an `image`, such as a screenshot, an optional `meta` such as a timeout, a standalone tool message's time ("Ran at 16:12", `.ran`, by the two-minute rule), and its `notes` (`{ severity, text }`, such as "Exited with code 5" or "Full output in /tmp/…") as lines under the output, `li[data-note][data-severity]`: `error` with an alert icon in the negative colour, `warn` with an alert icon and `info` with an info icon, both subdued; media galleries with images, video and audio; action cards for tools, pull requests and status; plans and checklists; inline diffs; question prompts; delegations; link previews; errors with a fix-it action, as a grey card (`.error-card[role=alert]`, `data-id` on system errors) inset by a wide margin on each side, a narrower one under 480 px: a red alert icon, the title in bold, the detail subdued and the action on the right, or under the detail below 360 px, announced as "Error: " and the title; a content-filter stop offers **Drop the last turn**, which rewinds that turn and puts its prompt back into the composer; when the turns right before it failed too, the button reads **Drop N failed turns** and rewinds to before the first of them, putting the latest prompt back), system messages (error cards; compactions and notices, rewinds and model changes included, as full-width dividers with a line on each side, like the day: a compaction shows only its title, its `text` kept for screen readers, one that lost messages (`state: 'fallback'`, by default "Compaction failed, transcript truncated", or `discarded`, "Context discarded") an alert icon in the negative colour, and a notice its title and text on one line, `role="note"`; a divider that wraps keeps a short line on each side) and licks, SLICC's events into a cone, on every channel, with their time by the two-minute rule; a lick's `severity` (`warn` or `error`) turns its channel badge into a notice or negative one with an alert icon. Permission requests are allowed or denied in place. The header is one row: the status, a model picker that names each model's provider and leaves out classifiers and models with `tools: false` (with no model on offer, **Set up a model**, `data-action="set-up-model"`, opens Settings), the thinking picker, the context meter and **New conversation**, which calls `clear` and puts focus back in the composer; on a cone, when the port can freeze, its tooltip says the old conversation stays in the Freezer. It never wraps: when it's short of room, the model picker's label is cut with an ellipsis, and under 560px wide (`header[data-compact]`) New conversation is icon-only, with `accessible-label` and its tooltip. The pickers re-read `models()` on `settings`, `accounts` and `agents`. When a live agent's model, or `Settings.model`, is no longer offered and its provider (the id before `/`) isn't a connected account, it moves to the offered chat model with `default: true`, else the first one; frozen agents are left alone, and so is everything on a follower unless it has Control and is connected. The chat re-runs this on `follow` and `readOnly` too, and `<slicc-app>` does it as well, when it binds, on those events and on `follow` and `readOnly`, so a new cone that starts on a provider that isn't set up moves at once. The transcript pads its end, and its `scroll-padding-block-end`, by the composer's measured height, so at the bottom the last message sits above the composer and a focused element scrolls clear of it. While a reply streams, its status icon follows what it is doing: a pencil for an edit, a page for a read, a magnifier for a search, an eye for the browser and an hourglass for any other tool; thinking and text keep the AI logo. Between the header and the transcript, a `<slicc-notices>` shows the model's notices. On a follower without Control, or while the agent port's `readOnly()` returns a line, a note (`p[data-follow="watch"]`, that line first, else the follow-based one) takes the composer's place, the header shows the model's name instead of the pickers and New conversation, and there's no suggested follow-up. |
+| `<slicc-chat>` | One thread's conversation (its `agent`, or the active agent if unset), by day. A message's time shows only when it is at least two minutes newer than the last time shown, and the first one after each day separator always shows; a hidden time stays for screen readers (`time.sr` with `datetime`, or `.sr` on licks and cards), and a meta row left empty isn't rendered. User messages (with attachments and a quiet timestamp, `time.when`, by that rule; the reader's own carry no name or delivery tag, while `data-mode` and `data-delivered` still say how they went; a message from another cone, a follower or a guest says who sent it, and an agent's request carries its name and an Agent badge; a message from another agent, an agent's request or a message `from` a cone (`origin` `agent`, or `from` set without `origin` `follower` or `guest`), is `[data-remote]`: a subtle indigo bubble and a 🤖 pill on its bottom edge, `aria-hidden` since the byline names the sender; people, the reader included, never get it), assistant messages (with the time by that rule, and the model only on the first reply and whenever it changes from the previous one, `.meta .model` with the usage as its tooltip; without a model the usage is the time's tooltip, and with neither it is the reply's own (`.reply[title]`); the turn always carries the usage as its `aria-description`; the cone's name isn't repeated; Markdown with tables, task lists, quotes, code and images; thinking; tool runs, one icon per run (`<slicc-tool-runs>`): three or more runs in a row form a cluster, a strip of icon buttons (`data-action="open-run"`, `data-target` the call's id, named by its `title` and status, `aria-expanded`) that each open one run's card below it, and on the right the model's label for the run, a button (`data-action="open-cluster"`, `aria-expanded`, named "Show all runs" while it has no text) that opens every card; the strip's tooltip and the group's accessible name sum it up, such as "3 commands, 1 read. Done"; prose breaks a run, hidden thinking and source links don't, and a standalone tool message or a done reply with only tool calls continues the run before it on the same day, its `data-id` moving onto its first card (`.tool[data-id]`); a single run is a strip of one, its icon and its `title` as the label, which opens with <kbd>Enter</kbd> or <kbd>Space</kbd> like the strip's buttons. A strip and its cards share one width, the column less a wide margin on each side, so they read as centred, and their edges line up. Icons fill from the start of a space kept for five, so a run that grows doesn't move its strip or its label; past five, the strip shows the newest five and scrolls back to the older ones, with <kbd>Tab</kbd> or a swipe, and returns to the newest when a run is added or the strip comes back into view. The label sits at the end and is cut with an ellipsis before it reaches that space. Under 480 px of column width the label takes a row of its own under the icons, which then show as many whole icons as fit. A cluster's label comes from the agent port's optional `toolLabel(agentId, callIds)`, asked once for each agent port, agent and set of runs; while a growing run waits for its new label, it keeps its last one, and without `toolLabel` the label is empty. A command's icon is the favicon of the site it names when an open browser tab already has a `data:` favicon for it (nothing is fetched; otherwise the globe), else the file browser's icon for the file it names, else the code icon; other tools show their kind's icon. A running run pulses (still, with a dashed ring, under `prefers-reduced-motion`), a done or cancelled one is grey and a failed one red, each with a corner glyph. The card (`.tool[data-tool][data-status][data-kind]`, a `details.run` under a pill and a `div[role=region]` named by its `title` and status under a strip) has no header of its own, no chevron, title, tool name or status: its input (a shell command after `$`), an edit's `diff` shown as a diff view, its output wrapped rather than cut off, an `image`, such as a screenshot, an optional `meta` such as a timeout, a standalone tool message's time ("Ran at 16:12", `.ran`, by the two-minute rule), and its `notes` (`{ severity, text }`, such as "Exited with code 5" or "Full output in /tmp/…") as lines under the output, `li[data-note][data-severity]`: `error` with an alert icon in the negative colour, `warn` with an alert icon and `info` with an info icon, both subdued; media galleries with images, video and audio; action cards for tools, pull requests and status; plans and checklists; inline diffs; question prompts (as decision cards, below); delegations; link previews; errors with a fix-it action, as a grey card (`.error-card[role=alert]`, `data-id` on system errors) inset by a wide margin on each side, a narrower one under 480 px: a red alert icon, the title in bold, the detail subdued and the action on the right, or under the detail below 360 px, announced as "Error: " and the title; a content-filter stop offers **Drop the last turn**, which rewinds that turn and puts its prompt back into the composer; when the turns right before it failed too, the button reads **Drop N failed turns** and rewinds to before the first of them, putting the latest prompt back), system messages (error cards; compactions and notices, rewinds and model changes included, as full-width dividers with a line on each side, like the day: a compaction shows only its title, its `text` kept for screen readers, one that lost messages (`state: 'fallback'`, by default "Compaction failed, transcript truncated", or `discarded`, "Context discarded") an alert icon in the negative colour, and a notice its title and text on one line, `role="note"`; a divider that wraps keeps a short line on each side) and licks, SLICC's events into a cone, on every channel, on the right (`.lick-turn`): a byline with the title and the time by the two-minute rule, then a dashed box (`.lick[data-id][data-channel]`) with the text and the count (×3); emoji pills on its bottom edge (`.reactions .reaction`, `aria-hidden`, each named by its `title`) give the channel (⏰ Schedule, 🪝 Webhook, ✨ Sprinkle, …) and the outcome (👍 Allowed, 👎 Denied, also said in the box's hidden text). A lick with a body is a `details.lick` whose head (`summary.lick-head`, with a quiet chevron that turns when open) toggles it with a click, <kbd>Enter</kbd> or <kbd>Space</kbd>; clicking the body doesn't close it. A lick's `severity` (`warn` or `error`) adds an alert icon to its byline, a coloured edge to its box and a spoken prefix. Pending permission requests (`sudo-request` licks with `state: 'pending'`) and open questions are decision cards in the centre column (`.decision-turn[data-pending]`, `data-id` the lick's or the question's), inset like a tool cluster (a wide margin on each side, a narrower one under 480 px), with their buttons on the right: **Deny**, then **Allow** (`data-action` `deny` and `allow`), or the question's options. A request with `expiresAt` counts down as m:ss; the count is hidden from screen readers, which hear its end time, then "Less than a minute left" and "Timed out", so the log's live region doesn't speak every second; a timed-out request (`data-expired`) loses its buttons. While pending, cards stick to the top of the log and pile, each a step lower than the one before; a card behind the front one (`data-pinned`, `--depth`) is a little smaller and softer for each card in front of it, and the log's `scroll-padding` keeps the pile from covering whatever has focus. Clicking a piled card (not its controls), or <kbd>Enter</kbd> on it, scrolls it back to its place at the bottom of the chat, and focusing anything inside a covered card does the same. When a card leaves the pile (answered, timed out or decided elsewhere) while it has focus, focus moves to the next pending card, else the composer. Under `prefers-reduced-motion`, nothing animates: no transitions, and the scroll is instant. The header is one row: the status, a model picker that names each model's provider and leaves out classifiers and models with `tools: false` (with no model on offer, **Set up a model**, `data-action="set-up-model"`, opens Settings), the thinking picker, the context meter and **New conversation**, which calls `clear` and puts focus back in the composer; on a cone, when the port can freeze, its tooltip says the old conversation stays in the Freezer. It never wraps: when it's short of room, the model picker's label is cut with an ellipsis, and under 560px wide (`header[data-compact]`) New conversation is icon-only, with `accessible-label` and its tooltip. The pickers re-read `models()` on `settings`, `accounts` and `agents`. When a live agent's model, or `Settings.model`, is no longer offered and its provider (the id before `/`) isn't a connected account, it moves to the offered chat model with `default: true`, else the first one; frozen agents are left alone, and so is everything on a follower unless it has Control and is connected. The chat re-runs this on `follow` and `readOnly` too, and `<slicc-app>` does it as well, when it binds, on those events and on `follow` and `readOnly`, so a new cone that starts on a provider that isn't set up moves at once. The transcript pads its end, and its `scroll-padding-block-end`, by the composer's measured height, so at the bottom the last message sits above the composer and a focused element scrolls clear of it. While a reply streams, its status icon follows what it is doing: a pencil for an edit, a page for a read, a magnifier for a search, an eye for the browser and an hourglass for any other tool; thinking and text keep the AI logo. Between the header and the transcript, a `<slicc-notices>` shows the model's notices. On a follower without Control, or while the agent port's `readOnly()` returns a line, a note (`p[data-follow="watch"]`, that line first, else the follow-based one) takes the composer's place, the header shows the model's name instead of the pickers and New conversation, and there's no suggested follow-up. |
 | `<slicc-notices>` | The model's `notices` as in-line alerts with their actions and a close button (none with `dismissible: false`), after a banner from the `tabs` port when another tab is paused or runs a different SLICC, and a warning for each waiting approval when the `approvals` port has no `decide` (`[data-approval-notice]`); renders nothing without any. |
 | `<slicc-approvals>` | The model's waiting `approvals` as a modal alert dialog, one at a time, oldest first; `<slicc-app>` mounts it. Renders nothing without `approvals.decide`. A request that `secretRules()` flags shows a warning (`[data-secret-rules]`, the path or token) and no **Always allow (**Always allow in this directory**, with the cwd in its hint, when the approval has `alwaysScope: 'cwd'` and a `cwd`)**. Focus starts on Deny and goes back, after Deny, Always allow, Allow once, <kbd>Esc</kbd> or Close, to what had it when the dialog opened; inside a terminal, to that `<slicc-terminal>` through its own `focus()`, even when it remounted meanwhile. |
 | `<slicc-follow>` | The model's `follow` state. By default a header chip (`#chip[data-follow]` with the link state: **Connecting to**, **Following**, **Reconnecting to**, **Unlinked from** or **Can’t reach** the owner; `compact` keeps only a follow icon and the light) whose popover says what this device can do (`[data-can]`), that the conversation may be out of date while reconnecting, and with Control that sending waits (`[data-reconnecting]`), and has **Leave** (`data-action="leave"`, behind a confirm unless unlinked). With `page`, the full page for `connecting`, `waiting` (connected without View: "Waiting for {owner} to allow this device"), `unlinked` and `failed` (`[data-follow-page]`), with **Try again** (`data-action="retry"`) when failed and the port has `retry`, and **Leave**. A rejected call shows its message (`[data-error]`). Renders nothing without the port. |

package/dist/slicc-dummy.js

@@ -824,10 +824,10 @@ var DummyAgent = class extends Emitter {
     this.#messages.get(agentId)?.push(message);
     this.emit("message", { agentId, message });
   }
-  #status(agentId, status) {
+  #status(agentId, status2) {
     const agent = this.#agent(agentId);
-    if (!agent || agent.status === status) return;
-    agent.status = status;
+    if (!agent || agent.status === status2) return;
+    agent.status = status2;
     this.#changed();
   }
   #pace(agentId, steps) {
@@ -2241,6 +2241,95 @@ var welcome_default = `<!DOCTYPE html>
 </html>
 `;
 
+// src/dummy/status.ts
+var status = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Status</title>
+    <style>
+      * { box-sizing: border-box; margin: 0; padding: 0; }
+      body {
+        font-family: var(--s2-font-family, 'Adobe Clean', -apple-system, system-ui, sans-serif);
+        background: transparent;
+        color: var(--s2-content-default, #e8e8e8);
+        font-size: 14px;
+      }
+      .card {
+        display: grid;
+        gap: 12px;
+        padding: 8px 20px 12px;
+      }
+      .row { display: flex; align-items: center; gap: 10px; }
+      .dot {
+        flex: none;
+        width: 8px;
+        height: 8px;
+        border-radius: 50%;
+        background: var(--dot);
+      }
+      .name { flex: 1; font-weight: 600; }
+      .meta { font-size: 12px; color: var(--s2-content-subdued, #9a9a9a); }
+      .steps { list-style: none; display: grid; gap: 6px; }
+      .steps label { display: flex; align-items: center; gap: 8px; cursor: pointer; }
+      .actions { display: flex; justify-content: flex-end; gap: 8px; }
+      button {
+        font: inherit;
+        padding: 6px 12px;
+        border-radius: 999px;
+        border: 1px solid var(--s2-gray-400, rgba(128, 128, 128, 0.5));
+        background: transparent;
+        color: inherit;
+        cursor: pointer;
+      }
+      button.primary {
+        background: var(--s2-accent, #3b63fb);
+        border-color: transparent;
+        color: #fff;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <div class="row" style="--dot: #2d9d78">
+        <span class="dot"></span>
+        <span class="name">PR #58 \xB7 Add retries for upstream timeouts</span>
+        <span class="meta">4 of 4 checks</span>
+      </div>
+      <div class="row" style="--dot: #e68619">
+        <span class="dot"></span>
+        <span class="name">Visual regression suite</span>
+        <span class="meta">2 snapshots changed</span>
+      </div>
+      <div class="row" style="--dot: #2d9d78">
+        <span class="dot"></span>
+        <span class="name">Staging</span>
+        <span class="meta">/health answered in 2 ms</span>
+      </div>
+      <ul class="steps">
+        <li><label><input type="checkbox" checked /> TTL fix merged</label></li>
+        <li><label><input type="checkbox" /> Merge the retry pull request</label></li>
+        <li><label><input type="checkbox" /> Update the forecast docs to Celsius</label></li>
+        <li><label><input type="checkbox" /> Tag 1.9.0</label></li>
+      </ul>
+      <div class="actions">
+        <button type="button" data-action="review">Review snapshots</button>
+        <button type="button" class="primary" data-action="continue">Continue</button>
+      </div>
+    </div>
+    <script>
+      document.querySelector('.actions').addEventListener('click', function (event) {
+        var action = event.target.getAttribute('data-action');
+        if (!action || !window.slicc) return;
+        var done = document.querySelectorAll('.steps input:checked').length;
+        slicc.lick({ action: action, data: { done: done } });
+      });
+    <\/script>
+  </body>
+</html>
+`;
+
 // src/dummy/extras.ts
 var day = 864e5;
 var now = Date.UTC(2026, 9, 5, 9, 0);
@@ -2444,6 +2533,15 @@ var sprinkles = [
     icon: "ice-cream-cone",
     agentId: "cone-sliccy",
     html: suggestions_default
+  },
+  {
+    id: "status",
+    name: "status",
+    title: "Status",
+    icon: "list-checks",
+    agentId: "cone-kitchen",
+    html: status,
+    inline: true
   }
 ];
 var coneSprinkle = (agentId, name2, title, icon, body) => ({
@@ -2551,8 +2649,8 @@ var DummyFiles = class extends Emitter {
       this.#changes.delete(path);
       return;
     }
-    const status = before === null ? "added" : after === null ? "deleted" : "modified";
-    this.#changes.set(path, { path, status, before, after, agentId });
+    const status2 = before === null ? "added" : after === null ? "deleted" : "modified";
+    this.#changes.set(path, { path, status: status2, before, after, agentId });
   }
   #announce(path) {
     this.emit("files", this.#entries());
@@ -2917,7 +3015,7 @@ var licks = [
     "docs-pass",
     "Wants to push to example/harbor (branch docs/celsius)",
     "git push origin docs/celsius",
-    { state: "pending" }
+    { state: "pending", expiresAt: Date.now() + 10 * 6e4 }
   ],
   [
     "sudo-request",
@@ -3197,70 +3295,7 @@ function work() {
       model: "claude-sonnet-5-5",
       parts: [
         { type: "text", text: "Here is where things stand." },
-        {
-          type: "card",
-          card: {
-            variant: "pr",
-            number: 58,
-            title: "Add retries for upstream timeouts",
-            branch: "fix/retry-upstream",
-            checks: "4 of 4 checks passed",
-            additions: 42,
-            deletions: 7,
-            files: 3,
-            tone: "positive"
-          }
-        },
-        {
-          type: "card",
-          card: {
-            variant: "tool",
-            title: "Visual regression suite",
-            badge: "bash",
-            status: "2 snapshots changed",
-            files: ["forecast-card.png", "forecast-card-dark.png"],
-            tone: "notice"
-          }
-        },
-        {
-          type: "card",
-          card: {
-            variant: "light",
-            title: "Staging is healthy",
-            detail: "/health answered in 2 ms",
-            tone: "informative"
-          }
-        },
-        {
-          type: "plan",
-          items: [
-            "Merge the retry pull request",
-            "Move the cache to KV",
-            "Update the forecast docs to Celsius",
-            "Tag 1.9.0"
-          ]
-        },
-        {
-          type: "check",
-          items: [
-            { text: "TTL fix merged" },
-            { text: "Retries reviewed", tone: "informative" },
-            { text: "Docs pass running", tone: "notice" },
-            { text: "KV migration not started", tone: "negative" }
-          ]
-        },
-        {
-          type: "diff",
-          path: "/workspace/harbor/src/lib/units.ts",
-          before: "export function toCelsius(f: number): number {\n  return ((f - 32) * 5) / 9;\n}\n",
-          after: "export function toCelsius(f: number): number {\n  return Math.round(((f - 32) * 5) / 9);\n}\n"
-        },
-        {
-          type: "link",
-          url: "https://api.example.com/docs/v2/forecast",
-          title: "Forecast API reference",
-          description: "Parameters, units and rate limits for /v2/forecast."
-        },
+        { type: "sprinkle", sprinkle: "status" },
         {
           type: "delegation",
           kind: "scoop",
@@ -4373,7 +4408,7 @@ var DummyMonitor = class extends Emitter {
     const listed = agent.list();
     const agents2 = listed.filter((candidate) => candidate.kind === "cone").flatMap((cone) => [cone, ...listed.filter((candidate) => candidate.parentId === cone.id)]);
     const active = agents2.filter((candidate) => candidate.status !== "idle").length;
-    const status = tray2.status();
+    const status2 = tray2.status();
     const fill = Math.max(...agents2.map((candidate) => candidate.contextFill), 0);
     const rows = (id) => this.#extra.find((section) => section.id === id)?.rows;
     const tasks = rows("tasks");
@@ -4388,20 +4423,20 @@ var DummyMonitor = class extends Emitter {
     return {
       updatedAt: Date.now(),
       vitals: [
-        ...status.budget ? [
+        ...status2.budget ? [
           {
             id: "budget",
-            label: `Budget (${status.budget.window})`,
-            value: `${status.budget.percent}%`,
-            unit: status.budget.resets,
-            ratio: status.budget.percent / 100
+            label: `Budget (${status2.budget.window})`,
+            value: `${status2.budget.percent}%`,
+            unit: status2.budget.resets,
+            ratio: status2.budget.percent / 100
           }
         ] : [],
         {
           id: "spend",
           label: "Spend",
-          value: `$${(status.spent ?? 0).toFixed(2)}`,
-          delta: `$${(status.rate ?? 0).toFixed(2)}/h`,
+          value: `$${(status2.spent ?? 0).toFixed(2)}`,
+          delta: `$${(status2.rate ?? 0).toFixed(2)}/h`,
           series: wave(this.#tick + 7)
         },
         {
@@ -4457,10 +4492,10 @@ var DummyMonitor = class extends Emitter {
           detail: "Compact it soon to keep replies fast.",
           severity: "warn"
         })),
-        ...status.connection === "live" ? [] : [
+        ...status2.connection === "live" ? [] : [
           {
             id: "tray",
-            title: `Tray ${status.connection}`,
+            title: `Tray ${status2.connection}`,
             detail: "Followers can\u2019t see this session.",
             severity: "error"
           }
@@ -4499,7 +4534,7 @@ var DummyMonitor = class extends Emitter {
         {
           id: "followers",
           label: "Tray followers",
-          rows: status.followers.map((follower) => ({
+          rows: status2.followers.map((follower) => ({
             name: follower.name,
             meta: follower.device,
             status: "active"
@@ -4864,11 +4899,11 @@ var DummyNetwork = class extends Emitter {
     this.#base = networkFixtures(scenario);
     this.#status = this.#with(this.#base);
   }
-  #withLeaders(status) {
+  #withLeaders(status2) {
     const leaders = this.#leaders;
-    if (!leaders) return status;
+    if (!leaders) return status2;
     this.#leaders = leaders.filter((leader) => leader.state !== "unlinked");
-    return { ...status, leaders };
+    return { ...status2, leaders };
   }
   #leader(id, change) {
     this.#leaders = this.#leaders.map((leader) => {
@@ -4892,15 +4927,15 @@ var DummyNetwork = class extends Emitter {
     this.#leaders = this.#leaders.filter((leader) => leader.id !== id);
     this.#emit();
   }
-  #with(status) {
-    return this.#withLeaders(this.#withLinks(status));
+  #with(status2) {
+    return this.#withLeaders(this.#withLinks(status2));
   }
-  #withLinks(status) {
+  #withLinks(status2) {
     const links = this.#links;
-    if (!links) return this.#withTailnet(status);
+    if (!links) return this.#withTailnet(status2);
     const exit = this.#exit;
-    const direct = status.route === "link" && exit?.kind !== "link";
-    const base = direct ? { ...status, route: "page", detail: null, browser: { via: null } } : status;
+    const direct = status2.route === "link" && exit?.kind !== "link";
+    const base = direct ? { ...status2, route: "page", detail: null, browser: { via: null } } : status2;
     const linked = { ...base, links, exit };
     const device = exit?.kind === "link" ? links.devices.find((item) => item.id === exit.id) : void 0;
     const browsing = links.devices.some(
@@ -4912,18 +4947,18 @@ var DummyNetwork = class extends Emitter {
     if (!device) return routed;
     return { ...routed, health: device.state === "connected" ? "ok" : "failing", detail: null };
   }
-  #withTailnet(status) {
+  #withTailnet(status2) {
     const tailnet = this.#tailnet;
-    if (!tailnet) return status;
+    if (!tailnet) return status2;
     const exit = tailnet.state === "running" ? tailnet.exitNode : null;
-    if (!exit) return { ...status, tailnet };
+    if (!exit) return { ...status2, tailnet };
     return {
-      ...status,
+      ...status2,
       route: "tailnet",
       health: "ok",
       detail: `${exit} carries everything except this computer\u2019s own services.`,
       tailnet,
-      exit: this.#links ? status.exit : null
+      exit: this.#links ? status2.exit : null
     };
   }
   #set(tailnet) {
@@ -5495,10 +5530,10 @@ var DummyTray = class extends Emitter {
   #status;
   #followers;
   #clock;
-  constructor(status, clock2) {
+  constructor(status2, clock2) {
     super();
-    this.#status = structuredClone(status);
-    this.#followers = structuredClone(status.followers);
+    this.#status = structuredClone(status2);
+    this.#followers = structuredClone(status2.followers);
     this.#clock = clock2;
   }
   status() {
@@ -6217,7 +6252,7 @@ function vaultFixtures(scenario, now2 = Date.now()) {
   const empty = scenario === "empty";
   const policy = scenario === "policy" || scenario === "notice";
   const backup = scenario === "backup";
-  const status = {
+  const status2 = {
     version: "0.1.0",
     protocol: 1,
     origin: "https://vault.sliccy.ai",
@@ -6242,7 +6277,7 @@ function vaultFixtures(scenario, now2 = Date.now()) {
       restricted: secrets.flatMap(({ name: name2, exits }) => exits ? [{ name: name2, exits }] : [])
     }
   };
-  return { status, list };
+  return { status: status2, list };
 }
 var labels2 = {
   unlock: "Unlock the vault",
@@ -6328,8 +6363,8 @@ var DummyVault = class extends Emitter {
   acknowledged = [];
   constructor(scenario, time, records = []) {
     super();
-    const { status, list } = vaultFixtures(scenario);
-    this.#status = status;
+    const { status: status2, list } = vaultFixtures(scenario);
+    this.#status = status2;
     this.#list = { ...list, secrets: [...list.secrets, ...records] };
     this.#time = time;
     this.#available = scenario === "waiting" ? "waiting" : "ready";
@@ -6656,8 +6691,8 @@ function createDummyModel({
       vault: new DummyVault(vault, time, accounts2 === "vault" ? accountRecords() : [])
     }
   };
-  base.vault?.on("status", (status) => {
-    if (!status.locked && agent.hold()?.reason === "locked") agent.setHold(null);
+  base.vault?.on("status", (status2) => {
+    if (!status2.locked && agent.hold()?.reason === "locked") agent.setHold(null);
   });
   return {
     ...base,