@phnx-labs/agents-cli 1.22.27 → 1.22.29

package/dist/lib/hosts/reconnect.js

@@ -73,7 +73,7 @@
  * is failing to put the user back into the agent.
  */
 import { sshExec, sshStream, shellQuote } from '../ssh-exec.js';
-import { sshTargetFor } from './types.js';
+import { hostIdentityArgs, sshTargetFor } from './types.js';
 /** ssh's connection-layer failure code — the signal that the link dropped rather
  *  than the remote command exiting on its own. Mirrors ssh-exec.ts `sshStream`. */
 export const SSH_CONN_FAILURE = 255;
@@ -214,15 +214,17 @@ export function reattachRemoteCommand(sessionId) {
  */
 export function reattachRemoteSession(host, sessionId) {
     const target = sshTargetFor(host);
+    const extraSshArgs = hostIdentityArgs(host);
     // Fresh (non-multiplexed) reachability probe: code 0 means the handshake actually
     // completed, so a hung/failed connect is never mistaken for a live reconnection.
-    const probe = sshExec(target, 'true', { multiplex: false });
+    // RUSH-2265: pass host identity on every hop (probe + stream), not only the first.
+    const probe = sshExec(target, 'true', { multiplex: false, extraSshArgs });
     if (probe.code !== 0)
         return { code: SSH_CONN_FAILURE, connected: false, heldMs: 0 };
     // Timed from AFTER the probe returned, so this is the attach's own duration and
     // carries none of the connect phase the file header rules out as a signal.
     const startedAt = Date.now();
-    const code = sshStream(target, reattachRemoteCommand(sessionId), { tty: true });
+    const code = sshStream(target, reattachRemoteCommand(sessionId), { tty: true, extraSshArgs });
     return { code, connected: true, heldMs: Date.now() - startedAt };
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/dist/lib/hosts/registry.js

@@ -94,6 +94,7 @@ function deviceHost(device, user, overlay) {
         source: 'inline',
         ...(address ? { address } : {}),
         user: user ?? device.user,
+        identityFile: device.auth.identityFile,
         os: device.platform !== 'unknown' ? device.platform : overlay?.os,
         ...(overlay?.caps?.length ? { caps: overlay.caps } : {}),
         enrolled: true,

package/dist/lib/hosts/tasks.d.ts

@@ -14,6 +14,7 @@ export interface HostTask {
     target: string;
     /** OpenSSH private-key path retained for follow/reconcile/stop calls. */
     identityFile?: string;
+    remoteShell?: 'posix' | 'powershell';
     agent: string;
     prompt: string;
     pid?: number;

package/dist/lib/menubar/snapshot.d.ts

@@ -1,10 +1,26 @@
 import type { WatchdogTickResult } from '../watchdog/runner.js';
+/**
+ * One registered fleet device, for the menu-bar's collapsible DEVICES section.
+ * Sourced from the local registry read (`loadDevices`) — no network probe — so
+ * it carries only what the registry knows for sure (name, platform, whether it
+ * is the interactive host, whether it is this machine). Live load% is merged in
+ * on the Swift side from the daemon-warmed `.fleet-stats.json`; online/offline
+ * is deliberately NOT claimed here (the registry's cached tailscale flag is
+ * documented as stale in both directions — registry.ts isLikelyOnline).
+ */
+export interface MenubarDevice {
+    name: string;
+    platform: string;
+    interactive: boolean;
+    isLocal: boolean;
+}
 export interface MenubarSnapshot {
     version: 1;
     capturedAt: string;
     routines: Record<string, unknown>[];
     recentSessions: Record<string, unknown>[];
     activeSessions: Record<string, unknown>[];
+    devices: MenubarDevice[];
     watchdog: {
         enabled: boolean;
         lastTick: Pick<WatchdogTickResult, 'didNudge' | 'counts'> | null;

package/dist/lib/menubar/snapshot.js

@@ -1,11 +1,31 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { buildRoutineListJson } from '../../commands/routines.js';
-import { backfillActiveRowsFromIndex, serializeActiveSessionsForJson, serializeSessionsJson } from '../../commands/sessions.js';
+import { backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson } from '../../commands/sessions.js';
 import { getConfigValue } from '../device-config.js';
+import { loadDevices } from '../devices/registry.js';
+import { machineId } from '../machine-id.js';
 import { querySessions } from '../session/db.js';
 import { readActiveSessionsCache } from '../session/session-cache.js';
 import { getRuntimeStateDir } from '../state.js';
+/**
+ * The full registered-device roster for the menu bar, from the local registry
+ * file only (no ssh, no stats probe) — as cheap as `buildRoutineListJson()`, so
+ * it rides the same 3-minute snapshot poll instead of a second timer.
+ */
+async function buildMenubarDevices() {
+    const reg = await loadDevices();
+    const interactiveHost = getConfigValue('interactive.host').value;
+    const self = machineId();
+    return Object.keys(reg)
+        .sort()
+        .map((name) => ({
+        name,
+        platform: reg[name].platform,
+        interactive: name === interactiveHost,
+        isLocal: name === self,
+    }));
+}
 export function readLastWatchdogTick(stateDir = path.join(getRuntimeStateDir(), 'watchdog')) {
     try {
         return JSON.parse(fs.readFileSync(path.join(stateDir, 'last-tick.json'), 'utf-8'));
@@ -16,12 +36,25 @@ export function readLastWatchdogTick(stateDir = path.join(getRuntimeStateDir(),
 }
 /** One-process read model for AGI Menu's repeating three-minute refresh. */
 export async function computeMenubarSnapshot() {
-    const [routines, recent] = await Promise.all([
+    const [routines, recent, devices] = await Promise.all([
         Promise.resolve(buildRoutineListJson()),
         Promise.resolve(querySessions({ limit: 40, skipExistenceCheck: true })),
+        buildMenubarDevices(),
     ]);
     const active = readActiveSessionsCache('local');
-    const activeSessions = active?.sessions ?? [];
+    const rawSessions = active?.sessions ?? [];
+    // The raw cache is never filtered at write time (RUSH-2336) — it retains
+    // queued/closed/crashed rows so `--queued`/`--closed`/`--crashed` can
+    // recover them, and the daemon's warm-tick gather (unlike the CLI's own
+    // local gather) never stamps `machine` on a row. Stamp self here — this IS
+    // the 'local' scope by construction — then apply the ONE canonical
+    // bare-active selector so the menubar never shows a retained dead/queued
+    // row nor a process row of unverified liveness.
+    const self = machineId();
+    for (const s of rawSessions)
+        if (!s.machine)
+            s.machine = self;
+    const activeSessions = rawSessions.filter(isRunningLiveSession);
     backfillActiveRowsFromIndex(activeSessions);
     return {
         version: 1,
@@ -29,6 +62,7 @@ export async function computeMenubarSnapshot() {
         routines,
         recentSessions: JSON.parse(serializeSessionsJson(recent)),
         activeSessions: serializeActiveSessionsForJson(activeSessions),
+        devices,
         watchdog: {
             enabled: getConfigValue('watchdog.enabled').value === true,
             lastTick: (() => {

package/dist/lib/models.d.ts

@@ -69,17 +69,24 @@ export declare function locateModelSource(agent: AgentId, version: string): Mode
  *   - constants: {OPUS_ID:"...",OPUS_NAME:"...",SONNET_ID:"...",...}
  */
 /**
- * Drop a bare `claude-<family>-<major>` (e.g. `claude-opus-4`) when a more specific
- * sibling (`claude-opus-4-8`) is present. The bare form is only ever an internal
- * `.includes("claude-opus-4")` prefix-check string in the binary, not a submittable
- * id (issue #1892); a bare id with no sibling (e.g. `claude-sonnet-5`) is a real
- * current model and is kept.
+ * Drop a catalog id that is a proper dash-boundary prefix of a more-specific
+ * sibling also present in the list (e.g. `claude-opus-4` when `claude-opus-4-8`
+ * is present, or `claude-opus-4-1` when `claude-opus-4-1-20250805` is present).
+ *
+ * Two sources produce these prefix forms in the native binary:
+ *  - standalone `.includes("claude-opus-4")` prefix-check strings (#1892)
+ *  - per-cloud metadata field values such as `foundry:"claude-opus-4-1"` next
+ *    to a real firstParty id `claude-opus-4-1-20250805` (#2233)
+ *
+ * A genuine bare current id with no longer sibling (e.g. `claude-sonnet-5`) is
+ * kept. The dash boundary (`startsWith(id + '-')`) avoids collapsing
+ * `claude-opus-4-1` into `claude-opus-4-10`.
  */
 export declare function dropBareLegacyIds(ids: string[]): string[];
 /**
  * Scan raw binary/bundle text for canonical Claude model ids, then drop bare
- * legacy prefixes (issue #1892). Two independent guards keep non-model strings
- * out of the catalog:
+ * legacy / cloud-metadata prefixes (#1892, #2233). Two independent guards keep
+ * non-model strings out of the catalog:
  *
  *  - **Word-boundary anchors on the id regex.** The id must not be glued to a
  *    surrounding identifier character, and must not be the truncated prefix of a
@@ -98,10 +105,10 @@ export declare function dropBareLegacyIds(ids: string[]): string[];
  *    id this scan exists to suppress (two packed strings can end up glued with no
  *    separator in the extracted binary text). The atomic match fails outright
  *    instead of degrading to the bare form.
- *  - **`dropBareLegacyIds`.** A standalone `.includes("claude-opus-4")` prefix
- *    check is a fully delimited string the anchors cannot tell apart from a real
- *    bare id, so a bare `claude-<family>-<major>` is dropped only when a
- *    more-specific sibling (`claude-opus-4-8`) is also present; a genuinely bare
+ *  - **`dropBareLegacyIds`.** A fully delimited string the anchors cannot tell
+ *    apart from a real id — whether a bare major (`.includes("claude-opus-4")`)
+ *    or a bare-minor per-cloud field value (`foundry:"claude-opus-4-1"`) — is
+ *    dropped when a more-specific sibling is also present; a genuinely bare
  *    current id with no sibling (`claude-sonnet-5`) is kept.
  */
 export declare function scanClaudeCatalogIds(text: string): string[];

package/dist/lib/models.js

@@ -290,22 +290,26 @@ function extractStrings(filePath, minLen = 6) {
  *   - constants: {OPUS_ID:"...",OPUS_NAME:"...",SONNET_ID:"...",...}
  */
 /**
- * Drop a bare `claude-<family>-<major>` (e.g. `claude-opus-4`) when a more specific
- * sibling (`claude-opus-4-8`) is present. The bare form is only ever an internal
- * `.includes("claude-opus-4")` prefix-check string in the binary, not a submittable
- * id (issue #1892); a bare id with no sibling (e.g. `claude-sonnet-5`) is a real
- * current model and is kept.
+ * Drop a catalog id that is a proper dash-boundary prefix of a more-specific
+ * sibling also present in the list (e.g. `claude-opus-4` when `claude-opus-4-8`
+ * is present, or `claude-opus-4-1` when `claude-opus-4-1-20250805` is present).
+ *
+ * Two sources produce these prefix forms in the native binary:
+ *  - standalone `.includes("claude-opus-4")` prefix-check strings (#1892)
+ *  - per-cloud metadata field values such as `foundry:"claude-opus-4-1"` next
+ *    to a real firstParty id `claude-opus-4-1-20250805` (#2233)
+ *
+ * A genuine bare current id with no longer sibling (e.g. `claude-sonnet-5`) is
+ * kept. The dash boundary (`startsWith(id + '-')`) avoids collapsing
+ * `claude-opus-4-1` into `claude-opus-4-10`.
  */
 export function dropBareLegacyIds(ids) {
-    return ids.filter((id) => {
-        const bareMajor = /^claude-[a-z]+-\d+$/.test(id);
-        return !(bareMajor && ids.some((o) => o !== id && o.startsWith(`${id}-`)));
-    });
+    return ids.filter((id) => !ids.some((other) => other !== id && other.startsWith(`${id}-`)));
 }
 /**
  * Scan raw binary/bundle text for canonical Claude model ids, then drop bare
- * legacy prefixes (issue #1892). Two independent guards keep non-model strings
- * out of the catalog:
+ * legacy / cloud-metadata prefixes (#1892, #2233). Two independent guards keep
+ * non-model strings out of the catalog:
  *
  *  - **Word-boundary anchors on the id regex.** The id must not be glued to a
  *    surrounding identifier character, and must not be the truncated prefix of a
@@ -324,10 +328,10 @@ export function dropBareLegacyIds(ids) {
  *    id this scan exists to suppress (two packed strings can end up glued with no
  *    separator in the extracted binary text). The atomic match fails outright
  *    instead of degrading to the bare form.
- *  - **`dropBareLegacyIds`.** A standalone `.includes("claude-opus-4")` prefix
- *    check is a fully delimited string the anchors cannot tell apart from a real
- *    bare id, so a bare `claude-<family>-<major>` is dropped only when a
- *    more-specific sibling (`claude-opus-4-8`) is also present; a genuinely bare
+ *  - **`dropBareLegacyIds`.** A fully delimited string the anchors cannot tell
+ *    apart from a real id — whether a bare major (`.includes("claude-opus-4")`)
+ *    or a bare-minor per-cloud field value (`foundry:"claude-opus-4-1"`) — is
+ *    dropped when a more-specific sibling is also present; a genuinely bare
  *    current id with no sibling (`claude-sonnet-5`) is kept.
  */
 export function scanClaudeCatalogIds(text) {

package/dist/lib/perf/db.js

@@ -244,7 +244,7 @@ export function aggregateSamples(opts = {}) {
         const key = `${r.kind}\0${r.label}`;
         let b = map.get(key);
         if (!b) {
-            b = { kind: r.kind, label: r.label, durations: [], hits: 0, stale: 0, misses: 0, errors: 0, timeouts: 0 };
+            b = { kind: r.kind, label: r.label, durations: [], hits: 0, stale: 0, misses: 0, errors: 0, blocks: 0, timeouts: 0 };
             map.set(key, b);
         }
         b.durations.push(Number(r.duration_ms));
@@ -254,10 +254,19 @@ export function aggregateSamples(opts = {}) {
             b.stale++;
         else if (r.cache === 'miss' || r.cache === 'none')
             b.misses++;
+        // Exit classes (Claude/Codex PreToolUse convention):
+        //   0 → allowed
+        //   2 → intentional deny/block (not a crash)
+        //   1 / other nonzero → real error
+        // Timeouts are recorded via status, not exit_code, so they don't double-count.
         if (r.status === 'timeout')
             b.timeouts++;
-        else if (typeof r.exit_code === 'number' && r.exit_code !== 0)
-            b.errors++;
+        else if (typeof r.exit_code === 'number') {
+            if (r.exit_code === 2)
+                b.blocks++;
+            else if (r.exit_code !== 0)
+                b.errors++;
+        }
     }
     const out = [];
     for (const b of map.values()) {
@@ -286,6 +295,10 @@ export function aggregateSamples(opts = {}) {
             row.errorCount = b.errors;
             row.errorRate = Math.round((b.errors / n) * 1000) / 1000;
         }
+        if (b.blocks > 0) {
+            row.blockCount = b.blocks;
+            row.blockRate = Math.round((b.blocks / n) * 1000) / 1000;
+        }
         if (b.timeouts > 0)
             row.timeoutRate = Math.round((b.timeouts / n) * 1000) / 1000;
         if (opts.project)

package/dist/lib/perf/types.d.ts

@@ -35,8 +35,19 @@ export interface PerfAggregateRow {
     cacheStalePct?: number;
     cacheMissPct?: number;
     errorCount?: number;
-    /** Fraction (0-1) of samples with a nonzero exit code. */
+    /**
+     * Fraction (0-1) of samples with a real crash exit (exit 1 / other nonzero
+     * except the intentional PreToolUse deny code 2). Exit 2 is blockRate.
+     */
     errorRate?: number;
+    /**
+     * Count of intentional deny/block exits (Claude/Codex PreToolUse exit 2).
+     * Not an error — deny-by-design guards (ask-user-question-guard, git-guard,
+     * plan-html-reminder) exit 2 when they block.
+     */
+    blockCount?: number;
+    /** Fraction (0-1) of samples with exit code 2 (intentional deny/block). */
+    blockRate?: number;
     /** Fraction (0-1) of samples with status:'timeout'. */
     timeoutRate?: number;
     /** Project key (see project-key.ts) the row is scoped to — set only when

package/dist/lib/project-probe.d.ts

@@ -73,6 +73,16 @@ export declare function formatWorkspaceLine(s: RepoWorkspaceStatus): string;
  * `fleet` row label.
  */
 export declare function formatFleetWorkspaces(statuses: HostWorkspaceStatus[]): string[];
+/**
+ * One-line fleet health summary — `6/13 clean · 4 behind · 4 dirty · 1 missing`.
+ * Sits ABOVE the per-host {@link formatFleetWorkspaces} table so the card is
+ * scannable without reading every host cell; the table keeps the per-host branch
+ * and drift detail. Zero buckets are omitted. `behind` colours red when any host
+ * is ≥10 behind (matching the footer's critical threshold), else yellow; a host
+ * that is both behind and dirty counts in both. Each host×path row is one unit,
+ * the same unit the table renders. Pure — chalk styling only.
+ */
+export declare function formatFleetSummary(statuses: HostWorkspaceStatus[]): string;
 /** Severity for a workspace/repo warning on the project card. */
 export type WorkspaceWarningSeverity = 'critical' | 'continue';
 export interface WorkspaceWarning {
@@ -81,13 +91,22 @@ export interface WorkspaceWarning {
     remediation?: string;
 }
 /**
- * Turn probed workspace rows into card-footer warnings.
+ * Turn probed workspace rows into card-footer warnings, GROUPED by root cause so
+ * a fleet where eight hosts drift is a few lines, not sixteen (each with its own
+ * repeated remediation).
  *
  * - missing / unreadable git → critical (agents there cannot share a tree)
- * - behind upstream → critical when ≥10 commits, continue otherwise
+ * - behind upstream → critical when ANY host is ≥10 commits behind, else continue
  * - dirty tree → continue (local work is fine; just note it)
  * - ahead-only is not a warning (that is progress waiting to push)
  *
- * Pure. Caller decides whether the rows came from `--fleet` or a local probe.
+ * Within one probed path, all behind hosts collapse to one warning listing each
+ * host with its count (`4 hosts behind origin/main — mac-mini ↓172, …`) plus one
+ * shared remediation; a lone host keeps its full sentence. Missing and dirty
+ * collapse the same way. `error` stays per-host (each message is distinct).
+ * Grouping is per path so two different repos never merge into one count. Unlike
+ * doctor's `emitGroup`, the list names EVERY host, not the first two — each
+ * host's drift count differs and is individually actionable. Pure — chalk only.
+ * Caller decides whether the rows came from `--fleet` or a local probe.
  */
 export declare function workspaceWarnings(statuses: HostWorkspaceStatus[]): WorkspaceWarning[];

package/dist/lib/project-probe.js

@@ -159,46 +159,134 @@ export function formatFleetWorkspaces(statuses) {
     });
 }
 /**
- * Turn probed workspace rows into card-footer warnings.
+ * One-line fleet health summary — `6/13 clean · 4 behind · 4 dirty · 1 missing`.
+ * Sits ABOVE the per-host {@link formatFleetWorkspaces} table so the card is
+ * scannable without reading every host cell; the table keeps the per-host branch
+ * and drift detail. Zero buckets are omitted. `behind` colours red when any host
+ * is ≥10 behind (matching the footer's critical threshold), else yellow; a host
+ * that is both behind and dirty counts in both. Each host×path row is one unit,
+ * the same unit the table renders. Pure — chalk styling only.
+ */
+export function formatFleetSummary(statuses) {
+    const total = statuses.length;
+    let clean = 0;
+    let behind = 0;
+    let dirty = 0;
+    let missing = 0;
+    let hardBehind = false;
+    for (const s of statuses) {
+        if (!s.present) {
+            missing++;
+            continue;
+        }
+        if (s.error)
+            continue; // unreadable — neither clean nor a drift bucket (surfaced in the footer)
+        const isBehind = s.behind !== undefined && s.behind > 0;
+        const isDirty = s.dirty !== undefined && s.dirty > 0;
+        if (isBehind) {
+            behind++;
+            if (s.behind >= 10)
+                hardBehind = true;
+        }
+        if (isDirty)
+            dirty++;
+        if (!isBehind && !isDirty)
+            clean++;
+    }
+    const parts = [chalk.green(`${clean}/${total} clean`)];
+    if (behind)
+        parts.push((hardBehind ? chalk.red : chalk.yellow)(`${behind} behind`));
+    if (dirty)
+        parts.push(chalk.yellow(`${dirty} dirty`));
+    if (missing)
+        parts.push(chalk.red(`${missing} missing`));
+    return parts.join(chalk.dim(' · '));
+}
+/**
+ * Turn probed workspace rows into card-footer warnings, GROUPED by root cause so
+ * a fleet where eight hosts drift is a few lines, not sixteen (each with its own
+ * repeated remediation).
  *
  * - missing / unreadable git → critical (agents there cannot share a tree)
- * - behind upstream → critical when ≥10 commits, continue otherwise
+ * - behind upstream → critical when ANY host is ≥10 commits behind, else continue
  * - dirty tree → continue (local work is fine; just note it)
  * - ahead-only is not a warning (that is progress waiting to push)
  *
- * Pure. Caller decides whether the rows came from `--fleet` or a local probe.
+ * Within one probed path, all behind hosts collapse to one warning listing each
+ * host with its count (`4 hosts behind origin/main — mac-mini ↓172, …`) plus one
+ * shared remediation; a lone host keeps its full sentence. Missing and dirty
+ * collapse the same way. `error` stays per-host (each message is distinct).
+ * Grouping is per path so two different repos never merge into one count. Unlike
+ * doctor's `emitGroup`, the list names EVERY host, not the first two — each
+ * host's drift count differs and is individually actionable. Pure — chalk only.
+ * Caller decides whether the rows came from `--fleet` or a local probe.
  */
 export function workspaceWarnings(statuses) {
     const out = [];
-    for (const s of [...statuses].sort((a, b) => a.host.localeCompare(b.host) || a.path.localeCompare(b.path))) {
-        const where = s.host ? `${s.host}` : 'local';
-        const pathBit = s.path ? ` (${s.path})` : '';
-        if (!s.present) {
+    const where = (s) => (s.host ? s.host : 'local');
+    const paths = [...new Set(statuses.map((s) => s.path))].sort((a, b) => a.localeCompare(b));
+    for (const path of paths) {
+        const pathBit = path ? ` (${path})` : '';
+        const rows = statuses.filter((s) => s.path === path);
+        const present = rows.filter((s) => s.present && !s.error);
+        // Missing checkout — grouped critical, a lone host keeps its full sentence.
+        const missing = rows.filter((s) => !s.present).sort((a, b) => where(a).localeCompare(where(b)));
+        if (missing.length === 1) {
             out.push({
                 severity: 'critical',
-                text: `${where}: checkout missing${pathBit}`,
+                text: `${where(missing[0])}: checkout missing${pathBit}`,
                 remediation: 'clone or sync the project root on that host before landing agents there',
             });
-            continue;
         }
-        if (s.error) {
+        else if (missing.length > 1) {
             out.push({
                 severity: 'critical',
-                text: `${where}: ${s.error}${pathBit}`,
+                text: `${missing.length} hosts missing checkout${pathBit} — ${missing.map(where).join(', ')}`,
+                remediation: 'clone or sync the project root on those hosts before landing agents there',
             });
-            continue;
         }
-        if (s.behind !== undefined && s.behind > 0) {
+        // Unreadable git — one per host, since each error message is distinct.
+        for (const s of rows.filter((s) => s.present && s.error).sort((a, b) => where(a).localeCompare(where(b)))) {
+            out.push({ severity: 'critical', text: `${where(s)}: ${s.error}${pathBit}` });
+        }
+        // Behind upstream — grouped, worst count first, one shared remediation.
+        const behind = present
+            .filter((s) => s.behind !== undefined && s.behind > 0)
+            .sort((a, b) => (b.behind ?? 0) - (a.behind ?? 0) || where(a).localeCompare(where(b)));
+        if (behind.length === 1) {
+            const s = behind[0];
             out.push({
-                severity: s.behind >= 10 ? 'critical' : 'continue',
-                text: `${where} is ${s.behind} commit${s.behind === 1 ? '' : 's'} behind ${s.upstream ?? 'upstream'}${pathBit}`,
+                severity: (s.behind ?? 0) >= 10 ? 'critical' : 'continue',
+                text: `${where(s)} is ${s.behind} commit${s.behind === 1 ? '' : 's'} behind ${s.upstream ?? 'upstream'}${pathBit}`,
                 remediation: 'pull (or rebase) before agents on this host open PRs against a stale base',
             });
         }
-        if (s.dirty !== undefined && s.dirty > 0) {
+        else if (behind.length > 1) {
+            const upstreams = new Set(behind.map((s) => s.upstream ?? 'upstream'));
+            const upstream = upstreams.size === 1 ? [...upstreams][0] : 'upstream';
+            const list = behind.map((s) => `${where(s)} ↓${s.behind}`).join(', ');
+            out.push({
+                severity: behind.some((s) => (s.behind ?? 0) >= 10) ? 'critical' : 'continue',
+                text: `${behind.length} hosts behind ${upstream}${pathBit} — ${list}`,
+                remediation: 'pull (or rebase) before agents on these hosts open PRs against a stale base',
+            });
+        }
+        // Dirty tree — grouped, most changes first, no remediation (local work is fine).
+        const dirty = present
+            .filter((s) => s.dirty !== undefined && s.dirty > 0)
+            .sort((a, b) => (b.dirty ?? 0) - (a.dirty ?? 0) || where(a).localeCompare(where(b)));
+        if (dirty.length === 1) {
+            const s = dirty[0];
+            out.push({
+                severity: 'continue',
+                text: `${where(s)} has ${s.dirty} uncommitted change${s.dirty === 1 ? '' : 's'}${pathBit}`,
+            });
+        }
+        else if (dirty.length > 1) {
+            const list = dirty.map((s) => `${where(s)} ${s.dirty}`).join(', ');
             out.push({
                 severity: 'continue',
-                text: `${where} has ${s.dirty} uncommitted change${s.dirty === 1 ? '' : 's'}${pathBit}`,
+                text: `${dirty.length} hosts with uncommitted changes${pathBit} — ${list}`,
             });
         }
     }

package/dist/lib/project-status.d.ts

@@ -87,6 +87,15 @@ export interface LiveDeadSplit {
  * crashed sessions is itself a thing to go fix.
  */
 export declare function liveDeadSplit(byStatus: Partial<Record<ActiveStatus, number>>): LiveDeadSplit;
+/**
+ * The `dead` row body: `41 crashed` when every dead session shares one status,
+ * else `12 finished or lost (8 crashed, 4 closed)`. The generic "finished or
+ * lost" only earns its keep when the statuses actually differ — with a single
+ * status it just hides which one behind a parenthetical that repeats the count.
+ * Pure — chalk styling only; the caller adds the `dead` label. Assumes
+ * `split.dead > 0` (the caller gates on it).
+ */
+export declare function formatDeadSummary(split: LiveDeadSplit): string;
 /** Sort members for the card: running first, then idle, then the rest; agent name asc within a state. */
 export declare function sortProjectMembers(members: ProjectMember[]): ProjectMember[];
 /** Cap for the members line before it collapses to `+N more`. */

package/dist/lib/project-status.js

@@ -135,6 +135,21 @@ export function liveDeadSplit(byStatus) {
     deadByStatus.sort((a, b) => b.n - a.n || a.status.localeCompare(b.status));
     return { live, dead, deadByStatus };
 }
+/**
+ * The `dead` row body: `41 crashed` when every dead session shares one status,
+ * else `12 finished or lost (8 crashed, 4 closed)`. The generic "finished or
+ * lost" only earns its keep when the statuses actually differ — with a single
+ * status it just hides which one behind a parenthetical that repeats the count.
+ * Pure — chalk styling only; the caller adds the `dead` label. Assumes
+ * `split.dead > 0` (the caller gates on it).
+ */
+export function formatDeadSummary(split) {
+    if (split.deadByStatus.length === 1) {
+        return chalk.yellow(`${split.dead} ${split.deadByStatus[0].status}`);
+    }
+    const detail = split.deadByStatus.map((d) => `${d.n} ${d.status}`).join(', ');
+    return `${chalk.yellow(`${split.dead} finished or lost`)} ${chalk.dim(`(${detail})`)}`;
+}
 /**
  * Display order for the members line: the states a human scans for first
  * (running, then idle, then need-input, then queued), everything else after,

package/dist/lib/refresh.js

@@ -135,15 +135,24 @@ export async function refresh(options = {}) {
         const versionsToSync = skipPrompts
             ? listInstalledVersions(agentId)
             : [defaultVer];
-        const actuallySynced = getActuallySyncedResources(agentId, defaultVer);
-        const newResources = getNewResources(available, actuallySynced, getProjectOnlyResources());
-        const hasAnySynced = actuallySynced.commands.length > 0 ||
-            actuallySynced.skills.length > 0 ||
-            actuallySynced.hooks.length > 0 ||
-            actuallySynced.memory.length > 0 ||
-            actuallySynced.mcp.length > 0 ||
-            actuallySynced.permissions.length > 0 ||
-            actuallySynced.plugins.length > 0;
+        // Interactive-only: getActuallySyncedResources walks every skill tree with
+        // content compares (~1s/agent on a full install). The unattended path
+        // (`skipPrompts` / `agents sync --yes`) never reads these — it always
+        // force-full-syncs — so skip the scan entirely (RUSH-2320 #1).
+        let actuallySynced;
+        let newResources;
+        let hasAnySynced = false;
+        if (!skipPrompts) {
+            actuallySynced = getActuallySyncedResources(agentId, defaultVer);
+            newResources = getNewResources(available, actuallySynced, getProjectOnlyResources());
+            hasAnySynced = actuallySynced.commands.length > 0 ||
+                actuallySynced.skills.length > 0 ||
+                actuallySynced.hooks.length > 0 ||
+                actuallySynced.memory.length > 0 ||
+                actuallySynced.mcp.length > 0 ||
+                actuallySynced.permissions.length > 0 ||
+                actuallySynced.plugins.length > 0;
+        }
         try {
             let selection;
             let forceFullSync = false;
@@ -156,7 +165,7 @@ export async function refresh(options = {}) {
                 if (userSelection)
                     selection = userSelection;
             }
-            else if (hasNewResources(newResources, agentId, defaultVer)) {
+            else if (newResources && hasNewResources(newResources, agentId, defaultVer)) {
                 log(chalk.cyan(`\n${agentLabel(agentId)}@${defaultVer}:`));
                 const userSelection = await promptNewResourceSelection(agentId, newResources, defaultVer);
                 if (userSelection)
@@ -168,7 +177,9 @@ export async function refresh(options = {}) {
             if (forceFullSync || (selection && Object.keys(selection).length > 0)) {
                 const kinds = new Set();
                 for (const ver of versionsToSync) {
-                    const syncResult = syncResourcesToVersion(agentId, ver, selection, forceFullSync ? { force: true } : undefined);
+                    // Pass the already-built `available` so each version does not re-scan
+                    // resource trees (RUSH-2320 #5).
+                    const syncResult = syncResourcesToVersion(agentId, ver, selection, { available, ...(forceFullSync ? { force: true } : {}) });
                     if (syncResult.commands)
                         kinds.add('commands');
                     if (syncResult.skills)

package/dist/lib/rotate.d.ts

@@ -145,6 +145,28 @@ export type AccountReadiness = {
  * reported while the account is actually serving requests.
  */
 export declare function readinessFromCandidate(candidate: RotateCandidate): AccountReadiness;
+/**
+ * Whether a human sitting at a terminal can clear this exclusion by launching
+ * the agent and signing in. The two unhealthy classes are opposites, and the
+ * zero-healthy callers MUST NOT treat them alike:
+ *
+ * - `signed_out` / `revoked` — recoverable. There is no credential (or the
+ *   server rejected it), and the harness's own TUI is the login surface, so
+ *   launching it is exactly the fix. Refusing to launch strands the user with
+ *   no way to authenticate through agents-cli at all (RUSH-2334).
+ * - `rate_limited` / `out_of_credits` — NOT recoverable. The account is signed
+ *   in and throttled; launching it just hammers an exhausted account, which is
+ *   precisely the loop RUSH-2132's fail-loud guard exists to stop. Only a
+ *   window reset clears these.
+ */
+export declare function isSignInRecoverable(readiness: AccountReadiness): boolean;
+/**
+ * The subset of an `exhausted` set whose exclusion a sign-in would clear, so an
+ * interactive caller can offer the login instead of dead-ending. Empty means
+ * every account is throttled — nothing a human can fix right now, so the caller
+ * keeps failing loud.
+ */
+export declare function signInRecoverableCandidates(candidates: RotateCandidate[]): RotateCandidate[];
 /**
  * Readiness for a specific installed (agent, version). Returns `{ ready: true }`
  * when the version isn't among the collected candidates — absence is the