@phnx-labs/agents-cli 1.22.46 → 1.22.49

package/dist/lib/daemon-services.js

@@ -67,6 +67,11 @@ export const DAEMON_SERVICES = [
         title: 'State-dir self-check',
         description: 'Self-terminates the daemon if its state directory is removed.',
     },
+    {
+        id: 'session-index',
+        title: 'Session-index warm',
+        description: 'Keeps this host\'s transcript index current so a locally-started session is discoverable within seconds.',
+    },
 ];
 /** Stable order of service IDs. */
 export const DAEMON_SERVICE_IDS = DAEMON_SERVICES.map((s) => s.id);
@@ -150,3 +155,53 @@ export function listDaemonServiceStates() {
     const cfg = readDaemonServicesConfig();
     return DAEMON_SERVICES.map((s) => ({ ...s, enabled: cfg.services[s.id] !== false }));
 }
+/**
+ * A tiny cross-process action queue for `agents daemon services restart <id>`
+ * (RUSH-3193 P4) — SIGHUP can only signal "reload", it carries no payload, so a
+ * restart request is dropped here first and the daemon's reload handler drains
+ * it. Same file-backed pattern as `services.yaml` above, for the same reason:
+ * the CLI invocation and the daemon are separate processes.
+ */
+function getDaemonServiceActionsPath() {
+    return path.join(getDaemonConfigDir(), 'service-actions.json');
+}
+/** Queue a live restart for `id`, to be picked up on the next SIGHUP reload. */
+export function queueDaemonServiceRestart(id) {
+    const filePath = getDaemonServiceActionsPath();
+    let ids = [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (Array.isArray(parsed.restart))
+            ids = parsed.restart;
+    }
+    catch {
+        // Missing or corrupt -> start a fresh queue.
+    }
+    if (!ids.includes(id))
+        ids.push(id);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    atomicWriteFileSync(filePath, JSON.stringify({ restart: ids }), 'utf-8');
+}
+/**
+ * Drain every queued restart request. Called once per SIGHUP reload by the
+ * daemon; never throws. Clears the file so a request is applied at most once.
+ */
+export function drainDaemonServiceRestartQueue() {
+    const filePath = getDaemonServiceActionsPath();
+    let ids = [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (Array.isArray(parsed.restart))
+            ids = parsed.restart;
+    }
+    catch {
+        return [];
+    }
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // Already gone.
+    }
+    return ids;
+}

package/dist/lib/daemon-ticks.d.ts

@@ -67,8 +67,9 @@ export declare function runFleetCacheWarmTick(): Promise<void>;
 /**
  * Usage refresh: keep the usage cache the `agents run` router reads
  * (RUSH-2061, readOnly hot path) fresh, WITHOUT the hot path ever fetching.
- * The configured primary host is the fleet's sole provider-facing writer;
- * subscribers import its token-free derived cache.
+ * Every host is its own provider-facing writer — it refreshes only the
+ * accounts it holds credentials for, straight from the provider APIs
+ * (RUSH-3193 #15; no cross-host broadcast).
  */
 export declare function runUsageRefreshTick(): Promise<void>;
 /**
@@ -79,9 +80,19 @@ export declare function runUsageRefreshTick(): Promise<void>;
  * Cadence matches {@link DEFAULT_ACTIVE_CACHE_MAX_AGE_MS} so one-shot readers and
  * long-lived watchers share one writer. Without this tick the journal has no
  * continuous producer and Factory freezes after the initial cache snapshot.
+ *
+ * Gated on reader presence (RUSH-3193): when no `sessions watch` / `feed watch`
+ * consumer has checked in within {@link ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS} the
+ * expensive `ps`+`lsof` gather is skipped entirely on this scheduled tick. A
+ * watcher connecting to a cold/idle daemon is NOT served by this tick alone —
+ * {@link noteActiveSessionsJournalReader} only writes a presence timestamp, with
+ * no path back to this timer — so the daemon separately runs
+ * {@link watchActiveSessionsReaderPresence} to detect that idle→recent edge and
+ * fire an out-of-band call into this same function immediately (RUSH-2484).
  */
 export declare function runActiveSessionsWarmTick(opts?: {
     gather?: () => Promise<import('./session/active.js').ActiveSession[]>;
+    nowMs?: number;
 }): Promise<{
     sessions: number;
 }>;

package/dist/lib/daemon-ticks.js

@@ -89,7 +89,7 @@ export async function refreshLocalFleetAuthState(opts) {
             // Fleet status publishes every tick regardless — it does not ride that endpoint.
             const cached = readFleetAuthRows(self);
             const reuse = shouldReuseCachedAuthProbe(force, cached, requestedAt);
-            const authRows = reuse ? cached : await probeLocalFleetAuth({ cliVersion: getCliVersion() });
+            const authRows = reuse ? cached : await probeLocalFleetAuth({ cliVersion: getCliVersion(), forceLive: force });
             if (!reuse)
                 writeFleetAuthRows(self, authRows);
             const row = await publishLocalFleetStatus(self);
@@ -108,35 +108,23 @@ export async function runFleetCacheWarmTick() {
 /**
  * Usage refresh: keep the usage cache the `agents run` router reads
  * (RUSH-2061, readOnly hot path) fresh, WITHOUT the hot path ever fetching.
- * The configured primary host is the fleet's sole provider-facing writer;
- * subscribers import its token-free derived cache.
+ * Every host is its own provider-facing writer — it refreshes only the
+ * accounts it holds credentials for, straight from the provider APIs
+ * (RUSH-3193 #15; no cross-host broadcast).
  */
 export async function runUsageRefreshTick() {
-    const { resolveUsagePrimaryHost } = await import('./device-config.js');
-    const { machineId } = await import('./machine-id.js');
-    // usage.primary-host, else interactive.host, else null (standalone local refresh)
-    const primaryHost = resolveUsagePrimaryHost() ?? undefined;
-    const self = machineId();
-    const { importUsageFleetFromHost, usageRefreshRole } = await import('./usage-fleet.js');
-    if (usageRefreshRole(primaryHost, self) === 'subscriber') {
-        const imported = await importUsageFleetFromHost(primaryHost);
-        console.log(`usage refresh: imported ${Object.keys(imported.usage).length} account(s) from primary host ${primaryHost}`);
-        return;
-    }
     const { runUsageRefresh, buildLocalUsageAccounts } = await import('./usage-refresh.js');
     const { writeClaudeUsageCache } = await import('./accounting/usage.js');
     const { usageRateLimitedUntil } = await import('./usage-backoff.js');
     const r = await runUsageRefresh({
         listAccounts: buildLocalUsageAccounts,
         writeUsageCache: writeClaudeUsageCache,
-        backoffUntil: usageRateLimitedUntil,
+        backoffUntil: (agentId, usageKey) => usageRateLimitedUntil(agentId, Date.now(), usageKey),
     });
     const { listProfiles } = await import('./profiles.js');
     const { refreshDueByokUsage } = await import('./byok-usage.js');
     const byok = await refreshDueByokUsage(listProfiles());
-    const { exportUsageFleet } = await import('./usage-fleet.js');
-    const published = exportUsageFleet();
-    console.log(`usage refresh: ${r.refreshed} refreshed, ${r.failed} failed, ${r.skippedNotDue} not-due, ${r.skippedBackoff} backed-off, ${r.skippedCap} capped; BYOK ${byok.refreshed} refreshed, ${byok.skipped} not-due; published ${Object.keys(published.usage).length} account(s)`);
+    console.log(`usage refresh: ${r.refreshed} refreshed, ${r.failed} failed, ${r.skippedNotDue} not-due, ${r.skippedBackoff} backed-off, ${r.skippedCap} capped; BYOK ${byok.refreshed} refreshed, ${byok.skipped} not-due`);
 }
 /**
  * Active-sessions warm (RUSH-2062 / RUSH-2484): publish THIS host's live session
@@ -146,10 +134,24 @@ export async function runUsageRefreshTick() {
  * Cadence matches {@link DEFAULT_ACTIVE_CACHE_MAX_AGE_MS} so one-shot readers and
  * long-lived watchers share one writer. Without this tick the journal has no
  * continuous producer and Factory freezes after the initial cache snapshot.
+ *
+ * Gated on reader presence (RUSH-3193): when no `sessions watch` / `feed watch`
+ * consumer has checked in within {@link ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS} the
+ * expensive `ps`+`lsof` gather is skipped entirely on this scheduled tick. A
+ * watcher connecting to a cold/idle daemon is NOT served by this tick alone —
+ * {@link noteActiveSessionsJournalReader} only writes a presence timestamp, with
+ * no path back to this timer — so the daemon separately runs
+ * {@link watchActiveSessionsReaderPresence} to detect that idle→recent edge and
+ * fire an out-of-band call into this same function immediately (RUSH-2484).
  */
 export async function runActiveSessionsWarmTick(opts = {}) {
-    const { publishLocalActiveSessions } = await import('./session/session-cache.js');
-    const r = await publishLocalActiveSessions({ gather: opts.gather });
+    const { publishLocalActiveSessions, isActiveSessionsJournalReaderRecent } = await import('./session/session-cache.js');
+    const nowMs = opts.nowMs ?? Date.now();
+    if (!isActiveSessionsJournalReaderRecent(nowMs)) {
+        console.log('active-sessions warm: idle (no recent reader), skipping gather');
+        return { sessions: 0 };
+    }
+    const r = await publishLocalActiveSessions({ gather: opts.gather, nowMs });
     console.log(`active-sessions warm: ${r.sessions.length} session(s) published`);
     return { sessions: r.sessions.length };
 }

package/dist/lib/device-config.d.ts

@@ -124,8 +124,6 @@ export declare function listConfig(opts?: ConfigTarget): ConfigEntry[];
 /** List user-scope config keys with their values. Used to show inherited settings
  * in per-device views without implying those keys are device-local. */
 export declare function listUserConfig(): ConfigEntry[];
-/** Resolve the explicit usage host, falling back to the user's interactive host. */
-export declare function resolveUsagePrimaryHost(): string | null;
 /**
  * Set a config key (validated). Device-scope keys target this machine unless
  * `opts.device` names a peer; `opts.fleet` writes the fleet-wide defaults layer
@@ -147,8 +145,32 @@ export type AutoPoolMode = (typeof AUTO_POOL_MODES)[number];
  * explicit `worker` mark (see {@link listConfiguredDeviceRoles}).
  */
 export declare function configuredDeviceRole(name: string): ConfiguredDeviceRole | undefined;
+/**
+ * The role marked on THIS machine — the one running the CLI — or undefined when
+ * it was never marked. Keyed off {@link machineId} (overridable via
+ * AGENTS_SYNC_MACHINE_ID), so it matches the device's own config-folder key.
+ *
+ * The auth strategy reads this: a `personal` device (the user's own interactive
+ * box) holds a real per-version login and MUST authenticate from it for EVERY
+ * run, interactive or headless; only a `worker` uses the file-based setup-token
+ * (RUSH-2395). `undefined` is treated as non-personal (worker-equivalent) by
+ * that gate — an unmarked box has no login to defer to.
+ */
+export declare function selfConfiguredDeviceRole(): ConfiguredDeviceRole | undefined;
 /** Mark a device's role fleet-wide; `undefined` clears the mark. */
 export declare function setConfiguredDeviceRole(name: string, role: ConfiguredDeviceRole | undefined): void;
+/**
+ * Devices whose OWN config pins one of the browser profile keys to `profile`.
+ *
+ * Used by `profiles rename` to warn rather than silently leave a peer pointing at
+ * a name that no longer exists. Deliberately read-only: rewriting another
+ * machine's device doc from here would be a cross-machine mutation nobody asked
+ * for, and the pin may well be correct there (a local profile of the same name).
+ */
+export declare function devicesPinningBrowserProfile(profile: string): Array<{
+    device: string;
+    key: 'browser.profile' | 'browser.viewer';
+}>;
 /**
  * Every device with an effective role, keyed by device name. Layers like every
  * other device-scope key: the fleet default (central fleet.defaults.config)
@@ -194,14 +216,7 @@ export declare function isSchedulerEnabled(): boolean;
  * scheduler init) refuses with.
  */
 export declare function assertSchedulerEnabled(): void;
-/**
- * True unless this machine's config turns off the managed tmux wrap for
- * interactive `agents run` launches (`tmux.enabled=false`).
- *
- * Read as one of the guards in `shouldWrapInTmux` (lib/exec.ts) — the durable,
- * per-machine form of `--no-tmux` / `AGENTS_NO_TMUX=1`, for a box whose tmux is
- * broken or unwanted. Unset means today's behavior: wrap.
- */
+/** True only when this machine explicitly enables the managed tmux wrap. */
 export declare function isTmuxEnabled(): boolean;
 /** True unless this machine's config disables the daemon outright (top-level kill switch). */
 export declare function isDaemonEnabled(): boolean;

package/dist/lib/device-config.js

@@ -36,7 +36,7 @@ import * as yaml from 'yaml';
 import { META_HEADER, getUserAgentsDir, readMeta, updateMeta, withMetaLock } from './state.js';
 import { atomicWriteFileSync } from './fs-atomic.js';
 import { machineId } from './machine-id.js';
-import { assertValidDeviceName } from './devices/registry.js';
+import { assertValidDeviceName, assertRegistrableDeviceName } from './devices/registry.js';
 import { migrateDeviceConfigStores } from './devices/config-migration.js';
 const DEVICE_PLATFORMS = ['windows', 'linux', 'macos', 'unknown'];
 const SSH_AUTH_METHODS = ['key', 'password'];
@@ -53,23 +53,7 @@ export const CONFIG_KEYS = [
         description: 'Device that shows the user artifacts (browser opens, dashboards) — the "online macOS box" skills should use instead of guessing.',
         validate: (v) => {
             try {
-                assertValidDeviceName(v);
-                return null;
-            }
-            catch (err) {
-                return err?.message ?? String(err);
-            }
-        },
-    },
-    {
-        name: 'usage.primary-host',
-        yamlKey: 'usagePrimaryHost',
-        scope: 'user',
-        type: 'string',
-        description: 'Device whose usage snapshots are authoritative for fleet-wide usage reporting.',
-        validate: (v) => {
-            try {
-                assertValidDeviceName(v);
+                assertRegistrableDeviceName(v);
                 return null;
             }
             catch (err) {
@@ -90,6 +74,18 @@ export const CONFIG_KEYS = [
             ? null
             : `auto.pool must be one of ${AUTO_POOL_MODES.join(' | ')}.`,
     },
+    {
+        name: 'browser.viewer',
+        yamlKey: 'browserViewer',
+        scope: 'device',
+        visibility: 'machine',
+        type: 'string',
+        description: "Which browser THIS machine shows YOU a page in (an .html artifact, `agents feedback`, a login " +
+            "dashboard): a profile name, or `os` for the OS default handler. Unset follows browser.profile. " +
+            "Distinct from browser.profile, which is the profile agents DRIVE — see RUSH-2709 for why " +
+            "collapsing the two was a mistake. Set it to `os` to keep the OS default handler.",
+        validate: (v) => typeof v === 'string' && v.length > 0 ? null : 'browser.viewer must be `os` or a profile name.',
+    },
     {
         name: 'browser.profile',
         yamlKey: 'defaultBrowserProfile',
@@ -144,11 +140,10 @@ export const CONFIG_KEYS = [
         scope: 'device',
         visibility: 'machine',
         type: 'bool',
-        defaultValue: true,
+        defaultValue: false,
         description: 'Whether an interactive `agents run` on this device is wrapped in the shared-socket tmux session. ' +
-            'On gives every agent an addressable pane (`agents sessions --active` tells co-located agents apart, ' +
-            '`agents focus` re-attaches without forking). Off spawns the agent directly on this box — the durable ' +
-            'form of `--no-tmux`, for a machine whose tmux is broken or unwanted.',
+            'Off, the default, spawns the agent directly. Turn it on to give every agent an addressable pane for ' +
+            '`agents message`, injection, and `agents focus` once the tmux mouse, clipboard, and scrollback behavior suits this device.',
     },
     {
         name: 'browser.remote-control',
@@ -170,7 +165,7 @@ export const CONFIG_KEYS = [
         description: 'Minutes a browser task may sit with no IPC action (navigate, click, type, screenshot, …) before the daemon\'s ' +
             'abandoned-task reaper closes its tabs and marks it done (RUSH-2622). 0 disables idle reaping — the reaper still ' +
             "closes a task whose owning agent session has exited, whatever this is set to. Read only on THIS box's own " +
-            'reaper tick and `agents browser gc`, so it never applies to a peer.',
+            'reaper tick and `agents browser prune`, so it never applies to a peer.',
         validate: (v) => v >= 0 ? null : 'browser.task-idle-minutes must be >= 0 (0 disables idle reaping).',
     },
     {
@@ -179,7 +174,26 @@ export const CONFIG_KEYS = [
         scope: 'device',
         visibility: 'shared',
         type: 'string-list',
-        description: 'Free-form operator notes about this device (one entry per `agents devices config <name> notes <text>`).',
+        description: 'Free-form operator notes about this device (one entry per `agents devices config <name> notes <text>`). ' +
+            'Long-form scratch, never shown in device listings — for the one-line synced summary of what the box is for, use `description`.',
+    },
+    {
+        name: 'description',
+        yamlKey: 'description',
+        scope: 'device',
+        visibility: 'shared',
+        type: 'string',
+        description: 'One line saying what this device is FOR ("gpu box — cuda 12.4"), synced fleet-wide. Kept to one short line ' +
+            'because the device-list renderer will show it (RUSH-3062, `surface` track). ' +
+            'Replaces the value on each set; for appended long-form scratch use `notes`.',
+        validate: (v) => {
+            const s = v;
+            if (s.includes('\n') || s.includes('\r'))
+                return 'description must be a single line.';
+            if (s.length > 80)
+                return `description must be at most 80 characters (got ${s.length}) — it is a one-line table cell.`;
+            return null;
+        },
     },
     {
         name: 'ssh.user',
@@ -456,12 +470,6 @@ export function listConfig(opts) {
 export function listUserConfig() {
     return CONFIG_KEYS.filter((spec) => spec.scope === 'user').map((spec) => getConfigValue(spec.name));
 }
-/** Resolve the explicit usage host, falling back to the user's interactive host. */
-export function resolveUsagePrimaryHost() {
-    return getConfigValue('usage.primary-host').value
-        ?? getConfigValue('interactive.host').value
-        ?? null;
-}
 // ─── Writes ───────────────────────────────────────────────────────────────────
 /** The fleet manifest for a defaults write: `devices` materializes as an
  * explicit empty map (NOT 'all') so `agents apply` targets nothing until the
@@ -593,6 +601,20 @@ export function configuredDeviceRole(name) {
     assertValidDeviceName(name);
     return getConfigValue('role', { device: name }).value;
 }
+/**
+ * The role marked on THIS machine — the one running the CLI — or undefined when
+ * it was never marked. Keyed off {@link machineId} (overridable via
+ * AGENTS_SYNC_MACHINE_ID), so it matches the device's own config-folder key.
+ *
+ * The auth strategy reads this: a `personal` device (the user's own interactive
+ * box) holds a real per-version login and MUST authenticate from it for EVERY
+ * run, interactive or headless; only a `worker` uses the file-based setup-token
+ * (RUSH-2395). `undefined` is treated as non-personal (worker-equivalent) by
+ * that gate — an unmarked box has no login to defer to.
+ */
+export function selfConfiguredDeviceRole() {
+    return configuredDeviceRole(machineId());
+}
 /** Mark a device's role fleet-wide; `undefined` clears the mark. */
 export function setConfiguredDeviceRole(name, role) {
     assertValidDeviceName(name);
@@ -601,6 +623,42 @@ export function setConfiguredDeviceRole(name, role) {
     else
         setConfigValue('role', role, { device: name });
 }
+/**
+ * Devices whose OWN config pins one of the browser profile keys to `profile`.
+ *
+ * Used by `profiles rename` to warn rather than silently leave a peer pointing at
+ * a name that no longer exists. Deliberately read-only: rewriting another
+ * machine's device doc from here would be a cross-machine mutation nobody asked
+ * for, and the pin may well be correct there (a local profile of the same name).
+ */
+export function devicesPinningBrowserProfile(profile) {
+    ensureDeviceConfigMigrated();
+    // Reports WHICH key each device used, not just that it matched. A caller
+    // telling the user to fix `browser.profile` on a device that actually pinned
+    // `browser.viewer` leaves the real pin broken and sets a second key nobody
+    // asked for.
+    const hits = [];
+    const devicesRoot = path.join(getUserAgentsDir(), 'devices');
+    let names = [];
+    try {
+        names = fs
+            .readdirSync(devicesRoot, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return hits;
+    }
+    for (const name of names.sort()) {
+        const cfg = readDeviceDocConfig(name);
+        // A device can pin BOTH; each needs its own fix line.
+        if (cfg.defaultBrowserProfile === profile)
+            hits.push({ device: name, key: 'browser.profile' });
+        if (cfg.browserViewer === profile)
+            hits.push({ device: name, key: 'browser.viewer' });
+    }
+    return hits;
+}
 /**
  * Every device with an effective role, keyed by device name. Layers like every
  * other device-scope key: the fleet default (central fleet.defaults.config)
@@ -720,16 +778,9 @@ export function assertSchedulerEnabled() {
     throw new Error(`The routines scheduler is disabled on this device (scheduler.enabled=false in ~/.agents/devices/${machineId()}/agents.yaml). ` +
         `Re-enable with: agents devices config ${machineId()} scheduler.enabled on`);
 }
-/**
- * True unless this machine's config turns off the managed tmux wrap for
- * interactive `agents run` launches (`tmux.enabled=false`).
- *
- * Read as one of the guards in `shouldWrapInTmux` (lib/exec.ts) — the durable,
- * per-machine form of `--no-tmux` / `AGENTS_NO_TMUX=1`, for a box whose tmux is
- * broken or unwanted. Unset means today's behavior: wrap.
- */
+/** True only when this machine explicitly enables the managed tmux wrap. */
 export function isTmuxEnabled() {
-    return getConfigValue('tmux.enabled').value !== false;
+    return getConfigValue('tmux.enabled').value === true;
 }
 /** True unless this machine's config disables the daemon outright (top-level kill switch). */
 export function isDaemonEnabled() {

package/dist/lib/devices/config-migration.d.ts

@@ -13,6 +13,13 @@
  *       `.history/devices/pins-<host>.json` (pins file wins on conflict — it
  *       is the destination); peers' pins are simply dropped from the tracked
  *       file (each peer owns/rewrites its own pins locally).
+ *   (e) legacy `.history/devices/ignored.json` (per-machine, UNTRACKED — a
+ *       dismissal never reached the rest of the fleet) folds into the central
+ *       TRACKED `fleet.ignored` list (RUSH-3062). Entries keep the legacy
+ *       file's `updatedAt` as `ignoredAt` and take THIS machine's id as
+ *       `ignoredOn` — the legacy store recorded neither, so the folding box
+ *       is the only attribution available. The legacy file is removed only
+ *       AFTER the central write lands.
  *
  * What stays put: a device doc's existing `config:` (already the right home)
  * and its `routines:` list (operator-owned, read cross-device by

package/dist/lib/devices/config-migration.js

@@ -13,6 +13,13 @@
  *       `.history/devices/pins-<host>.json` (pins file wins on conflict — it
  *       is the destination); peers' pins are simply dropped from the tracked
  *       file (each peer owns/rewrites its own pins locally).
+ *   (e) legacy `.history/devices/ignored.json` (per-machine, UNTRACKED — a
+ *       dismissal never reached the rest of the fleet) folds into the central
+ *       TRACKED `fleet.ignored` list (RUSH-3062). Entries keep the legacy
+ *       file's `updatedAt` as `ignoredAt` and take THIS machine's id as
+ *       `ignoredOn` — the legacy store recorded neither, so the folding box
+ *       is the only attribution available. The legacy file is removed only
+ *       AFTER the central write lands.
  *
  * What stays put: a device doc's existing `config:` (already the right home)
  * and its `routines:` list (operator-owned, read cross-device by
@@ -33,9 +40,10 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import { META_HEADER, getDevicesAutoLaunchPath, getDevicePinsPath, getUserAgentsDir, readMeta, updateMeta, withMetaLock, } from '../state.js';
+import { META_HEADER, getDevicesAutoLaunchPath, getDevicesIgnoredPath, getDevicePinsPath, getUserAgentsDir, readMeta, updateMeta, withMetaLock, } from '../state.js';
 import { atomicWriteFileSync } from '../fs-atomic.js';
 import { machineId } from '../machine-id.js';
+import { withIgnoredAdded } from './registry.js';
 /** Read every device doc. A doc that fails to parse is loudly skipped. */
 function readDeviceDocs(devicesRoot) {
     const docs = [];
@@ -124,6 +132,32 @@ function readAutoLaunchFlags(autoLaunchPath) {
 function isConfigMap(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
+/**
+ * The legacy per-machine ignored.json. Absent => null. A parse failure is
+ * logged loudly and reported as `undefined` so the caller LEAVES the file in
+ * place for a later retry — never silently emptied, the same corruption
+ * contract the ignore-list itself keeps (registry.ts's loadIgnoredEntries).
+ */
+function readLegacyIgnoredFile(p) {
+    let raw;
+    try {
+        raw = fs.readFileSync(p, 'utf-8');
+    }
+    catch {
+        return null; // absent — nothing to fold
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            names: Array.isArray(parsed.ignored) ? parsed.ignored.filter((n) => typeof n === 'string') : [],
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : undefined,
+        };
+    }
+    catch (err) {
+        console.error(`device config migration: could not parse ${p} (${err.message}); leaving it for a later retry`);
+        return undefined;
+    }
+}
 /**
  * Fold every legacy device-config/pins location into the current layout. Safe
  * to call on every boot / config access: cheap no-op once folded.
@@ -139,6 +173,9 @@ export function migrateDeviceConfigStores() {
     const centralHasConfig = Object.values(centralDevices).some((ov) => ov?.config && Object.keys(ov.config).length > 0);
     const autoLaunchFlags = readAutoLaunchFlags(autoLaunchPath);
     const docs = readDeviceDocs(devicesRoot);
+    const legacyIgnoredPath = getDevicesIgnoredPath();
+    const legacyIgnoredPending = fs.existsSync(legacyIgnoredPath);
+    const legacyIgnored = legacyIgnoredPending ? readLegacyIgnoredFile(legacyIgnoredPath) : null;
     const pinsPath = getDevicePinsPath();
     let selfPins = {};
     try {
@@ -172,7 +209,7 @@ export function migrateDeviceConfigStores() {
         : undefined;
     const hasDestinationWork = plans.length > 0 || newDocs.length > 0 || docAgents !== undefined || docIsolated !== undefined;
     const autoLaunchPending = fs.existsSync(autoLaunchPath);
-    if (!centralHasConfig && !hasDestinationWork && !autoLaunchPending)
+    if (!centralHasConfig && !hasDestinationWork && !autoLaunchPending && !legacyIgnoredPending)
         return;
     // ── 2. Destination writes FIRST (crash-safe), under the meta lock so they
     //    serialize against writeMetaUnlocked's own read-merge-write of the doc.
@@ -221,7 +258,18 @@ export function migrateDeviceConfigStores() {
                     nextDevices[name] = rest;
             }
             const fleet = { ...m.fleet, devices: nextDevices };
-            if (Object.keys(nextDevices).length === 0 && !fleet.defaults && !fleet.secrets && !fleet.routines) {
+            // Drop the whole `fleet` block only when NOTHING else lives in it. Every
+            // resident must be named here: `ignored` holds the user's dismissals and
+            // `discovery` their discovery policy, and deleting the block would not
+            // just lose them locally — `agents repo push` would sync the deletion
+            // fleet-wide. Add any new fleet.* key to this guard.
+            const fleetIsEmpty = Object.keys(nextDevices).length === 0 &&
+                !fleet.defaults &&
+                !fleet.secrets &&
+                !fleet.routines &&
+                !fleet.discovery &&
+                !(fleet.ignored && fleet.ignored.length > 0);
+            if (fleetIsEmpty) {
                 const { fleet: _, ...rest } = m;
                 void _;
                 return rest;
@@ -238,6 +286,22 @@ export function migrateDeviceConfigStores() {
             console.error(`device config migration: could not remove ${autoLaunchPath} (${err.message}); a later run retries`);
         }
     }
+    // ── 4. Legacy ignored.json → central fleet.ignored ───────────────────────
+    // Destination write (updateMeta: withMetaLock + atomic write) lands BEFORE
+    // the legacy file is removed, so a crash re-folds on the next run and
+    // withIgnoredAdded's union-by-name makes that a no-op. A file that failed to
+    // parse (legacyIgnored === undefined) is left in place for that retry.
+    if (legacyIgnored) {
+        if (legacyIgnored.names.length > 0) {
+            updateMeta((m) => withIgnoredAdded(m, legacyIgnored.names, legacyIgnored.updatedAt ?? new Date().toISOString()));
+        }
+        try {
+            fs.rmSync(legacyIgnoredPath, { force: true });
+        }
+        catch (err) {
+            console.error(`device config migration: could not remove ${legacyIgnoredPath} (${err.message}); a later run retries`);
+        }
+    }
 }
 /** Shallow-set equality for folded doc content (values compared deep via JSON). */
 function sameDocContent(a, b) {

package/dist/lib/devices/health.d.ts

@@ -1,7 +1,7 @@
 /**
  * Device resource probing for `agents devices list`.
  *
- * One SSH round-trip per device gathers load average, memory pressure, and core
+ * One SSH round-trip per device gathers load average, memory pressure, disk, and core
  * count (mac + linux via a POSIX snippet, windows via a CIM one-liner), parsed
  * into a {@link DeviceStats}. Probes run in parallel with a bounded timeout so
  * the list stays responsive — a slow or hung box degrades to "no stats" instead
@@ -19,6 +19,19 @@ export declare const PROBE_TIMEOUT_MS = 2500;
  * "Preparing modules for first use" cost on top of PowerShell startup, which
  * routinely blows the 2.5s POSIX budget on a relayed connection. */
 export declare const WIN_PROBE_TIMEOUT_MS = 6000;
+/** One-shot remote snapshot: load, memory, core count, then root filesystem. */
+export declare const PROBE_SNIPPET = "uptime; echo ---AGSTAT---; (vm_stat 2>/dev/null || cat /proc/meminfo 2>/dev/null); echo ---AGSTAT---; (nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null); echo ---AGSTAT---; df -Pk / 2>/dev/null | tail -1";
+/** Windows equivalent, one labeled line via CIM. PowerShell 5.1-safe: no `||`
+ * chaining, plain string concatenation. `LoadPercentage` is $null on some
+ * hosts/VMs, which concatenates to an empty field — the parser treats that as
+ * "no load signal" and headroom falls back to memory pressure alone.
+ * wrapRemoteCommand base64-encodes this for powershell-shell devices, so the
+ * quoting survives ssh intact. */
+export declare const WIN_PROBE_SNIPPET = "$os = Get-CimInstance Win32_OperatingSystem; $cpu = (Get-CimInstance Win32_Processor | Measure-Object -Property LoadPercentage -Average).Average; $disk = Get-CimInstance Win32_LogicalDisk -Filter \"DeviceID='C:'\"; Write-Output ('AGWINSTAT load=' + $cpu + ' freeKb=' + $os.FreePhysicalMemory + ' totalKb=' + $os.TotalVisibleMemorySize + ' ncpu=' + $env:NUMBER_OF_PROCESSORS + ' diskFreeKb=' + ($disk.FreeSpace / 1KB) + ' diskTotalKb=' + ($disk.Size / 1KB))";
+export declare function localProbeInvocation(platform: NodeJS.Platform): {
+    file: string;
+    args: string[];
+};
 export interface DeviceStats {
     host: string;
     reachable: boolean;
@@ -30,6 +43,11 @@ export interface DeviceStats {
     memPercent?: number;
     memTotalBytes?: number;
     memFreeBytes?: number;
+    diskTotalBytes?: number;
+    diskFreeBytes?: number;
+    diskUsedPercent?: number;
+    /** When the static ncpu/RAM/disk totals were last observed. */
+    specsFetchedAt?: number;
     fetchedAt: number;
 }
 /** Compact human byte size: 512M, 64G, 1.5T (binary units, ≤1 decimal). */
@@ -47,7 +65,14 @@ export declare function parseLinuxMemInfo(out: string): MemStats;
 export declare function parseNcpu(out: string): {
     ncpu?: number;
 };
-/** Assemble a DeviceStats from the three snippet sections. */
+interface DiskStats {
+    diskTotalBytes?: number;
+    diskFreeBytes?: number;
+    diskUsedPercent?: number;
+}
+/** Parse the final data row from `df -k /`, deriving usage from block counts. */
+export declare function parseDf(out: string): DiskStats;
+/** Assemble a DeviceStats from the four snippet sections. */
 export declare function parseProbeOutput(host: string, stdout: string, fetchedAt: number): DeviceStats;
 /** Assemble a DeviceStats from the windows one-liner. A missing marker line
  * (e.g. CIM unavailable) keeps `reachable: true` — ssh answered — with no