@phnx-labs/agents-cli 1.20.77 → 1.20.82

package/dist/lib/hosts/dispatch.js

@@ -19,6 +19,7 @@ import { saveTask, updateTask, terminalPatch } from './tasks.js';
 import { followHostTask } from './progress.js';
 import { wrapHostCommandWithCredentials } from './credentials.js';
 import { hostKeyCheckingOpts } from '../devices/known-hosts.js';
+import { toRemotePortable } from '../project-root.js';
 // Use $HOME (not ~) so the path is correct whether or not it's quoted and
 // regardless of the run's cwd. Task ids are 8 hex chars, so these paths are
 // injection-safe to interpolate unquoted into remote commands.
@@ -39,6 +40,21 @@ function homeRemainder(p) {
         return p.slice(6);
     return null;
 }
+/**
+ * Derive the remote directory to mirror from the local cwd, for a host run the
+ * caller gave no `--cwd`/`--remote-cwd`.
+ *
+ * Without this a `--host` run lands in the remote `$HOME`, so an agent launched
+ * from a repo starts with no project context and the user has to `cd` by hand.
+ * Only a cwd under the LOCAL home is mirrored — that is the part with a
+ * meaningful remote analogue (`~/src/x` re-roots onto the remote home). A path
+ * outside home returns undefined: `/opt/thing` on this box says nothing about
+ * the target's filesystem, so the run keeps the remote home.
+ */
+export function deriveMirroredCwd(localCwd) {
+    const portable = toRemotePortable(localCwd);
+    return homeRemainder(portable) === null ? undefined : portable;
+}
 /**
  * Build a `cd <dir> && ` prefix that resolves on the REMOTE host.
  *
@@ -46,15 +62,26 @@ function homeRemainder(p) {
  * the local one (`/home/<me>` vs `/Users/<me>`). We emit an unquoted `"$HOME"`
  * for that segment — the remote login shell expands it — and shell-quote the
  * remainder. Any other path (absolute or relative) is quoted verbatim.
+ *
+ * `mirror` marks a directory the caller DERIVED from the local cwd rather than
+ * one the user asked for (see `deriveMirroredCwd`). The same repo checked out at
+ * the same home-relative path on both boxes is the common fleet layout, so
+ * mirroring lands the remote agent in the project instead of `$HOME`. It is a
+ * best-effort mirror by definition — the host may simply not have that checkout
+ * — so a missing directory falls back to the remote home instead of failing the
+ * run. An explicit `--cwd`/`--remote-cwd` is never mirrored: the user named that
+ * directory, so a missing one must surface as a `cd` error.
  */
-export function remoteCdPrefix(remoteCwd) {
+export function remoteCdPrefix(remoteCwd, opts = {}) {
     if (!remoteCwd)
         return '';
     const rest = homeRemainder(remoteCwd);
     if (rest === '')
         return 'cd "$HOME" && ';
-    if (rest !== null)
-        return `cd "$HOME"/${shellQuote(rest)} && `;
+    if (rest !== null) {
+        const dir = `"$HOME"/${shellQuote(rest)}`;
+        return opts.mirror ? `{ cd ${dir} || cd "$HOME"; } && ` : `cd ${dir} && `;
+    }
     return `cd ${shellQuote(remoteCwd)} && `;
 }
 /**
@@ -190,7 +217,7 @@ async function launchDetached(host, target, opts) {
     // resolved actor provenance first so the detached remote run inherits it
     // instead of re-resolving from this box's SSH_CONNECTION (RUSH-2028).
     const invocation = ['agents', ...opts.forwardedArgs].map(shellQuote).join(' ');
-    const cwd = remoteCdPrefix(opts.remoteCwd);
+    const cwd = remoteCdPrefix(opts.remoteCwd, { mirror: opts.mirrorCwd });
     const actorExports = posixEnvExports(withActorEnv());
     const prelude = actorExports ? `${actorExports}; ` : '';
     let inner = `${prelude}${cwd}${invocation} > ${remoteLog} 2>&1; echo $? > ${remoteExit}`;
@@ -385,7 +412,7 @@ export async function runInteractiveOnHost(host, opts) {
     for (const w of warnings)
         process.stderr.write(`[hosts] warning: ${w}\n`);
     const invocation = ['agents', ...buildInteractiveRunForwardedArgs(opts)].map(shellQuote).join(' ');
-    const cwd = remoteCdPrefix(opts.remoteCwd);
+    const cwd = remoteCdPrefix(opts.remoteCwd, { mirror: opts.mirrorCwd });
     // Forward actor provenance so the interactive remote run inherits it rather
     // than re-resolving from this box's SSH_CONNECTION (RUSH-2028).
     const actorExports = posixEnvExports(withActorEnv());
@@ -413,6 +440,7 @@ export async function dispatchToHost(host, opts) {
     return launchDetached(host, target, {
         forwardedArgs: buildRunForwardedArgs(opts),
         remoteCwd: opts.remoteCwd,
+        mirrorCwd: opts.mirrorCwd,
         follow: opts.follow,
         timeoutMs: opts.timeoutMs,
         agentLabel: opts.agent,

package/dist/lib/hosts/option.js

@@ -12,8 +12,8 @@
 /** Attach the standard `--host` flag family to a command and return it (chainable). */
 export function addHostOption(cmd) {
     return cmd
-        .option('-H, --host <name>', 'Run this command on another machine over SSH instead of locally — a device, a registered host, or user@host. See `agents devices` / `agents hosts`.')
-        .option('--device <name>', 'Alias of --host: run this command on a registered device (from `agents devices`).')
+        .option('-H, --host <name>', 'Run this command on another machine over SSH instead of locally — a device, a registered host, user@host, or `all` to fan out across every registered device. See `agents devices` / `agents hosts`.')
+        .option('--device <name>', 'Alias of --host: run this command on a registered device (from `agents devices`), or `all` to run it across the whole fleet.')
         .option('--remote-cwd <dir>', "Working directory on the host for --host runs. Resolves on the REMOTE host — pass a '$HOME'-relative path (single-quoted so your local shell doesn't expand it) or a valid remote absolute path; a local ~ expands here and won't exist there (/Users/you vs /home/you). No effect on 'teams add'.")
         .option('--no-tty', 'Force non-interactive output for --host runs even from a terminal.')
         .option('--any', 'With --host <cap> (a capability tag), pick any matching host instead of erroring when several match.');

package/dist/lib/hosts/passthrough.d.ts

@@ -16,8 +16,28 @@
  * table or, when `--host`/`--device` is present, exits with a clear
  * "not supported" message — never commander's raw `unknown option`.
  */
+import { type DeviceRegistry } from '../devices/registry.js';
+import { runLocalCommand, runOnDevice } from '../devices/fleet.js';
+/** Per-command remote behaviour. Absence from this map = not host-routable here. */
+interface RemoteSpec {
+    /** Flags appended when running non-interactively (no local TTY / `--no-tty`). */
+    nonInteractive?: string[];
+}
 /** Pull the value of `--host`/`-H`/`--remote-cwd` (any form) out of an argv. */
 export declare function flagValue(args: string[], long: string, short?: string): string | undefined;
+/** Injectable dependencies for {@link runFleetPassthrough} — used by tests. */
+export interface FleetPassthroughOptions {
+    /** Override the device registry loader (tests). */
+    loadDevices?: () => Promise<DeviceRegistry>;
+    /** Override the per-device runner (tests). Defaults to `runOnDevice`. */
+    runner?: typeof runOnDevice;
+    /** Override the local runner for the self device (tests). Defaults to `runLocalCommand`. */
+    localRunner?: typeof runLocalCommand;
+    /** Override this machine's id (tests). Defaults to `machineId()`. */
+    self?: string;
+}
+/** Run `agents <command> …` across every registered device and render the roster. */
+export declare function runFleetPassthrough(command: string, allArgs: string[], spec: RemoteSpec, opts?: FleetPassthroughOptions): Promise<boolean>;
 /**
  * Route `agents <command> … --host <name>` to a remote if the command is
  * host-routable and a `--host` (or its `--device` alias) was given. Returns
@@ -30,4 +50,5 @@ export declare function flagValue(args: string[], long: string, short?: string):
  * @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 declare function maybeRunOnHost(command: string, allArgs: string[]): Promise<boolean>;
+export declare function maybeRunOnHost(command: string, allArgs: string[], opts?: FleetPassthroughOptions): Promise<boolean>;
+export {};

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/remote-cmd.js

@@ -116,6 +116,8 @@ export const RUN_OPTION_FORWARDING = {
     tailscale: 'local-only', // --tailscale/--no-tailscale gate the lease net mode; never forwarded
     copyCreds: 'local-only', // copies creds TO the host before dispatch — local concern only
     authCheck: 'local-only', // --no-auth-check gates the local interactive login preflight; --host runs skip that preflight entirely
+    // Deprecated alias for --device auto; resolved on the launching box before SSH.
+    smart: 'local-only',
 };
 /** Actionable messages for value-aware rejections, keyed by attribute name. */
 export const RUN_OPTION_REJECT_MESSAGES = {

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/MenubarHelper.app/Contents/Info.plist

@@ -8,6 +8,8 @@
     <string>com.phnx-labs.agents-menubar</string>
     <key>CFBundleName</key>
     <string>Agents Menu Bar</string>
+    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleShortVersionString</key>