@phnx-labs/agents-cli 1.22.27 → 1.22.28

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## 1.22.28
+
+- **`agents run` / `agents teams` `--device`/`--host`: fail loud when a pinned harness version is not installed on the target (RUSH-2313).** A concrete pin like `codex@0.145.0` is checked against the remote `agents view --json` listing during `ensureHostReady` *before* the run is marked dispatched. Missing pins exit non-zero naming the box, the pin, what is installed there, and `agents ssh <box> -- agents add <agent>@<ver>` — so detached fleet drains no longer print `Dispatched` and then die only in the remote log. Aliases (`@latest` / …) still resolve on the remote; a bare agent name still only warns. Source: `apps/cli/src/lib/hosts/ready.ts`, `dispatch.ts`, `teams/agents.ts`.
+
+- **fix: Windows-host e2e suites can resolve `win-mini` again under the hermetic device registry.** `tests/setup.ts` (RUSH-2042 / #1572) redirects `AGENTS_DEVICES_DIR` to an empty fork-private directory so unit fixtures never leak into the real fleet registry. The live `ssh-tunnel.e2e` / `browser/drivers/ssh.e2e` suites still need a real `DeviceProfile` for `AGENTS_TEST_WIN_HOST`, so after #1572 every `tests-windows-host-e2e.yml` run failed immediately with `Unknown device 'win-mini'` — even on a tailnet-joined runner that could ssh to the box. The setup file now seeds the private registry from the real fleet entry (or synthesizes one from `ssh -G <host>`) when `AGENTS_TEST_WIN_HOST` is set; the real registry is never written. Source: `apps/cli/tests/seed-e2e-win-host.ts`, `apps/cli/tests/setup.ts`.
+
+- **OpenCode timeout-sample spool dir is Windows-safe (#1869).** The generated
+  `agents-cli-hooks.ts` plugin used `PERF_SPOOL.slice(0, PERF_SPOOL.lastIndexOf("/"))`
+  to mkdir the perf spool parent. On Windows `getPerfDir()` is backslash-separated,
+  so `lastIndexOf("/")` returned -1 and the slice dropped one character — the
+  sample write was fail-silent and never landed. The plugin now imports
+  `node:path` and uses `path.dirname(PERF_SPOOL)`. Source: `apps/cli/src/lib/hooks.ts`.
+
+- **Bash-command classifier: single-source tool registry + broader unwrap (#1889).** The embedded Python activity-log hook (`ACTIVITY_LOG_HOOK_SCRIPT` in `activity.ts`) hand-duplicated `bash-command.ts`'s `TOOL_REGISTRY` and `VALUE_FLAGS` with a "keep them in sync" comment — the two had already drifted (Python was missing `rmdir`, and `agents`/`linear` two-level tools). Both tables are now generated from the TypeScript source (`pythonToolRegistryLiteral` / `pythonValueFlagsLiteral`) at module load. Separately, `unwrapCommand` (and the matching Python `_unwrap_command`) now peels `export VAR=…`, `set -euo pipefail`, `for`/`until` loop bodies, `if`/`then` branches, and `(command)` subshell prefixes that previously classified as `other`. Source: `apps/cli/src/lib/session/bash-command.ts`, `apps/cli/src/lib/activity.ts`.
+
+- **Active-session polls skip re-parsing quiet transcripts (#2047).** `computeLiveSignals` (the per-session tail/parse behind `agents sessions --active` and the menu-bar badge tick) now memoizes by transcript path + mtime + `pidAlive` inside the process, so a 30s poll no longer re-tails every live session whose file has not changed. Positive Claude transcript-path resolutions are also memoized while the file still exists, avoiding a full walk of every Claude version-home `projects/` tree per pid per tick. Source: `apps/cli/src/lib/session/active.ts`.
+
+- perf(sessions): throttle headless `ps`/`lsof` scan + memoize process table across an active-session poll (#2047)
+
+- **`agents routines devices --set` / `--clear` no longer abort when a fleet peer is offline (#2118).** Pinning a routine used to fan out pause/resume to every registered device and throw on the first unreachable one — often *after* the pin had already succeeded on the target — so a single asleep laptop made fleet pins unusable and the error looked like the pin failed. Offline peers are now skipped with a warning; the command exits non-zero only when a *selected* target device cannot be reached. Source: `apps/cli/src/commands/routines.ts`.
+
+- **`agents models claude` no longer lists a per-cloud bare-minor id as a plain catalog entry (#2233).** The id-scan fallback (`scanClaudeCatalogIds`, used when the structured alias/perCloud maps yield fewer than two models) used to surface short forms like `claude-opus-4-1` that only appear as a `foundry:` / cloud-scoped field next to a real firstParty id (`claude-opus-4-1-20250805`). `dropBareLegacyIds` now drops **any** id that is a dash-boundary prefix of a more-specific sibling also present in the scan — covering both the bare-major `.includes("claude-opus-4")` artifacts (#1892) and these bare-minor cloud-metadata values — while keeping genuine bare currents with no sibling (`claude-sonnet-5`) and not collapsing `claude-opus-4-1` into `claude-opus-4-10`. Source: `apps/cli/src/lib/models.ts`.
+
+- **Menu-bar dropdown density toggle removed.** The `Density: Auto/Rich/Compact` footer item and the whole rich/compact rendering fork are gone; the dropdown now always renders the rich rows (session/work titles, expanded Routines and Recent sections). Removes the `menubarDensity` UserDefaults key and `MENUBAR_DENSITY` env override, and updates the menu-bar docs to match. Source: `apps/cli/menubar/Sources/MenubarHelper/StatusItemController.swift`, `apps/cli/docs/menubar.md`.
+
+- **The macOS secrets broker can now hold an explicit key subset under its own lease id and expiry (RUSH-2255).** `agents secrets lease <bundle> --keys K1,K2 --for 8h` authenticates once, stores only those resolved values in broker memory and the restart session, and reports lease metadata without exposing values. Unknown, missing, and expired keys fail closed. Source: `apps/cli/src/{commands/secrets.ts,lib/secrets/{agent,lease,session-store}.ts}`.
+
+- **Scoped leases can now be listed and revoked by id (RUSH-2256).** `agents secrets leases` shows bundle, keys, and remaining lifetime; `agents secrets revoke <lease-id>` wipes exactly that broker grant and its restart session. Source: `apps/cli/src/{commands/secrets.ts,lib/secrets/{agent,session-store}.ts}`.
+
+- **Fleet devices accept an explicit SSH private-key path (RUSH-2265).** `agents devices set <name> --auth key --identity-file <path>` stores the path on that device and every shared SSH invocation passes it to OpenSSH with `-i`, so devices no longer depend on whichever key the ambient ssh agent happens to offer. Switching a device from password to key auth also removes stale password-bundle metadata from the registry.
+
+- **Detached agent dispatch now runs on Windows OpenSSH hosts (RUSH-2267).** Headless `agents run … --host <windows>` launches through a hidden PowerShell process, preserves actor/session/env context, and uses durable Windows-native log, follow, reconcile, stop, and cleanup operations.
+
+- **`agents repo pull` fast-forwards a clean behind-only checkout instead of failing with "Cannot rebase onto multiple branches" (RUSH-2282).** After fetch, a 1-behind tree integrates via `merge --ff-only` against the tracking ref; only genuinely diverged histories enter rebase. Avoids re-running `git pull --rebase` on a multi-entry `FETCH_HEAD` (common after bare fetch when the remote has several branches, or under concurrent fleet fetch). Source: `apps/cli/src/lib/git.ts` `pullRepo`.
+
+- **`agents perf` splits intentional deny (exit 2) from crashes (exit 1) — hook health is readable again (RUSH-2294).** Deny-by-design guards (`ask-user-question-guard`, `plan-html-reminder`, `git-guard`, …) exit 2 on purpose; the warehouse previously counted any nonzero exit as `errorCount`, so a working guard read as a "92%-error" hook. Exit 0 = allow, exit 2 = `blockCount`/`blockRate`, exit 1 / other = `errorCount`/`errorRate`. The hooks table column is now `ERR/BLOCK/TO` (`err:…% block:…% to:…%`). JSON rows gain `blockCount`/`blockRate`. Source: `apps/cli/src/lib/perf/db.ts`, `apps/cli/src/lib/hooks/profile.ts`, `apps/cli/src/commands/perf.ts`.
+
+- **Claude launches reuse an unchanged file-backed setup-token instead of decrypting it on every exec (RUSH-2317).** The process-lifetime cache is isolated by version home and invalidates from the encrypted credential file's identity, ctime, mtime, and size; token rotation is picked up on the next launch, missing per-account tokens are negatively cached, and plaintext tokens remain memory-only. Source: `apps/cli/src/lib/claude-account-token.ts`, `apps/cli/src/lib/secrets/filestore.ts`.
+
+- **Repeated full session listings reuse stable transcript membership (RUSH-2318).** The process briefly caches settled transcript directories by mtime+size, rereads recently changed directories, and expires every entry within the filesystem timestamp-precision window, avoiding burst-time repeat reads without hiding filesystem-only creates or deletes. Source: `apps/cli/src/lib/session/db.ts`.
+
+- **`agents sync --yes` drops ~1s/agent of dead work and reuses still-fresh fingerprints (RUSH-2320).** Measured on a real install: `getActuallySyncedResources` was ~1055 ms/agent on the unattended path that never reads it; `buildManifest` re-hashed every file (~716 ms) after a no-op force sync; the guard-hit path spent ~12 ms building inventories it then discarded. Unattended sync now skips the interactive inventory, the skills detector is stat-first on size before any content read, `buildManifest` carries still-fresh fingerprints from the previous manifest, and `syncResourcesToVersion` runs its no-change guard before pattern expansion (accepting a caller-supplied `available` inventory so multi-version fan-out does not re-scan). Source: `apps/cli/src/lib/refresh.ts`, `apps/cli/src/lib/versions.ts`, `apps/cli/src/lib/staleness/`.
+
+- **fix: `agents run <agent>` no longer dead-ends when every account is logged out — it launches so you can sign in.** A harness with one installed, signed-out version had no reachable login path at all: `agents run cursor` exited with `no healthy cursor account under strategy 'balanced' — excluded: 2026.07.23 (signed_out)`, the `agents run cursor@` account picker marked the logged-out row `disabled` and offered only `No usable accounts — cancel`, and `agents use cursor` only set a default. The zero-healthy guard (RUSH-2132) treated a missing login like an exhausted account, but they are opposites — a throttled account must not be launched, while a signed-out one is fixed precisely BY launching, since the harness's own TUI is the login surface. On a human-facing terminal run (a real TTY and no `--json`), a single sign-in-recoverable account now launches directly (naming the version and the login command) and several open the account picker with auth-blocked rows selectable and labelled `launch to sign in`; `rate_limited` / `out_of_credits` still fail loud, and off a TTY — or under `--json` — both classes keep the exact watchdog-parsed error, now with the harness's login command alongside `--strategy pinned`. Source: `apps/cli/src/lib/rotate.ts` (`isSignInRecoverable`, `signInRecoverableCandidates`), `apps/cli/src/commands/run-account-picker.ts` (`pickSignInLaunchVersion`), `apps/cli/src/commands/exec.ts`. (RUSH-2334)
+
+- **`sessions --active` no longer shows retained dead/queued rows, and every process row now carries its PID (RUSH-2336).** Bare `--active` (CLI table/JSON, the interactive browser, `focus`, and the menu bar) previously kept a row alive as long as its pid wasn't *known* dead — so a queued-but-not-started row, or a process of genuinely unverified liveness, could still show up. The canonical selector (`isRunningLiveSession`) now excludes `queued`/`closed`/`crashed` outright (still reachable via `--queued`/`--closed`/`--crashed`) and requires a real process row to positively verify its machine, a positive pid, and `pidAlive === true`; a cloud row stays active on its provider + task id alone. Every process-backed `--active --json` row now guarantees `machine`/`pid`/`pidAlive: true`, and the human CLI row and the menu bar's session detail both show the matching `machine:pid` (or `provider · taskId` for cloud) locator. Source: `apps/cli/src/commands/sessions.ts`, `apps/cli/src/lib/menubar/snapshot.ts`, `apps/cli/menubar/Sources/MenubarHelper/`.
+
+- **`agents projects status` card scans faster: grouped warnings, a fleet health summary, and a truthful `dead` label (RUSH-2337).** On a busy fleet the card printed each host's git drift twice — once in the inline `fleet` table, then again as one 2-line block per host in the warnings footer (18 lines for 3 facts) — and read `dead 41 finished or lost (41 crashed)`, which contradicts itself when every dead session is a crash. Now: (1) the warnings footer **groups by root cause** — all behind hosts collapse to one warning listing each with its count (`4 hosts behind origin/main — mac-mini ↓172, yosemite-m2 ↓217, …`) under one shared remediation, dirty/missing the same, a lone host keeps its full sentence, grouped per probed path so two repos never merge (mirrors doctor's `emitGroup`); (2) a one-line **fleet health summary** (`6/13 clean · 4 behind · 4 dirty · 1 missing`) sits above the per-host table, which keeps its branch/drift detail; (3) the `dead` row names the status directly when singular (`dead  41 crashed`); (4) the fleet-wide rollup carries a `fleet snapshot · as of HH:MM` stamp; (5) `linear` shows a completion percent (`468/547 done (86%)`). Source: apps/cli/src/lib/project-probe.ts, apps/cli/src/lib/project-status.ts, apps/cli/src/commands/projects.ts, apps/cli/docs/11-projects.md.
+
 ## 1.22.27
 
 - **`agents sessions --teams` groups sessions by team (RUSH-1997).** Instead of one flat list with a `[team/handle]` tag, `--teams` now prints a report grouped by team: each team names its spawner (the orchestrator session that created it) and spawn time, and every teammate row shows its mode + handle. Team-flagged spawns that carry no teammate `meta.json` — headless `agents run` sessions, or teammates whose team record aged out — sink into a trailing `(no team)` bucket, so a real `agents teams` teammate and a bare SDK spawn are never shown as the same thing. `--teams --flat`/`--tree` keep the plain inline table, and a search query keeps the interactive picker. `TeamOrigin` (also on `--teams --json`) now carries the teammate's `startedAt` spawn time and a `source` (`meta` = teammate, `entrypoint` = bare spawn). Source: `apps/cli/src/lib/session/team-filter.ts`, `apps/cli/src/commands/sessions.ts`.

package/README.md

@@ -11,7 +11,7 @@
   <a href="https://github.com/phnx-labs/agents-cli"><img src="https://img.shields.io/badge/github-phnx--labs%2Fagents--cli-blue?style=flat-square" alt="github" /></a>
 </p>
 
-**The missing toolchain for CLI coding agents.** Run any agent on your existing subscription. Spawn parallel teams in isolated terminals or dispatch to the cloud for a PR. Watch live state across the fleet, nudge stalled runs, and message agents mid-flight. Schedule routines and set monitors that fire an agent when a source changes, drive browsers and Electron apps, store secrets behind Touch ID, and file tickets from a menu-bar bar — all from one CLI.
+**A framework for running a distributed agent factory.** Dispatch Claude, Codex, Antigravity, Grok, and more across your own machines, in parallel, on your existing subscriptions. Measure every run with `agents perf` / `agents insights`, fold what you learn back into `AGENTS.md` and skills, then put the loop on a schedule with routines and monitors. Spawn parallel teams in isolated terminals or dispatch to the cloud for a PR. Watch live state across the fleet, nudge stalled runs, and message agents mid-flight. Store secrets behind Touch ID, drive real browsers and Electron apps, and steer the whole fleet from a menu bar — all from one CLI.
 
 <p align="center">
   <a href="https://github.com/anthropics/claude-code" title="Claude Code"><img src="assets/harnesses/anthropic.svg" height="32" alt="Claude Code" /></a>
@@ -60,20 +60,25 @@ Source: [github.com/phnx-labs/agents-cli](https://github.com/phnx-labs/agents-cl
 
 Also available as `ag` -- all commands work with both `agents` and `ag`.
 
-- [Pin versions per project](#pin-versions-per-project)
+- [Factory loop](#factory-loop)
 - [One config, every agent](#one-config-every-agent)
 - [Run any agent](#run-any-agent)
 - [Sessions across agents](#sessions-across-agents)
 - [Control the fleet](#control-the-fleet)
 - [Sync the fleet](#sync-the-fleet)
-- [Run open models through Claude Code](#run-open-models-through-claude-code)
+- [Pin versions per project](#pin-versions-per-project)
+- [Run open models through Claude Code](#run-open-models-through-claude-code-experimental)
+- [Run on your own machines](#run-on-your-own-machines)
 - [Teams](#teams)
 - [Cloud](#cloud)
 - [Workflows](#workflows)
+- [Plugins](#plugins)
+- [Make it yours](#make-it-yours)
 - [Browser](#browser)
 - [Secrets](#secrets)
 - [Routines](#routines)
 - [Monitors](#monitors)
+- [Share](#share)
 - [PTY](#pty)
 - [Portable setup](#portable-setup)
 - [Menu bar](#menu-bar)
@@ -84,34 +89,35 @@ Also available as `ag` -- all commands work with both `agents` and `ag`.
 
 ---
 
-## Pin versions per project
-
-```bash
-# This project needs claude@2.0.65 -- newer versions changed tool calling.
-agents use claude@2.0.65 -p
-
-# The monorepo uses codex@0.116.0 across the team.
-agents use codex@0.116.0 -p
-```
-
-This creates an `agents.yaml` at the project root:
-
-```yaml
-# agents.yaml (commit this to your repo)
-agents:
-  claude: "2.0.65"
-  codex: "0.116.0"
-```
+## Factory loop
 
-Think `requirements.txt` for CLI coding agents, on steroids. A shim reads `agents.yaml` from the project root and routes `claude` / `codex` / `antigravity` / `grok` (and others) to the right version automatically. Each version gets its own isolated home -- switching backs up config and re-syncs resources.
+The same loop whether it's one agent on your laptop or a fleet across a dozen machines: dispatch work, measure what happened, fold the lesson back into the harness, then put it on a schedule.
 
 ```bash
-agents add claude@2.0.65     # Install a specific version
-agents add codex@latest       # Install latest
-agents add codex@oldest       # Install the oldest published version
-agents view                   # See everything installed
+# Dispatch a team across the fleet -- each teammate in its own worktree
+agents teams create checkout --devices yosemite-s0,yosemite-s1
+agents teams add checkout claude "Owns: app/payments/*" --name payments
+agents teams add checkout codex  "Write tests for the new code" --name qa --after payments
+agents teams start checkout --watch
+
+# Measure what happened -- latency, friction, dead-weight skills
+agents perf commands --days 7      # slowest CLI entrypoints
+agents insights --since 30d        # friction, harness comparison, ranked actions
+
+# Fold the lesson back into the harness -- every agent picks it up next run
+agents rules add ~/lessons/payments-review.md --agents claude
+agents skills add ~/skills/payments-review --agents claude
+
+# Put it on a schedule so it runs itself
+agents routines add nightly-payments-audit \
+  --schedule "0 2 * * *" --agent claude --prompt "Audit payments/* for regressions"
+
+# Steer the fleet this loop runs on from the menu bar
+agents menubar setup
 ```
 
+`agents perf` reads a disposable warehouse at `~/.agents/.cache/perf/perf.db` -- hook, command, and run timing rollups, deletable any time. `agents insights` (alias `agents sessions insights`) is deterministic and offline: it caches per-session facets, compares harnesses, and ranks actions by evidence count -- no model call unless you pass `--narrative`. Routines put any of this on a cron ([Routines](#routines)); monitors fire it on a change instead of a clock ([Monitors](#monitors)); the menu bar is the always-on control surface for the fleet these commands drive ([Menu bar](#menu-bar)).
+
 ---
 
 ## One config, every agent
@@ -464,6 +470,36 @@ See [docs/fleet.md](apps/cli/docs/fleet.md) for the manifest schema and reconcil
 
 ---
 
+## Pin versions per project
+
+```bash
+# This project needs claude@2.0.65 -- newer versions changed tool calling.
+agents use claude@2.0.65 -p
+
+# The monorepo uses codex@0.116.0 across the team.
+agents use codex@0.116.0 -p
+```
+
+This creates an `agents.yaml` at the project root:
+
+```yaml
+# agents.yaml (commit this to your repo)
+agents:
+  claude: "2.0.65"
+  codex: "0.116.0"
+```
+
+Think `requirements.txt` for CLI coding agents, on steroids. A shim reads `agents.yaml` from the project root and routes `claude` / `codex` / `antigravity` / `grok` (and others) to the right version automatically. Each version gets its own isolated home -- switching backs up config and re-syncs resources.
+
+```bash
+agents add claude@2.0.65     # Install a specific version
+agents add codex@latest       # Install latest
+agents add codex@oldest       # Install the oldest published version
+agents view                   # See everything installed
+```
+
+---
+
 ## Run open models through Claude Code (experimental)
 
 > **Note:** Profiles are experimental, but available by default — no enable step needed.

package/dist/commands/exec.js

@@ -1795,7 +1795,7 @@ export function registerRunCommand(program) {
                 await warnUnpushedWork(resumeExec.cwd ?? process.cwd());
             process.exit(resumeExit);
         }
-        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, implicitModeFor, headlessPlanStallCommand, nativeResume, resolveInteractive, inferredInteractiveWithoutTty }, { ALL_AGENT_IDS, ACCOUNT_INSPECTION_AGENT_IDS, agentLabel, supportsAccountInspection }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveHostSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES, collectHarnessCandidates, pickHarnessWeighted, classifyHarnessCandidates, formatHarnessPickBanner, formatNoHealthyHarnessError, formatNoHealthyAccountError }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents, ensureSubagentDispatchTool }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports, capableAgents }, { shareRuntimeEnv },] = await Promise.all([
+        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, implicitModeFor, headlessPlanStallCommand, nativeResume, resolveInteractive, inferredInteractiveWithoutTty }, { ALL_AGENT_IDS, ACCOUNT_INSPECTION_AGENT_IDS, agentLabel, supportsAccountInspection }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveHostSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES, collectHarnessCandidates, pickHarnessWeighted, classifyHarnessCandidates, formatHarnessPickBanner, formatNoHealthyHarnessError, formatNoHealthyAccountError, signInRecoverableCandidates }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents, ensureSubagentDispatchTool }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports, capableAgents }, { shareRuntimeEnv },] = await Promise.all([
             import('../lib/exec.js'),
             import('../lib/agents.js'),
             import('../lib/profiles.js'),
@@ -2302,6 +2302,9 @@ export function registerRunCommand(program) {
         // synthesize a same-agent fallback chain from the other healthy accounts
         // (issue #348). Stays null unless a non-pinned strategy actually rotated.
         let rotationResult = null;
+        // Set when the zero-healthy path already announced a deliberate
+        // launch-to-sign-in, so the login preflight below does not repeat it.
+        let signInLaunch = false;
         if (options.strategy && !explicitStrategy) {
             console.error(chalk.red(`Invalid strategy: ${options.strategy}. Use ${RUN_STRATEGIES.join(', ')}.`));
             process.exit(1);
@@ -2328,15 +2331,53 @@ export function registerRunCommand(program) {
                 try {
                     const resolved = await resolveRunVersion(agent, strategy, cwd);
                     if (resolved.exhausted) {
-                        // Fail loud (RUSH-2132): the old behavior warned "found no
-                        // usable version; falling back to defaults" and launched the
-                        // pinned default anyway — the exact move that loops a rotate
-                        // into an exhausted account. The message text is a contract
-                        // the Factory watchdog tail-detects; do not reword it.
-                        console.error(chalk.red(formatNoHealthyAccountError(agent, strategy, resolved.exhausted)));
-                        process.exit(1);
+                        // Zero healthy accounts splits two ways, and conflating them is what
+                        // stranded a logged-out harness with no way in at all (RUSH-2334):
+                        //
+                        // - THROTTLED (rate_limited / out_of_credits) -> fail loud (RUSH-2132).
+                        //   The old behavior warned "found no usable version; falling back to
+                        //   defaults" and launched the pinned default anyway — the exact move
+                        //   that loops a rotate into an exhausted account. Only a window reset
+                        //   clears it. The message text is a contract the Factory watchdog
+                        //   tail-detects; do not reword it.
+                        // - NEEDS A SIGN-IN (signed_out / revoked) -> launching IS the fix,
+                        //   because the harness's own TUI is the login surface. So on a TTY we
+                        //   carry the user into that login instead of erroring. Exiting here
+                        //   made `agents run <agent>`, `agents run <agent>@`, and `agents use`
+                        //   all dead-end with no reachable way to authenticate.
+                        const recoverable = signInRecoverableCandidates(resolved.exhausted);
+                        const { signInLaunchDecision } = await import('./run-account-picker.js');
+                        const decision = signInLaunchDecision({
+                            recoverable: recoverable.length,
+                            tty: isInteractiveTerminal(),
+                            json: options.json === true,
+                        });
+                        if (decision === 'launch') {
+                            const { pickSignInLaunchVersion } = await import('./run-account-picker.js');
+                            const signInVersion = await pickSignInLaunchVersion(agent, recoverable, !!options.quiet);
+                            // A cancelled prompt launches nothing — same contract as the
+                            // trailing-@ account picker above.
+                            if (!signInVersion)
+                                return;
+                            version = signInVersion;
+                            // We just told the user this account is logged out and why we're
+                            // launching it, so suppress the downstream login preflight — it
+                            // would print a second, near-identical "looks logged out" warning.
+                            signInLaunch = true;
+                        }
+                        else {
+                            console.error(chalk.red(formatNoHealthyAccountError(agent, strategy, resolved.exhausted)));
+                            if (recoverable.length > 0) {
+                                // Off a TTY nobody can complete a login, so we still exit — but
+                                // name the actual fix rather than only offering --strategy pinned,
+                                // which would just pin the same unauthenticated account.
+                                const { loginHint } = await import('../lib/signin-badge.js');
+                                console.error(chalk.gray(`To sign in: ${loginHint(agent)} — or run \`agents run ${agent}\` from a terminal.`));
+                            }
+                            process.exit(1);
+                        }
                     }
-                    if (resolved.version) {
+                    else if (resolved.version) {
                         version = resolved.version;
                         rotationResult = resolved.rotation;
                         if (resolved.rotation && !options.quiet) {
@@ -2428,7 +2469,10 @@ export function registerRunCommand(program) {
                 json: options.json,
                 quiet: options.quiet,
                 authCheckDisabled: options.authCheck === false || process.env.AGENTS_NO_AUTH_CHECK === '1',
-                rotated: !!rotationResult || accountPickerRequested,
+                // `signInLaunch` means the zero-healthy path already reported this exact
+                // account as logged out and named the login command, so re-probing here
+                // only prints a second, near-identical warning.
+                rotated: !!rotationResult || accountPickerRequested || signInLaunch,
             });
             if (preflight) {
                 try {

package/dist/commands/hosts.js

@@ -13,7 +13,7 @@ import { isInteractiveTerminal } from './utils.js';
 import { assertValidSshTarget } from '../lib/ssh-exec.js';
 import { getProvider, listAllHosts, resolveHost } from '../lib/hosts/registry.js';
 import { getDevice } from '../lib/devices/registry.js';
-import { sshTargetFor } from '../lib/hosts/types.js';
+import { hostIdentityArgs, sshTargetFor } from '../lib/hosts/types.js';
 import { listSshConfigHosts, listKnownHosts, isSshConfigHost } from '../lib/hosts/ssh-config.js';
 import { probeHost, remoteAgentsVersion, bootstrapAgentsCli, localCliVersion, } from '../lib/hosts/ready.js';
 import { resolveRemoteOsSync } from '../lib/hosts/remote-os.js';
@@ -190,14 +190,15 @@ async function doCheck(name) {
     const target = sshTargetFor(host);
     const os = host.os ?? resolveRemoteOsSync(name);
     process.stdout.write(`Probing ${chalk.cyan(name)} (${target})… `);
-    const probe = probeHost(target, os);
+    const identityArgs = hostIdentityArgs(host);
+    const probe = probeHost(target, os, identityArgs);
     if (!probe.reachable) {
         console.log(chalk.red('unreachable'));
         process.exitCode = 1;
         return;
     }
     console.log(chalk.green('reachable') + chalk.gray(probe.os ? ` · ${probe.os}` : ''));
-    const ver = remoteAgentsVersion(target, probe.os ?? os);
+    const ver = remoteAgentsVersion(target, probe.os ?? os, identityArgs);
     console.log(`  agents-cli: ${ver ? chalk.green(ver) : chalk.yellow('not installed')}`);
 }
 async function doRemove(name) {

package/dist/commands/perf.d.ts

@@ -23,6 +23,16 @@ interface PerfGlobalOpts {
 }
 /** Map warehouse rows shaped like hook.fire into the existing HookProfileRow UI. */
 export declare function asHookRows(rows: PerfAggregateRow[]): HookProfileRow[];
+/**
+ * `err:12% block:40% to:4%` when any rate is present, else ''.
+ * Exit 2 (intentional deny) is `block:`, not `err:` — so a deny-by-design
+ * guard no longer reads as a crashing hook in the table.
+ */
+export declare function formatRateColumn(r: {
+    errorRate?: number;
+    blockRate?: number;
+    timeoutRate?: number;
+}): string;
 export declare function renderHookTable(rows: HookProfileRow[], warnMs: number): void;
 /**
  * Prefer SQLite samples; fall back to the legacy daily JSONL so existing

package/dist/commands/perf.js

@@ -43,6 +43,8 @@ export function asHookRows(rows) {
         cacheMissPct: r.cacheMissPct ?? 0,
         errorCount: r.errorCount ?? 0,
         errorRate: r.errorRate,
+        blockCount: r.blockCount ?? 0,
+        blockRate: r.blockRate,
         timeoutRate: r.timeoutRate,
         project: r.project,
     }));
@@ -57,11 +59,17 @@ function printTable(headers, widths, lines, slowFlags) {
         console.log(slowFlags[i] ? chalk.yellow(line) : line);
     }
 }
-/** `err:12% to:4%` when either rate is present, else ''. */
-function formatRateColumn(r) {
+/**
+ * `err:12% block:40% to:4%` when any rate is present, else ''.
+ * Exit 2 (intentional deny) is `block:`, not `err:` — so a deny-by-design
+ * guard no longer reads as a crashing hook in the table.
+ */
+export function formatRateColumn(r) {
     const parts = [];
     if (r.errorRate)
         parts.push(`err:${Math.round(r.errorRate * 100)}%`);
+    if (r.blockRate)
+        parts.push(`block:${Math.round(r.blockRate * 100)}%`);
     if (r.timeoutRate)
         parts.push(`to:${Math.round(r.timeoutRate * 100)}%`);
     return parts.join(' ');
@@ -73,7 +81,7 @@ export function renderHookTable(rows, warnMs) {
         console.log(chalk.gray('Hooks write via cache/matches shims into the spool; run a session or resync hooks.'));
         return;
     }
-    const widths = { hook: 36, n: 5, p50: 7, p95: 7, p99: 7, mean: 7, max: 7, cache: 22, rate: 14 };
+    const widths = { hook: 36, n: 5, p50: 7, p95: 7, p99: 7, mean: 7, max: 7, cache: 22, rate: 22 };
     const pad = (s, w) => (s.length >= w ? s.slice(0, w) : s + ' '.repeat(w - s.length));
     const header = [
         pad('HOOK', widths.hook),
@@ -84,7 +92,7 @@ export function renderHookTable(rows, warnMs) {
         pad('MEAN', widths.mean),
         pad('MAX', widths.max),
         pad('CACHE', widths.cache),
-        pad('ERR/TIMEOUT', widths.rate),
+        pad('ERR/BLOCK/TO', widths.rate),
     ].join(' ');
     console.log(chalk.bold(header));
     console.log(chalk.gray('─'.repeat(header.length)));
@@ -112,8 +120,8 @@ function renderLabelTable(title, rows, warnMs, limit) {
         console.log(chalk.gray(`No ${title} samples yet.`));
         return;
     }
-    const widths = [40, 5, 7, 7, 7, 7, 7, 14];
-    printTable(['LABEL', 'N', 'P50', 'P95', 'P99', 'MEAN', 'MAX', 'ERR/TIMEOUT'], widths, sliced.map((r) => [
+    const widths = [40, 5, 7, 7, 7, 7, 7, 22];
+    printTable(['LABEL', 'N', 'P50', 'P95', 'P99', 'MEAN', 'MAX', 'ERR/BLOCK/TO'], widths, sliced.map((r) => [
         r.label,
         String(r.n),
         formatMs(r.p50Ms),

package/dist/commands/projects.js

@@ -20,9 +20,9 @@ import { machineId } from '../lib/machine-id.js';
 import { getActiveSessions } from '../lib/session/active.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
 import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
-import { formatFleetWorkspaces, parseRemoteProbe, probeProjectWorkspaces, workspaceTargetsForDef, workspaceWarnings, } from '../lib/project-probe.js';
+import { formatFleetSummary, formatFleetWorkspaces, parseRemoteProbe, probeProjectWorkspaces, workspaceTargetsForDef, workspaceWarnings, } from '../lib/project-probe.js';
 import { listProjectDefs, loadProjectDef, writeProjectDef, removeProjectDef, projectDefPath, isSafeProjectName, validateProjectDef, } from '../lib/projects.js';
-import { rollupSessionsByProject, withDefaultMachine, isDeadStatus, liveDeadSplit, enrichProjectSignals, formatProjectMembersByHost, formatProjectWarnings, } from '../lib/project-status.js';
+import { rollupSessionsByProject, withDefaultMachine, isDeadStatus, formatDeadSummary, liveDeadSplit, enrichProjectSignals, formatProjectMembersByHost, formatProjectWarnings, } from '../lib/project-status.js';
 import { fetchLinearProjectCounts } from '../lib/linear-project-counts.js';
 import { listLinearProjects, pickLinearProject } from '../lib/linear-projects.js';
 import { checkRepoSlug } from '../lib/project-doctor.js';
@@ -302,8 +302,7 @@ warnWorkspaces = []) {
     if (split.dead > 0) {
         // Wreckage is worth a number of its own — 19 crashed sessions is a thing to
         // go fix, not a throughput signal to fold into the headline.
-        const deadDetail = split.deadByStatus.map((d) => `${d.n} ${d.status}`).join(', ');
-        console.log(`  ${chalk.dim('dead')}     ${chalk.yellow(`${split.dead} finished or lost`)} ${chalk.dim(`(${deadDetail})`)}`);
+        console.log(`  ${chalk.dim('dead')}     ${formatDeadSummary(split)}`);
     }
     // Live only, grouped by host when machine stamps exist so "who is on which
     // box" is visible. Flat collapse hid that when harness×status matched across hosts.
@@ -327,7 +326,8 @@ warnWorkspaces = []) {
     if (ships.length)
         console.log(`  ${chalk.dim('ships')}    ${ships.join(' · ')}`);
     if (linear) {
-        console.log(`  ${chalk.dim('linear')}   ${linear.done}/${linear.total}${linear.truncated ? '+' : ''} done · ${linear.inProgress} in progress`);
+        const pct = linear.total > 0 ? ` ${chalk.dim(`(${Math.round((linear.done / linear.total) * 100)}%)`)}` : '';
+        console.log(`  ${chalk.dim('linear')}   ${linear.done}/${linear.total}${linear.truncated ? '+' : ''} done${pct} · ${linear.inProgress} in progress`);
     }
     for (const line of formatMilestoneLines(linear?.milestones ?? [], linear?.nextMilestone, nowMs, milestoneLimit)) {
         console.log(line);
@@ -346,13 +346,18 @@ warnWorkspaces = []) {
         console.log(`  ${chalk.dim('tickets')}  ${r.tickets.slice(0, 8).join(' · ')}${r.tickets.length > 8 ? ' …' : ''}`);
     }
     if (fleet) {
-        const lines = formatFleetWorkspaces(fleet);
-        if (lines.length === 0) {
+        const table = formatFleetWorkspaces(fleet);
+        if (table.length === 0) {
             console.log(`  ${chalk.dim('fleet')}    ${chalk.gray('no workspace paths (set root or repos[].path)')}`);
         }
-        lines.forEach((line, i) => {
-            console.log(`  ${chalk.dim((i === 0 ? 'fleet' : '').padEnd(5))}    ${line}`);
-        });
+        else {
+            // A compact health line first (scan without reading every host), then the
+            // full per-host table under it. The grouped footer carries the actionable
+            // subset; this line + the table carry the whole picture.
+            [formatFleetSummary(fleet), ...table].forEach((line, i) => {
+                console.log(`  ${chalk.dim((i === 0 ? 'fleet' : '').padEnd(5))}    ${line}`);
+            });
+        }
     }
     if (remote?.artifacts) {
         const last = remote.lastArtifact ? `  ${chalk.dim(`· last: ${remote.lastArtifact}`)}` : '';
@@ -639,6 +644,15 @@ export function registerProjectsCommands(program) {
         }
         // Compact rollup shows the next milestone; `view` shows every declared one.
         const milestoneLimit = detail ? Number.POSITIVE_INFINITY : 1;
+        // Stamp the fleet-wide rollup with when it was taken, so a scrollback isn't
+        // mistaken for a live snapshot. A single named `view` skips it (one card, and
+        // its own detail makes the freshness obvious).
+        if (!detail) {
+            const t = new Date(nowMs);
+            const hhmm = `${String(t.getHours()).padStart(2, '0')}:${String(t.getMinutes()).padStart(2, '0')}`;
+            console.log(chalk.dim(`fleet snapshot · as of ${hhmm}`));
+            console.log('');
+        }
         for (const d of defs) {
             renderCard(d, roll.get(d.name), remote.get(d.name), fleetFor(d), linear.get(d.name), nowMs, milestoneLimit, focus.get(d.name) ?? [], detail, 
             // Always feed workspace rows into the warnings footer so behind/dirty

package/dist/commands/routines.js

@@ -1560,8 +1560,17 @@ export function registerRoutinesCommands(program) {
             const unknown = [...selectedSet].filter((device) => !all.includes(device));
             if (unknown.length > 0)
                 throw new Error(`Unknown device${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}`);
+            // --set/--clear fan out to every registered device so peers outside the
+            // new set get paused. An asleep/offline peer must not abort the whole
+            // pin: the target may already be applied, and an unreachable box cannot
+            // be running the routine (it picks up the enabled set on next sync).
+            // Exit non-zero only when a *selected* device could not be enabled
+            // (github.com/phnx-labs/agents-cli#2118).
+            const skipped = [];
+            const failedTargets = [];
             for (const device of all) {
                 const action = selectedSet.has(device) ? 'resume' : 'pause';
+                const isTarget = selectedSet.has(device);
                 if (device === normalizeHost(machineId())) {
                     setJobEnabled(name, action === 'resume');
                     if (isDaemonRunning())
@@ -1570,12 +1579,30 @@ export function registerRoutinesCommands(program) {
                 }
                 const launch = getCliLaunch(['routines', action, name, '--host', device]);
                 const result = spawnSync(launch.command, launch.args, { stdio: 'inherit', env: process.env });
-                if ((result.status ?? 1) !== 0)
-                    throw new Error(`Could not ${action} '${name}' on ${device}`);
+                if ((result.status ?? 1) !== 0) {
+                    if (isTarget) {
+                        failedTargets.push(device);
+                    }
+                    else {
+                        skipped.push({ device, action });
+                    }
+                }
             }
+            for (const s of skipped) {
+                console.log(chalk.yellow(`Skipped ${s.action} of '${name}' on ${s.device} (unreachable; will sync when online)`));
+            }
+            if (failedTargets.length > 0) {
+                const offlineNote = skipped.length > 0
+                    ? ` (also skipped offline: ${skipped.map((s) => s.device).join(', ')})`
+                    : '';
+                throw new Error(`Could not enable '${name}' on: ${failedTargets.join(', ')}${offlineNote}`);
+            }
+            const offlineNote = skipped.length > 0
+                ? ` (${skipped.length} offline device${skipped.length === 1 ? '' : 's'} skipped)`
+                : '';
             console.log(chalk.green(selected.length === 0
-                ? `Routine '${name}' disabled on every registered device`
-                : `Routine '${name}' enabled on: ${selected.join(', ')}`));
+                ? `Routine '${name}' disabled on every registered device${offlineNote}`
+                : `Routine '${name}' enabled on: ${selected.join(', ')}${offlineNote}`));
         };
         if (options.clear) {
             await applyDevices([]);

package/dist/commands/run-account-picker.d.ts

@@ -4,11 +4,48 @@ export interface RunAccountChoice {
     name: string;
     value: string;
     disabled?: string;
+    /** Can serve a run right now: signed in, authenticated, and under quota. */
     ready: boolean;
+    /**
+     * Selectable, but picking it launches the harness so you can authenticate
+     * first (RUSH-2334). Mutually exclusive with `ready`; never `disabled`.
+     */
+    signInRequired: boolean;
 }
 /** Human-readable remaining capacity for every window the provider exposes. */
 export declare function formatAccountLimits(candidate: RotateCandidate): string;
 /** Build aligned picker rows with usable accounts first and unsafe rows disabled. */
 export declare function buildRunAccountChoices(candidates: RotateCandidate[], globalDefault: string | null): RunAccountChoice[];
+/**
+ * Whether a zero-healthy run may recover by launching for a login, or must keep
+ * failing loud. Three inputs, all of which have to hold:
+ *
+ * - `recoverable` — at least one excluded account is only auth-blocked. An
+ *   all-throttled set is never launched (RUSH-2132): only a window reset clears it.
+ * - `tty` — a login needs a human present; off a TTY nobody can complete one.
+ * - `json` — `--json` marks a MACHINE consumer, which must never be handed a
+ *   picker or dropped into a login TUI. This mirrors the canonical
+ *   `Surface.interactive = tty && !json` in `commands/utils.ts`; a `--json` caller
+ *   gets the parseable fail-loud error instead.
+ */
+export declare function signInLaunchDecision(input: {
+    recoverable: number;
+    tty: boolean;
+    json: boolean;
+}): 'launch' | 'fail-loud';
+/**
+ * Choose which installed version to launch so the user can authenticate, when a
+ * strategy found zero healthy accounts but at least one is merely signed out
+ * (RUSH-2334). Returns the version to launch, or null if the user cancelled.
+ *
+ * A single candidate does NOT prompt — a one-item picker is pure noise, and the
+ * only thing to decide has one answer. Several candidates fall through to the
+ * normal account picker, which shows every account with its state so the choice
+ * is informed (throttled rows stay disabled there).
+ *
+ * Callers MUST have already confirmed an interactive terminal: off a TTY there
+ * is nobody to complete the login, and the run should fail loud instead.
+ */
+export declare function pickSignInLaunchVersion(agent: AgentId, recoverable: RotateCandidate[], quiet?: boolean): Promise<string | null>;
 /** Prompt for one safe installed account/version. A cancelled picker launches nothing. */
 export declare function pickRunAccountCandidate(agent: AgentId): Promise<RotateCandidate | null>;