@phnx-labs/agents-cli 1.20.77 → 1.20.78

package/dist/lib/daemon.d.ts

@@ -69,27 +69,6 @@ export declare function reapStrayDaemons(keepPid?: number): {
 export declare function log(level: string, message: string): void;
 /** Main daemon loop: load jobs, schedule crons, monitor runs, and handle signals. */
 export declare function runDaemon(): Promise<void>;
-/**
- * Read the long-lived Claude OAuth token (from `claude setup-token`) that the
- * user stored under the `claude` secrets bundle. Resolves the bundle the same
- * way `agents run --secrets` does. Interactive starts may prompt Keychain;
- * headless auto-starts are broker-only and return null unless the user already
- * unlocked the bundle in the secrets agent. That keeps a background browser
- * command from hanging on an unseen biometric prompt. Never throws: an absent
- * token leaves the daemon on its existing interactive OAuth session.
- */
-export declare function readDaemonClaudeOAuthToken(opts?: {
-    allowPrompt?: boolean;
-}): string | null;
-/**
- * Read the FULL `claude` bundle env — the main `CLAUDE_CODE_OAUTH_TOKEN` plus any
- * per-account `CLAUDE_CODE_OAUTH_TOKEN_<slug>` setup-tokens. Same resolution and
- * never-throws contract as {@link readDaemonClaudeOAuthToken}; returns `{}` when
- * the bundle can't be read (broker-only headless miss, absent bundle, etc.).
- */
-export declare function readDaemonClaudeBundleEnv(opts?: {
-    allowPrompt?: boolean;
-}): Record<string, string>;
 /**
  * Write a launchd plist or systemd unit with owner-only permissions atomically.
  *
@@ -103,21 +82,19 @@ export declare function writeOwnerOnlyServiceManifest(filePath: string, content:
 /**
  * Generate a macOS launchd plist for auto-starting the daemon.
  *
- * The plist never embeds the Claude OAuth token (RUSH-1759): a persisted service
- * manifest is a plaintext credential on disk even at 0600. The daemon instead
- * obtains the token at startup from the `claude` secrets bundle
- * (readDaemonClaudeOAuthToken, injected in runDaemon), so it stays in the
- * Keychain-backed secure store and never touches the unit file.
+ * The plist never embeds a Claude OAuth token: the daemon holds no Claude
+ * credential at all. Routine runs authenticate through the per-account
+ * CLAUDE_CONFIG_DIR login on this device, exactly like an interactive
+ * `agents run`, so no credential ever touches the service manifest.
  */
 export declare function generateLaunchdPlist(agentsBin?: string): string;
 /**
  * Generate a Linux systemd user unit for auto-starting the daemon.
  *
- * The unit never embeds the Claude OAuth token (RUSH-1759): a persisted service
- * manifest is a plaintext credential on disk even at 0600. The daemon instead
- * obtains the token at startup from the `claude` secrets bundle
- * (readDaemonClaudeOAuthToken, injected in runDaemon), so it stays in the secure
- * store and never touches the unit file.
+ * The unit never embeds a Claude OAuth token: the daemon holds no Claude
+ * credential at all. Routine runs authenticate through the per-account
+ * CLAUDE_CONFIG_DIR login on this device, exactly like an interactive
+ * `agents run`, so no credential ever touches the unit file.
  */
 export declare function generateSystemdUnit(agentsBin?: string): string;
 export { getAgentsBinPath };
@@ -140,15 +117,6 @@ export declare function ensureDaemonStarted(): {
     pid: number | null;
     method: string;
 } | null;
-/**
- * Environment for the detached daemon fallback. The launchd/systemd paths
- * deliver the long-lived OAuth token via the service manifest's environment;
- * the detached path has no manifest, so inject it here. Read happens during an
- * interactive `routines start`, so a Keychain Touch ID prompt can be satisfied;
- * the daemon then passes it to every routine run it spawns. An already-set
- * value (e.g. inherited from launchd) is left untouched.
- */
-export declare function buildDetachedDaemonEnv(baseEnv?: NodeJS.ProcessEnv, bundleEnv?: Record<string, string>): NodeJS.ProcessEnv;
 /**
  * Resolve how to launch the daemon: `node <entry> __daemon-run`, matching the
  * exact form that works under a direct `__daemon-run`.
@@ -197,7 +165,7 @@ interface StartDetachedOptions {
     agentsBin?: string;
     /** Log file the daemon's stdio is redirected to (defaults to the daemon log). */
     logPath?: string;
-    /** Environment for the child (defaults to the OAuth-augmented detached env). */
+    /** Environment for the child (defaults to the daemon's current process env). */
     env?: NodeJS.ProcessEnv;
 }
 export declare function startDetached(opts?: StartDetachedOptions): {

package/dist/lib/daemon.js

@@ -18,11 +18,9 @@ import { JobScheduler } from './scheduler.js';
 import { MonitorEngine } from './monitors/engine.js';
 import { executeJobDetached, monitorRunningJobs } from './runner.js';
 import { detectOverdueJobs, notifyOverdue } from './overdue.js';
-import { notifyDesktop } from './menubar/notify-desktop.js';
 import { notifyRoutineStart, notifyRoutineFinish, notifyRoutineStartFailed } from './routine-notify.js';
 import { BrowserService } from './browser/service.js';
 import { BrowserIPCServer } from './browser/ipc.js';
-import { readAndResolveBundleEnv } from './secrets/bundles.js';
 import { redactSecrets } from './redact.js';
 import { getAgentsBinPath, getCliLaunch, BUN_VIRTUAL_ROOT } from './cli-entry.js';
 const PID_FILE = 'daemon.pid';
@@ -35,12 +33,6 @@ const PLIST_NAME = 'com.phnx-labs.agents-daemon';
 const SYSTEMD_UNIT = 'agents-daemon.service';
 const MONITOR_TICK_MS = 60_000;
 const WEDGE_THRESHOLD_TICKS = 3;
-// A long-lived `claude setup-token` value stored in this secrets bundle/key is
-// baked into the daemon's service-manager environment so headless routine runs
-// authenticate without depending on the short-lived interactive Keychain OAuth
-// session (which expires between runs and produces intermittent 401s).
-const DAEMON_OAUTH_BUNDLE = 'claude';
-const DAEMON_OAUTH_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
 /**
  * RUSH-1817: decide whether the daemon should (re)take over hosting the secrets
  * broker. The startup host decision is one-shot; this drives the periodic
@@ -309,47 +301,13 @@ export async function runDaemon() {
         process.exit(0);
     }
     log('INFO', `Daemon started (PID: ${process.pid})`);
-    // RUSH-1759: the launchd plist / systemd unit no longer bake the Claude OAuth
-    // token onto disk. Obtain it here from the secure `claude` secrets bundle and
-    // inject into this process's env so every routine run this daemon spawns still
-    // receives it (via the sandbox allowlist), without the token ever being
-    // persisted in the service manifest. A read from a file-backed store (Linux)
-    // needs no prompt; on macOS it resolves broker-only from an unlocked
-    // secrets-agent and is otherwise absent (leaving the daemon on its existing
-    // interactive OAuth session), matching the detached-start path. Never blocks.
-    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN) {
-        const bundleEnv = readDaemonClaudeBundleEnv();
-        const oauthToken = (bundleEnv[DAEMON_OAUTH_KEY] ?? '').trim();
-        if (oauthToken) {
-            process.env.CLAUDE_CODE_OAUTH_TOKEN = oauthToken;
-            // Also inject each per-account CLAUDE_CODE_OAUTH_TOKEN_<slug> present in the
-            // bundle, so a routine authenticates its rotation-pinned account via that
-            // account's own long-lived, non-rotating setup-token (runner.ts
-            // buildRoutineSpawnEnv) instead of the interactive session that rotates and
-            // logs the fleet out (Claude Code #25609 / #56339).
-            let perAccount = 0;
-            for (const [k, v] of Object.entries(bundleEnv)) {
-                if (k.startsWith('CLAUDE_CODE_OAUTH_TOKEN_') && (v ?? '').trim() && !process.env[k]) {
-                    process.env[k] = v.trim();
-                    perAccount++;
-                }
-            }
-            log('INFO', `Loaded Claude OAuth token from secrets bundle for routine runs${perAccount ? ` (+${perAccount} per-account)` : ''}`);
-        }
-        else {
-            // No token available (e.g. a headless macOS daemon whose keychain was
-            // locked at start resolves broker-only and gets nothing). Historically
-            // this was silent, so every Claude routine the daemon spawned failed auth
-            // with no signal. Make it loud: WARN in the log and fire a desktop alert.
-            log('WARN', 'No Claude OAuth token available — Claude routine runs will fail auth on this host. ' +
-                'Restart the daemon with the keychain unlocked, or unlock the `claude` secrets bundle.');
-            notifyDesktop({
-                title: 'agents daemon: no Claude credential',
-                body: 'Claude routines will fail auth on this host. Restart the daemon with the keychain unlocked.',
-                action: 'routines:list',
-            });
-        }
-    }
+    // The daemon holds NO Claude credential of its own. Routine runs authenticate
+    // exactly like an interactive `agents run`: through the per-account
+    // CLAUDE_CONFIG_DIR login on this device (its own auto-refreshing
+    // .credentials.json). Claude Code's interactive access token is short-lived but
+    // refreshes itself per-device; a routine whose account login has gone dead is
+    // skipped up front by the auth-health preflight (runner.ts) with a re-login
+    // hint, rather than papered over by an injected fallback token.
     // Reap any stray duplicate daemon of this install that slipped past the start
     // lock or was orphaned by a hard-crash — before it can double-fire jobs.
     try {
@@ -833,38 +791,6 @@ export async function runDaemon() {
     process.on('SIGINT', () => handleShutdown());
     await new Promise(() => { });
 }
-/**
- * Read the long-lived Claude OAuth token (from `claude setup-token`) that the
- * user stored under the `claude` secrets bundle. Resolves the bundle the same
- * way `agents run --secrets` does. Interactive starts may prompt Keychain;
- * headless auto-starts are broker-only and return null unless the user already
- * unlocked the bundle in the secrets agent. That keeps a background browser
- * command from hanging on an unseen biometric prompt. Never throws: an absent
- * token leaves the daemon on its existing interactive OAuth session.
- */
-export function readDaemonClaudeOAuthToken(opts = {}) {
-    const token = (readDaemonClaudeBundleEnv(opts)[DAEMON_OAUTH_KEY] ?? '').trim();
-    return token.length > 0 ? token : null;
-}
-/**
- * Read the FULL `claude` bundle env — the main `CLAUDE_CODE_OAUTH_TOKEN` plus any
- * per-account `CLAUDE_CODE_OAUTH_TOKEN_<slug>` setup-tokens. Same resolution and
- * never-throws contract as {@link readDaemonClaudeOAuthToken}; returns `{}` when
- * the bundle can't be read (broker-only headless miss, absent bundle, etc.).
- */
-export function readDaemonClaudeBundleEnv(opts = {}) {
-    try {
-        const allowPrompt = opts.allowPrompt ?? Boolean(process.stdin.isTTY);
-        const { env } = readAndResolveBundleEnv(DAEMON_OAUTH_BUNDLE, {
-            caller: 'daemon',
-            agentOnly: !allowPrompt,
-        });
-        return env;
-    }
-    catch {
-        return {};
-    }
-}
 /** Escape a string for safe inclusion in an XML <string> node. */
 function xmlEscape(s) {
     return s
@@ -892,11 +818,10 @@ export function writeOwnerOnlyServiceManifest(filePath, content) {
 /**
  * Generate a macOS launchd plist for auto-starting the daemon.
  *
- * The plist never embeds the Claude OAuth token (RUSH-1759): a persisted service
- * manifest is a plaintext credential on disk even at 0600. The daemon instead
- * obtains the token at startup from the `claude` secrets bundle
- * (readDaemonClaudeOAuthToken, injected in runDaemon), so it stays in the
- * Keychain-backed secure store and never touches the unit file.
+ * The plist never embeds a Claude OAuth token: the daemon holds no Claude
+ * credential at all. Routine runs authenticate through the per-account
+ * CLAUDE_CONFIG_DIR login on this device, exactly like an interactive
+ * `agents run`, so no credential ever touches the service manifest.
  */
 export function generateLaunchdPlist(agentsBin = getAgentsBinPath()) {
     const launch = getDaemonLaunch(agentsBin);
@@ -934,11 +859,10 @@ function systemdExecArg(value) {
 /**
  * Generate a Linux systemd user unit for auto-starting the daemon.
  *
- * The unit never embeds the Claude OAuth token (RUSH-1759): a persisted service
- * manifest is a plaintext credential on disk even at 0600. The daemon instead
- * obtains the token at startup from the `claude` secrets bundle
- * (readDaemonClaudeOAuthToken, injected in runDaemon), so it stays in the secure
- * store and never touches the unit file.
+ * The unit never embeds a Claude OAuth token: the daemon holds no Claude
+ * credential at all. Routine runs authenticate through the per-account
+ * CLAUDE_CONFIG_DIR login on this device, exactly like an interactive
+ * `agents run`, so no credential ever touches the unit file.
  */
 export function generateSystemdUnit(agentsBin = getAgentsBinPath()) {
     const launch = getDaemonLaunch(agentsBin);
@@ -1082,31 +1006,6 @@ function startDaemonLocked(agentsBin) {
     }
     return startDetached({ agentsBin });
 }
-/**
- * Environment for the detached daemon fallback. The launchd/systemd paths
- * deliver the long-lived OAuth token via the service manifest's environment;
- * the detached path has no manifest, so inject it here. Read happens during an
- * interactive `routines start`, so a Keychain Touch ID prompt can be satisfied;
- * the daemon then passes it to every routine run it spawns. An already-set
- * value (e.g. inherited from launchd) is left untouched.
- */
-export function buildDetachedDaemonEnv(baseEnv = process.env, bundleEnv = readDaemonClaudeBundleEnv()) {
-    const env = { ...baseEnv };
-    if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
-        const main = (bundleEnv[DAEMON_OAUTH_KEY] ?? '').trim();
-        if (main)
-            env.CLAUDE_CODE_OAUTH_TOKEN = main;
-    }
-    // Per-account setup-tokens — same rationale as the runDaemon startup injection:
-    // a routine authenticates its rotation-pinned account via that account's own
-    // long-lived, non-rotating token. An already-set value wins.
-    for (const [k, v] of Object.entries(bundleEnv)) {
-        if (k.startsWith('CLAUDE_CODE_OAUTH_TOKEN_') && (v ?? '').trim() && !env[k]) {
-            env[k] = v.trim();
-        }
-    }
-    return env;
-}
 /**
  * Resolve how to launch the daemon: `node <entry> __daemon-run`, matching the
  * exact form that works under a direct `__daemon-run`.
@@ -1186,7 +1085,7 @@ export function startDetached(opts = {}) {
     const child = spawn(command, args, {
         stdio: ['ignore', logFd, logFd],
         ...backgroundSpawnOptions({ fdStdio: true }),
-        env: opts.env ?? buildDetachedDaemonEnv(),
+        env: opts.env ?? process.env,
     });
     // A failed spawn (ENOENT/EACCES) emits 'error' asynchronously; without a
     // listener that would crash the parent as an unhandled EventEmitter error.

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

@@ -0,0 +1,101 @@
+/**
+ * Cross-device harness divergence for `agents doctor` (RUSH-2027).
+ *
+ * `agents fleet status` already fans out `agents doctor --json` per device and
+ * builds a {@link FleetHealthReport} of coarse device health (reachable, CLIs
+ * installed, agents-cli version skew, local sync drift). It deliberately does
+ * NOT compare fine-grained *resource presence* across devices — so a plugin like
+ * `swarm` installed on one box but missing on another is silent until a user
+ * types `/swarm:run` on the wrong machine and gets `Unknown command`.
+ *
+ * This module is the missing comparison. Each device self-reports its installed
+ * inventory (resource kinds, per-agent version sets, `.agents`/`.system` repo
+ * state) in its `doctor --json` payload; {@link compareFleetInventories} takes
+ * the collected per-device inventories and, treating the local machine as the
+ * baseline, flags:
+ *
+ *   1. Resource presence gaps  — a resource present on one device, missing on
+ *      another (either direction relative to the local baseline).
+ *   2. Agent version gaps      — an agent version installed on one device but
+ *      not another (e.g. `yosemite-s0 missing claude@2.1.220`).
+ *   3. `.agents`/`.system` repo drift — a device whose config-repo HEAD, branch,
+ *      or dirty state diverges from the local baseline.
+ *
+ * Pure and SSH-free: the SSH fan-out lives in the doctor command; this module
+ * only consumes the already-collected payloads, so the divergence logic is
+ * unit-tested against fixture inventories with no live fleet.
+ */
+/** Resource kinds compared across devices. Mirrors {@link DoctorKind} plus the
+ *  top-level `workflows`/`memory` inventory that `getAvailableResources` emits;
+ *  `promptcuts` is a single present/absent bit surfaced as one named resource. */
+export type FleetResourceKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'permissions' | 'subagents' | 'plugins' | 'promptcuts' | 'workflows';
+export declare const FLEET_RESOURCE_KINDS: FleetResourceKind[];
+/** Per-repo state for the `.agents` (user) or `.system` config repo, as a device
+ *  self-reports it. `null` fields mean "not a git repo / unreadable" on that box. */
+export interface RepoState {
+    /** Current branch, or null when detached / unreadable. */
+    branch: string | null;
+    /** Short HEAD commit (8 chars), or null when unreadable. */
+    head: string | null;
+    /** True when the working tree has uncommitted changes. */
+    dirty: boolean;
+}
+/**
+ * The self-reported harness inventory a single device emits in `doctor --json`.
+ * Comparable device-to-device with no further probing.
+ */
+export interface FleetInventory {
+    /** Installed resource names per kind. `rules` here are the top-level rules
+     *  files (memory presets), not per-agent compiled AGENTS.md. */
+    resources: Record<FleetResourceKind, string[]>;
+    /** Installed version ids per agent id (e.g. `{ claude: ['2.1.170','2.1.220'] }`). */
+    agentVersions: Record<string, string[]>;
+    /** State of the user (`~/.agents`) and system (`~/.agents/.system`) config repos. */
+    repos: {
+        agents: RepoState | null;
+        system: RepoState | null;
+    };
+}
+/** A device's inventory paired with its name (and reachability). A device that
+ *  was unreachable / failed to report carries `inventory: null` and is skipped
+ *  by the comparison (its absence is a `fleet status` concern, not divergence). */
+export interface DeviceInventory {
+    name: string;
+    inventory: FleetInventory | null;
+}
+export type FleetDivergenceKind = 'resource-missing-remote' | 'resource-missing-local' | 'agent-version-missing-remote' | 'agent-version-missing-local' | 'repo-drift';
+/** One cross-device divergence finding, baseline = the local machine. */
+export interface FleetDivergence {
+    kind: FleetDivergenceKind;
+    /** The device the finding is about (the remote box, or the local box for a
+     *  `*-missing-local` finding where a remote has something local lacks). */
+    device: string;
+    /** Resource kind for a resource finding; agent id for a version finding;
+     *  `agents`/`system` for a repo finding. */
+    category: string;
+    /** The specific resource name / version id / repo label that diverges. */
+    name: string;
+    /** Human-readable one-liner, ready for the warnings list. */
+    message: string;
+}
+export interface FleetDivergenceReport {
+    /** Name of the device used as the comparison baseline (the local machine). */
+    baseline: string;
+    divergences: FleetDivergence[];
+    /** Devices that reported an inventory and were compared. */
+    comparedDevices: string[];
+    /** Devices that could not be compared (offline / no inventory in payload). */
+    skippedDevices: string[];
+    hasDivergence: boolean;
+}
+/**
+ * Compare a set of per-device inventories against the local baseline and emit
+ * every cross-device divergence. The baseline is the device whose name equals
+ * {@link baselineName} (the local machine); if that device has no inventory the
+ * report is empty (nothing to compare against). Devices with no inventory are
+ * recorded under `skippedDevices` and never produce false "missing" findings.
+ *
+ * Ordering is deterministic (device, then category, then name) so the human and
+ * JSON output — and the tests — are stable.
+ */
+export declare function compareFleetInventories(devices: DeviceInventory[], baselineName: string): FleetDivergenceReport;

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

@@ -0,0 +1,188 @@
+/**
+ * Cross-device harness divergence for `agents doctor` (RUSH-2027).
+ *
+ * `agents fleet status` already fans out `agents doctor --json` per device and
+ * builds a {@link FleetHealthReport} of coarse device health (reachable, CLIs
+ * installed, agents-cli version skew, local sync drift). It deliberately does
+ * NOT compare fine-grained *resource presence* across devices — so a plugin like
+ * `swarm` installed on one box but missing on another is silent until a user
+ * types `/swarm:run` on the wrong machine and gets `Unknown command`.
+ *
+ * This module is the missing comparison. Each device self-reports its installed
+ * inventory (resource kinds, per-agent version sets, `.agents`/`.system` repo
+ * state) in its `doctor --json` payload; {@link compareFleetInventories} takes
+ * the collected per-device inventories and, treating the local machine as the
+ * baseline, flags:
+ *
+ *   1. Resource presence gaps  — a resource present on one device, missing on
+ *      another (either direction relative to the local baseline).
+ *   2. Agent version gaps      — an agent version installed on one device but
+ *      not another (e.g. `yosemite-s0 missing claude@2.1.220`).
+ *   3. `.agents`/`.system` repo drift — a device whose config-repo HEAD, branch,
+ *      or dirty state diverges from the local baseline.
+ *
+ * Pure and SSH-free: the SSH fan-out lives in the doctor command; this module
+ * only consumes the already-collected payloads, so the divergence logic is
+ * unit-tested against fixture inventories with no live fleet.
+ */
+export const FLEET_RESOURCE_KINDS = [
+    'commands',
+    'skills',
+    'hooks',
+    'rules',
+    'mcp',
+    'permissions',
+    'subagents',
+    'plugins',
+    'promptcuts',
+    'workflows',
+];
+function sortedUnique(list) {
+    return Array.from(new Set(list)).sort();
+}
+function repoLabel(repo) {
+    return repo === 'agents' ? '.agents' : '.system';
+}
+/** 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). */
+function describeRepoDrift(local, remote) {
+    if (local.head && remote.head && local.head !== remote.head) {
+        return `HEAD ${remote.head} != local ${local.head}`;
+    }
+    if (local.branch !== remote.branch) {
+        return `branch ${remote.branch ?? 'detached'} != local ${local.branch ?? 'detached'}`;
+    }
+    // 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';
+    }
+    return null;
+}
+/**
+ * Compare a set of per-device inventories against the local baseline and emit
+ * every cross-device divergence. The baseline is the device whose name equals
+ * {@link baselineName} (the local machine); if that device has no inventory the
+ * report is empty (nothing to compare against). Devices with no inventory are
+ * recorded under `skippedDevices` and never produce false "missing" findings.
+ *
+ * Ordering is deterministic (device, then category, then name) so the human and
+ * JSON output — and the tests — are stable.
+ */
+export function compareFleetInventories(devices, baselineName) {
+    const baseline = devices.find((d) => d.name === baselineName)?.inventory ?? null;
+    const remotes = devices.filter((d) => d.name !== baselineName);
+    const comparedDevices = [];
+    const skippedDevices = [];
+    const divergences = [];
+    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).
+        for (const d of remotes)
+            skippedDevices.push(d.name);
+        return {
+            baseline: baselineName,
+            divergences: [],
+            comparedDevices: [],
+            skippedDevices: skippedDevices.sort(),
+            hasDivergence: false,
+        };
+    }
+    for (const remote of remotes) {
+        if (!remote.inventory) {
+            skippedDevices.push(remote.name);
+            continue;
+        }
+        comparedDevices.push(remote.name);
+        const inv = remote.inventory;
+        // 1) Resource presence, both directions.
+        for (const kind of FLEET_RESOURCE_KINDS) {
+            const localSet = new Set(baseline.resources[kind] ?? []);
+            const remoteSet = new Set(inv.resources[kind] ?? []);
+            for (const name of sortedUnique(baseline.resources[kind] ?? [])) {
+                if (!remoteSet.has(name)) {
+                    divergences.push({
+                        kind: 'resource-missing-remote',
+                        device: remote.name,
+                        category: kind,
+                        name,
+                        message: `${remote.name} is missing ${kind.replace(/s$/, '')} '${name}' (present on ${baselineName})`,
+                    });
+                }
+            }
+            for (const name of sortedUnique(inv.resources[kind] ?? [])) {
+                if (!localSet.has(name)) {
+                    divergences.push({
+                        kind: 'resource-missing-local',
+                        device: remote.name,
+                        category: kind,
+                        name,
+                        message: `${baselineName} is missing ${kind.replace(/s$/, '')} '${name}' (present on ${remote.name})`,
+                    });
+                }
+            }
+        }
+        // 2) Agent version parity, both directions, per agent id.
+        const agentIds = sortedUnique([
+            ...Object.keys(baseline.agentVersions),
+            ...Object.keys(inv.agentVersions),
+        ]);
+        for (const agent of agentIds) {
+            const localVers = new Set(baseline.agentVersions[agent] ?? []);
+            const remoteVers = new Set(inv.agentVersions[agent] ?? []);
+            for (const v of sortedUnique(baseline.agentVersions[agent] ?? [])) {
+                if (!remoteVers.has(v)) {
+                    divergences.push({
+                        kind: 'agent-version-missing-remote',
+                        device: remote.name,
+                        category: agent,
+                        name: v,
+                        message: `${remote.name} is missing ${agent}@${v} (installed on ${baselineName})`,
+                    });
+                }
+            }
+            for (const v of sortedUnique(inv.agentVersions[agent] ?? [])) {
+                if (!localVers.has(v)) {
+                    divergences.push({
+                        kind: 'agent-version-missing-local',
+                        device: remote.name,
+                        category: agent,
+                        name: v,
+                        message: `${baselineName} is missing ${agent}@${v} (installed on ${remote.name})`,
+                    });
+                }
+            }
+        }
+        // 3) `.agents` / `.system` repo drift vs the local baseline.
+        for (const repo of ['agents', 'system']) {
+            const localRepo = baseline.repos[repo];
+            const remoteRepo = inv.repos[repo];
+            if (!localRepo || !remoteRepo)
+                continue; // one side isn't a readable repo
+            const drift = describeRepoDrift(localRepo, remoteRepo);
+            if (drift) {
+                divergences.push({
+                    kind: 'repo-drift',
+                    device: remote.name,
+                    category: repo,
+                    name: repoLabel(repo),
+                    message: `${remote.name} ${repoLabel(repo)} repo diverged: ${drift}`,
+                });
+            }
+        }
+    }
+    divergences.sort((a, b) => a.device.localeCompare(b.device) ||
+        a.kind.localeCompare(b.kind) ||
+        a.category.localeCompare(b.category) ||
+        a.name.localeCompare(b.name));
+    return {
+        baseline: baselineName,
+        divergences,
+        comparedDevices: comparedDevices.sort(),
+        skippedDevices: skippedDevices.sort(),
+        hasDivergence: divergences.length > 0,
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Build the self-reported harness inventory a device emits in `doctor --json`
+ * for cross-device divergence detection (RUSH-2027).
+ *
+ * Kept separate from {@link ../devices/fleet-divergence.js} — which stays a pure,
+ * SSH-free comparator — because this reads the live install (resource dirs,
+ * installed version homes, config repos). One call produces the {@link
+ * 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';
+/**
+ * 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.
+ */
+export declare function collectLocalFleetInventory(cwd?: string): FleetInventory;

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

@@ -0,0 +1,57 @@
+/**
+ * Build the self-reported harness inventory a device emits in `doctor --json`
+ * for cross-device divergence detection (RUSH-2027).
+ *
+ * Kept separate from {@link ../devices/fleet-divergence.js} — which stays a pure,
+ * SSH-free comparator — because this reads the live install (resource dirs,
+ * installed version homes, config repos). One call produces the {@link
+ * 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 { 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';
+function toRepoState(snap) {
+    if (!snap)
+        return null;
+    return { branch: snap.branch, head: snap.head, dirty: snap.dirty };
+}
+/**
+ * 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.
+ */
+export function collectLocalFleetInventory(cwd = process.cwd()) {
+    const available = getAvailableResources(cwd);
+    const resources = {};
+    for (const kind of FLEET_RESOURCE_KINDS) {
+        if (kind === 'promptcuts') {
+            resources[kind] = available.promptcuts ? ['promptcuts.yaml'] : [];
+        }
+        else if (kind === 'rules') {
+            // getAvailableResources exposes top-level rules under `memory`.
+            resources[kind] = [...available.memory].sort();
+        }
+        else {
+            resources[kind] = [...(available[kind] ?? [])].sort();
+        }
+    }
+    const agentVersions = {};
+    for (const agent of ALL_AGENT_IDS) {
+        const versions = listInstalledVersions(agent);
+        if (versions.length > 0)
+            agentVersions[agent] = [...versions].sort();
+    }
+    return {
+        resources,
+        agentVersions,
+        repos: {
+            agents: toRepoState(readRepoState(getUserAgentsDir())),
+            system: toRepoState(readRepoState(getSystemAgentsDir())),
+        },
+    };
+}