@phnx-labs/agents-cli 1.20.74 → 1.20.77

package/dist/commands/setup-computer.js

@@ -37,7 +37,7 @@ export async function runComputerWizard() {
         return false;
     }
     // 1. Download + verify + install the signed, notarized helper.
-    console.log(chalk.bold('Installing the Computer Helper...'));
+    console.log(chalk.bold('Installing the Agents Computer helper...'));
     try {
         await installComputerHelperMacLocal();
     }
@@ -57,7 +57,7 @@ export async function runComputerWizard() {
     }
     // 3. Guide the two permission grants if not already trusted.
     if (!trusted) {
-        console.log(chalk.bold('\nGrant two permissions to "Computer Helper" (one-time):'));
+        console.log(chalk.bold('\nGrant two permissions to "Agents Computer" (one-time):'));
         console.log('  1. ' + chalk.cyan('Accessibility') + chalk.dim('     — lets it click/type'));
         console.log('  2. ' + chalk.cyan('Screen Recording') + chalk.dim('  — lets it screenshot windows'));
         console.log(chalk.dim('\nOpening System Settings > Privacy & Security ...'));

package/dist/commands/ssh.d.ts

@@ -10,6 +10,7 @@
  * rsync / `agents sessions --host` resolve the same logical names.
  */
 import type { Command } from 'commander';
+import { type FanOutDeviceTarget } from '../lib/devices/fleet.js';
 import { type CrabboxBox } from '../lib/crabbox/cli.js';
 /**
  * Live "Leased boxes" section for `agents devices` (F4, RUSH-1923), computed
@@ -19,5 +20,17 @@ import { type CrabboxBox } from '../lib/crabbox/cli.js';
  * the row formatting is deterministic in tests.
  */
 export declare function renderLeasedBoxesSection(boxes: CrabboxBox[], nowSecs: number): string[];
+/**
+ * Race `fanOut` against an overall wall-clock deadline (RUSH-2041).
+ *
+ * If `fanOut` settles first the result passes through unchanged. If the
+ * deadline fires first every pending remote target is mapped to `failed` (or
+ * `skipped` for pre-skipped targets), so callers always get a complete result
+ * array and the command exits promptly rather than hanging.
+ *
+ * Exported so the unit test can exercise the real path with a hanging probe
+ * instead of reimplementing the logic.
+ */
+export declare function raceFleetPingDeadline<T, Target extends FanOutDeviceTarget>(fanOut: Promise<import('../lib/devices/fleet.js').FanOutDeviceResult<T>[]>, remoteTargets: Target[], overallTimeoutMs: number): Promise<import('../lib/devices/fleet.js').FanOutDeviceResult<T>[]>;
 /** Register both `agents ssh` and `agents devices`. */
 export declare function registerSshCommands(program: Command): void;

package/dist/commands/ssh.js

@@ -20,21 +20,22 @@ import { readAndResolveBundleEnv, isHeadlessSecretsContext } from '../lib/secret
 import { machineId } from '../lib/session/sync/config.js';
 import { registerFleetCaptureCommand } from './fleet-capture.js';
 import { registerFleetApplyAlias } from './apply.js';
-import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, } from '../lib/devices/registry.js';
+import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, writeReachability, } from '../lib/devices/registry.js';
+import { collectReachabilityWriteBacks, deviceOnlineState } from '../lib/devices/reachability.js';
 import { addControlToken } from '../lib/serve/token.js';
 import { DEFAULT_SERVE_PORT } from '../lib/serve/server.js';
 import { nodeToDeviceInput, parseTailscaleStatus, tailscaleStatusJson, } from '../lib/devices/tailscale.js';
-import { localLoginUser, planDeviceReconciliation, runDeviceSync, withDefaultUser } from '../lib/devices/sync.js';
+import { defaultPickerChecked, localLoginUser, planDeviceReconciliation, runDeviceSync, withDefaultUser } from '../lib/devices/sync.js';
 import { resolveDeviceTarget, splitUserHost } from '../lib/devices/resolve-target.js';
 import { clearPendingSentinel } from '../lib/devices/pending.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { hostNameFor, renderSshConfig } from '../lib/devices/ssh-config.js';
-import { ASKPASS_BUNDLE_ENV, ASKPASS_KEY_ENV, buildSshInvocation, fleetDialTarget, writeAskpassShim, } from '../lib/devices/connect.js';
+import { ASKPASS_BUNDLE_ENV, ASKPASS_KEY_ENV, ASKPASS_AGENT_ONLY_ENV, buildSshInvocation, fleetDialTarget, writeAskpassShim, } from '../lib/devices/connect.js';
 import { ensureManagedKnownHostsDir, isHostPinned } from '../lib/devices/known-hosts.js';
 import { shouldSyncTerminfo, syncTerminfoToDevice, terminfoHostKey } from '../lib/devices/terminfo.js';
-import { fanOutDevices, planFleetTargets, remoteFleetTargets, runFleet, skipLabel, upgradeCommand, } from '../lib/devices/fleet.js';
+import { fanOutDevices, fleetHealthSkip, planFleetTargets, remoteFleetTargets, runFleet, skipLabel, upgradeCommand, } from '../lib/devices/fleet.js';
 import { fleetCapacity, fmtBytes, headroom, } from '../lib/devices/health.js';
-import { buildFleetHealthReport, renderFleetMatrix, renderFleetWarnings, } from '../lib/devices/health-report.js';
+import { buildFleetHealthReport, renderFleetMatrix, renderFleetSummary, renderFleetWarnings, } from '../lib/devices/health-report.js';
 import { loadFleetStats, readStatsCache } from '../lib/devices/stats-cache.js';
 import { checkSyncStatus, countOrphans } from '../lib/drift.js';
 import { checkAllClis } from '../lib/teams/agents.js';
@@ -47,14 +48,17 @@ import { authCellColor, formatCheckedAge, isDeadVerdict, probeLocalFleetAuth, re
 import { runFleetLogin } from '../lib/fleet/remote-login.js';
 /** One-line summary of a device for `list`. `isSelf` marks the machine this
  * command is running on so it stands out from the rest of the tailnet. */
-function deviceSummary(d, isSelf = false) {
+function deviceSummary(d, isSelf = false, stats) {
     const addr = hostNameFor(d) ?? chalk.gray('no address');
-    const online = d.tailscale
-        ? d.tailscale.online
-            ? chalk.green('online')
-            : chalk.gray('offline')
-        : chalk.gray('unknown');
-    const reach = d.tailscale?.online && !d.tailscale.direct ? chalk.yellow(' (relayed)') : '';
+    // Prefer a fresh live verdict (this run's probe, else the written-back
+    // reachability) over the stale tailscale.online snapshot (RUSH-1965).
+    const state = deviceOnlineState(d, stats);
+    const online = state === 'online'
+        ? chalk.green('online')
+        : state === 'offline'
+            ? chalk.gray('offline')
+            : chalk.gray('unknown');
+    const reach = state === 'online' && d.tailscale && !d.tailscale.direct ? chalk.yellow(' (relayed)') : '';
     const marker = isSelf ? chalk.cyan('▸ ') : '  ';
     const name = isSelf ? chalk.bold.cyan(d.name.padEnd(16)) : chalk.bold(d.name.padEnd(16));
     const here = isSelf ? chalk.cyan('  ← this machine') : '';
@@ -106,8 +110,11 @@ function renderDeviceTable(reg, names, self, statsMap, full = false) {
         const marker = isSelf ? chalk.cyan('▸ ') : '  ';
         const label = isSelf ? chalk.bold.cyan(name.padEnd(16)) : chalk.bold(name.padEnd(16));
         const plat = String(d.platform).padEnd(8);
-        const offline = d.tailscale && !d.tailscale.online;
         const stats = statsMap.get(name);
+        // Prefer this run's live probe, then the written-back verdict, over the
+        // stale tailscale.online snapshot — so a reachable box never renders
+        // "offline" while its live load/mem sit one column over (RUSH-1965).
+        const offline = deviceOnlineState(d, stats) === 'offline';
         if (offline) {
             lines.push(`${marker}${label}${plat} ${chalk.gray('offline')}`);
             continue;
@@ -243,13 +250,16 @@ async function runInteractiveDeviceSync() {
             // Everything not already dismissed starts checked, so pressing Enter keeps
             // the fleet as-is (matching what auto-sync would register). Unchecking a
             // device removes it AND dismisses it so auto-sync never re-adds it.
+            // Sharee nodes (shared in by another user) start unchecked unless already
+            // registered — registering one must be a deliberate check, never the
+            // default Enter.
             message: 'Your fleet — uncheck a device to remove and stop suggesting it:',
             pageSize: Math.min(nodes.length, 20),
             choices: nodes.map((n) => {
-                const flags = [n.platform, n.online ? undefined : 'offline', ignored.has(n.name) ? 'ignored' : undefined]
+                const flags = [n.platform, n.online ? undefined : 'offline', n.sharee ? 'shared' : undefined, ignored.has(n.name) ? 'ignored' : undefined]
                     .filter(Boolean)
                     .join(', ');
-                return { value: n.name, name: `${n.name}  ${chalk.gray(`(${flags})`)}`, checked: !ignored.has(n.name) };
+                return { value: n.name, name: `${n.name}  ${chalk.gray(`(${flags})`)}`, checked: defaultPickerChecked(n, registered, ignored) };
             }),
         });
     }
@@ -347,26 +357,23 @@ async function runFleetStatus(opts) {
     const statsMap = opts.stats === false
         ? new Map()
         : (await loadFleetStats(probeable, { forceRefresh, selfName: self })).stats;
+    // Persist the live probe's reachability verdict so the online/offline word is
+    // read from a fresh probe, not a stale tailscale snapshot (RUSH-1965).
+    // Best-effort: a registry write must never break the status render.
+    await writeReachability(collectReachabilityWriteBacks(reg, statsMap)).catch(() => { });
     const rows = [localHealthRow(self, statsMap.get(self))];
     const remoteTargets = remoteFleetTargets(planned, self)
         .map((t) => ({
         name: t.device.name,
         platform: t.device.platform,
-        skip: t.skip,
+        // Fail fast: gate the expensive version+doctor dials on the reachability
+        // verdict the cheap stats probe already computed one step earlier. A box
+        // it found unreachable skips straight to an `unreachable` row instead of
+        // burning 15s+30s per box — so one genuinely-offline device can't stall
+        // the matrix for ~60s (RUSH-1964). See {@link fleetHealthSkip} for why
+        // this is trusted on the default path, not just under `--refresh`.
+        skip: fleetHealthSkip(t.skip, statsMap.get(t.device.name)),
         dialTarget: fleetDialTarget(t.device),
-        // Fail fast: the stats probe already tried this box with the same
-        // (registry) address. If it came back unreachable, don't spend another
-        // 15s+30s on version+doctor — skip straight to an unreachable row so one
-        // genuinely-offline device can't stall the whole matrix.
-        //
-        // Only trust this on a FRESH probe (`--refresh`/`--live`). loadFleetStats
-        // is cache-first (daemon-warmed ~3min), so a box that came back online
-        // since the last warm would otherwise be skipped to "unreachable" without
-        // a live attempt — a false negative. On a default run we still do the live
-        // probe (fast now that it dials the registry address).
-        ...(forceRefresh && statsMap.get(t.device.name)?.reachable === false && !t.skip
-            ? { skip: 'unreachable' }
-            : {}),
     }));
     const remote = await fanOutDevices(remoteTargets, probeRemoteHealth);
     for (const result of remote) {
@@ -400,18 +407,32 @@ async function runFleetStatus(opts) {
     for (const row of rows) {
         if (!row.auth)
             row.auth = summarizeHostAuth(authCache, row.name);
+        // Resolve the online/offline verdict and last-seen once (RUSH-1966) so the
+        // summary view reads one truth — the same `deviceOnlineState` ordering the
+        // registry write-back uses — instead of re-deriving it from error/skipped.
+        const profile = reg[row.name];
+        if (profile) {
+            row.online = deviceOnlineState(profile, statsMap.get(row.name));
+            row.lastSeen = profile.tailscale?.lastSeen ?? profile.reachability?.checkedAt;
+        }
     }
     const report = buildFleetHealthReport(rows);
     if (opts.json) {
         console.log(JSON.stringify(report, null, 2));
     }
-    else {
+    else if (opts.verbose) {
+        // Full grid: the auth/CLI/sync/version columns and the warnings rollup.
         for (const line of renderFleetWarnings(report))
             console.log(line);
         console.log();
         for (const line of renderFleetMatrix(report))
             console.log(line);
     }
+    else {
+        // Default: rollup + NEEDS ATTENTION + OS-grouped quiet rows + footer.
+        for (const line of renderFleetSummary(report, { self }))
+            console.log(line);
+    }
     if (opts.strict && report.hasWarnings)
         process.exitCode = 1;
 }
@@ -420,13 +441,43 @@ async function probeRemoteAuth(target) {
     const isWin = /^win/i.test((target.platform ?? '').trim());
     const env = isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' };
     const cmd = buildRemoteAgentsInvocation(['devices', 'ping', '--local', '--json'], undefined, isWin ? 'windows' : undefined, env);
-    const res = await sshExecAsync(target.dialTarget, cmd, { timeoutMs: 60000, multiplex: true });
+    const res = await sshExecAsync(target.dialTarget, cmd, { timeoutMs: 15000, multiplex: true });
     if (res.code !== 0) {
         throw new Error(res.timedOut ? 'timed out' : (res.stderr.trim() || `exit ${res.code ?? 'unknown'}`));
     }
     const parsed = JSON.parse(res.stdout);
     return parsed.rows ?? [];
 }
+/**
+ * Race `fanOut` against an overall wall-clock deadline (RUSH-2041).
+ *
+ * If `fanOut` settles first the result passes through unchanged. If the
+ * deadline fires first every pending remote target is mapped to `failed` (or
+ * `skipped` for pre-skipped targets), so callers always get a complete result
+ * array and the command exits promptly rather than hanging.
+ *
+ * Exported so the unit test can exercise the real path with a hanging probe
+ * instead of reimplementing the logic.
+ */
+export async function raceFleetPingDeadline(fanOut, remoteTargets, overallTimeoutMs) {
+    const overallDeadline = new Promise((_, reject) => setTimeout(() => reject(new Error('fleet ping overall deadline exceeded')), overallTimeoutMs));
+    try {
+        return await Promise.race([fanOut, overallDeadline]);
+    }
+    catch (err) {
+        // Overall deadline hit before all devices settled — mark every pending
+        // device as failed so the command exits promptly. Individual probes that
+        // already settled are not retrievable (Promise.all internals), so we
+        // record all remote targets as timed out / skipped.
+        const errMsg = err instanceof Error ? err.message : String(err);
+        return remoteTargets.map((t) => ({
+            name: t.name,
+            status: t.skip ? 'skipped' : 'failed',
+            reason: t.skip,
+            error: t.skip ? undefined : errMsg,
+        }));
+    }
+}
 async function runFleetPing(opts) {
     const self = machineId();
     const cliVersion = getCliVersion();
@@ -463,9 +514,16 @@ async function runFleetPing(opts) {
     const spinner = isInteractiveTerminal() && !opts.json
         ? ora(`Pinging ${probeable} device${probeable === 1 ? '' : 's'}…`).start()
         : undefined;
+    // Per-device: 15 s (matches the version probe budget; enough for the ~8 s
+    // provider-fetch inside the remote local auth probe, with headroom).
+    // Overall: 30 s hard cap so the command can never outlast a reasonable
+    // budget when several devices are simultaneously unreachable (RUSH-2041).
+    const FLEET_PING_DEVICE_TIMEOUT_MS = 15_000;
+    const FLEET_PING_OVERALL_TIMEOUT_MS = 30_000;
     let remote;
     try {
-        remote = await fanOutDevices(remoteTargets, probeRemoteAuth);
+        const fanOut = fanOutDevices(remoteTargets, probeRemoteAuth, { perDeviceTimeoutMs: FLEET_PING_DEVICE_TIMEOUT_MS });
+        remote = await raceFleetPingDeadline(fanOut, remoteTargets, FLEET_PING_OVERALL_TIMEOUT_MS);
     }
     finally {
         spinner?.stop();
@@ -737,6 +795,10 @@ Typical workflow:
             finally {
                 spinner?.stop();
             }
+            // Write the live verdict back so this and every other consumer read one
+            // reachability truth instead of the stale tailscale snapshot (RUSH-1965).
+            if (statsMap)
+                await writeReachability(collectReachabilityWriteBacks(reg, statsMap)).catch(() => { });
         }
         console.log(chalk.bold(`Devices (${names.length})`));
         for (const line of renderDeviceTable(reg, names, self, statsMap, opts.full))
@@ -766,14 +828,20 @@ Typical workflow:
         .action(runList);
     devicesCmd
         .command('status')
-        .description('Show fleet health: warnings rollup, per-device sync drift, CLI readiness, version skew, and resource headroom.')
+        .description('Fleet health at a glance: online/offline rollup, a NEEDS ATTENTION list (each with its fix command), and quiet per-device rows grouped by OS. Use --verbose for the full auth/CLI/sync grid.')
         .option('--json', 'output machine-readable JSON')
         .option('--strict', 'exit non-zero when any device has drift or is unreachable')
         .option('--no-stats', 'skip the live resource probe')
         .option('--refresh', 'force a live probe of every device, bypassing the cache')
         .option('--live', 'alias of --refresh (shorter to type)')
-        .action(async (opts) => {
-        await runFleetStatus(opts);
+        .option('--verbose', 'show the full per-device auth/CLI/sync/version grid instead of the summary')
+        .action(async (opts, cmd) => {
+        // The root program also defines a global `--verbose`; commander binds a
+        // shared long flag to the program, not the leaf. Read the effective value
+        // from the merged globals so `fleet status --verbose` works at either level
+        // (same pattern as `fleet ping --verbose`).
+        const verbose = opts.verbose ?? Boolean(cmd.optsWithGlobals().verbose);
+        await runFleetStatus({ ...opts, verbose });
     });
     devicesCmd
         .command('ping')
@@ -1014,7 +1082,7 @@ secrets bundle via an askpass shim — the password never touches argv.
         // `user@device` (same device, login user overridden — dialed via its
         // Tailscale route, not LAN DNS), or an ad-hoc `user@host`/`host` literal.
         // A bare unregistered alias still errors as "Unknown device".
-        const device = resolveDeviceTarget(name, await loadDevices());
+        const device = await resolveDeviceTarget(name);
         if (!device) {
             // Not a registered device — it may be a leased crabbox box slug. ssh into
             // it directly (crabbox@<tailnet|ip>:2222) before giving up.
@@ -1076,8 +1144,13 @@ async function runAskpass() {
         console.error(`askpass: ${ASKPASS_BUNDLE_ENV} not set`);
         process.exit(1);
     }
+    // A read-only stats probe sets ASKPASS_AGENT_ONLY_ENV to force a broker-only
+    // resolve even under a TTY — so `agents devices` never pops Touch ID just to
+    // render load/mem for an uncached password-auth device (RUSH-1970). Otherwise
+    // fall back to the headless-context heuristic.
+    const agentOnly = process.env[ASKPASS_AGENT_ONLY_ENV] === '1' || isHeadlessSecretsContext();
     try {
-        const { env } = readAndResolveBundleEnv(bundle, { caller: 'agents ssh', keys: [key], keyMode: 'storage', agentOnly: isHeadlessSecretsContext() });
+        const { env } = readAndResolveBundleEnv(bundle, { caller: 'agents ssh', keys: [key], keyMode: 'storage', agentOnly });
         const value = env[key];
         if (value === undefined) {
             console.error(`askpass: key '${key}' not found in bundle '${bundle}'`);

package/dist/commands/status.js

@@ -13,6 +13,7 @@ import { AGENTS } from '../lib/agents.js';
 import { setHelpSections } from '../lib/help.js';
 import { computeSyncStatus } from '../lib/sync-status.js';
 import { promptDriftSync } from '../lib/drift-sync.js';
+import { resolveConfiguredModel } from '../lib/models.js';
 import { resolveSurface } from './utils.js';
 const agentName = (id) => AGENTS[id]?.name ?? id;
 function versionSummary(v) {
@@ -75,8 +76,15 @@ export function registerStatusCommand(program) {
             console.log(chalk.gray('  (no installed agent versions)'));
         }
         for (const v of status.agents) {
-            const label = `${agentName(v.agent)}@${v.version}${v.isDefault ? chalk.gray(' (default)') : ''}`;
-            console.log(`  ${label.padEnd(28)} ${versionSummary(v)}`);
+            // Model sits right beside the version, same priority (no label).
+            const model = resolveConfiguredModel(v.agent, v.version)?.model;
+            const defaultTag = v.isDefault ? ' (default)' : '';
+            const plain = `${agentName(v.agent)}@${v.version}${model ? ` · ${model}` : ''}${defaultTag}`;
+            const shown = `${agentName(v.agent)}@${v.version}`
+                + (model ? ` ${chalk.gray('·')} ${chalk.yellow(model)}` : '')
+                + (v.isDefault ? chalk.gray(' (default)') : '');
+            const pad = ' '.repeat(Math.max(1, 34 - plain.length));
+            console.log(`  ${shown}${pad}${versionSummary(v)}`);
         }
         if (status.totals.orphan > 0) {
             console.log(chalk.gray(`  (${status.totals.orphan} orphan${status.totals.orphan === 1 ? '' : 's'} — run \`agents prune cleanup\`)`));

package/dist/commands/versions.js

@@ -7,6 +7,7 @@ import { select, confirm, checkbox } from '@inquirer/prompts';
 import { AGENTS, ALL_AGENT_IDS, accountOrgBadge, getAccountEmail, getAccountInfo, agentLabel, warnAgentDeprecated, isSelfUpdatingAgent, } from '../lib/agents.js';
 import { formatUsageSummary, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { viewAction } from './view.js';
+import { resolveConfiguredModel, formatAgentIdentity } from '../lib/models.js';
 import { readManifest, writeManifest, createDefaultManifest } from '../lib/manifest.js';
 import { installVersion, removeVersion, listInstalledVersions, isVersionInstalled, isLatestInstalled, isOldestInstalled, getGlobalDefault, setGlobalDefault, markVersionIsolated, setIsolatedDefault, isVersionIsolated, getVersionHomePath, getVersionDir, syncResourcesToVersion, parseAgentSpec, promptResourceSelection, promptNewResourceSelection, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, printTrashFooter, } from '../lib/versions.js';
 import { carryForwardSettings } from '../lib/settings-manifest.js';
@@ -410,7 +411,10 @@ export function registerVersionsCommands(program) {
                     spinner.text = msg;
                 });
                 if (result.success) {
-                    spinner.succeed(`Installed ${agentLabel(agentConfig.id)}@${result.installedVersion}`);
+                    const installedVer = result.installedVersion || version;
+                    const installedModel = resolveConfiguredModel(agentConfig.id, installedVer)?.model;
+                    const installedIdentity = formatAgentIdentity(`${agentLabel(agentConfig.id)}@${result.installedVersion}`, installedModel ? chalk.yellow(installedModel) : null);
+                    spinner.succeed(`Installed ${installedIdentity}`);
                     const installedVersion = result.installedVersion || version;
                     // Track the concrete version so a `--project` pin records it instead
                     // of the `latest`/`oldest` alias.
@@ -756,8 +760,9 @@ export function registerVersionsCommands(program) {
                 manifest.agents[agentId] = finalVersion;
                 writeManifest(process.cwd(), manifest);
                 const projEmail = await getAccountEmail(agentId, getVersionHomePath(agentId, finalVersion));
-                const projEmailStr = projEmail ? chalk.cyan(` (${projEmail})`) : '';
-                console.log(chalk.green(`Set ${agentLabel(agentConfig.id)}@${finalVersion} for this project`) + projEmailStr);
+                const projModel = resolveConfiguredModel(agentId, finalVersion)?.model;
+                const projIdentity = formatAgentIdentity(chalk.green(`${agentLabel(agentConfig.id)}@${finalVersion}`), projModel ? chalk.yellow(projModel) : null, projEmail ? chalk.cyan(projEmail) : null);
+                console.log(`Set ${projIdentity} for this project`);
             }
             else {
                 // Smart resource detection: compare available vs ACTUALLY synced (source of truth: files, not tracking)
@@ -895,15 +900,19 @@ export function registerVersionsCommands(program) {
                 switchHomeFileSymlinks(agentId, finalVersion);
                 warnIfShimShadowed(agentId);
                 const useEmail = await getAccountEmail(agentId, getVersionHomePath(agentId, finalVersion));
-                const useEmailStr = useEmail ? chalk.cyan(` (${useEmail})`) : '';
+                const useModel = resolveConfiguredModel(agentId, finalVersion)?.model;
+                const useModelStr = useModel ? chalk.yellow(useModel) : null;
+                const useAcctStr = useEmail ? chalk.cyan(useEmail) : null;
                 // Self-updating agents are one binary; `use` only swaps the config
                 // symlink (the profile), it does not change which binary runs — so say
                 // "profile", not "version", to match what actually happened.
                 if (isSelfUpdatingAgent(agentId)) {
-                    console.log(chalk.green(`Switched ${agentLabel(agentConfig.id)} to config profile ${finalVersion}`) + useEmailStr);
+                    const identity = formatAgentIdentity(chalk.green(agentLabel(agentConfig.id)), useModelStr, useAcctStr);
+                    console.log(`Switched ${identity} to config profile ${chalk.green(finalVersion)}`);
                 }
                 else {
-                    console.log(chalk.green(`Set ${agentLabel(agentConfig.id)}@${finalVersion} as global default`) + useEmailStr);
+                    const identity = formatAgentIdentity(chalk.green(`${agentLabel(agentConfig.id)}@${finalVersion}`), useModelStr, useAcctStr);
+                    console.log(`Set ${identity} as global default`);
                 }
             }
         }

package/dist/commands/view.d.ts

@@ -10,6 +10,7 @@ import type { Command } from 'commander';
 import { accountDisplayLabel } from '../lib/agents.js';
 import type { AccountInfo } from '../lib/agents.js';
 import type { AgentId } from '../lib/types.js';
+import { type ConfiguredModelSource } from '../lib/models.js';
 import { type ProfileSummary } from '../lib/profiles.js';
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export declare const accountColumnLabel: typeof accountDisplayLabel;
@@ -51,6 +52,10 @@ export interface ViewJsonVersion {
     }>;
     lastActive: string | null;
     path: string;
+    configuredModel?: {
+        model: string;
+        source: ConfiguredModelSource;
+    } | null;
     /** Present only when --resources / --detailed (or --json with a section
      *  flag) is passed: this version's resource inventory with git sync-state. */
     resources?: VersionResourcesJson;

package/dist/commands/view.js

@@ -23,6 +23,7 @@ import { getCentralRulesFileName } from '../lib/rules/rules.js';
 import { composeRulesFromState } from '../lib/rules/compose.js';
 import { getConfiguredRunStrategy } from '../lib/rotate.js';
 import { resolveRunDefaults } from '../lib/run-defaults.js';
+import { resolveConfiguredModel } from '../lib/models.js';
 import { listProfiles, profileSummary } from '../lib/profiles.js';
 import { loadManifest, isStale } from '../lib/staleness/index.js';
 import { confirm } from '@inquirer/prompts';
@@ -419,6 +420,10 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
         let maxPlanWidth = 3;
         let maxUsageWidth = 0;
         let maxStatusWidth = 0;
+        // The configured model sits right after the version, at the same priority.
+        // Resolve once here (fs + catalog reads) and reuse in the render loop.
+        let maxModelWidth = 0;
+        const modelByKey = new Map();
         for (const agentId of versionManaged) {
             const versions = listInstalledVersions(agentId);
             const globalDefault = getGlobalDefault(agentId);
@@ -431,6 +436,11 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                     maxEmail = Math.max(maxEmail, accountLabel.length);
                 if (info?.plan)
                     maxPlanWidth = Math.max(maxPlanWidth, info.plan.length);
+                const model = resolveConfiguredModel(agentId, v)?.model;
+                if (model) {
+                    modelByKey.set(`${agentId}:${v}`, model);
+                    maxModelWidth = Math.max(maxModelWidth, model.length);
+                }
             }
             // Profile rows share these columns with version rows so they line up.
             for (const profile of profilesByAgent.get(agentId) ?? []) {
@@ -499,6 +509,11 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 const usageInfo = usageKey ? usageByKey.get(usageKey) : undefined;
                 // Build columns, trimming trailing whitespace when columns are empty
                 const parts = [`    ${label}`];
+                // Configured model — same priority as the version, right beside it.
+                if (maxModelWidth > 0) {
+                    const model = modelByKey.get(`${agentId}:${version}`) ?? '';
+                    parts.push(chalk.yellow(model.padEnd(maxModelWidth)));
+                }
                 const hasEmail = !!vInfo?.email;
                 const signedIn = !!vInfo?.signedIn;
                 const usageUnavailable = agentReportsUsage(agentId) && signedIn && !usageInfo?.snapshot;
@@ -508,12 +523,11 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 // Otherwise it reflects install time (misleading "just now" for fresh installs).
                 const activeStr = vInfo && hasEmail ? formatLastActive(vInfo.lastActive) : '';
                 const hasActive = activeStr.length > 0;
+                // The model now has its own column above; keep only the run mode here.
                 const runDefaults = resolveRunDefaults(agentId, version);
                 const runDefaultBits = [];
                 if (runDefaults.mode)
                     runDefaultBits.push(`mode:${runDefaults.mode}`);
-                if (runDefaults.model)
-                    runDefaultBits.push(`model:${runDefaults.model}`);
                 if (!hasEmail && !hasUsage && !signedIn) {
                     // Installed but never signed in
                     parts.push(chalk.gray('(logged out — log in with: ' + loginHint(agentId) + ')'));
@@ -555,10 +569,12 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
             // No status badge, no last-active — profiles don't accumulate usage state.
             for (const profile of profilesByAgent.get(agentId) ?? []) {
                 const nameCol = chalk.cyan(profile.name.padEnd(maxVerLabel));
+                // Pad the model column so profile rows line up with version rows.
+                const modelPad = maxModelWidth > 0 ? `${' '.repeat(maxModelWidth)}  ` : '';
                 const authCol = chalk.gray(profile.auth.padEnd(maxEmail));
                 const usageEquivalent = profileKindAndModel(profile.model, maxPlanWidth);
                 const usagePad = ' '.repeat(Math.max(0, maxUsageWidth - visibleWidth(usageEquivalent)));
-                console.log(`    ${nameCol}  ${authCol}  ${chalk.gray(usageEquivalent + usagePad)}`);
+                console.log(`    ${nameCol}  ${modelPad}${authCol}  ${chalk.gray(usageEquivalent + usagePad)}`);
                 if (showPaths) {
                     console.log(chalk.gray(`      ${profile.path}`));
                 }
@@ -881,9 +897,12 @@ async function showAgentResources(agentId, requestedVersion, filter) {
         const accountLabel = accountColumnLabel(accountInfo);
         const emailStr = accountLabel ? chalk.cyan(`  ${accountLabel}`) : '';
         const status = chalk.green(version);
+        // Configured model sits right beside the version, same priority (no label).
+        const configuredModel = resolveConfiguredModel(agentId, version);
+        const modelStr = configuredModel ? chalk.yellow(`  ${configuredModel.model}`) : '';
         const usageStr = formatUsageSummary(usageInfo.snapshot?.plan ?? accountInfo.plan, null);
         const usagePart = usageStr ? `  ${usageStr}` : '';
-        console.log(`  ${colorAgent(agentId)(AGENTS[agentId].name.padEnd(14))} ${status}${emailStr}${usagePart}`);
+        console.log(`  ${colorAgent(agentId)(AGENTS[agentId].name.padEnd(14))} ${status}${modelStr}${emailStr}${usagePart}`);
         const usageLines = formatUsageSection(usageInfo);
         if (usageLines.length > 0) {
             console.log();
@@ -1221,6 +1240,7 @@ async function collectAgentsJson(filterAgentId, resourceSections) {
                 : [],
             lastActive: info.lastActive ? info.lastActive.toISOString() : null,
             path: getVersionDir(agentId, version),
+            configuredModel: resolveConfiguredModel(agentId, version),
         };
         if (wantResources && resourceSync) {
             entry.resources = collectVersionResources(agentId, home, process.cwd(), cliStates?.[agentId]?.installed ?? false, resourceSections, resourceSync);

package/dist/commands/watchdog.d.ts

@@ -8,10 +8,15 @@
  *
  *   agents watchdog                    one tick, dry — prints what it WOULD nudge/skip and why
  *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
- *   agents watchdog --watch            daemon loop (poll every --interval)
+ *   agents watchdog --watch            manual poll loop (dry unless --nudge)
  *   agents watchdog --json             machine-readable tick output (for the menu-bar)
- *   agents watchdog enable|disable     flip the global auto-nudge sentinel (default OFF)
+ *   agents watchdog enable|disable     turn the always-on watchdog routine on/off
  *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
+ *
+ * The always-on watchdog is a daemon-fired ROUTINE, not a private sentinel + a
+ * hand-rolled loop: `enable` creates/enables a `watchdog` command routine
+ * (`agents watchdog --nudge` every couple of minutes) and reloads the daemon;
+ * `disable` pauses it. See ../lib/watchdog/routine.ts.
  */
 import type { Command } from 'commander';
 /** Register the `agents watchdog` command tree. */