@phnx-labs/agents-cli 1.20.78 → 1.20.83

package/dist/lib/hosts/passthrough.js

@@ -24,6 +24,9 @@ import { dispatchAgentsCommand, withActorEnv } from './dispatch.js';
 import { stripRoutingFlags, buildRemoteAgentsInvocation, HOST_ROUTING_SPECS, } from './remote-cmd.js';
 import { resolveRemoteOsSync } from './remote-os.js';
 import { machineId } from '../session/sync/config.js';
+import { loadDevices } from '../devices/registry.js';
+import { fanOutDevices, planFleetTargets, runLocalCommand, runOnDevice, } from '../devices/fleet.js';
+import { platformGroupLabel } from '../devices/health-report.js';
 /**
  * First-class groups that run transparently on a remote via SSH when
  * `--host`/`--device` is present. Keep both canonical names and aliases
@@ -102,6 +105,7 @@ const OWN_HOST_COMMANDS = new Set([
     'harnesses',
     'sessions',
     'feed',
+    'activity', // fans `--host`/`--device`/`--devices-all` out itself (feed-style)
     'computer',
     'secrets',
     'logs',
@@ -112,8 +116,15 @@ const OWN_HOST_COMMANDS = new Set([
     'apply', // `--device` scopes the fleet reconcile to one device (it targets devices itself)
     'monitors', // `--device` names the OWNER machine (pin-to-one), not a routing target
 ]);
-/** `--no-tty` is stripped like the routing flags but carries no value. */
-const STRIP_SPECS = [...HOST_ROUTING_SPECS, { long: 'no-tty', takesValue: false }];
+/** `--no-tty` is stripped like the routing flags but carries no value. The plural
+ * fleet flags are stripped only when we handle the `all` sentinel ourselves;
+ * otherwise they fall through to command-level aggregators. */
+const STRIP_SPECS = [
+    ...HOST_ROUTING_SPECS,
+    { long: 'no-tty', takesValue: false },
+    { long: 'hosts', takesValue: true },
+    { long: 'devices', takesValue: true },
+];
 /** Pull the value of `--host`/`-H`/`--remote-cwd` (any form) out of an argv. */
 export function flagValue(args, long, short) {
     for (let i = 0; i < args.length; i++) {
@@ -155,6 +166,201 @@ async function resolveTargetHost(name, any) {
     assertValidSshTarget(name); // rejects injection / flag-smuggling before it reaches ssh
     return syntheticHost(name);
 }
+/** Detect the `all` sentinel on any routing flag. */
+function isFleetAllSentinel(hostFlag, deviceFlag, hostsFlag, devicesFlag) {
+    return (hostFlag?.toLowerCase() === 'all' ||
+        deviceFlag?.toLowerCase() === 'all' ||
+        hostsFlag?.toLowerCase() === 'all' ||
+        devicesFlag?.toLowerCase() === 'all');
+}
+/** Strip routing flags from the argv and ensure the per-device call emits JSON. */
+function buildFleetForwardedArgs(allArgs) {
+    const stripped = stripRoutingFlags(allArgs, STRIP_SPECS);
+    if (!stripped.includes('--json'))
+        stripped.push('--json');
+    return stripped;
+}
+/** Parse stdout as JSON; on failure return an object describing the error. */
+function safeJsonParse(stdout) {
+    try {
+        return JSON.parse(stdout);
+    }
+    catch {
+        return { parseError: 'invalid JSON', snippet: stdout.trim().slice(0, 200) };
+    }
+}
+/** One-line summary of a per-device `agents view [agent] --json` payload. */
+function summarizeViewResult(forwarded, json) {
+    // After routing flags are stripped, the agent argument is the first token that
+    // is not a flag (e.g. `kimi` in `agents view kimi --json`).
+    const agentArg = forwarded.find((a, i) => i > 0 && !a.startsWith('-'));
+    // `agents view --json` returns an array; `agents view <agent> --json` returns
+    // a single object. Normalize to the per-agent shape.
+    const agent = agentArg
+        ? (Array.isArray(json) ? json[0] : json)
+        : undefined;
+    if (!agentArg) {
+        const rows = Array.isArray(json) ? json : [];
+        const count = rows.reduce((n, r) => n + (r.versions?.length ?? 0), 0);
+        return count === 0 ? 'no agents installed' : `${count} version${count === 1 ? '' : 's'}`;
+    }
+    if (!agent || !Array.isArray(agent.versions) || agent.versions.length === 0) {
+        return 'not installed';
+    }
+    const v = agent.versions.find((x) => x.isDefault) ?? agent.versions[0];
+    const parts = [chalk.cyan(String(v.version))];
+    if (v.signedIn) {
+        parts.push(chalk.green('active'));
+        if (v.email)
+            parts.push(chalk.gray(String(v.email)));
+    }
+    else {
+        parts.push(chalk.gray('signed out'));
+    }
+    return parts.join(' · ');
+}
+function formatCompactUsd(usd) {
+    if (usd >= 1000)
+        return `$${(usd / 1000).toFixed(1)}k`;
+    if (usd >= 1)
+        return `$${usd.toFixed(2)}`;
+    return `$${usd.toFixed(3)}`;
+}
+function formatCompactTokens(n) {
+    const abs = Math.abs(n);
+    if (abs >= 1e9)
+        return `${(n / 1e9).toFixed(1)}B`;
+    if (abs >= 1e6)
+        return `${(n / 1e6).toFixed(1)}M`;
+    if (abs >= 1e3)
+        return `${(n / 1e3).toFixed(1)}K`;
+    return String(n);
+}
+/** One-line summary of a per-device `agents output --json` payload. */
+function summarizeOutputResult(json) {
+    const p = json;
+    const burn = p?.burn;
+    if (!burn || typeof burn !== 'object')
+        return 'ok';
+    const parts = [];
+    if (typeof burn.costUsd === 'number')
+        parts.push(`${formatCompactUsd(burn.costUsd)} burned`);
+    if (typeof burn.outputTokens === 'number')
+        parts.push(`${formatCompactTokens(burn.outputTokens)} output tokens`);
+    const commits = p?.output?.commits;
+    if (typeof commits === 'number' && commits > 0)
+        parts.push(`${commits} commits`);
+    return parts.length ? parts.join(' · ') : 'ok';
+}
+/** Best-effort summary of any per-device JSON payload. */
+function summarizeResult(command, forwarded, json) {
+    if (command === 'view')
+        return summarizeViewResult(forwarded, json);
+    if (command === 'output')
+        return summarizeOutputResult(json);
+    return 'ok';
+}
+const GROUP_ORDER = ['macOS', 'Linux', 'Windows', 'Other'];
+/** Render the grouped-by-OS fleet roster from per-device results. */
+function renderFleetRoster(command, forwarded, results, self) {
+    const agentArg = forwarded[1];
+    const installed = results.filter((r) => r.status === 'ok').length;
+    const skipped = results.filter((r) => r.status === 'skipped').length;
+    const failed = results.filter((r) => r.status === 'failed').length;
+    const title = agentArg ? `${command} ${agentArg}` : command;
+    const summaryParts = [];
+    if (installed)
+        summaryParts.push(`${installed} installed`);
+    if (failed)
+        summaryParts.push(`${failed} unreachable`);
+    if (skipped)
+        summaryParts.push(`${skipped} skipped`);
+    console.log(chalk.bold(title) + chalk.gray(` · ${results.length} device${results.length === 1 ? '' : 's'}`));
+    console.log('');
+    const nameW = Math.max(6, ...results.map((r) => r.name.length));
+    const grouped = new Map();
+    for (const r of results) {
+        const g = platformGroupLabel(r.device.platform);
+        (grouped.get(g) ?? grouped.set(g, []).get(g)).push(r);
+    }
+    for (const group of GROUP_ORDER) {
+        const members = grouped.get(group);
+        if (!members || members.length === 0)
+            continue;
+        members.sort((a, b) => {
+            const aSelf = a.name.toLowerCase() === self.toLowerCase();
+            const bSelf = b.name.toLowerCase() === self.toLowerCase();
+            return (aSelf ? -1 : bSelf ? 1 : 0) || a.name.localeCompare(b.name);
+        });
+        console.log(chalk.bold(group));
+        for (const r of members) {
+            const isSelf = r.name.toLowerCase() === self.toLowerCase();
+            const prefix = isSelf ? chalk.cyan('▸') : ' ';
+            let glyph;
+            let text;
+            if (r.status === 'skipped') {
+                glyph = chalk.gray('○');
+                text = chalk.gray(String(r.reason ?? 'skipped'));
+            }
+            else if (r.status === 'failed') {
+                glyph = chalk.red('✕');
+                text = chalk.red(String(r.error ?? 'unreachable').split('\n')[0].slice(0, 80));
+            }
+            else {
+                glyph = chalk.green('●');
+                text = summarizeResult(command, forwarded, r.value);
+            }
+            const selfNote = isSelf ? chalk.cyan('   ← this machine') : '';
+            console.log(` ${prefix} ${r.name.padEnd(nameW)}  ${glyph}  ${text}${selfNote}`);
+        }
+        console.log('');
+    }
+    if (summaryParts.length) {
+        console.log(chalk.gray(summaryParts.join(' · ')));
+    }
+}
+/** Run `agents <command> …` across every registered device and render the roster. */
+export async function runFleetPassthrough(command, allArgs, spec, opts = {}) {
+    const self = opts.self ?? machineId();
+    const registry = await (opts.loadDevices ?? loadDevices)();
+    const planned = planFleetTargets(registry);
+    const targets = planned.map((t) => ({
+        name: t.device.name,
+        device: t.device,
+        skip: t.skip,
+    }));
+    const forwarded = buildFleetForwardedArgs(allArgs);
+    const runner = opts.runner ?? runOnDevice;
+    const localRunner = opts.localRunner ?? runLocalCommand;
+    const results = await fanOutDevices(targets, async (target) => {
+        const cmd = ['agents', ...forwarded];
+        const isSelf = target.device.name.toLowerCase() === self.toLowerCase();
+        const res = isSelf ? localRunner(cmd) : runner(target.device, cmd);
+        if (res.code !== 0) {
+            const detail = (res.stderr || res.stdout || 'unreachable').trim().slice(0, 200);
+            throw new Error(detail || 'unreachable');
+        }
+        return safeJsonParse(res.stdout);
+    }, { perDeviceTimeoutMs: 120_000 });
+    // Map fan-out results back to typed results with device attached for rendering.
+    const typedResults = results.map((r, i) => ({
+        ...r,
+        device: targets[i].device,
+    }));
+    if (allArgs.includes('--json')) {
+        const out = {};
+        for (const r of typedResults) {
+            out[r.name] = r.status === 'ok' ? r.value : { error: r.error ?? r.reason ?? 'unknown' };
+        }
+        console.log(JSON.stringify(out, null, 2));
+    }
+    else {
+        renderFleetRoster(command, forwarded, typedResults, self);
+    }
+    const anyFailed = typedResults.some((r) => r.status === 'failed');
+    process.exitCode = anyFailed ? 1 : 0;
+    return true;
+}
 /**
  * Route `agents <command> … --host <name>` to a remote if the command is
  * host-routable and a `--host` (or its `--device` alias) was given. Returns
@@ -167,11 +373,16 @@ async function resolveTargetHost(name, any) {
  * @param command the resolved subcommand name (`process.argv`'s first non-flag).
  * @param allArgs `process.argv.slice(2)` — the command name followed by its args.
  */
-export async function maybeRunOnHost(command, allArgs) {
+export async function maybeRunOnHost(command, allArgs, opts) {
     const hostFlag = flagValue(allArgs, 'host', 'H');
     const deviceFlag = flagValue(allArgs, 'device');
+    const hostsFlag = flagValue(allArgs, 'hosts');
+    const devicesFlag = flagValue(allArgs, 'devices');
     const hostName = hostFlag ?? deviceFlag;
-    if (!hostName)
+    const fleetAll = isFleetAllSentinel(hostFlag, deviceFlag, hostsFlag, devicesFlag);
+    // Proceed when any routing flag is present, including the plural fleet flags
+    // that may carry the `all` sentinel.
+    if (!hostName && !hostsFlag && !devicesFlag)
         return false;
     // Commands with their own richer --host semantics must reach local commander
     // BEFORE any single-target conflict gate. sessions/feed merge --host and
@@ -193,14 +404,18 @@ export async function maybeRunOnHost(command, allArgs) {
             return false;
         }
     }
-    // `--hosts` is always a generic fleet flag — bail for every command so the
-    // local aggregator handles it. `--devices` is fan-out on most commands but
-    // a placement flag on `routines` (which devices may run the routine), so
-    // only exempt routines from the bail.
-    if (allArgs.includes('--hosts'))
-        return false;
-    if (allArgs.includes('--devices') && command !== 'routines')
+    // `--hosts` / `--devices` are command-level fleet flags unless their value is
+    // the `all` sentinel, which this module fans out generically. On `routines`,
+    // a non-all `--devices` value is placement (which devices may run the routine).
+    if (allArgs.includes('--hosts') && hostsFlag?.toLowerCase() !== 'all')
         return false;
+    if (allArgs.includes('--devices')) {
+        if (devicesFlag === undefined)
+            return false; // malformed, let commander error
+        const isAll = devicesFlag.toLowerCase() === 'all';
+        if (!isAll && command !== 'routines')
+            return false;
+    }
     const spec = REMOTE_PASSTHROUGH[command];
     if (!spec) {
         // Flag was accepted (no raw commander "unknown option") but this group has
@@ -210,13 +425,23 @@ export async function maybeRunOnHost(command, allArgs) {
         process.exitCode = 1;
         return true;
     }
-    // Single-target remote path only: reject a conflicting --host/--device pair
-    // rather than silently preferring one (same rule as `agents run`).
+    // Reject a conflicting --host/--device pair before either the fleet fan-out
+    // or single-target path runs. Equal values (e.g. both `all`) are allowed.
     if (hostFlag && deviceFlag && hostFlag !== deviceFlag) {
         console.error(chalk.red('Conflicting --host/--device values — pass just one.'));
         process.exitCode = 1;
         return true;
     }
+    // Generic fleet fan-out for the `all` sentinel — before single-host resolution
+    // so `all` is never treated as a literal hostname.
+    if (fleetAll) {
+        return runFleetPassthrough(command, allArgs, spec, opts);
+    }
+    // After the bailouts and fleet fan-out above, the only remaining path is a
+    // single-target --host/--device. Guard for the type checker: plural non-all
+    // flags and bare flags were already handled.
+    if (!hostName)
+        return false;
     // Running against your own machine is just a local run — skip the SSH round-trip.
     // `machineId()` is the same self-identifier the device registry and session
     // sync use (lowercased short hostname); compare case-insensitively.

package/dist/lib/hosts/run-target.d.ts

@@ -49,6 +49,8 @@ export interface HostPromptRun {
     sessionId?: string;
     /** Working directory on the host, already made remote-portable by the caller. */
     remoteCwd?: string;
+    /** `remoteCwd` was derived from the local cwd — mirror it, don't fail on it. */
+    mirrorCwd?: boolean;
     /** Stream progress and block until completion (default true). */
     follow?: boolean;
     timeoutMs?: number;

package/dist/lib/hosts/run-target.js

@@ -85,6 +85,7 @@ export async function dispatchPromptToHost(host, opts) {
         mode: opts.mode,
         model: opts.model,
         remoteCwd: opts.remoteCwd,
+        mirrorCwd: opts.mirrorCwd,
         sessionId: forcedSessionId,
         emitSessionId,
         name: opts.name,

package/dist/lib/hq/floor.d.ts

@@ -2,7 +2,7 @@ import type { ActiveSession } from '../session/active.js';
 import type { OpenBlock } from '../feed.js';
 import type { AgentStatusDetail, TaskInfo } from '../teams/api.js';
 export type HqRoomKind = 'team' | 'machine' | 'lobby';
-export type HqAgentMood = 'working' | 'waiting' | 'blocked' | 'celebrating' | 'idle';
+export type HqAgentMood = 'working' | 'waiting' | 'blocked' | 'celebrating' | 'done' | 'idle';
 export type HqAmbientKind = 'needs_input' | 'error' | 'pr' | 'team_active' | 'idle_scene';
 export interface HqAction {
     id: string;

package/dist/lib/hq/floor.js

@@ -28,6 +28,10 @@ function teammateName(session, teammatesById) {
     return session.agentId;
 }
 function moodForSession(session, hasOpenBlock) {
+    if (session.status === 'abandoned')
+        return 'blocked';
+    if (session.status === 'closed')
+        return 'done';
     if (session.status === 'input_required' || session.activity === 'waiting_input' || hasOpenBlock)
         return 'waiting';
     if (session.rateLimited)
@@ -175,6 +179,7 @@ export function buildHqFloor(input) {
         }
     }
     for (const room of rooms.values()) {
+        const roomAgents = agents.filter((agent) => agent.roomId === room.id);
         if (room.kind === 'team' && room.counts.running > 0) {
             ambientEvents.push({
                 id: `team-active:${room.id}`,
@@ -184,7 +189,7 @@ export function buildHqFloor(input) {
                 intensity: 'low',
             });
         }
-        if (room.counts.agents > 0 && room.counts.running === 0 && room.counts.needsInput === 0) {
+        if (roomAgents.length > 0 && roomAgents.every((agent) => agent.mood === 'idle')) {
             ambientEvents.push({
                 id: `idle:${room.id}`,
                 kind: 'idle_scene',

package/dist/lib/mcp.js

@@ -18,7 +18,6 @@ import { getBinaryPath, getVersionHomePath } from './versions.js';
 import { IS_WINDOWS, execFileShellSpec } from './platform/index.js';
 import { AGENTS, getMcpConfigPathForHome, getProjectMcpConfigPath } from './agents.js';
 import { isCapable } from './capabilities.js';
-import { setGeminiAutoUpdateDisabled, updateGeminiSettings } from './gemini-settings.js';
 /**
  * Parse an MCP server config from a YAML file.
  */
@@ -401,7 +400,7 @@ export async function registerMcpCommandToTargets(targets, name, commandSpec, sc
 function registerMcpCommand(agentId, name, commandSpec, scope, transport, options = {}) {
     try {
         validateMcpServerName(name);
-        if (agentId === 'hermes' || agentId === 'forge') {
+        if (agentId === 'hermes') {
             const server = {
                 name,
                 path: '',
@@ -413,12 +412,7 @@ function registerMcpCommand(agentId, name, commandSpec, scope, transport, option
                         : { command: commandSpec.command, args: commandSpec.args }),
                 },
             };
-            if (agentId === 'hermes') {
-                installMcpToHermesConfig(server, options.home || os.homedir());
-            }
-            else {
-                installMcpToForgeConfig(server, options.home || os.homedir());
-            }
+            installMcpToHermesConfig(server, options.home || os.homedir());
             return { success: true };
         }
         const bin = options.binary || AGENTS[agentId].cliCommand;
@@ -436,31 +430,6 @@ function registerMcpCommand(agentId, name, commandSpec, scope, transport, option
         return { success: false, error: err.message };
     }
 }
-/**
- * Install MCP server to Gemini config file.
- */
-function installMcpToGeminiConfig(server, versionHome) {
-    const configPath = path.join(versionHome, '.gemini', 'settings.json');
-    updateGeminiSettings(configPath, (config) => {
-        setGeminiAutoUpdateDisabled(config);
-        if (!config.mcpServers || typeof config.mcpServers !== 'object') {
-            config.mcpServers = {};
-        }
-        const mcpServers = config.mcpServers;
-        if (server.config.transport === 'stdio') {
-            mcpServers[server.name] = {
-                command: server.config.command,
-                args: server.config.args || [],
-                env: server.config.env || {},
-            };
-        }
-        else {
-            mcpServers[server.name] = {
-                url: server.config.url,
-            };
-        }
-    });
-}
 /**
  * Install MCP server to Cursor config file.
  */
@@ -574,31 +543,6 @@ function installMcpToHermesConfig(server, versionHome) {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
 }
-function installMcpToForgeConfig(server, versionHome) {
-    const configPath = path.join(versionHome, '.forge', '.mcp.json');
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    }
-    if (!config.mcpServers || typeof config.mcpServers !== 'object' || Array.isArray(config.mcpServers)) {
-        config.mcpServers = {};
-    }
-    const mcpServers = config.mcpServers;
-    if (server.config.transport === 'stdio') {
-        mcpServers[server.name] = {
-            command: server.config.command,
-            args: server.config.args || [],
-            ...(server.config.env && { env: server.config.env }),
-        };
-    }
-    else {
-        mcpServers[server.name] = {
-            url: server.config.url,
-        };
-    }
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
 function installMcpToOpenCodeConfig(server, versionHome) {
     const configPath = path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
     let config = {};
@@ -643,10 +587,8 @@ function writeMcpConfigSupportsAgent(agentId) {
     switch (agentId) {
         case 'claude':
         case 'cursor':
-        case 'gemini':
         case 'kimi':
         case 'droid':
-        case 'forge':
         case 'openclaw':
         case 'codex':
         case 'grok':
@@ -672,10 +614,8 @@ export function writeMcpConfig(agentId, configPath, servers, mode = 'overwrite')
     switch (agentId) {
         case 'claude':
         case 'cursor':
-        case 'gemini':
         case 'kimi':
-        case 'droid':
-        case 'forge': {
+        case 'droid': {
             let config = {};
             if (fs.existsSync(configPath)) {
                 try {
@@ -888,10 +828,6 @@ export function installMcpServers(agentId, version, versionHome, mcpNames, optio
                 installMcpViaCodex(binaryPath, server, versionHome);
                 handled = true;
             }
-            else if (agentId === 'gemini') {
-                installMcpToGeminiConfig(server, versionHome);
-                handled = true;
-            }
             else if (agentId === 'cursor') {
                 installMcpToCursorConfig(server, versionHome);
                 handled = true;
@@ -943,10 +879,6 @@ export function installMcpServers(agentId, version, versionHome, mcpNames, optio
                 installMcpToHermesConfig(server, versionHome);
                 handled = true;
             }
-            else if (agentId === 'forge') {
-                installMcpToForgeConfig(server, versionHome);
-                handled = true;
-            }
             // Project-layer servers also get merged into the agent's project-level
             // config (e.g., .mcp.json, .codex/config.toml) so the CLI discovers them
             // when run inside the repo.

package/dist/lib/menubar/install-menubar.d.ts

@@ -124,6 +124,28 @@ export declare function disableMenubarService(): void;
  * Best-effort — never throws into startup.
  */
 export declare function installMenubarLaunchAgentOnUpgrade(): void;
+/** A live MenubarHelper process: its pid and the executable it is running. */
+export interface MenubarProcess {
+    pid: number;
+    executable: string;
+}
+/**
+ * Split the live MenubarHelper processes into the installed bundle's own
+ * (`running`) and every other copy (`foreign`).
+ *
+ * `pgrep -f MenubarHelper` conflated the two, so a stray dev build could hold
+ * the global Cmd-Shift-V chord (RegisterEventHotKey is first-come) while status
+ * still reported a healthy `running: yes` — the paste was dead and nothing said
+ * so. A foreign copy is the thing to look for, so name it.
+ *
+ * Identity comes from `comm` (the resolved executable), never from a substring
+ * of the command line: matching the latter flags any shell that merely mentions
+ * MenubarHelper. `command` is consulted only to drop `--notify` one-shots.
+ */
+export declare function classifyMenubarProcesses(commOutput: string, commandOutput: string, installedExec: string): {
+    running: boolean;
+    foreign: MenubarProcess[];
+};
 export interface MenubarStatus {
     platform: string;
     source: string | null;
@@ -133,6 +155,8 @@ export interface MenubarStatus {
     stale: boolean;
     serviceInstalled: boolean;
     running: boolean;
+    /** Live MenubarHelper processes that are NOT the installed bundle. */
+    foreignInstances: MenubarProcess[];
     disabledByUser: boolean;
 }
 export declare function getMenubarStatus(): MenubarStatus;

package/dist/lib/menubar/install-menubar.js

@@ -441,12 +441,61 @@ export function installMenubarLaunchAgentOnUpgrade() {
         /* never block startup on the menu bar */
     }
 }
+/** Parse `ps -axo pid=,<field>=` into pid -> field. The field is the rest of the
+ *  line, so a path containing spaces (App Support does) survives intact. */
+function parsePsLines(psOutput) {
+    const out = new Map();
+    for (const line of psOutput.split('\n')) {
+        const m = /^\s*(\d+)\s+(.+)$/.exec(line);
+        if (m)
+            out.set(Number(m[1]), m[2]);
+    }
+    return out;
+}
+/**
+ * Split the live MenubarHelper processes into the installed bundle's own
+ * (`running`) and every other copy (`foreign`).
+ *
+ * `pgrep -f MenubarHelper` conflated the two, so a stray dev build could hold
+ * the global Cmd-Shift-V chord (RegisterEventHotKey is first-come) while status
+ * still reported a healthy `running: yes` — the paste was dead and nothing said
+ * so. A foreign copy is the thing to look for, so name it.
+ *
+ * Identity comes from `comm` (the resolved executable), never from a substring
+ * of the command line: matching the latter flags any shell that merely mentions
+ * MenubarHelper. `command` is consulted only to drop `--notify` one-shots.
+ */
+export function classifyMenubarProcesses(commOutput, commandOutput, installedExec) {
+    const commands = parsePsLines(commandOutput);
+    const foreign = [];
+    let running = false;
+    for (const [pid, executable] of parsePsLines(commOutput)) {
+        if (path.basename(executable) !== 'MenubarHelper')
+            continue;
+        // `--notify` is a one-shot that posts a notification and exits; it runs the
+        // installed binary but never claims the status item or the chords.
+        if ((commands.get(pid) || '').includes('--notify'))
+            continue;
+        if (executable === installedExec)
+            running = true;
+        else
+            foreign.push({ pid, executable });
+    }
+    return { running, foreign };
+}
 export function getMenubarStatus() {
     const dest = installedAppPath();
     let running = false;
+    let foreignInstances = [];
     if (onDarwin()) {
-        const r = spawnSync('pgrep', ['-f', 'MenubarHelper'], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf-8' });
-        running = r.status === 0 && (r.stdout || '').trim().length > 0;
+        const ps = (format) => spawnSync('ps', ['-axo', format], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf-8' });
+        const comm = ps('pid=,comm=');
+        const command = ps('pid=,command=');
+        if (comm.status === 0 && command.status === 0) {
+            const c = classifyMenubarProcesses(comm.stdout || '', command.stdout || '', installedExecutablePath());
+            running = c.running;
+            foreignInstances = c.foreign;
+        }
     }
     const serviceInstalled = menubarServiceInstalled();
     return {
@@ -458,6 +507,7 @@ export function getMenubarStatus() {
         stale: onDarwin() && serviceInstalled && menubarSetupStale(),
         serviceInstalled,
         running,
+        foreignInstances,
         disabledByUser: menubarDisabledByUser(),
     };
 }

package/dist/lib/menubar/notify-desktop.d.ts

@@ -16,6 +16,7 @@
  * 'error' listener — without it Node re-throws ENOENT as an uncaught exception and
  * takes the whole daemon down (the exact crash overdue.test.ts guards).
  */
+import { type ChildProcess } from 'child_process';
 export interface DesktopNotification {
     /** Bold first line. */
     title: string;
@@ -36,6 +37,20 @@ export interface DesktopNotification {
 export declare function buildMenubarNotifyArgs(n: DesktopNotification): string[];
 /** AppleScript for the osascript degradation path. Exported for tests. */
 export declare function buildOsascriptNotifyArgs(n: DesktopNotification): string[];
+/**
+ * Spawn one detached, best-effort notifier process with a bounded lifetime.
+ *
+ * The child is detached + unref'd so it never blocks the daemon, but — unlike a
+ * pure fire-and-forget — it is supervised: a watchdog SIGKILLs it after
+ * `timeoutMs` so a stalled notifier can never linger (the pile-up this fixes).
+ * The common path (a sub-second post + self-exit) clears the watchdog on the
+ * child's own 'exit', so the kill only ever fires for a genuinely hung child.
+ *
+ * `timeoutMs` is injectable so the bounded-lifetime behaviour is testable against
+ * a real long-running child without a multi-second wait. Returns the child so a
+ * caller/test can observe it; callers in this module ignore it.
+ */
+export declare function spawnDetachedQuiet(command: string, args: string[], timeoutMs?: number): ChildProcess;
 /**
  * Fire a native desktop notification, branded via the MenubarHelper companion on
  * macOS. Best-effort — any failure is swallowed so a notification hiccup never