@phnx-labs/agents-cli 1.20.77 → 1.20.78

package/CHANGELOG.md

@@ -1,5 +1,107 @@
 # Changelog
 
+## 1.20.78
+
+- **`agents sessions <uuid>` now resolves a remote session exactly, across the
+  fleet.** A full session id absent from the local disk used to fall back to an
+  FTS content search — and because a UUID appears verbatim in other sessions'
+  transcripts (a watchdog `/continue <uuid>` reference), that surfaced a list of
+  unrelated "matches" instead of the one session, which actually lived on another
+  machine. A UUID is now treated as an identifier: on a local miss the CLI fans
+  the id lookup out to the online fleet (the existing `gatherRemoteList` SSH
+  sweep), and when exactly one machine holds it, renders that session's summary
+  from the owning peer via `runOnPeer` (instead of `Session transcript not
+  available`). Same id on more than one box surfaces a machine-labeled conflict to
+  disambiguate with `--device <host>`; a UUID found nowhere prints a clear "no
+  session on this machine" message. There is **no** fuzzy/content fallback for a
+  UUID anywhere — the peer's `--json` answer id-resolves too, so a content
+  mentioner can never masquerade as the session. `--local` still restricts the
+  lookup to the local machine, and a peer already answering a parent's sweep
+  (`AGENTS_SESSIONS_LOCAL=1`) never re-fans-out. Source:
+  `resolveSessionAcrossFleet` / `fleetHitsById` / `shouldFanOutForId` in
+  `apps/cli/src/commands/sessions.ts` (wired into `renderOneSession`), and the
+  id-only `--json` resolution at the sessions listing seam. (RUSH-2024)
+
+- **`agents doctor --devices` now detects cross-device harness divergence (RUSH-2027).** The umbrella fleet diagnostic compares each registered device's installed harness inventory — resources (commands, skills, hooks, rules, mcp, permissions, subagents, plugins, promptcuts, workflows), per-agent installed versions, and `.agents`/`.system` config-repo state (branch, HEAD, dirty) — against the local machine as the baseline, and flags anything present on one box but missing on another. A plugin like `swarm` installed on `zion` but absent on `yosemite-s0` now surfaces as a clear warning (`yosemite-s0 is missing plugin 'swarm' (present on zion)`) instead of only being discovered at runtime as `Unknown command: /swarm:run`. Agent-version gaps (`yosemite-s0 is missing claude@2.1.220`) and diverged config repos are reported too. Read-only by default — it never installs or syncs; `--json` carries a stable `fleet` divergence block for the VS Code extension to consume. `agents fleet status` gained the same per-device divergence warning in its rollup. Every device's top-level `doctor --json` now emits a `fleet` inventory field so the comparison needs no extra probe. Source: `apps/cli/src/lib/devices/fleet-divergence.ts` (comparator), `apps/cli/src/lib/devices/fleet-inventory.ts` (`collectLocalFleetInventory`), `apps/cli/src/commands/doctor.ts` (`runDevicesDoctor`, `renderFleetDivergence`, `--json` `fleet` field), `apps/cli/src/lib/devices/health-report.ts` (`buildFleetHealthReport` divergence warning), `apps/cli/src/lib/git.ts` (`readRepoState`).
+
+- **`agents doctor` now shows repo-behind notices; they no longer appear on stderr during normal commands (RUSH-2048).** `printPendingUpdateNotices()` — which wrote "agents-cli: ~/.agents/ is N commits behind origin/main" to stderr on every CLI invocation — is replaced by `readRepoBehindMarkers()`, which returns the same data without printing. `agents doctor` reads these markers and renders a "Repo updates" section showing which repos are behind and the `agents repo pull <alias>` fix command. `agents doctor --json` emits a `repos` array so menubar helpers and other consumers can read the same data. Markers persist on disk until the next background fetch overwrites them, so the notice stays visible until the user acts. Source: `apps/cli/src/lib/auto-pull.ts`, `apps/cli/src/commands/doctor.ts`, `apps/cli/src/index.ts`.
+
+- **Session affinity data + host affinity resolver (RUSH-2049).** Sessions index
+  persists `machine` (schema v18) so affinity can `GROUP BY machine`.
+  `queryAffinityRollup` returns launch counts by device (and harness/joint for
+  analytics). Host affinity sampling lives in `smart-launch.ts` as
+  `resolveDeviceAffinity` / `applyDeviceAutoToOptions` (weight ∝ launches^α;
+  online hosts with no history still explore at weight 1). Account pick stays
+  the existing balanced strategy (live session/week rate-limit windows).
+  **User-facing host pick shipped as `--device auto` / `--host auto` in
+  RUSH-2059** (not a public `--smart` flag and not harness auto-pick). Source:
+  `apps/cli/src/lib/session/db.ts`, `origin-machine.ts`, `smart-launch.ts`.
+
+- **`agents sessions --all` now widens every non-status filter, not just the
+  directory (RUSH-2055).** `--all` used to only drop the current-project scope; it
+  now also drops the 30-day window cap, so one flag means "all values for every
+  non-status filter" — all directories AND all time. `--active` still composes as a
+  status filter, and `-a` / `--device` / `--since` still narrow their own axis (an
+  explicit `--since` overrides the all-time default). Applies to both the bare
+  listing and `--active`. Source: `apps/cli/src/commands/sessions-browser.ts`.
+
+- **Device affinity is `--device auto` (not `--smart` / harness `auto`) (RUSH-2059).**
+  Host pick from 14d usage affinity is a special value on the existing host flags:
+  `agents run claude --device auto` or `--host auto`. The harness is always the
+  agent you type — never auto-selected. Deprecated hidden `--smart` maps to
+  `--device auto` for one release. Extension New Agent unpinned launches use
+  `--device auto`. Banner: `device=auto → <host> (affinity …) · accounts=balanced`.
+  Source: `apps/cli/src/commands/exec.ts`, `smart-launch.ts`,
+  `apps/factory/src/core/agents.ts`.
+
+- **`agents sessions --active` no longer hides most of your running sessions.** On a TTY, `--active` opens the interactive browser, and the browser resolved "running" two ways that both dropped live sessions: its live scan called the local-only `getActiveSessions()` instead of the fleet sweep the static view uses, and it treated running as an *intersection* with the transcript index (`pool.filter(r => live.has(r.id))`) rather than a source of rows. Together they meant every session on another machine was invisible, as was any local one the index didn't already carry — a fleet with 32 live sessions across 7 machines showed 4. The browser now shares one gather with the static view (`gatherActiveSessions`) and folds live sessions the index lacks in as their own rows, keyed by session id, cloud task id, or `machine:pid` so two id-less sessions never collapse into one. Picking a row that has no session id yet reports where the process is instead of trying to open a transcript that doesn't exist. Source: `apps/cli/src/commands/sessions.ts` (`gatherActiveSessions`, `isIdlessLiveRow`), `apps/cli/src/commands/sessions-browser.ts` (`liveRowKey`, `indexLiveRows`, `liveSessionToMeta`, `mergeLiveIntoPool`).
+- **The session browser now shows which program each running session is in.** A new host column names the terminal or editor hosting the session — `codium`, `ghostty`, `tmux`, or `tmux→ghostty` when a tmux session is being watched through another app (a bare `tmux` means it is running detached) — so a session in the list can actually be found. The column is live-only and appears just in the running view, since transcript metadata carries no host. The id column also truncates now, so a row named by a 7-digit pid can no longer shunt every later column out of alignment. Source: `apps/cli/src/commands/sessions.ts` (`liveHostLabel`, `formatPickerLabel`, `PickerColumns.showHost`).
+
+- **The routines daemon holds no Claude credential and injects no token.** A
+  scheduled or daemon-fired Claude run now authenticates exactly like an
+  interactive `agents run claude` on the same machine: through the rotation-pinned
+  account's own `CLAUDE_CONFIG_DIR` login (`.credentials.json`), which Claude Code
+  refreshes per-device. The daemon previously read a token from the `claude`
+  secrets bundle and injected it into every routine spawn — first as one ambient
+  `CLAUDE_CODE_OAUTH_TOKEN` (RUSH-1759), then also as per-account
+  `CLAUDE_CODE_OAUTH_TOKEN_<account>` setup-tokens — which shadowed each account's
+  own on-disk login and made the daemon a second, competing credential store. Both
+  paths are removed, along with the sandbox `ENV_ALLOWLIST` entry that forwarded
+  them; a sandboxed routine now strips `CLAUDE_CODE_OAUTH_TOKEN` from its
+  environment and falls through to the per-account login. A box whose interactive
+  login has expired is skipped up front by the auth-health preflight with a
+  `re-login required` hint instead of running on an injected fallback — log in once
+  on that box (`agents run claude`) to restore it; no daemon restart is needed. This
+  keeps the daemon out of the credential entirely, which is what avoids the
+  fleet-wide rotation logout (a shared/injected token was the cause, not the fix).
+  Removed: `readDaemonClaudeOAuthToken` / `readDaemonClaudeBundleEnv` /
+  `buildDetachedDaemonEnv` (`daemon.ts`), `resolveAccountSetupToken` and
+  `apps/cli/src/lib/secrets/account-token.ts`, `claudeHomeHasOwnCredential`
+  (`agents.ts`). Source: `apps/cli/src/lib/daemon.ts`, `runner.ts`, `sandbox.ts`,
+  `agents.ts`.
+
+- **`agents sessions` no longer over-counts test results from arbitrary stdout.** The catch-up digest scraped any `\d+ pass`-shaped substring anywhere in a command's output, so a `442 passwords generated` log, a `git status: 442 files` line, or a `442 passes/sec` benchmark was reported as `Tests ✓ tests 442 pass`. It also treated any command merely containing a runner token as a test run, so npm-script sub-targets like `bun test:setup`, `npm run test:watch`, or `pnpm test:ci` were counted. Test-run classification now matches only real invocations (`bun/npm/yarn/pnpm test` bare, `vitest`, `jest`, `mocha`, `pytest`, `go test`, `cargo test`, `tsc`) and rejects `:sub-target` scripts, and pass/fail counts are read only from each runner's authoritative summary construct — vitest's ` Tests  N passed` / ` Tests  N failed | M passed` row, jest's `Tests:` line, pytest's `=== N passed[, M failed] in Xs ===` rule, bun's ` N pass`/` N fail` block closed by `Ran N tests`, and mocha's ` N passing`/` N failing`. A verdict is reported only when a real summary matched, so an ambiguous blob now shows nothing instead of a fabricated pass count. Source: `apps/cli/src/lib/session/digest.ts` (`TEST_RUNNERS` classification with `(?![:\w-])` guard, new `parseSummaryLine`, `parseTestOutput`); consumed by `apps/cli/src/lib/session/render.ts` (`renderTestsLine`) and `apps/cli/src/commands/sessions-picker.ts`.
+
+- **Readable `Dirs:` line in `agents sessions`.** The session preview's touched-directories line no longer renders raw Claude project-slugs (`-home-me--agents-…`) or nested worktree paths. Paths under a git worktree collapse to `⧉ <slug>/<remainder>`; a Claude project-slug is matched in slug space (its cwd/`.`-encoding is lossy, so it is never decoded to a fake path) — a slug worktree shows `⧉ <name>` and a slug pointing at the session's own cwd (internal projects-storage scratch) is dropped; real paths still relativize against the session cwd and home (`~`). Source: `apps/cli/src/commands/sessions-picker.ts`.
+
+- **`release.sh` is now a zero-config, self-routing release — runnable from any fleet box with an empty environment.** No routing/secret environment variables: `SIGN_HOST`, `SECRET_HOST`, `SIGN_HOST_REPO`, `FORCE_REMOTE_SIGN`, the `PREFERRED_SIGN_HOSTS` list, the `zion` fallback, and the `agents devices` fleet discovery are all gone. The release has three self-selected homes: git/gh orchestration on the invoking box, the Linux test suite on a **dynamic crabbox** (`scripts/sandbox.sh` selects an available Hetzner VM for the repo's `.crabbox.yaml` profile or warms one — never a hardcoded instance), and build + sign + notarize + `npm publish` + computer-helper on the **`mac-mini` home base** (the one hardcoded name, `RELEASE_HOME_BASE`). The script detects its own host (`scutil --get LocalHostName` / `hostname -s`) and runs the privileged phase on the home base — locally if already there, else over ssh — always by checking out the `v<version>` tag into a throwaway worktree and running **that worktree's** `release.sh --home-base-phase`, so the publishing script is the one carried by the release tag, never the home base's stale on-disk checkout; the worktree is removed on exit on success or failure. The npm token is resolved on the home base and never borrowed to the trigger box. A new shared `scripts/headless-sign-context.sh` factors the headless keychain-unlock + `AGENTS_SECRETS_PASSPHRASE` preamble (no Touch ID) used by both the on-home-base publish and `remote-sign-mac.sh`. A phase tracker (`[n/N]`, N=6 for a normal release, 4 for a catch-up publish) labels each phase with the box it runs on and a ✓/✗ result; a crabbox test failure prints the failing tests + the captured log path and halts before any PR/publish. Idempotency/catch-up/tree-verification guards are preserved. Source: `apps/cli/scripts/release.sh`, `apps/cli/scripts/remote-sign-mac.sh`, `apps/cli/scripts/headless-sign-context.sh`.
+
+- **`agents secrets unlock` now grants globally, so one Touch ID actually covers everything.** An unlock was silently scoped to the ambient `AGENTS_AGENT_NAME`: typed in a plain shell it was stored under a literal `cli` harness, while a read from inside an agent looked under *its* harness (`claude`, `codex`, …). The two never met, so a valid 7-day grant was invisible to every agent for its whole life — `agents secrets exec <bundle>` reported "not unlocked in the secrets agent" while the bundle sat unexpired in the store, and each miss cost another Touch ID or blocked a headless run outright. An unlock with no `--for` is now a global grant that every harness and a plain shell can read; `--for <agent>` still narrows it to one harness, and readers resolve own-harness → global so a narrow grant wins where it applies. The broker's in-memory store and the durable session store share one scope chain, so behavior is identical before and after a daemon restart. Grants already written under the old `cli` scope migrate to global on the next broker start — an unlock you already paid Touch ID for keeps working across the upgrade instead of going unreadable. Source: `apps/cli/src/lib/secrets/scope.ts` (`GLOBAL_HARNESS`, `bundleScopeChain`), `apps/cli/src/lib/secrets/agent.ts` (`get` handler), `apps/cli/src/lib/secrets/session-store.ts` (`resolveSession`, `cli`→global migration), `apps/cli/src/lib/secrets/bundles.ts` (`readAndResolveBundleEnv`), `apps/cli/src/commands/secrets.ts` (`unlock --for`).
+
+- **`agents sessions export <id>` now resolves a short id the same way `sessions
+  <id>` does — by id only, never fuzzy content.** The id-only fix landed for the
+  `sessions` view but `sessions export` still gated its index lookup on
+  `isCompleteSessionId`, so a bare hex short-id like `d3470b57` absent from the
+  discovered pool skipped the index and fell through to the text query — bundling
+  every transcript that merely MENTIONED the id into the export. The one canonical
+  id-shaped test, `looksLikeSessionId`, now lives beside `isCompleteSessionId` in
+  `lib/session/discover.ts` and is shared: `sessions export` resolves any id-shaped
+  selector through the index (exact -> prefix -> `findSessionsById`) and reports
+  "No session with id …" on a miss instead of shipping the mentioner. Source:
+  `apps/cli/src/lib/session/discover.ts`, `apps/cli/src/commands/sessions-export.ts`.
+
+- **Resolve a Claude transcript across every version home, not just the live `~/.claude`.** A session launched under an earlier agent version keeps its transcript under that version's home; resolving only the `~/.claude` symlink (which repoints to the newest installed version) meant that installing a new version silently hid every still-running older-version session — no `sessionFile`, so `agents sessions` rendered it `unknown` and the watchdog skipped it as "no activity timestamp". `findClaudeSessionFile` now searches all version-home project roots via `getAgentSessionDirs`, newest mtime winning. Source: `apps/cli/src/lib/session/active.ts`.
+
 ## 1.20.77
 
 - **Interactive `agents run --host` now tracks the real session for every agent,

package/README.md

@@ -443,6 +443,8 @@ agents hosts check gpu-box              # reachable? which agents-cli version?
 agents run claude --host gpu-box "profile this build"   # headless: follows live by default
 agents run claude --host gpu-box                         # no prompt → interactive TTY over SSH (tmux-backed)
 agents run claude --host gpu-box --copy-creds "fix auth" # copy local runtime creds + Claude token, shred after
+agents run claude --device auto "…"                      # affinity-pick host from 14d usage (harness stays claude)
+agents run claude --host auto "…"                        # same — auto is a host value, not a harness name
 agents hosts ps                         # list dispatched runs + terminal status
 agents hosts stop <id>                  # terminate a hung/detached run (alias: kill)
 agents logs --host gpu-box              # pick a dispatched run — concise summary by default

package/dist/commands/doctor.d.ts

@@ -22,6 +22,7 @@
  * apply pending sync.
  */
 import type { Command } from 'commander';
+import { type FleetDivergenceReport } from '../lib/devices/fleet-divergence.js';
 export declare function wrapLine(prefix: string, text: string, width?: number): string[];
 /**
  * Windows-only advisory lines. When the effective PowerShell execution policy
@@ -33,4 +34,12 @@ export declare function wrapLine(prefix: string, text: string, width?: number):
  * PowerShell.
  */
 export declare function execPolicyWarningLines(platform: NodeJS.Platform, policy: string | null): string[];
+/**
+ * Render the cross-device divergence section for `agents doctor --devices`
+ * (RUSH-2027): a clean all-clear when the fleet agrees, otherwise the specific
+ * gaps — a resource/version present here but missing on a box, or a diverged
+ * config repo — grouped by device, each a plain-language line. Devices that
+ * couldn't be compared (offline / older CLI) are named so the readout is honest.
+ */
+export declare function renderFleetDivergence(report: FleetDivergenceReport): string[];
 export declare function registerDoctorCommand(program: Command): void;

package/dist/commands/doctor.js

@@ -4,6 +4,8 @@ import { addHostOption } from '../lib/hosts/option.js';
 import { buildRemoteAgentsInvocation } from '../lib/hosts/remote-cmd.js';
 import { loadDevices, isControlDevice } from '../lib/devices/registry.js';
 import { fanOutDevices } from '../lib/devices/fleet.js';
+import { compareFleetInventories } from '../lib/devices/fleet-divergence.js';
+import { collectLocalFleetInventory } from '../lib/devices/fleet-inventory.js';
 import { resolveHost } from '../lib/hosts/registry.js';
 import { sshExecAsync } from '../lib/ssh-exec.js';
 import { sshTargetFor } from '../lib/hosts/types.js';
@@ -24,6 +26,7 @@ import { heal, healChangedAnything } from '../lib/heal.js';
 import { blocksLocalScripts, getEffectiveExecutionPolicy } from '../lib/platform/winpath.js';
 import { scanUserRcFiles, rcSecretWarningLines } from '../lib/secrets/rc-hygiene.js';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
+import { readRepoBehindMarkers } from '../lib/auto-pull.js';
 import * as fs from 'fs';
 const AGENT_NAMES = Object.fromEntries(ALL_AGENT_IDS.map((id) => [id, AGENTS[id].name]));
 // ─── overview mode (no target) ────────────────────────────────────────────────
@@ -61,7 +64,7 @@ function printWrappedLine(prefix, text) {
     for (const line of wrapLine(prefix, text))
         console.log(chalk.gray(line));
 }
-function renderOverviewText(clis, syncRows, orphanRows, hostClis, signIn) {
+function renderOverviewText(clis, syncRows, orphanRows, hostClis, signIn, repoBehindMarkers) {
     console.log(chalk.bold('Agent CLIs'));
     // Show the fleet you actually run — agents that are ready in PATH, plus any
     // you MANAGE (have installed versions) whose binary isn't resolving (a real
@@ -182,6 +185,10 @@ function renderOverviewText(clis, syncRows, orphanRows, hostClis, signIn) {
     // environment (readable via /proc/<pid>/environ) — the RUSH-1968 class. Flag
     // them here so the master passphrase never silently lives in `~/.zshenv` again.
     renderRcHygieneAdvisory();
+    // Repos that are behind upstream — surfaced here instead of on stderr during
+    // every command. Markers are written by the background fetch worker and persist
+    // until the user runs `agents repo pull <alias>`.
+    renderRepoBehindAdvisory(repoBehindMarkers);
 }
 // ─── windows execution-policy advisory ─────────────────────────────────────────
 /**
@@ -217,6 +224,25 @@ function renderRcHygieneAdvisory() {
         console.log(chalk.gray(`           ${line}`));
     }
 }
+// ─── repo-behind advisory ─────────────────────────────────────────────────────
+/**
+ * Render repo-behind notices from background fetch markers as a "Repo updates"
+ * section in `agents doctor`. Reads without consuming the markers so repeated
+ * invocations keep showing the notice until the user runs `agents repo pull`.
+ */
+function renderRepoBehindAdvisory(markers) {
+    const behind = markers.filter((m) => m.behind > 0);
+    if (behind.length === 0)
+        return;
+    console.log();
+    console.log(chalk.bold('Repo updates'));
+    for (const m of behind) {
+        const label = m.alias === 'user' ? '~/.agents/' : m.alias;
+        const commits = `${m.behind} commit${m.behind === 1 ? '' : 's'}`;
+        console.log(`  ${chalk.yellow('warn ')}  ${label} is ${commits} behind ${m.branch}`);
+        console.log(chalk.gray(`           run \`agents repo pull ${m.alias}\` to update`));
+    }
+}
 function renderExecPolicyAdvisory() {
     // Only probe the policy on Windows — getEffectiveExecutionPolicy() spawns
     // powershell, which is a wasted (doomed) process on POSIX where the advisory
@@ -314,29 +340,74 @@ async function probeFleetTarget(target) {
         };
     }
 }
+/**
+ * Fetch a device's harness inventory by running its top-level `agents doctor
+ * --json` (which carries the `fleet` field, RUSH-2027). Separate from
+ * {@link probeFleetTarget} — that forwards `teams doctor --json` for per-agent
+ * readiness, a different payload. Returns the parsed {@link FleetInventory} or
+ * null (unreachable, non-zero exit, unparseable, or an older CLI with no
+ * `fleet` field); a null is skipped by the comparator, never a false gap.
+ */
+async function probeFleetInventory(target) {
+    const isWin = /^win/i.test((target.os ?? '').trim());
+    const remoteCmd = buildRemoteAgentsInvocation(['doctor', '--json'], undefined, isWin ? 'windows' : undefined, isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' });
+    const res = await sshExecAsync(target.sshTarget, remoteCmd, { timeoutMs: 30000, multiplex: true });
+    if (res.code !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(res.stdout);
+        return parsed.fleet ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 async function runDevicesDoctor(opts) {
     const singleName = opts.host || opts.device;
     const targets = await resolveFleetTargets(opts);
     const localName = machineId();
     const results = [];
-    // Local machine first, directly.
+    // Local machine first, directly. Its inventory is collected in-process — no
+    // SSH round-trip to this box.
     if (!singleName) {
-        results.push({ name: localName, online: true, agents: await collectTeamsDoctorData() });
+        results.push({
+            name: localName,
+            online: true,
+            agents: await collectTeamsDoctorData(),
+            inventory: collectLocalFleetInventory(opts.cwd ?? process.cwd()),
+        });
     }
-    // Remote targets in parallel, through the shared fleet fan-out helper.
-    const remoteResults = await fanOutDevices(targets, probeFleetTarget);
+    // Remote targets in parallel: agent readiness (teams doctor) and the harness
+    // inventory (top-level doctor --json) in one fan-out per concern. Both run
+    // through the shared fleet helper so an offline box degrades to a skipped row.
+    const [remoteResults, inventoryResults] = await Promise.all([
+        fanOutDevices(targets, probeFleetTarget),
+        fanOutDevices(targets, probeFleetInventory),
+    ]);
+    const inventoryByName = new Map();
+    for (const r of inventoryResults)
+        inventoryByName.set(r.name, r.status === 'ok' ? (r.value ?? null) : null);
     results.push(...remoteResults.map((r) => {
+        const inventory = inventoryByName.get(r.name) ?? undefined;
         if (r.status === 'ok' && r.value)
-            return r.value;
+            return { ...r.value, inventory: inventory ?? undefined };
         return {
             name: r.name,
             online: false,
             error: r.error ?? String(r.reason ?? 'skipped'),
             agents: {},
+            inventory: inventory ?? undefined,
         };
     }));
+    // Cross-device divergence: compare every device's inventory against the local
+    // baseline and flag resources / agent versions / repo state present on one box
+    // but missing on another (RUSH-2027). A single-device filter has no baseline
+    // to compare against, so the section is only meaningful for the full fan-out.
+    const divergence = singleName
+        ? null
+        : compareFleetInventories(results.map((r) => ({ name: r.name, inventory: r.inventory ?? null })), localName);
     if (opts.json) {
-        console.log(JSON.stringify({ devices: results }, null, 2));
+        console.log(JSON.stringify({ devices: results, fleet: divergence }, null, 2));
         return;
     }
     if (results.length === 0) {
@@ -360,6 +431,49 @@ async function runDevicesDoctor(opts) {
     }
     console.log();
     console.log(chalk.gray('  rdy* = installed and signed in · rdy = installed · no = not installed · err = probe failed · - = offline'));
+    if (divergence) {
+        console.log();
+        for (const line of renderFleetDivergence(divergence))
+            console.log(line);
+    }
+}
+/**
+ * Render the cross-device divergence section for `agents doctor --devices`
+ * (RUSH-2027): a clean all-clear when the fleet agrees, otherwise the specific
+ * gaps — a resource/version present here but missing on a box, or a diverged
+ * config repo — grouped by device, each a plain-language line. Devices that
+ * couldn't be compared (offline / older CLI) are named so the readout is honest.
+ */
+export function renderFleetDivergence(report) {
+    const lines = [chalk.bold('Cross-device divergence')];
+    const skippedNote = report.skippedDevices.length > 0
+        ? chalk.gray(`  (not compared: ${report.skippedDevices.join(', ')} — offline or no inventory)`)
+        : null;
+    if (!report.hasDivergence) {
+        lines.push(chalk.green(`  Fleet is consistent — every compared device matches ${report.baseline}.`));
+        if (skippedNote)
+            lines.push(skippedNote);
+        return lines;
+    }
+    // Group findings by the LAGGING device so a box with several gaps reads as one
+    // block AND the remediation points at the right box. For a `*-missing-local`
+    // finding the resource is absent on the local baseline (present on `d.device`),
+    // so the box that's behind is the baseline — not the remote that has it.
+    const byDevice = new Map();
+    for (const d of report.divergences) {
+        const lagging = d.kind.endsWith('-missing-local') ? report.baseline : d.device;
+        (byDevice.get(lagging) ?? byDevice.set(lagging, []).get(lagging)).push(d);
+    }
+    for (const device of Array.from(byDevice.keys()).sort()) {
+        lines.push(`  ${chalk.yellow('⚠')} ${chalk.bold(device)}`);
+        for (const d of byDevice.get(device)) {
+            lines.push(chalk.gray(`      ${d.message}`));
+        }
+    }
+    if (skippedNote)
+        lines.push(skippedNote);
+    lines.push(chalk.gray('  Read-only — run `agents apply` or `agents repo pull` on a lagging box to reconcile.'));
+    return lines;
 }
 function parseTargetArg(arg) {
     const at = arg.indexOf('@');
@@ -647,7 +761,7 @@ export function registerDoctorCommand(program) {
         .option('--cwd <path>', 'Resolution cwd for project layer detection (default: process.cwd())')
         .option('--adopt <agent>', "Take over the agent's native launcher that shadows the shim (symlink it to the version-managed shim; reversible with --release)")
         .option('--release <agent>', 'Undo --adopt: restore the native launcher agents-cli previously adopted')
-        .option('--devices', 'Check agent readiness on every registered device (alias --hosts)')
+        .option('--devices', 'Check agent readiness AND cross-device harness divergence (missing resources/versions, repo drift) on every registered device (alias --hosts)')
         .option('--hosts', 'Alias of --devices');
     setHelpSections(doctorCmd, {
         examples: `
@@ -671,6 +785,10 @@ export function registerDoctorCommand(program) {
 
       # Heal just one agent (all its installed versions)
       agents doctor claude --fix
+
+      # Fleet: agent readiness + cross-device divergence (missing plugins/skills,
+      # agent-version gaps, .agents/.system repo drift) vs this machine
+      agents doctor --devices
     `,
     });
     doctorCmd.action(async (target, opts) => {
@@ -758,6 +876,7 @@ export function registerDoctorCommand(program) {
             const syncRows = checkSyncStatus(cwd);
             const orphanRows = countOrphans();
             const hostClis = listCliStatus(cwd);
+            const repoBehindMarkers = readRepoBehindMarkers();
             // Advisory login state per installed agent (file-based getAccountInfo,
             // no home → the account-global/active credential). Best-effort: a probe
             // failure just leaves that agent's badge as "logged out".
@@ -782,6 +901,12 @@ export function registerDoctorCommand(program) {
                     auth: summarizeHostAuth(readAuthHealthCache(), machineId()),
                     sync: syncRows,
                     orphans: orphanRows,
+                    // This host's harness inventory — installed resources per kind,
+                    // installed version ids per agent, and `.agents`/`.system` repo
+                    // state — so `agents doctor --devices` can compare presence across
+                    // the fleet and flag a resource/version present here but missing
+                    // elsewhere (RUSH-2027). Read-only; no network.
+                    fleet: collectLocalFleetInventory(cwd),
                     hostClis: {
                         statuses: hostClis.statuses.map((s) => ({
                             name: s.manifest.name,
@@ -791,10 +916,19 @@ export function registerDoctorCommand(program) {
                         })),
                         errors: hostClis.errors,
                     },
+                    // Repos behind upstream — emitted here so menubar and other consumers
+                    // can surface the notices without reading stderr from normal commands.
+                    repos: repoBehindMarkers.map((m) => ({
+                        alias: m.alias,
+                        dir: m.dir,
+                        behind: m.behind,
+                        branch: m.branch,
+                        fetchedAt: m.fetchedAt,
+                    })),
                 }, null, 2));
                 return;
             }
-            renderOverviewText(clis, syncRows, orphanRows, hostClis, signIn);
+            renderOverviewText(clis, syncRows, orphanRows, hostClis, signIn, repoBehindMarkers);
             // Point at the interactive reconcile when anything is out of sync — the
             // report shouldn't be a dead end. `agents status` runs the unified
             // home-reading engine and offers to sync (opt-in, never auto-fires here).

package/dist/commands/exec.js

@@ -383,8 +383,8 @@ export function registerRunCommand(program) {
         .option('--budget <tokens>', 'Loop token hard-cap: stop once cumulative tokens reach this (stoppedBy: budget), enforced outside the agent. Loop only.')
         .option('--until <signal>', 'Loop stop condition. `signal` reads <runDir>/loop-signal.json {continue,reason} each iteration; absent or continue:false stops (fail-closed). Loop only.')
         .option('--interval <dur>', 'Loop delay between iterations ("0" back-to-back, "30m" paces). Loop only.')
-        .option('--host <name>', 'Offload this run onto another machine over SSH instead of running locally — a device, a registered agent host, or user@host. See `agents devices` / `agents hosts`.')
-        .option('--device <name>', 'Alias of --host: offload this run onto a registered device (from `agents devices`).')
+        .option('--host <name>', 'Offload this run onto another machine over SSH — a device name, registered host, or user@host. Pass "auto" to pick from 14d usage affinity (most-used online device has highest probability). See `agents devices`.')
+        .option('--device <name>', 'Alias of --host. Pass "auto" for affinity-based device pick (same as --host auto).')
         .option('--remote-cwd <dir>', "Explicit host working directory for --host runs, used VERBATIM (overrides --cwd; usually --cwd suffices — it re-roots a local-home path onto the remote home). Pass a single-quoted '$HOME/…' or a valid remote absolute path; a local ~ expands here and won't exist there (/Users/you vs /home/you).")
         .option('--no-follow', 'With --host, dispatch detached and return immediately (track via `agents hosts ps/logs`).')
         .option('--any', 'With --host <cap> (a capability tag), pick any matching host instead of erroring when several match.')
@@ -399,6 +399,8 @@ export function registerRunCommand(program) {
     // `--on` and `--computer` are hidden aliases of `--host` — same behavior.
     runCmd.addOption(new Option('--on <name>', 'Alias of --host.').hideHelp());
     runCmd.addOption(new Option('--computer <name>', 'Alias of --host.').hideHelp());
+    // Deprecated one-release alias: `agents run … --smart` → treat as `--device auto`.
+    runCmd.addOption(new Option('--smart', 'Deprecated: use --device auto (affinity host pick).').hideHelp());
     // Internal: the `--host` dispatch forwards this so the REMOTE run prints its
     // resolved session id as a one-line stdout sentinel (hosts/session-marker.ts),
     // letting the launcher relate the remote-created session back to itself for
@@ -495,11 +497,14 @@ export function registerRunCommand(program) {
         // their existing meaning in every dispatch path below.
         const accountPicker = parseRunAccountPickerRequest(agentSpec);
         const accountPickerRequested = accountPicker.requested;
-        const normalizedAgentSpec = accountPicker.normalizedAgentSpec;
+        let normalizedAgentSpec = accountPicker.normalizedAgentSpec;
         if (!accountPicker.valid) {
             console.error(chalk.red(`Invalid account picker target: ${agentSpec}. Use agents run <agent>@.`));
             process.exit(1);
         }
+        // Account-picker conflict check runs BEFORE device=auto may set balanced,
+        // so an implicit balanced preference never surfaces as a fake
+        // "cannot be combined with --balanced" when the user only typed trailing @.
         if (accountPickerRequested) {
             const conflicts = runAccountPickerConflicts(options);
             if (conflicts.length > 0) {
@@ -508,6 +513,27 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
         }
+        // --device auto / --host auto (and deprecated --smart): affinity-pick host.
+        // Harness is always the agent the user typed — never auto-picked.
+        // Affinity failure degrades to local (does not kill the run).
+        {
+            const { applyDeviceAutoToOptions } = await import('../lib/smart-launch.js');
+            const result = applyDeviceAutoToOptions(options, {
+                accountPickerRequested,
+            });
+            if (!options.quiet && result.deprecationSmart) {
+                process.stderr.write(chalk.yellow('[agents] --smart is deprecated; use --device auto\n'));
+            }
+            if (!options.quiet && result.skipped) {
+                process.stderr.write(chalk.yellow(`[agents] device=auto skipped: ${result.skipped} (running local)\n`));
+            }
+            if (!options.quiet && result.banner) {
+                const { hostLabel, deviceHint, acctNote } = result.banner;
+                process.stderr.write(chalk.gray(`[agents] device=auto → ${hostLabel}` +
+                    (deviceHint ? ` (affinity ${deviceHint})` : '') +
+                    ` · ${acctNote}\n`));
+            }
+        }
         // --lease: invent a disposable cloud box for this run (via crabbox), run
         // the agent there, then tear it down. --box: reuse a named warm crabbox
         // box, run the same bootstrap there, and leave the box running.

package/dist/commands/repo.js

@@ -856,6 +856,10 @@ export function registerRepoCommands(program) {
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);
+                // A failed repo must fail the command. Without this, `agents fleet run
+                // "agents repo pull user"` reported 11 ok across a fleet that pulled
+                // nothing — the silence that hid RUSH-2056. Matches commands/sync.ts.
+                process.exitCode = 1;
             }
         }
         // RUSH-1980: a pull rewrites the routine YAML on disk, but the daemon's
@@ -911,6 +915,10 @@ export function registerRepoCommands(program) {
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);
+                // A failed repo must fail the command. Without this, `agents fleet run
+                // "agents repo push user"` reported ok across a fleet that pushed
+                // nothing — the silence that hid RUSH-2056. Matches commands/sync.ts.
+                process.exitCode = 1;
             }
         }
     });

package/dist/commands/routines.js

@@ -297,8 +297,10 @@ export function registerRoutinesCommands(program) {
         - Detached/daemon fires use the pre-flight pick only (next tick re-selects).
         - Diagnostic lines log which account was picked, which were skipped, and
           each failover hop: look for "[agents] routine <name>:" in the run log.
-        - Headless Claude auth: store CLAUDE_CODE_OAUTH_TOKEN in the 'claude'
-          secrets bundle so the daemon can inject it into routine spawns.
+        - Claude auth: a routine authenticates through the pinned account's own
+          on-disk login (the same one 'agents run claude' uses on this device).
+          The daemon injects no token; if that account's login has expired the
+          run is skipped up front with a re-login hint.
     `,
     });
     routinesCmd

package/dist/commands/secrets.js

@@ -22,6 +22,7 @@ import { bundleBackend, bundleExists, bundleItemStore, bundlePolicy, deleteBundl
 import { encryptForFallback, decryptForFallback } from '../lib/secrets/filestore.js';
 import { getKeychainToken, getKeychainTokens, hasKeychainToken, secretsKeychainItem, setKeychainToken, } from '../lib/secrets/index.js';
 import { assertOpAvailable, createPasswordItem, deleteItemByTitle, extractSecrets, itemExistsByTitle, listItems, listVaults, } from '../lib/onepassword.js';
+import { GLOBAL_HARNESS } from '../lib/secrets/scope.js';
 import { secretsHoldMs, secretsAgentDurable, agentLoad, agentLock, agentPing, agentStatus, ensureAgentRunning, runAgentLoadFromStdin, runSecretsAgent, uninstallSecretsAgentService, } from '../lib/secrets/agent.js';
 import { saveSession, deleteBundleSessions, deleteAllSessions } from '../lib/secrets/session-store.js';
 import { getCliVersionFresh } from '../lib/version.js';
@@ -2057,7 +2058,7 @@ Examples:
         .description('Hold a bundle in the secrets-agent after one Touch ID, so concurrent runs read it without re-prompting (macOS). With --host, unlock FILE-backed bundle(s) on a remote (the passphrase prompt surfaces over the SSH TTY); keychain/biometry bundles are GUI-only and can\'t be remote-unlocked.')
         .option('--ttl <duration>', 'How long to hold it (e.g. 30m, 8h, 3d). Default 7d.')
         .option('--durable', 'Keep the unlock across sleep + reboot too (default: survives upgrade/restart but re-locks on sleep). Set secrets.agent.durable in agents.yaml to make this the default.')
-        .option('--for <agent>', 'Scope the unlock to one harness type (for example claude, codex, or kimi).')
+        .option('--for <agent>', 'Narrow the unlock to ONE harness type (for example claude, codex, or kimi). Default: the grant is global — every harness and a plain shell can read it, so one Touch ID covers them all.')
         .option('--all', 'Unlock every configured bundle')
         .option('--host <target>', 'Unlock the bundle(s) on this remote machine over SSH instead of locally (file-backed bundles only — the remote\'s passphrase prompt surfaces on your terminal over a -tt session). Single-valued (NOT variadic) so it never swallows the bundle name: `unlock <name> --host <machine>`.')
         .action(async (names, opts) => {
@@ -2130,7 +2131,12 @@ Examples:
         // (single-instance start lock, #414) and best-effort — never blocks unlock.
         ensureDaemonStarted();
         let loaded = 0;
-        const harness = opts.for || process.env.AGENTS_AGENT_NAME || 'cli';
+        // An unlock is a deliberate act, so it grants GLOBALLY unless `--for`
+        // narrows it to one harness. It must NOT inherit the ambient
+        // AGENTS_AGENT_NAME: that silently scoped a terminal unlock to whichever
+        // agent happened to launch the shell, leaving the grant unreadable to
+        // every other reader for its whole TTL.
+        const harness = opts.for || GLOBAL_HARNESS;
         for (const name of targets) {
             try {
                 // noAgent: read the real keychain (one Touch ID) rather than the

package/dist/commands/sessions-browser.d.ts

@@ -9,7 +9,8 @@
  * Built on {@link dynamicPicker}; every data source (discover, fleet, live index,
  * preview, resume dispatch) is reused from the existing sessions plumbing.
  */
-import type { SessionMeta } from '../lib/session/types.js';
+import { type SessionMeta } from '../lib/session/types.js';
+import type { ActiveSession } from '../lib/session/active.js';
 /**
  * The single canonical filter state. Every field has a flag equivalent, so the
  * same view is reachable interactively (hotkeys) or from the command line (flags).
@@ -59,11 +60,14 @@ export declare function activeBrowserSeed(opts: {
     agent?: string;
     host?: string[];
     since?: string;
+    all?: boolean;
 }): Partial<BrowserFilter>;
 /**
  * The initial filter for the bare interactive listing: current-repo subtree by
- * default (matches the static overview's cwd scoping), `--all` widens to every
- * directory, `--since` seeds the window.
+ * default (matches the static overview's cwd scoping). `--all` sets every
+ * non-status filter to its "all" value — every directory (project) AND all-time
+ * (window) — so one flag maxes the view; `--since` still overrides the window and
+ * `-a`/`--device` still narrow their axis.
  */
 export declare function bareBrowserSeed(opts: {
     teams?: boolean;
@@ -71,6 +75,44 @@ export declare function bareBrowserSeed(opts: {
     all?: boolean;
     since?: string;
 }): Partial<BrowserFilter>;
+/**
+ * A live session's stable row key: its session id when the agent reported one,
+ * else a per-machine handle so an id-less live session (a just-booted harness, a
+ * cloud task) still gets exactly one row instead of being dropped. Cloud rows key
+ * on the task id because they have no pid — keying them all on the machine alone
+ * would collapse two cloud tasks into one row, the same silent-drop this whole
+ * change exists to remove.
+ */
+export declare function liveRowKey(a: ActiveSession, self: string): string;
+/** Index live sessions by {@link liveRowKey} — the join key between the live scan
+ *  and the transcript pool. Id-carrying rows key on the session id, so a live row
+ *  and its transcript row collapse to one. */
+export declare function indexLiveRows(rows: ActiveSession[], self: string): Map<string, ActiveSession>;
+/**
+ * Project a live session onto the picker's row shape, for a session the transcript
+ * pool doesn't carry — a peer's session, a transcript outside the current window,
+ * or an agent that has not written one yet. `filePath` is the live transcript path
+ * when the scan resolved one and empty otherwise, which is what
+ * {@link handlePickedSession} keys "there is nothing to open yet" off.
+ */
+export declare function liveSessionToMeta(a: ActiveSession, self: string): SessionMeta;
+/**
+ * Fold the live scan INTO the transcript pool. The running filter used to be a
+ * pure intersection (`pool ∩ live`), which meant a session had to already be in
+ * the pool to be shown as running — so every session on another machine, and
+ * every local one outside the pool's window, was invisible in the browser while
+ * `--active --json` listed it. Live sessions the pool lacks are appended as their
+ * own rows, then the whole set is grouped local-machine-first.
+ */
+export declare function mergeLiveIntoPool(rows: SessionMeta[], live: Map<string, ActiveSession>, self: string): SessionMeta[];
+/**
+ * Whether to render the host-program column. It belongs to the running view
+ * only, so this gates on the FILTER — not on the live index being populated.
+ * `liveCache` outlives a toggle of the `r` hotkey, so testing `live` alone would
+ * keep the column after running is turned back off, widening a plain transcript
+ * listing that has no live rows to explain it.
+ */
+export declare function shouldShowHostColumn(f: BrowserFilter, live: Map<string, ActiveSession> | null, rows: SessionMeta[]): boolean;
 /**
  * Launch the interactive session browser. `initial` seeds the filter (e.g.
  * `{ running: true }` for `--active`). Resolves after the user resumes a session