@phnx-labs/agents-cli 1.20.67 → 1.20.68

package/dist/commands/teams.js

@@ -809,6 +809,23 @@ async function pickTeamOr(mgr, command) {
         throw err;
     }
 }
+/**
+ * `teams add --remote-cwd` is a no-op trap. `--remote-cwd` comes from the shared
+ * `--host` option family (option.ts) and is meaningful for commands that *route*
+ * to a host, but `teams add` special-cases `--host`/`--device` as PLACEMENT, so
+ * the flag is never read — a teammate's directory is the team's repo plus its
+ * `--worktree`, not a path passed here. Silently ignoring it misleads you into
+ * thinking it set the teammate's repo path (the exact wrong model that turns one
+ * team into a teardown-and-rebuild). Reject with guidance instead. Exported for
+ * the unit test that pins the message.
+ */
+export function remoteCwdOnAddError(team) {
+    return (`--remote-cwd has no effect on 'teams add' — it does not set a teammate's repo or directory.\n` +
+        `  A teammate works in the team's repo plus its own --worktree:\n` +
+        `    • Set the repo once, on the team:  agents teams create ${team} --repo <url|path>\n` +
+        `    • Place the teammate on a machine: agents teams add ${team} <agent> "<task>" --device <host> --worktree <name>\n` +
+        `  (Remote worktrees fork from the host's freshly-fetched origin/<default> automatically.)`);
+}
 /** Register the `agents teams` command tree (list, create, add, status, start, remove, disband, logs, doctor). */
 export function registerTeamsCommands(program) {
     const teams = program
@@ -853,6 +870,20 @@ export function registerTeamsCommands(program) {
         '<profile>'        a profile from 'agents view' — runs through 'agents
                            run <profile>' with the profile's host harness
 
+      Placement & repos (the part people get wrong):
+        --remote-cwd does NOT place a teammate or set its repo — it is ignored on
+        'teams add' (and rejected, so you find out immediately). A teammate's
+        directory is the team's repo plus its --worktree:
+          --device <host>     run THIS teammate on <host>
+          create --repo <r>   ONE repo for the whole team (defaults to this
+                              checkout's origin). Work spanning repos → one team
+                              per repo — don't build a cross-repo team then rebuild.
+        With --enable-worktrees each teammate gets its own worktree + branch:
+          local teammate      forks from your CURRENT local HEAD — no fetch, so
+                              pull/sync the checkout first or it forks stale
+          remote (--device)   forks from the freshly-fetched origin/<default> on
+                              the host (no manual sync needed)
+
       Short aliases:
         teams c  = create    teams a  = add       teams s  = status
         teams rm = remove    teams d  = disband   teams ls = list
@@ -978,7 +1009,7 @@ export function registerTeamsCommands(program) {
         .option('--use-worktree <path>', 'All teammates share this existing worktree path (mutually exclusive with --enable-worktrees)')
         .option('--devices <list>', 'Pool of machines this team may run teammates on (comma-separated). Enables distributed auto-scheduling.')
         .option('--hosts <list>', 'Alias for --devices.')
-        .option('--repo <urlOrPath>', 'How each device gets the code (git URL to clone, or a path). Defaults to the local checkout origin.')
+        .option('--repo <urlOrPath>', 'How each remote (--device) teammate gets the code — ONE git URL/path for the whole team (existing checkout reused, else cloned). A team is single-repo; for work across repos, make one team per repo. Defaults to this checkout origin.')
         .option('--json', 'Output machine-readable JSON')
         .action(async (team, opts) => {
         try {
@@ -1073,6 +1104,13 @@ export function registerTeamsCommands(program) {
         .option('--force', "Skip the advisory 'may not be signed in' / 'account throttled' warnings")
         .option('--json', 'Output machine-readable JSON')
         .action(async (team, teammate, task, opts) => {
+        // `--remote-cwd` rides the shared --host option family but is never read by
+        // `teams add` (placement, not routing). Fail loud with guidance rather than
+        // silently ignoring it — see remoteCwdOnAddError. `!== undefined` so even an
+        // explicit empty value (`--remote-cwd ""`) is rejected, not silently dropped.
+        if (opts.remoteCwd !== undefined) {
+            die(remoteCwdOnAddError(team));
+        }
         if (!VALID_MODES.includes(opts.mode)) {
             die(`Invalid mode '${opts.mode}'. Use one of: ${VALID_MODES.join(', ')}`);
         }

package/dist/commands/view.d.ts

@@ -133,6 +133,7 @@ export declare function viewAction(agentArg?: string, options?: {
     dryRun?: boolean;
     resources?: string | boolean;
     detailed?: boolean;
+    refresh?: boolean;
 } & ViewSectionFilter): Promise<void>;
 /** Register the `agents view` command. */
 export declare function registerViewCommand(program: Command): void;

package/dist/commands/view.js

@@ -5,7 +5,8 @@ import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
 import { AGENTS, ALL_AGENT_IDS, accountOrgBadge, getAllCliStates, getAccountInfo, resolveAgentName, formatAgentError, agentLabel, colorAgent, } from '../lib/agents.js';
-import { deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
+import { loginHint } from '../lib/signin-badge.js';
+import { agentReportsUsage, deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { readManifest } from '../lib/manifest.js';
 import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, promptNewResourceSelection, syncResourcesToVersion, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, } from '../lib/versions.js';
 import { ensureVersionedAliasCurrent, removeShim, } from '../lib/shims.js';
@@ -244,7 +245,7 @@ function renderHostClisSection(cwd) {
         console.log(`  ${chalk.red('error')}      ${chalk.gray(err.file)}: ${chalk.gray(err.reason)}`);
     }
 }
-async function showInstalledVersions(filterAgentId) {
+async function showInstalledVersions(filterAgentId, viewOpts) {
     const spinnerText = filterAgentId
         ? `Checking ${agentLabel(filterAgentId)} agents...`
         : 'Checking installed agents...';
@@ -326,7 +327,7 @@ async function showInstalledVersions(filterAgentId) {
             cliVersion,
             info,
         })),
-    ]);
+    ], { forceRefresh: viewOpts?.forceRefresh });
     const mergeCanonical = (info) => {
         const key = getUsageLookupKey(info);
         if (!key)
@@ -417,7 +418,8 @@ async function showInstalledVersions(filterAgentId) {
                 const info = rawInfo ? mergeCanonical(rawInfo) : undefined;
                 const usageKey = getUsageLookupKey(info);
                 const usageInfo = usageKey ? usageByKey.get(usageKey) : undefined;
-                const usageStr = formatUsageSummary(info?.plan || null, usageInfo?.snapshot || null, maxPlanWidth);
+                const usageUnavailable = agentReportsUsage(agentId) && !!info?.signedIn && !usageInfo?.snapshot;
+                const usageStr = formatUsageSummary(info?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, { unavailable: usageUnavailable });
                 maxUsageWidth = Math.max(maxUsageWidth, visibleWidth(usageStr));
                 const statusStr = formatUsageStatusBadge(info?.usageStatus);
                 maxStatusWidth = Math.max(maxStatusWidth, visibleWidth(statusStr));
@@ -457,7 +459,8 @@ async function showInstalledVersions(filterAgentId) {
                 const parts = [`    ${label}`];
                 const hasEmail = !!vInfo?.email;
                 const signedIn = !!vInfo?.signedIn;
-                const usageStr = formatUsageSummary(vInfo?.plan || null, usageInfo?.snapshot || null, maxPlanWidth);
+                const usageUnavailable = agentReportsUsage(agentId) && signedIn && !usageInfo?.snapshot;
+                const usageStr = formatUsageSummary(vInfo?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, { unavailable: usageUnavailable });
                 const hasUsage = usageStr.length > 0;
                 // Only show lastActive for versions with an actual logged-in account.
                 // Otherwise it reflects install time (misleading "just now" for fresh installs).
@@ -471,7 +474,7 @@ async function showInstalledVersions(filterAgentId) {
                     runDefaultBits.push(`model:${runDefaults.model}`);
                 if (!hasEmail && !hasUsage && !signedIn) {
                     // Installed but never signed in
-                    parts.push(chalk.gray('(not signed in — run ' + agent.cliCommand + ' to log in)'));
+                    parts.push(chalk.gray('(logged out — log in with: ' + loginHint(agentId) + ')'));
                 }
                 else {
                     if (hasEmail || hasUsage || hasActive || signedIn) {
@@ -1438,7 +1441,7 @@ export async function viewAction(agentArg, options) {
             return;
         }
         // No argument: show all installed versions
-        await showInstalledVersions();
+        await showInstalledVersions(undefined, { forceRefresh: options?.refresh === true });
         return;
     }
     // Parse agent@version syntax
@@ -1499,7 +1502,7 @@ export async function viewAction(agentArg, options) {
     }
     else {
         // Just agent name: show versions for that agent
-        await showInstalledVersions(agentId);
+        await showInstalledVersions(agentId, { forceRefresh: options?.refresh === true });
     }
 }
 /** Register the `agents view` command. */
@@ -1509,6 +1512,7 @@ export function registerViewCommand(program) {
         .option('--json', 'Emit machine-readable JSON (version list, usage, signed-in status).')
         .option('--resources [sections]', 'In --json mode, include each version\'s resources: "all" (default) or a comma list (skills,plugins,mcp,commands,workflows,memory,hooks). Implies --json.')
         .option('--detailed', 'Include all resources in --json output (alias for --resources all). Implies --json.')
+        .option('-r, --refresh', 'Force a live usage refresh, bypassing the cache (slower). Repopulates the S:/W: limit bars for every account whose token is reachable.')
         .option('--prune', 'Remove older installed versions that share an account with a newer installed version. Skips the global default.')
         .option('--dry-run', 'With --prune, show duplicate versions without deleting')
         .option('-y, --yes', 'Skip the prune confirmation prompt.')

package/dist/lib/agents.d.ts

@@ -139,11 +139,13 @@ export interface AccountInfo {
  */
 export declare function formatClaudeOrgLabel(orgType: string | null | undefined): string | null;
 /**
- * Short badge identifying which org an account belongs to: "Turing Labs · Team"
- * for multi-seat orgs, just the tier label ("Max") for personal plans — a
- * personal org's name is auto-generated boilerplate ("<email>'s Organization"),
- * not identity. Returns null when the account carries no organizationType
- * (signed out, non-Claude agents, configs predating the field).
+ * Short badge identifying which ORG an account belongs to — "Turing Labs" for a
+ * multi-seat Team/Enterprise org, whose name is real identity that disambiguates
+ * a Team seat from a same-email personal plan. Returns null for personal plans
+ * (Max/Pro/Free): the tier label now lives in the aligned plan column, so a badge
+ * would only duplicate it, and a personal org's name is auto-generated boilerplate
+ * ("<email>'s Organization"), not identity. Also null when the account carries no
+ * organizationType (signed out, non-Claude agents, configs predating the field).
  */
 export declare function accountOrgBadge(info?: Pick<AccountInfo, 'organizationType' | 'organizationName'> | null): string | null;
 /** Return the email address associated with the agent's auth config, or null. */
@@ -303,6 +305,10 @@ export declare function getUserMcpConfigPath(agentId: AgentId): string;
  * Get MCP config path for a specific HOME directory (used for version-managed agents).
  */
 export declare function getMcpConfigPathForHome(agentId: AgentId, home: string): string;
+/**
+ * Get project-scoped MCP config path for an agent.
+ */
+export declare function getProjectMcpConfigPath(agentId: AgentId, cwd?: string): string;
 /**
  * Parse MCP config based on agent type.
  */

package/dist/lib/agents.js

@@ -978,20 +978,19 @@ export function formatClaudeOrgLabel(orgType) {
         .join(' ');
 }
 /**
- * Short badge identifying which org an account belongs to: "Turing Labs · Team"
- * for multi-seat orgs, just the tier label ("Max") for personal plans — a
- * personal org's name is auto-generated boilerplate ("<email>'s Organization"),
- * not identity. Returns null when the account carries no organizationType
- * (signed out, non-Claude agents, configs predating the field).
+ * Short badge identifying which ORG an account belongs to — "Turing Labs" for a
+ * multi-seat Team/Enterprise org, whose name is real identity that disambiguates
+ * a Team seat from a same-email personal plan. Returns null for personal plans
+ * (Max/Pro/Free): the tier label now lives in the aligned plan column, so a badge
+ * would only duplicate it, and a personal org's name is auto-generated boilerplate
+ * ("<email>'s Organization"), not identity. Also null when the account carries no
+ * organizationType (signed out, non-Claude agents, configs predating the field).
  */
 export function accountOrgBadge(info) {
-    const label = formatClaudeOrgLabel(info?.organizationType);
-    if (!label)
-        return null;
     const isMultiSeat = info?.organizationType === 'claude_team' || info?.organizationType === 'claude_enterprise';
     if (isMultiSeat && info?.organizationName)
-        return `${info.organizationName} · ${label}`;
-    return label;
+        return info.organizationName;
+    return null;
 }
 /** Return the email address associated with the agent's auth config, or null. */
 export async function getAccountEmail(agentId, home) {
@@ -1321,19 +1320,23 @@ export async function getAccountInfo(agentId, home) {
                     ['org', organizationId],
                 ]);
                 const usageKey = buildIdentityKey(agentId, [['org', organizationId]]);
-                // Plan is derived from .claude.json's billingType only. Reading
-                // subscriptionType from the keychain item ("Claude Code-credentials-<hash>")
-                // forces a macOS Keychain ACL prompt on every `agents run` (one prompt per
-                // installed version under balanced rotation) because Claude Code writes its
-                // credentials with its own process in the ACL — our helper isn't trusted by
-                // that item. Callers that genuinely need subscriptionType (e.g. detailed
-                // `agents view`) should call loadClaudeOauth() directly.
-                let plan = null;
-                if (oa?.billingType === 'stripe_subscription') {
-                    plan = 'Pro';
-                }
-                else if (oa?.billingType) {
-                    plan = oa.billingType;
+                // Plan tier is derived from .claude.json's organizationType, which carries
+                // the TRUE tier (claude_max → "Max", claude_pro → "Pro", claude_team →
+                // "Team") and is already in-hand from the config we just read — no Keychain
+                // prompt. billingType only distinguishes "has a Stripe subscription" and so
+                // mislabels every Max account as "Pro"; keep it as a fallback for older
+                // configs predating organizationType. (Reading subscriptionType from the
+                // keychain item would force a macOS Keychain ACL prompt on every `agents
+                // run`, so we deliberately avoid it — organizationType gives us the tier
+                // without that cost.)
+                let plan = formatClaudeOrgLabel(oa?.organizationType);
+                if (!plan) {
+                    if (oa?.billingType === 'stripe_subscription') {
+                        plan = 'Pro';
+                    }
+                    else if (oa?.billingType) {
+                        plan = oa.billingType;
+                    }
                 }
                 // usageStatus is NOT derived from cachedExtraUsageDisabledReason. That
                 // field reports why pay-as-you-go overage is off (out_of_credits = no
@@ -2194,7 +2197,7 @@ export function getMcpConfigPathForHome(agentId, home) {
 /**
  * Get project-scoped MCP config path for an agent.
  */
-function getProjectMcpConfigPath(agentId, cwd = process.cwd()) {
+export function getProjectMcpConfigPath(agentId, cwd = process.cwd()) {
     switch (agentId) {
         case 'claude':
             // Claude uses .mcp.json at project root for project-scoped MCPs

package/dist/lib/browser/profiles.js

@@ -228,27 +228,6 @@ function hasSshEndpoint(endpoints) {
         }
     });
 }
-/**
- * True when any endpoint is an `ssh://…?os=windows` target — i.e. the browser
- * lives on a remote Windows host. Such a profile's binary (`msedge.exe`) will
- * never exist on this Mac, so create-time local-binary validation must be
- * skipped; the binary is resolved on the remote at connect time instead.
- */
-function hasRemoteWindowsEndpoint(endpoints) {
-    const targets = Array.isArray(endpoints)
-        ? endpoints
-        : Object.values(endpoints).map((preset) => preset.target);
-    return targets.some((target) => {
-        try {
-            const url = new URL(target);
-            return (url.protocol === 'ssh:' &&
-                (url.searchParams.get('os') || '').toLowerCase() === 'windows');
-        }
-        catch {
-            return false;
-        }
-    });
-}
 export async function createProfile(profile) {
     const meta = readMeta();
     if (meta.browser?.[profile.name]) {
@@ -276,10 +255,10 @@ export async function createProfile(profile) {
     // deferring the failure to the first task. `findBrowserPath` short-circuits
     // for browser=custom without a binary by throwing — same outcome.
     //
-    // Skip for remote-Windows profiles: the browser is `msedge.exe` on the
-    // remote box, never on this Mac, so a local lookup would always (wrongly)
-    // fail. The remote launcher resolves it at connect time via App Paths.
-    if (!hasRemoteWindowsEndpoint(profile.endpoints)) {
+    // Skip for SSH profiles: the browser binary lives on the remote host, so a
+    // local lookup would validate the wrong machine. The remote launcher resolves
+    // it at connect time.
+    if (!hasSshEndpoint(profile.endpoints)) {
         findBrowserPath(profile.browser, profile.binary);
     }
     meta.browser = meta.browser ?? {};

package/dist/lib/cli-entry.d.ts

@@ -0,0 +1,23 @@
+export declare const BUN_VIRTUAL_ROOT: RegExp;
+export declare function getAgentsBinPath(argv1?: string | undefined, execPath?: string): string;
+/**
+ * A CLI entry must be launched through the Node runtime when it is a Node
+ * script — a `.js`/`.cjs`/`.mjs` file, OR a symlink/extension-less shim whose
+ * shebang names `node`. Package installs link `bin/agents` to a `dist/index.js`
+ * (a symlink) or drop an extension-less `#!/usr/bin/env node` shim, so an
+ * extension check alone misses them and they get run directly. A real compiled
+ * binary (Mach-O/ELF/PE) has no `#!node` shebang, so it takes the direct branch
+ * and owns its own runtime resolution.
+ */
+export declare function isNodeScriptEntry(agentsBin: string): boolean;
+/**
+ * Build the `{ command, args }` to re-invoke this CLI with `sub` as its argv,
+ * resolving the JS-vs-standalone shape above. This is the single primitive behind
+ * both the daemon launch and the secrets-broker spawn — never hand-roll
+ * `[process.execPath, process.argv[1], …]`, which appends the bun virtual entry
+ * as a bogus subcommand on standalone builds.
+ */
+export declare function getCliLaunch(sub: string[], agentsBin?: string): {
+    command: string;
+    args: string[];
+};

package/dist/lib/cli-entry.js

@@ -0,0 +1,116 @@
+/**
+ * Resolve how to re-invoke THIS `agents` CLI as a child process, correctly across
+ * both install shapes:
+ *
+ *   1. **JS install** — `agents` is a `dist/index.js` (or a symlink / `#!node`
+ *      shim to it). `process.execPath` is `node`, `process.argv[1]` is the script.
+ *      Relaunch as `node <entry> <sub…>`.
+ *   2. **Bun standalone binary** (#315) — `agents` is a compiled Mach-O/ELF/PE.
+ *      `process.execPath` is the physical signed binary, and `process.argv[1]` is
+ *      the *virtual* embedded entry `/$bunfs/root/agents`, which Bun reports as an
+ *      existing path. Passing that virtual path as an argv element makes the CLI
+ *      receive it as a subcommand and die with `unknown command '/$bunfs/root/agents'`.
+ *      Relaunch by executing the physical binary directly: `<binary> <sub…>`.
+ *
+ * Both `getDaemonLaunch` (daemon.ts) and the secrets-broker `cliSpawn`
+ * (secrets/agent.ts) route through here so the two never drift. This module is a
+ * leaf — it imports nothing from `lib/` — so it can be pulled into either without
+ * an import cycle (daemon.ts ↔ secrets/agent.ts already form one).
+ */
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+export 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. 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(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(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 runningEntry;
+    }
+    try {
+        return execFileSync('which', ['agents'], { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'agents';
+    }
+}
+/**
+ * A CLI entry must be launched through the Node runtime when it is a Node
+ * script — a `.js`/`.cjs`/`.mjs` file, OR a symlink/extension-less shim whose
+ * shebang names `node`. Package installs link `bin/agents` to a `dist/index.js`
+ * (a symlink) or drop an extension-less `#!/usr/bin/env node` shim, so an
+ * extension check alone misses them and they get run directly. A real compiled
+ * binary (Mach-O/ELF/PE) has no `#!node` shebang, so it takes the direct branch
+ * and owns its own runtime resolution.
+ */
+export function isNodeScriptEntry(agentsBin) {
+    let resolved = agentsBin;
+    try {
+        resolved = fs.realpathSync(agentsBin);
+    }
+    catch {
+        // Unresolvable (e.g. a template path that does not exist on this box): fall
+        // back to the extension check on the path as given.
+    }
+    if (/\.(c|m)?js$/.test(resolved))
+        return true;
+    try {
+        const fd = fs.openSync(resolved, 'r');
+        try {
+            const buf = Buffer.alloc(128);
+            const n = fs.readSync(fd, buf, 0, 128, 0);
+            const firstLine = buf.toString('utf-8', 0, n).split('\n', 1)[0];
+            return firstLine.startsWith('#!') && /\bnode\b/.test(firstLine);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build the `{ command, args }` to re-invoke this CLI with `sub` as its argv,
+ * resolving the JS-vs-standalone shape above. This is the single primitive behind
+ * both the daemon launch and the secrets-broker spawn — never hand-roll
+ * `[process.execPath, process.argv[1], …]`, which appends the bun virtual entry
+ * as a bogus subcommand on standalone builds.
+ */
+export function getCliLaunch(sub, agentsBin = getAgentsBinPath()) {
+    // Resolve a bun virtual entry to the physical executable even when a caller
+    // passes agentsBin explicitly (getAgentsBinPath already does this for the
+    // default), so a `/$bunfs/root/agents` never becomes the command or an argv.
+    const bin = resolveBunStandaloneEntry(agentsBin, process.execPath);
+    if (isNodeScriptEntry(bin)) {
+        return { command: process.execPath, args: [bin, ...sub] };
+    }
+    return { command: bin, args: [...sub] };
+}

package/dist/lib/daemon.d.ts

@@ -6,6 +6,7 @@
  * (macOS), systemd (Linux), or as a plain detached process. PID tracking,
  * log output, reload (SIGHUP), and graceful shutdown are handled here.
  */
+import { getAgentsBinPath } from './cli-entry.js';
 /** Read the stored daemon PID from disk. Returns null if not present or invalid. */
 export declare function readDaemonPid(): number | null;
 /** Write the daemon PID to the pid file. */
@@ -101,7 +102,7 @@ export declare function generateLaunchdPlist(agentsBin?: string): string;
  * store and never touches the unit file.
  */
 export declare function generateSystemdUnit(agentsBin?: string): string;
-export declare function getAgentsBinPath(argv1?: string | undefined, execPath?: string): string;
+export { getAgentsBinPath };
 /** Start the daemon via launchd, systemd, or as a detached process. */
 export declare function startDaemon(agentsBin?: string): {
     pid: number | null;
@@ -201,4 +202,3 @@ export declare function getDaemonStatus(): {
 export declare function readDaemonLog(lines?: number): string;
 /** Send SIGHUP to the daemon to trigger a job reload. */
 export declare function signalDaemonReload(): boolean;
-export {};

package/dist/lib/daemon.js

@@ -21,6 +21,7 @@ import { BrowserService } from './browser/service.js';
 import { BrowserIPCServer } from './browser/ipc.js';
 import { readAndResolveBundleEnv } from './secrets/bundles.js';
 import { redactSecrets } from './redact.js';
+import { getAgentsBinPath, getCliLaunch, BUN_VIRTUAL_ROOT } from './cli-entry.js';
 const PID_FILE = 'daemon.pid';
 const LOCK_FILE = 'daemon.lock';
 const LOG_FILE = 'logs.jsonl';
@@ -781,47 +782,11 @@ Environment=PATH=${daemonNodeBinDir()}:/usr/local/bin:/usr/bin:/bin
 [Install]
 WantedBy=default.target`;
 }
-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. 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(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(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 runningEntry;
-    }
-    try {
-        return execFileSync('which', ['agents'], { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return 'agents';
-    }
-}
+// Binary-resolution helpers (getAgentsBinPath / isNodeScriptEntry / getCliLaunch)
+// live in ./cli-entry.js — a leaf module the secrets broker also imports without
+// forming a cycle. Re-exported so existing `from './daemon.js'` importers of
+// getAgentsBinPath keep resolving.
+export { getAgentsBinPath };
 /**
  * Ask the service manager for the daemon's live PID. Used as a fallback when
  * the daemon hasn't yet written its pid file but launchd/systemd already report
@@ -980,49 +945,7 @@ export function getDaemonLaunch(agentsBin = getAgentsBinPath()) {
     const { warnings } = validateDaemonBinary(agentsBin);
     for (const w of warnings)
         process.stderr.write(`[agents] ${w}\n`);
-    if (isNodeScriptEntry(agentsBin)) {
-        return { command: process.execPath, args: [agentsBin, 'daemon', '_run'] };
-    }
-    return { command: agentsBin, args: ['daemon', '_run'] };
-}
-/**
- * A daemon entry must be launched through the Node runtime when it is a Node
- * script — a `.js`/`.cjs`/`.mjs` file, OR a symlink/extension-less shim whose
- * shebang names `node`. Package installs link `bin/agents` to a `dist/index.js`
- * (a symlink) or drop an extension-less `#!/usr/bin/env node` shim, so an
- * extension check alone misses them and they get run directly. Executing such an
- * entry then relies on the shebang resolving `node` off the daemon's PATH — and
- * when that PATH points at a pruned nvm version (or an ancient system node), the
- * daemon crash-loops at import (`node:util` has no `styleText` on Node 18). A
- * real compiled binary (Mach-O/ELF/PE) has no `#!node` shebang, so it takes the
- * direct branch and owns its own runtime resolution.
- */
-function isNodeScriptEntry(agentsBin) {
-    let resolved = agentsBin;
-    try {
-        resolved = fs.realpathSync(agentsBin);
-    }
-    catch {
-        // Unresolvable (e.g. a template path that does not exist on this box): fall
-        // back to the extension check on the path as given.
-    }
-    if (/\.(c|m)?js$/.test(resolved))
-        return true;
-    try {
-        const fd = fs.openSync(resolved, 'r');
-        try {
-            const buf = Buffer.alloc(128);
-            const n = fs.readSync(fd, buf, 0, 128, 0);
-            const firstLine = buf.toString('utf-8', 0, n).split('\n', 1)[0];
-            return firstLine.startsWith('#!') && /\bnode\b/.test(firstLine);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-    }
-    catch {
-        return false;
-    }
+    return getCliLaunch(['daemon', '_run'], agentsBin);
 }
 /**
  * The directory of the Node runtime that generated this service manifest, kept
@@ -1050,11 +973,7 @@ function daemonNodeBinDir() {
  * 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 };
+    return getCliLaunch(subArgs, agentsBin);
 }
 export function validateDaemonBinary(binPath) {
     const warnings = [];

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

@@ -24,6 +24,17 @@ export interface FleetRunResult {
     /** Truncated combined stderr/stdout for failures. */
     detail?: string;
 }
+export interface FanOutDeviceTarget {
+    name: string;
+    skip?: FleetSkipReason | string;
+}
+export interface FanOutDeviceResult<T> {
+    name: string;
+    status: 'ok' | 'failed' | 'skipped';
+    value?: T;
+    error?: string;
+    reason?: FleetSkipReason | string;
+}
 /**
  * Classify each registered device for a fleet operation.
  *
@@ -34,6 +45,16 @@ export interface FleetRunResult {
  *   it has a registry address — same path as any other box).
  */
 export declare function planFleetTargets(reg: DeviceRegistry): FleetTarget[];
+/**
+ * Remote fan-out targets for the fleet health/drift gates (`fleet status`,
+ * `check --devices`): every planned device except this machine and control-only
+ * cockpits. A control device never runs agents (mirrors doctor's fan-out, which
+ * drops it via `isControlDevice`), so counting it as unreachable/drift would make
+ * the CI gate fail on every run for a fleet that merely has a cockpit registered.
+ * Offline / no-address devices are kept — those are genuine faults a gate should
+ * surface — so their `skip` reason still flows through as an `unreachable` row.
+ */
+export declare function remoteFleetTargets(planned: FleetTarget[], self: string): FleetTarget[];
 /** Human label for a skip reason. */
 export declare function skipLabel(reason: FleetSkipReason): string;
 /**
@@ -61,3 +82,5 @@ export declare function upgradeCommand(version?: string): string[];
  * the runner are recorded as `failed` so one bad device never aborts the rest.
  */
 export declare function runFleet(targets: FleetTarget[], cmd: string[], runner?: typeof runOnDevice): FleetRunResult[];
+/** Run one async probe per device in parallel, preserving input order. */
+export declare function fanOutDevices<T, Target extends FanOutDeviceTarget = FanOutDeviceTarget>(targets: Target[], probe: (target: Target) => Promise<T>): Promise<FanOutDeviceResult<T>[]>;