@phnx-labs/agents-cli 1.22.46 → 1.22.47

package/dist/commands/ssh.js

@@ -18,10 +18,12 @@ import ora from 'ora';
 import { getCliVersion } from '../lib/version.js';
 import { readAndResolveBundleEnv } from '../lib/secrets/bundles.js';
 import { machineId } from '../lib/session/sync/config.js';
+import { assertRegistrableDeviceName } from '../lib/devices/registry.js';
 import { isDeviceAuto, resolveDeviceAffinity } from '../lib/smart-launch.js';
+import { isDeviceInteractive, resolveInteractiveDevice, interactiveUnsetError, } from '../lib/devices/interactive-host.js';
 import { registerFleetCaptureCommand } from './fleet-capture.js';
 import { registerFleetApplyAlias } from './apply.js';
-import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, writeReachability, } from '../lib/devices/registry.js';
+import { addIgnored, getDevice, loadDevices, loadIgnored, loadIgnoredEntries, removeDevice, removeIgnored, upsertDevice, writeReachability, } from '../lib/devices/registry.js';
 import { resolveDeviceProfile } from '../lib/devices/resolve-profile.js';
 import { collectReachabilityWriteBacks, deviceOnlineState } from '../lib/devices/reachability.js';
 import { nodeToDeviceInput, parseTailscaleStatus, tailscaleStatusJson, } from '../lib/devices/tailscale.js';
@@ -47,7 +49,7 @@ import { buildRemoteAgentsInvocation } from '../lib/hosts/remote-cmd.js';
 import { listTasks, resolveTaskRef } from '../lib/hosts/tasks.js';
 import { reconcileRunningTasks } from '../lib/hosts/reconcile.js';
 import { stopDispatchedTask } from '../lib/hosts/dispatch.js';
-import { terminalWidth, truncateToWidth } from '../lib/session/width.js';
+import { stringWidth, stripAnsi, terminalWidth, truncateToWidth } from '../lib/session/width.js';
 import { sshExecAsync } from '../lib/ssh-exec.js';
 import { ALL_AGENT_IDS } from '../lib/agents.js';
 import { collectLocalHarnessInventory, groupByAccount, renderAccountsMatrix, renderHarnessMatrix, } from '../lib/devices/harness-inventory.js';
@@ -113,30 +115,99 @@ function pctCell(v, width) {
         return chalk.yellow(s);
     return chalk.red(s);
 }
+/** Floor for the `spec` column; the real width is measured from the rows.
+ *
+ * A fixed width cannot work here: `fmtBytes` emits an optional decimal, so a
+ * spec string runs from `8c 16G 256G` (11) to `10c 23.5G 460G` (14) depending
+ * purely on the hardware behind it. Anything narrower than the widest row
+ * pushes load/mem/disk/headroom out of alignment row-to-row AND against the
+ * header — which defeats the scannability this column exists for. */
+const SPEC_WIDTH_MIN = 12;
+/** The static hardware as one compact cell — `12c 64G 1T`: cores, total RAM,
+ * total root disk via fmtBytes. `—` when the probe never saw the box (specs
+ * ride the long-TTL static tier, so a warm cache almost always has them).
+ * Unpadded; {@link renderDeviceTable} pads to the measured column width. */
+function specText(stats) {
+    if (!stats?.reachable || !stats.ncpu)
+        return '—';
+    return `${stats.ncpu}c ${fmtBytes(stats.memTotalBytes)} ${fmtBytes(stats.diskTotalBytes)}`;
+}
+/** The widest spec string across the rows actually being rendered, floored at
+ * SPEC_WIDTH_MIN so a short fleet still lines up with the header. */
+function specColumnWidth(names, statsMap) {
+    return Math.max(SPEC_WIDTH_MIN, ...names.map((n) => stringWidth(specText(statsMap.get(n)))));
+}
+/** Colour + pad one spec cell to the measured column width. */
+function specCell(stats, width) {
+    const text = specText(stats);
+    return (text === '—' ? chalk.gray : chalk.greenBright)(text.padEnd(width));
+}
+/** The one-line `description` config value per device (absent when unset). */
+function listDeviceDescriptions(names) {
+    const out = {};
+    for (const n of names) {
+        const v = getConfigValue('description', { device: n }).value;
+        if (typeof v === 'string' && v.length > 0)
+            out[n] = v;
+    }
+    return out;
+}
+/**
+ * Fit a device row to the terminal width. The description is the FIRST thing
+ * to truncate, then the role tag; the fixed columns (device, platform, spec,
+ * load/mem/disk numbers, headroom, and the ▸/★/←/relay markers) never
+ * truncate. `role` and `desc` arrive fully rendered (ansi + leading gap).
+ */
+function fitDeviceRow(fixed, role, desc, width) {
+    const w = (s) => stringWidth(stripAnsi(s));
+    let over = w(fixed) + w(role) + w(desc) - width;
+    if (over > 0 && desc) {
+        // `desc` is '  ' + gray(text) — truncate the text, keep the gap.
+        const text = stripAnsi(desc).slice(2);
+        const budget = w(text) - over;
+        desc = budget > 0 ? '  ' + chalk.gray(truncateToWidth(text, budget)) : '';
+        over = w(fixed) + w(role) + w(desc) - width;
+    }
+    // A partial role word ("work…") reads as a bug — when it can't fit whole,
+    // it drops entirely. The numbers are never touched.
+    if (over > 0 && role)
+        role = '';
+    return fixed + role + desc;
+}
 /**
  * Render the device list. When `statsMap` is provided, resource columns are
- * appended — normalized load, memory, a headroom badge, and (in `full` mode)
- * core count and free/total memory — so it's obvious which boxes have room.
+ * appended — a `spec` cell (cores / total RAM / total disk), normalized load,
+ * memory and disk-used percentages, a headroom badge, and (in `full` mode)
+ * free/total memory — with the per-device role and `description` riding the
+ * tail, so it's obvious which boxes have room and what each box is for.
  * Without it (probe skipped) the classic reachability line is used. A fleet
  * capacity summary is appended whenever stats were gathered.
  */
-function renderDeviceTable(reg, names, self, statsMap, full = false, interactiveHost) {
+export function renderDeviceTable(reg, names, self, statsMap, full = false, interactiveHost, opts = {}) {
     if (!statsMap) {
         const roles = listConfiguredDeviceRoles(names);
         return names.map((n) => deviceSummary(reg[n], n === self, undefined, n === interactiveHost, roles));
     }
     const deviceRoles = listConfiguredDeviceRoles(names);
+    const specWidth = specColumnWidth(names, statsMap);
+    const descriptions = listDeviceDescriptions(names);
+    const width = opts.width ?? terminalWidth();
     const lines = [];
     const head = '  ' +
         chalk.gray('device'.padEnd(16)) +
         chalk.gray('platform'.padEnd(8)) +
         ' ' +
-        (full ? chalk.gray('cores'.padStart(6)) : '') +
+        chalk.gray('spec'.padEnd(specWidth)) +
         chalk.gray('load'.padStart(5)) +
         chalk.gray('mem'.padStart(6)) +
+        chalk.gray('disk'.padStart(5)) +
         (full ? '  ' + chalk.gray('free/total'.padEnd(12)) : '') +
         '  ' +
-        chalk.gray('headroom');
+        chalk.gray('headroom') +
+        '  ' +
+        chalk.gray('role') +
+        '  ' +
+        chalk.gray('description');
     lines.push(head);
     for (const name of names) {
         // Effective profile: the operator's central config (ssh.*/platform/user)
@@ -147,18 +218,20 @@ function renderDeviceTable(reg, names, self, statsMap, full = false, interactive
         const label = isSelf ? chalk.bold.cyan(name.padEnd(16)) : chalk.bold(name.padEnd(16));
         const plat = String(d.platform).padEnd(8);
         const stats = statsMap.get(name);
+        const role = roleTag(name, deviceRoles);
+        const desc = descriptions[name] ? '  ' + chalk.gray(descriptions[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')}`);
+            lines.push(fitDeviceRow(`${marker}${label}${plat} ${chalk.gray('offline')}`, role, desc, width));
             continue;
         }
         const relay = !isSelf && d.tailscale?.online && !d.tailscale.direct ? chalk.yellow(' relay') : '';
-        const cores = full ? chalk.gray(String(stats?.ncpu ?? '—').padStart(6)) : '';
         const load = pctCell(stats?.loadPercent, 5);
         const mem = pctCell(stats?.memPercent, 6);
+        const disk = pctCell(stats?.diskUsedPercent, 5);
         const freeTotal = full
             ? '  ' +
                 (stats?.reachable && stats.memTotalBytes
@@ -168,13 +241,21 @@ function renderDeviceTable(reg, names, self, statsMap, full = false, interactive
         const badge = HEADROOM_BADGE[headroom(stats)];
         const here = isSelf ? chalk.cyan('  ← this machine') : '';
         const interactive = name === interactiveHost ? chalk.yellow('  ★ interactive') : '';
-        lines.push(`${marker}${label}${plat} ${cores}${load}${mem}${freeTotal}  ${badge}${relay}${here}${interactive}${roleTag(name, deviceRoles)}`);
+        lines.push(fitDeviceRow(`${marker}${label}${plat} ${specCell(stats, specWidth)}${load}${mem}${disk}${freeTotal}  ${badge}${relay}${here}${interactive}`, role, desc, width));
     }
-    // Fleet capacity summary — total cores + how much RAM is free right now.
+    // Fleet capacity summary — total cores, how much RAM is free right now, and
+    // total free root disk across the reachable fleet.
     const cap = fleetCapacity(statsMap.values());
     if (cap.reachable > 0) {
         const freePct = cap.memTotalBytes > 0 ? Math.round((cap.memFreeBytes / cap.memTotalBytes) * 100) : 0;
-        lines.push(chalk.gray(`  Fleet capacity: ${cap.cores} cores · ${fmtBytes(cap.memFreeBytes)} free / ${fmtBytes(cap.memTotalBytes)} RAM (${freePct}% free) across ${cap.reachable} reachable device${cap.reachable === 1 ? '' : 's'}`));
+        let diskFreeBytes = 0;
+        for (const s of statsMap.values())
+            if (s.reachable)
+                diskFreeBytes += s.diskFreeBytes ?? 0;
+        lines.push(chalk.gray(`  Fleet capacity: ${cap.cores} cores · ${fmtBytes(cap.memFreeBytes)} free / ${fmtBytes(cap.memTotalBytes)} RAM (${freePct}% free) · ${fmtBytes(diskFreeBytes)} disk free across ${cap.reachable} reachable device${cap.reachable === 1 ? '' : 's'}`));
+    }
+    if (opts.ignoredCount) {
+        lines.push(chalk.gray(`  ${opts.ignoredCount} ignored node${opts.ignoredCount === 1 ? '' : 's'} not listed — 'agents devices ignored'`));
     }
     return lines;
 }
@@ -975,6 +1056,7 @@ function registerDevicesCommands(program) {
         agents devices sync            # pick which tailscale nodes to keep (TTY)
         agents devices sync --yes      # register all non-ignored nodes
         agents devices ignore ipad165  # dismiss a node so it's never re-suggested
+        agents devices ignored         # list dismissed nodes (when / which machine)
 
       Inspect:
         agents devices list            # what's registered (★ = interactive host)
@@ -990,6 +1072,7 @@ function registerDevicesCommands(program) {
         agents devices config win-mini ssh.auth password
         agents devices config worker ssh.identity-file ~/.ssh/worker_ed25519
         agents devices config mac-mini auto-launch.enabled off
+        agents devices describe mark-1 "gpu box — cuda 12.4"  # one-line purpose, shown in the list
         agents devices config mac-mini interactive.host zion # where agents show YOU artifacts
         agents devices render --write  # write ~/.ssh/config.d/agents include
 
@@ -1002,10 +1085,10 @@ function registerDevicesCommands(program) {
     registerLeaseCommand(devicesCmd);
     registerSnapshotCommand(devicesCmd);
     registerCommandGroups(devicesCmd, [
-        { title: 'Discover & register', names: ['sync', 'register', 'add', 'ignore', 'unignore', 'rm'] },
+        { title: 'Discover & register', names: ['sync', 'register', 'add', 'ignore', 'unignore', 'ignored', 'rm'] },
         { title: 'Inspect', names: ['list', 'show', 'status', 'ping', 'harnesses', 'accounts', 'snapshot'] },
         { title: 'Disposable devices', names: ['lease'] },
-        { title: 'Configure a device', names: ['config', 'render'] },
+        { title: 'Configure a device', names: ['config', 'describe', 'render'] },
         { title: 'Fleet operations', names: ['update', 'run', 'login', 'capture', 'apply'] },
     ]);
     devicesCmd
@@ -1085,6 +1168,47 @@ function registerDevicesCommands(program) {
         setDeviceDiscoveryStatus(name, undefined);
         console.log(chalk.green(`No longer ignoring '${name}'`) + chalk.gray(' — run `agents devices sync` to register it.'));
     });
+    const ignoredCmd = devicesCmd
+        .command('ignored')
+        .description('List dismissed tailscale nodes — what was dismissed, when, and on which machine.')
+        .option('--json', 'output machine-readable JSON')
+        .action((opts) => {
+        try {
+            const entries = loadIgnoredEntries();
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+                return;
+            }
+            if (entries.length === 0) {
+                console.log(chalk.gray("No ignored nodes. 'agents devices ignore <name>' dismisses one — it won't be re-suggested."));
+                return;
+            }
+            console.log(chalk.bold(`Ignored nodes (${entries.length})`));
+            for (const e of entries) {
+                const age = formatCheckedAge(Date.parse(e.ignoredAt));
+                console.log(`  ${chalk.bold(e.name.padEnd(24))} ${chalk.gray(`${age} · dismissed on ${e.ignoredOn}`)}`);
+            }
+            console.log(chalk.gray("Undo one with 'agents devices unignore <name>'."));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    setHelpSections(ignoredCmd, {
+        examples: `
+      agents devices ignored          # what was dismissed, when, and on which machine
+      agents devices ignored --json   # machine-readable [{ name, ignoredAt, ignoredOn }]
+      agents devices unignore old-laptop   # undo a dismissal
+    `,
+        notes: `
+      Dismissals live in the tracked central agents.yaml (fleet.ignored) and
+      sync with 'agents repo push/pull', so a node dismissed on one box stays
+      dismissed everywhere. An ignored node is not a device — it never enters
+      the registry, so 'agents devices list' never shows it; this command is
+      where dismissals are visible.
+    `,
+    });
     // ─── devices config (unified settings surface) ────────────────────────────
     //
     // ONE command for every per-device setting: `agents devices config <name>
@@ -1461,6 +1585,8 @@ function registerDevicesCommands(program) {
     `,
         notes: `
       Keys: role (worker|personal), see 'agents devices role',
+      description (one line saying what the box is for — see
+      'agents devices describe'; renders in the devices list tail),
       agents.max-concurrent, scheduler.enabled, daemon.enabled,
       watchdog.enabled, tmux.enabled, browser.remote-control,
       browser.task-idle-minutes, browser.profile,
@@ -1529,6 +1655,40 @@ function registerDevicesCommands(program) {
       box stays excluded, since that is what the mark is for.
     `,
     });
+    const describeCmd = devicesCmd
+        .command('describe <name> [text...]')
+        .description('Show or set the one-line description of what a device is FOR ("gpu box — cuda 12.4"). ' +
+        'Rendered as the tail column of `agents devices list` and synced fleet-wide. ' +
+        'Same key as `agents devices config <name> description` — one store, two names.')
+        .option('--unset', 'remove the description (the device falls back to the fleet default / unset)')
+        .option('--json', 'output machine-readable JSON')
+        .action(async (name, textParts, opts) => {
+        try {
+            // Thin sugar over the 'description' config key — the same engine that
+            // backs `agents devices config <name> description`, not a second path.
+            await runDevicesConfig(name, 'description', textParts ?? [], opts);
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    setHelpSections(describeCmd, {
+        examples: `
+      agents devices describe mark-1 "gpu box — cuda 12.4"  # set it (80 chars, one line)
+      agents devices describe mark-1                        # read it back
+      agents devices describe mark-1 --unset                # remove it
+      agents devices describe mark-1 --json                 # machine-readable
+      agents devices config mark-1 description "gpu box"    # equivalent — same store
+    `,
+        notes: `
+      The description is the device-scope 'description' config key: stored in
+      the tracked per-device doc (devices/<name>/agents.yaml config: block),
+      synced fleet-wide with 'agents repo push/pull', and rendered as the tail
+      column of 'agents devices list'. It replaces on each set — for appended
+      long-form scratch use 'agents devices config <name> notes "…"'.
+    `,
+    });
     /** Deprecation notice for a retired subcommand — STDERR only, so a --json consumer's stdout stays parseable. */
     const configTombstoneNotice = (retired, replacement) => {
         console.error(chalk.yellow(`Deprecated: "agents devices ${retired}" is now "agents devices ${replacement}". Running that for you.\n`));
@@ -1753,6 +1913,7 @@ function registerDevicesCommands(program) {
             process.stdout.write(JSON.stringify(names.map((name) => {
                 const config = deviceConfigJson(name);
                 const health = statsMap?.get(name);
+                const description = getConfigValue('description', { device: name }).value;
                 return {
                     ...resolveDeviceProfile(reg[name]),
                     interactive: name === interactiveHost,
@@ -1760,6 +1921,7 @@ function registerDevicesCommands(program) {
                     // marked (absent when unmarked), `autoPool` is the answer that
                     // matters to a caller — may `--device auto` pick this box.
                     ...(jsonRoles[name] ? { role: jsonRoles[name] } : {}),
+                    ...(typeof description === 'string' && description ? { description } : {}),
                     autoPool: autoPool.has(name),
                     ...(config ? { config } : {}),
                     ...(health ? { health: { ...health, headroom: headroom(health) } } : {}),
@@ -1768,7 +1930,10 @@ function registerDevicesCommands(program) {
             return;
         }
         console.log(chalk.bold(`Devices (${names.length})`));
-        for (const line of renderDeviceTable(reg, names, self, statsMap, opts.full, interactiveHost))
+        // Dismissed nodes are not devices (never in the registry) — surface their
+        // count under the table so a "missing" node is explainable from the list.
+        const ignoredCount = loadIgnoredEntries().length;
+        for (const line of renderDeviceTable(reg, names, self, statsMap, opts.full, interactiveHost, { ignoredCount }))
             console.log(line);
         if (freshness?.servedFromCache && freshness.oldestFetchedAt != null) {
             console.log(chalk.gray(`  updated ${formatCheckedAge(freshness.oldestFetchedAt)} — pass --refresh (--live) for a live probe`));
@@ -1789,7 +1954,7 @@ function registerDevicesCommands(program) {
     devicesCmd
         .command('list')
         .alias('ls')
-        .description('List registered devices with platform, address, reachability, and live resource headroom.')
+        .description('List registered devices with platform, spec (cores/RAM/disk), live load/mem/disk headroom, role, and description.')
         .option('--json', 'output effective device profiles, config, and health as a JSON array')
         .option('--no-stats', 'skip the live resource probe (instant; names/addresses only)')
         .option('--refresh', 'force a live probe of every device, bypassing the cache')
@@ -1924,6 +2089,10 @@ email) into a single row. Use \`agents devices harnesses\` for the per-install v
         .option('--platform <platform>', 'windows | linux | macos')
         .action(async (name, target, opts) => {
         try {
+            // The one place a device name is CHOSEN rather than observed, so the one
+            // place the reserved-sentinel policy belongs. upsertDevice itself stays
+            // shape-only — `devices sync` feeds it tailnet node names in a loop.
+            assertRegistrableDeviceName(name);
             const { host, user } = splitUserHost(target);
             const isIp = /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
             const d = await upsertDevice(name, {
@@ -2190,6 +2359,15 @@ the target when it exists, else the remote home. Same portable-cwd rule as
         // nothing to resolve "self" to, and mis-report the pick as "Unknown
         // device").
         let target = name;
+        if (isDeviceInteractive(name)) {
+            const pinned = resolveInteractiveDevice();
+            if (!pinned) {
+                console.error(chalk.red(interactiveUnsetError()));
+                process.exit(1);
+            }
+            process.stderr.write(chalk.gray(`[agents] device=interactive → ${pinned}\n`));
+            target = pinned;
+        }
         if (isDeviceAuto(name)) {
             const plan = resolveDeviceAffinity({});
             if (!plan.host) {

package/dist/commands/teams.js

@@ -18,6 +18,7 @@ import { createTeam, ensureTeam, getTeam, loadTeams, removeTeam, teamExists, } f
 import { setHelpSections } from '../lib/help.js';
 import { createWorktree, commitsBehindDefault, isGitRepo, hasUncommittedChanges, removeWorktree, worktreeCheckoutExists, worktreeExists, } from '../lib/teams/worktree.js';
 import { resolveHost } from '../lib/hosts/registry.js';
+import { isDeviceInteractive, resolveInteractiveDevice, interactiveUnsetError, } from '../lib/devices/interactive-host.js';
 import { isDeviceAuto, resolveDeviceAuto } from '../lib/smart-launch.js';
 import { sshTargetFor } from '../lib/hosts/types.js';
 import { ensureHostReady } from '../lib/hosts/ready.js';
@@ -1369,7 +1370,22 @@ export function registerTeamsCommands(program) {
             // trim, drop blanks, dedupe (preserving first-seen order).
             const rawPool = [opts.devices, opts.hosts].filter(Boolean).join(',');
             const devices = [];
-            for (const d of rawPool.split(',').map((s) => s.trim()).filter(Boolean)) {
+            for (const raw of rawPool.split(',').map((s) => s.trim()).filter(Boolean)) {
+                // Resolve `interactive` to the concrete device HERE, the same way the
+                // single `--device` pin does. A pool is a set of specific machines the
+                // scheduler picks between, so persisting the sentinel would let the
+                // pool's membership change silently the next time `interactive.host`
+                // is re-pinned — and every later friction message would quote
+                // "interactive" instead of a box the user can act on.
+                let d = raw;
+                if (isDeviceInteractive(d)) {
+                    const pinned = resolveInteractiveDevice();
+                    if (!pinned) {
+                        dieFriction('teams', 'pool-device-interactive-unset', interactiveUnsetError());
+                    }
+                    process.stderr.write(chalk.gray(`[teams] pool device=interactive → ${pinned}\n`));
+                    d = pinned;
+                }
                 if (!devices.includes(d))
                     devices.push(d);
             }
@@ -1444,7 +1460,7 @@ export function registerTeamsCommands(program) {
         .alias('a')
         .description("Add a teammate to work on a task. Runs in background; returns immediately. Use 'status' to check in.")
         .option('-n, --name <name>', 'Friendly name for this teammate (e.g. alice). Required if using --after. Unique within team.')
-        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/cursor/droid/opencode; kimi/grok/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
+        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (more autonomous than edit, mechanism per-harness — see 'agents modes <agent>') | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/cursor/droid/opencode; kimi/grok/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
         .option('-e, --effort <effort>', `Reasoning intensity: ${VALID_EFFORTS.join('|')}`, 'medium')
         .option('--model <model>', 'Cost tier (cheap|default|best|ultra) or a concrete id (e.g. claude-opus-4-8); tiers resolve per harness+version to a supported model')
         .option('--env <key=value>', 'Set an environment variable for this teammate (repeatable for multiple vars)', (val, prev) => [...prev, val], [])
@@ -1507,6 +1523,22 @@ export function registerTeamsCommands(program) {
             process.stderr.write(chalk.gray(`[teams] device=auto → ${picked === machineId() ? 'local' : picked}\n`));
             explicitDevice = picked;
         }
+        // `interactive` needs the same up-front resolution, and for a sharper
+        // reason: `teams add`/`create` bail out of the fleet passthrough
+        // (passthrough.ts, the teams subcommand guard), so the sentinel block
+        // there never runs and this is the only resolver. Left literal, the
+        // local-machine check below compares 'interactive' against the machine id,
+        // takes the remote branch on the pinned box itself, and pins the teammate
+        // to an SSH hop into this same machine — skipping three local preflights
+        // on the way.
+        if (explicitDevice && isDeviceInteractive(explicitDevice)) {
+            const pinned = resolveInteractiveDevice();
+            if (!pinned) {
+                dieFriction('teams', 'device-interactive-unset', interactiveUnsetError());
+            }
+            process.stderr.write(chalk.gray(`[teams] device=interactive → ${pinned === machineId() ? 'local' : pinned}\n`));
+            explicitDevice = pinned;
+        }
         // Distributed teams: --device <name> PINS this teammate to a machine over
         // SSH. Resolve + validate the placement here so a bad target fails at `add`
         // time, not silently at launch. Persisted (hostName/hostTarget/repoPath) so

package/dist/commands/view.d.ts

@@ -10,10 +10,12 @@ 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 { FormatUsageSummaryOpts, UsageInfo } from '../lib/accounting/usage.js';
 import type { ResourceSection, ViewJsonAgent } from '../lib/view-types.js';
 export type { ResourceItemJson, ResourceSection, SyncState, VersionResourcesJson, ViewJsonAgent, ViewJsonVersion } from '../lib/view-types.js';
 import { type ProfileSummary } from '../lib/profiles.js';
 import { type ByokUsageResult } from '../lib/byok-usage.js';
+export declare function viewUsageSummaryOptions(agentId: AgentId, signedIn: boolean, usageInfo: UsageInfo | undefined, maxWindows: number | undefined): FormatUsageSummaryOpts;
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export declare const accountColumnLabel: typeof accountDisplayLabel;
 /**

package/dist/commands/view.js

@@ -8,7 +8,7 @@ import { AGENTS, ALL_AGENT_IDS, accountDisplayLabel, getAllCliStates, getUnmanag
 import { ambientClaudeToken, loginHint } from '../lib/signin-badge.js';
 import { machineId } from '../lib/machine-id.js';
 import { authCacheKey, formatCheckedAge, readAuthHealthCache } from '../lib/auth-health.js';
-import { agentReportsUsage, deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, isUsageHeadlessScopeError, } from '../lib/accounting/usage.js';
+import { agentReportsUsage, classifyUsageErrorKind, deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageBenignState, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, isUsageHeadlessScopeError, } from '../lib/accounting/usage.js';
 import { readManifest } from '../lib/manifest.js';
 import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, isVersionIsolated, getIsolatedDefault, } from '../lib/installations/versions.js';
 import { ensureVersionedAliasCurrent, removeShim, } from '../lib/installations/shims.js';
@@ -32,6 +32,19 @@ import { renderHarnessDetail } from './harness.js';
 import { confirm } from '@inquirer/prompts';
 import { formatPath, isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
+export function viewUsageSummaryOptions(agentId, signedIn, usageInfo, maxWindows) {
+    const headless = isUsageHeadlessScopeError(usageInfo?.error);
+    const benignState = usageInfo ? getUsageBenignState(usageInfo) : null;
+    return {
+        unavailable: agentReportsUsage(agentId) && signedIn && !usageInfo?.snapshot && !headless && !benignState,
+        unverified: !headless && !!usageInfo?.snapshot && !!usageInfo.error,
+        headless,
+        maxWindows,
+        errorKind: classifyUsageErrorKind(usageInfo?.error),
+        errorDetail: usageInfo?.error ?? null,
+        benignState,
+    };
+}
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export const accountColumnLabel = accountDisplayLabel;
 /**
@@ -535,15 +548,7 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 const info = rawInfo ? mergeCanonical(rawInfo) : undefined;
                 const usageKey = getUsageLookupKey(info);
                 const usageInfo = usageKey ? usageByKey.get(usageKey) : undefined;
-                const headless = isUsageHeadlessScopeError(usageInfo?.error);
-                const usageUnavailable = agentReportsUsage(agentId) && !!info?.signedIn && !usageInfo?.snapshot && !headless;
-                const usageUnverified = !headless && !!usageInfo?.snapshot && !!usageInfo.error;
-                const usageStr = formatUsageSummary(info?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, {
-                    unavailable: usageUnavailable,
-                    unverified: usageUnverified,
-                    headless,
-                    maxWindows: usageWindowCap,
-                });
+                const usageStr = formatUsageSummary(info?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, viewUsageSummaryOptions(agentId, !!info?.signedIn, usageInfo, usageWindowCap));
                 maxUsageWidth = Math.max(maxUsageWidth, stringWidth(usageStr));
                 const statusStr = formatUsageStatusBadge(info?.usageStatus);
                 maxStatusWidth = Math.max(maxStatusWidth, stringWidth(statusStr));
@@ -603,15 +608,7 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 }
                 const hasEmail = !!vInfo?.email;
                 const signedIn = !!vInfo?.signedIn;
-                const headless = isUsageHeadlessScopeError(usageInfo?.error);
-                const usageUnavailable = agentReportsUsage(agentId) && signedIn && !usageInfo?.snapshot && !headless;
-                const usageUnverified = !headless && !!usageInfo?.snapshot && !!usageInfo.error;
-                const usageStr = formatUsageSummary(vInfo?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, {
-                    unavailable: usageUnavailable,
-                    unverified: usageUnverified,
-                    headless,
-                    maxWindows: usageWindowCap,
-                });
+                const usageStr = formatUsageSummary(vInfo?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, viewUsageSummaryOptions(agentId, signedIn, usageInfo, usageWindowCap));
                 const hasUsage = usageStr.length > 0;
                 // Only show lastActive for versions with an actual logged-in account.
                 // Otherwise it reflects install time (misleading "just now" for fresh installs).
@@ -731,12 +728,7 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
             gMaxStatusWidth = Math.max(gMaxStatusWidth, stringWidth(formatUsageStatusBadge(gInfo?.usageStatus)));
             const gUsageKey = getUsageLookupKey(gInfo);
             const gUsage = gUsageKey ? usageByKey.get(gUsageKey) : undefined;
-            const gHeadless = isUsageHeadlessScopeError(gUsage?.error);
-            const gUsageStr = formatUsageSummary(gInfo?.plan || null, gUsage?.snapshot || null, 3, {
-                unverified: !gHeadless && !!gUsage?.snapshot && !!gUsage.error,
-                headless: gHeadless,
-                maxWindows: usageWindowCap,
-            });
+            const gUsageStr = formatUsageSummary(gInfo?.plan || null, gUsage?.snapshot || null, 3, viewUsageSummaryOptions(agentId, !!gInfo?.signedIn, gUsage, usageWindowCap));
             gMaxUsageWidth = Math.max(gMaxUsageWidth, stringWidth(gUsageStr));
             const gDisplay = accountColumnLabel(gInfo);
             if (gDisplay)
@@ -754,12 +746,7 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
             const parts = [`    ${verLabel}${padding}`];
             const gUsageKey = getUsageLookupKey(gInfo);
             const gUsage = gUsageKey ? usageByKey.get(gUsageKey) : undefined;
-            const gHeadless = isUsageHeadlessScopeError(gUsage?.error);
-            const gUsageStr = formatUsageSummary(gInfo?.plan || null, gUsage?.snapshot || null, 3, {
-                unverified: !gHeadless && !!gUsage?.snapshot && !!gUsage.error,
-                headless: gHeadless,
-                maxWindows: usageWindowCap,
-            });
+            const gUsageStr = formatUsageSummary(gInfo?.plan || null, gUsage?.snapshot || null, 3, viewUsageSummaryOptions(agentId, !!gInfo?.signedIn, gUsage, usageWindowCap));
             const gActiveStr = gInfo ? formatLastActive(gInfo.lastActive) : '';
             if (gInfo?.email || gUsageStr || gActiveStr || gInfo?.signedIn) {
                 const gDisplay = accountColumnLabel(gInfo);

package/dist/commands/watchdog.js

@@ -144,8 +144,7 @@ export function registerWatchdogCommand(program) {
         .option('--cooldown <dur>', 'Minimum time between nudges to the same session', humanMs(DEFAULT_THRESHOLDS.cooldownMs))
         .option('--dormant <dur>', 'Idle time after which a session is left alone (dormant)', humanMs(DEFAULT_THRESHOLDS.dormantMs))
         .option('--text <text>', 'Nudge text delivered into the terminal', 'Continue.')
-        .option('--smart', 'Use the LLM decider (agents run) instead of the deterministic path (non-reproducible)')
-        .option('--smart-agent <agent>', 'Agent the --smart decider runs as', 'claude')
+        .option('--smart-agent <agent>', 'Agent the watchdog decider runs as', 'claude')
         .option('--allow-ghostty-focus', 'Permit the coarse, focus-stealing Ghostty path (off by default)')
         .option('--verbose', 'Show healthy and non-actionable session inspections too')
         .option('--json', 'Emit the tick result as JSON (for the menu-bar / scripts)')
@@ -163,7 +162,6 @@ export function registerWatchdogCommand(program) {
         const tickOnce = async (willInject, sessions) => runWatchdogPass({
             nudge: willInject,
             nudgeText: opts.text,
-            smart: opts.smart === true,
             smartAgent: opts.smartAgent,
             thresholds,
             allowGhosttyFocus: opts.allowGhosttyFocus === true,
@@ -233,17 +231,14 @@ export function registerWatchdogCommand(program) {
       agents watchdog rotate off
     `,
         notes: `
-      Decision path: a cheap deterministic pre-filter resolves the obvious cases
-      (clearly complete -> skip; a clear promise-without-toolcall -> nudge) and
-      ESCALATES the judgment-heavy cases -- a session parked on a question, or an
-      ambiguous stall -- to a smart brain. The brain drives the agent to finish
-      end-to-end when it asked a needless / already-authorized question or paused
-      with work left, and leaves it for the human on genuine cases (credentials,
-      an irreversible or outward-facing action, a real ambiguous decision, or a
-      completed task). The brain is a customizable 'watchdog' workflow (drop a
-      WORKFLOW.md in project/user workflows/ to override the prompt + model);
-      absent one, the built-in prompt runs via 'agents run --mode plan'. Pass
-      --smart to force every stalled candidate through the brain.
+      Decision path: the watchdog is an AGENT, not a heuristic script. Every idle
+      session on this machine (its task + transcript tail) is handed to ONE
+      'agents run --mode plan' call per tick, which judges each: idle-but-unfinished
+      (was given a task, went quiet, not finished/handed off) -> NUDGE that drives
+      it to finish; idle-and-done or genuinely-needs-human -> SKIP. The agent is a
+      customizable 'watchdog' workflow (drop a WORKFLOW.md in project/user
+      workflows/ to override the prompt + model); absent one, the built-in prompt
+      runs. Nothing is nudged when nothing is idle (no agent is spawned).
 
       Delivery (answer-router): a running agent is steered via its mailbox; a
       parked-on-question agent is answered into its EXACT split -- tmux / iTerm /

package/dist/lib/account-capabilities.d.ts

@@ -19,6 +19,10 @@ export interface NativeAccountCapability {
     scope: 'version' | 'device' | 'unsupported';
     status: 'supported' | 'conditional' | 'discovery-only' | 'unsupported';
 }
+/** Native-login selector coverage required by RUSH-3053. */
+export declare const NATIVE_ACCOUNT_SELECTOR_AGENTS: readonly ["claude", "codex", "cursor", "grok", "kimi"];
+/** Explicit dispositions for config-isolated harnesses outside that selector. */
+export declare const NATIVE_ACCOUNT_SELECTOR_EXCLUSIONS: Partial<Record<AgentId, string>>;
 /** Canonical truth for native-account naming and attachment semantics. */
 export declare const NATIVE_ACCOUNT_CAPABILITIES: Record<AgentId, NativeAccountCapability>;
 export declare function nativeAccountCapability(agent: AgentId): NativeAccountCapability;