@phnx-labs/agents-cli 1.22.23 → 1.22.25

package/dist/lib/startup/command-registry.js

@@ -29,6 +29,7 @@ export const loadFork = async () => (await import('../../commands/fork.js')).reg
 export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
 export const loadSet = async () => (await import('../../commands/set.js')).registerSetCommand;
 export const loadModels = async () => (await import('../../commands/models.js')).registerModelsCommand;
+export const loadModes = async () => (await import('../../commands/modes.js')).registerModesCommand;
 export const loadPrune = async () => (await import('../../commands/prune.js')).registerPruneCommand;
 export const loadTrash = async () => (await import('../../commands/trash.js')).registerTrashCommands;
 export const loadRestore = async () => (await import('../../commands/trash.js')).registerRestoreCommand;
@@ -145,6 +146,11 @@ export const COMMAND_LOADERS = {
     registry: [loadPackages],
     search: [loadPackages],
     install: [loadPackages],
+    // packages.ts also registers `publish` at top level (commands/packages.ts:435).
+    // It was missing here, so `agents publish` only worked via the unknown-command
+    // fallback that registers the whole tree — and the --host router could not see
+    // it as a real command at all (RUSH-2022).
+    publish: [loadPackages],
     routines: [loadRoutines],
     monitors: [loadMonitors],
     projects: [loadProjects],
@@ -154,6 +160,7 @@ export const COMMAND_LOADERS = {
     defaults: [loadDefaults],
     set: [loadSet],
     models: [loadModels],
+    modes: [loadModes],
     trash: [loadTrash],
     restore: [loadRestore],
     doctor: [loadDoctor],
@@ -229,3 +236,40 @@ export const COMMAND_LOADERS = {
     funnel: [loadFunnel],
     humans: [loadHumans],
 };
+/**
+ * Top-level names that {@link COMMAND_LOADERS} does not carry because they are
+ * registered inline in src/index.ts — closures over entry-point state (the
+ * deprecated aliases and tombstones) plus the internal/upgrade commands. They are
+ * real commands, so anything that asks "does this command exist?" must count them.
+ */
+const INLINE_COMMAND_NAMES = [
+    'perms', // deprecated alias -> permissions
+    'exec', // deprecated alias -> run
+    'jobs', // deprecated alias -> routines
+    'cron', // deprecated alias -> routines
+    'check', // tombstone -> doctor --check
+    'resources', // tombstone -> view --merged
+    'hq', // tombstone
+    '_internal',
+    'upgrade',
+];
+/**
+ * Every top-level command name the CLI answers to — the loader table plus the
+ * inline aliases/tombstones above. This is the "does this command exist?"
+ * predicate for code that runs BEFORE commander parses, most importantly the
+ * `--host`/`--device` router (lib/hosts/passthrough.ts): without it a typo'd
+ * command carrying `--host` reported a flag-support error instead of
+ * `unknown command` (RUSH-2022).
+ *
+ * Commander sub-aliases (`sessions ls`, `teams rm`, …) are deliberately absent —
+ * this set is top-level only. `command-registry.test.ts` pins it against the real
+ * registered command tree so a new command can never drift out of it.
+ */
+export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
+    ...Object.keys(COMMAND_LOADERS),
+    ...INLINE_COMMAND_NAMES,
+]);
+/** Whether `name` is a top-level command this CLI registers. See {@link KNOWN_TOP_LEVEL_COMMANDS}. */
+export function isKnownTopLevelCommand(name) {
+    return KNOWN_TOP_LEVEL_COMMANDS.has(name);
+}

package/dist/lib/sync-umbrella.d.ts

@@ -68,6 +68,11 @@ export interface RunUmbrellaArgs {
     yes: boolean;
     /** Secrets passphrase, if available (env var or prompt). Undefined => skip secrets. */
     passphrase?: string;
+    /**
+     * Suppress human progress from the reconcile stage (`refresh`). Required so
+     * `agents sync --json` / fleet fan-out leave stdout as a single JSON object.
+     */
+    quiet?: boolean;
 }
 /**
  * Execute the planned stages in order: repos -> secrets -> reconcile.

package/dist/lib/sync-umbrella.js

@@ -18,6 +18,7 @@
 import { pullRepo } from './git.js';
 import { getUserAgentsDir, getEnabledExtraRepos } from './state.js';
 import { listRemoteBundles, pullBundle } from './secrets/sync.js';
+import { SYNC_PASSPHRASE_ENV } from './secrets/sync-passphrase.js';
 /**
  * Decide which stages run. Pure — no I/O. Semantics:
  *   bare (no flags)        fetch repos, then reconcile
@@ -52,7 +53,7 @@ export function planUmbrellaStages(f) {
  * reconcile — `agents sync` should make as much current as it can in one pass.
  */
 export async function runUmbrellaSync(args) {
-    const { flags, log, yes, passphrase } = args;
+    const { flags, log, yes, passphrase, quiet = false } = args;
     const plan = planUmbrellaStages(flags);
     const result = { plan, reconciled: false };
     if (plan.fetchRepos) {
@@ -79,10 +80,10 @@ export async function runUmbrellaSync(args) {
             result.secrets = {
                 pulled: 0,
                 skipped: true,
-                reason: 'no passphrase — set AGENTS_SECRETS_PASSPHRASE or run `agents login` (#366)',
+                reason: `no passphrase — set ${SYNC_PASSPHRASE_ENV} or run \`agents login\` (#366)`,
                 errors: [],
             };
-            log('secrets: skipped (no passphrase available)');
+            log(`secrets: skipped (no passphrase — set ${SYNC_PASSPHRASE_ENV})`);
         }
         else {
             let pulled = 0;
@@ -108,7 +109,7 @@ export async function runUmbrellaSync(args) {
     }
     if (plan.reconcile) {
         const { refresh } = await import('./refresh.js');
-        await refresh({ skipPrompts: yes });
+        await refresh({ skipPrompts: yes, quiet });
         result.reconciled = true;
         // Keep already-registered devices' reachability current, and surface newly
         // appeared tailnet nodes as "pending" for the menu-bar Register/Ignore gate

package/dist/lib/teams/agents.js

@@ -197,7 +197,7 @@ export function buildTeammateSpawnEnv(envOverrides) {
  */
 export { captureProcessStartTime };
 /** Agent types the team runner supports. */
-const TEAM_AGENT_TYPES = ['codex', 'cursor', 'claude', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
+const TEAM_AGENT_TYPES = ['codex', 'cursor', 'claude', 'opencode', 'grok', 'antigravity', 'kimi', 'droid', 'warp'];
 // Suffix appended to all prompts to ensure agents provide a summary
 const PROMPT_SUFFIX = `
 

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';
+export type AgentType = 'codex' | 'gemini' | '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/tmux/session.d.ts

@@ -114,6 +114,8 @@ export interface TmuxClient {
 export declare function listClients(socket?: string): Promise<TmuxClient[]>;
 /** A dead pane's exit status, read from tmux while the pane lingers under remain-on-exit. */
 export interface PaneExit {
+    /** False when the pane/socket no longer exists or tmux could not query it. */
+    found: boolean;
     /** True once the process that ran in the pane has exited (pane is dead). */
     dead: boolean;
     /** Exit status of the dead pane's process, when tmux reports it. */
@@ -122,8 +124,8 @@ export interface PaneExit {
 /**
  * Read whether a pane's process has exited and, if so, its exit status. Used by
  * the spawn-wrap path to recover the wrapped agent's exit code after the attach
- * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
- * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ * client returns. `found: false` distinguishes a missing pane from a living one;
+ * focus must recover the former instead of attaching a retained/stale target.
  */
 export declare function paneExitStatus(pane: string, socket?: string): Promise<PaneExit>;
 /**

package/dist/lib/tmux/session.js

@@ -248,8 +248,8 @@ export async function listClients(socket) {
 /**
  * Read whether a pane's process has exited and, if so, its exit status. Used by
  * the spawn-wrap path to recover the wrapped agent's exit code after the attach
- * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
- * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ * client returns. `found: false` distinguishes a missing pane from a living one;
+ * focus must recover the former instead of attaching a retained/stale target.
  */
 export async function paneExitStatus(pane, socket) {
     let res;
@@ -261,13 +261,13 @@ export async function paneExitStatus(pane, socket) {
         });
     }
     catch {
-        return { dead: false };
+        return { found: false, dead: false };
     }
     if (res.code !== 0)
-        return { dead: false };
+        return { found: false, dead: false };
     const [deadRaw, statusRaw] = res.stdout.trim().split(/\s+/);
     const status = statusRaw !== undefined && statusRaw !== '' ? parseInt(statusRaw, 10) : undefined;
-    return { dead: deadRaw === '1', status: Number.isFinite(status) ? status : undefined };
+    return { found: true, dead: deadRaw === '1', status: Number.isFinite(status) ? status : undefined };
 }
 /**
  * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`

package/dist/lib/types.d.ts

@@ -8,9 +8,10 @@
 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 type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi' | 'muse';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi' | 'muse' | 'warp';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
 export type RunStrategy = 'pinned' | 'available' | 'balanced';
+export type RunEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
 /**
  * Reserved `<agent>` keyword for `agents run auto` — full-auto dispatch:
  * host (14d launch affinity) → harness (best-account headroom, weighted) →
@@ -36,6 +37,7 @@ export interface AgentRunConfig {
 export interface RunDefaults {
     mode?: Mode;
     model?: string;
+    effort?: RunEffort;
 }
 /** `run:` section in agents.yaml. Agent keys keep strategy; `defaults` stores selector rules. */
 export type RunConfig = Partial<Record<AgentId, AgentRunConfig>> & {

package/dist/lib/versions.js

@@ -928,6 +928,21 @@ export function getBinaryPath(agent, version) {
             ? path.join(getHomeDir(), 'bin', 'muse.exe')
             : path.join(getHomeDir(), '.local', 'bin', 'muse');
     }
+    if (agent === 'warp') {
+        // Warp Agent CLI installs a single global, self-updating `oz` binary — brew
+        // cask on macOS, the `oz-stable` apt|yum|pacman package on Linux — so, unlike
+        // droid/muse (which land at ~/.local/bin), its install location is
+        // platform/package specific. Resolve the real binary on PATH (findInPath
+        // skips our own shims dir) so isVersionInstalled / agents view agree with
+        // what executes. When oz is not installed, fall back to a deterministic path
+        // that won't exist, so isVersionInstalled reports uninstalled honestly.
+        const onPath = findInPath('oz');
+        if (onPath)
+            return onPath;
+        return IS_WINDOWS
+            ? path.join(getHomeDir(), 'bin', 'oz.exe')
+            : '/opt/warpdotdev/oz-stable/oz';
+    }
     const versionDir = getVersionDir(agent, version);
     return path.join(versionDir, 'node_modules', '.bin', agentConfig.cliCommand);
 }
@@ -1539,7 +1554,7 @@ export async function installVersion(agent, version, onProgress, opts) {
         // exec itself forever. So we skip the resolver-backed agents here AND, for
         // everyone else, filter the shims dir out of the `which` candidates so the
         // same race can't bite a non-special-cased installScript agent.
-        if (agent !== 'grok' && agent !== 'droid' && agent !== 'muse') {
+        if (agent !== 'grok' && agent !== 'droid' && agent !== 'muse' && agent !== 'warp') {
             // findInPath is a pure-Node PATH scan that already skips our own shims
             // dir — so it returns the genuine install, never our dispatcher shim
             // (which sits ahead of ~/.local/bin on PATH and would otherwise be

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

@@ -0,0 +1,17 @@
+import { type ActiveSession } from '../session/active.js';
+import { type WatchdogThresholds, type WatchdogTickResult } from './runner.js';
+export interface WatchdogPassOptions {
+    nudge: boolean;
+    nudgeText?: string;
+    smart?: boolean;
+    smartAgent?: string;
+    thresholds?: WatchdogThresholds;
+    allowGhosttyFocus?: boolean;
+    sessions?: ActiveSession[];
+    stateDir?: string;
+    mailboxGc?: boolean;
+}
+export declare function loadWatchdogSessions(): Promise<ActiveSession[]>;
+export declare function runWatchdogMailboxGc(sessions: ActiveSession[]): void;
+/** Execute one watchdog pass from the daemon or the explicit CLI command. */
+export declare function runWatchdogPass(opts: WatchdogPassOptions): Promise<WatchdogTickResult>;

package/dist/lib/watchdog/service.js

@@ -0,0 +1,39 @@
+import * as path from 'path';
+import { gcMailbox } from '../mailbox-gc.js';
+import { mailboxIdForActiveSession } from '../mailbox-target.js';
+import { getActiveSessions } from '../session/active.js';
+import { loadLocalActiveSessions } from '../session/session-cache.js';
+import { getRuntimeStateDir } from '../state.js';
+import { runWatchdogTick } from './runner.js';
+export async function loadWatchdogSessions() {
+    const loaded = await loadLocalActiveSessions({
+        gather: () => getActiveSessions({ localOnly: true }),
+    });
+    return loaded.sessions;
+}
+export function runWatchdogMailboxGc(sessions) {
+    const activeBoxIds = new Set(sessions.map(mailboxIdForActiveSession).filter((id) => Boolean(id)));
+    try {
+        gcMailbox(activeBoxIds);
+    }
+    catch {
+        // Housekeeping is retried by the next daemon tick.
+    }
+}
+/** Execute one watchdog pass from the daemon or the explicit CLI command. */
+export async function runWatchdogPass(opts) {
+    const sessions = opts.sessions ?? await loadWatchdogSessions();
+    const result = await runWatchdogTick({
+        nudge: opts.nudge,
+        nudgeText: opts.nudgeText,
+        smart: opts.smart,
+        smartAgent: opts.smartAgent,
+        thresholds: opts.thresholds,
+        allowGhosttyFocus: opts.allowGhosttyFocus,
+        stateDir: opts.stateDir ?? path.join(getRuntimeStateDir(), 'watchdog'),
+        sessions,
+    });
+    if (opts.mailboxGc !== false)
+        runWatchdogMailboxGc(sessions);
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.23",
+  "version": "1.22.25",
   "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",