@phnx-labs/agents-cli 1.22.34 → 1.22.37

package/dist/lib/migrate.js

@@ -8,84 +8,25 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
+import { stringifyDoc } from './yaml-io.js';
 import { execSync } from 'child_process';
 import { atomicWriteFileSync } from './fs-atomic.js';
 import { machineId } from './machine-id.js';
 import { AGENTS, agentConfigDirName, findInPath } from './agents.js';
 import { createLink } from './platform/index.js';
-import { migrateLegacyRoutineActivation, setJobEnabled, listJobs, validateJob } from './routines.js';
-import { addEnabledRoutinesOnUpgrade, enabledRoutineNames, replaceEnabledRoutines } from './routine-activation.js';
+import { foldLegacySystemRepo, copyDirSkipExisting } from './migrate-fold.js';
+export { foldLegacySystemRepo } from './migrate-fold.js';
+import { migrateLegacyRoutineActivation, listJobs, validateJob } from './routines.js';
+import { setConfigValue } from './device-config.js';
+import { enabledRoutineNames, replaceEnabledRoutines } from './routine-activation.js';
 import { evaluateActivationReadiness } from './routine-readiness.js';
-import { DAEMON_TICK_ROUTINE_NAMES } from './daemon-ticks.js';
+import { migrateDeviceConfigToCentral } from './devices/config-migration.js';
 const HOME = process.env.HOME ?? os.homedir();
 const USER_DIR = path.join(HOME, '.agents');
 /** Canonical system-repo location (post-fold). */
 const SYSTEM_DIR = path.join(USER_DIR, '.system');
-/** Legacy system-repo location — folded into SYSTEM_DIR by foldLegacySystemRepo(). */
-const LEGACY_SYSTEM_DIR = path.join(HOME, '.agents-system');
 const HISTORY_DIR = path.join(USER_DIR, '.history');
 const CACHE_DIR = path.join(USER_DIR, '.cache');
-/**
- * Fold ~/.agents-system/ into ~/.agents/.system/.
- *
- * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
- * (the new path), so the contents have to be there before they execute.
- *
- * Strategy:
- *   1. If legacy dir doesn't exist or is already a symlink, no-op.
- *   2. If new path doesn't exist yet, rename in one shot (fast path).
- *   3. If both exist (mid-migration / re-run on partially-migrated state),
- *      merge legacy → new with new winning on collision, then drop legacy.
- *
- * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
- * so external tooling that still references ~/.agents-system/ keeps
- * resolving correctly. The symlink is harmless on its own and can be
- * removed with `rm ~/.agents-system` once everything has updated.
- *
- * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
- * LEGACY_SYSTEM_DIR" without duplicating data.
- */
-export function foldLegacySystemRepo() {
-    let legacyStat = null;
-    try {
-        legacyStat = fs.lstatSync(LEGACY_SYSTEM_DIR);
-    }
-    catch { /* missing */ }
-    if (!legacyStat)
-        return;
-    if (legacyStat.isSymbolicLink())
-        return;
-    if (!legacyStat.isDirectory())
-        return;
-    try {
-        fs.mkdirSync(USER_DIR, { recursive: true, mode: 0o700 });
-    }
-    catch { /* best-effort */ }
-    if (!fs.existsSync(SYSTEM_DIR)) {
-        try {
-            fs.renameSync(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
-            try {
-                createLink(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
-            }
-            catch { /* best-effort */ }
-            console.error('Folded ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
-            return;
-        }
-        catch {
-            // Cross-device rename or perm issue — fall through to copy + remove.
-        }
-    }
-    try {
-        copyDirSkipExisting(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
-        fs.rmSync(LEGACY_SYSTEM_DIR, { recursive: true, force: true });
-        try {
-            createLink(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
-        }
-        catch { /* best-effort */ }
-        console.error('Merged ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
-    }
-    catch { /* best-effort */ }
-}
 /** True when `relPath` is a file tracked by a git repo rooted at `repoDir`. */
 function isTrackedInGitRepo(repoDir, relPath) {
     try {
@@ -669,45 +610,6 @@ function mergeOverlappingVersionHomes() {
         console.error(`Merged ${mergedCount} overlapping version home${mergedCount === 1 ? '' : 's'} from legacy ~/.agents-system/versions/ into ~/.agents/versions/ (legacy moved to ~/.agents/.trash/versions/)`);
     }
 }
-function copyDirSkipExisting(src, dest) {
-    let entries;
-    try {
-        entries = fs.readdirSync(src, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
-    for (const entry of entries) {
-        const s = path.join(src, entry.name);
-        const d = path.join(dest, entry.name);
-        if (fs.existsSync(d)) {
-            if (entry.isDirectory()) {
-                const dStat = fs.lstatSync(d);
-                if (dStat.isDirectory())
-                    copyDirSkipExisting(s, d);
-            }
-            continue;
-        }
-        try {
-            fs.renameSync(s, d);
-        }
-        catch {
-            try {
-                if (entry.isDirectory()) {
-                    copyDirSkipExisting(s, d);
-                }
-                else if (entry.isSymbolicLink()) {
-                    fs.symlinkSync(fs.readlinkSync(s), d);
-                }
-                else {
-                    fs.copyFileSync(s, d);
-                }
-            }
-            catch { /* best-effort */ }
-        }
-    }
-}
 /**
  * Rename ~/.agents/permissions/sets/ -> ~/.agents/permissions/presets/.
  * Also handles ~/.agents-system/permissions/sets/ for system repo.
@@ -810,7 +712,7 @@ function repairAgentConfigSymlinks() {
 /**
  * Repair self-referential agent binary symlinks.
  *
- * Some installScript-based agents — notably Factory's `droid`, whose installer
+ * Some installScript-based agents — notably Factory.ai's `droid`, whose installer
  * drops a standalone native binary at ~/.local/bin/droid — were registered at
  * install time by resolving the post-install binary with `which <cli>`. Because
  * ~/.agents/.cache/shims sits ahead of ~/.local/bin on PATH, `which` could
@@ -2091,35 +1993,37 @@ export function pauseUnreadyEnabledRoutines() {
         `(run 'agents routines doctor --all' to see why): ${paused.join(', ')}`);
 }
 /**
- * Fold the legacy watchdog enable sentinel into the watchdog routine.
+ * Fold the legacy watchdog enable sentinel into the `watchdog.enabled` config.
  *
  * The always-on watchdog used to be gated by a presence sentinel at
- * `<runtime-state>/watchdog/enabled`; it is now a daemon routine. A user who had
- * run `agents watchdog enable` under the old build has that file on disk — without
- * this, upgrading would silently drop them back to OFF (the always-on nudge just
- * stops), the worst failure mode for a "survives reboots" feature. If the sentinel
- * exists, ensure the `watchdog` routine exists AND is enabled, then delete the
- * sentinel so this runs exactly once. If ensuring the routine fails, the sentinel
- * is left in place so a later run retries rather than silently losing the opt-in.
+ * `<runtime-state>/watchdog/enabled`; it is now a daemon-owned timer (RUSH-2495)
+ * gated by the `watchdog.enabled` device-config flag — the same flag
+ * `agents watchdog enable` writes. A user who had run `agents watchdog enable`
+ * under the old build has that file on disk; without this, upgrading would
+ * silently drop them back to OFF (the nudge just stops), the worst failure mode
+ * for a "survives reboots" feature. If the sentinel exists, set
+ * `watchdog.enabled: true`, then delete the sentinel so this runs exactly once.
+ * If setting it fails, the sentinel is left in place so a later run retries
+ * rather than silently losing the opt-in.
  *
- * Both seams are injectable so the migration is unit-testable without touching the
- * real routines dir (and without racing the routine module's own tests).
+ * The setter seam is injectable so the migration is unit-testable without
+ * touching the real device config.
  */
-export function migrateWatchdogSentinelToRoutine(sentinelPath = path.join(CACHE_DIR, 'state', 'watchdog', 'enabled'), enable = setJobEnabled) {
+export function migrateWatchdogSentinelToConfig(sentinelPath = path.join(CACHE_DIR, 'state', 'watchdog', 'enabled'), enable = (value) => setConfigValue('watchdog.enabled', value)) {
     if (!fs.existsSync(sentinelPath))
         return;
     try {
-        enable('watchdog', true);
+        enable(true);
     }
     catch (err) {
-        console.error(`watchdog sentinel migration: could not create the routine (${err.message}); leaving the sentinel for a later retry`);
+        console.error(`watchdog sentinel migration: could not set watchdog.enabled (${err.message}); leaving the sentinel for a later retry`);
         return;
     }
     try {
         fs.rmSync(sentinelPath);
     }
     catch { /* already gone */ }
-    console.error('Migrated watchdog: legacy enable sentinel → watchdog routine (kept enabled)');
+    console.error('Migrated watchdog: legacy enable sentinel → watchdog.enabled config (kept enabled)');
 }
 /**
  * Rename cli/ → clis/ in each of the given `.agents/` directories.
@@ -2245,7 +2149,10 @@ function migrateHumans() {
                 if (notifyNode.items.length === 0)
                     doc.delete('notify');
             }
-            fs.writeFileSync(agentsYamlPath, String(doc), 'utf-8');
+            // `flowCollectionPadding: false` keeps committed flow sequences unpadded
+            // (`[a, b]`, not `[ a, b ]`) so re-emitting agents.yaml here does not dirty
+            // the synced ~/.agents tree and block pulls (RUSH-2505).
+            fs.writeFileSync(agentsYamlPath, stringifyDoc(doc), 'utf-8');
         }
         catch { /* best-effort — leave the old key if we can't rewrite */ }
     }
@@ -2287,6 +2194,72 @@ export function seedActiveCursorLoginPerVersion() {
     }
     catch { /* best-effort — a failed seed just means one re-login */ }
 }
+/**
+ * Fold the pre-markdown Kimi subagent layout out of every kimi version home.
+ *
+ * agents-cli used to write each Kimi subagent as a `<name>.yaml` +
+ * `<name>.system.md` pair plus a managed `_agents-cli.yaml` index, against the
+ * agentspec of `kimi-cli` — a different product from the `kimi-code` harness we
+ * install, which never read any of it. Those files are inert, but not harmless:
+ * `<name>.system.md` ends in `.md`, so the subagent enumerator would surface it
+ * as a phantom subagent named `<name>.system`, and kimi-code logs
+ * `Missing frontmatter` for it once per session.
+ *
+ * This is the ONE place that knows about the old layout — the registry target
+ * describes only the current `<name>.md` shape. A pair is identified by its
+ * signature (a `<name>.yaml` with a sibling `<name>.system.md`), so a subagent a
+ * user legitimately named e.g. `foo.system` is never touched: it has no
+ * `foo.yaml` beside it. Idempotent; a no-op once the dirs are clean.
+ */
+export function migrateKimiSubagentsToMarkdown(versionsDir) {
+    const kimiVersions = path.join(versionsDir ?? path.join(HISTORY_DIR, 'versions'), 'kimi');
+    let versions;
+    try {
+        versions = fs.readdirSync(kimiVersions);
+    }
+    catch {
+        return; // no kimi installed
+    }
+    let removed = 0;
+    for (const version of versions) {
+        const dir = path.join(kimiVersions, version, 'home', '.kimi-code', 'agents');
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        const present = new Set(entries);
+        const doomed = [];
+        for (const entry of entries) {
+            if (entry === '_agents-cli.yaml') {
+                doomed.push(entry); // reserved managed index, only ever written by us
+                continue;
+            }
+            if (!entry.endsWith('.yaml'))
+                continue;
+            const base = entry.slice(0, -'.yaml'.length);
+            // Only a genuine legacy pair — a bare .yaml with no sibling prompt is not
+            // ours to delete.
+            if (!present.has(`${base}.system.md`))
+                continue;
+            doomed.push(entry, `${base}.system.md`);
+        }
+        for (const entry of doomed) {
+            try {
+                fs.rmSync(path.join(dir, entry), { force: true });
+                removed++;
+            }
+            catch {
+                // leave it; the next run retries
+            }
+        }
+    }
+    if (removed > 0) {
+        console.error(`Removed ${removed} pre-markdown Kimi subagent file(s); run 'agents sync kimi' to write the new format`);
+    }
+}
 /** Run all idempotent migrations. Safe to call multiple times. */
 export async function runMigration() {
     // MUST run first: every other migrator reads SYSTEM_DIR (the new path).
@@ -2306,6 +2279,8 @@ export async function runMigration() {
     // Cursor runs now isolate the login per version home; preserve the current
     // login by seeding the active home's token from the legacy global copy.
     seedActiveCursorLoginPerVersion();
+    // Drop the pre-markdown Kimi subagent files; the registry now writes <name>.md.
+    migrateKimiSubagentsToMarkdown();
     migrateRunsIntoRoutines();
     migrateTrashToHidden();
     migrateBackupsToHidden();
@@ -2324,6 +2299,13 @@ export async function runMigration() {
     // agents.yaml. After migrateVersionResourcesToPatterns so versions: is already
     // in pattern form when it moves to the history file.
     migrateSplitDeviceLocalMeta();
+    // Fold per-device operator config (device-doc config:/defaultBrowserProfile
+    // and .history/devices/auto-launch.json) into the central
+    // fleet.devices.<name>.config block. After migrateSplitDeviceLocalMeta so the
+    // device docs are in their canonical location. Also invoked on daemon boot
+    // and on the first device-config read/write in a process, so sentinel'd
+    // installs (which skip this whole run) still converge.
+    migrateDeviceConfigToCentral();
     // Bucket moves: collapse runtime state into ~/.agents/.history and ~/.agents/.cache.
     migrateRuntimeToHistory();
     migrateLegacySessionMarkersToBookmarks();
@@ -2358,13 +2340,9 @@ export async function runMigration() {
     // Fold legacy host-placement `remoteCwd` into the canonical portable `cwd`.
     migrateRoutineRemoteCwdToCwd();
     migrateLegacyRoutineActivation();
-    // These routines replace daemon timers that were always active. Devices with
-    // an existing activation manifest must retain that behavior after upgrade.
-    addEnabledRoutinesOnUpgrade(DAEMON_TICK_ROUTINE_NAMES);
-    // Fold the legacy watchdog enable sentinel into the watchdog routine so a user
-    // who opted in under the old build stays opted in after upgrading. After the
-    // routine rewrites above so the routines dir is in its canonical shape.
-    migrateWatchdogSentinelToRoutine();
+    // Fold the legacy watchdog enable sentinel into `watchdog.enabled` config so a
+    // user who opted in under the old build stays opted in after upgrading.
+    migrateWatchdogSentinelToConfig();
     // Deactivate any routine whose execution context no longer resolves ready, so
     // an anchor-less agent/workflow routine cannot keep firing-and-failing after the
     // fold (RUSH-2290). Runs AFTER the tick/watchdog routines are added so those

package/dist/lib/model-tier-overrides.d.ts

@@ -38,6 +38,6 @@ export declare function resolveTierOverride(agent: AgentId, version?: string | n
 /** Every configured override entry, sorted by selector (for `agents models tier list`). */
 export declare function listTierOverrides(): TierOverrideEntry[];
 /** Pin `tier -> model` for a selector. Writes agents.yaml. */
-export declare function setTierOverride(selectorInput: string, tierInput: string, model: string): TierOverrideEntry;
+export declare function setTierOverride(selectorInput: string, tierInput: string | ModelTier, model: string): TierOverrideEntry;
 /** Clear one tier (or all tiers when `tierInput` is omitted) for a selector. Returns true if anything changed. */
 export declare function clearTierOverride(selectorInput: string, tierInput?: string): boolean;

package/dist/lib/model-tier-overrides.js

@@ -90,8 +90,21 @@ export function clearTierOverride(selectorInput, tierInput) {
             delete tiers[parsed.selector];
             changed = true;
         }
-        model.tiers = tiers;
-        return { ...meta, model };
+        // Drop the emptied container rather than leaving `model: {tiers: {}}` in the
+        // shared agents.yaml — the same discipline lib/hosts/providers/local.ts uses
+        // for an emptied `hosts:`. A vestigial empty map is a real diff on a tracked
+        // file that every machine syncs, so clearing the last override would show up
+        // as a spurious local change on whichever box happened to run the command.
+        if (Object.keys(tiers).length > 0) {
+            model.tiers = tiers;
+            return { ...meta, model };
+        }
+        delete model.tiers;
+        if (Object.keys(model).length > 0)
+            return { ...meta, model };
+        const { model: _dropped, ...rest } = meta;
+        void _dropped;
+        return rest;
     });
     return changed;
 }

package/dist/lib/monitors/config.d.ts

@@ -145,11 +145,25 @@ export declare function monitorRunsOnThisDevice(config: Pick<MonitorConfig, 'dev
  * per-type field/shape checks.
  */
 export declare function validateMonitor(config: Partial<MonitorConfig>): string[];
-/** List all monitor configs in ~/.agents/monitors/. */
+/**
+ * List all monitor configs, unioning the user dir (~/.agents/monitors/) over the
+ * built-in system dir (~/.agents/.system/monitors/). Higher layer wins by name
+ * (first-seen), so a user monitor shadows a system built-in of the same name.
+ */
 export declare function listMonitors(): MonitorConfig[];
-/** Read a single monitor config by name. Returns null if not found or corrupt. */
+/**
+ * Read a single monitor config by name, checking the user dir then the system
+ * dir (a user monitor shadows a system built-in). Returns null if not found or
+ * corrupt.
+ */
 export declare function readMonitor(name: string): MonitorConfig | null;
-/** Get the filesystem path of a monitor's YAML config, or null if not found. */
+/**
+ * Get the filesystem path of a monitor's YAML config in the USER dir, or null.
+ * User-layer only by design — like routines' getJobPath (lib/routines.ts), its
+ * caller (`agents monitors edit`) writes to the returned path, and the system
+ * mirror is pull-only. To edit a system built-in, `edit` materializes a user
+ * copy (prefilled via readMonitor()) rather than opening the mirror.
+ */
 export declare function getMonitorPath(name: string): string | null;
 /** Write a monitor config to disk atomically, omitting fields that match defaults. */
 export declare function writeMonitor(config: MonitorConfig): void;

package/dist/lib/monitors/config.js

@@ -12,7 +12,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import { getMonitorsDir, ensureAgentsDir } from '../state.js';
+import { getMonitorsDir, getSystemMonitorsDir, ensureAgentsDir } from '../state.js';
 import { safeJoin, isSafeSegmentName } from '../paths.js';
 import { atomicWriteFileSync } from '../fs-atomic.js';
 import { machineId, normalizeHost } from '../machine-id.js';
@@ -273,51 +273,85 @@ export function validateMonitor(config) {
     }
     return errors;
 }
-function readMonitorFile(filePath) {
+/**
+ * Read and normalize a monitor file. `scope` decides the enabled default when
+ * the YAML has no explicit `enabled:` field: a `user` monitor defaults to
+ * enabled (MONITOR_DEFAULTS), while a `system` built-in stays opt-in (disabled)
+ * until the user enables it — mirroring how routines treat a fresh built-in
+ * (lib/routines.ts readJobFile).
+ */
+function readMonitorFile(filePath, scope = 'user') {
     try {
         const content = fs.readFileSync(filePath, 'utf-8');
         const parsed = yaml.parse(content);
         if (!parsed || typeof parsed !== 'object')
             return null;
+        const hasEnabled = Object.prototype.hasOwnProperty.call(parsed, 'enabled');
         return {
             ...MONITOR_DEFAULTS,
             ...parsed,
             name: parsed.name || path.basename(filePath).replace(/\.ya?ml$/, ''),
+            // A system built-in with no explicit `enabled:` is opt-in until enabled;
+            // a user monitor keeps the enabled-by-default behavior.
+            enabled: hasEnabled ? parsed.enabled !== false : scope === 'system' ? false : (MONITOR_DEFAULTS.enabled ?? true),
         };
     }
     catch {
         return null;
     }
 }
-/** List all monitor configs in ~/.agents/monitors/. */
+/** The layered monitor dirs, user before system so user shadows system by name. */
+function monitorLayers() {
+    return [
+        { scope: 'user', path: getMonitorsDir() },
+        { scope: 'system', path: getSystemMonitorsDir() },
+    ];
+}
+/**
+ * List all monitor configs, unioning the user dir (~/.agents/monitors/) over the
+ * built-in system dir (~/.agents/.system/monitors/). Higher layer wins by name
+ * (first-seen), so a user monitor shadows a system built-in of the same name.
+ */
 export function listMonitors() {
     ensureAgentsDir();
-    const dir = getMonitorsDir();
-    if (!fs.existsSync(dir))
-        return [];
     const monitors = [];
     const seen = new Set();
-    for (const file of fs.readdirSync(dir).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'))) {
-        const monitor = readMonitorFile(path.join(dir, file));
-        if (!monitor || seen.has(monitor.name))
+    for (const { scope, path: dir } of monitorLayers()) {
+        if (!fs.existsSync(dir))
             continue;
-        seen.add(monitor.name);
-        monitors.push(monitor);
+        for (const file of fs.readdirSync(dir).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'))) {
+            const monitor = readMonitorFile(path.join(dir, file), scope);
+            if (!monitor || seen.has(monitor.name))
+                continue;
+            seen.add(monitor.name);
+            monitors.push(monitor);
+        }
     }
     return monitors;
 }
-/** Read a single monitor config by name. Returns null if not found or corrupt. */
+/**
+ * Read a single monitor config by name, checking the user dir then the system
+ * dir (a user monitor shadows a system built-in). Returns null if not found or
+ * corrupt.
+ */
 export function readMonitor(name) {
     ensureAgentsDir();
-    const dir = getMonitorsDir();
-    for (const ext of ['.yml', '.yaml']) {
-        const filePath = safeJoin(dir, name + ext);
-        if (fs.existsSync(filePath))
-            return readMonitorFile(filePath);
+    for (const { scope, path: dir } of monitorLayers()) {
+        for (const ext of ['.yml', '.yaml']) {
+            const filePath = safeJoin(dir, name + ext);
+            if (fs.existsSync(filePath))
+                return readMonitorFile(filePath, scope);
+        }
     }
     return null;
 }
-/** Get the filesystem path of a monitor's YAML config, or null if not found. */
+/**
+ * Get the filesystem path of a monitor's YAML config in the USER dir, or null.
+ * User-layer only by design — like routines' getJobPath (lib/routines.ts), its
+ * caller (`agents monitors edit`) writes to the returned path, and the system
+ * mirror is pull-only. To edit a system built-in, `edit` materializes a user
+ * copy (prefilled via readMonitor()) rather than opening the mirror.
+ */
 export function getMonitorPath(name) {
     const dir = getMonitorsDir();
     for (const ext of ['.yml', '.yaml']) {

package/dist/lib/monitors/engine.d.ts

@@ -13,6 +13,19 @@
  */
 import { type MonitorConfig, type MonitorEvent } from './config.js';
 import { type Observation } from './sources/index.js';
+/** Poll-model source types the engine actually evaluates on a cadence; ws/webhook are push-only and inert here. */
+export declare const POLL_SOURCE_TYPES: Set<string>;
+/**
+ * Whether a monitor's liveness has crossed into a drought worth notifying the
+ * owner about: enough consecutive failed checks, and not already notified for
+ * this drought. Pure so the branch is unit-testable without a real notify.
+ */
+export declare function shouldEscalateDrought(liveness: MonitorLivenessLike): boolean;
+/** The liveness fields the drought predicate reads. */
+interface MonitorLivenessLike {
+    consecutiveErrors: number;
+    droughtNotifiedAt?: string;
+}
 /** The fire/no-fire decision for one observation, plus what to persist. */
 export interface FireDecision {
     fire: boolean;
@@ -55,7 +68,25 @@ export declare class MonitorEngine {
     private isDue;
     /** Evaluate every due monitor once. Overlap-guarded so a slow cycle never stacks. */
     tick(): Promise<void>;
-    private runMonitor;
+    /**
+     * Evaluate one monitor once and record the outcome. Public so the daemon tick
+     * and tests drive the exact same path. A "failed check" is an evaluation that
+     * produced no observation, threw, OR fired an action that failed — all three
+     * are "the monitor ran and accomplished nothing", the drought signal. A poll
+     * that observes and either fires cleanly or matches nothing is a success and
+     * resets the streak.
+     */
+    runMonitor(monitor: MonitorConfig): Promise<void>;
+    /**
+     * Record the poll heartbeat and, on a sustained failure streak, escalate a
+     * drought to the owner exactly once. The heartbeat is what makes a
+     * polling-but-not-matching monitor visibly distinct from one the engine never
+     * touched (RUSH-2485); the streak is what turns "every poll fails and the owner
+     * never hears about it" into one notification.
+     */
+    private afterCheck;
+    /** Notify the owner that an enabled monitor has failed N checks in a row and done nothing. */
+    private escalateDrought;
     private fire;
 }
 export {};