@phnx-labs/agents-cli 1.22.116 → 1.22.118

package/dist/lib/state.js

@@ -864,17 +864,6 @@ function writeIfChanged(filePath, content) {
     atomicWriteFileSync(filePath, content);
     return true;
 }
-/**
- * True in the always-on daemon process (launched as `agents __daemon-run`,
- * see cli/src/index.ts). The daemon owns central git commits through
- * fleet-shared-repo-sync's publish tick, so a central write from inside the
- * daemon must NOT also commit here — that would race the publisher's own
- * add/commit/rebase/push on the same index. Every ordinary CLI invocation
- * returns false and commits its own central edit synchronously.
- */
-function isDaemonProcess() {
-    return process.argv[2] === '__daemon-run';
-}
 /**
  * Commit the central `agents.yaml` in the user repo, synchronously, so a CLI
  * config mutation never leaves the working tree dirty on that one shared-line
@@ -892,8 +881,11 @@ function isDaemonProcess() {
  * never run inside the short, non-heartbeated lockfile window; the user repo
  * already pushes.
  *
- * Scoped tightly: only called when the central bytes actually changed, and never
- * from the daemon (see {@link isDaemonProcess}). A commit failure fails open —
+ * Scoped tightly: only called when the central bytes actually changed — from a
+ * CLI command and from the daemon alike, since no daemon tick commits the user
+ * repo any more (the shared-state exchange moved to SSH, PHNX-4116), so a
+ * daemon-side central write would otherwise sit dirty until the next CLI
+ * central edit. A commit failure fails open —
  * a concurrent daemon holding `index.lock`, a mid-rebase repo — leaving
  * agents.yaml dirty; the next successful central write commits it, and until
  * then a pull that would collide refuses rather than losing data. A config
@@ -1685,13 +1677,11 @@ export function updateMeta(updates) {
  * A CLI command that actually moved the fleet-shared central agents.yaml commits
  * it so the tree is never left dirty on that file at rest — the window that
  * trips `dirtyTreeRefusal` and wedges pulls fleet-wide (PHNX-3968). Gated on a
- * real byte change and never run in the daemon, whose publish tick owns central
- * commits. See {@link commitCentralConfig}.
+ * real byte change. See {@link commitCentralConfig}.
  */
 export function commitCentralConfigAfterWrite(centralChanged) {
-    if (centralChanged && !isDaemonProcess()) {
+    if (centralChanged)
         commitCentralConfig(USER_AGENTS_DIR);
-    }
 }
 /** Derive a filesystem-safe local clone path for a package source URL. */
 export function getPackageLocalPath(source) {

package/dist/lib/teams/parsers.d.ts

@@ -1,5 +1,5 @@
 /** Supported agent CLI types for team spawning. */
-export type AgentType = 'codex' | 'gemini' | 'cursor' | 'claude' | 'opencode' | 'grok' | 'antigravity' | 'kimi' | 'droid' | 'warp';
+export type AgentType = 'codex' | 'cursor' | 'claude' | 'opencode' | 'grok' | 'antigravity' | 'kimi' | 'droid' | 'warp';
 /** Normalize a raw JSON event from any agent type into an array of unified event objects. */
 export declare function normalizeEvents(agentType: AgentType, raw: any): any[];
 /** Normalize a raw JSON event, returning only the first unified event (convenience wrapper). */

package/dist/lib/teams/parsers.js

@@ -2,7 +2,7 @@
  * Agent event stream parsers.
  *
  * Normalizes the heterogeneous JSON event formats emitted by each agent CLI
- * (Claude, Codex, Gemini, Cursor, OpenCode, Grok, Antigravity, Kimi) into a unified
+ * (Claude, Codex, Cursor, OpenCode, Grok, Antigravity, Kimi) into a unified
  * event schema with consistent types: init, message, tool_use, bash,
  * file_read, file_write, file_create, file_delete, result, error, and others.
  */
@@ -18,7 +18,6 @@ const droidToolUseMap = new Map();
 const TEAM_EVENT_NORMALIZERS = {
     codex: normalizeCodex,
     cursor: normalizeCursor,
-    gemini: normalizeGemini,
     claude: normalizeClaude,
     opencode: normalizeOpencode,
     grok: normalizeGrok,
@@ -415,140 +414,6 @@ function normalizeCursor(raw) {
             timestamp: timestamp,
         }];
 }
-function normalizeGemini(raw) {
-    if (!raw || typeof raw !== 'object') {
-        return [{
-                type: 'unknown',
-                agent: 'gemini',
-                raw: raw,
-                timestamp: new Date().toISOString(),
-            }];
-    }
-    const eventType = raw?.type || 'unknown';
-    const timestamp = raw?.timestamp || new Date().toISOString();
-    if (eventType === 'init') {
-        return [{
-                type: 'init',
-                agent: 'gemini',
-                model: raw?.model,
-                session_id: raw?.session_id,
-                timestamp: timestamp,
-            }];
-    }
-    else if (eventType === 'message') {
-        const role = raw?.role || 'assistant';
-        if (role === 'assistant') {
-            return [{
-                    type: 'message',
-                    agent: 'gemini',
-                    content: raw?.content || '',
-                    complete: !raw?.delta,
-                    timestamp: timestamp,
-                }];
-        }
-        else {
-            return [{
-                    type: 'user_message',
-                    agent: 'gemini',
-                    content: raw?.content || '',
-                    timestamp: timestamp,
-                }];
-        }
-    }
-    else if (eventType === 'tool_call' || eventType === 'tool_use') {
-        const toolNameRaw = raw?.tool_name || raw?.name || 'unknown';
-        const toolName = String(toolNameRaw);
-        let toolArgsRaw = raw?.parameters;
-        if (toolArgsRaw === null || toolArgsRaw === undefined) {
-            toolArgsRaw = raw?.args;
-        }
-        const toolArgs = (typeof toolArgsRaw === 'object' && toolArgsRaw !== null) ? toolArgsRaw : {};
-        const toolNameLower = toolName.toLowerCase();
-        const filePath = toolArgs?.file_path || toolArgs?.path || '';
-        const command = toolArgs?.command || '';
-        // File write/edit tools - Gemini uses 'replace', 'edit', 'patch', 'write_file', etc.
-        const writeTools = ['replace', 'edit', 'patch', 'write_file', 'edit_file', 'update_file', 'modify_file'];
-        if (writeTools.includes(toolNameLower) || (toolNameLower.includes('write') && toolNameLower.includes('file'))) {
-            if (!filePath.trim()) {
-                return [];
-            }
-            return [{
-                    type: 'file_write',
-                    agent: 'gemini',
-                    tool: toolName,
-                    path: filePath,
-                    timestamp: timestamp,
-                }];
-        }
-        // File read tools
-        const readTools = ['read_file', 'view_file', 'cat_file', 'get_file'];
-        if (readTools.includes(toolNameLower) || (toolNameLower.includes('read') && toolNameLower.includes('file'))) {
-            if (!filePath.trim()) {
-                return [];
-            }
-            return [{
-                    type: 'file_read',
-                    agent: 'gemini',
-                    tool: toolName,
-                    path: filePath,
-                    timestamp: timestamp,
-                }];
-        }
-        // File delete tools
-        const deleteTools = ['delete_file', 'remove_file', 'rm_file'];
-        if (deleteTools.includes(toolNameLower) || (toolNameLower.includes('delete') && toolNameLower.includes('file'))) {
-            if (!filePath.trim()) {
-                return [];
-            }
-            return [{
-                    type: 'file_delete',
-                    agent: 'gemini',
-                    tool: toolName,
-                    path: filePath,
-                    timestamp: timestamp,
-                }];
-        }
-        // Shell/bash tools
-        if (['shell', 'bash', 'execute', 'run_command', 'run_shell_command'].includes(toolNameLower)) {
-            if (!command.trim()) {
-                return [];
-            }
-            return [{
-                    type: 'bash',
-                    agent: 'gemini',
-                    tool: toolName,
-                    command: command,
-                    timestamp: timestamp,
-                }];
-        }
-        return [{
-                type: 'tool_use',
-                agent: 'gemini',
-                tool: toolName,
-                args: toolArgs,
-                timestamp: timestamp,
-            }];
-    }
-    else if (eventType === 'result') {
-        const stats = raw?.stats || {};
-        return [{
-                type: 'result',
-                agent: 'gemini',
-                status: raw?.status || 'success',
-                duration_ms: stats?.duration_ms,
-                usage: {
-                    total_tokens: stats?.total_tokens || 0,
-                },
-                timestamp: timestamp,
-            }];
-    }
-    return [{
-            type: eventType,
-            agent: 'gemini',
-            raw: raw,
-            timestamp: timestamp,
-        }];
-}
 function normalizeClaude(raw) {
     const eventType = raw.type || 'unknown';
     const subtype = raw.subtype;

package/dist/lib/teams/placement-probe.js

@@ -16,12 +16,16 @@
  * of the rank stays live (the pure pick recounts the roster each call), only the
  * SSH-measured load/harness snapshot is reused within the TTL.
  *
- * All SSH here is via `execFile` (async, bounded) so the whole pool is probed in
- * parallel; a slow or wedged box degrades to "no signal" instead of blocking the
- * launch. The readiness payload is `agents view --json`, so remote and local
- * candidates carry the same installed/sign-in verdict.
+ * All SSH here is via `spawn` (async, kill-bounded) so the whole pool is probed
+ * in parallel; a slow or wedged box degrades to "no signal" instead of blocking
+ * the launch. The readiness payload is `agents view --json`, so remote and local
+ * candidates carry the same installed/sign-in verdict. The dispatcher's usage
+ * envelope rides the same round-trip on stdin (`agents __usage-ingest` runs
+ * first in the probe, PHNX-4116), so the worker the pick lands on holds current
+ * usage numbers at dispatch rather than at the next usage-sync tick.
  */
-import { execFile } from 'child_process';
+import { spawn } from 'child_process';
+import { buildFleetStatePayload } from '../accounting/usage-sync.js';
 import { probeFleetStats, headroom } from '../devices/health.js';
 import { loadDevicesSync } from '../devices/registry.js';
 import { buildSshInvocation, writeAskpassShim } from '../devices/connect.js';
@@ -51,34 +55,62 @@ export function clearPlacementSignalCache() {
  * failure) — reachability is then left to {@link probeFleetStats}; `false` when
  * the box answered but agents-cli or the agent is absent (a genuine can't-run).
  */
-function probeRemoteReadiness(device, agent) {
+function probeRemoteReadiness(device, agent, usagePayload) {
+    const unknown = { installed: undefined, signedIn: undefined, pickerEligible: undefined };
     let args;
     let env;
     try {
         const shim = writeAskpassShim();
-        const cmd = buildReadyProbeCommand(device.shell === 'powershell' ? 'windows' : undefined);
+        const cmd = buildReadyProbeCommand(device.shell === 'powershell' ? 'windows' : undefined, { ingestUsage: true });
         // agentOnly: a read-only probe must never force a foreground Touch ID sheet
         // on a password-auth device (mirrors probeDeviceStats in devices/health).
         ({ args, env } = buildSshInvocation(device, [cmd], shim, {}, { agentOnly: true }));
     }
     catch {
-        return Promise.resolve({ installed: undefined, signedIn: undefined, pickerEligible: undefined });
+        return Promise.resolve(unknown);
     }
     return new Promise((resolve) => {
-        execFile('ssh', args, { encoding: 'utf-8', env: { ...process.env, ...env }, timeout: READY_PROBE_TIMEOUT_MS }, (err, stdout) => {
-            if (err || !stdout)
-                return resolve({ installed: undefined, signedIn: undefined, pickerEligible: undefined });
+        const child = spawn('ssh', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...env },
+            windowsHide: true,
+        });
+        let stdout = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(killTimer);
+            resolve(value);
+        };
+        // A wedged box degrades to "no signal": SIGTERM at the budget, SIGKILL shortly
+        // after, so one dead peer can never hold the whole placement wave open.
+        const timer = setTimeout(() => child.kill('SIGTERM'), READY_PROBE_TIMEOUT_MS);
+        const killTimer = setTimeout(() => { if (!settled)
+            child.kill('SIGKILL'); }, READY_PROBE_TIMEOUT_MS + 250);
+        killTimer.unref?.();
+        child.stdout.setEncoding('utf-8');
+        child.stdout.on('data', (chunk) => { stdout += chunk; });
+        child.stderr.resume();
+        child.on('error', () => finish(unknown));
+        child.on('close', (code) => {
+            if (code !== 0 || !stdout)
+                return finish(unknown);
             const probe = parseReadyProbe(stdout);
             if (!probe.reachable)
-                return resolve({ installed: undefined, signedIn: undefined, pickerEligible: undefined });
+                return finish(unknown);
             if (!probe.version)
-                return resolve({ installed: false, signedIn: false, pickerEligible: false });
+                return finish({ installed: false, signedIn: false, pickerEligible: false });
             const installed = viewHasAgent(probe.view, agent);
             const eligibility = installed
                 ? viewAgentAccountEligibility(probe.view, agent)
                 : { signedIn: false, pickerEligible: false };
-            resolve({ installed, ...eligibility });
+            finish({ installed, ...eligibility });
         });
+        child.stdin.on('error', () => { });
+        child.stdin.end(usagePayload);
     });
 }
 /**
@@ -107,6 +139,9 @@ export async function probePoolSignals(pool, agent, opts = {}) {
     }
     const selfProfile = profiles.find((d) => normalizeHost(d.name) === self);
     const stats = await probeFleetStats(profiles, { selfName: selfProfile?.name });
+    // Built once per wave: this box's current usage rows (headed only — a worker
+    // dispatcher has none to give), ingested by every remote candidate it probes.
+    const usagePayload = JSON.stringify(buildFleetStatePayload({ usageOnly: true }));
     const installed = new Map(agent
         ? await Promise.all(profiles.map(async (d) => {
             const isSelf = normalizeHost(d.name) === self;
@@ -125,7 +160,7 @@ export async function probePoolSignals(pool, agent, opts = {}) {
                         pickerEligible: readiness.some((candidate) => candidate.ready || isSignInRecoverable(candidate)),
                     }];
             }
-            return [d.name, await probeRemoteReadiness(d, agent)];
+            return [d.name, await probeRemoteReadiness(d, agent, usagePayload)];
         }))
         : []);
     const signals = new Map();

package/dist/lib/teams/scheduler.d.ts

@@ -29,6 +29,13 @@ export interface DevicePlacementSignal {
     signedIn?: boolean;
     /** Requested agent has at least one row the interactive account picker can launch. */
     pickerEligible?: boolean;
+    /**
+     * The box's OWN aggregate readiness reason when it has no ready account
+     * (`runReady.reason`, e.g. `all signed_out`), so the placement error names why
+     * the remote turned itself away rather than a bare "no ready harness account"
+     * (PHNX-4116). Undefined when ready or when the remote gave no reason.
+     */
+    reason?: string;
 }
 /** Team fields the placement cascade reads (a subset of TeamMeta). */
 interface PlacementTeam {

package/dist/lib/types.d.ts

@@ -8,7 +8,7 @@
 import type { CloudProviderId } from './cloud/types.js';
 import type { FeedBroadcastConfig } from './feed-broadcast.js';
 /** Unique identifier for a current or legacy AI coding agent. */
-export declare const AGENT_IDS: readonly ["claude", "codex", "gemini", "cursor", "opencode", "openclaw", "copilot", "amp", "goose", "antigravity", "grok", "kimi", "droid", "hermes", "muse", "warp"];
+export declare const AGENT_IDS: readonly ["claude", "codex", "cursor", "opencode", "openclaw", "copilot", "amp", "goose", "antigravity", "grok", "kimi", "droid", "hermes", "muse", "warp"];
 export type AgentId = typeof AGENT_IDS[number];
 export declare function isAgentId(value: string): value is AgentId;
 /**
@@ -190,6 +190,15 @@ export interface AgentConfig {
     variableSyntax: string;
     supportsHooks: boolean;
     nativeAgentsSkillsDir?: boolean;
+    /**
+     * The harness loads a plugin's bundled skills itself, namespaced
+     * `<plugin>:<skill>`, from the plugin registration sync writes. Sync must
+     * then NOT also flatten them into top-level `skills/<name>/`: the flat copy
+     * is a second, un-namespaced registration of the same skill, so every
+     * plugin skill showed twice (`/continue` and `/sessions:continue`). Harnesses
+     * without this flag only see plugin skills through the flattened copies.
+     */
+    nativePluginSkills?: boolean;
     /**
      * This agent's *own* cloud backend. `agents cloud run --agent <id>` routes
      * here when no `--provider` is given (precedence: --provider > this >

package/dist/lib/types.js

@@ -6,7 +6,7 @@
  * formats for each supported agent.
  */
 /** Unique identifier for a current or legacy AI coding agent. */
-export const AGENT_IDS = ['claude', 'codex', 'gemini', 'cursor', 'opencode', 'openclaw', 'copilot', 'amp', 'goose', 'antigravity', 'grok', 'kimi', 'droid', 'hermes', 'muse', 'warp'];
+export const AGENT_IDS = ['claude', 'codex', 'cursor', 'opencode', 'openclaw', 'copilot', 'amp', 'goose', 'antigravity', 'grok', 'kimi', 'droid', 'hermes', 'muse', 'warp'];
 export function isAgentId(value) {
     return AGENT_IDS.includes(value);
 }

package/dist/lib/view-types.d.ts

@@ -66,6 +66,33 @@ export interface ViewJsonVersion {
     } | null;
     resources?: VersionResourcesJson;
 }
+/**
+ * Whether a `run` on THIS box would find a launch-ready account for the agent,
+ * computed from the SAME enumeration the local router uses
+ * (`collectRunCandidates` → `readinessFromCandidate`), including native slots
+ * (`fromSlot`) — NOT the per-version `versions[]` list, which enumerates version
+ * homes and misses the account slots a run actually picks from (PHNX-4116). This
+ * is the one readiness gate: `agents run --device auto` reads THIS answer off
+ * `agents view --json` rather than re-deriving freshness on the dispatching box,
+ * so the box that runs and the box that dispatches can never disagree.
+ */
+export interface ViewJsonRunReady {
+    /** At least one account is launch-ready right now. */
+    ready: boolean;
+    /**
+     * When ready, names a ready account (`ready (work)`); when not, the aggregate
+     * exclusion reason the dispatcher surfaces (`all signed_out`, `no accounts`, or
+     * a comma list of distinct reasons).
+     */
+    reason: string;
+    /** Per-account verdict; `reason` is `'ready'` for a ready account, else the
+     *  `readinessFromCandidate` reason (`signed_out`/`revoked`/`rate_limited`/…). */
+    accounts: Array<{
+        name: string;
+        ready: boolean;
+        reason: string;
+    }>;
+}
 export interface ViewJsonAgent {
     agent: AgentId;
     versions: ViewJsonVersion[];
@@ -74,6 +101,11 @@ export interface ViewJsonAgent {
      * never the internal catalog row, so consumers (AGI EXT) read one shape.
      */
     accounts?: AccountListEntryJson[];
+    /**
+     * The one run-readiness gate for this agent on this box (PHNX-4116). Absent on
+     * an older remote CLI, whose readers fall back to per-version `launchable`.
+     */
+    runReady?: ViewJsonRunReady;
     harnesses: ProfileSummary[];
 }
 export type ResourceSection = 'commands' | 'skills' | 'mcp' | 'memory' | 'hooks' | 'workflows' | 'plugins';

package/dist/lib/watchdog/read.js

@@ -35,7 +35,6 @@ const WATCHDOG_SESSION_LAYOUT = {
     claude: { subdir: 'projects', ext: '.jsonl' },
     codex: { subdir: 'sessions', ext: '.jsonl' },
     droid: { subdir: 'sessions', ext: '.jsonl' },
-    gemini: { subdir: 'tmp', ext: '.json' },
 };
 const WATCHDOG_SESSION_LAYOUT_DEFAULT = { subdir: 'projects', ext: '.jsonl' };
 /**

package/dist/lib/watchdog/rotate.js

@@ -145,7 +145,6 @@ function nextOccurrenceMs(hour, minute, timeZone, nowMs) {
 export const ROTATE_EXIT_SEQUENCES = {
     claude: ['\x1b', '\x03', '\x03'], // Esc, Ctrl+C, Ctrl+C (Esc first for Claude)
     codex: ['\x03', '\x03'], // Ctrl+C twice
-    gemini: ['\x03', '\x03'],
     cursor: ['\x03', '\x03'],
     opencode: ['\x03', '\x03'],
 };
@@ -314,7 +313,7 @@ export async function defaultRotateGate() {
 }
 // --- readiness --------------------------------------------------------------------
 /** Transcript layouts to probe for the new session (mirrors read.ts's table). */
-const ROTATE_TRANSCRIPT_AGENTS = ['claude', 'codex', 'gemini', 'droid'];
+const ROTATE_TRANSCRIPT_AGENTS = ['claude', 'codex', 'droid'];
 /**
  * Default TUI-liveness probe for the relaunched session: the new session's
  * transcript resolves under any known harness layout. `--session-id` is honored

package/dist/lib/watchdog/runner.js

@@ -379,7 +379,7 @@ export async function runWatchdogTick(opts = {}) {
             session,
             candidate: {
                 terminalId: sid,
-                agentType: session.kind === 'codex' || session.kind === 'gemini' ? session.kind : 'claude',
+                agentType: session.kind === 'codex' ? 'codex' : 'claude',
                 tailLines: tail,
                 stalledForMs: st.stalledForMs,
                 task: session.topic ?? session.label ?? session.name,
@@ -502,7 +502,7 @@ export async function runWatchdogTick(opts = {}) {
         const tailLines = tailCache.get(session.sessionId) ?? tailFor(session);
         const candidate = {
             terminalId: session.sessionId,
-            agentType: (session.kind === 'codex' || session.kind === 'gemini' ? session.kind : 'claude'),
+            agentType: (session.kind === 'codex' ? 'codex' : 'claude'),
             tailLines,
             stalledForMs: status.stalledForMs,
         };

package/dist/lib/watchdog/watchdog.d.ts

@@ -1,6 +1,6 @@
 export interface WatchdogCandidate {
     terminalId: string;
-    agentType: 'claude' | 'codex' | 'gemini';
+    agentType: 'claude' | 'codex';
     tailLines: string[];
     stalledForMs: number;
     /** The originating task / first prompt / topic — so the agent can judge "was given a task but hasn't finished it". */

package/dist/lib/watchdog/watchdogTail.js

@@ -32,13 +32,6 @@ export function summarizeWatchdogTail(tailLines, agentType) {
             else if (claim?.role === 'assistant' && !lastAssistant)
                 lastAssistant = claim.text;
         }
-        else if (agentType === 'gemini') {
-            const claim = readGemini(raw);
-            if (claim?.role === 'user' && !lastUser)
-                lastUser = claim.text;
-            else if (claim?.role === 'assistant' && !lastAssistant)
-                lastAssistant = claim.text;
-        }
     }
     return {
         lastUserMessage: clip(lastUser),
@@ -71,30 +64,6 @@ function readCodex(raw) {
         return null;
     return { role, text };
 }
-// Gemini stores chats as a single pretty-printed JSON document — readTailLines
-// returns partial fragments that JSON.parse rejects. So in practice this
-// branch only fires for the JSONL-style events that some Gemini wrappers emit
-// during a live session. Acceptable: the result is an empty summary, which
-// the UI handles gracefully.
-function readGemini(raw) {
-    const t = raw.type;
-    if (t === 'user_message') {
-        const text = typeof raw.text === 'string' ? raw.text : null;
-        return text ? { role: 'user', text } : null;
-    }
-    if (t === 'agent_message' || t === 'model_message') {
-        const text = typeof raw.text === 'string' ? raw.text : null;
-        return text ? { role: 'assistant', text } : null;
-    }
-    if (t === 'message') {
-        const role = raw.role === 'user' ? 'user' : raw.role === 'assistant' ? 'assistant' : null;
-        if (!role)
-            return null;
-        const text = typeof raw.text === 'string' ? raw.text : pickContentText(raw.content);
-        return text ? { role, text } : null;
-    }
-    return null;
-}
 function pickContentText(content) {
     if (typeof content === 'string')
         return isSyntheticTagged(content) ? null : content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.116",
+  "version": "1.22.118",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",

package/scripts/postinstall.js

@@ -50,16 +50,16 @@ function shellQuote(value) {
 }
 
 // Shorthands that delegate to the installed agents-cli entrypoint.
-const ALIASES = ['browser', 'teams'];
+const ALIASES = ['teams'];
 
 // Aliases this script USED to write and must now remove on every install.
-// `secrets` (PHNX-3989), `sessions` (PHNX-4012), and `pty` (PHNX-4091): those
-// names belong to standalone CLIs now (`pty` -> `@phnx-labs/term-cli`'s
-// `term`). An alias shim that `exec`s `agents <name>` re-enters the
-// passthrough and shadows the real binary because the shims dir sits first on
-// PATH — the 1.22.85 fork bomb. Postinstall is the upgrade path that actually
-// runs, so it prunes here.
-const RETIRED_ALIASES = ['secrets', 'sessions', 'pty'];
+// `secrets` (PHNX-3989), `sessions` (PHNX-4012), `pty` (PHNX-4091), and
+// `browser` (PHNX-4101): those names belong to standalone CLIs now (`pty` ->
+// `@phnx-labs/term-cli`'s `term`; `browser` -> `@phnx-labs/browser-cli`). An
+// alias shim that `exec`s `agents <name>` re-enters the passthrough and shadows
+// the real binary because the shims dir sits first on PATH — the 1.22.85 fork
+// bomb. Postinstall is the upgrade path that actually runs, so it prunes here.
+const RETIRED_ALIASES = ['secrets', 'sessions', 'pty', 'browser'];
 
 function removeRetiredAliasShims() {
   for (const name of RETIRED_ALIASES) {

package/dist/browser.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/browser.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { registerBrowserSubcommands } from './commands/browser.js';
-import { maybeRunStandaloneOnHost } from './lib/hosts/passthrough.js';
-async function main() {
-    // `browser … --device <box>` routes to a remote over SSH, exactly like
-    // `agents browser … --device <box>` does through index.ts. Standalone-only:
-    // this binary never enters index.ts, so without this the flag was dropped.
-    if (await maybeRunStandaloneOnHost('browser')) {
-        process.exit(process.exitCode ?? 0);
-    }
-    const program = new Command();
-    program.name('browser').description('Browser automation via CDP');
-    registerBrowserSubcommands(program);
-    program.parse();
-}
-void main();

package/dist/commands/browser-picker.d.ts

@@ -1,18 +0,0 @@
-import type { ProfileStatus, TaskStatus } from '../lib/browser/types.js';
-export interface BrowserTask {
-    task: TaskStatus;
-    profile: ProfileStatus;
-}
-interface PickedBrowserTask {
-    task: BrowserTask;
-    action: 'view' | 'stop';
-}
-interface BrowserPickerConfig {
-    message: string;
-    tasks: BrowserTask[];
-    pageSize?: number;
-    initialSearch?: string;
-}
-/** Show an interactive browser task picker. */
-export declare function browserTaskPicker(config: BrowserPickerConfig): Promise<PickedBrowserTask | null>;
-export {};