@phnx-labs/agents-cli 1.20.67 → 1.20.69

package/dist/index.js

@@ -50,7 +50,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadMonitors, loadRun, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadShare, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadMonitors, loadRun, loadFork, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadShare, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { emit, redactArgs } from './lib/events.js';
@@ -690,6 +690,7 @@ async function registerAllEagerCommands() {
     await reg(loadRoutines);
     await reg(loadMonitors);
     await reg(loadRun);
+    await reg(loadFork);
     await reg(loadDefaults);
     await reg(loadModels);
     await reg(loadPrune);

package/dist/lib/agents.d.ts

@@ -139,13 +139,25 @@ 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;
+/** Agents whose local credential formats expose enough state for account selection. */
+export declare const ACCOUNT_INSPECTION_AGENT_IDS: readonly ["claude", "codex", "gemini", "grok", "antigravity", "kimi", "droid", "opencode"];
+/** Whether agents-cli can determine this agent's per-version sign-in state. */
+export declare function supportsAccountInspection(agentId: AgentId): boolean;
+/**
+ * Human-readable account identity shared by every account-aware surface.
+ * Prefer email, append a multi-seat Claude organization name when present,
+ * then fall back to a non-secret account id or a generic signed-in label.
+ */
+export declare function accountDisplayLabel(info?: Pick<AccountInfo, 'email' | 'accountId' | 'signedIn' | 'organizationType' | 'organizationName'> | null): string;
 /** Return the email address associated with the agent's auth config, or null. */
 export declare function getAccountEmail(agentId: AgentId, home?: string): Promise<string | null>;
 /** Decrypted contents of Droid's auth.v2.file (subset we consume). */
@@ -303,6 +315,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,51 @@ 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;
+}
+/** Agents whose local credential formats expose enough state for account selection. */
+export const ACCOUNT_INSPECTION_AGENT_IDS = [
+    'claude',
+    'codex',
+    'gemini',
+    'grok',
+    'antigravity',
+    'kimi',
+    'droid',
+    'opencode',
+];
+const ACCOUNT_INSPECTION_AGENTS = new Set(ACCOUNT_INSPECTION_AGENT_IDS);
+/** Whether agents-cli can determine this agent's per-version sign-in state. */
+export function supportsAccountInspection(agentId) {
+    return ACCOUNT_INSPECTION_AGENTS.has(agentId);
+}
+/**
+ * Human-readable account identity shared by every account-aware surface.
+ * Prefer email, append a multi-seat Claude organization name when present,
+ * then fall back to a non-secret account id or a generic signed-in label.
+ */
+export function accountDisplayLabel(info) {
+    if (!info)
+        return '';
+    if (info.email) {
+        const badge = accountOrgBadge(info);
+        return badge ? `${info.email} (${badge})` : info.email;
+    }
+    if (info.signedIn)
+        return info.accountId ? `id:${info.accountId}` : 'signed in';
+    return '';
 }
 /** Return the email address associated with the agent's auth config, or null. */
 export async function getAccountEmail(agentId, home) {
@@ -1321,19 +1352,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 +2229,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/auth-health.d.ts

@@ -0,0 +1,103 @@
+import { type AccountInfo } from './agents.js';
+import type { AgentId } from './types.js';
+import { type ProviderProbe } from './usage.js';
+/**
+ * - `live`        — completed an authenticated request (200).
+ * - `revoked`     — the server rejected the token (401/403).
+ * - `expired`     — locally-detected expiry; not network-verified (no refresh on the read path).
+ * - `rate_limited`— token works but is throttled right now (429).
+ * - `unverified`  — credential present, not locally expired, but this agent has no in-repo probe endpoint (codex/grok).
+ * - `unconfigured`— no usable credential on disk.
+ * - `error`       — network/other failure; verdict indeterminate (keep the last known one).
+ */
+export type AuthVerdict = 'live' | 'revoked' | 'expired' | 'rate_limited' | 'unverified' | 'unconfigured' | 'error';
+export interface AuthHealth {
+    verdict: AuthVerdict;
+    /** epoch ms of the probe. */
+    checkedAt: number;
+    /** optional short human detail (e.g. "HTTP 401", a network error). */
+    detail?: string;
+    /** account label for display (email / id), when known. Never part of the key. */
+    account?: string;
+}
+/** Agents with a live network probe wired up today. The rest are best-effort. */
+export declare const LIVE_PROBE_AGENTS: ReadonlySet<AgentId>;
+/** Map an HTTP status from a live probe to a verdict. */
+export declare function classifyHttpStatus(status: number): AuthVerdict;
+/** Turn a raw provider probe (from usage.ts) into a verdict. */
+export declare function verdictFromProbe(probe: ProviderProbe): AuthVerdict;
+/** A short human detail line for a probe result (rendered under --verbose). */
+export declare function probeDetail(probe: ProviderProbe): string | undefined;
+/** Uncolored glyph for a verdict (color is applied by the caller). */
+export declare function verdictGlyph(verdict: AuthVerdict): string;
+/** One-word label for matrices/verbose output. */
+export declare function verdictLabel(verdict: AuthVerdict): string;
+/** Roll a set of verdicts (one host×agent's installs) into counts for a matrix cell. */
+export interface VerdictSummary {
+    live: number;
+    /** revoked — the server rejected the token (401/403). Genuinely needs re-login. */
+    bad: number;
+    /**
+     * expired / rate_limited / unverified / error — degraded or unknown, but NOT
+     * "re-login now". `expired` is soft for kimi/droid (their CLIs refresh the
+     * token on next launch; we don't refresh on the read path), so it must not be
+     * lumped with revoked or we'd cry wolf on a self-healing token.
+     */
+    warn: number;
+    total: number;
+}
+export declare function summarizeVerdicts(verdicts: AuthVerdict[]): VerdictSummary;
+/** Verdicts that mean "this token was rejected by the server — re-login required". */
+export declare function isDeadVerdict(verdict: AuthVerdict): boolean;
+/** Human "3m ago" style age for a checkedAt timestamp. */
+export declare function formatCheckedAge(checkedAt: number, now?: number): string;
+/**
+ * Human account label for display (email, else id). NOT used in the cache key —
+ * two installs on one host can hold the same account with independently valid
+ * tokens, so the key is keyed by version (below), not account.
+ */
+export declare function authAccountLabel(info: Pick<AccountInfo, 'email' | 'accountId' | 'userId'> | null | undefined): string | undefined;
+/** Cache key: one entry per install — (host, agent, version). Unique per token. */
+export declare function authCacheKey(host: string, agent: AgentId | string, version: string): string;
+/** Read the whole cache (best-effort; a corrupt/missing file yields an empty map). */
+export declare function readAuthHealthCache(): Record<string, AuthHealth>;
+/** Read one entry, or null. */
+export declare function readAuthHealth(host: string, agent: AgentId | string, version: string): AuthHealth | null;
+/**
+ * Merge entries into the cache. An incoming `error` verdict (a network blip,
+ * not a server rejection) is indeterminate, so it must NOT clobber a prior
+ * known verdict — otherwise one 8s timeout flips a `live` chip to `error`,
+ * exactly the "cry wolf" the verdict model avoids for `expired`. This is the
+ * behaviour promised by the `error` doc on AuthVerdict ("keep the last known
+ * one"). Pure, so it's unit-tested directly. */
+export declare function mergeAuthHealthEntries(current: Record<string, AuthHealth>, incoming: Record<string, AuthHealth>): Record<string, AuthHealth>;
+/** Merge one or more entries into the cache (best-effort write). */
+export declare function writeAuthHealthEntries(entries: Record<string, AuthHealth>): void;
+/**
+ * Complete a live auth probe for one (agent, home). For claude/kimi/droid this
+ * hits the provider; for everyone else it reports a best-effort local verdict
+ * (`unverified` when a credential is present, `unconfigured` otherwise) — never
+ * masquerading as `live`.
+ */
+export declare function probeAuthHealth(agent: AgentId, home: string | undefined, opts?: {
+    cliVersion?: string | null;
+    info?: AccountInfo | null;
+}): Promise<AuthHealth>;
+/** One probed install on a host. */
+export interface AuthProbeRow {
+    agent: AgentId;
+    version: string;
+    account?: string;
+    health: AuthHealth;
+}
+/**
+ * Enumerate every installed (agent, version) on THIS host, probe each in
+ * parallel, and return the rows (installs with no credential at all are
+ * dropped). Shared by `agents fleet ping --local` and the daemon refresh.
+ */
+export declare function probeLocalFleetAuth(opts?: {
+    cliVersion?: string | null;
+    agents?: readonly AgentId[];
+}): Promise<AuthProbeRow[]>;
+/** Persist a host's probed rows into the cache (keyed by host+agent+version). */
+export declare function writeFleetAuthRows(host: string, rows: AuthProbeRow[]): void;

package/dist/lib/auth-health.js

@@ -0,0 +1,232 @@
+/**
+ * Live auth-health: does an agent account's stored credential actually complete
+ * an authenticated request right now?
+ *
+ * The rest of the CLI reports "signed in" from a local heuristic — a credential
+ * file is present and its email decodes — which cannot distinguish a good token
+ * from a revoked-but-unexpired one. This module completes a real request per
+ * (agent, account) and records the verdict in a small cache that `agents view`,
+ * `agents fleet status`, and the run rotation all read. The daemon and
+ * `agents fleet ping` are the writers; everyone else reads.
+ *
+ * The network probes themselves live in lib/usage.ts (where the per-provider
+ * token loaders + endpoints already are); this module classifies their result,
+ * covers the best-effort (non-networked) providers, and owns the cache.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ALL_AGENT_IDS, getAccountInfo } from './agents.js';
+import { getCacheDir } from './state.js';
+import { probeClaudeStatus, probeDroidStatus, probeKimiStatus, } from './usage.js';
+import { getVersionHomePath, listInstalledVersions } from './versions.js';
+/** Agents with a live network probe wired up today. The rest are best-effort. */
+export const LIVE_PROBE_AGENTS = new Set(['claude', 'kimi', 'droid']);
+// ---------------------------------------------------------------------------
+// Pure classifiers / render (unit-tested; no network, no fs)
+// ---------------------------------------------------------------------------
+/** Map an HTTP status from a live probe to a verdict. */
+export function classifyHttpStatus(status) {
+    if (status >= 200 && status < 300)
+        return 'live';
+    if (status === 401 || status === 403)
+        return 'revoked';
+    if (status === 429)
+        return 'rate_limited';
+    return 'error';
+}
+/** Turn a raw provider probe (from usage.ts) into a verdict. */
+export function verdictFromProbe(probe) {
+    if (probe.token === 'missing')
+        return 'unconfigured';
+    if (probe.token === 'expired')
+        return 'expired';
+    if (probe.status == null)
+        return 'error';
+    return classifyHttpStatus(probe.status);
+}
+/** A short human detail line for a probe result (rendered under --verbose). */
+export function probeDetail(probe) {
+    if (probe.status != null && (probe.status < 200 || probe.status >= 300))
+        return `HTTP ${probe.status}`;
+    if (probe.error)
+        return probe.error;
+    return undefined;
+}
+const VERDICT_GLYPHS = {
+    live: '●', // ●
+    revoked: '○', // ○
+    expired: '○', // ○
+    rate_limited: '◐', // ◐
+    unverified: '◐', // ◐
+    unconfigured: '·', // ·
+    error: '·', // ·
+};
+/** Uncolored glyph for a verdict (color is applied by the caller). */
+export function verdictGlyph(verdict) {
+    return VERDICT_GLYPHS[verdict] ?? '·';
+}
+/** One-word label for matrices/verbose output. */
+export function verdictLabel(verdict) {
+    switch (verdict) {
+        case 'live': return 'live';
+        case 'revoked': return 'revoked';
+        case 'expired': return 'expired';
+        case 'rate_limited': return 'limited';
+        case 'unverified': return 'unverified';
+        case 'unconfigured': return '—';
+        case 'error': return '?';
+    }
+}
+export function summarizeVerdicts(verdicts) {
+    let live = 0;
+    let bad = 0;
+    let warn = 0;
+    for (const v of verdicts) {
+        if (v === 'live')
+            live++;
+        else if (v === 'revoked')
+            bad++;
+        else
+            warn++;
+    }
+    return { live, bad, warn, total: verdicts.length };
+}
+/** Verdicts that mean "this token was rejected by the server — re-login required". */
+export function isDeadVerdict(verdict) {
+    return verdict === 'revoked';
+}
+/** Human "3m ago" style age for a checkedAt timestamp. */
+export function formatCheckedAge(checkedAt, now = Date.now()) {
+    const secs = Math.max(0, Math.round((now - checkedAt) / 1000));
+    if (secs < 60)
+        return `${secs}s ago`;
+    const mins = Math.round(secs / 60);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.round(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.round(hours / 24)}d ago`;
+}
+// ---------------------------------------------------------------------------
+// Cache identity + IO (single source of truth read by view/fleet/rotation)
+// ---------------------------------------------------------------------------
+/**
+ * Human account label for display (email, else id). NOT used in the cache key —
+ * two installs on one host can hold the same account with independently valid
+ * tokens, so the key is keyed by version (below), not account.
+ */
+export function authAccountLabel(info) {
+    return info?.email || info?.accountId || info?.userId || undefined;
+}
+/** Cache key: one entry per install — (host, agent, version). Unique per token. */
+export function authCacheKey(host, agent, version) {
+    return `${host}:${agent}:${version}`;
+}
+function cacheFilePath() {
+    return path.join(getCacheDir(), '.auth-health.json');
+}
+/** Read the whole cache (best-effort; a corrupt/missing file yields an empty map). */
+export function readAuthHealthCache() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cacheFilePath(), 'utf-8'));
+        if (parsed && parsed.entries && typeof parsed.entries === 'object')
+            return parsed.entries;
+    }
+    catch {
+        // missing or corrupt — treat as empty
+    }
+    return {};
+}
+/** Read one entry, or null. */
+export function readAuthHealth(host, agent, version) {
+    return readAuthHealthCache()[authCacheKey(host, agent, version)] ?? null;
+}
+/**
+ * Merge entries into the cache. An incoming `error` verdict (a network blip,
+ * not a server rejection) is indeterminate, so it must NOT clobber a prior
+ * known verdict — otherwise one 8s timeout flips a `live` chip to `error`,
+ * exactly the "cry wolf" the verdict model avoids for `expired`. This is the
+ * behaviour promised by the `error` doc on AuthVerdict ("keep the last known
+ * one"). Pure, so it's unit-tested directly. */
+export function mergeAuthHealthEntries(current, incoming) {
+    const merged = { ...current };
+    for (const [key, health] of Object.entries(incoming)) {
+        if (health.verdict === 'error' && merged[key])
+            continue; // keep last known
+        merged[key] = health;
+    }
+    return merged;
+}
+/** Merge one or more entries into the cache (best-effort write). */
+export function writeAuthHealthEntries(entries) {
+    try {
+        const dir = getCacheDir();
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const merged = {
+            version: 1,
+            entries: mergeAuthHealthEntries(readAuthHealthCache(), entries),
+        };
+        fs.writeFileSync(cacheFilePath(), JSON.stringify(merged, null, 2));
+    }
+    catch {
+        // best-effort; a failed write just means the next reader falls back to heuristics
+    }
+}
+// ---------------------------------------------------------------------------
+// The probe (writer side)
+// ---------------------------------------------------------------------------
+/**
+ * Complete a live auth probe for one (agent, home). For claude/kimi/droid this
+ * hits the provider; for everyone else it reports a best-effort local verdict
+ * (`unverified` when a credential is present, `unconfigured` otherwise) — never
+ * masquerading as `live`.
+ */
+export async function probeAuthHealth(agent, home, opts) {
+    const checkedAt = Date.now();
+    if (LIVE_PROBE_AGENTS.has(agent)) {
+        let probe;
+        if (agent === 'claude')
+            probe = await probeClaudeStatus(home, opts?.cliVersion);
+        else if (agent === 'kimi')
+            probe = await probeKimiStatus(home);
+        else
+            probe = await probeDroidStatus(home);
+        return { verdict: verdictFromProbe(probe), checkedAt, detail: probeDetail(probe) };
+    }
+    const info = opts?.info !== undefined ? opts.info : await getAccountInfo(agent, home).catch(() => null);
+    return { verdict: info?.signedIn ? 'unverified' : 'unconfigured', checkedAt };
+}
+/**
+ * Enumerate every installed (agent, version) on THIS host, probe each in
+ * parallel, and return the rows (installs with no credential at all are
+ * dropped). Shared by `agents fleet ping --local` and the daemon refresh.
+ */
+export async function probeLocalFleetAuth(opts) {
+    const agentIds = opts?.agents ?? ALL_AGENT_IDS;
+    const tasks = [];
+    for (const agent of agentIds) {
+        for (const version of listInstalledVersions(agent)) {
+            const home = getVersionHomePath(agent, version);
+            tasks.push((async () => {
+                const info = await getAccountInfo(agent, home).catch(() => null);
+                const health = await probeAuthHealth(agent, home, { cliVersion: opts?.cliVersion, info });
+                health.account = authAccountLabel(info);
+                if (health.verdict === 'unconfigured')
+                    return null;
+                return { agent, version, account: health.account, health };
+            })());
+        }
+    }
+    const settled = await Promise.all(tasks);
+    return settled.filter((r) => r !== null);
+}
+/** Persist a host's probed rows into the cache (keyed by host+agent+version). */
+export function writeFleetAuthRows(host, rows) {
+    const entries = {};
+    for (const row of rows) {
+        entries[authCacheKey(host, row.agent, row.version)] = row.health;
+    }
+    writeAuthHealthEntries(entries);
+}

package/dist/lib/browser/chrome.d.ts

@@ -24,6 +24,15 @@ export declare function findFirstInstalledBrowser(platform?: string): {
     browserType: BrowserType;
     binary: string;
 } | null;
+/**
+ * List every installed Chromium-family browser on this machine, in the platform
+ * priority order. Used by `agents setup browser` to offer a pick when more than
+ * one is present. Returns [] if none are installed.
+ */
+export declare function listInstalledBrowsers(platform?: string): {
+    browserType: BrowserType;
+    binary: string;
+}[];
 export interface LaunchResult {
     pid: number;
     port: number;

package/dist/lib/browser/chrome.js

@@ -203,6 +203,28 @@ export function findFirstInstalledBrowser(platform = os.platform()) {
     }
     return null;
 }
+/**
+ * List every installed Chromium-family browser on this machine, in the platform
+ * priority order. Used by `agents setup browser` to offer a pick when more than
+ * one is present. Returns [] if none are installed.
+ */
+export function listInstalledBrowsers(platform = os.platform()) {
+    const priority = DEFAULT_BROWSER_PRIORITY[platform];
+    const platformPaths = BROWSER_PATHS[platform];
+    if (!priority || !platformPaths)
+        return [];
+    const found = [];
+    for (const browserType of priority) {
+        const candidates = platformPaths[browserType] || [];
+        for (const p of candidates) {
+            if (fs.existsSync(p)) {
+                found.push({ browserType, binary: resolveBrowserBinary(p) });
+                break; // one install path per browser type is enough
+            }
+        }
+    }
+    return found;
+}
 export async function launchBrowser(profileName, browserType, port, options = {}, secrets, customBinary, 
 // `electron: true` distinguishes Notion / VS Code-style apps from
 // regular Chrome — purely informational, stored in meta.json so the

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[];
+};