@phnx-labs/agents-cli 1.20.93 → 1.21.1

package/CHANGELOG.md

@@ -1,5 +1,295 @@
 # Changelog
 
+## 1.21.1
+
+- **Feed posts require a title + body; phone `{message}` ends with a Sent-from footer.** `agents feed post --title "Short subject" "body text"` — title is the phone first line (~4–5 words), body follows after a blank line, then `Sent from <agent>/<session-chunk> on <host>` (like "Sent from my iPhone"). Em/en dashes in title/body are scrubbed to ASCII ` - `. Source: `apps/cli/src/lib/feed-broadcast.ts`, `feed-post.ts`, `commands/feed.ts`.
+
+- **Hook `timeout` in agents.yaml now accepts duration strings, not just bare seconds (#1555).**
+  A hook can be written `timeout: 5s` / `timeout: 2m` / `timeout: 1h30m` instead of only
+  `timeout: 30` — self-documenting at the call site. A bare number still means seconds, so
+  every existing manifest keeps working. `parseHookManifest` normalizes the value to a
+  seconds number once, so all harness serializers keep consuming a number; an unparseable
+  timeout is dropped with a warning rather than silently coerced. Source:
+  `apps/cli/src/lib/hooks.ts` (`normalizeHookTimeoutSeconds`, `parseHookManifest`),
+  `apps/cli/docs/hooks.md`.
+
+- **Owner notifications route through the one channel seam.** The feed urgent-block
+  dispatch and the monitor `notify` action now send through the registered channel
+  provider (`lookupTransport` → `ChannelProvider.send`) instead of shelling out to
+  `openclaw` directly. The recipient comes from `notify.owner` in agents.yaml — the
+  hardcoded owner chat id is gone, so changing `notify.owner` is honoured by every
+  path. A bare `--notify` on a monitor now targets `notify.owner`; `--notify <channel>`
+  overrides the owner channel. The monitor path also gains the provider's missing-binary
+  guard (a clean error instead of a raw ENOENT). A channel name that resolves to no
+  registered provider (a typo in `notify.owner.channel`, or `--notify <channel>`) fails
+  that one send with a clean error — it does not exit the monitor daemon or abort the
+  `agents feed --dispatch` loop. Source: `apps/cli/src/lib/notify.ts`,
+  `apps/cli/src/lib/monitors/dispatch.ts`, `apps/cli/src/lib/channels/resolve.ts`.
+
+## 1.21.0
+
+- **A clone of your own DotAgents repo no longer hijacks project-layer rule resolution (RUSH-2037).**
+  Cloning `~/.agents` to the canonical `~/src/github.com/<you>/.agents` path (to edit
+  rules in an editor) made that checkout eligible as a *project* layer whenever you
+  worked from its parent directory. Because project outranks user, a stale clone's
+  `rules/subrules/*` then silently shadowed the live user rules by filename, and the
+  compile planted an out-of-date `AGENTS.md` in an ancestor dir that every session
+  beneath it ingested. Project-layer discovery now identifies a DotAgents repo by
+  **repo identity** (git origin), not path: a `.agents/` that is itself a git checkout
+  whose origin matches the user's or system's DotAgents repo is skipped, so the live
+  user layer wins. Legitimate project `.agents/` layers (a plain subdirectory of a
+  project, or a git repo with an unrelated origin) are unaffected.
+  Source: `apps/cli/src/lib/state.ts`.
+
+- **`agents sessions --local` no longer dials remote-host teammates over ssh,
+  in the default listing or `--active` (RUSH-2118).** `--local` is supposed to
+  mean this-machine-only, but the underlying `AgentManager` poll still fired a
+  real ssh round-trip for every teammate dispatched via
+  `agents teams add --device` — even a teammate that had already finished.
+  On a box with 30 completed remote-host teammates that measured out to 180
+  real `ssh` execve calls (6 per teammate: two ssh calls in
+  `syncRemoteMirror`, run three times per poll) and a ~4.3s
+  `--active --local` call. A `--local` query now reads a remote-host
+  teammate's last-persisted `meta.json` state instead of dialing it, and a
+  teammate that has already reached a terminal status (completed/failed/
+  stopped) is never re-dialed by ANY `--active` query, local or not — its
+  final log bytes and exit code were already captured on the poll that
+  resolved it. The same gate now covers every `--local` surface: the bare
+  default listing's live-glyph enrichment (`maybeLiveIndex`) and `--preview`
+  (`renderSessionPreview`, freely combinable with `--local`) both called the
+  local-only `getActiveSessions()` with no `localOnly` threaded through,
+  despite the `--local` help text already promising this-machine-only for
+  all of them. Source: `apps/cli/src/lib/teams/agents.ts`
+  (`syncRemoteMirror`, `readNewEvents`, `updateStatusFromProcess`,
+  `AgentManager`), `apps/cli/src/lib/session/active.ts` (`listTeamsActive`,
+  `getActiveSessions`), `apps/cli/src/commands/sessions.ts`
+  (`gatherActiveSessions`, `maybeLiveIndex`, `renderSessionPreview`).
+
+- **A rules preset now applies at `agents run` time, not only after `agents
+  rules switch` (RUSH-2128).** `setActiveRulesPreset` used to take effect only on the next
+  explicit `agents rules switch`/`agents add`/`agents use` — a preset change
+  made any other way left the harness launching against a stale rules file
+  until someone remembered to re-sync. `agents run` now re-applies the active
+  preset for the resolved agent+version immediately before dispatch, every
+  time, with a skip-fast sentinel so an unchanged preset costs no recompose or
+  rewrite. Version-scoped only; per-model preset scoping is a follow-up.
+  Source: `apps/cli/src/lib/rules/run-sync.ts`, `apps/cli/src/commands/exec.ts`.
+
+- **Activity events now carry the same actor and session lineage as operational events.**
+  The TypeScript activity writer and the embedded PostToolUse hook stamp actor kind,
+  launch id, and parent session id from the shared execution provenance floor, so
+  `agents events` no longer invents an agent name as the activity record's OS user.
+  Source: `apps/cli/src/lib/event-provenance.ts`, `apps/cli/src/lib/activity.ts`.
+
+- **`agents view` no longer re-scans every installed Claude binary on each run.**
+  When a Claude model extractor produced zero models (a broken regex, or a
+  mid-install CLI), the result was never cached — so `getModelCatalog` re-ran a
+  full `readFileSync` scan of the 230-270MB Claude binary for every affected
+  installed version, on every invocation (~1.85s each). With 4 affected
+  versions installed, that was ~7.5s added to every `agents view`. A 0-model
+  extraction is now cached too, stamped with when it was attempted, and served
+  for 24 hours before self-healing by retrying; an upgrade/reinstall (a new
+  source mtime) still re-extracts immediately, as before. Measured on a real
+  install with 7 Claude versions (4 of them hitting the broken extractor): the
+  cold first-call cost (~12.5s, unavoidable) drops to ~1-2ms on every
+  subsequent call. Source: `apps/cli/src/lib/models.ts`.
+
+- **Per-device and fleet-wide config keys now have a home: the `config:` block in
+  the two-tier agents.yaml store.** Three new subcommands under `agents devices`
+  (no new top-level noun): `agents devices set-interactive <name>` records the one
+  device agents show YOU artifacts on (browser opens, dashboards) as
+  `config.interactiveHost` in the central, synced agents.yaml — skills no longer
+  guess "the online macOS box", and the host is marked `★ interactive` in
+  `agents devices list`. `agents devices configure <name> --max-agents N
+  --scheduler on|off` and `agents devices note <name> "…"` (repeat
+  to append, `--clear` to empty) write device-scope keys under `config:` in
+  `~/.agents/devices/<name>/agents.yaml` — targetable for any device from any box
+  (the devices/ tree syncs; each machine reads only its own). The default browser
+  profile joins the same registry as `browser.profile`, routed to the existing
+  device-local `defaultBrowserProfile` field (no duplicate key, resolution order
+  unchanged). Unset keys always mean today's behavior; everything is scriptable
+  with `--json`, and `devices list --json` now carries each row's `config` and an
+  `interactive` flag. agents.yaml files the CLI writes now carry a
+  `yaml-language-server` hint pointing at the new
+  `apps/cli/schema/agents-yaml.schema.json`.
+
+  The keys are live inputs, not just stored values. `--scheduler off` stops the
+  routines scheduler from starting on that device — `routines add` skips the
+  auto-start with the reason, a manual `routines start` refuses, and the daemon
+  re-evaluates the gate on every SIGHUP reload (boot it again with
+  `agents devices configure <host> --scheduler on` + any reload, no daemon
+  restart). `--max-agents` feeds host ranking: Factory auto-launch excludes a
+  device at its cap (counting device-wide running agents) and names the cap when
+  a pool is exhausted; teams placement excludes it from the least-loaded
+  auto-pick (counting the team's own roster, local teammates included) and an
+  all-capped pool fails loud instead of over-filling a machine. Setup asks
+  instead of guessing: bare `agents setup` ends with a skippable preferences
+  step (which machine you sit at → interactive host; which browser agents drive
+  here → device default), `agents setup fleet` offers the interactive host after
+  a sync, and the `agents setup browser` picker highlights the auto-detect
+  winner. Source: `apps/cli/src/lib/device-config.ts`,
+  `apps/cli/src/lib/state.ts`, `apps/cli/src/lib/daemon.ts`,
+  `apps/cli/src/lib/teams/scheduler.ts`, `apps/cli/src/commands/ssh.ts`,
+  `apps/cli/src/commands/setup-preferences.ts`,
+  `apps/factory/src/core/launchHost.ts`,
+  `apps/cli/schema/agents-yaml.schema.json`.
+
+- **Mailbox messages now expire and dead boxes are reaped automatically.** Messages
+  enqueued without an explicit TTL used to sit in the spool forever, so pending mail
+  would outlive the session that needed it. They now get a 24-hour default TTL
+  (`AGENTS_MAILBOX_TTL` overrides the default; `agents message … --ttl 2h` sets it
+  per message). When a message expires, a live-but-idle box archives it with a
+  `dropped: expired` receipt. The watchdog tick also runs a liveness sweep using the
+  same live-session set as `agents sessions --active`, archiving pending mail in dead
+  boxes as `dropped: dead` and pruning stale consumed entries. Dropped messages tied
+  to a feed block surface a failure receipt (`status: dropped` / `expired`) so the
+  sender sees the bounce instead of silence. Run the sweep manually with
+  `agents mailboxes gc` (`--json` supported). Source:
+  `apps/cli/src/lib/mailbox.ts`, `apps/cli/src/lib/mailbox-gc.ts`,
+  `apps/cli/src/commands/message.ts`, `apps/cli/src/commands/mailboxes.ts`,
+  `apps/cli/src/commands/watchdog.ts`, `apps/cli/src/lib/feed.ts`.
+
+- **The menu-bar helper can no longer leak CLI processes until the machine is unusable.**
+  Its poll shelled `agents doctor --json` through an unbounded `Process` +
+  `readDataToEndOfFile()`. Two properties composed badly: the call had no deadline
+  (`doctor --json` measures **136s on an idle box**, against a 60s poll interval), and a
+  helper that died mid-call left the child reparented to launchd (PPID 1) with nothing
+  to reap it — along with the `node -e` version probes that child had forked. Both fire
+  together, because the helper crashes under exactly the conditions that make the CLI
+  slow: `NSApplication.shared` segfaults inside `SLSNewConnection` when WindowServer is
+  too starved to hand out a connection, launchd's `KeepAlive` restarts it, and the
+  restart spawns a new doctor while the old one keeps burning a core. Observed on a real
+  machine: 38 orphaned doctors + 92 orphaned probes, ~13 of 18 cores consumed, load
+  average 490, keystrokes visibly lagging.
+  The crash itself cannot be prevented from inside the app — it is AppKit dereferencing
+  a null connection before any of our code runs — so a crash no longer costs anything
+  permanent: every child carries a deadline (30s; 180s for `doctor --json`, above its
+  real measured cost); it is spawned as its own process-group leader so a timeout kills
+  the whole subtree rather than just the CLI; and each live child is recorded on disk so
+  the *next* launch reaps whatever a crash abandoned (no exit handler runs on SIGSEGV).
+  The doctor refresh also drops from every 60s to every 15 minutes, and the launchd job
+  gains `ThrottleInterval` 30 so a startup crash-loop cannot respawn every 10s.
+  A poll that blows its deadline now shows a stale menu instead of taking the machine
+  down with it. Source: `apps/cli/menubar/Sources/MenubarHelper/ChildProcess.swift`,
+  `AgentsCLI.swift`, `StatusItemController.swift`, `main.swift`,
+  `apps/cli/src/lib/menubar/install-menubar.ts`.
+
+- **The macOS menu-bar helper is now notarized, ending the "app is damaged"
+  dialog and the per-run `no valid code signature; skipping launch` spam
+  (RUSH-2134).** The helper shipped Developer-ID signed but *not* notarized, so
+  Gatekeeper on macOS 26+ rejected it as damaged and the install path tried to
+  heal it by re-signing ad-hoc on every `agents` invocation — which can never
+  satisfy Gatekeeper, so the dialog and the noise persisted. The release now
+  notarizes + staples the helper (`menubar/scripts/build.sh`, mandatory for any
+  Developer-ID build, run under the release's `agents secrets exec apple.com`
+  context), the `prepack` gate refuses to pack an un-notarized bundle
+  (`scripts/verify-menubar-helper.sh` now requires a stapled ticket), and the
+  runtime ad-hoc re-sign band-aid is deleted — a notarized + stapled bundle
+  survives npm's tarball round-trip untouched, so the helper launches with no
+  per-machine healing. The launch guards now verify Gatekeeper acceptance (not
+  just `codesign --verify`) and fail loud pointing at an upgrade rather than
+  re-signing over it. Source: `apps/cli/menubar/scripts/build.sh`,
+  `apps/cli/scripts/verify-menubar-helper.sh`, `apps/cli/scripts/release.sh`,
+  `apps/cli/src/lib/menubar/install-menubar.ts`.
+
+- **`agents projects import` gains Linear as a source, and gates the Factory guess.**
+  `import --from-linear` turns the workspace's Linear projects into definitions via the
+  `linear` CLI, binding a local checkout only on an exact name match so it never
+  silently points a project at the wrong repo. `--from-factory` now imports only
+  `high`-confidence rows by default (`--min-confidence low|medium|high`, `--all` to
+  take everything), and prints why each row was skipped — the auto-detected registry
+  used to absorb every stale clone it found. Source: `apps/cli/src/lib/project-import.ts`.
+- **`agents projects list` columns line up again.** Widths are computed from the rows
+  being printed instead of a fixed 32-character path pad that every home-relative root
+  ran straight through. Source: `apps/cli/src/commands/projects.ts`.
+
+- **`agents projects status` shows the next Linear milestone.** A new `next` line names
+  the project's earliest unfinished milestone with its progress and a human due date
+  (`Beta cut · 3/8 · due in 6 days`, `overdue by 3 days`, `due Aug 21`) — a percentage
+  says how far along a project is, the milestone says what it is due to hit next. The
+  milestone list comes from the project rather than from issue assignments, so a
+  milestone with nothing filed under it yet still shows; it rides along on the first
+  page of the existing issue fetch, costing no extra request. Source:
+  `apps/cli/src/lib/linear-project-counts.ts`.
+
+- **`agents publish --branch <b>` now pushes the index to `<b>`, not just the printed URL (#1061).**
+  The flag rewrote the printed `raw.githubusercontent.com/.../<b>/skills-index.json`
+  URL, but the commit still landed on the checked-out branch — so `--branch dev` from a
+  `main` checkout published the index to `main` while advertising a `dev` URL that didn't
+  resolve. `commitAndPush` now takes an optional target branch and pushes
+  `<current>:<target>`, reporting back the branch the index actually landed on so the URL
+  references it. Omitting `--branch` still publishes to the repo's current branch.
+  Source: `apps/cli/src/lib/git.ts` (`commitAndPush`, `pushOrigin`, `getCurrentBranch`),
+  `apps/cli/src/commands/packages.ts`.
+
+- **Remove the unused `agents hq` command.** `agents hq floor --json` was a
+  machine-readable bridge for an interactive Agents HQ floor UI that was never
+  built — `apps/factory` has zero references to it and it had no other consumer.
+  Typing `agents hq` now prints a clear removal notice and exits non-zero instead
+  of silently disappearing. Source: `apps/cli/src/index.ts`,
+  `apps/cli/src/lib/startup/command-registry.ts` (removed
+  `apps/cli/src/commands/hq.ts`, `apps/cli/src/lib/hq/`).
+
+- **Removed `agents drive` and the R2/CRDT background session-sync beta.** Both
+  predate `agents sessions export`/`import`, which now cover the same ground
+  without a daemon: `agents drive` (rsync-based session/config mirroring) and
+  the opt-in `session-sync` beta (`agents sessions sync`, the daemon's ~90s R2
+  push/pull loop, `agents sync --sessions`) are gone. If you had `session-sync`
+  or `drive` enabled, re-enable is no longer possible — use `--host` for live
+  cross-machine reads or `agents sessions export --encrypt` /
+  `agents sessions import` for portable, encrypted transcript bundles instead.
+  The R2 network client and CRDT merge machinery are removed entirely with the
+  rest of the background sync. Export/import's own encrypted-bundle path
+  survives unchanged: it never talked to R2 over the network — it only reuses
+  the `r2.backups` bundle's shared `R2_SYNC_ENC_KEY` for local AES-256-GCM
+  encryption, falling back to a printed ephemeral key when that bundle isn't
+  configured. Source: `apps/cli/src/commands/drive.ts`,
+  `apps/cli/src/commands/sessions-sync.ts`, `apps/cli/src/lib/session/sync/crdt.ts`,
+  `apps/cli/src/lib/session/sync/sync.ts`, `apps/cli/src/lib/session/sync/r2.ts`,
+  `apps/cli/src/lib/daemon.ts`.
+
+- **A routine that fires less often than weekly can now be caught up at all.** Overdue
+  detection walked a fixed one-week window for the most recent expected fire, so any cron whose
+  gap exceeds that returned nothing and the routine was skipped entirely — never flagged
+  overdue on any device, never caught up, no `missed` record, silently. Monthly, semi-monthly,
+  quarterly and annual routines were all in that class. Measured on a real schedule
+  (`0 9 1,13,25 * *`, 12-day gaps): on **10 of every 28 days** the routine could not be
+  evaluated. The lookback now widens (week → month → quarter → year) only when the narrower
+  window finds nothing, so a dense schedule never walks more than a week of occurrences.
+- **Catch-up no longer resurrects a retired routine.** `detectOverdueJobs` never checked
+  `endAt`, and the scheduler only auto-disables lazily inside a live cron tick — so a routine
+  whose `endAt` elapsed while the daemon was down was still enabled on disk, rescheduled on
+  restart, and executed by the catch-up pass.
+- **One-shot detection matches the scheduler's.** Overdue used the raw `runOnce` flag while the
+  scheduler uses `isOneShotRoutine`, so a one-shot-*like* schedule (a fixed minute/hour/day/
+  month) that never carried the flag could be replayed by catch-up.
+- **The creation floor now covers built-in routines.** `routineEffectiveStart` resolved a
+  routine's file through a user-layer-only lookup, but `listJobs` reads the system layer too —
+  so a built-in shipped in the system repo had neither a `createdAt` stamp nor a resolvable
+  path, the floor was skipped, and it read as instantly overdue on first daemon start. Added
+  `resolveJobFilePath`, which resolves across every layer the loader reads.
+- **A `createdAt` in the future is clamped to now.** Left unclamped (clock skew, a hand-edited
+  year) it sits after every possible expected fire, so the routine could never be flagged
+  overdue until wall-clock time caught up.
+
+- **A routine now runs on exactly one device, instead of once per device listed.** `devices:`
+  was an allowlist where *every* listed device fired independently, so a routine pinned to two
+  boxes ran twice on every schedule — two full agent sessions doing identical work and burning
+  double the agent quota. On one live fleet seven routines were in that state: `security-sweep`
+  ran at 15:30:02 on one box and 15:30:03 on the other, both completing. Ownership is now a pure
+  function of the config (the first device in normalized sort order), so every daemon reaches the
+  same answer with no lease, no cross-device coordination, and no split brain when the fleet
+  partitions. Omitting `devices` still means fleet-wide, which is what `watchdog` and
+  `check-updates` want.
+- **`agents routines add --devices a,b` and `devices --set a,b` are now rejected.** A routine
+  belongs to one machine; the error names the fix. Routines already on disk with a multi-device
+  pin keep running — on their owner only — rather than being dropped.
+- **`agents doctor` lists any routine still carrying a multi-device pin**, with the devices it
+  names, the one that now fires, and the command to make it explicit. Also in `doctor --json` as
+  `ambiguousDevicePins`. The remediation deliberately offers the candidates rather than
+  prescribing the owner: the lowest-sorted name can be a registry alias that matches no live
+  machine, and cementing that would keep the routine dead.
+
 ## 1.20.93
 
 - **`agents send` is a real delivery envelope; `notify` is just `--to owner` (RUSH-2123).** Flag-first form: `--to`, `--text`, `--channel`, `--attach`, `--url`. `--to owner` expands from `notify.owner` in agents.yaml. Positional text still works. Help names the three planes (deliver / record / control) so send is not confused with `feed post`, `activity`, or `message`/`sessions inject`. Source: `apps/cli/src/commands/send.ts`, `apps/cli/src/lib/channels/send.ts`.

package/README.md

@@ -341,7 +341,7 @@ agents feed --flat                  # one row per agent (legacy)
 agents feed --host mac-mini         # scope the view to one or more hosts
 agents feed --local                 # skip the SSH fan-out
 agents feed --json                  # blocks stamped with their outcome key
-agents feed post "halfway done"     # agent status post (auto session identity)
+agents feed post --title "Halfway done" "CI green, watching merge"  # title + body
 ```
 
 Top-level questions and waiting notifications publish one atomic open-block record per session, including the mailbox id, host, runtime, and every answer option. The default view collapses agents under the **outcome** they serve (Linear ticket, PR, worktree slug, or Unassigned) so a 1,100-agent fleet reads as dozens of deliverables. Answered, resumed, and stopped blocks clear automatically; Task subagents are excluded. The rendered reply command uses the same mailbox id with `agents message`, so the decision routes back to the agent that asked it.
@@ -476,6 +476,9 @@ agents devices list                     # fleet + headroom: load, mem, idle/busy
 agents devices list --live              # force a live probe of every device (alias of --refresh)
 agents devices list --full              # add per-device cores and free/total RAM
 agents devices list --no-stats          # instant: names/addresses only, skip the probe
+agents devices set-interactive zion     # the device agents show YOU artifacts on (★ in the list)
+agents devices configure mac-mini --max-agents 4 --scheduler off   # per-device config (syncs via devices/<name>/agents.yaml)
+agents devices note mac-mini "runs the releases — don't reboot"    # operator notes, repeat to append
 agents ssh mac-mini                     # hardened SSH: fails fast if offline,
                                         # PowerShell on Windows, password-from-Keychain,
                                         # auto-syncs your terminfo (Ghostty/kitty/…) so

package/dist/commands/beta.js

@@ -1,9 +1,7 @@
 import chalk from 'chalk';
 import { ALL_BETA_FEATURES, getBetaConfigLocation, getEnabledBetaFeatures, setBetaEnabled, } from '../lib/beta.js';
 const BETA_DESCRIPTIONS = {
-    drive: 'Google Drive integration for reading and writing files',
     factory: 'Cloud-based agent dispatch via Rush Factory',
-    'session-sync': 'Cross-machine session transcript sync via R2 (daemon push/pull)',
     projects: 'Named multi-repo projects with a progress rollup (agents projects)',
 };
 function parseFeatures(values) {
@@ -19,12 +17,12 @@ function parseFeatures(values) {
 export function registerBetaCommands(program) {
     const beta = program
         .command('beta')
-        .description('Enable or disable preview features like drive and factory.')
+        .description('Enable or disable preview features like factory.')
         .addHelpText('after', `
 Examples:
   agents beta list
-  agents beta enable drive factory
-  agents beta disable drive
+  agents beta enable factory
+  agents beta disable factory
 `);
     beta
         .command('list')

package/dist/commands/doctor.js

@@ -13,6 +13,7 @@ import { resolveHost } from '../lib/hosts/registry.js';
 import { sshExecAsync } from '../lib/ssh-exec.js';
 import { sshTargetFor } from '../lib/hosts/types.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
+import { findAmbiguousDevicePins } from '../lib/routines.js';
 import chalk from 'chalk';
 import { checkAllClis, collectTeamsDoctorData } from '../lib/teams/agents.js';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError, getAccountInfo } from '../lib/agents.js';
@@ -1298,6 +1299,10 @@ export function registerDoctorCommand(program) {
             const inventory = await collectLocalFleetInventory(cwd);
             const localName = machineId();
             const duplicateHooks = inspectDuplicateVersionHooks(cwd);
+            // A routine belongs to one device. A multi-device pin used to fire it
+            // once per listed device — duplicate agent runs, duplicate spend — so
+            // surface any that are still on disk with the exact fix.
+            const ambiguousPins = findAmbiguousDevicePins(cwd);
             // Legacy account-global sign-in map, kept for `--json` back-compat
             // (ssh.ts RemoteDoctorJson / menubar read `signIn`). File-based, no home.
             const signIn = {};
@@ -1361,6 +1366,9 @@ export function registerDoctorCommand(program) {
                     // reading `sync`/`orphans`/`repos` are unaffected.
                     health: computeOverviewHealth(syncRows, orphanRows, repoBehindMarkers, duplicateHooks),
                     duplicateHooks,
+                    // Routines whose `devices` names more than one machine — each used to
+                    // fire once per device. `owner` is the one that fires now.
+                    ambiguousDevicePins: ambiguousPins,
                     // Prioritized RUSH-2069 findings (critical/warning, per-version, with
                     // remediation). Additive alongside the legacy fields above.
                     findings,
@@ -1404,6 +1412,21 @@ export function registerDoctorCommand(program) {
             if (syncRows.some((r) => r.status !== 'fresh' || (r.unwiredHooks ?? 0) > 0) || repoBehindMarkers.some((m) => m.behind > 0)) {
                 console.log(chalk.gray('\nRun `agents status` to review and sync what has drifted.'));
             }
+            // A routine runs on exactly one device. Each of these named several and
+            // used to fire once per device — duplicate agent runs on every schedule.
+            if (ambiguousPins.length > 0) {
+                console.log();
+                console.log(chalk.yellow(`${ambiguousPins.length} routine(s) pin more than one device — a routine runs on exactly one:`));
+                for (const pin of ambiguousPins) {
+                    console.log(`  ${chalk.cyan(pin.name)} ${chalk.gray(`[${pin.devices.join(', ')}]`)} ` +
+                        `${chalk.gray('→ fires only on')} ${pin.owner}`);
+                    // Deliberately not prescribing `--set ${pin.owner}`: ownership is the
+                    // lowest-sorted name, which can be a registry alias that matches no
+                    // live machine (`worker` here), and cementing that keeps the routine
+                    // dead. Name the candidates and let the operator pick the real box.
+                    console.log(chalk.gray(`      fix: agents routines devices ${pin.name} --set <${pin.devices.join('|')}>`));
+                }
+            }
             return;
         }
         const parsed = parseTargetArg(target);

package/dist/commands/exec.js

@@ -23,6 +23,7 @@ import * as os from 'os';
 import { spawnSync } from 'child_process';
 import { randomUUID } from 'crypto';
 import { isSessionTrackedAgent } from '../lib/session/types.js';
+import { applyActiveRulesPresetAtRun } from '../lib/rules/run-sync.js';
 /** Distinguish a terminal account-picker marker from an explicit @version pin. */
 export function parseRunAccountPickerRequest(agentSpec) {
     const requested = agentSpec.endsWith('@');
@@ -1978,6 +1979,18 @@ export function registerRunCommand(program) {
             }
         }
         const defaultVersion = version ?? resolveVersion(agent, cwd);
+        // Re-apply the active rules preset before every launch (issue: preset
+        // changes via `setActiveRulesPreset` only took effect after an explicit
+        // `agents rules switch` / `agents sync`). Version-scoped, skip-fast when
+        // nothing changed — see lib/rules/run-sync.ts. Placed here (immediately
+        // after the resolved version is known, before ACP/loop/fallback branch
+        // off) so every downstream dispatch path for this agent+version sees a
+        // fresh rules file, not just the plain execAgent path. `defaultVersion`
+        // is null when nothing is installed yet — execAgent handles that error
+        // path itself; there's no version home to sync into.
+        if (defaultVersion) {
+            applyActiveRulesPresetAtRun(agent, defaultVersion, getVersionHomePath(agent, defaultVersion));
+        }
         // Login preflight (advisory, warn + continue). On a local INTERACTIVE
         // launch, probe whether this agent's account has a credential and print a
         // one-line warning if it looks logged out — so you find out BEFORE the TUI

package/dist/commands/feed.js

@@ -234,44 +234,44 @@ export function registerFeedCommand(program) {
     feed
         .command('post')
         .description('Post a status update to the fleet activity stream (for agents)')
-        .argument('<text...>', 'What just happened — one short human line')
+        .argument('<text...>', 'Body: what just happened (after --title)')
+        .requiredOption('--title <title>', 'Short subject, ~4-5 words (phone first 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('--blocked', 'You are STUCK and need the user. Opens an answerable block and always broadcasts at important — do not also pass --level.')
+        .option('--blocked', 'You are STUCK and need the user. Opens an answerable block and always broadcasts at important - do not also pass --level.')
         .option('--option <label...>', 'With --blocked: an answer the user can pick; repeatable')
         .option('--default <answer>', 'With --blocked: a safe default policy may apply if nobody answers in time')
         .option('--json', 'Emit the written event as JSON')
         .addHelpText('after', `
 Examples:
-  # Inside an agents-cli run (session identity is already in the env):
-  agents feed post "CHANGELOG pushed; watching CI and mac-mini E2E"
-  agents feed post "cover render ready" --attach ./out/cover.png
-  agents feed post "ready for review" --json
+  # Title (subject) + body. Phone broadcasts put title first, body after a
+  # blank line, then a "Sent from agent/session on host" footer.
+  agents feed post --title "CHANGELOG pushed" "Watching CI and mac-mini E2E"
+  agents feed post --title "Cover ready" "render at ./out/cover.png" --attach ./out/cover.png
+  agents feed post --title "Ready for review" "PR opened, waiting on prix-cloud" --json
 
-  # Worth interrupting someone over — reaches sinks gated on minLevel: important:
-  agents feed post "release blocked: npm token expired" --level important
+  # Worth interrupting someone over - reaches sinks gated on minLevel: important:
+  agents feed post --title "npm token expired" "Cannot publish the release" --level important
 
-  # You are STUCK and cannot proceed. Opens an answerable block that stays in
-  # 'agents feed' until someone resolves it, and always reaches the owner —
-  # do NOT also pass --level:
-  agents feed post "force-push denied by git-guard on PR #1749" --blocked
-  agents feed post "publish to npm or wait for review?" --blocked --option publish --option wait
-  agents feed post "delete the stale preview env?" --blocked --default "leave it"
+  # Stuck: opens a needs-you block and always broadcasts at important:
+  agents feed post --title "Force-push denied" "git-guard blocked PR #1749" --blocked
+  agents feed post --title "Publish or wait?" "npm publish now or after review" --blocked --option publish --option wait
+  agents feed post --title "Delete preview env?" "stale preview still running" --blocked --default "leave it"
 
   # Exhaust self-serve FIRST. A block is for what you genuinely cannot do:
   # a credential only the user holds, a decision only they can make, an
   # approval only they can give. Not "should I do the obvious next step?".
 
   # Outside a run, pass the session explicitly:
-  agents feed post "manual note" --session 00998b0e-2d15-4d2f-a58b-974a886c9b47
+  agents feed post --title "Manual note" "context for the next agent" --session 00998b0e-2d15-4d2f-a58b-974a886c9b47
 
-Identity (session, agent, host, runtime, pid, launchId) is stamped automatically.
-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.
+Identity (session, agent, host, runtime, pid, launchId) is stamped automatically
+and rides the phone footer of feed.broadcast {message}. Domain facts (tickets,
+PRs) are not CLI flags - the ticket is joined from the session index at post
+time. No em-dashes in title/body - they are scrubbed on the way out.
 
-Configure where a post is mirrored under feed.broadcast in agents.yaml — see
+Configure where a post is mirrored under feed.broadcast in agents.yaml - see
 docs/06-observability.md.
 `)
         .action((textParts, opts, cmd) => {
@@ -279,6 +279,7 @@ docs/06-observability.md.
         // binds the flag on the parent, so a `feed post … --json` lands on
         // parent.opts().json — not the child. Read both.
         const flags = {
+            title: opts?.title ?? cmd?.opts?.()?.title,
             session: opts?.session ?? cmd?.opts?.()?.session,
             attach: opts?.attach ?? cmd?.opts?.()?.attach,
             level: opts?.level ?? cmd?.opts?.()?.level,
@@ -298,8 +299,12 @@ docs/06-observability.md.
             if (!flags.blocked && (flags.option?.length || flags.default)) {
                 throw new Error('--option/--default only apply with --blocked.');
             }
+            if (!flags.title?.trim()) {
+                throw new Error('Missing --title. Usage: agents feed post --title "Short subject" "body text"');
+            }
             const level = flags.blocked ? 'important' : parseFeedPostLevel(flags.level);
             const { event } = postFeedStatus({
+                title: flags.title,
                 text: Array.isArray(textParts) ? textParts.join(' ') : String(textParts ?? ''),
                 sessionId: flags.session,
                 attach: flags.attach,
@@ -312,12 +317,20 @@ docs/06-observability.md.
             let outcomes;
             if (flags.blocked) {
                 const block = buildDeclaredBlock(event, {
-                    text: event.detail ?? '',
+                    // Prefer title as the front-loaded ask on the phone; body is detail.
+                    text: event.title
+                        ? (event.detail ? `${event.title}: ${event.detail}` : event.title)
+                        : (event.detail ?? ''),
                     options: flags.option,
                     safeDefault: flags.default,
                 });
                 publishBlock(block);
-                outcomes = broadcastBlock(block, { project: event.project, agent: event.agent });
+                outcomes = broadcastBlock(block, {
+                    project: event.project,
+                    agent: event.agent,
+                    title: event.title,
+                    body: event.detail,
+                });
             }
             else {
                 outcomes = broadcastPostedEvent(event, level);
@@ -561,6 +574,7 @@ function broadcastPostedEvent(event, level) {
         return [];
     const ticket = getSessionById(event.sessionId)?.ticketId;
     const planned = planFeedBroadcast(config, {
+        title: event.title,
         text: event.detail ?? '',
         level,
         ticket,
@@ -675,7 +689,7 @@ function renderUpdatesView(updates) {
     }));
     console.log();
     if (updates.length === 0) {
-        console.log(chalk.gray('  No progress updates yet. Agents post them with `agents feed post "…"`.'));
+        console.log(chalk.gray('  No progress updates yet. Agents post them with `agents feed post --title "…" "…"`.'));
         return;
     }
     for (const ev of updates) {

package/dist/commands/mailboxes.js

@@ -2,7 +2,9 @@ import * as os from 'os';
 import * as path from 'path';
 import chalk from 'chalk';
 import { die, humanDuration, relTime, truncate, visibleWidth } from '../lib/format.js';
+import { setHelpSections } from '../lib/help.js';
 import { listBoxes, readBox, mailboxDir, isValidMailboxId, watchMessages, } from '../lib/mailbox.js';
+import { gcMailbox } from '../lib/mailbox-gc.js';
 import { GLYPH, masthead, sparkline, aggregate, hourlyCounts, graphEdges, } from '../lib/comms-render.js';
 import { getMailboxRootDir } from '../lib/state.js';
 import { getActiveSessions } from '../lib/session/active.js';
@@ -262,6 +264,21 @@ function renderBetween(boxes, a, b, json) {
         console.log(`    ${truncate(m.text.replace(/\s+/g, ' ').trim(), 100)}`);
     }
 }
+async function runGcCommand(opts) {
+    const sessions = await getActiveSessions();
+    const activeBoxIds = new Set(sessions.map(mailboxIdForActiveSession).filter((id) => !!id));
+    const result = gcMailbox(activeBoxIds);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.messagesDroppedDead === 0 && result.messagesDroppedExpired === 0) {
+        console.log(chalk.dim(`gc: ${result.boxesScanned} boxes scanned, no pending messages dropped.`));
+        return;
+    }
+    console.log(chalk.yellow(`gc: ${result.messagesDroppedDead} dead-box messages, ${result.messagesDroppedExpired} expired messages dropped ` +
+        `(${result.boxesScanned} boxes scanned, ${result.deadBoxes} dead boxes).`));
+}
 function renderGraph(boxes, filters, json) {
     const nonEmpty = boxes.filter((b) => b.messages.length > 0);
     const msgs = aggregate(nonEmpty).filter((m) => matchesFilters(m, m.toLabel, m.box, filters));
@@ -313,7 +330,7 @@ function newestMessage(box) {
     return box.messages.reduce((a, b) => (a.ts >= b.ts ? a : b));
 }
 export function registerMailboxesCommand(program) {
-    program
+    const cmd = program
         .command('mailboxes')
         .alias('mailbox')
         .argument('[id]', 'A mailbox id (session UUID / teams agentId) to inspect in full')
@@ -387,4 +404,25 @@ export function registerMailboxesCommand(program) {
         }
         renderOverview(boxes, limit, filters);
     });
+    const gcCmd = cmd
+        .command('gc')
+        .description('Run a liveness sweep: archive pending messages in dead boxes and prune stale consumed mail.')
+        .option('--json', 'Emit the GC result as JSON')
+        .action(async (_opts, command) => runGcCommand({ json: command.optsWithGlobals().json === true }));
+    setHelpSections(gcCmd, {
+        examples: `
+      # One-shot sweep using the live session set as the liveness source
+      agents mailboxes gc
+
+      # Machine-readable summary (for scripts / monitors)
+      agents mailboxes gc --json
+    `,
+        notes: `
+      A box is considered dead when no live session (the same source
+      \`agents sessions --active\` uses) owns it. Pending messages in dead boxes
+      are archived as \`dropped: dead\`; expired messages in live boxes are
+      archived as \`dropped: expired\'. Both surfaces a failure receipt back to
+      the feed store when the message carried a blockId.
+    `,
+    });
 }