@phnx-labs/agents-cli 1.20.66 → 1.20.68

package/dist/commands/ssh.js

@@ -15,6 +15,7 @@ import * as os from 'os';
 import * as path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
+import { getCliVersion } from '../lib/version.js';
 import { readAndResolveBundleEnv, isHeadlessSecretsContext } from '../lib/secrets/bundles.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, } from '../lib/devices/registry.js';
@@ -28,8 +29,13 @@ import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { hostNameFor, renderSshConfig } from '../lib/devices/ssh-config.js';
 import { ASKPASS_BUNDLE_ENV, ASKPASS_KEY_ENV, buildSshInvocation, writeAskpassShim, } from '../lib/devices/connect.js';
 import { ensureManagedKnownHostsDir, isHostPinned } from '../lib/devices/known-hosts.js';
-import { planFleetTargets, runFleet, skipLabel, upgradeCommand, } from '../lib/devices/fleet.js';
-import { fleetCapacity, fmtBytes, headroom, probeFleetStats, } from '../lib/devices/health.js';
+import { fanOutDevices, planFleetTargets, remoteFleetTargets, runFleet, skipLabel, upgradeCommand, } from '../lib/devices/fleet.js';
+import { fleetCapacity, fmtBytes, headroom, probeLocalStats, probeFleetStats, } from '../lib/devices/health.js';
+import { buildFleetHealthReport, renderFleetMatrix, renderFleetWarnings, } from '../lib/devices/health-report.js';
+import { checkSyncStatus, countOrphans } from '../lib/drift.js';
+import { checkAllClis } from '../lib/teams/agents.js';
+import { buildRemoteAgentsInvocation } from '../lib/hosts/remote-cmd.js';
+import { sshExecAsync } from '../lib/ssh-exec.js';
 /** One-line summary of a device for `list`. `isSelf` marks the machine this
  * command is running on so it stands out from the rest of the tailnet. */
 function deviceSummary(d, isSelf = false) {
@@ -219,6 +225,92 @@ function printFleetResults(results) {
     if (failed > 0)
         process.exitCode = 1;
 }
+function localHealthRow(self, stats) {
+    return {
+        name: self,
+        platform: process.platform === 'darwin' ? 'macos' : process.platform,
+        version: getCliVersion(),
+        stats,
+        clis: checkAllClis(),
+        sync: checkSyncStatus(process.cwd()),
+        orphans: countOrphans(),
+    };
+}
+async function probeRemoteHealth(target) {
+    const isWin = /^win/i.test((target.platform ?? '').trim());
+    const env = isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' };
+    const versionCmd = buildRemoteAgentsInvocation(['--version'], undefined, isWin ? 'windows' : undefined, env);
+    const versionRes = await sshExecAsync(target.name, versionCmd, { timeoutMs: 15000, multiplex: true });
+    const version = versionRes.code === 0 ? versionRes.stdout.trim().split(/\s+/)[0] || null : null;
+    const doctorCmd = buildRemoteAgentsInvocation(['doctor', '--json'], undefined, isWin ? 'windows' : undefined, env);
+    const doctorRes = await sshExecAsync(target.name, doctorCmd, { timeoutMs: 30000, multiplex: true });
+    if (doctorRes.code !== 0) {
+        throw new Error(doctorRes.timedOut ? 'timed out' : (doctorRes.stderr.trim() || `exit ${doctorRes.code ?? 'unknown'}`));
+    }
+    const parsed = JSON.parse(doctorRes.stdout);
+    return {
+        version,
+        clis: parsed.clis ?? {},
+        sync: parsed.sync ?? [],
+        orphans: parsed.orphans ?? [],
+    };
+}
+async function runFleetStatus(opts) {
+    const reg = await loadDevices();
+    const self = machineId();
+    const planned = planFleetTargets(reg);
+    const probeable = planned.filter((t) => !t.skip).map((t) => t.device);
+    const statsMap = opts.stats === false
+        ? new Map()
+        : await probeFleetStats(probeable, { selfName: self });
+    if (opts.stats !== false && !statsMap.has(self)) {
+        statsMap.set(self, await probeLocalStats(self));
+    }
+    const rows = [localHealthRow(self, statsMap.get(self))];
+    const remoteTargets = remoteFleetTargets(planned, self)
+        .map((t) => ({
+        name: t.device.name,
+        platform: t.device.platform,
+        skip: t.skip,
+    }));
+    const remote = await fanOutDevices(remoteTargets, probeRemoteHealth);
+    for (const result of remote) {
+        const profile = reg[result.name];
+        if (result.status === 'ok' && result.value) {
+            rows.push({
+                name: result.name,
+                platform: profile?.platform,
+                stats: statsMap.get(result.name),
+                ...result.value,
+            });
+        }
+        else {
+            rows.push({
+                name: result.name,
+                platform: profile?.platform,
+                stats: statsMap.get(result.name),
+                skipped: result.reason ? String(result.reason) : undefined,
+                error: result.error,
+                clis: {},
+                sync: [],
+                orphans: [],
+            });
+        }
+    }
+    const report = buildFleetHealthReport(rows);
+    if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        for (const line of renderFleetWarnings(report))
+            console.log(line);
+        console.log();
+        for (const line of renderFleetMatrix(report))
+            console.log(line);
+    }
+    if (opts.strict && report.hasWarnings)
+        process.exitCode = 1;
+}
 /** Register the `agents devices` command tree (also aliased as `fleet`). */
 function registerDevicesCommands(program) {
     const devicesCmd = program
@@ -346,6 +438,15 @@ Typical workflow:
         for (const line of renderDeviceTable(reg, names, self, statsMap, opts.full))
             console.log(line);
     });
+    devicesCmd
+        .command('status')
+        .description('Show fleet health: warnings rollup, per-device sync drift, CLI readiness, version skew, and resource headroom.')
+        .option('--json', 'output machine-readable JSON')
+        .option('--strict', 'exit non-zero when any device has drift or is unreachable')
+        .option('--no-stats', 'skip the live resource probe')
+        .action(async (opts) => {
+        await runFleetStatus(opts);
+    });
     devicesCmd
         .command('show <name>')
         .description('Show the full profile for one device.')

package/dist/commands/teams.d.ts

@@ -32,5 +32,16 @@ export declare function decideTeamMessageRoute(status: AgentStatus, hasMessage:
  * the teammate itself so we don't need the original --cloud CLI args.
  */
 export declare function wireCloudDispatcher(mgr: AgentManager): void;
+/**
+ * `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 declare function remoteCwdOnAddError(team: string): string;
 /** Register the `agents teams` command tree (list, create, add, status, start, remove, disband, logs, doctor). */
 export declare function registerTeamsCommands(program: Command): void;

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 {
@@ -1059,7 +1090,7 @@ export function registerTeamsCommands(program) {
         .alias('a')
         .description("Add a teammate to work on a task. Runs in background; returns immediately. Use 'status' to check in.")
         .option('-n, --name <name>', 'Friendly name for this teammate (e.g. alice). Required if using --after. Unique within team.')
-        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip.`, 'edit')
+        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/droid/opencode; kimi/grok/cursor/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
         .option('-e, --effort <effort>', `Reasoning intensity: ${VALID_EFFORTS.join('|')}`, 'medium')
         .option('--model <model>', 'Override the effort tier and use this specific model (e.g. claude-opus-4-6)')
         .option('--env <key=value>', 'Set an environment variable for this teammate (repeatable for multiple vars)', (val, prev) => [...prev, val], [])
@@ -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

@@ -505,6 +505,10 @@ export const AGENTS = {
             workflows: false,
             memory: true,
             modes: ['plan', 'edit', 'skip'],
+            // grok's `--permission-mode plan` silently stalls a headless `-p` run at
+            // its ExitPlanMode gate (no TTY to approve). Headless plan auto-downgrades
+            // to auto (→ edit via resolveMode). Interactive plan is unaffected.
+            headlessPlan: false,
             rulesImports: true,
         },
     },
@@ -544,6 +548,10 @@ export const AGENTS = {
             workflows: true,
             memory: false,
             modes: ['plan', 'edit', 'auto', 'skip'],
+            // kimi's headless `-p` refuses to combine with `--plan` (`Cannot combine
+            // --prompt with --plan`). Headless plan auto-downgrades to auto (kimi -p
+            // auto-runs). Interactive plan is unaffected.
+            headlessPlan: false,
             rulesImports: false,
         },
     },
@@ -970,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) {
@@ -1313,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
@@ -2186,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] };
+}