@phnx-labs/agents-cli 1.20.87 → 1.20.89

package/dist/lib/devices/fleet-divergence.d.ts

@@ -40,6 +40,23 @@ export interface RepoState {
     /** True when the working tree has uncommitted changes. */
     dirty: boolean;
 }
+/**
+ * Per-version sign-in state a device self-reports, so the fleet doctor can show
+ * every installed version's account (and a provable logged-out) without a second
+ * SSH round-trip. `provable` is true only when the credential is absent from BOTH
+ * the version home and the active/global HOME (see `credentialPresence`); an
+ * unprovable absence (opaque/keychain agent) is a warning, not a critical.
+ */
+export interface FleetVersionSignIn {
+    version: string;
+    /** A usable local credential was found for this version (or shared globally). */
+    signedIn: boolean;
+    /** Human account label (email, org badge, or opaque id), when derivable. */
+    account: string | null;
+    /** True only when a logged-out state is PROVABLE (credential absent per-version
+     *  AND globally) — the caller gates a critical on this. */
+    provable: boolean;
+}
 /**
  * The self-reported harness inventory a single device emits in `doctor --json`.
  * Comparable device-to-device with no further probing.
@@ -55,6 +72,11 @@ export interface FleetInventory {
         agents: RepoState | null;
         system: RepoState | null;
     };
+    /** Per-version sign-in state per agent id, for the fleet doctor's accounts
+     *  line and cross-fleet logged-out criticals. Optional — an older CLI that
+     *  predates this field omits it, and the caller degrades to a warning
+     *  ("older agents-cli — can't report per-version sign-in"). */
+    signIn?: Record<string, FleetVersionSignIn[]>;
 }
 /** A device's inventory paired with its name (and reachability). A device that
  *  was unreachable / failed to report carries `inventory: null` and is skipped

package/dist/lib/devices/fleet-divergence.js

@@ -45,20 +45,25 @@ function repoLabel(repo) {
 }
 /** Describe how a remote repo state diverges from the local baseline, or null
  *  when they match. Compares HEAD first (the load-bearing difference), then
- *  branch, then a dirty tree on either side (naming which side is dirty). */
+ *  branch, then a dirty tree on either side.
+ *
+ *  HEAD and branch differences are symmetric — by convention the remote is the
+ *  one "diverged from the baseline" — but a dirty tree belongs to exactly one
+ *  box, and blaming the wrong one sends the user to a clean machine. */
 function describeRepoDrift(local, remote) {
     if (local.head && remote.head && local.head !== remote.head) {
-        return `HEAD ${remote.head} != local ${local.head}`;
+        return { detail: `repo diverged: HEAD ${remote.head} != local ${local.head}`, blame: 'remote' };
     }
     if (local.branch !== remote.branch) {
-        return `branch ${remote.branch ?? 'detached'} != local ${local.branch ?? 'detached'}`;
+        return {
+            detail: `repo diverged: branch ${remote.branch ?? 'detached'} != local ${local.branch ?? 'detached'}`,
+            blame: 'remote',
+        };
     }
-    // Flag a dirty tree on EITHER side (symmetric with HEAD/branch above), and name
-    // the side that has the uncommitted changes — the remote, or the local baseline.
     if (remote.dirty !== local.dirty) {
         return remote.dirty
-            ? 'remote tree has uncommitted changes'
-            : 'local tree has uncommitted changes';
+            ? { detail: 'tree has uncommitted changes', blame: 'remote' }
+            : { detail: 'tree has uncommitted changes', blame: 'local' };
     }
     return null;
 }
@@ -78,6 +83,9 @@ export function compareFleetInventories(devices, baselineName) {
     const comparedDevices = [];
     const skippedDevices = [];
     const divergences = [];
+    /** Repos already reported as the BASELINE's problem — one dirty local tree is
+     *  one finding, not one per remote compared against. */
+    const localBlamed = new Set();
     if (!baseline) {
         // No local baseline to compare against — record every remote as skipped so
         // the caller can say so, but emit no divergences (we can't know the truth).
@@ -163,15 +171,31 @@ export function compareFleetInventories(devices, baselineName) {
             if (!localRepo || !remoteRepo)
                 continue; // one side isn't a readable repo
             const drift = describeRepoDrift(localRepo, remoteRepo);
-            if (drift) {
+            if (!drift)
+                continue;
+            if (drift.blame === 'local') {
+                // The BASELINE owns this one. File it against the baseline, and only
+                // once: the local tree being dirty is a single fact about this machine,
+                // not one problem per remote we happened to compare against.
+                if (localBlamed.has(repo))
+                    continue;
+                localBlamed.add(repo);
                 divergences.push({
                     kind: 'repo-drift',
-                    device: remote.name,
+                    device: baselineName,
                     category: repo,
                     name: repoLabel(repo),
-                    message: `${remote.name} ${repoLabel(repo)} repo diverged: ${drift}`,
+                    message: `${baselineName} ${repoLabel(repo)} ${drift.detail}`,
                 });
+                continue;
             }
+            divergences.push({
+                kind: 'repo-drift',
+                device: remote.name,
+                category: repo,
+                name: repoLabel(repo),
+                message: `${remote.name} ${repoLabel(repo)} ${drift.detail}`,
+            });
         }
     }
     divergences.sort((a, b) => a.device.localeCompare(b.device) ||

package/dist/lib/devices/fleet-inventory.d.ts

@@ -8,12 +8,23 @@
  * FleetInventory} that both the local baseline and every remote box serialize
  * into their doctor payload; the comparator then diffs those payloads.
  */
-import { type FleetInventory } from './fleet-divergence.js';
+import { type FleetInventory, type FleetVersionSignIn } from './fleet-divergence.js';
+/**
+ * Probe every installed version's sign-in state, per agent. For each version we
+ * read its own home's account (via the shim-set config dir) and, when logged
+ * out, decide whether that is PROVABLE: an agent that can't be inspected
+ * (`!supportsAccountInspection`) never claims logged out, and a version that
+ * merely lacks its own credential but shares the global login (`active`) is
+ * signed in, not out. Pure reads (file-presence + cheap account parse), no
+ * network, no keychain prompt. Only agents with at least one installed version
+ * appear, so the map lines up with {@link FleetInventory.agentVersions}.
+ */
+export declare function collectLocalFleetSignIn(): Promise<Record<string, FleetVersionSignIn[]>>;
 /**
  * Collect this machine's harness inventory: installed resources per kind,
- * installed version ids per agent, and `.agents`/`.system` repo state. Pure
- * reads — never mutates the install. `promptcuts` (a single present/absent bit
- * in {@link getAvailableResources}) is surfaced as a one-element list so it
- * compares like any other named resource.
+ * installed version ids per agent, `.agents`/`.system` repo state, and
+ * per-version sign-in. Pure reads — never mutates the install. `promptcuts` (a
+ * single present/absent bit in {@link getAvailableResources}) is surfaced as a
+ * one-element list so it compares like any other named resource.
  */
-export declare function collectLocalFleetInventory(cwd?: string): FleetInventory;
+export declare function collectLocalFleetInventory(cwd?: string): Promise<FleetInventory>;

package/dist/lib/devices/fleet-inventory.js

@@ -8,24 +8,71 @@
  * FleetInventory} that both the local baseline and every remote box serialize
  * into their doctor payload; the comparator then diffs those payloads.
  */
-import { getAvailableResources, listInstalledVersions } from '../versions.js';
+import { getAvailableResources, getVersionHomePath, listInstalledVersions } from '../versions.js';
 import { getUserAgentsDir, getSystemAgentsDir } from '../state.js';
 import { readRepoState } from '../git.js';
-import { ALL_AGENT_IDS } from '../agents.js';
-import { FLEET_RESOURCE_KINDS } from './fleet-divergence.js';
+import { ALL_AGENT_IDS, accountDisplayLabel, credentialPresence, getAccountInfo, supportsAccountInspection, } from '../agents.js';
+import { FLEET_RESOURCE_KINDS, } from './fleet-divergence.js';
 function toRepoState(snap) {
     if (!snap)
         return null;
     return { branch: snap.branch, head: snap.head, dirty: snap.dirty };
 }
+/**
+ * Probe every installed version's sign-in state, per agent. For each version we
+ * read its own home's account (via the shim-set config dir) and, when logged
+ * out, decide whether that is PROVABLE: an agent that can't be inspected
+ * (`!supportsAccountInspection`) never claims logged out, and a version that
+ * merely lacks its own credential but shares the global login (`active`) is
+ * signed in, not out. Pure reads (file-presence + cheap account parse), no
+ * network, no keychain prompt. Only agents with at least one installed version
+ * appear, so the map lines up with {@link FleetInventory.agentVersions}.
+ */
+export async function collectLocalFleetSignIn() {
+    const out = {};
+    await Promise.all(ALL_AGENT_IDS.map(async (agent) => {
+        const versions = listInstalledVersions(agent);
+        if (versions.length === 0)
+            return;
+        const rows = await Promise.all(versions.map(async (version) => {
+            const home = getVersionHomePath(agent, version);
+            let signedIn = false;
+            let account = null;
+            try {
+                const info = await getAccountInfo(agent, home);
+                signedIn = info.signedIn;
+                account = accountDisplayLabel(info) || null;
+            }
+            catch {
+                /* advisory only — treat as logged out, provability decided below */
+            }
+            // Provable logout: the agent is inspectable AND the credential is absent
+            // from BOTH the version home and the active/global HOME. An opaque or
+            // keychain-only agent, or one sharing the global login, is never a
+            // provable logout.
+            let provable = false;
+            if (!signedIn && supportsAccountInspection(agent)) {
+                const presence = credentialPresence(agent, home);
+                // `knownLocation` is load-bearing: an agent can sit in the inspection
+                // set with no credential path (cursor does), and then both probes are
+                // false only because there is nothing to look for. Treating that as a
+                // provable logout prints a CRITICAL for a version that is signed in.
+                provable = presence.knownLocation && !presence.perVersion && !presence.active;
+            }
+            return { version, signedIn, account, provable };
+        }));
+        out[agent] = rows;
+    }));
+    return out;
+}
 /**
  * Collect this machine's harness inventory: installed resources per kind,
- * installed version ids per agent, and `.agents`/`.system` repo state. Pure
- * reads — never mutates the install. `promptcuts` (a single present/absent bit
- * in {@link getAvailableResources}) is surfaced as a one-element list so it
- * compares like any other named resource.
+ * installed version ids per agent, `.agents`/`.system` repo state, and
+ * per-version sign-in. Pure reads — never mutates the install. `promptcuts` (a
+ * single present/absent bit in {@link getAvailableResources}) is surfaced as a
+ * one-element list so it compares like any other named resource.
  */
-export function collectLocalFleetInventory(cwd = process.cwd()) {
+export async function collectLocalFleetInventory(cwd = process.cwd()) {
     const available = getAvailableResources(cwd);
     const resources = {};
     for (const kind of FLEET_RESOURCE_KINDS) {
@@ -53,5 +100,6 @@ export function collectLocalFleetInventory(cwd = process.cwd()) {
             agents: toRepoState(readRepoState(getUserAgentsDir())),
             system: toRepoState(readRepoState(getSystemAgentsDir())),
         },
+        signIn: await collectLocalFleetSignIn(),
     };
 }

package/dist/lib/events.d.ts

@@ -13,7 +13,7 @@
  */
 import { type ActorKind } from './actor.js';
 export type EventLevel = 'audit' | 'warn' | 'info' | 'debug';
-export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'secrets.get' | 'secrets.unlocked' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
+export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'secrets.get' | 'secrets.unlocked' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'webhook.received' | 'webhook.authorized' | 'webhook.rejected' | 'webhook.matched' | 'webhook.fired' | 'webhook.handler.start' | 'webhook.handler.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
 export declare function levelFor(event: EventType): EventLevel;
 export interface EventMeta {
     ts: string;

package/dist/lib/exec.d.ts

@@ -66,7 +66,14 @@ export declare function resolveMode(agent: AgentId, requested: Mode): Mode;
  * downgraded. This is the single source of truth shared by buildExecCommand
  * (agents run / teams) and the routine runner.
  */
-export declare function resolveHeadlessMode(agent: AgentId, requested: Mode, interactive: boolean): Mode;
+export declare function resolveHeadlessMode(agent: AgentId, requested: Mode, interactive: boolean, warningContext?: string, warningState?: ModeWarningState): Mode;
+export interface ModeWarningState {
+    /** Agents already warned about, so one run warns once per agent. A fallback
+     *  chain degrades each agent independently and the agent that actually ran is
+     *  usually not the first, so this cannot be a single boolean. */
+    emitted?: Set<AgentId>;
+    quiet?: boolean;
+}
 /**
  * The mode an agent should run in when the caller has no preference.
  *
@@ -94,6 +101,10 @@ export interface ExecOptions {
     cwd?: string;
     /** Force headless mode even when no prompt is provided (e.g. piping via stdin). */
     headless?: boolean;
+    /** Prefix for mode-degradation warnings emitted by shared headless paths. */
+    modeWarningContext?: string;
+    /** Shared across command previews/spawns/loop iterations so degradation warns once. */
+    modeWarningState?: ModeWarningState;
     json?: boolean;
     model?: string;
     addDirs?: string[];
@@ -400,8 +411,8 @@ export declare function detectAuthFailure(text: string): boolean;
  * reason logic can never catch it — the `error:"authentication_failed"` marker
  * and the `result`+`is_error` text are the reliable signals.
  *
- * Gated on the Claude stream-json shape; other agents don't emit these fields,
- * so callers pass their agent and this returns false for non-claude.
+ * Gated on the Claude-compatible stream-json shape emitted by Claude and Cursor;
+ * callers pass their agent so unrelated stream formats cannot match by accident.
  */
 export declare function detectAuthFailureEvent(logText: string, agent: AgentId): boolean;
 /**

package/dist/lib/exec.js

@@ -124,10 +124,35 @@ export function resolveMode(agent, requested) {
  * downgraded. This is the single source of truth shared by buildExecCommand
  * (agents run / teams) and the routine runner.
  */
-export function resolveHeadlessMode(agent, requested, interactive) {
+export function resolveHeadlessMode(agent, requested, interactive, warningContext, warningState) {
     const mode = resolveMode(agent, requested);
+    const warn = (message) => {
+        if (warningState?.quiet)
+            return;
+        if (warningState) {
+            warningState.emitted ??= new Set();
+            if (warningState.emitted.has(agent))
+                return;
+            warningState.emitted.add(agent);
+        }
+        process.stderr.write(message);
+    };
+    if (mode !== requested) {
+        const subject = warningContext ? `${warningContext}: ` : '';
+        if (requested === 'plan') {
+            const limitation = agent === 'cursor'
+                ? "cursor's read-only plan mode is not enabled in this build"
+                : `${agent} has no read-only 'plan' mode`;
+            warn(`[agents] ${subject}${limitation}; ` +
+                `running '${mode}' (writable) instead${agent === 'cursor' ? ' (RUSH-2101)' : ''}. ` +
+                `Pass --mode ${mode} to silence this.\n`);
+        }
+        else {
+            warn(`[agents] ${subject}${agent} has no '${requested}' mode; using '${mode}'.\n`);
+        }
+    }
     if (!interactive && mode === 'plan' && AGENTS[agent].capabilities.headlessPlan === false) {
-        process.stderr.write(`warning: ${agent} has no headless plan mode; running --mode auto instead\n`);
+        warn(`warning: ${agent} has no headless plan mode; running --mode auto instead\n`);
         return resolveMode(agent, 'auto');
     }
     return mode;
@@ -425,7 +450,6 @@ export const AGENT_COMMANDS = {
         base: ['cursor-agent'],
         promptFlag: '-p',
         modeFlags: {
-            // cursor-agent has no read-only flag; we only expose edit + skip.
             edit: [],
             skip: ['-f'],
         },
@@ -669,13 +693,18 @@ export function buildExecCommand(options) {
     //   degrades to `auto` with a stderr warning (see resolveHeadlessMode)
     // - `skip` on an unsupported agent → throws a clear error
     // After resolution, the chosen mode is guaranteed to be in template.modeFlags.
-    const resolvedMode = resolveHeadlessMode(options.agent, normalizeMode(options.mode), interactive);
+    const resolvedMode = resolveHeadlessMode(options.agent, normalizeMode(options.mode), interactive, options.modeWarningContext, options.modeWarningState);
     const modeFlags = template.modeFlags[resolvedMode];
     if (!modeFlags) {
         // Defense in depth: would only fire if AGENTS.capabilities.modes and
         // AGENT_COMMANDS.modeFlags drifted apart. Tests assert they agree.
         throw new Error(`Internal error: ${options.agent} declares '${resolvedMode}' in capabilities.modes but has no entry in AGENT_COMMANDS.modeFlags.${resolvedMode}.`);
     }
+    if (options.agent === 'cursor' && resolvedMode === 'edit' && !interactive) {
+        // A configured headless run is the workspace trust decision. Keep this
+        // narrower than --yolo/-f, which also bypasses permission checks.
+        cmd.push('--trust');
+    }
     // Codex's workspace-write sandbox blocks $HOME (verified against the live CLI
     // and OpenAI's sandbox docs: writable roots extend scope "without removing the
     // sandbox entirely"). But the model routinely shells out to `agents ...`, whose
@@ -1269,7 +1298,10 @@ async function spawnAgent(options) {
         agent: options.agent,
         version: options.version,
         cwd: options.cwd || process.cwd(),
-        mode: options.mode,
+        // The mode that ran, not the one requested — `agents run` passes the
+        // requested mode so the resolver can warn, but telemetry must agree with
+        // the audit log. See RUSH-2106 for removing that ambiguity at the source.
+        mode: resolveMode(options.agent, normalizeMode(options.mode)),
         model: options.model,
         interactive,
         sessionId: options.sessionId,
@@ -1549,6 +1581,7 @@ export function detectRateLimit(text) {
 export const AUTH_FAILURE_PATTERNS = [
     /OAuth (?:access token has been revoked|session expired)/i,
     /(?:Please run|run) \/login/i,
+    /Please run 'agent login' first/i,
     /\bNot logged in\b/i,
     /Invalid authentication credentials/i,
     /Failed to authenticate/i,
@@ -1573,11 +1606,11 @@ export function detectAuthFailure(text) {
  * reason logic can never catch it — the `error:"authentication_failed"` marker
  * and the `result`+`is_error` text are the reliable signals.
  *
- * Gated on the Claude stream-json shape; other agents don't emit these fields,
- * so callers pass their agent and this returns false for non-claude.
+ * Gated on the Claude-compatible stream-json shape emitted by Claude and Cursor;
+ * callers pass their agent so unrelated stream formats cannot match by accident.
  */
 export function detectAuthFailureEvent(logText, agent) {
-    if (agent !== 'claude')
+    if (agent !== 'claude' && agent !== 'cursor')
         return false;
     const lines = logText.split('\n');
     for (const line of lines) {

package/dist/lib/factory/snapshot.d.ts

@@ -0,0 +1,78 @@
+import { type ActiveSession } from '../session/active.js';
+import { serializeActiveSessionsForJson } from '../../commands/sessions.js';
+import { readAuthHealthCache, type AuthVerdict } from '../auth-health.js';
+import { readStatsCache } from '../devices/stats-cache.js';
+export declare const FACTORY_PROJECTS: readonly [{
+    readonly name: "Prix";
+    readonly repo: "phnx-labs/prix";
+}, {
+    readonly name: "Rush App";
+    readonly repo: "phnx-labs/rush";
+}, {
+    readonly name: "Rush CLI";
+    readonly repo: "phnx-labs/rush-cli";
+}, {
+    readonly name: "Agents CLI";
+    readonly repo: "phnx-labs/agents-cli";
+}, {
+    readonly name: "Linear CLI";
+    readonly repo: "phnx-labs/linear-cli";
+}];
+export interface FactoryConfig {
+    source: 'default' | 'file';
+    ceiling: number;
+    max_dispatch_per_tick: number;
+    per_project: Record<string, {
+        weight: number;
+        cap: number;
+    }>;
+    idle_boxes: string[];
+    digest: {
+        times: string[];
+        tz: string;
+    };
+}
+export interface FactorySnapshot {
+    generatedAt: string;
+    sessions: ReturnType<typeof serializeActiveSessionsForJson>;
+    queues: Record<string, {
+        todo: number;
+        inProgress: number;
+        blocked: number;
+    }>;
+    prs: Array<{
+        repo: string;
+        number: number;
+        ci: string;
+        review: string;
+        mergeable: string;
+    }>;
+    devices: Array<{
+        name: string;
+        load: number | null;
+        idle: boolean;
+    }>;
+    recentRuns: Array<{
+        routine: string;
+        status: string;
+        durationMs: number | null;
+    }>;
+    auth: {
+        claude: AuthVerdict | null;
+    };
+    config: FactoryConfig;
+}
+export interface SnapshotDependencies {
+    home: string;
+    now: () => Date;
+    activeSessions: () => Promise<ActiveSession[]>;
+    run: (file: string, args: string[]) => Promise<string>;
+    readAuth: () => ReturnType<typeof readAuthHealthCache>;
+    readDeviceStats: () => ReturnType<typeof readStatsCache>;
+}
+export declare function readFactoryConfig(home: string): FactoryConfig;
+export declare function queueCounts(todoPayload: unknown, openPayload: unknown): FactorySnapshot['queues'][string];
+export declare function parsePullRequests(repo: string, payload: unknown): FactorySnapshot['prs'];
+export declare function parseDevices(payload: unknown, cached?: ReturnType<typeof readStatsCache>): FactorySnapshot['devices'];
+export declare function readRecentRuns(home: string, limit?: number): FactorySnapshot['recentRuns'];
+export declare function buildFactorySnapshot(overrides?: Partial<SnapshotDependencies>): Promise<FactorySnapshot>;