@phnx-labs/agents-cli 1.20.48 → 1.20.50

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 1.20.50
+
+- **Distributed agent teams: teammates can now run on different machines across your fleet, not just the box running `teams start`.** A single team can place the backend teammate on a Linux box and the UI teammate on a Mac while one orchestrator still drives the DAG, polls status, and cleans up. One vocabulary, all optional (omit it and teams stay 100% local as before): `teams create --devices a,b,c` (alias `--hosts`) declares a pool the team may auto-schedule onto, `--repo <url|path>` (defaults to the local checkout's `origin`) says how each device gets the code, and `teams add --device X` (alias `--host`) pins one teammate to a host — which needs **no** pool, so "send just one teammate elsewhere" is zero-setup. Placement resolves top-down at launch: explicit `--device` pin → single-device pool (whole team there) → multi-device pool (least-loaded auto-schedule) → local. Remote teammates dispatch over SSH via the existing `agents devices`/host machinery (a third teammate backend beside local and cloud), are monitored by offset-tailing the remote log + `.exit` sentinel, and get the repo auto-provisioned per device (reuse an existing checkout, else clone into `~/.agents/repos/<team>`) with an optional per-teammate git worktree on the host. `teams status`/`teams logs` show each teammate's host and stream its output back with the local mirror capped (~512KB rolling tail) so a 10+-teammate fleet can't blow up the orchestrator. POSIX hosts only in v1 (Windows rejected with a clear message). Source: `apps/cli/src/lib/teams/{scheduler,remoteWorktree,agents,api,supervisor,registry}.ts`, `apps/cli/src/lib/hosts/{progress,passthrough}.ts`, `apps/cli/src/commands/teams.ts`, `apps/cli/docs/teams.md`.
+- **NEW: `agents doctor --devices` shows a cross-device agent-readiness matrix.** `agents doctor` could already run on one remote machine via `--host`, but checking the whole fleet meant running the command once per box. `--devices` fans out `agents teams doctor --json` to every registered device (plus the local machine), renders a device × agent matrix, and emits a stable JSON contract with `--json`. `--device <name>` or `--host <name>` scopes the same matrix to a single machine. The remote probe now bootstraps `PATH` with the canonical shim directories before running, so login shells that haven't sourced interactive rc files no longer report false "not installed" negatives. Source: `apps/cli/src/commands/doctor.ts`, `apps/cli/src/lib/teams/agents.ts`, `apps/cli/src/lib/hosts/{passthrough,remote-cmd}.ts`.
+- **`agents run codex` / `agents teams` now honor your configured Codex model instead of silently defaulting to `gpt-5.3-codex`.** Codex runs under a per-version `CODEX_HOME`, and your `model` preference (`~/.codex/config.toml`) lives only in the version-home that was active when you set it. A dispatch pinned to a different version read a home with no top-level `model`, so Codex fell back to its built-in default — which a ChatGPT-tier account isn't entitled to use, so the run died with `400: The 'gpt-5.3-codex' model is not supported when using Codex with a ChatGPT account` before doing any work, even though `ag view` reported Codex "signed in". When no explicit `--model` is passed, the model is now defaulted (for Codex) to the top-level `model` in your active `~/.codex/config.toml` and forwarded via `--model`; it's read-only (no file writes), so fanning out many parallel runs to one version-home can't race. Verified live on a box where Codex was 100% unusable: the request model changed `gpt-5.3-codex` → `gpt-5.5` and codex@0.142.0 returned successfully. Source: `apps/cli/src/lib/exec.ts`, `apps/cli/src/lib/shims.ts` (`readCodexConfiguredModel`).
+- **Fix: `agents add claude@<version>` now produces a runnable install — it no longer ships a half-built binary that dies with "claude native binary not installed."** `installVersion` runs `npm install --ignore-scripts` (the right posture for the dependency *tree* — never run arbitrary transitive postinstalls), but that also skipped the agent package's OWN postinstall, which for `@anthropic-ai/claude-code` is a required step: the package ships a ~500-byte stub at `bin/claude.exe` plus per-arch native binaries as optional deps, and its `postinstall` (`node install.cjs`) is what copies the correct ~231 MB native binary over the stub. Skipped, every launch died with `Error: claude native binary not installed`. The existing launch-health self-heal (#764, and its Windows/daemon extension) couldn't save it on two counts: the stub reports its breakage *politely* rather than with a raw `ENOENT`, so the probe's missing-binary signature didn't match and the gutted install read as healthy; and the repair path (`ensureAgentRunnable` → clean reinstall) re-ran the same `--ignore-scripts` install, so it never copied the binary either. `installVersion` now runs the **first-party** package's declared `postinstall` after the npm install (scoped to that one package — never the dependency tree, never claude-code's `exit 1` `prepare` guard), best-effort, before the integrity gate. Because `installVersion` is the single choke point for `agents add`, config refresh, run-time heal, and the daemon's proactive heal, this also revives the repair path for the whole class. `isMissingBinarySignature` was additionally widened to recognize the stub's polite phrases (`native binary not installed`, `postinstall did not run`, `optional dependency was not downloaded`) so the self-heal catches this failure mode if a postinstall ever silently no-ops. Verified end-to-end on linux-arm64: `installVersion('claude','2.1.186')` into a clean HOME runs the postinstall automatically, lands the 231,782,112-byte binary (not the stub), and `claude.exe --version` returns `2.1.186 (Claude Code)` — with no manual `install.cjs` step. Source: `apps/cli/src/lib/versions.ts` (`installVersion`, `isMissingBinarySignature`).
+
+## 1.20.49
+
+- **`agents run --mode plan` no longer hard-fails on agents without a read-only mode (antigravity, cursor, kiro, …).** Those agents have no plan flag, so an explicit or default `--mode plan` used to abort with `does not support 'plan' mode` — breaking multi-agent scripts that pass a uniform plan flag, and diverging from `agents teams add` (default mode `edit`). `resolveMode` now degrades unsupported `plan` to the agent's safest native mode (`capabilities.modes[0]`, typically `edit`), matching the existing `auto` → `edit` degrade. The CLI prints a yellow warning when the user explicitly asked for plan (gray for the implicit default) so the elevation is never silent. `skip` still hard-fails when unsupported. Source: `apps/cli/src/lib/exec.ts`, `apps/cli/src/commands/exec.ts`.
+- **`agents cloud cancel` now actually cancels paused runs.** `RushProvider.cancel()` issued `DELETE /api/v1/cloud-runs/{id}`, which the backend doesn't implement — it 404s — so `agents cloud cancel` (and the Factory Floor's cancel affordance) silently failed on any run that wasn't actively running: `queued`, `needs_review`, and `input_required` runs stayed stuck (e.g. a 14-day-old input-required run lingering in the Floor's "NEEDS YOU" bucket forever). Switched to the cancel action endpoint `POST /api/v1/cloud-runs/{id}/cancel`, which the backend implements and which cancels paused runs too. Verified live against `api.prix.dev` (the POST returned `{"ok":true,"status":"cancelled"}` and the stuck run transitioned `needs_review` → `cancelled`). Source: `apps/cli/src/lib/cloud/rush.ts`.
+
 ## 1.20.48
 
 - **Menu-bar helper: a RECENT TICKETS section shows the issues you filed via the quick-issue bar, each clickable to open in Linear.** The completion notification is transient, so the tickets the `Cmd-Shift-O` bar creates now also persist to a small local ledger (`~/.agents/.history/menubar/recent-tickets.json`, newest-first, deduped by id, capped at 10) that the menu-bar dropdown surfaces below RECENT sessions — click a row to open the ticket. The dispatch records the id + note + Linear URL on a successful create; the section renders nothing when the ledger is empty. Source: `apps/cli/menubar/Sources/MenubarHelper/{RecentTickets,StatusItemController,AgentsCLI,IssueSelfTest}.swift`.

package/README.md

@@ -307,6 +307,9 @@ agents logs <id> --full                 # the full raw transcript / stdout (toke
 agents logs <id> -f                     # re-attach to a running one and follow
 agents view claude --host gpu-box       # inspect the remote install
 agents sync --host gpu-box              # make the remote machine current
+agents doctor --devices                 # readiness matrix for every registered device
+agents doctor --devices --json          # machine-readable fleet readiness
+agents doctor --device mac-mini         # same matrix, scoped to one device
 
 # Your Tailscale fleet, auto-discovered
 agents devices sync                     # ingest `tailscale status`

package/dist/commands/doctor.js

@@ -1,6 +1,12 @@
 import { addHostOption } from '../lib/hosts/option.js';
+import { buildRemoteAgentsInvocation } from '../lib/hosts/remote-cmd.js';
+import { loadDevices } from '../lib/devices/registry.js';
+import { resolveHost } from '../lib/hosts/registry.js';
+import { sshExec } from '../lib/ssh-exec.js';
+import { sshTargetFor } from '../lib/hosts/types.js';
+import { machineId } from '../lib/session/sync/config.js';
 import chalk from 'chalk';
-import { checkAllClis } from '../lib/teams/agents.js';
+import { checkAllClis, collectTeamsDoctorData } from '../lib/teams/agents.js';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError } from '../lib/agents.js';
 import { getGlobalDefault, getVersionHomePath, isVersionInstalled, listInstalledVersions, parseAgentSpec, } from '../lib/versions.js';
 import { loadManifest, isStale } from '../lib/staleness/index.js';
@@ -203,6 +209,121 @@ function renderExecPolicyAdvisory() {
         console.log(chalk.gray(`           ${line}`));
     }
 }
+const AGENT_ORDER = ['claude', 'codex', 'kimi', 'grok', 'antigravity', 'opencode', 'cursor', 'gemini', 'droid'];
+function shortAgentHeader(name) {
+    return name.slice(0, 4).padEnd(4);
+}
+function agentCell(entry) {
+    if (!entry)
+        return chalk.gray('-   ');
+    if (entry.installed) {
+        const signedInHint = entry.signedIn ? '*' : ' ';
+        return chalk.green(`rdy${signedInHint}`.padEnd(4));
+    }
+    if (entry.error)
+        return chalk.red('err '.padEnd(4));
+    return chalk.gray('no  '.padEnd(4));
+}
+async function resolveFleetTargets(opts) {
+    const singleName = opts.host || opts.device;
+    if (singleName) {
+        // --device / --host as a single-device filter: resolve through the device
+        // registry first, then the general host registry, then ad-hoc user@host.
+        const registry = await loadDevices();
+        const deviceProfile = registry[singleName];
+        if (deviceProfile) {
+            return [{
+                    name: deviceProfile.name,
+                    sshTarget: deviceProfile.name,
+                    os: deviceProfile.platform !== 'unknown' ? deviceProfile.platform : undefined,
+                }];
+        }
+        const host = await resolveHost(singleName);
+        if (host) {
+            return [{ name: singleName, sshTarget: sshTargetFor(host), os: host.os }];
+        }
+        console.error(chalk.red(`Unknown host or device '${singleName}'.`));
+        process.exit(1);
+    }
+    const registry = await loadDevices();
+    const localName = machineId();
+    return Object.values(registry)
+        .filter((d) => d.name.toLowerCase() !== localName)
+        .map((d) => ({
+        name: d.name,
+        sshTarget: d.name,
+        os: d.platform !== 'unknown' ? d.platform : undefined,
+    }));
+}
+async function probeFleetTarget(target) {
+    const forwarded = ['teams', 'doctor', '--json'];
+    const isWin = /^win/i.test((target.os ?? '').trim());
+    const remoteCmd = buildRemoteAgentsInvocation(forwarded, undefined, isWin ? 'windows' : undefined, 
+    // POSIX login shells often lack the shims dir; Windows PowerShell usually
+    // has it via the install profile, and our single-quote escaping would
+    // prevent $HOME expansion there, so skip the bootstrap on Windows.
+    isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' });
+    const res = sshExec(target.sshTarget, remoteCmd, { timeoutMs: 30000, multiplex: true });
+    if (res.code !== 0) {
+        return {
+            name: target.name,
+            online: false,
+            error: res.timedOut ? 'timed out' : (res.stderr || `exit ${res.code ?? 'unknown'}`),
+            agents: {},
+        };
+    }
+    try {
+        const agents = JSON.parse(res.stdout);
+        return { name: target.name, online: true, agents };
+    }
+    catch (err) {
+        const stderrHint = res.stderr ? ` stderr: ${res.stderr.trim()}` : '';
+        return {
+            name: target.name,
+            online: true,
+            error: `invalid JSON (${err?.message ?? 'parse error'})${stderrHint}`,
+            agents: {},
+        };
+    }
+}
+async function runDevicesDoctor(opts) {
+    const singleName = opts.host || opts.device;
+    const targets = await resolveFleetTargets(opts);
+    const localName = machineId();
+    const results = [];
+    // Local machine first, directly.
+    if (!singleName) {
+        results.push({ name: localName, online: true, agents: await collectTeamsDoctorData() });
+    }
+    // Remote targets in parallel.
+    const remoteResults = await Promise.all(targets.map(probeFleetTarget));
+    results.push(...remoteResults);
+    if (opts.json) {
+        console.log(JSON.stringify({ devices: results }, null, 2));
+        return;
+    }
+    if (results.length === 0) {
+        console.log(chalk.gray('No registered devices. Run `agents devices` to register some.'));
+        return;
+    }
+    const agentsToShow = AGENT_ORDER.filter((a) => results.some((r) => r.agents[a] !== undefined));
+    console.log(chalk.bold('Agent readiness by device'));
+    if (agentsToShow.length === 0) {
+        console.log(chalk.gray('  (no agent data collected)'));
+        return;
+    }
+    const nameWidth = Math.max(...results.map((r) => r.name.length));
+    const header = `  ${'Device'.padEnd(nameWidth)}  ${agentsToShow.map(shortAgentHeader).join('  ')}`;
+    console.log(chalk.gray(header));
+    for (const row of results) {
+        const status = row.online ? chalk.green('online ') : chalk.red('offline');
+        const errorSuffix = row.error ? `  ${chalk.gray(row.error)}` : '';
+        const cells = agentsToShow.map((a) => agentCell(row.agents[a])).join('  ');
+        console.log(`  ${row.name.padEnd(nameWidth)}  ${status}  ${cells}${errorSuffix}`);
+    }
+    console.log();
+    console.log(chalk.gray('  rdy* = installed and signed in · rdy = installed · no = not installed · err = probe failed · - = offline'));
+}
 function parseTargetArg(arg) {
     const at = arg.indexOf('@');
     const agentPart = at === -1 ? arg : arg.slice(0, at);
@@ -484,7 +605,9 @@ export function registerDoctorCommand(program) {
         .option('--kind <kinds>', 'Restrict to comma-separated resource kinds (commands,skills,hooks,rules,mcp,permissions,subagents,plugins,promptcuts)')
         .option('--cwd <path>', 'Resolution cwd for project layer detection (default: process.cwd())')
         .option('--adopt <agent>', "Take over the agent's native launcher that shadows the shim (symlink it to the version-managed shim; reversible with --release)")
-        .option('--release <agent>', 'Undo --adopt: restore the native launcher agents-cli previously adopted');
+        .option('--release <agent>', 'Undo --adopt: restore the native launcher agents-cli previously adopted')
+        .option('--devices', 'Check agent readiness on every registered device (alias --hosts)')
+        .option('--hosts', 'Alias of --devices');
     setHelpSections(doctorCmd, {
         examples: `
       # Overview: CLI availability + sync status + orphans across all defaults
@@ -511,6 +634,14 @@ export function registerDoctorCommand(program) {
     });
     doctorCmd.action(async (target, opts) => {
         const cwd = opts.cwd ? opts.cwd : process.cwd();
+        if (opts.devices || opts.hosts) {
+            if (target) {
+                console.error(chalk.red('Cannot combine --devices with a target argument.'));
+                process.exit(1);
+            }
+            await runDevicesDoctor(opts);
+            return;
+        }
         // Launcher adoption escape hatch. `--adopt <agent>` forces the take-over
         // even for a non-default agent; `--release <agent>` reverses it.
         if (opts.adopt || opts.release) {

package/dist/commands/exec.js

@@ -570,7 +570,7 @@ export function registerRunCommand(program) {
             });
             process.exit(resumeExit);
         }
-        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, defaultModeFor, headlessPlanStallCommand, nativeResume, resolveInteractive }, { ALL_AGENT_IDS }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports },] = await Promise.all([
+        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, headlessPlanStallCommand, nativeResume, resolveInteractive }, { ALL_AGENT_IDS }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports },] = await Promise.all([
             import('../lib/exec.js'),
             import('../lib/agents.js'),
             import('../lib/profiles.js'),
@@ -1017,28 +1017,38 @@ export function registerRunCommand(program) {
             console.error(chalk.red(`Invalid mode: ${mode}. Use plan, edit, auto, or skip ('full' accepted as alias for skip).`));
             process.exit(1);
         }
-        // When the user did not pass --mode explicitly, the default is the
-        // generic 'plan'. Some agents (antigravity: edit/skip only, grok in some
-        // configurations) do not support plan. For implicit defaults, degrade
-        // silently to the agent's first listed mode rather than throwing — the
-        // user did not ask for read-only, they asked for "just run it." An
-        // explicit --mode plan still throws (see resolveMode), because silently
-        // elevating an explicit read-only request to edit is unsafe.
+        // Default CLI mode is the generic 'plan'. Agents without a read-only
+        // mode (antigravity, cursor, kiro, …) degrade via resolveMode to their
+        // safest native mode (modes[0], typically edit). That covers both the
+        // implicit default and an explicit `--mode plan`, so multi-agent
+        // scripts can pass a uniform plan flag without per-agent branching.
+        // Elevation is never silent: we warn on stderr (yellow when the user
+        // explicitly asked for plan; gray for the implicit default / auto).
+        // `skip` still hard-fails when unsupported — pretending we bypassed
+        // permissions would be unsafe.
         const modeIsDefault = modeSource === 'default';
+        const requestedMode = normalizeMode(mode);
+        let resolvedMode;
         try {
-            resolveMode(agent, normalizeMode(mode));
+            resolvedMode = resolveMode(agent, requestedMode);
         }
         catch (err) {
-            if (modeIsDefault && !modeFromRunDefault) {
-                mode = defaultModeFor(agent);
-                if (!options.quiet) {
-                    process.stderr.write(chalk.gray(`[agents] ${agent} has no '${options.mode}' mode; using '${mode}'\n`));
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+        if (resolvedMode !== requestedMode) {
+            mode = resolvedMode;
+            if (!options.quiet) {
+                if (requestedMode === 'plan' && !modeIsDefault) {
+                    process.stderr.write(chalk.yellow(`[agents] ${agent} has no read-only 'plan' mode; using '${mode}' (writable) instead. Pass --mode ${mode} to silence this.\n`));
+                }
+                else {
+                    process.stderr.write(chalk.gray(`[agents] ${agent} has no '${requestedMode}' mode; using '${mode}'\n`));
                 }
             }
-            else {
-                console.error(chalk.red(err.message));
-                process.exit(1);
-            }
+        }
+        else {
+            mode = resolvedMode;
         }
         // Fail fast on the headless-plan stall footgun: a slash command run
         // headless under the implicit default 'plan' mode hangs forever at