@phnx-labs/agents-cli 1.22.34 → 1.22.37

package/dist/lib/shims.js

@@ -223,12 +223,79 @@ async function promptConflictStrategy(conflictInfos) {
 //        The old dispatcher checked only the global dir, so a pinned grok that
 //        installed into the versioned home fell through to the "not installed"
 //        error.
-export const SHIM_SCHEMA_VERSION = 29;
+// v30 — RUSH-2459: two compounding grok binary-resolution bugs fixed. (1) The
+//        "exact version match" grep ran against `ls`'s FULL PATH output, and
+//        the versioned home's own path always contains the version string
+//        (.../versions/grok/<version>/...), so it matched every candidate
+//        unconditionally and silently degraded to "whatever ls sorts first" —
+//        now matched against each candidate's basename instead. (2) When no
+//        filename genuinely carries the version, the fallback no longer
+//        trusts whatever sorts first: it rejects any grok-* candidate under
+//        1MB (real grok binaries are ~100MB+; a stray wrapper/alias script is
+//        a few hundred bytes) and prefers the most recently modified
+//        survivor. On yosemite-s0 both bugs fired together: a stale, unrelated
+//        grok-0.2.118-* file — a 99-byte wrapper that exec'd cursor-agent —
+//        sorted alphabetically before the real self-updated grok binary and
+//        was silently launched instead.
+export const SHIM_SCHEMA_VERSION = 30;
 /** Internal marker string used to embed the schema version in shim scripts. */
 const SHIM_VERSION_MARKER = 'agents-shim-version:';
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+/**
+ * Bash function embedded in every generated grok binary-resolution block
+ * (the dispatcher shim's `generateShimScript` and the direct alias's
+ * `generateVersionedAliasScript`). Prints the path to use, or nothing.
+ *
+ * Prefers a `grok-*` FILENAME that carries the pinned version string —
+ * checked against `basename`, never the full path: `dir` is always
+ * `.../versions/grok/<version>/home/.grok/downloads`, so the version string
+ * is already a substring of every path in that directory regardless of the
+ * actual filename. The original `ls "$dir"/grok-* | grep -i "$version"`
+ * matched on the full line and so matched every candidate unconditionally,
+ * silently degrading to "whatever sorts first" — the versioned-home half of
+ * RUSH-2459, distinct from (and compounding) the missing-match fallback bug
+ * below.
+ *
+ * Grok self-updates its binary in place while running under the shim, so a
+ * version-home's downloads dir can accumulate several `grok-*` files whose
+ * names have drifted away from the version-home's pinned version — when no
+ * filename carries it, never trust whatever the directory listing returns
+ * first (RUSH-2459: a stale, unrelated 99-byte wrapper script matching the
+ * `grok-*` naming pattern sorted before the real ~127MB self-updated binary
+ * and was silently exec'd). Instead, reject anything under
+ * MIN_GROK_BINARY_BYTES — comfortably above any wrapper/alias artifact,
+ * comfortably below a real compiled binary — and among the survivors, pick
+ * the most recently modified: the file grok's self-updater actually wrote
+ * last. Mirrors the TS implementation, `resolveGrokFallbackBinary` in
+ * versions.ts (which reads bare filenames via `fs.readdirSync` and so never
+ * had the full-path-match bug).
+ */
+const GROK_RESOLVE_BINARY_FN = `_resolve_grok_binary() {
+  local dir="$1" version_hint="$2"
+  local candidate base size mtime
+  for candidate in "$dir"/grok-*; do
+    [ -f "$candidate" ] || continue
+    base=$(basename "$candidate")
+    case "$base" in
+      *"$version_hint"*) printf '%s\\n' "$candidate"; return ;;
+    esac
+  done
+  local min_bytes=1000000
+  local best="" best_mtime=-1
+  for candidate in "$dir"/grok-*; do
+    [ -f "$candidate" ] || continue
+    size=$(wc -c < "$candidate" 2>/dev/null || echo 0)
+    [ "$size" -ge "$min_bytes" ] || continue
+    mtime=$(stat -c %Y "$candidate" 2>/dev/null || stat -f %m "$candidate" 2>/dev/null || echo -1)
+    if [ "$mtime" -gt "$best_mtime" ]; then
+      best_mtime="$mtime"
+      best="$candidate"
+    fi
+  done
+  printf '%s\\n' "$best"
+}`;
 function codexShimLaunchArgs() {
     return [
         '-c',
@@ -236,6 +303,43 @@ function codexShimLaunchArgs() {
         ...codexPolicyArgs('edit'),
     ].map(shellQuote).join(' ');
 }
+/**
+ * The `exec` tail for a generated shim. For most agents this is a plain
+ * `exec "$BINARY"<launchArgs> "$@"`.
+ *
+ * Codex is special: its `workspace-write` sandbox hardcodes any `.agents/` (and
+ * `.codex/`) directory read-only, but agents-cli keeps every worktree at
+ * `<repo>/.agents/worktrees/<slug>`, so an in-repo build under a static
+ * shim would hit `EROFS`. The `agents run codex` path fixes this by adding
+ * `<repo>/.agents` to the profile's `workspace_roots` (see codexEditWritableRoots
+ * / repoAgentsDirForCwd), but a static shim has no cwd at generation time. So the
+ * shim resolves the repo's `.agents` from `$PWD` at RUN time — worktree-aware,
+ * mirroring repoAgentsDirForCwd — and passes it via Codex's own `--add-dir`
+ * (verified to compose with the `agents-edit` profile). The resolution is inline
+ * bash because the shim is the launch hot path and must not spawn Node to compute
+ * one directory. `--add-dir` is added only when the resolved `.agents` exists.
+ */
+function shimExecTail(agent, launchArgs) {
+    if (agent !== 'codex')
+        return `exec "$BINARY"${launchArgs} "$@"`;
+    return `_repo_agents=""
+case "$PWD" in
+  */.agents/worktrees/*) _repo_agents="\${PWD%%/.agents/worktrees/*}/.agents" ;;
+  *)
+    _d="$PWD"
+    # Stop before $HOME so a dotfiles repo at $HOME is not treated as the project
+    # root (mirrors repoRootForCwd's home exclusion in project-key.ts).
+    while [ -n "$_d" ] && [ "$_d" != "/" ] && [ "$_d" != "$HOME" ]; do
+      if [ -e "$_d/.git" ]; then _repo_agents="$_d/.agents"; break; fi
+      _d=$(dirname "$_d")
+    done
+    ;;
+esac
+if [ -n "$_repo_agents" ] && [ -d "$_repo_agents" ]; then
+  exec "$BINARY"${launchArgs} --add-dir "$_repo_agents" "$@"
+fi
+exec "$BINARY"${launchArgs} "$@"`;
+}
 function getAgentsBinForGeneratedShim() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'index.js');
 }
@@ -501,27 +605,20 @@ VERSION_DIR="$AGENTS_USER_DIR/.history/versions/$AGENT/$VERSION"
 # for pre-fix installs, the global ~/.grok/downloads), not node_modules. We
 # still use the agents-cli version dir purely for GROK_HOME isolation.
 if [ "$AGENT" = "grok" ]; then
+${GROK_RESOLVE_BINARY_FN}
   # Check the versioned home first — this is where the binary lands when the
   # installer runs with GROK_HOME set (i.e. via the shim or a correct
   # \`agents add grok\`), or when grok self-updates from within the shim.
   GROK_DOWNLOADS="$VERSION_DIR/home/.grok/downloads"
   if [ -d "$GROK_DOWNLOADS" ]; then
-    # Prefer a binary whose filename contains the exact version
-    BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | grep -i "$VERSION" | head -1)
-    if [ -z "$BINARY" ]; then
-      # Fallback to the "current" grok binary (symlink or latest)
-      BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | head -1)
-    fi
+    BINARY=$(_resolve_grok_binary "$GROK_DOWNLOADS" "$VERSION")
   fi
   # Fall back to the global grok home (binary installed without GROK_HOME set,
   # e.g. an earlier \`agents add grok@latest\` before this resolution fix).
   if [ -z "$BINARY" ] || [ ! -x "$BINARY" ]; then
     GROK_DOWNLOADS="$HOME/.grok/downloads"
     if [ -d "$GROK_DOWNLOADS" ]; then
-      BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | grep -i "$VERSION" | head -1)
-      if [ -z "$BINARY" ]; then
-        BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | head -1)
-      fi
+      BINARY=$(_resolve_grok_binary "$GROK_DOWNLOADS" "$VERSION")
     fi
   fi
   if [ -z "$BINARY" ] || [ ! -x "$BINARY" ]; then
@@ -585,13 +682,12 @@ elif [ "$AGENT" = "muse" ]; then
     fi
   fi
 elif [ "$AGENT" = "warp" ]; then
-  # Warp Agent CLI installs a global, self-updating oz binary (brew cask on
-  # macOS, the oz-stable apt|yum|pacman package on Linux) -- a platform/package
-  # specific location, not ~/.local/bin -- so resolve it from PATH with the same
-  # shims-dir re-exec guard as droid/muse.
+  # Warp Agent CLI installs a global, self-updating warp binary at
+  # ~/.local/bin/warp (curl installer) -- like droid/muse -- so resolve it from
+  # PATH with the same shims-dir re-exec guard as droid/muse.
   BINARY=$(adopted_original_bin || echo "")
   if [ -z "$BINARY" ]; then
-    BINARY=$(command -v oz 2>/dev/null || echo "")
+    BINARY=$(command -v warp 2>/dev/null || echo "")
     case "$(readlink -f "$BINARY" 2>/dev/null)" in
       "$AGENTS_USER_DIR/.cache/shims/"*) BINARY="" ;;
     esac
@@ -707,7 +803,7 @@ if [ "\$LAUNCH_SKIP" = "0" ]; then
   "\$AGENTS_BIN" sync --agent "\$AGENT" --agent-version "\$VERSION" --launch --cwd "\$PWD" --quiet 2>/dev/null || true
 fi
 
-exec "$BINARY"${launchArgs} "$@"
+${shimExecTail(agent, launchArgs)}
 `;
 }
 /**
@@ -905,8 +1001,22 @@ export function removeShim(agent) {
  *        alias failed with "not installed" whenever the binary was staged into
  *        the versioned home (installer run with GROK_HOME set, or grok
  *        self-update under the shim).
+ *  v16 — RUSH-2459: two compounding grok binary-resolution bugs fixed. (1) The
+ *        "exact version match" grep ran against `ls`'s FULL PATH output, and
+ *        the versioned home's own path always contains the version string
+ *        (.../versions/grok/<version>/...), so it matched every candidate
+ *        unconditionally and silently degraded to "whatever ls sorts first" —
+ *        now matched against each candidate's basename instead. (2) When no
+ *        filename genuinely carries the version, the fallback no longer
+ *        trusts whatever sorts first: it rejects any grok-* candidate under
+ *        1MB (real grok binaries are ~100MB+; a stray wrapper/alias script is
+ *        a few hundred bytes) and prefers the most recently modified
+ *        survivor. On yosemite-s0 both bugs fired together: a stale, unrelated
+ *        grok-0.2.118-* file — a 99-byte wrapper that exec'd cursor-agent —
+ *        sorted alphabetically before the real self-updated grok binary and
+ *        was silently launched instead.
  */
-export const VERSIONED_ALIAS_SCHEMA_VERSION = 15;
+export const VERSIONED_ALIAS_SCHEMA_VERSION = 16;
 /** Internal marker string used to embed the schema version in versioned alias scripts. */
 const VERSIONED_ALIAS_VERSION_MARKER = 'agents-versioned-alias-version:';
 // The version string is interpolated into a generated bash script and into
@@ -1025,18 +1135,17 @@ export XDG_CONFIG_HOME="$HOME/.agents/.history/versions/${agent}/${version}/home
     const binaryResolution = agent === 'grok'
         ? `# Grok ships its native binary in the versioned home's .grok/downloads (or,
 # for pre-fix installs, the global ~/.grok/downloads), not node_modules.
+${GROK_RESOLVE_BINARY_FN}
 GROK_DOWNLOADS="${versionDir}/home/.grok/downloads"
 BINARY=""
 if [ -d "$GROK_DOWNLOADS" ]; then
-  BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | grep -i "${version}" | head -1)
-  [ -n "$BINARY" ] || BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | head -1)
+  BINARY=$(_resolve_grok_binary "$GROK_DOWNLOADS" "${version}")
 fi
 # Fall back to the global grok home (binary installed without GROK_HOME set).
 if [ -z "$BINARY" ] || [ ! -x "$BINARY" ]; then
   GROK_GLOBAL_DOWNLOADS="$HOME/.grok/downloads"
   if [ -d "$GROK_GLOBAL_DOWNLOADS" ]; then
-    BINARY=$(ls "$GROK_GLOBAL_DOWNLOADS"/grok-* 2>/dev/null | grep -i "${version}" | head -1)
-    [ -n "$BINARY" ] || BINARY=$(ls "$GROK_GLOBAL_DOWNLOADS"/grok-* 2>/dev/null | head -1)
+    BINARY=$(_resolve_grok_binary "$GROK_GLOBAL_DOWNLOADS" "${version}")
   fi
 fi
 # Refuse a PATH match under our own shims dir — it resolves to this alias's
@@ -1073,10 +1182,10 @@ else
   esac
 fi`
                 : agent === 'warp'
-                    ? `# Warp Agent CLI installs a global self-updating \`oz\` binary (brew cask on
-# macOS, oz-stable apt|yum|pacman on Linux) — a platform-specific location, not
-# ~/.local/bin — so resolve it from PATH, refusing anything under our shims dir.
-BINARY=$(command -v oz 2>/dev/null || echo "")
+                    ? `# Warp Agent CLI installs a global self-updating \`warp\` binary at
+# ~/.local/bin/warp (curl installer) — like droid/muse — so resolve it from
+# PATH, refusing anything under our shims dir.
+BINARY=$(command -v warp 2>/dev/null || echo "")
 case "$BINARY" in
   "$HOME/.agents/.cache/shims/"*) BINARY="" ;;
 esac`
@@ -1094,7 +1203,7 @@ if [ -z "$BINARY" ] || [ ! -x "$BINARY" ]; then
 fi
 ${managedEnv}
 
-exec "$BINARY"${launchArgs} "$@"
+${shimExecTail(agent, launchArgs)}
 `;
 }
 /**

package/dist/lib/signin-badge.js

@@ -24,11 +24,12 @@ export function loginHint(agentId) {
             return `${cli}, then /login`;
         case 'codex':
         case 'grok':
-        // Warp Agent CLI: `oz login` opens a browser sign-in (or set WARP_API_KEY).
-        case 'warp':
             return `${cli} login`;
         case 'opencode':
             return `${cli} auth login`;
+        // Warp Agent CLI has no `login` subcommand: running `warp` opens a browser
+        // sign-in on launch (or set WARP_API_KEY / pass --api-key), so the default
+        // bare-`warp` hint is correct.
         default:
             return cli;
     }

package/dist/lib/skills.js

@@ -10,6 +10,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
+import { normalizeAliases } from './resource-aliases.js';
 import { AGENTS, ensureSkillsDir, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
 import { getUserSkillsDir, getSkillsDir as getSystemSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, getTrashSkillsDir } from './state.js';
@@ -98,6 +99,7 @@ export function tryParseSkillMetadata(skillDir) {
                         version: parsed.version,
                         license: parsed.license,
                         keywords: parsed.keywords,
+                        aliases: normalizeAliases(parsed.aliases),
                     },
                 };
             }

package/dist/lib/smart-launch.d.ts

@@ -59,11 +59,13 @@ export interface DeviceAutoPlan {
     }>;
     pickedDeviceKey: string;
 }
+export declare function formatNoHealthyDeviceError(pool: string[], signals: Map<string, DevicePlacementSignal>, agent?: string): string;
 /**
  * Pick the least-loaded healthy device that can run `agent` when the harness is
- * known. `run auto` omits the agent and ranks the same live health/load signals
- * without an installed-harness filter. The local machine participates in the
- * same probe; a fully unusable fleet degrades to local instead of stranding a run.
+ * known. `run auto` omits the agent and treats any ready account on the device
+ * as eligible. The local machine participates in the
+ * same probe and must pass the same eligibility checks. An empty eligible pool
+ * fails loud; automatic placement never silently becomes a local launch.
  */
 export declare function resolveDeviceAuto(agent?: string, opts?: {
     eligibleHosts?: string[];
@@ -87,12 +89,10 @@ export type DeviceAutoHostOptions = {
     strategy?: string;
 };
 export type DeviceAutoApplyResult = {
-    /** True when affinity ran (success or degrade-to-local). */
+    /** True when automatic placement ran successfully. */
     attempted: boolean;
     /** True when deprecated `--smart` was seen. */
     deprecationSmart: boolean;
-    /** Affinity threw: host slots cleared → local; message for stderr. */
-    skipped?: string;
     /** Present when affinity resolved without error. */
     banner?: {
         hostLabel: string;
@@ -102,8 +102,8 @@ export type DeviceAutoApplyResult = {
 };
 /**
  * Apply `--device auto` / `--host auto` (and deprecated `--smart`) onto run options.
- * Mutates `options` in place. On affinity failure, clears auto slots (local) and
- * returns `skipped` — never throws; callers must not hard-exit.
+ * Mutates `options` in place. Placement failures propagate without rewriting
+ * `auto`, so callers fail loud instead of silently launching locally.
  */
 export declare function applyDeviceAutoToOptions(options: DeviceAutoHostOptions, deps?: {
     resolve?: () => DeviceAutoPlan | Promise<DeviceAutoPlan>;

package/dist/lib/smart-launch.js

@@ -11,6 +11,7 @@ import { loadDevicesSync } from './devices/registry.js';
 import { normalizeHost } from './machine-id.js';
 import { probePoolSignals } from './teams/placement-probe.js';
 import { pickBestDevice } from './teams/scheduler.js';
+import { getAccountInfo } from './agents.js';
 /** Peakiness of usage weights; >1 amplifies the most-used option. */
 export const DEFAULT_AFFINITY_ALPHA = 1.3;
 /**
@@ -64,38 +65,73 @@ export function listOnlineDeviceNames(localName = localMachineId()) {
     }
     return [...names];
 }
+export function formatNoHealthyDeviceError(pool, signals, agent) {
+    const excluded = pool.map((key) => {
+        const signal = signals.get(key);
+        const reason = signal?.reachable !== true
+            ? 'unreachable'
+            : signal.headroom === 'loaded'
+                ? 'overloaded'
+                : signal.installed !== true || signal.signedIn !== true
+                    ? 'no ready harness account'
+                    : 'ineligible';
+        return `${key} (${reason})`;
+    }).join(', ');
+    const target = agent ? `can run ${agent}` : "for 'run auto'";
+    return `agents: no healthy device ${target} — excluded: ${excluded}; earliest window resets unknown`;
+}
 /**
  * Pick the least-loaded healthy device that can run `agent` when the harness is
- * known. `run auto` omits the agent and ranks the same live health/load signals
- * without an installed-harness filter. The local machine participates in the
- * same probe; a fully unusable fleet degrades to local instead of stranding a run.
+ * known. `run auto` omits the agent and treats any ready account on the device
+ * as eligible. The local machine participates in the
+ * same probe and must pass the same eligibility checks. An empty eligible pool
+ * fails loud; automatic placement never silently becomes a local launch.
  */
 export async function resolveDeviceAuto(agent, opts = {}) {
     const local = normalizeHost(opts.localMachine ?? localMachineId());
     const pool = [...new Set((opts.eligibleHosts ?? listOnlineDeviceNames(local)).map(normalizeHost))];
     if (!pool.includes(local))
         pool.push(local);
-    try {
-        const signals = await (opts.probe ?? probePoolSignals)(pool, agent);
-        const picked = pickBestDevice(pool, [], { signals, agentLabel: agent });
-        return {
-            host: picked === local ? null : picked,
-            pickedDeviceKey: picked,
-            candidates: pool.map((key) => ({
-                key,
-                loadPercent: signals.get(key)?.loadPercent,
-                installed: signals.get(key)?.installed,
-                signedIn: signals.get(key)?.signedIn,
-            })),
-        };
+    const signals = await (opts.probe ?? probePoolSignals)(pool, agent);
+    if (!agent && !opts.probe) {
+        const { collectFleetHarnesses } = await import('../commands/ssh.js');
+        const inventory = await collectFleetHarnesses({ devices: pool });
+        const byHost = new Map(inventory.map((result) => [normalizeHost(result.host), result]));
+        for (const key of pool) {
+            const result = byHost.get(key);
+            const accountEligible = !!result && !result.error && !result.skipped && result.rows.some((row) => row.ready);
+            const current = signals.get(key);
+            if (current)
+                signals.set(key, { ...current, installed: accountEligible, signedIn: accountEligible });
+        }
     }
-    catch {
-        return {
-            host: null,
-            pickedDeviceKey: local,
-            candidates: [{ key: local }],
-        };
+    if (agent && !opts.probe && signals.has(local)) {
+        const info = await getAccountInfo(agent).catch(() => null);
+        const eligible = !!info?.signedIn && info.usageStatus !== 'rate_limited' && info.usageStatus !== 'out_of_credits';
+        signals.set(local, { ...signals.get(local), signedIn: eligible });
     }
+    const eligiblePool = pool.filter((key) => {
+        const signal = signals.get(key);
+        if (signal?.reachable !== true || signal.headroom === 'loaded')
+            return false;
+        if (!agent)
+            return opts.probe ? true : signal.installed === true && signal.signedIn === true;
+        return signal.installed === true && signal.signedIn === true;
+    });
+    if (eligiblePool.length === 0) {
+        throw new Error(formatNoHealthyDeviceError(pool, signals, agent));
+    }
+    const picked = pickBestDevice(eligiblePool, [], { signals, agentLabel: agent });
+    return {
+        host: picked === local ? null : picked,
+        pickedDeviceKey: picked,
+        candidates: pool.map((key) => ({
+            key,
+            loadPercent: signals.get(key)?.loadPercent,
+            installed: signals.get(key)?.installed,
+            signedIn: signals.get(key)?.signedIn,
+        })),
+    };
 }
 /**
  * Resolve host for `--device auto`. Does NOT pick harness or accounts.
@@ -152,8 +188,8 @@ export function isDeviceAuto(value) {
 const HOST_SLOTS = ['host', 'device', 'on', 'computer'];
 /**
  * Apply `--device auto` / `--host auto` (and deprecated `--smart`) onto run options.
- * Mutates `options` in place. On affinity failure, clears auto slots (local) and
- * returns `skipped` — never throws; callers must not hard-exit.
+ * Mutates `options` in place. Placement failures propagate without rewriting
+ * `auto`, so callers fail loud instead of silently launching locally.
  */
 export async function applyDeviceAutoToOptions(options, deps = {}) {
     let deprecationSmart = false;
@@ -167,42 +203,27 @@ export async function applyDeviceAutoToOptions(options, deps = {}) {
     if (!hasAuto) {
         return { attempted: false, deprecationSmart };
     }
-    try {
-        const resolve = deps.resolve ?? (() => resolveDeviceAuto(deps.agent));
-        const plan = await resolve();
-        const concrete = plan.host; // null = local
-        for (const k of HOST_SLOTS) {
-            if (isDeviceAuto(options[k])) {
-                options[k] = concrete ?? undefined;
-            }
+    const resolve = deps.resolve ?? (() => resolveDeviceAuto(deps.agent));
+    const plan = await resolve();
+    const concrete = plan.host; // null = local
+    for (const k of HOST_SLOTS) {
+        if (isDeviceAuto(options[k])) {
+            options[k] = concrete ?? undefined;
         }
-        const accountPickerRequested = deps.accountPickerRequested ?? false;
-        if (!accountPickerRequested && !options.strategy && !options.balanced) {
-            options.balanced = true;
-        }
-        const hostLabel = concrete ?? 'local';
-        const deviceHint = plan.candidates
-            .slice(0, 4)
-            .map((c) => `${c.key}:${c.loadPercent === undefined ? '?' : `${Math.round(c.loadPercent)}%`}`)
-            .join(', ');
-        const acctNote = accountPickerRequested ? 'accounts=picker' : 'accounts=balanced';
-        return {
-            attempted: true,
-            deprecationSmart,
-            banner: { hostLabel, deviceHint, acctNote },
-        };
     }
-    catch (err) {
-        // Graceful degrade: clear auto slots so the run continues locally.
-        for (const k of HOST_SLOTS) {
-            if (isDeviceAuto(options[k])) {
-                options[k] = undefined;
-            }
-        }
-        return {
-            attempted: true,
-            deprecationSmart,
-            skipped: err.message,
-        };
+    const accountPickerRequested = deps.accountPickerRequested ?? false;
+    if (!accountPickerRequested && !options.strategy && !options.balanced) {
+        options.balanced = true;
     }
+    const hostLabel = concrete ?? 'local';
+    const deviceHint = plan.candidates
+        .slice(0, 4)
+        .map((c) => `${c.key}:${c.loadPercent === undefined ? '?' : `${Math.round(c.loadPercent)}%`}`)
+        .join(', ');
+    const acctNote = accountPickerRequested ? 'accounts=picker' : 'accounts=balanced';
+    return {
+        attempted: true,
+        deprecationSmart,
+        banner: { hostLabel, deviceHint, acctNote },
+    };
 }

package/dist/lib/ssh-exec.d.ts

@@ -2,7 +2,7 @@
  * Shared SSH exec primitive — the single hardened choke point for running a
  * command on a remote host over the system `ssh`.
  *
- * `agents hosts` dispatch and the browser driver both go through here so the
+ * `agents run --host` dispatch and the browser driver both go through here so the
  * connection hardening (`BatchMode`, `accept-new`, `ConnectTimeout`) and the
  * target-injection guard live in exactly one place. Target validation is the
  * canonical definition; `commands/secrets.ts` re-exports it.

package/dist/lib/ssh-exec.js

@@ -2,7 +2,7 @@
  * Shared SSH exec primitive — the single hardened choke point for running a
  * command on a remote host over the system `ssh`.
  *
- * `agents hosts` dispatch and the browser driver both go through here so the
+ * `agents run --host` dispatch and the browser driver both go through here so the
  * connection hardening (`BatchMode`, `accept-new`, `ConnectTimeout`) and the
  * target-injection guard live in exactly one place. Target validation is the
  * canonical definition; `commands/secrets.ts` re-exports it.

package/dist/lib/staleness/prune.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Manifest-bounded prune (RUSH-2438).
+ *
+ * `agents sync` was additive-only: it installed/updated resources present in
+ * source but never removed a resource that had been DELETED from source, so a
+ * removed command/skill/hook lingered in every installed version home forever
+ * (and stayed live in the `/` menu). Bare `agents sync <agent>` full syncs did
+ * sweep orphans, but the repo-scoped forms the reconcile path actually uses —
+ * `agents sync <agent>@all system`, `agents sync <agent> system --force` — pass
+ * a selection, which turned the orphan sweeps off. This closes that gap.
+ *
+ * The prune set is computed by name, bounded by the sync manifest:
+ *
+ *     prune = (names the last sync recorded as installed)
+ *           − (names still present in source across ALL layers)
+ *           ∩ (names currently materialized in the version home)
+ *
+ * Each clause is a safety guarantee:
+ *   - The manifest bound means only agents-installed resources are ever
+ *     candidates — a file the user hand-authored into the version home was
+ *     never recorded, so it is never touched.
+ *   - Diffing against ALL layers (not just the scoped one) means a resource
+ *     still provided by any other layer — e.g. a same-named user command that
+ *     shadows a removed system command — stays: it is still "in source".
+ *   - Requiring the name to be materialized skips work for anything already
+ *     gone and never errors on a missing path.
+ *
+ * When there is NO manifest we cannot know what a prior sync installed, so we
+ * FAIL LOUD by pruning nothing and reporting it — never a "delete everything
+ * not in source" guess. The manifest is written by the next full sync, so the
+ * baseline heals itself.
+ *
+ * Deletion itself is delegated to each writer's `remove()` (the inverse of
+ * `write()`), so per-harness layout knowledge — native file vs command-skill
+ * dir vs goose recipe — lives in one place and can't drift.
+ */
+import type { AgentId } from '../types.js';
+import type { SyncManifest } from './types.js';
+/**
+ * Kinds prune reconciles. Restricted to the name-keyed file/dir resources whose
+ * writer implements `remove()`. Deliberately excluded, each with a reason:
+ *   - hooks — a version-home hook script is coupled to a settings.json /
+ *     hooks.json REGISTRATION. Pruning the last hook to zero would delete the
+ *     script but must also GC its registration in the same pass, and that lands
+ *     in `src/lib/hooks.ts` — a Windows-portable-path surface the CI windows leg
+ *     gates on. Split to RUSH-2456 so this PR stays Linux-only-green; hook FILES
+ *     are still reconciled by the in-write orphan sweep (versions.ts, gated on
+ *     `hooksToSync > 0`).
+ *   - rules / permissions — synced as a wholesale rewrite (one composed file /
+ *     the full allowlist), so a removed rule or group already drops out.
+ *   - plugins — carry their own reconciliation via `cleanOrphanedPluginSkills`.
+ *   - mcp — registered through each agent's CLI/config, a separate removal path.
+ *   - subagents / workflows — no clean per-name inverse yet (multi-agent index
+ *     finalize; native workflow trees); tracked for a follow-up.
+ */
+export declare const PRUNABLE_KINDS: readonly ["commands", "skills"];
+export type PrunableKind = typeof PRUNABLE_KINDS[number];
+export interface PruneInput {
+    agent: AgentId;
+    version: string;
+    versionHome: string;
+    cwd: string;
+    /**
+     * The sync manifest loaded BEFORE this sync ran — the record of what the last
+     * sync installed. `null` means no prior full sync established a baseline.
+     */
+    previousManifest: SyncManifest | null;
+    /**
+     * Current source resource names across ALL layers (project/user/system/extras),
+     * per prunable kind. A name present here is still "in source" and never pruned.
+     */
+    sourceNames: Record<PrunableKind, ReadonlyArray<string>>;
+}
+export interface PruneOutcome {
+    /** Names actually removed from the version home, per kind. */
+    pruned: Record<PrunableKind, string[]>;
+    /**
+     * True when prune ran with no manifest and therefore deleted nothing — the
+     * fail-loud baseline case. Callers surface this so a skipped reconcile is
+     * never mistaken for "nothing to prune".
+     */
+    skippedNoManifest: boolean;
+}
+/**
+ * Remove resources that a prior sync installed and that are now gone from
+ * source, from one agent@version home. Deletes nothing when no manifest exists.
+ */
+export declare function pruneRemovedResources(input: PruneInput): PruneOutcome;