@phnx-labs/agents-cli 1.20.53 → 1.20.54

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 1.20.54
+
+- **Unified fleet target resolution for `agents ssh` + `sessions --host`.** `agents ssh` now accepts the full target grammar the fan-out already used — a registered `name`, a `user@device` (same device, login user overridden, still dialed via its Tailscale route rather than raw LAN DNS), and an ad-hoc `user@host`/`host` literal — instead of only an exact device name (`agents ssh muqsit@mac-mini` no longer errors "Unknown device"). A bare unregistered alias still reports "Unknown device". `sessions --host user@device` now resolves the host part through the registry too, so it stops silently diverging onto the non-Tailscale route. New `resolveDeviceTarget`; `resolveSshTarget` shares one host-part matcher. Source: `apps/cli/src/lib/devices/resolve-target.ts`, `apps/cli/src/commands/ssh.ts`.
+- **`agents sessions --host` searches the peer's whole index, not its login cwd.** A remote listing runs in the peer's SSH-login home dir and was silently cwd-scoped, so `sessions --host <box>` read as empty (`No sessions found for /home/<user>`) even when the box's index was full. `--host` now defaults to whole-index (`--all`) scope; an explicit path query / `--project` / `--since` / `--agent` filter still narrows on top. It also runs the peer once, for itself (`AGENTS_SESSIONS_LOCAL=1`), so it no longer re-sweeps the fleet and prints a spurious `<this-machine>: unreachable`. Source: `apps/cli/src/lib/session/remote.ts`, `apps/cli/src/commands/sessions.ts`.
+- **`agents devices sync` pins each device's login user.** Tailscale status carries a node's OS + address but not the account you ssh in as, so sync now materializes the local operator's username onto newly-synced devices (never clobbering a user you pinned). This makes `--host <device>` dial the same account no matter which machine launches the fan-out, instead of leaning on ssh's implicit local-username default. Source: `apps/cli/src/lib/devices/sync.ts`.
+
 ## 1.20.53
 
 - **`agents add <agent>@latest` resolves to a concrete version before installing (no install race).** `latest` (like `oldest`) is now resolved via `npm view` up front and installed as a pinned spec directly into `versions/<agent>/<version>/`. Previously `latest` installed into a shared, well-known `versions/<agent>/latest/` scratch dir and was renamed to the real version only after npm finished — so a concurrent `agents view` reconcile (`reconcileStaleLatestForAgent`) or a second `latest` install could rename that dir out from under npm mid-extraction, corrupting the install with `ENOENT` on the seeded `package.json`. A concrete dir per version has no shared name to race on. Source: `apps/cli/src/lib/versions.ts`.

package/dist/commands/sessions.js

@@ -28,7 +28,7 @@ import { stringWidth, truncateToWidth, padToWidth, terminalWidth } from '../lib/
 import { discoverSessions, countSessionsInScope, resolveSessionById, searchContentIndex, getSessionRoots } from '../lib/session/discover.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { parseSession } from '../lib/session/parse.js';
-import { runRemoteSessions, buildForwardedArgs } from '../lib/session/remote.js';
+import { runRemoteSessions, buildForwardedArgs, ensureWholeIndex } from '../lib/session/remote.js';
 import { formatRelativeTime } from '../lib/session/relative-time.js';
 import { renderConversationMarkdown, renderSummary, renderSummaryHeader, computeSummaryStats, renderJson, filterEvents, parseRoleList } from '../lib/session/render.js';
 import { renderMarkdown } from '../lib/markdown.js';
@@ -559,8 +559,10 @@ export function serializeSessionsJson(sessions) {
  */
 async function runRemoteSessionsJson(hosts) {
     // Forward the caller's own filters (query, --limit, --since, …) minus --host,
-    // and guarantee --json so each peer answers with a parseable array.
-    const forwarded = buildForwardedArgs(process.argv, new Set(hosts));
+    // and guarantee --json so each peer answers with a parseable array. Force
+    // whole-index scope: an explicit --host means "that box's index", not the
+    // slice that happens to sit under the peer's SSH-login home dir.
+    const forwarded = ensureWholeIndex(buildForwardedArgs(process.argv, new Set(hosts)));
     if (!forwarded.includes('--json'))
         forwarded.push('--json');
     const { sessions } = await gatherRemoteList(forwarded, hosts);

package/dist/commands/ssh.js

@@ -19,7 +19,8 @@ import { readAndResolveBundleEnv } from '../lib/secrets/bundles.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, } from '../lib/devices/registry.js';
 import { nodeToDeviceInput, parseTailscaleStatus, tailscaleStatusJson, } from '../lib/devices/tailscale.js';
-import { planDeviceReconciliation, runDeviceSync } from '../lib/devices/sync.js';
+import { localLoginUser, planDeviceReconciliation, runDeviceSync, withDefaultUser } from '../lib/devices/sync.js';
+import { resolveDeviceTarget } 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';
@@ -106,8 +107,11 @@ async function runInteractiveDeviceSync() {
     }
     const byName = new Map(nodes.map((n) => [n.name, n]));
     const plan = planDeviceReconciliation(byName.keys(), selected, registered, ignored);
-    for (const name of plan.toRegister)
-        await upsertDevice(name, nodeToDeviceInput(byName.get(name)));
+    const localUser = localLoginUser();
+    for (const name of plan.toRegister) {
+        const input = withDefaultUser(nodeToDeviceInput(byName.get(name)), reg[name]?.user, localUser);
+        await upsertDevice(name, input);
+    }
     for (const name of plan.toUnignore)
         await removeIgnored(name);
     for (const name of plan.toRemove)
@@ -332,16 +336,24 @@ secrets bundle via an askpass shim — the password never touches argv.
             await runAskpass();
             return;
         }
-        const device = await mustGetDevice(name);
+        // Accept the full fleet target grammar: a registered `name`, a
+        // `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());
+        if (!device) {
+            console.error(chalk.red(`Unknown device '${name}'. See 'agents devices list'.`));
+            process.exit(1);
+        }
         // Preflight: a device Tailscale last saw offline would otherwise hang
         // for the full ConnectTimeout. Fail fast with a clear message instead.
         if (device.tailscale && !device.tailscale.online) {
-            console.error(chalk.red(`Device '${name}' is offline (Tailscale last saw it ${device.tailscale.lastSeen ?? 'a while ago'}).`));
+            console.error(chalk.red(`Device '${device.name}' is offline (Tailscale last saw it ${device.tailscale.lastSeen ?? 'a while ago'}).`));
             console.error(chalk.gray("Run 'agents devices sync' to refresh reachability."));
             process.exit(1);
         }
         if (device.tailscale?.online && !device.tailscale.direct) {
-            console.error(chalk.yellow(`Note: connection to '${name}' is relayed (DERP ${device.tailscale.relay ?? '?'}) — expect higher latency.`));
+            console.error(chalk.yellow(`Note: connection to '${device.name}' is relayed (DERP ${device.tailscale.relay ?? '?'}) — expect higher latency.`));
         }
         try {
             const shim = writeAskpassShim();

package/dist/lib/devices/resolve-target.d.ts

@@ -1,4 +1,4 @@
-import { type DeviceRegistry } from './registry.js';
+import { type DeviceProfile, type DeviceRegistry } from './registry.js';
 /** A dialable peer: the ssh target, the machine id used to tag its rows, a
  * display name, and the OS family that picks the remote shell dialect. */
 export interface ResolvedSshTarget {
@@ -7,14 +7,31 @@ export interface ResolvedSshTarget {
     name: string;
     os?: string;
 }
+/** Split a `user@host` / `host` token into its login user (if any) and host part. */
+export declare function splitUserHost(token: string): {
+    user?: string;
+    host: string;
+};
 /**
  * Resolve one `--host`/`--device` token to a concrete ssh target through the
  * registry. Registry hit → the device's real address + platform (so the machine
- * id, route, and OS all match the auto-discovery sweep). Miss → a literal
- * `user@host` fallback, its OS taken from the host overlay if enrolled. Returns
- * undefined only when the token fails the shared ssh-target injection guard.
+ * id, route, and OS all match the auto-discovery sweep), with any `user@`
+ * overriding the login account. Miss → a literal `user@host` fallback, its OS
+ * taken from the host overlay if enrolled. Returns undefined only when the token
+ * fails the shared ssh-target injection guard.
  */
 export declare function resolveSshTarget(token: string, reg: DeviceRegistry): ResolvedSshTarget | undefined;
+/**
+ * Resolve a target token to a full {@link DeviceProfile} for `agents ssh`. Same
+ * grammar as {@link resolveSshTarget}, but returns the whole profile (auth,
+ * shell, tailscale metadata) `buildSshInvocation` needs — not just a target
+ * string. A registered `name` or `user@device` yields that profile (with the
+ * login user overridden by any `user@`); an ad-hoc `user@host`/`host` literal
+ * yields a synthesized key-auth profile. A bare unregistered alias (no `@`/dot)
+ * returns undefined so the caller reports "Unknown device" rather than dialing a
+ * literal — the strict behaviour the interactive wrapper has always had.
+ */
+export declare function resolveDeviceTarget(token: string, reg: DeviceRegistry): DeviceProfile | undefined;
 /**
  * Resolve an explicit `--host`/`--device` list to dialable targets, reading the
  * registry once. A token that fails the injection guard is skipped with a

package/dist/lib/devices/resolve-target.js

@@ -13,8 +13,12 @@
  * `%C` hash → a cold dial every time) and could read a perfectly reachable box
  * as "unreachable" when only the non-Tailscale route was down.
  *
- * A raw `user@host` that matches no registered device falls back to a literal
- * target so ad-hoc boxes still work.
+ * The grammar is uniform across the fleet: `mac-mini` (device name), and
+ * `muqsit@mac-mini` (same device, login user overridden) both resolve through
+ * the registry to the device's Tailscale route — the `user@` form no longer
+ * short-circuits to a bare `ssh muqsit@mac-mini` (LAN DNS). A `user@host` that
+ * matches no registered device falls back to a literal target so ad-hoc boxes
+ * still work.
  */
 import chalk from 'chalk';
 import { assertValidSshTarget } from '../ssh-exec.js';
@@ -22,12 +26,28 @@ import { normalizeHost } from '../machine-id.js';
 import { resolveRemoteOsSync } from '../hosts/remote-os.js';
 import { sshTargetFor } from './connect.js';
 import { loadDevices } from './registry.js';
+/** Split a `user@host` / `host` token into its login user (if any) and host part. */
+export function splitUserHost(token) {
+    const at = token.indexOf('@');
+    return at === -1 ? { host: token } : { user: token.slice(0, at), host: token.slice(at + 1) };
+}
+/**
+ * Match a host part (the piece after any `user@`) to a registered device: exact
+ * registry key first, then a normalized-host match so `yosemite-s0` and
+ * `yosemite-s0.<tailnet>.ts.net` land on the same profile. The single source of
+ * truth both `resolveSshTarget` (fan-out) and `resolveDeviceTarget` (`agents
+ * ssh`) share, so a `user@device` can never resolve two different routes.
+ */
+function matchDevice(host, reg) {
+    return reg[host] ?? Object.values(reg).find((d) => normalizeHost(d.name) === normalizeHost(host));
+}
 /**
  * Resolve one `--host`/`--device` token to a concrete ssh target through the
  * registry. Registry hit → the device's real address + platform (so the machine
- * id, route, and OS all match the auto-discovery sweep). Miss → a literal
- * `user@host` fallback, its OS taken from the host overlay if enrolled. Returns
- * undefined only when the token fails the shared ssh-target injection guard.
+ * id, route, and OS all match the auto-discovery sweep), with any `user@`
+ * overriding the login account. Miss → a literal `user@host` fallback, its OS
+ * taken from the host overlay if enrolled. Returns undefined only when the token
+ * fails the shared ssh-target injection guard.
  */
 export function resolveSshTarget(token, reg) {
     try {
@@ -36,22 +56,70 @@ export function resolveSshTarget(token, reg) {
     catch {
         return undefined;
     }
-    const bare = token.split('@').pop() || token;
-    // An explicit `user@host` names an exact account/target — honour it literally.
-    // A bare alias (`yosemite-s0`) resolves through the registry to the device's
-    // real address, so it never diverges from the auto-discovery sweep.
-    const device = token.includes('@')
-        ? undefined
-        : reg[token] ?? Object.values(reg).find((d) => normalizeHost(d.name) === normalizeHost(bare));
+    const { user, host } = splitUserHost(token);
+    // A device and a `user@device` are the same box; resolve the host part through
+    // the registry so both dial the Tailscale route, and let an explicit `user@`
+    // override only the login account.
+    const device = matchDevice(host, reg);
     if (device) {
         try {
-            return { target: sshTargetFor(device), machine: normalizeHost(device.name), name: device.name, os: device.platform };
+            const effective = user ? { ...device, user } : device;
+            return { target: sshTargetFor(effective), machine: normalizeHost(device.name), name: device.name, os: device.platform };
         }
         catch {
             // Registered but has no address to dial — fall through to the literal token.
         }
     }
-    return { target: token, machine: normalizeHost(bare), name: token, os: resolveRemoteOsSync(token) };
+    return { target: token, machine: normalizeHost(host), name: token, os: resolveRemoteOsSync(token) };
+}
+/** Timestamps for a synthesized ad-hoc profile — never persisted, so a constant
+ * keeps the value deterministic (and side-effect free) without reading the clock. */
+const SYNTH_TS = '1970-01-01T00:00:00.000Z';
+/** True when a token is clearly a network target (a `user@`, or a dotted/IPv6
+ * host / IP) rather than a bare alias. A bare unknown word is a typo, so `agents
+ * ssh foo` still says "Unknown device" instead of dialing a literal `foo`. */
+function looksLikeHostLiteral(token) {
+    return token.includes('@') || token.includes('.') || token.includes(':');
+}
+/** Synthesize a throwaway device profile for an ad-hoc `user@host` / `host`
+ * literal so `agents ssh` can dial a box that was never registered. */
+function adHocDevice(token, host, user) {
+    const isIp = /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
+    return {
+        name: token,
+        platform: 'unknown',
+        shell: 'posix',
+        user,
+        address: { via: 'manual', dnsName: isIp ? undefined : host, ip: isIp ? host : undefined },
+        auth: { method: 'key' },
+        createdAt: SYNTH_TS,
+        updatedAt: SYNTH_TS,
+    };
+}
+/**
+ * Resolve a target token to a full {@link DeviceProfile} for `agents ssh`. Same
+ * grammar as {@link resolveSshTarget}, but returns the whole profile (auth,
+ * shell, tailscale metadata) `buildSshInvocation` needs — not just a target
+ * string. A registered `name` or `user@device` yields that profile (with the
+ * login user overridden by any `user@`); an ad-hoc `user@host`/`host` literal
+ * yields a synthesized key-auth profile. A bare unregistered alias (no `@`/dot)
+ * returns undefined so the caller reports "Unknown device" rather than dialing a
+ * literal — the strict behaviour the interactive wrapper has always had.
+ */
+export function resolveDeviceTarget(token, reg) {
+    try {
+        assertValidSshTarget(token);
+    }
+    catch {
+        return undefined;
+    }
+    const { user, host } = splitUserHost(token);
+    const device = matchDevice(host, reg);
+    if (device)
+        return user ? { ...device, user } : device;
+    if (looksLikeHostLiteral(token))
+        return adHocDevice(token, host, user);
+    return undefined;
 }
 /**
  * Resolve an explicit `--host`/`--device` list to dialable targets, reading the

package/dist/lib/devices/sync.d.ts

@@ -1,5 +1,23 @@
+import { type DeviceInput } from './registry.js';
 import { type TailscaleNode } from './tailscale.js';
 import type { PendingDevice } from './pending.js';
+/**
+ * The login user to stamp onto newly-synced devices. Tailscale status carries a
+ * node's OS and address but NOT the account you ssh in as, so we materialize the
+ * local operator's username — tailnet devices are overwhelmingly one person's
+ * boxes, and this is exactly the account ssh would already fall back to. Pinning
+ * it in the registry makes `--host <device>` dial that account no matter which
+ * machine launches the fan-out (a peer whose local user differs otherwise dials
+ * the wrong account). Returns undefined when the username isn't a safe ssh
+ * identifier, so a weird value never lands in the registry. */
+export declare function localLoginUser(): string | undefined;
+/**
+ * Fill in a device's login user during sync WITHOUT ever clobbering an account
+ * the user pinned. Precedence: an existing registered user wins; else the local
+ * operator's username; else leave it unset (ssh's implicit local default still
+ * applies). Pure so the "never overwrite an explicit user" guard is unit-tested
+ * without a tailnet. */
+export declare function withDefaultUser(input: DeviceInput, prevUser: string | undefined, localUser: string | undefined): DeviceInput;
 /**
  * bootstrap — register every non-ignored node (opt-out). First-run `agents
  *   setup` and manual `agents devices sync`, so the fleet is usable out of box.

package/dist/lib/devices/sync.js

@@ -14,8 +14,39 @@
  *   - soft (`soft: true`): auto-callers must never abort setup/sync because a
  *     machine has no tailscale — they get a result with `ok: false` instead.
  */
+import * as os from 'os';
 import { loadDevices, loadIgnored, upsertDevice, } from './registry.js';
 import { nodeToDeviceInput, parseTailscaleStatus, tailscaleStatusJson, } from './tailscale.js';
+/**
+ * The login user to stamp onto newly-synced devices. Tailscale status carries a
+ * node's OS and address but NOT the account you ssh in as, so we materialize the
+ * local operator's username — tailnet devices are overwhelmingly one person's
+ * boxes, and this is exactly the account ssh would already fall back to. Pinning
+ * it in the registry makes `--host <device>` dial that account no matter which
+ * machine launches the fan-out (a peer whose local user differs otherwise dials
+ * the wrong account). Returns undefined when the username isn't a safe ssh
+ * identifier, so a weird value never lands in the registry. */
+export function localLoginUser() {
+    let u;
+    try {
+        u = os.userInfo().username;
+    }
+    catch {
+        u = process.env.USER || process.env.USERNAME || undefined;
+    }
+    return u && /^[a-zA-Z0-9._-]+$/.test(u) ? u : undefined;
+}
+/**
+ * Fill in a device's login user during sync WITHOUT ever clobbering an account
+ * the user pinned. Precedence: an existing registered user wins; else the local
+ * operator's username; else leave it unset (ssh's implicit local default still
+ * applies). Pure so the "never overwrite an explicit user" guard is unit-tested
+ * without a tailnet. */
+export function withDefaultUser(input, prevUser, localUser) {
+    if (input.user || prevUser || !localUser)
+        return input;
+    return { ...input, user: localUser };
+}
 /**
  * Node names present on the tailnet but neither already in the registry nor on
  * the ignore-list — i.e. genuinely new devices worth surfacing. Pure so the
@@ -68,8 +99,10 @@ export async function runDeviceSync(opts = {}) {
             platform: byName.get(name)?.platform ?? 'unknown',
         }));
         const toUpsert = selectNodesToUpsert(nodes, registered, ignored, mode);
+        const localUser = localLoginUser();
         for (const node of toUpsert) {
-            await upsertDevice(node.name, nodeToDeviceInput(node));
+            const input = withDefaultUser(nodeToDeviceInput(node), registeredBefore[node.name]?.user, localUser);
+            await upsertDevice(node.name, input);
         }
         return { ok: true, synced: toUpsert.length, pending };
     }

package/dist/lib/session/remote.d.ts

@@ -16,6 +16,19 @@ export declare function shellQuote(s: string): string;
  *             (`[runtime, script, 'sessions', ...]`).
  */
 export declare function buildForwardedArgs(argv: string[], hosts?: Set<string>): string[];
+/**
+ * Force a forwarded `agents sessions` listing to span the peer's WHOLE index.
+ *
+ * A remote listing runs in the peer's SSH-login cwd — its home dir — and the
+ * default listing is silently cwd-scoped, so `sessions --host box` reads as
+ * empty even when the box's index is full (`No sessions found for /home/<user>`).
+ * Across SSH a peer's cwd is meaningless, so `--host` defaults to `--all`
+ * (whole-index) scope. This only drops the *cwd* narrowing — an explicit path
+ * query, `--project`, `--since`, or `--agent` filter still narrows on top, and
+ * a query that looks like a path takes precedence over `--all` on the remote.
+ * Idempotent: never adds a second `--all`.
+ */
+export declare function ensureWholeIndex(forwardedArgs: string[]): string[];
 /**
  * Build the single remote command string for `ssh <host> <cmd>`. Forwarded args
  * are quoted for the inner login shell, then the whole `agents …` invocation is

package/dist/lib/session/remote.js

@@ -30,6 +30,7 @@ import { getCacheDir } from '../state.js';
 import { SSH_OPTS, controlOpts, assertValidSshTarget } from '../ssh-exec.js';
 import { remoteShellFor, buildWindowsAgentsCommand } from '../hosts/remote-cmd.js';
 import { resolveRemoteOsSync } from '../hosts/remote-os.js';
+import { NO_FANOUT_ENV } from './remote-active.js';
 import { formatRelativeTime } from './relative-time.js';
 import { terminalWidth } from './width.js';
 /**
@@ -81,6 +82,21 @@ export function buildForwardedArgs(argv, hosts = new Set()) {
     }
     return out;
 }
+/**
+ * Force a forwarded `agents sessions` listing to span the peer's WHOLE index.
+ *
+ * A remote listing runs in the peer's SSH-login cwd — its home dir — and the
+ * default listing is silently cwd-scoped, so `sessions --host box` reads as
+ * empty even when the box's index is full (`No sessions found for /home/<user>`).
+ * Across SSH a peer's cwd is meaningless, so `--host` defaults to `--all`
+ * (whole-index) scope. This only drops the *cwd* narrowing — an explicit path
+ * query, `--project`, `--since`, or `--agent` filter still narrows on top, and
+ * a query that looks like a path takes precedence over `--all` on the remote.
+ * Idempotent: never adds a second `--all`.
+ */
+export function ensureWholeIndex(forwardedArgs) {
+    return forwardedArgs.includes('--all') ? forwardedArgs : [...forwardedArgs, '--all'];
+}
 /**
  * Build the single remote command string for `ssh <host> <cmd>`. Forwarded args
  * are quoted for the inner login shell, then the whole `agents …` invocation is
@@ -93,16 +109,23 @@ export function buildForwardedArgs(argv, hosts = new Set()) {
  * remote renders its table to the local screen.
  */
 export function buildRemoteCommand(forwardedArgs, columns, os) {
+    // `--host <box>` means "that box's own sessions" — so the peer must answer for
+    // ITSELF and not re-sweep its fleet. Without this the remote `agents sessions`
+    // fans back out to every device IT knows (including us), printing a spurious
+    // `<this-machine>: unreachable`. AGENTS_SESSIONS_LOCAL=1 pins the peer local,
+    // matching the JSON fan-out path (`remote-list.ts`).
     if (remoteShellFor(os) === 'powershell') {
-        const env = columns && columns > 0 ? { COLUMNS: String(columns) } : undefined;
+        const env = { [NO_FANOUT_ENV]: '1' };
+        if (columns && columns > 0)
+            env.COLUMNS = String(columns);
         return buildWindowsAgentsCommand({ args: forwardedArgs, env });
     }
     const inner = ['agents', ...forwardedArgs].map(shellQuote).join(' ');
     // Forward the caller's terminal width so the remote renders the table to the
     // local screen (over SSH the remote's own COLUMNS is unset/wrong). `VAR=val
     // cmd` scopes the env to that process — the remote's terminalWidth() reads it.
-    const withCols = columns && columns > 0 ? `COLUMNS=${columns} ${inner}` : inner;
-    return `bash -lc ${shellQuote(withCols)}`;
+    const envPrefix = `${NO_FANOUT_ENV}=1` + (columns && columns > 0 ? ` COLUMNS=${columns}` : '');
+    return `bash -lc ${shellQuote(`${envPrefix} ${inner}`)}`;
 }
 /**
  * Classify an ssh `spawnSync` result. ssh(1) reserves exit 255 for its own
@@ -182,7 +205,7 @@ function replayRemoteCache(host, forwardedArgs) {
 export function runRemoteSessions(hosts, argv = process.argv) {
     for (const host of hosts)
         assertValidSshTarget(host); // fail fast on any bad target
-    const forwarded = buildForwardedArgs(argv, new Set(hosts));
+    const forwarded = ensureWholeIndex(buildForwardedArgs(argv, new Set(hosts)));
     const cols = terminalWidth();
     const multi = hosts.length > 1;
     let failures = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.53",
+  "version": "1.20.54",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",