@phnx-labs/agents-cli 1.20.84 → 1.20.86

package/CHANGELOG.md

@@ -1,5 +1,103 @@
 # Changelog
 
+## 1.20.86
+
+- **`agents sessions` now shows a Kimi session's todo list and its file-touching
+  tool calls.** Kimi writes its checklist with `TodoList` (items shaped
+  `{title, status}`, where finished is `done`) rather than Claude's `TodoWrite`
+  (`{content, status: "completed"}`), so the checklist registry matched nothing
+  and every Kimi session rendered with no todos — in the picker preview, the
+  session detail, and the `--active` fan-out that carries progress off remote
+  devices. Kimi also names the file argument `path` where Claude names it
+  `file_path`, so `Read`/`Write`/`Edit` calls summarized as a bare `Read ` with
+  no file. Both spellings are now handled, and the snapshot-checklist tool names
+  live in one exported registry (`SNAPSHOT_TODO_TOOLS`) that the picker and the
+  state engine share instead of each hardcoding its own pair. Source:
+  `apps/cli/src/lib/session/parse.ts`, `apps/cli/src/lib/session/state.ts`,
+  `apps/cli/src/commands/sessions-picker.ts`.
+
+- **`agents view` now shows Grok's default model (e.g. `grok-4.5`).** Claude,
+  Codex, Antigravity, and Kimi already filled the model column via their
+  catalogs; Grok was missing from `locateModelSource`, so
+  `resolveConfiguredModel` returned null and the column stayed blank. Grok has
+  no `settings.json` `model` field (its config is `config.toml` +
+  `models_cache.json`); the authoritative default is `grok models` →
+  `Default model: <id>`. The catalog extractor now spawns that command against
+  the version-home binary (skipping failed-download stubs) and flags the
+  default, so `agents view`, `agents view --json` (`configuredModel`), and the
+  other identity-cluster surfaces show it. Source: `apps/cli/src/lib/models.ts`,
+  `apps/cli/src/commands/models.ts`.
+
+- **`agents events --limit 0` now reads the whole stream, and a capped read says
+  so.** `--limit` parsed as `Math.max(1, parseInt(raw) || 50)`, so `--limit 0`
+  collapsed back to `50` (`0 || 50`) and there was no way to read past the default
+  cap at all. The cap is applied after filtering and before the caller sees
+  anything, so every aggregation over `--json` silently ranked the newest 50
+  records instead of the matching set — measured against a real 7-day corpus of
+  2,135 CLI failures in 9 classes, 8 of 9 ranks came out wrong with counts off by
+  roughly 100x, and nothing warned. `--limit 0` now means no cap (29,649 records
+  on a 30-day stream here, against 50 before), a truncated read prints
+  `Showing the newest 50 — more events matched. Pass --limit 0 for all.` (on
+  stderr under `--json`, so a `| jq` pipeline still receives clean JSON), and a
+  non-numeric, negative, or empty `--limit` exits 2 rather than quietly becoming
+  50 — an empty one (`--limit "$LIMIT"` with the variable unset) would otherwise
+  have read as "no cap" and returned the whole stream unannounced.
+  Source: `apps/cli/src/commands/events.ts`, `apps/cli/tests/events-limit.test.ts`,
+  `apps/cli/docs/06-observability.md`.
+
+- **Desktop notifications now show the current agents-cli mark, not the old
+  logo.** The menu-bar helper's app icon — the icon macOS puts on the left of
+  every notification banner it posts (the menu bar helper's own notices and every
+  `agents run --notify` finish notice) — was generated from the retired gradient
+  "A" logo, so notifications carried stale branding while the menu-bar status
+  item already used the new lowercase `a`. The shared master logo
+  (`assets/logo.png`) is now the current `a` mark, so the menu-bar helper, the
+  `agents computer` helper, and the keychain helper all regenerate their
+  `AppIcon.icns` from it on the next build. Source: `assets/logo.png`,
+  `apps/cli/menubar/scripts/build.sh`.
+
+## 1.20.85
+
+- **`agents feed post` can now be mirrored to the systems you actually watch.**
+  A post was durable but local: an operator away from every terminal never saw
+  it, and the tracker that owns the work heard nothing. Declare sinks under
+  `feed.broadcast` in `agents.yaml` — argv templates, not built-in integrations —
+  and each post is fanned out to them. `--level important` marks a post worth
+  interrupting someone over, so a sink with `minLevel: important` never fires on
+  a routine "CI green"; a template referencing `{ticket}` is skipped when no
+  ticket is known, and the ticket is joined from the session index rather than
+  asked for as a flag. `{message}` composes the human line a messaging sink wants
+  — `<project> · <text>` plus the first attached URL — so an out-of-band ping
+  leads with the project and carries a clickable link. Delivery is best-effort
+  and reported per sink; a mirror that fails never costs you the post. Source:
+  `apps/cli/src/lib/feed-broadcast.ts`, `apps/cli/src/commands/feed.ts`,
+  `apps/cli/docs/06-observability.md`.
+
+- **`agents feed --filter updates` now shows the progress posts agents actually
+  wrote, across the fleet.** The view read the most recent N activity events and
+  *then* kept `status.posted`, so routine `file.edited` churn filled the whole
+  slice — a box with six real posts rendered "0 posts" (and `--json` returned one
+  of six). `readRecentActivity` gained `events` / `tier` filters that apply before
+  the limit, so the limit counts posts; the same fix restores the milestone lane
+  under `agents feed`. The updates view also fans out over SSH like the block view
+  (`-H/--host`, `--device`, `--local` to opt out), because an agent posts on
+  whichever box ran it. Source: `apps/cli/src/lib/activity.ts`,
+  `apps/cli/src/commands/feed.ts`.
+
+- **`agents run --notify` posts a desktop notification when a headless run
+  finishes, and menu-bar quick dispatch now uses it.** The dispatch panel used to
+  post its "finished"/"failed" notice from the MenubarHelper's own
+  process-termination callback, so a helper that restarted mid-run — an upgrade
+  replacing the bundle, a crash — took the callback with it while the run carried
+  on reparented to launchd, and the dispatch could never report back. The run
+  process owns the notice now: armed on its own `exit`, so it covers local,
+  `--host` and `--lease` dispatch alike and survives anything that happens to the
+  launcher. The helper's click actions also accept `url:<https…>` so a completion
+  notification can open the PR or ticket the run produced. Source:
+  `apps/cli/src/lib/run-notify.ts`, `apps/cli/src/commands/exec.ts`,
+  `apps/cli/menubar/Sources/MenubarHelper/AgentsCLI.swift`,
+  `apps/cli/menubar/Sources/MenubarHelper/PromptPanel.swift`.
+
 ## 1.20.84
 
 - **Agent onboarding cheat sheet and docs drift guard.** Added

package/dist/commands/events.d.ts

@@ -14,4 +14,20 @@
  * today's operational log live.
  */
 import type { Command } from 'commander';
+/**
+ * Resolve `--limit` into a record cap. `0` means "no cap" — without it there is
+ * no way to read the whole stream, and any aggregation (group-by failure, count
+ * per module) silently ranks the newest 50 records instead of the real set.
+ * A non-numeric or negative value is a usage error, not a quiet fallback.
+ */
+export declare function resolveEventsLimit(raw: string | undefined): number | undefined;
+/**
+ * Cap `fetched` (read with `limit + 1`) to `limit`, reporting whether records
+ * were dropped. The caller announces the cap so a truncated read is never
+ * mistaken for the complete set.
+ */
+export declare function capRecords<T>(fetched: T[], limit: number | undefined): {
+    records: T[];
+    truncated: boolean;
+};
 export declare function registerEventsCommand(program: Command): void;

package/dist/commands/events.js

@@ -17,6 +17,33 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import { getLogsPath } from '../lib/events.js';
 import { readUnifiedEvents } from '../lib/event-stream.js';
+/**
+ * Resolve `--limit` into a record cap. `0` means "no cap" — without it there is
+ * no way to read the whole stream, and any aggregation (group-by failure, count
+ * per module) silently ranks the newest 50 records instead of the real set.
+ * A non-numeric or negative value is a usage error, not a quiet fallback.
+ */
+export function resolveEventsLimit(raw) {
+    const token = raw ?? '50';
+    // Number('') and Number('   ') are both 0, which would read as "no cap" — an
+    // empty --limit (an unset "$LIMIT" in a script) must be rejected, not silently
+    // turned into the unbounded read.
+    const value = token.trim() === '' ? NaN : Number(token);
+    if (!Number.isInteger(value) || value < 0) {
+        throw new RangeError(`Invalid --limit ${raw} — pass a whole number, or 0 for no cap.`);
+    }
+    return value === 0 ? undefined : value;
+}
+/**
+ * Cap `fetched` (read with `limit + 1`) to `limit`, reporting whether records
+ * were dropped. The caller announces the cap so a truncated read is never
+ * mistaken for the complete set.
+ */
+export function capRecords(fetched, limit) {
+    if (limit === undefined || fetched.length <= limit)
+        return { records: fetched, truncated: false };
+    return { records: fetched.slice(0, limit), truncated: true };
+}
 /** Parse `--since`: relative offsets (30s/5m/2h/7d/4w) or an ISO/absolute date. */
 function parseSince(s) {
     const m = s.match(/^(\d+)([smhdw])$/);
@@ -80,7 +107,7 @@ export function registerEventsCommand(program) {
         .option('--agent <name>', 'Only events tagged with this agent')
         .option('--since <time>', 'Only events newer than this (e.g. 2h, 7d, or ISO date)')
         .option('--audit', 'Operational events only (skip agent activity)')
-        .option('--limit <n>', 'Max records to show (default 50)', '50')
+        .option('--limit <n>', 'Max records to show; 0 for no cap (default 50)', '50')
         .option('--json', 'Output raw records as JSON')
         .option('-f, --follow', "Tail today's operational log live")
         .addHelpText('after', `
@@ -90,31 +117,41 @@ Examples:
   agents events --audit                  Operational events only (secrets / teams / ...)
   agents events --event pr.opened --since 7d
   agents events --module secrets         Every secret accessed or revealed
-  agents events -f                       Live tail (operational)`)
+  agents events -f                       Live tail (operational)
+  agents events --event pr.opened --since 30d --limit 0 --json
+                                         Every match — use --limit 0 whenever you
+                                         aggregate, or you rank only the newest 50`)
         .action(async (options) => {
         if (options.follow) {
             await followLog();
             return;
         }
-        const limit = Math.max(1, parseInt(options.limit ?? '50', 10) || 50);
+        let limit;
         let startDate;
         try {
+            limit = resolveEventsLimit(options.limit);
             startDate = options.since ? parseSince(options.since) : undefined;
         }
         catch (err) {
             console.error(chalk.red(err.message));
             process.exit(2);
         }
-        const records = readUnifiedEvents({
+        // Read one past the cap so we can tell a full result from a clipped one.
+        const fetched = readUnifiedEvents({
             startDate,
             eventTypes: options.event && options.event.length ? options.event : undefined,
             agent: options.agent,
             command: options.command,
             module: options.module,
-            limit,
+            limit: limit === undefined ? undefined : limit + 1,
             includeActivity: !options.audit,
         });
+        const { records, truncated } = capRecords(fetched, limit);
+        const capNote = `Showing the newest ${limit} — more events matched. Pass --limit 0 for all.`;
         if (options.json) {
+            // Notice goes to stderr so `--json | jq` still receives clean JSON.
+            if (truncated)
+                console.error(chalk.yellow(capNote));
             console.log(JSON.stringify(records, null, 2));
             return;
         }
@@ -126,6 +163,8 @@ Examples:
         for (const r of records.slice().reverse())
             console.log(renderRow(r));
         console.log(chalk.gray(`\n${records.length} event(s). Log: ${getLogsPath()}`));
+        if (truncated)
+            console.log(chalk.yellow(capNote));
     });
 }
 /** commander repeatable-option collector. */

package/dist/commands/exec.js

@@ -367,6 +367,7 @@ export function registerRunCommand(program) {
         .option('--resume [id]', 'Resume a previous conversation. Accepts a full or partial session id (prefix-matched against the index); omit the id to pick from recent sessions interactively. Resumes under the version that started the session. claude/codex resume natively; other agents replay via a /continue first message. Pair with a prompt to continue headlessly.')
         .option('--session-id <id>', 'Force a NEW conversation to use this exact session UUID (Claude only). This CREATES a session — to resume an existing one, use --resume.')
         .option('--name <slug>', 'Name the run — seeds the session label so it shows up as `<name>` in `agents sessions` and resolves by it (and `agents hosts logs <name>` for --host runs) instead of an opaque id. An agent-generated title later refines the label; your name shows until then. Optional.')
+        .option('--notify', 'Post a desktop notification when a headless run finishes. Fired by this process on exit, so it survives whatever launched the run (the menu bar dispatching it, a terminal you closed).')
         .option('--verbose', 'Show detailed execution logs')
         .option('--raw', 'Interactive runs on macOS/Linux launch inside a shared tmux session (for %pane addressing + re-attach). Pass --raw to spawn the agent directly instead. Also disabled by AGENTS_NO_TMUX=1.')
         .option('--no-tmux', 'Spawn the agent directly instead of wrapping it in the shared tmux session. Same effect as --raw / AGENTS_NO_TMUX=1. Use this to see the agent\'s full startup output when a launch is failing.')
@@ -492,6 +493,20 @@ export function registerRunCommand(program) {
             // a native flag, not a prompt. Run interactively.
             prompt = undefined;
         }
+        // --notify: post a desktop notification when this run finishes. Armed on
+        // process exit so it covers EVERY dispatch path below (local, --host,
+        // --lease, the error path) instead of one branch. Only for headless runs
+        // — an interactive run ends in front of the person who started it.
+        if (options.notify && prompt !== undefined) {
+            const { armRunFinishNotification } = await import('../lib/run-notify.js');
+            armRunFinishNotification({
+                agent: agentSpec,
+                name: options.name,
+                prompt,
+                cwd: options.cwd ?? process.cwd(),
+                host: options.host,
+            });
+        }
         // A trailing @ is an explicit request to choose one installed account.
         // Strip only that terminal marker; concrete agent@version pins retain
         // their existing meaning in every dispatch path below.

package/dist/commands/feed.js

@@ -1,7 +1,10 @@
 import chalk from 'chalk';
 import { ensureFeedPublishHook, listAskStats, listBlocks, recordNotified } from '../lib/feed.js';
-import { ensureActivityLogHook, readRecentActivity, formatActivityLine, formatProgressUpdate } from '../lib/activity.js';
+import { ensureActivityLogHook, readRecentActivity, formatActivityLine, formatProgressUpdate, mergeActivityEvents, parseActivityPayload, } from '../lib/activity.js';
 import { postFeedStatus } from '../lib/feed-post.js';
+import { parseFeedPostLevel, planFeedBroadcast, runFeedBroadcast, } from '../lib/feed-broadcast.js';
+import { getSessionById } from '../lib/session/db.js';
+import { readMeta } from '../lib/state.js';
 import { enrichBlocksFromSessions, groupBlocksByOutcome, isUnambiguousOutcomeAnswer, openBlocksForOutcome, stampBlockOutcomes, } from '../lib/feed-outcome.js';
 import { classifyBlock, filterBlocksForFeed, suppressionDigest, } from '../lib/ask-classifier.js';
 import { machineId, normalizeHost } from '../lib/machine-id.js';
@@ -234,6 +237,7 @@ export function registerFeedCommand(program) {
         .argument('<text...>', 'What just happened — one short human line')
         .option('--session <id>', 'Session id escape hatch (default: auto from env / pid registry)')
         .option('--attach <path-or-url...>', 'Attach an artifact (local file or URL); repeatable')
+        .option('--level <level>', 'How loudly to broadcast: milestone (default) or important. Configured sinks with minLevel: important only fire on the latter.', 'milestone')
         .option('--json', 'Emit the written event as JSON')
         .addHelpText('after', `
 Examples:
@@ -242,11 +246,19 @@ Examples:
   agents feed post "cover render ready" --attach ./out/cover.png
   agents feed post "ready for review" --json
 
+  # Worth interrupting someone over — reaches sinks gated on minLevel: important:
+  agents feed post "release blocked: npm token expired" --level important
+
   # Outside a run, pass the session explicitly:
   agents feed post "manual note" --session 00998b0e-2d15-4d2f-a58b-974a886c9b47
 
 Identity (session, agent, host, runtime, pid, launchId) is stamped automatically.
-Domain facts (tickets, PRs) are not CLI flags — join them on the session at read time.
+Domain facts (tickets, PRs) are not CLI flags — the ticket is joined from the
+session index at post time, so a broadcast sink can comment on it without the
+agent having to remember it.
+
+Configure where a post is mirrored under feed.broadcast in agents.yaml — see
+docs/06-observability.md.
 `)
         .action((textParts, opts, cmd) => {
         // Parent `feed` also declares `--json` (for the list view). Commander
@@ -255,19 +267,23 @@ Domain facts (tickets, PRs) are not CLI flags — join them on the session at re
         const flags = {
             session: opts?.session ?? cmd?.opts?.()?.session,
             attach: opts?.attach ?? cmd?.opts?.()?.attach,
+            level: opts?.level ?? cmd?.opts?.()?.level,
             json: Boolean(opts?.json ?? cmd?.opts?.()?.json ?? cmd?.parent?.opts?.()?.json),
         };
         try {
+            const level = parseFeedPostLevel(flags.level);
             const { event } = postFeedStatus({
                 text: Array.isArray(textParts) ? textParts.join(' ') : String(textParts ?? ''),
                 sessionId: flags.session,
                 attach: flags.attach,
             });
+            const outcomes = broadcastPostedEvent(event, level);
             if (flags.json) {
-                console.log(JSON.stringify(event, null, 2));
+                console.log(JSON.stringify(outcomes.length ? { ...event, broadcast: outcomes } : event, null, 2));
                 return;
             }
             console.log(formatProgressUpdate(event));
+            reportBroadcast(outcomes);
         }
         catch (err) {
             console.error(chalk.red(err.message));
@@ -305,20 +321,39 @@ Domain facts (tickets, PRs) are not CLI flags — join them on the session at re
                 }
             }
         }
-        // Updates view: deliberate progress posts only, over the local activity
-        // timeline (blocks are decisions, not announcements). Short-circuit the
-        // whole block pipeline — no remote fan-out, no dispatch policy.
+        // Trailing lane under the block views: `--filter all` appends the same
+        // fleet-wide updates section, anything else the compact local lane.
+        const renderTrailingActivity = async () => {
+            if (filter === 'all') {
+                console.log();
+                renderUpdatesView(await gatherStatusPosts({
+                    limit: UPDATES_VIEW_LIMIT, hosts: opts.host, local: opts.local, includeLocal, self,
+                }));
+                return;
+            }
+            if (includeLocal)
+                renderActivityLane();
+        };
+        // Updates view: deliberate progress posts only (blocks are decisions, not
+        // announcements). Short-circuits the block pipeline — no dispatch policy —
+        // but fans out like the block view, because a post lands on whichever box
+        // ran the agent.
         if (filter === 'updates') {
             for (const warning of setupWarnings) {
                 console.error(chalk.yellow(`Feed hook setup warning: ${warning}`));
             }
+            const updates = await gatherStatusPosts({
+                limit: opts.json ? UPDATES_JSON_LIMIT : UPDATES_VIEW_LIMIT,
+                hosts: opts.host,
+                local: opts.local,
+                includeLocal,
+                self,
+            });
             if (opts.json) {
-                const updates = readRecentActivity({ sinceMs: Date.now() - 7 * 24 * 60 * 60 * 1000, limit: 100 })
-                    .filter((e) => e.event === 'status.posted');
                 console.log(JSON.stringify(updates, null, 2));
                 return;
             }
-            renderUpdatesView();
+            renderUpdatesView(updates);
             return;
         }
         // Active sessions feed both the GC sweep and outcome enrichment (ticket/PR).
@@ -428,14 +463,7 @@ Domain facts (tickets, PRs) are not CLI flags — join them on the session at re
         }
         if (blocks.length === 0) {
             console.log(chalk.gray(digest ? 'No open blocks after stall suppression.' : 'No open blocks.'));
-            if (includeLocal) {
-                if (filter === 'all') {
-                    console.log();
-                    renderUpdatesView();
-                }
-                else
-                    renderActivityLane();
-            }
+            await renderTrailingActivity();
             return;
         }
         // Shared fleet-comms masthead (same family as `agents mailboxes`).
@@ -458,16 +486,45 @@ Domain facts (tickets, PRs) are not CLI flags — join them on the session at re
         });
         for (const g of groups)
             renderOutcomeGroup(g, self);
-        if (includeLocal) {
-            if (filter === 'all') {
-                console.log();
-                renderUpdatesView();
-            }
-            else
-                renderActivityLane();
-        }
+        await renderTrailingActivity();
     });
 }
+/**
+ * Mirror a written post to the configured sinks (`feed.broadcast` in
+ * agents.yaml). The ticket is JOINED from the session index rather than asked
+ * for as a flag — it is a domain fact about the session, and an agent that has
+ * to remember a `--ticket` argument is an agent that will forget it. Returns the
+ * per-sink outcomes; an empty array means nothing is configured, which is the
+ * default and is not a failure.
+ */
+function broadcastPostedEvent(event, level) {
+    const config = readMeta().feed?.broadcast;
+    if (!config || Object.keys(config).length === 0)
+        return [];
+    const ticket = getSessionById(event.sessionId)?.ticketId;
+    const planned = planFeedBroadcast(config, {
+        text: event.detail ?? '',
+        level,
+        ticket,
+        project: event.project,
+        agent: event.agent,
+        host: event.host,
+        session: event.sessionId,
+        links: (event.attachments ?? [])
+            .map((a) => a.href)
+            .filter((href) => /^https?:\/\//i.test(href)),
+    });
+    return runFeedBroadcast(planned);
+}
+/** One line per sink that ran. Silent when nothing is configured. */
+function reportBroadcast(outcomes) {
+    for (const o of outcomes) {
+        if (o.ok)
+            console.log(chalk.gray(`  → ${o.name}`));
+        else
+            console.error(chalk.yellow(`  → ${o.name} failed: ${o.error}`));
+    }
+}
 /** Normalize a raw --filter value; unknown/empty falls back to the default. */
 export function resolveFeedFilter(raw) {
     const v = (raw ?? '').trim().toLowerCase();
@@ -490,15 +547,59 @@ function renderActivityEntry(ev) {
         console.log(formatActivityLine(ev, { showHost: true }));
     }
 }
+/** How far back the updates view looks for deliberate progress posts. */
+const UPDATES_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+/** Posts kept per machine in the rendered view / the `--json` payload. */
+const UPDATES_VIEW_LIMIT = 30;
+const UPDATES_JSON_LIMIT = 100;
+/**
+ * The most recent `limit` deliberate progress posts on THIS machine, newest
+ * first. The event filter is pushed into the reader so `limit` counts posts —
+ * slicing first and filtering after returned an empty view on a busy box, where
+ * routine `file.edited` hook events fill the whole slice.
+ */
+function readStatusPosts(limit) {
+    return readRecentActivity({
+        sinceMs: Date.now() - UPDATES_WINDOW_MS,
+        limit,
+        events: ['status.posted'],
+    });
+}
+/**
+ * Progress posts across the fleet, newest first. An agent posts on whichever
+ * box it runs on, so a local-only read shows the operator a fraction of what
+ * the fleet reported. Peers are dialed with the same SSH fan-out the block view
+ * uses; `--local` (or the no-fanout env guard on a peer) keeps it to this box.
+ */
+async function gatherStatusPosts(opts) {
+    const local = opts.includeLocal ? readStatusPosts(opts.limit) : [];
+    const forceLocal = opts.local === true || process.env[FEED_NO_FANOUT_ENV] === '1';
+    if (forceLocal)
+        return local;
+    const remoteHosts = opts.hosts?.length ? remoteFeedHostsToDial(opts.hosts, opts.self) : undefined;
+    if (opts.hosts?.length && (!remoteHosts || remoteHosts.length === 0))
+        return local;
+    const remote = await gatherRemoteAgentsJson({
+        args: ['feed', '--filter', 'updates', '--json'],
+        noFanoutEnv: FEED_NO_FANOUT_ENV,
+        hosts: remoteHosts,
+        parse: parseActivityPayload,
+    });
+    return mergeActivityEvents(local, remote.items).slice(0, opts.limit);
+}
 /**
  * Render the **Updates** view: deliberate progress posts only (`status.posted`),
  * recency-ordered, with rich identity chips. Pure `file.edited` / git-hook noise
  * is excluded so operators see announcements, not tool churn.
  */
-function renderUpdatesView(limit = 30) {
-    const updates = readRecentActivity({ sinceMs: Date.now() - 7 * 24 * 60 * 60 * 1000, limit })
-        .filter((e) => e.event === 'status.posted');
-    console.log(masthead({ title: 'updates', accent: 'cyan', host: machineId(), right: `${updates.length} post${updates.length === 1 ? '' : 's'}` }));
+function renderUpdatesView(updates) {
+    const hosts = new Set(updates.map((e) => e.host).filter(Boolean));
+    console.log(masthead({
+        title: 'updates',
+        accent: 'cyan',
+        host: hosts.size > 1 ? `${hosts.size} machines` : (updates[0]?.host ?? machineId()),
+        right: `${updates.length} post${updates.length === 1 ? '' : 's'}`,
+    }));
     console.log();
     if (updates.length === 0) {
         console.log(chalk.gray('  No progress updates yet. Agents post them with `agents feed post "…"`.'));
@@ -516,8 +617,11 @@ function renderUpdatesView(limit = 30) {
  * when empty.
  */
 function renderActivityLane(limit = 6) {
-    const events = readRecentActivity({ sinceMs: Date.now() - 24 * 60 * 60 * 1000, limit })
-        .filter((e) => e.tier === 'milestone');
+    const events = readRecentActivity({
+        sinceMs: Date.now() - 24 * 60 * 60 * 1000,
+        limit,
+        tier: 'milestone',
+    });
     if (events.length === 0)
         return;
     console.log(chalk.bold('\n  recent activity'));

package/dist/commands/models.js

@@ -13,7 +13,7 @@ import { listInstalledVersions, getGlobalDefault, resolveVersion, resolveVersion
 import { getModelCatalog, locateModelSource } from '../lib/models.js';
 import { terminalWidth, truncateToWidth, stringWidth } from '../lib/session/width.js';
 import { wrapJoined } from './inspect.js';
-const MODEL_CAPABLE_AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'openclaw', 'antigravity', 'kimi'];
+const MODEL_CAPABLE_AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'openclaw', 'antigravity', 'kimi', 'grok'];
 /**
  * Agents that don't necessarily install under ~/.agents/versions (cursor ships
  * via a curl script). For these, fall back to the PATH binary and synthesize

package/dist/commands/sessions-picker.js

@@ -9,7 +9,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
-import { parseSession, sanitizeForTerminal } from '../lib/session/parse.js';
+import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '../lib/session/parse.js';
 import { cleanSessionPrompt, extractSessionTopic } from '../lib/session/prompt.js';
 import { linkPath, linkUrl, relativeToCwd, shortenModel } from '../lib/session/render.js';
 import { linearIssueUrl } from '../lib/session/linear.js';
@@ -312,9 +312,10 @@ function formatCompactPreview(events, session) {
             if (!planFile && p && /\/plans\/[^/]+\.md$/.test(p)) {
                 planFile = p;
             }
-            // Claude TodoWrite (`todos`) and Codex update_plan (`plan`) — same source as
-            // extractTodoProgress in the state engine. Prefer the most recent write.
-            if (tool === 'TodoWrite' || tool === 'update_plan') {
+            // Every harness's checklist-snapshot tool (Claude TodoWrite, Kimi TodoList,
+            // Codex update_plan, …) — the same registry the state engine folds through
+            // extractTodoProgress. Prefer the most recent write.
+            if (SNAPSHOT_TODO_TOOLS.has(tool)) {
                 const progress = extractTodoProgress(event.args);
                 if (progress)
                     latestTodos = progress;

package/dist/lib/activity.d.ts

@@ -105,6 +105,14 @@ export interface RecentActivityOptions {
     root?: string;
     /** Per-session tail budget in bytes. */
     maxBytesPerSession?: number;
+    /**
+     * Only include these event names. Applied BEFORE `limit`, so asking for a
+     * rare event (a deliberate `status.posted`) returns that many of it instead
+     * of however many survive a slice dominated by routine `file.edited` churn.
+     */
+    events?: string[];
+    /** Only include events in these tiers. Applied BEFORE `limit`, as `events` is. */
+    tier?: ActivityTier;
 }
 /**
  * Merge recent events across every session's log, newest first. Reads only the

package/dist/lib/activity.js

@@ -194,9 +194,14 @@ export function listActivitySessions(root) {
 export function readRecentActivity(opts = {}) {
     const dir = opts.root ?? getActivityDir();
     const sinceMs = opts.sinceMs ?? 0;
+    const wanted = opts.events && opts.events.length > 0 ? new Set(opts.events) : null;
     const all = [];
     for (const sessionId of listActivitySessions(dir)) {
         for (const ev of readSessionActivity(sessionId, dir, opts.maxBytesPerSession)) {
+            if (wanted && !wanted.has(ev.event))
+                continue;
+            if (opts.tier && ev.tier !== opts.tier)
+                continue;
             const t = Date.parse(ev.ts);
             if (Number.isFinite(t) && t >= sinceMs)
                 all.push(ev);

package/dist/lib/feed-broadcast.d.ts

@@ -0,0 +1,66 @@
+/** How loudly a post asks to be heard. Ordered — `important` implies milestone. */
+export type FeedPostLevel = 'milestone' | 'important';
+/** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
+export declare function parseFeedPostLevel(raw: string | undefined): FeedPostLevel;
+export interface FeedSinkConfig {
+    /**
+     * argv to run, with `{placeholder}` tokens substituted. First element is the
+     * program; it is spawned directly (no shell), so quoting is not a concern and
+     * post text can never become shell syntax.
+     */
+    command: string[];
+    /** Lowest post level that reaches this sink. Defaults to `milestone` (all posts). */
+    minLevel?: FeedPostLevel;
+}
+/** `feed.broadcast` in agents.yaml — sink name → what to run. */
+export type FeedBroadcastConfig = Record<string, FeedSinkConfig>;
+/** Everything a template may interpolate. Absent values skip templates that need them. */
+export interface FeedBroadcastContext {
+    /** The post text, verbatim. */
+    text: string;
+    level: FeedPostLevel;
+    /** Tracker id for the work, e.g. `RUSH-2081`. */
+    ticket?: string;
+    /** Repo/project the post came from. */
+    project?: string;
+    agent?: string;
+    host?: string;
+    session?: string;
+    /** URLs attached to the post — the PR, the ticket, a shared plan. */
+    links?: string[];
+}
+export interface PlannedSink {
+    name: string;
+    argv: string[];
+}
+export interface SinkOutcome {
+    name: string;
+    ok: boolean;
+    /** stderr tail when the sink failed, for the warning line. */
+    error?: string;
+}
+/**
+ * A human-facing one-liner for a messaging sink: what project, what happened,
+ * and the link to go read more. Leading with the project is deliberate — a
+ * message that opens with an agent name tells the reader nothing about which of
+ * their projects just moved.
+ */
+export declare function composeBroadcastMessage(ctx: FeedBroadcastContext): string;
+/**
+ * Substitute `{placeholder}` tokens in an argv template. Returns undefined when
+ * the template needs a value this post does not have — the sink is then skipped
+ * rather than run with an empty argument, which is how a `linear update --comment`
+ * would otherwise comment on nothing.
+ */
+export declare function renderSinkArgv(template: string[], ctx: FeedBroadcastContext): string[] | undefined;
+/**
+ * Which sinks this post reaches, in config order. Pure — the dry-run listing and
+ * the real fan-out plan through here, so what `--dry-run` shows is what runs.
+ */
+export declare function planFeedBroadcast(config: FeedBroadcastConfig | undefined, ctx: FeedBroadcastContext): PlannedSink[];
+/**
+ * Run the planned sinks. Each is a direct spawn with a bounded lifetime; a sink
+ * that fails or is not installed is reported, never thrown — the post is already
+ * written and must not be undone by a mirror that could not be reached.
+ */
+export declare function runFeedBroadcast(planned: PlannedSink[], timeoutMs?: number): SinkOutcome[];