@phnx-labs/agents-cli 1.20.77 → 1.20.82

package/dist/lib/daemon.d.ts

@@ -68,28 +68,25 @@ export declare function reapStrayDaemons(keepPid?: number): {
 /** Append a JSONL log entry to the daemon log file (owner-only permissions). */
 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.).
+ * Anchor the daemon's working directory to a stable, always-present path.
+ *
+ * The daemon is long-lived and inherits whatever cwd it was launched from — often
+ * a git worktree (e.g. a `.agents/worktrees/<slug>/` a session happened to be in).
+ * When that directory is later removed (`git worktree remove`, `rm -rf`), the
+ * daemon keeps the deleted inode as its cwd — a process cannot chdir out of a
+ * deleted directory on its own — and every job it spawns inherits the dead cwd
+ * (`spawnJobAttempt` and command runs pass no explicit `cwd`, so the child uses
+ * the parent's). Bun then fails `getcwd()` during startup and every routine crashes
+ * at 0 seconds with `ENOENT: Bun could not find a file` before the agent even runs.
+ *
+ * Re-anchoring to the home directory once, at daemon startup, makes the daemon
+ * immune regardless of how it was launched (systemd unit, launchd, or a manual
+ * `agents __daemon-run` from any directory). Returns the resolved cwd, or null if
+ * anchoring failed (logged, non-fatal).
  */
-export declare function readDaemonClaudeBundleEnv(opts?: {
-    allowPrompt?: boolean;
-}): Record<string, string>;
+export declare function anchorDaemonCwd(): string | null;
+export declare function runDaemon(): Promise<void>;
 /**
  * Write a launchd plist or systemd unit with owner-only permissions atomically.
  *
@@ -103,21 +100,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 +135,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 +183,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

@@ -11,18 +11,16 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { getDaemonDir as getDaemonDirRoot } from './state.js';
-import { isAlive, killTree, backgroundSpawnOptions } from './platform/index.js';
+import { isAlive, killTree, backgroundSpawnOptions, waitForExit } from './platform/index.js';
 import { listJobs as listAllJobs } from './routines.js';
 import { syncAllProjectRoutines } from './routines-project.js';
 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
@@ -179,6 +171,10 @@ export function isDaemonWedged() {
     const elapsed = Date.now() - Date.parse(hb.lastTick);
     return elapsed > WEDGE_THRESHOLD_TICKS * MONITOR_TICK_MS;
 }
+/** How long stopDaemon waits for a SIGTERMed daemon to exit before escalating. */
+const STOP_GRACE_MS = 5000;
+/** How long it waits after the hard tree-kill before giving up. */
+const STOP_KILL_GRACE_MS = 2000;
 /** Check if the daemon process is alive by sending signal 0 to the stored PID. */
 export function isDaemonRunning() {
     const pid = readDaemonPid();
@@ -297,6 +293,34 @@ export function log(level, message) {
     catch { /* best effort */ }
 }
 /** Main daemon loop: load jobs, schedule crons, monitor runs, and handle signals. */
+/**
+ * Anchor the daemon's working directory to a stable, always-present path.
+ *
+ * The daemon is long-lived and inherits whatever cwd it was launched from — often
+ * a git worktree (e.g. a `.agents/worktrees/<slug>/` a session happened to be in).
+ * When that directory is later removed (`git worktree remove`, `rm -rf`), the
+ * daemon keeps the deleted inode as its cwd — a process cannot chdir out of a
+ * deleted directory on its own — and every job it spawns inherits the dead cwd
+ * (`spawnJobAttempt` and command runs pass no explicit `cwd`, so the child uses
+ * the parent's). Bun then fails `getcwd()` during startup and every routine crashes
+ * at 0 seconds with `ENOENT: Bun could not find a file` before the agent even runs.
+ *
+ * Re-anchoring to the home directory once, at daemon startup, makes the daemon
+ * immune regardless of how it was launched (systemd unit, launchd, or a manual
+ * `agents __daemon-run` from any directory). Returns the resolved cwd, or null if
+ * anchoring failed (logged, non-fatal).
+ */
+export function anchorDaemonCwd() {
+    const home = os.homedir();
+    try {
+        process.chdir(home);
+        return home;
+    }
+    catch (err) {
+        log('WARN', `Could not anchor daemon cwd to ${home}: ${err.message}`);
+        return null;
+    }
+}
 export async function runDaemon() {
     // Single-instance guard: a direct `agents __daemon-run` (manual, or a
     // service-manager restart racing a live predecessor) must not clobber a
@@ -309,47 +333,14 @@ 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',
-            });
-        }
-    }
+    anchorDaemonCwd();
+    // 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 +824,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 +851,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 +892,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 +1039,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 +1118,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.
@@ -1262,11 +1194,19 @@ export function stopDaemon() {
                 process.kill(pid, 'SIGTERM');
             }
             catch { /* process already exited */ }
-            // Escalate to a hard tree-kill if it ignored SIGTERM after the grace period.
-            setTimeout(() => {
-                if (isAlive(pid))
-                    killTree(pid);
-            }, 5000);
+            // Wait for it to actually go. This used to be a setTimeout escalation plus
+            // an immediate removeDaemonPid(), which had two failure modes: in a
+            // short-lived process (the npm postinstall) the timer never fired at all,
+            // and clearing the pid file while the old daemon still ran made
+            // isDaemonRunning() report false, so startDaemon() launched a SECOND
+            // daemon. Its hosted broker then unlinked the live socket and rebound,
+            // orphaning the first broker with every unlocked bundle still in its RAM
+            // and unreachable — two brokers on one socket path, seen on a real machine
+            // after an install into a second prefix.
+            if (!waitForExit(pid, STOP_GRACE_MS)) {
+                killTree(pid);
+                waitForExit(pid, STOP_KILL_GRACE_MS);
+            }
         }
     }
     removeDaemonPid();

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;