@phnx-labs/agents-cli 1.20.55 → 1.20.56

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 1.20.56
+
+- **Fix native routine schedulers rejecting the published CLI as a Bun virtual path.** Bun's standalone runtime reports the embedded `/$bunfs/root/agents` entry as existing at `process.argv[1]`, while the real physical executable lives at `process.execPath`. Daemon resolution now substitutes that physical executable before generating launchd/systemd manifests or detached launches; the existing virtual-path guard still rejects any virtual path that reaches supervision. Source: `apps/cli/src/lib/daemon.ts`.
+
+- **Fix: `agents teams`, `agents message`, and `agents profiles check` work again on the signed standalone binary (regression from #315).** When `agents` resolves to the bun-compiled Mach-O (shipped since 1.20.53), three self-spawn sites relaunched the CLI as `[process.execPath, process.argv[1], …]` — but under a bun standalone executable `process.argv[1]` is the virtual entry `/$bunfs/root/agents`, so the child died with `unknown command '/$bunfs/root/agents'` (or `/bin/sh: /$bunfs/root/agents: No such file or directory`). Every teammate spawned by a compiled-binary install failed in 0s. New shared `getAgentsInvocation(subArgs)` (`apps/cli/src/lib/daemon.ts`) resolves the real on-disk binary — mapping the `/$bunfs/root/…` virtual path to `process.execPath`, running a `.js` entry under node, and a native binary directly — and `teams/agents.ts`, `commands/message.ts`, and `commands/profiles.ts` route through it. Verified end-to-end: a teammate spawned by the freshly-compiled binary runs to `completed` with no `$bunfs` error. Source: `apps/cli/src/lib/daemon.ts` (`getAgentsInvocation`), `apps/cli/src/lib/teams/agents.ts`, `apps/cli/src/commands/{message,profiles}.ts`.
 ## 1.20.55
 
 - **Routine scheduler health is now observable and self-healing.** `agents routines status` distinguishes `running`, `wedged`, and `stopped`, and reports the daemon binary plus heartbeat age. Routine listing/status opportunistically finalize orphaned runs; PID reuse checks and a 24-hour wall-clock limit prevent stale `running` records; daemon startup rejects bun virtual paths and warns about worktree binaries that can disappear. Source: `apps/cli/src/lib/daemon.ts`, `apps/cli/src/lib/runner.ts`, `apps/cli/src/commands/routines.ts`.
@@ -10,7 +15,7 @@
 - **`agents devices sync` pins the login user on Windows too.** `os.userInfo().username` returns `COMPUTER\user` / `DOMAIN\user` on Windows, which failed the safe-charset guard, so Windows boxes synced with no pinned user and `--host <device>` fell back to the wrong local account. `sanitizeLoginUser` now strips the domain prefix to the bare ssh account before the guard. Also folds the duplicate `user@host` splitter (`parseTarget` in `ssh.ts`) into the canonical `splitUserHost` so there is one parser. Source: `apps/cli/src/lib/devices/sync.ts`, `apps/cli/src/commands/ssh.ts`.
 - **Menu bar ACTIVE section now shows every local session, not just extension-registered terminals.** The dropdown's session source was `live-terminals.json`, which only carries terminals the Factory extension registers — a machine with 25 live sessions (tmux, ghostty, headless) rendered `ACTIVE · 1 running`. The helper now feeds triage + ACTIVE from `agents sessions --active --local --json` (the session engine's authoritative view, issue #741 contract) on the same warm-cache pattern as routines (30s TTL, refreshed off the click path; the cheap file still covers cold start and the 10s badge poll). Blocked sessions outside the extension's view now surface in NEEDS YOU too. Idle rows cap at 3 per repo group — the group header carries the true counts — so a big idle fleet can't wall the menu. Source: `apps/cli/menubar/Sources/MenubarHelper/{StatusItemController,LocalState,AgentsCLI,Models}.swift`.
 - **Daemon service manifests pin JavaScript installs to the current Node runtime.** launchd and systemd now invoke `process.execPath <entry> daemon _run`, matching the detached launcher, instead of executing the JS entrypoint through `#!/usr/bin/env node`. Linux user services therefore stop falling back to an obsolete system Node (observed as Node 18 failing on `node:util.styleText`) when the CLI was installed under Node 22/24. Native `agents` launchers remain direct executables. Source: `apps/cli/src/lib/daemon.ts`.
-- **Routines can be pinned to one machine with `device:` / `--device`.** Routine YAMLs sync fleet-wide via the user repo, so an enabled routine previously fired on every device running the scheduler. A `device: <name>` pin (matched against the local `machineId()`, normalized like `agents devices` names) makes the job inert everywhere else: the cron scheduler skips it, webhook triggers don't match it, overdue detection/`catchup`/daemon nags ignore it, and `routines run` refuses with an `agents ssh <device>` pointer. `routines list` grows a Device column and `--json` gains `device` + `runsHere`. Source: `apps/cli/src/lib/routines.ts`, `apps/cli/src/lib/scheduler.ts`, `apps/cli/src/lib/overdue.ts`, `apps/cli/src/lib/triggers/webhook.ts`, `apps/cli/src/commands/routines.ts`.
+- **Routines support a `devices:` allowlist so multiple machines each fire the same job independently.** Routine YAMLs sync fleet-wide via the user repo, so without a restriction an enabled routine fires on every device running the scheduler. A `devices: [yosemite-s0, mac-mini]` allowlist makes each listed machine run the job independently on schedule; omitting the field (or `--clear`) leaves the job unrestricted. A single-entry list `devices: [yosemite-s0]` replaces the legacy singular `device:` pin — v12 migration converts any existing `device: X` YAML automatically to `devices: [X]`. All automatic paths (cron scheduler, webhook triggers, overdue/`catchup`, daemon nags, detached runner fires, one-shot `--at`) skip devices outside the allowlist; attempting to run a job on an ineligible host errors with the allowed device names and a ready-to-paste `--host` hint. `routines add --devices yosemite-s0,mac-mini` sets the list at creation (validated against the registered fleet); `routines devices <name>` opens a preselected multi-select picker; `--set <csv>` and `--clear` update it non-interactively and are mutually exclusive. `routines list` gains a Devices column; `--json` gains `devices` array and `runsHere`. `--host <device>` (alias: `--device`) routes any `routines` subcommand to a remote machine over SSH. Source: `apps/cli/src/lib/routines.ts`, `apps/cli/src/lib/scheduler.ts`, `apps/cli/src/lib/overdue.ts`, `apps/cli/src/lib/triggers/webhook.ts`, `apps/cli/src/lib/runner.ts`, `apps/cli/src/lib/hosts/passthrough.ts`, `apps/cli/src/lib/migrate.ts`, `apps/cli/src/commands/routines.ts`.
 - **Routines now default to `--mode auto` instead of `plan` (RUSH-1595).** A routine created without an explicit `mode` now runs under the smart classifier (`auto`) rather than read-only `plan`, so unattended jobs can create PRs, write files, and run tests end-to-end without every user opting in — `auto` maps to `--permission-mode auto` (claude), workspace-write + network (codex), `--auto high` (droid), and kimi's default headless run (which had no read-only mode and previously errored at `plan`). Opt down to `mode: plan` for read-only monitoring/reporting. `JOB_DEFAULTS.mode`, the `agents routines add --mode` flag default, and the file-add default all move to `auto`; `writeJob` now omits `mode` when it equals `auto`. Source: `apps/cli/src/lib/routines.ts`, `apps/cli/src/commands/routines.ts`.
 - **`agents publish` — a self-hosted, zero-infrastructure skill registry that round-trips with `agents search`/`agents install`.** Publish walks a git repo's `skills/` directory, records a sha256 of every `SKILL.md`, and writes a flat `skills-index.json` (`SkillIndexDocument` shape) at the repo root, then commits + pushes it and prints the `raw.githubusercontent.com` URL plus the exact `agents registry add skill <name> <url>` command to share. No hosted aggregator: the index is just a file in your GitHub repo, consumed directly by the existing `fetchSkillIndex`/`searchSkillRegistries` path. Targets your `~/.agents` repo by default or an extra repo via `--repo <alias>` (`--dry-run` previews without pushing). Each index entry carries `sha256`, threaded through `SkillEntry`/`normalizeSkillEntry`, and `agents install` now verifies the freshly cloned `SKILL.md` against it — a mismatch aborts with a clear error rather than trusting a tampered artifact. This is the self-hosted/git-index slice of #336; global no-URL discovery (a hosted aggregator) remains future work. Source: `apps/cli/src/commands/packages.ts` (`publish` subcommand + install-time verify), `apps/cli/src/lib/registry.ts` (`buildSkillIndex`, `verifySkillIntegrity`, `sha256OfFile`, `parseOwnerRepoFromRemote`, `SkillIndexEntry.sha256`), `apps/cli/src/lib/types.ts` (`SkillEntry.sha256`). (#336)
 

package/README.md

@@ -643,9 +643,12 @@ agents routines list                   # All jobs + next run times
 agents routines run daily-digest       # Test it now, ignore the schedule
 agents routines logs daily-digest      # Last execution — status + report (add --full for raw stdout)
 
-# Routines sync to every device; pin one to a single machine with --device
+# Routines sync to every device; restrict to an allowlist with --devices
 agents routines add nightly-drain --schedule "0 3 * * *" --agent claude \
-  --device yosemite-s0 --prompt "Drain the work queue"
+  --devices yosemite-s0,mac-mini --prompt "Drain the local work queue"
+
+agents routines devices nightly-drain --set yosemite-s0,mac-mini  # update allowlist
+agents routines list --host yosemite-s0                            # query another device
 ```
 
 Jobs run sandboxed -- agents only see directories and tools you explicitly allow.

package/dist/commands/message.js

@@ -5,6 +5,7 @@ import { getActiveSessions } from '../lib/session/active.js';
 import { getTaskById, updateTaskStatus } from '../lib/cloud/store.js';
 import { resolveProvider } from '../lib/cloud/registry.js';
 import { mailboxDir, enqueue } from '../lib/mailbox.js';
+import { getAgentsInvocation } from '../lib/daemon.js';
 import { resolveMessageTarget, mailboxIdForActiveSession } from '../lib/mailbox-target.js';
 import { blockIdForSession, listBlocks, readBlock, recordAnswer, recordMessageReceipt, } from '../lib/feed.js';
 import { verifyOperatorIdentity } from '../lib/operator.js';
@@ -89,11 +90,12 @@ async function deliverViaResume(route, mailboxId) {
         die(`Internal error: resume route incomplete for ${mailboxId}.`);
     }
     const argv = resumeArgv(route);
-    // Spawn the same agents binary the user invoked (process.argv[1]) so version
-    // pins and wrappers stay consistent. Detach so the resume can take over a TTY
-    // when interactive; for feed answers we pass the prompt non-interactively.
-    const bin = process.argv[1] ?? 'agents';
-    const child = spawn(process.execPath, [bin, ...argv], {
+    // Relaunch the same agents CLI (via getAgentsInvocation, which resolves the
+    // real binary — not a bun /$bunfs virtual path under the compiled build) so
+    // version pins and wrappers stay consistent. Detach so the resume can take
+    // over a TTY when interactive; for feed answers we pass it non-interactively.
+    const inv = getAgentsInvocation(argv);
+    const child = spawn(inv.command, inv.args, {
         stdio: 'inherit',
         env: process.env,
     });

package/dist/commands/profiles.js

@@ -13,6 +13,7 @@ import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists,
 import { getPreset, listPresets, expandPreset } from '../lib/profiles-presets.js';
 import { hasKeychainToken, keychainItemName, setKeychainToken, deleteKeychainToken, } from '../lib/secrets/profiles.js';
 import { isInteractiveTerminal } from './utils.js';
+import { getAgentsInvocation } from '../lib/daemon.js';
 /**
  * Pure helper: builds a Profile from collected wizard inputs. Extracted so the
  * shape of preset->profile mapping for the `create` wizard is unit-testable
@@ -280,15 +281,15 @@ Examples:
             const run = await confirm({ message: 'Run smoke test now?', default: true });
             if (run) {
                 console.log(chalk.gray(`Spawning: agents run ${name} "say alive in one word" (60s timeout)`));
-                const child = spawn(process.argv[0], [
-                    process.argv[1],
+                const inv = getAgentsInvocation([
                     'run',
                     name,
                     'say alive in one word',
                     '--headless',
                     '--timeout',
                     '60s',
-                ], { stdio: 'inherit' });
+                ]);
+                const child = spawn(inv.command, inv.args, { stdio: 'inherit' });
                 child.on('exit', (code) => process.exit(code ?? 0));
             }
             else {

package/dist/commands/routines.js

@@ -12,7 +12,7 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, } from '../lib/daemon.js';
 import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
-import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, jobRunsOnThisDevice, } from '../lib/routines.js';
+import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, jobRunsOnThisDevice, checkJobDeviceEligibility, } from '../lib/routines.js';
 import { fireWebhookJobs, matchJobsToWebhook } from '../lib/triggers/webhook.js';
 import { getRoutinesDir } from '../lib/state.js';
 import { IS_WINDOWS } from '../lib/platform/index.js';
@@ -22,6 +22,9 @@ import { JobScheduler } from '../lib/scheduler.js';
 import { detectOverdueJobs } from '../lib/overdue.js';
 import { isInteractiveTerminal, requireInteractiveSelection } from './utils.js';
 import { setHelpSections } from '../lib/help.js';
+import { loadDevices } from '../lib/devices/registry.js';
+import { normalizeHost } from '../lib/machine-id.js';
+import { addHostOption } from '../lib/hosts/option.js';
 /**
  * Human-friendly wall-clock a run took (e.g. "  · 3 min", "  · 45 sec"), or ""
  * when it hasn't completed or timestamps are unparseable. Leading separator lets
@@ -122,11 +125,34 @@ async function pickJob(message, filter, alternatives = [], cwd) {
         throw err;
     }
 }
+/**
+ * Parse a comma-separated devices string, normalize, deduplicate, and validate
+ * each entry against the registered fleet. Exits nonzero on empty/whitespace
+ * input or unknown devices.
+ */
+async function parseAndValidateDevices(raw) {
+    const names = [...new Set(raw.split(',').map((s) => s.trim()).filter(Boolean).map((s) => normalizeHost(s)))];
+    if (names.length === 0) {
+        console.log(chalk.red('--devices requires at least one non-empty device name'));
+        process.exit(1);
+    }
+    const registry = await loadDevices();
+    const registered = new Set(Object.keys(registry).map((k) => normalizeHost(k)));
+    const unknown = names.filter((n) => !registered.has(n));
+    if (unknown.length > 0) {
+        console.log(chalk.red(`Unknown device(s): ${unknown.join(', ')}`));
+        console.log(chalk.gray(`Registered: ${[...registered].sort().join(', ') || '(none)'}`));
+        console.log(chalk.gray('Enroll devices with: agents devices sync'));
+        process.exit(1);
+    }
+    return names;
+}
 /** Register the `agents routines` command tree. */
 export function registerRoutinesCommands(program) {
     const routinesCmd = program
         .command('routines')
         .description('Schedule agents to run on a cron schedule or at a specific time. The scheduler auto-starts on first add.');
+    addHostOption(routinesCmd);
     setHelpSections(routinesCmd, {
         examples: `
       # Cron routine: Claude every weekday at 9 AM (scheduler auto-starts)
@@ -141,6 +167,15 @@ export function registerRoutinesCommands(program) {
       # List all routines and their next run times
       agents routines list
 
+      # List routines on a specific device
+      agents routines list --host yosemite-s0
+
+      # Create a routine restricted to specific devices
+      agents routines add nightly --schedule "0 2 * * *" --agent claude --prompt "Summarize today's commits" --devices yosemite-s0,mac-mini
+
+      # Interactively manage which devices may run a routine
+      agents routines devices nightly
+
       # Run a routine right now in the foreground (ignores schedule)
       agents routines run daily-standup
 
@@ -216,7 +251,7 @@ export function registerRoutinesCommands(program) {
                     scheduleHuman: fireConditionLabel(job),
                     trigger: job.trigger ?? null,
                     timezone: job.timezone ?? null,
-                    device: job.device ?? null,
+                    devices: job.devices ?? [],
                     runsHere: jobRunsOnThisDevice(job),
                     enabled: job.enabled,
                     overdue: overdueSet.has(job.name),
@@ -240,11 +275,11 @@ export function registerRoutinesCommands(program) {
         const NAME_W = 24;
         const AGENT_W = 10;
         const REPO_W = REPO_DISPLAY_MAX;
-        const DEVICE_W = 13;
+        const DEVICE_W = 22;
         const SCHED_W = 22;
         const ENABLED_W = 10;
         const NEXT_W = 22;
-        const header = `  ${'Name'.padEnd(NAME_W)} ${'Agent'.padEnd(AGENT_W)} ${'Repo'.padEnd(REPO_W)} ${'Device'.padEnd(DEVICE_W)} ${'Schedule'.padEnd(SCHED_W)} ${'Enabled'.padEnd(ENABLED_W)} ${'Next Run'.padEnd(NEXT_W)} Last Status`;
+        const header = `  ${'Name'.padEnd(NAME_W)} ${'Agent'.padEnd(AGENT_W)} ${'Repo'.padEnd(REPO_W)} ${'Devices'.padEnd(DEVICE_W)} ${'Schedule'.padEnd(SCHED_W)} ${'Enabled'.padEnd(ENABLED_W)} ${'Next Run'.padEnd(NEXT_W)} Last Status`;
         console.log(chalk.gray(header));
         console.log(chalk.gray('  ' + '-'.repeat(NAME_W + AGENT_W + REPO_W + DEVICE_W + SCHED_W + ENABLED_W + NEXT_W + 20)));
         for (const job of jobs) {
@@ -268,11 +303,14 @@ export function registerRoutinesCommands(program) {
             // chalk adds escape codes; pad the raw word and let chalk wrap it.
             const enabledWord = job.enabled ? 'yes' : 'no';
             const enabledPad = Math.max(0, ENABLED_W - enabledWord.length);
-            // Unpinned jobs run everywhere; a pin that names another machine is
-            // grayed — this machine never fires it.
-            const deviceWord = job.device || '-';
-            const deviceCell = !job.device
-                ? chalk.gray('-')
+            const deviceFull = job.devices?.join(',') ?? '';
+            const deviceWord = deviceFull.length === 0
+                ? 'all'
+                : deviceFull.length > DEVICE_W
+                    ? deviceFull.slice(0, DEVICE_W - 1) + '…'
+                    : deviceFull;
+            const deviceCell = deviceFull.length === 0
+                ? chalk.gray('all')
                 : jobRunsOnThisDevice(job)
                     ? deviceWord
                     : chalk.gray(deviceWord);
@@ -305,7 +343,7 @@ export function registerRoutinesCommands(program) {
         .option('-e, --effort <effort>', 'Reasoning effort: low | medium | high | xhigh | max | auto', 'auto')
         .option('-t, --timeout <timeout>', 'Kill the agent if it runs longer than this (e.g., 10m, 2h, 3d, 1w; max 1w)', '10m')
         .option('--timezone <tz>', 'Interpret schedule in this timezone (e.g., America/Los_Angeles)')
-        .option('--device <name>', 'Pin to one machine (routines are fleet-synced): only the device with this name schedules and fires the job')
+        .option('--devices <names>', 'Fleet allowlist (comma-separated): only listed devices schedule and fire this routine. Omit for unrestricted.')
         .option('--at <time>', 'One-shot mode: run once at this time (e.g., "14:30" or "2026-02-24 09:00"), then disable')
         .option('--end-at <iso>', 'Stop firing on or after this ISO 8601 timestamp (e.g., "2026-12-31T23:59:00Z"); routine auto-disables.')
         .option('--disabled', 'Create the routine but keep it paused (enable later with resume)')
@@ -349,6 +387,11 @@ export function registerRoutinesCommands(program) {
                 console.log(chalk.red('Prompt is required (use --prompt)'));
                 process.exit(1);
             }
+            // Parse and validate --devices against the fleet registry.
+            let devices;
+            if (options.devices !== undefined) {
+                devices = await parseAndValidateDevices(options.devices);
+            }
             const config = {
                 name: nameOrPath,
                 schedule,
@@ -360,7 +403,7 @@ export function registerRoutinesCommands(program) {
                 enabled: !options.disabled,
                 prompt: options.prompt,
                 timezone: options.timezone,
-                ...(options.device ? { device: options.device } : {}),
+                ...(devices ? { devices } : {}),
                 ...(runOnce ? { runOnce: true } : {}),
                 ...(options.endAt ? { endAt: options.endAt } : {}),
             };
@@ -562,9 +605,10 @@ export function registerRoutinesCommands(program) {
             console.log(chalk.red(`Job '${name}' not found`));
             process.exit(1);
         }
-        if (!jobRunsOnThisDevice(job)) {
-            console.log(chalk.red(`Job '${name}' is pinned to device '${job.device}' and never runs here.`));
-            console.log(chalk.gray(`  Run it there: agents ssh ${job.device} 'agents routines run ${name}'`));
+        const eligibility = checkJobDeviceEligibility(job);
+        if (eligibility) {
+            console.log(chalk.red(eligibility.message));
+            console.log(chalk.gray(`  ${eligibility.suggestion}`));
             process.exit(1);
         }
         const runLabel = job.workflow ? `workflow: ${job.workflow}` : `agent: ${job.agent}`;
@@ -852,6 +896,87 @@ export function registerRoutinesCommands(program) {
             process.exit(1);
         }
     });
+    // Fleet allowlist management for a single routine.
+    routinesCmd
+        .command('devices [name]')
+        .description('View or change which devices may run a routine. Without flags, opens an interactive picker (requires a TTY).')
+        .option('--set <devices>', 'Replace the allowlist with this comma-separated list (strict fleet validation)')
+        .option('--clear', 'Remove the allowlist so the routine runs on every device')
+        .action(async (name, options) => {
+        const hasSet = options.set !== undefined;
+        if (hasSet && options.clear) {
+            console.log(chalk.red('--set and --clear are mutually exclusive'));
+            process.exit(1);
+        }
+        if (!name) {
+            name = await pickJob('Select routine', undefined, ['agents routines devices <name>']) ?? undefined;
+            if (!name)
+                return;
+        }
+        const job = readJob(name);
+        if (!job) {
+            console.log(chalk.red(`Job '${name}' not found`));
+            process.exit(1);
+        }
+        if (options.clear) {
+            job.devices = undefined;
+            writeJob(job);
+            console.log(chalk.green(`Devices cleared for '${name}' — runs on all devices`));
+            if (isDaemonRunning())
+                signalDaemonReload();
+            return;
+        }
+        if (hasSet) {
+            const devices = await parseAndValidateDevices(options.set);
+            job.devices = devices;
+            writeJob(job);
+            console.log(chalk.green(`Devices for '${name}' set to: ${devices.join(', ')}`));
+            if (isDaemonRunning())
+                signalDaemonReload();
+            return;
+        }
+        // Interactive picker
+        if (!isInteractiveTerminal()) {
+            requireInteractiveSelection('device allowlist', ['agents routines devices <name> --set a,b', 'agents routines devices <name> --clear']);
+        }
+        const registry = await loadDevices();
+        const registeredNames = Object.keys(registry).map((k) => normalizeHost(k)).sort();
+        if (registeredNames.length === 0) {
+            console.log(chalk.yellow('No devices registered. Enroll with: agents devices sync'));
+            return;
+        }
+        const currentSet = new Set((job.devices ?? []).map((d) => normalizeHost(d)));
+        try {
+            const { checkbox } = await import('@inquirer/prompts');
+            const selected = await checkbox({
+                message: `Devices allowed to run '${name}' (space to toggle, enter to confirm, empty = unrestricted):`,
+                choices: registeredNames.map((d) => ({
+                    value: d,
+                    name: d,
+                    checked: currentSet.has(d),
+                })),
+            });
+            if (selected.length === 0) {
+                job.devices = undefined;
+                writeJob(job);
+                console.log(chalk.green(`Devices cleared for '${name}' — runs on all devices`));
+            }
+            else {
+                job.devices = selected;
+                writeJob(job);
+                console.log(chalk.green(`Devices for '${name}' set to: ${selected.join(', ')}`));
+            }
+            if (isDaemonRunning())
+                signalDaemonReload();
+        }
+        catch (err) {
+            if (isPromptCancelled(err)) {
+                console.log(chalk.gray('Cancelled'));
+                return;
+            }
+            throw err;
+        }
+    });
     // Scheduler lifecycle — usually auto-managed by `routines add`, exposed here for manual control.
     routinesCmd
         .command('start')
@@ -950,4 +1075,9 @@ export function registerRoutinesCommands(program) {
             console.log(chalk.gray('No scheduler logs'));
         }
     });
+    // Every direct routines subcommand accepts the shared --host family so remote
+    // fall-through works and each subcommand's --help documents the flags.
+    for (const sub of routinesCmd.commands) {
+        addHostOption(sub);
+    }
 }

package/dist/index.js

@@ -874,7 +874,7 @@ if (process.env.AGENTS_SKIP_MIGRATION !== '1') {
         // Bumping the suffix re-runs migrations for every user; binary releases that
         // don't change the schema must NOT re-run (they would destroy user content
         // when migration steps overlap with user-authored paths). See issue #20.
-        const sentinelValue = 'v11';
+        const sentinelValue = 'v12';
         let needRun = true;
         try {
             if (fs.existsSync(sentinel) && fs.readFileSync(sentinel, 'utf-8').trim() === sentinelValue) {

package/dist/lib/daemon.d.ts

@@ -85,7 +85,7 @@ export declare function writeOwnerOnlyServiceManifest(filePath: string, content:
 export declare function generateLaunchdPlist(oauthToken?: string | null): string;
 /** Generate a Linux systemd user unit for auto-starting the daemon. */
 export declare function generateSystemdUnit(oauthToken?: string | null): string;
-export declare function getAgentsBinPath(): string;
+export declare function getAgentsBinPath(argv1?: string | undefined, execPath?: string): string;
 /** Start the daemon via launchd, systemd, or as a detached process. */
 export declare function startDaemon(): {
     pid: number | null;
@@ -136,6 +136,24 @@ export declare function getDaemonLaunch(agentsBin?: string): {
     command: string;
     args: string[];
 };
+/**
+ * Build the argv to relaunch the `agents` CLI with the given subcommand args.
+ *
+ * Resolves the real on-disk binary via getAgentsBinPath(), then dispatches: a
+ * `.js` entry runs under node (`node <entry> …`), a native/compiled binary runs
+ * directly (`<bin> …`).
+ *
+ * Callers MUST route self-spawns through this rather than hand-rolling
+ * `[process.execPath, process.argv[1], …]`: under the compiled standalone binary
+ * (#315) `process.argv[1]` is the bun virtual entry `/$bunfs/root/agents`, so the
+ * hand-rolled form becomes `agents /$bunfs/root/agents …` → the CLI receives the
+ * bunfs path as a subcommand and dies with "unknown command '/$bunfs/root/agents'".
+ * getAgentsBinPath() resolves that virtual entry to the physical process.execPath.
+ */
+export declare function getAgentsInvocation(subArgs: string[], agentsBin?: string): {
+    command: string;
+    args: string[];
+};
 export declare function validateDaemonBinary(binPath: string): {
     warnings: string[];
 };

package/dist/lib/daemon.js

@@ -712,28 +712,39 @@ Environment=PATH=/usr/local/bin:/usr/bin:/bin:${os.homedir()}/.nvm/versions/node
 [Install]
 WantedBy=default.target`;
 }
-export function getAgentsBinPath() {
+const BUN_VIRTUAL_ROOT = /[/\\]\$bunfs[/\\]root[/\\]/;
+function resolveBunStandaloneEntry(entry, execPath) {
+    if (!BUN_VIRTUAL_ROOT.test(entry))
+        return entry;
+    if (!execPath || BUN_VIRTUAL_ROOT.test(execPath) || !fs.existsSync(execPath)) {
+        throw new Error(`Cannot resolve agents CLI: Bun standalone executable not found at ${execPath || '(empty path)'}`);
+    }
+    return execPath;
+}
+export function getAgentsBinPath(argv1 = process.argv[1], execPath = process.execPath) {
     // Prefer the binary actively executing this code. `which agents` returns
     // whatever happens to be first on PATH, which means a side-by-side dev
     // build at ~/.local/bin would silently spawn the registry-installed
-    // daemon and run stale code. process.argv[1] is the absolute path of
-    // the JS entrypoint the user actually invoked.
-    const argv1 = process.argv[1];
-    if (argv1 && fs.existsSync(argv1)) {
+    // daemon and run stale code. For a JS install, process.argv[1] is the
+    // absolute entrypoint the user actually invoked. A Bun standalone instead
+    // exposes its embedded /$bunfs/root entry at argv[1] and its physical signed
+    // executable at process.execPath; Bun reports both as existing paths.
+    const runningEntry = argv1 ? resolveBunStandaloneEntry(argv1, execPath) : undefined;
+    if (runningEntry && fs.existsSync(runningEntry)) {
         // The package's browser/computer entrypoints are sibling shims without a
         // `daemon` command. A daemon started as their IPC side effect must launch
         // through the main agents entrypoint instead of replaying the shim path.
-        const entryName = path.basename(argv1);
+        const entryName = path.basename(runningEntry);
         const compiledShim = /^(browser|computer)\.(c|m)?js$/.test(entryName);
         const installedShim = /^(browser|computer)$/.test(entryName);
         if (compiledShim || installedShim) {
-            const agentsEntry = path.join(path.dirname(argv1), compiledShim ? 'index.js' : 'agents');
+            const agentsEntry = path.join(path.dirname(runningEntry), compiledShim ? 'index.js' : 'agents');
             if (!fs.existsSync(agentsEntry)) {
                 throw new Error(`Cannot start agents daemon: main CLI entry not found at ${agentsEntry}`);
             }
             return agentsEntry;
         }
-        return argv1;
+        return runningEntry;
     }
     try {
         return execFileSync('which', ['agents'], { encoding: 'utf-8' }).trim();
@@ -903,9 +914,30 @@ export function getDaemonLaunch(agentsBin = getAgentsBinPath()) {
     }
     return { command: agentsBin, args: ['daemon', '_run'] };
 }
+/**
+ * Build the argv to relaunch the `agents` CLI with the given subcommand args.
+ *
+ * Resolves the real on-disk binary via getAgentsBinPath(), then dispatches: a
+ * `.js` entry runs under node (`node <entry> …`), a native/compiled binary runs
+ * directly (`<bin> …`).
+ *
+ * Callers MUST route self-spawns through this rather than hand-rolling
+ * `[process.execPath, process.argv[1], …]`: under the compiled standalone binary
+ * (#315) `process.argv[1]` is the bun virtual entry `/$bunfs/root/agents`, so the
+ * hand-rolled form becomes `agents /$bunfs/root/agents …` → the CLI receives the
+ * bunfs path as a subcommand and dies with "unknown command '/$bunfs/root/agents'".
+ * getAgentsBinPath() resolves that virtual entry to the physical process.execPath.
+ */
+export function getAgentsInvocation(subArgs, agentsBin = getAgentsBinPath()) {
+    const resolvedBin = resolveBunStandaloneEntry(agentsBin, process.execPath);
+    if (/\.(c|m)?js$/.test(resolvedBin)) {
+        return { command: process.execPath, args: [resolvedBin, ...subArgs] };
+    }
+    return { command: resolvedBin, args: subArgs };
+}
 export function validateDaemonBinary(binPath) {
     const warnings = [];
-    if (/\/\$bunfs\/root\//.test(binPath)) {
+    if (BUN_VIRTUAL_ROOT.test(binPath)) {
         throw new Error(`Refusing to supervise daemon: resolved binary is a bun virtual path (${binPath}). ` +
             `Install agents globally (npm i -g @phnx-labs/agents-cli) and restart.`);
     }

package/dist/lib/hosts/passthrough.js

@@ -34,6 +34,7 @@ const REMOTE_PASSTHROUGH = {
     sync: { nonInteractive: ['--yes'] },
     teams: {},
     message: {},
+    routines: {},
 };
 /** `--no-tty` is stripped like the routing flags but carries no value. */
 const STRIP_SPECS = [...HOST_ROUTING_SPECS, { long: 'no-tty', takesValue: false }];
@@ -115,10 +116,13 @@ export async function maybeRunOnHost(command, allArgs) {
         process.exitCode = 1;
         return true;
     }
-    // `--devices` / `--hosts` fan out to every registered device locally; don't
-    // let a per-host passthrough turn it into a cascading remote fan-out.
-    const fleetFlag = allArgs.includes('--devices') || allArgs.includes('--hosts');
-    if (fleetFlag)
+    // `--hosts` is always a generic fleet flag — bail for every command so the
+    // local aggregator handles it. `--devices` is fan-out on most commands but
+    // a placement flag on `routines` (which devices may run the routine), so
+    // only exempt routines from the bail.
+    if (allArgs.includes('--hosts'))
+        return false;
+    if (allArgs.includes('--devices') && command !== 'routines')
         return false;
     const hostName = hostFlag ?? deviceFlag;
     if (!hostName)

package/dist/lib/migrate.d.ts

@@ -96,5 +96,14 @@ export declare function repairSelfReferentialBinShims(versionsRoot?: string, shi
  * the new name.
  */
 export declare function migrateExtrasExtrasToAgentsExtras(historyDir?: string): void;
+/**
+ * Rewrite every routine YAML that carries the legacy singular `device: <value>`
+ * field to the new plural `devices: [<value>]` format. Preserves all other
+ * fields. Idempotent: a routine that already has `devices:` (or neither field)
+ * is left untouched.
+ *
+ * Params default to the real routines dir; injectable for tests.
+ */
+export declare function migrateRoutineDeviceToDevices(routinesDir?: string): void;
 /** Run all idempotent migrations. Safe to call multiple times. */
 export declare function runMigration(): Promise<void>;

package/dist/lib/migrate.js

@@ -1885,6 +1885,52 @@ export function migrateExtrasExtrasToAgentsExtras(historyDir = HISTORY_DIR) {
         console.error(`Renamed extras-extras → agents-extras (dirs: ${renamedDirs}, known_marketplaces: ${rewroteKnown}, settings: ${rewroteSettings})`);
     }
 }
+/**
+ * Rewrite every routine YAML that carries the legacy singular `device: <value>`
+ * field to the new plural `devices: [<value>]` format. Preserves all other
+ * fields. Idempotent: a routine that already has `devices:` (or neither field)
+ * is left untouched.
+ *
+ * Params default to the real routines dir; injectable for tests.
+ */
+export function migrateRoutineDeviceToDevices(routinesDir) {
+    const dir = routinesDir ?? path.join(USER_DIR, 'routines');
+    if (!fs.existsSync(dir))
+        return;
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+    let migrated = 0;
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        let doc;
+        try {
+            doc = yaml.parse(raw);
+            if (!doc || typeof doc !== 'object')
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (!('device' in doc))
+            continue;
+        if ('devices' in doc) {
+            delete doc.device;
+            atomicWriteFileSync(filePath, yaml.stringify(doc));
+            continue;
+        }
+        const val = doc.device;
+        if (typeof val !== 'string' || !val.trim()) {
+            throw new Error(`${file}: legacy 'device' field is not a valid device name — repair the file and retry`);
+        }
+        delete doc.device;
+        doc.devices = [val.trim()];
+        atomicWriteFileSync(filePath, yaml.stringify(doc));
+        migrated++;
+    }
+    if (migrated > 0) {
+        console.error(`Migrated ${migrated} routine${migrated === 1 ? '' : 's'}: device → devices`);
+    }
+}
 /** Run all idempotent migrations. Safe to call multiple times. */
 export async function runMigration() {
     // MUST run first: every other migrator reads SYSTEM_DIR (the new path).
@@ -1937,6 +1983,8 @@ export async function runMigration() {
     // installed version-home. Runs after migrateRuntimeToHistory so the version
     // homes are at their canonical HISTORY_DIR location.
     migrateExtrasExtrasToAgentsExtras();
+    // Rewrite routine YAML files: singular `device:` -> plural `devices: []`.
+    migrateRoutineDeviceToDevices();
     // Symlink repair runs LAST so it can find the post-move version homes.
     repairAgentConfigSymlinks();
     // Repair self-referential node_modules/.bin/<cli> symlinks (the droid

package/dist/lib/routines.d.ts

@@ -61,14 +61,13 @@ export interface JobConfig {
     timezone?: string;
     repo?: string;
     /**
-     * Pin this routine to one machine. `~/.agents/routines/` is synced to every
-     * device via the user repo, so without a pin an enabled routine fires on
-     * EVERY machine running the scheduler. When set, only the device whose
-     * `machineId()` matches (normalized hostname, e.g. `yosemite-s0`) schedules,
-     * fires, catches up, or counts this job as overdue; everywhere else it is
-     * inert and `run` refuses with an `agents ssh` pointer.
+     * Fleet allowlist — restrict this routine to specific devices. When omitted
+     * or empty, the routine is unrestricted and fires on every device running the
+     * scheduler. When set, only devices whose `machineId()` matches any entry
+     * (via `normalizeHost`) schedule, fire, catch up, or count this job as
+     * overdue; everywhere else it is inert and `run` refuses with a pointer.
      */
-    device?: string;
+    devices?: string[];
     variables?: Record<string, string>;
     sandbox?: boolean;
     allow?: JobAllowConfig;
@@ -94,12 +93,31 @@ export interface RunMeta {
     exitCode: number | null;
 }
 /**
- * True when the job may execute on this machine: no `device` pin, or the pin
- * names this device. Both sides go through `normalizeHost` so `Yosemite-S0`,
- * `yosemite-s0.tailnet.ts.net`, and `yosemite-s0` all agree. Every fire path
- * (cron scheduler, webhook, catchup/overdue, manual run) gates on this.
+ * True when the job may execute on this machine: no `devices` allowlist (or
+ * empty), or the allowlist includes this device. Both sides go through
+ * `normalizeHost` so `Yosemite-S0`, `yosemite-s0.tailnet.ts.net`, and
+ * `yosemite-s0` all agree. Every fire path (cron scheduler, webhook,
+ * catchup/overdue, manual run) gates on this.
  */
-export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'device'>): boolean;
+export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'devices'>): boolean;
+/** Human presentation of a device-affinity mismatch for commands and runner. */
+export interface JobEligibilityResult {
+    /** Full human message, e.g. "Job 'NAME' can only run on: a, b". */
+    message: string;
+    /** One-line copy-paste suggestion, e.g. "agents routines run NAME --host a". */
+    suggestion: string;
+    /** Comma-separated allowed devices label, e.g. "a, b". */
+    allowedLabel: string;
+    /** First allowed device (normalized), useful for the suggested host. */
+    firstHost: string;
+}
+/**
+ * Return null when the job may run here; otherwise return a structured,
+ * human-friendly eligibility failure. Centralizes the message/suggestion
+ * construction so manual run, executeJob, and executeJobDetached stay in
+ * sync. Scheduler/webhook/overdue paths continue to use jobRunsOnThisDevice.
+ */
+export declare function checkJobDeviceEligibility(config: Pick<JobConfig, 'name' | 'devices'>): JobEligibilityResult | null;
 /**
  * List all job configs, scanning project > user routine dirs.
  * Project routines (`<project>/.agents/routines/`) shadow user routines of the
@@ -113,7 +131,12 @@ export declare function listJobs(cwd?: string): JobConfig[];
  * only resolve user routines.
  */
 export declare function readJob(name: string, cwd?: string): JobConfig | null;
-/** Write a job config to disk, omitting fields that match defaults. */
+/** Write a job config to disk, omitting fields that match defaults.
+ *
+ * Updates the one existing supported extension (.yml or .yaml) atomically.
+ * New routines are written as .yml. If both extensions exist for the same
+ * name, the write fails explicitly so we never choose or drop a sibling.
+ */
 export declare function writeJob(config: JobConfig): void;
 /** Delete a job config file by name. Returns true if the file existed. */
 export declare function deleteJob(name: string): boolean;

package/dist/lib/routines.js

@@ -12,6 +12,7 @@ import * as yaml from 'yaml';
 import { Cron } from 'croner';
 import { getRoutinesDir, getRunsDir, ensureAgentsDir, getProjectRoutinesDir } from './state.js';
 import { safeJoin } from './paths.js';
+import { atomicWriteFileSync } from './fs-atomic.js';
 import { ALL_AGENT_IDS } from './agents.js';
 import { machineId, normalizeHost } from './machine-id.js';
 /** Canonical set of accepted GitHub trigger events — single source for validation. */
@@ -42,15 +43,33 @@ export function normalizeTriggerEvent(input) {
     return aliases[key] ?? null;
 }
 /**
- * True when the job may execute on this machine: no `device` pin, or the pin
- * names this device. Both sides go through `normalizeHost` so `Yosemite-S0`,
- * `yosemite-s0.tailnet.ts.net`, and `yosemite-s0` all agree. Every fire path
- * (cron scheduler, webhook, catchup/overdue, manual run) gates on this.
+ * True when the job may execute on this machine: no `devices` allowlist (or
+ * empty), or the allowlist includes this device. Both sides go through
+ * `normalizeHost` so `Yosemite-S0`, `yosemite-s0.tailnet.ts.net`, and
+ * `yosemite-s0` all agree. Every fire path (cron scheduler, webhook,
+ * catchup/overdue, manual run) gates on this.
  */
 export function jobRunsOnThisDevice(config) {
-    if (!config.device)
+    if (!config.devices || config.devices.length === 0)
         return true;
-    return normalizeHost(config.device) === machineId();
+    const self = machineId();
+    return config.devices.some((d) => normalizeHost(d) === self);
+}
+/**
+ * Return null when the job may run here; otherwise return a structured,
+ * human-friendly eligibility failure. Centralizes the message/suggestion
+ * construction so manual run, executeJob, and executeJobDetached stay in
+ * sync. Scheduler/webhook/overdue paths continue to use jobRunsOnThisDevice.
+ */
+export function checkJobDeviceEligibility(config) {
+    if (jobRunsOnThisDevice(config))
+        return null;
+    const allowed = (config.devices ?? []).map((d) => normalizeHost(d));
+    const allowedLabel = allowed.join(', ');
+    const firstHost = allowed[0] ?? 'HOST';
+    const message = `Job '${config.name}' can only run on: ${allowedLabel}`;
+    const suggestion = `agents routines run ${config.name} --host ${firstHost}`;
+    return { message, suggestion, allowedLabel, firstHost };
 }
 /** Default values applied to every job config when fields are omitted. */
 const JOB_DEFAULTS = {
@@ -122,6 +141,11 @@ function readJobFile(filePath) {
         const parsed = yaml.parse(content);
         if (!parsed || typeof parsed !== 'object')
             return null;
+        // Fail closed on the legacy singular `device` key. A routine that still
+        // carries it after v12 startup migration is unmigrated state and must be
+        // treated as unavailable/inert rather than unrestricted.
+        if (Object.prototype.hasOwnProperty.call(parsed, 'device'))
+            return null;
         return {
             ...JOB_DEFAULTS,
             ...parsed,
@@ -132,11 +156,23 @@ function readJobFile(filePath) {
         return null;
     }
 }
-/** Write a job config to disk, omitting fields that match defaults. */
+/** Write a job config to disk, omitting fields that match defaults.
+ *
+ * Updates the one existing supported extension (.yml or .yaml) atomically.
+ * New routines are written as .yml. If both extensions exist for the same
+ * name, the write fails explicitly so we never choose or drop a sibling.
+ */
 export function writeJob(config) {
     ensureAgentsDir();
     const jobsDir = getRoutinesDir();
-    const filePath = safeJoin(jobsDir, config.name + '.yml');
+    const ymlPath = safeJoin(jobsDir, config.name + '.yml');
+    const yamlPath = safeJoin(jobsDir, config.name + '.yaml');
+    const ymlExists = fs.existsSync(ymlPath);
+    const yamlExists = fs.existsSync(yamlPath);
+    if (ymlExists && yamlExists) {
+        throw new Error(`Routine '${config.name}' has both .yml and .yaml files; resolve the ambiguity before editing.`);
+    }
+    const filePath = ymlExists ? ymlPath : yamlExists ? yamlPath : ymlPath;
     const output = { ...config };
     if (output.mode === 'auto')
         delete output.mode;
@@ -148,7 +184,10 @@ export function writeJob(config) {
         delete output.enabled;
     if (output.runOnce === false || output.runOnce === undefined)
         delete output.runOnce;
-    fs.writeFileSync(filePath, yaml.stringify(output), 'utf-8');
+    const devArr = output.devices;
+    if (!devArr || devArr.length === 0)
+        delete output.devices;
+    atomicWriteFileSync(filePath, yaml.stringify(output));
 }
 /** Delete a job config file by name. Returns true if the file existed. */
 export function deleteJob(name) {
@@ -232,8 +271,19 @@ export function validateJob(config) {
         }
     }
     if (config.device !== undefined) {
-        if (typeof config.device !== 'string' || config.device.trim() === '') {
-            errors.push('device must be a non-empty device name (as shown by `agents devices`, e.g. yosemite-s0)');
+        errors.push('singular "device" key is no longer supported — replace with devices: [<name>] (an array)');
+    }
+    if (config.devices !== undefined) {
+        if (!Array.isArray(config.devices)) {
+            errors.push('devices must be an array of device names (as shown by `agents devices`)');
+        }
+        else {
+            for (const d of config.devices) {
+                if (typeof d !== 'string' || d.trim() === '') {
+                    errors.push('each entry in devices must be a non-empty device name');
+                    break;
+                }
+            }
         }
     }
     return errors;

package/dist/lib/runner.js

@@ -17,7 +17,7 @@ import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { resolveJobPrompt, parseTimeout, writeRunMeta, getRunDir, } from './routines.js';
+import { resolveJobPrompt, parseTimeout, writeRunMeta, getRunDir, checkJobDeviceEligibility, } from './routines.js';
 import { getRunsDir } from './state.js';
 import { prepareJobHome, buildSpawnEnv } from './sandbox.js';
 import { resolveModel, buildReasoningFlags } from './models.js';
@@ -378,6 +378,10 @@ function spawnJobAttempt(cmd, env, attemptLogPath, timeoutMs, combinedLogPath) {
  * failover across healthy same-agent accounts (RUSH-1016).
  */
 export async function executeJob(config, deps) {
+    const eligibility = checkJobDeviceEligibility(config);
+    if (eligibility) {
+        throw new Error(eligibility.message);
+    }
     maybeRotate();
     const launch = await resolveRoutineLaunch(config);
     const primaryVersion = launch.chain[0]?.version ?? config.version;
@@ -537,6 +541,11 @@ export async function executeJob(config, deps) {
 }
 /** Spawn a job as a detached process and return immediately with run metadata. */
 export async function executeJobDetached(config) {
+    const eligibility = checkJobDeviceEligibility(config);
+    if (eligibility) {
+        process.stderr.write(`[agents] daemon: skipping '${config.name}' — ${eligibility.message}\n`);
+        throw new Error(eligibility.message);
+    }
     // Pre-flight: pick a healthy version/account so the daemon does not launch
     // into a credit-exhausted install. Detached cannot mid-run failover (no exit
     // wait); the next schedule tick re-selects if this attempt still fails.

package/dist/lib/teams/agents.js

@@ -8,6 +8,7 @@
  * multiple permission modes (plan, edit, full).
  */
 import { spawn, execSync, execFileSync } from 'child_process';
+import { getAgentsInvocation } from '../daemon.js';
 import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as path from 'path';
@@ -1697,12 +1698,11 @@ export class AgentManager {
         return args;
     }
     buildCommand(agentType, prompt, mode, model, cwd = null, sessionId = null, effort = 'medium', version = null, profileName = null) {
-        const agentsCli = process.argv[1];
-        const cmd = [
-            process.execPath,
-            agentsCli,
-            ...this.buildRunArgv(agentType, prompt, mode, model, effort, version, profileName),
-        ];
+        // Route through getAgentsInvocation so a teammate launched by the compiled
+        // standalone binary (#315) doesn't relaunch as `agents /$bunfs/root/agents …`
+        // (process.argv[1] is the bun virtual entry there) → "unknown command".
+        const inv = getAgentsInvocation(this.buildRunArgv(agentType, prompt, mode, model, effort, version, profileName));
+        const cmd = [inv.command, ...inv.args];
         if (cwd)
             cmd.push('--cwd', cwd);
         // Pin the session UUID to our agent_id so buildExecEnv keys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.55",
+  "version": "1.20.56",
   "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",