@phnx-labs/agents-cli 1.22.13 → 1.22.15

package/dist/lib/routine-activation.d.ts

@@ -0,0 +1,14 @@
+export declare function normalizeRoutineNames(names: Iterable<string>): string[];
+/** null means this device has not materialized activation state yet. */
+export declare function enabledRoutineNames(): string[] | null;
+export declare function routineEnabledOnThisDevice(name: string): boolean | null;
+export declare function replaceEnabledRoutines(names: Iterable<string>): string[];
+/**
+ * Add or remove one routine on this machine. `legacyEnabledNames` seeds the
+ * manifest the first time an upgraded host changes activation, preserving every
+ * other routine that was effectively enabled under the old definition fields.
+ */
+export declare function setRoutineEnabledOnThisDevice(name: string, enabled: boolean, legacyEnabledNames?: Iterable<string>): string[];
+/** Read-only fleet view from synced device documents. Never writes a peer file. */
+export declare function devicesWithRoutineEnabled(name: string): string[];
+export declare function currentRoutineDevice(): string;

package/dist/lib/routine-activation.js

@@ -0,0 +1,78 @@
+/** Device-scoped routine activation.
+ *
+ * Definitions say what a routine does. This module owns the independent answer
+ * to whether THIS device runs it: membership in the top-level `routines:` list
+ * of `~/.agents/devices/<machine>/agents.yaml`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { machineId } from './machine-id.js';
+import { getUserAgentsDir, readMeta, updateMeta } from './state.js';
+export function normalizeRoutineNames(names) {
+    return [...new Set([...names].map((name) => name.trim()).filter(Boolean))].sort();
+}
+/** null means this device has not materialized activation state yet. */
+export function enabledRoutineNames() {
+    const names = readMeta().deviceRoutines;
+    return Array.isArray(names) ? normalizeRoutineNames(names) : null;
+}
+export function routineEnabledOnThisDevice(name) {
+    const names = enabledRoutineNames();
+    return names === null ? null : names.includes(name);
+}
+export function replaceEnabledRoutines(names) {
+    const normalized = normalizeRoutineNames(names);
+    updateMeta((meta) => ({ ...meta, deviceRoutines: normalized }));
+    return normalized;
+}
+/**
+ * Add or remove one routine on this machine. `legacyEnabledNames` seeds the
+ * manifest the first time an upgraded host changes activation, preserving every
+ * other routine that was effectively enabled under the old definition fields.
+ */
+export function setRoutineEnabledOnThisDevice(name, enabled, legacyEnabledNames = []) {
+    const current = enabledRoutineNames() ?? normalizeRoutineNames(legacyEnabledNames);
+    const next = new Set(current);
+    if (enabled)
+        next.add(name);
+    else
+        next.delete(name);
+    return replaceEnabledRoutines(next);
+}
+/** Read-only fleet view from synced device documents. Never writes a peer file. */
+export function devicesWithRoutineEnabled(name) {
+    const devicesDir = path.join(getUserAgentsDir(), 'devices');
+    if (!fs.existsSync(devicesDir))
+        return [];
+    const devices = [];
+    for (const entry of fs.readdirSync(devicesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const file = path.join(devicesDir, entry.name, 'agents.yaml');
+        if (!fs.existsSync(file))
+            continue;
+        let parsed;
+        try {
+            parsed = yaml.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch (err) {
+            throw new Error(`Device config corrupted at ${file}: ${err.message}`);
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`Device config corrupted at ${file}: expected a YAML map.`);
+        }
+        const routines = parsed.routines;
+        if (routines === undefined)
+            continue;
+        if (!Array.isArray(routines) || routines.some((routine) => typeof routine !== 'string')) {
+            throw new Error(`Device config corrupted at ${file}: routines must be a string list.`);
+        }
+        if (routines.includes(name))
+            devices.push(entry.name);
+    }
+    return devices.sort();
+}
+export function currentRoutineDevice() {
+    return machineId();
+}

package/dist/lib/routines-project.d.ts

@@ -67,7 +67,7 @@ export interface SyncProjectResult {
  * - Overwrites user copies that already carry matching `source.projectPath`
  * - Never clobbers a hand-authored user routine (no source / different source)
  * - Removes user copies from this project whose YAML disappeared
- * - Auto-pins `devices` for host/fleet/cloud placement when unset
+ * - Activates materialized routines on this device without mutating definitions
  */
 export declare function syncProjectRoutines(projectRoot: string): SyncProjectResult;
 export interface SyncAllResult {

package/dist/lib/routines-project.js

@@ -14,9 +14,8 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { execFileSync } from 'child_process';
 import { getProjectAgentsDir, getProjectRoutinesDir, readMeta, updateMeta, ensureAgentsDir, } from './state.js';
-import { readJob, writeJob, deleteJob, listJobs, validateJob, resolveHostStrategy, placementRequiresFiringPin, } from './routines.js';
+import { readJob, writeJob, setJobEnabled, deleteJob, listJobs, validateJob, } from './routines.js';
 import { parseOwnerRepoFromRemote } from './registry.js';
-import { machineId } from './machine-id.js';
 import { isSafeSegmentName } from './paths.js';
 /** Expand `~/…` and resolve to an absolute path. */
 export function expandProjectPath(p) {
@@ -221,7 +220,7 @@ function readProjectJobFile(filePath) {
  * - Overwrites user copies that already carry matching `source.projectPath`
  * - Never clobbers a hand-authored user routine (no source / different source)
  * - Removes user copies from this project whose YAML disappeared
- * - Auto-pins `devices` for host/fleet/cloud placement when unset
+ * - Activates materialized routines on this device without mutating definitions
  */
 export function syncProjectRoutines(projectRoot) {
     ensureAgentsDir();
@@ -276,12 +275,6 @@ export function syncProjectRoutines(projectRoot) {
             if (existing.createdAt)
                 job.createdAt = existing.createdAt;
         }
-        // Placement that leaves the firing machine must pin devices to avoid
-        // every fleet daemon dispatching once.
-        const strategy = resolveHostStrategy(job);
-        if (placementRequiresFiringPin(strategy) && (!job.devices || job.devices.length === 0)) {
-            job.devices = [machineId()];
-        }
         // Surface repo for list/display when project has a GitHub origin.
         if (git.repo && !job.repo)
             job.repo = git.repo;
@@ -294,6 +287,7 @@ export function syncProjectRoutines(projectRoot) {
         }
         try {
             writeJob(job);
+            setJobEnabled(job.name, job.enabled);
             result.synced.push(file.name);
         }
         catch (err) {

package/dist/lib/routines.d.ts

@@ -294,7 +294,7 @@ export declare function finalizeRunMeta(meta: RunMeta, status: RunMeta['status']
  * `yosemite-s0` all agree. Every fire path (cron scheduler, webhook,
  * catchup/overdue, manual run) gates on this.
  */
-export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'devices'>): boolean;
+export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'name' | 'devices'>): boolean;
 /**
  * The ONE device that owns a routine — the single daemon allowed to fire it.
  *
@@ -423,6 +423,8 @@ export declare function serializeJob(output: Record<string, unknown>, existingTe
 export declare function deleteJob(name: string): boolean;
 /** Enable or disable a job by name. */
 export declare function setJobEnabled(name: string, enabled: boolean): void;
+/** Materialize legacy definition state into this device's activation manifest. */
+export declare function migrateLegacyRoutineActivation(): boolean;
 /** Validate a partial job config, returning a list of human-readable errors. */
 export declare function validateJob(config: Partial<JobConfig>): string[];
 /** Validate a job trigger block, returning a list of human-readable errors. */

package/dist/lib/routines.js

@@ -17,6 +17,7 @@ import { ALL_AGENT_IDS } from './agents.js';
 import { machineId, normalizeHost } from './machine-id.js';
 import { resolveActor } from './actor.js';
 import { percentile } from './percentile.js';
+import { enabledRoutineNames, replaceEnabledRoutines, routineEnabledOnThisDevice, setRoutineEnabledOnThisDevice, } from './routine-activation.js';
 export const HOST_STRATEGIES = ['local', 'host', 'fleet', 'cloud'];
 /** Canonical set of accepted GitHub trigger events — single source for validation. */
 export const GITHUB_TRIGGER_EVENTS = [
@@ -82,6 +83,9 @@ export function finalizeRunMeta(meta, status, exitCode, opts) {
  * catchup/overdue, manual run) gates on this.
  */
 export function jobRunsOnThisDevice(config) {
+    const activated = routineEnabledOnThisDevice(config.name);
+    if (activated !== null)
+        return activated;
     const owner = routineOwnerDevice(config);
     // Unrestricted: no pin means fleet-wide by design (`watchdog`, `check-updates`).
     if (owner === null)
@@ -260,7 +264,7 @@ export function listJobs(cwd) {
             jobs.push(job);
         }
     }
-    return jobs;
+    return jobs.map(applyDeviceActivation);
 }
 /**
  * Read a single job config by name, checking project > user > system.
@@ -286,12 +290,16 @@ export function readJob(name, cwd) {
         const job = readJobFromDir(dir, name);
         if (job) {
             if (scope === 'project')
-                return overlayUserRoutineDevices(job, readJobFromDir(userDir, name));
-            return job;
+                return applyDeviceActivation(overlayUserRoutineDevices(job, readJobFromDir(userDir, name)));
+            return applyDeviceActivation(job);
         }
     }
     return null;
 }
+function applyDeviceActivation(job) {
+    const activated = routineEnabledOnThisDevice(job.name);
+    return activated === null ? job : { ...job, enabled: activated };
+}
 function readJobFromDir(dir, name) {
     for (const ext of ['.yml', '.yaml']) {
         const filePath = safeJoin(dir, name + ext);
@@ -327,6 +335,10 @@ function readJobFile(filePath) {
             ...JOB_DEFAULTS,
             ...parsed,
             name: parsed.name || path.basename(filePath).replace(/\.ya?ml$/, ''),
+            // Before a device manifest exists, preserve only explicit legacy state.
+            // A new built-in definition with no `enabled:` field stays opt-in until
+            // setup materializes this host's routines list.
+            enabled: Object.prototype.hasOwnProperty.call(parsed, 'enabled') ? parsed.enabled !== false : false,
         };
     }
     catch {
@@ -368,15 +380,12 @@ export function writeJob(config) {
         delete output.effort;
     if (output.timeout === '10m')
         delete output.timeout;
-    if (output.enabled === true)
-        delete output.enabled;
+    delete output.enabled;
     if (output.runOnce === false || output.runOnce === undefined)
         delete output.runOnce;
     if (output.catchup === true || output.catchup === undefined)
         delete output.catchup;
-    const devArr = output.devices;
-    if (!devArr || devArr.length === 0)
-        delete output.devices;
+    delete output.devices;
     let existingText = null;
     if (ymlExists || yamlExists) {
         try {
@@ -441,8 +450,20 @@ export function setJobEnabled(name, enabled) {
     const job = readJob(name);
     if (!job)
         throw new Error(`Job '${name}' not found`);
-    job.enabled = enabled;
-    writeJob(job);
+    const legacyEnabled = enabledRoutineNames() === null
+        ? listJobs().filter((candidate) => candidate.enabled && jobRunsOnThisDevice(candidate)).map((candidate) => candidate.name)
+        : [];
+    setRoutineEnabledOnThisDevice(name, enabled, legacyEnabled);
+}
+/** Materialize legacy definition state into this device's activation manifest. */
+export function migrateLegacyRoutineActivation() {
+    if (enabledRoutineNames() !== null)
+        return false;
+    const jobs = listJobs();
+    if (!jobs.some((job) => job.enabled || Array.isArray(job.devices)))
+        return false;
+    replaceEnabledRoutines(jobs.filter((job) => job.enabled && jobRunsOnThisDevice(job)).map((job) => job.name));
+    return true;
 }
 /** Validate a partial job config, returning a list of human-readable errors. */
 export function validateJob(config) {
@@ -606,15 +627,6 @@ export function validateJob(config) {
     if (config.catchup !== undefined && typeof config.catchup !== 'boolean') {
         errors.push('catchup must be a boolean (false to skip running a missed fire late)');
     }
-    // Off-box placement without a devices pin fires on every fleet daemon and
-    // each dispatches once (RUSH-1980). Enforce the pin at validation so hand
-    // edits and devices --clear cannot re-open the hole.
-    if (placementRequiresFiringPin(strategy)) {
-        if (!config.devices || config.devices.length === 0) {
-            errors.push(`hostStrategy: ${strategy} requires devices: [<name>] to pin which daemon may fire ` +
-                '(otherwise every fleet daemon dispatches once). Pin to one machine, e.g. devices: [this-host]');
-        }
-    }
     return errors;
 }
 /** Validate a job trigger block, returning a list of human-readable errors. */
@@ -1155,6 +1167,7 @@ export function installJobFromSource(sourcePath, name) {
             return { success: false, error: errors.join(', ') };
         }
         writeJob(config);
+        setJobEnabled(config.name, config.enabled);
         return { success: true };
     }
     catch (err) {

package/dist/lib/session/db.d.ts

@@ -120,6 +120,25 @@ export interface QueryOptions {
 export declare function getDB(): Database.Database;
 /** Close the cached database connection. */
 export declare function closeDB(): void;
+export interface FtsOptimizeResult {
+    table: string;
+    segmentsBefore: number;
+    segmentsAfter: number;
+}
+/**
+ * Compact the session + tool-call full-text-search indexes.
+ *
+ * FTS5 appends a new segment on every insert and leaves a tombstone on every
+ * delete. The scanner delete+inserts a session's docs on each rescan (and on
+ * every extractor-version bump), and FTS5 never merges those segments on its
+ * own — so `tool_call_text_data` / `session_text_data` accumulate hundreds of
+ * thousands of unmerged segments, gigabytes of index for tens of MB of content,
+ * and `agents sessions` queries slow to a crawl. The FTS5 `'optimize'` command
+ * merges every segment into one and purges tombstones. Non-destructive: no
+ * searchable content is lost. Reclaimed space becomes reusable free pages inside
+ * the DB file; run VACUUM (with the daemon stopped) to return it to the OS.
+ */
+export declare function optimizeSessionSearchIndex(): FtsOptimizeResult[];
 /**
  * Try to claim the right to run the incremental scan. Returns true if this
  * process should proceed with scanning, false if another live process is

package/dist/lib/session/db.js

@@ -820,6 +820,30 @@ export function closeDB() {
         cachedStmts = {};
     }
 }
+/**
+ * Compact the session + tool-call full-text-search indexes.
+ *
+ * FTS5 appends a new segment on every insert and leaves a tombstone on every
+ * delete. The scanner delete+inserts a session's docs on each rescan (and on
+ * every extractor-version bump), and FTS5 never merges those segments on its
+ * own — so `tool_call_text_data` / `session_text_data` accumulate hundreds of
+ * thousands of unmerged segments, gigabytes of index for tens of MB of content,
+ * and `agents sessions` queries slow to a crawl. The FTS5 `'optimize'` command
+ * merges every segment into one and purges tombstones. Non-destructive: no
+ * searchable content is lost. Reclaimed space becomes reusable free pages inside
+ * the DB file; run VACUUM (with the daemon stopped) to return it to the OS.
+ */
+export function optimizeSessionSearchIndex() {
+    const db = getDB();
+    // Hardcoded literals — never interpolate caller input into an identifier.
+    const tables = ['tool_call_text', 'session_text'];
+    const segments = (table) => db.prepare(`SELECT count(*) AS n FROM ${table}_data`).get().n;
+    return tables.map((table) => {
+        const segmentsBefore = segments(table);
+        db.prepare(`INSERT INTO ${table}(${table}) VALUES('optimize')`).run();
+        return { table, segmentsBefore, segmentsAfter: segments(table) };
+    });
+}
 // ---------------------------------------------------------------------------
 // Scan coordinator — prevents concurrent full scans across processes
 // ---------------------------------------------------------------------------

package/dist/lib/state.js

@@ -812,6 +812,7 @@ const META_KEY_SCOPE = {
     versions: 'device',
     defaultBrowserProfile: 'device',
     deviceConfig: 'device',
+    deviceRoutines: 'device',
     // Central — synced via agents.yaml.
     run: 'central',
     model: 'central',
@@ -909,7 +910,7 @@ function serializeCentral(central) {
     return isEmpty ? META_HEADER : doc.toString({ collectionStyle: 'block' });
 }
 function writeMetaUnlocked(meta) {
-    const { agents, isolatedAgents, versions, defaultBrowserProfile, deviceConfig, ...central } = meta;
+    const { agents, isolatedAgents, versions, defaultBrowserProfile, deviceConfig, deviceRoutines, ...central } = meta;
     // Write the machine-local files FIRST, then strip central — so a crash mid-write
     // never removes pins/versions from central before they're persisted elsewhere.
     const devicePath = getDeviceMetaPath();
@@ -923,7 +924,8 @@ function writeMetaUnlocked(meta) {
     // Device-scope config (`maxAgents`, `schedulerEnabled`, …) is per-machine, so it
     // rides the device doc under `config:` — never the central doc that syncs.
     const hasDeviceConfig = !!deviceConfig && Object.keys(deviceConfig).length > 0;
-    if (hasAgents || hasIsolatedAgents || hasDefaultBrowser || hasDeviceConfig) {
+    const hasDeviceRoutines = Array.isArray(deviceRoutines);
+    if (hasAgents || hasIsolatedAgents || hasDefaultBrowser || hasDeviceConfig || hasDeviceRoutines) {
         // Device-local doc carries `agents:` pins, `defaultBrowserProfile:`, and the
         // device-scope `config:` — all per-machine and must never land in central
         // agents.yaml (which syncs).
@@ -936,6 +938,8 @@ function writeMetaUnlocked(meta) {
             deviceDoc.defaultBrowserProfile = defaultBrowserProfile;
         if (hasDeviceConfig)
             deviceDoc.config = deviceConfig;
+        if (hasDeviceRoutines)
+            deviceDoc.routines = deviceRoutines;
         fs.mkdirSync(path.dirname(devicePath), { recursive: true });
         writeIfChanged(devicePath, META_HEADER + yaml.stringify(deviceDoc));
     }
@@ -971,8 +975,12 @@ function writeMetaUnlocked(meta) {
 function overlayMachineLocal(meta) {
     const devicePath = getDeviceMetaPath();
     if (fs.existsSync(devicePath)) {
+        let dm = null;
         try {
-            const dm = yaml.parse(fs.readFileSync(devicePath, 'utf-8'));
+            dm = yaml.parse(fs.readFileSync(devicePath, 'utf-8'));
+        }
+        catch { /* preserve the existing tolerance for malformed legacy device YAML */ }
+        if (dm) {
             if (dm?.agents)
                 meta.agents = { ...meta.agents, ...dm.agents };
             if (dm?.isolatedAgents)
@@ -981,8 +989,13 @@ function overlayMachineLocal(meta) {
                 meta.defaultBrowserProfile = dm.defaultBrowserProfile;
             if (dm?.config)
                 meta.deviceConfig = dm.config;
+            if (dm && Object.prototype.hasOwnProperty.call(dm, 'routines')) {
+                if (!Array.isArray(dm.routines) || dm.routines.some((name) => typeof name !== 'string')) {
+                    throw new Error(`Device config corrupted at ${devicePath}: routines must be a string list.`);
+                }
+                meta.deviceRoutines = dm.routines;
+            }
         }
-        catch { /* ignore malformed device file */ }
     }
     const vrPath = getVersionResourcesPath();
     if (fs.existsSync(vrPath)) {

package/dist/lib/types.d.ts

@@ -511,10 +511,16 @@ export interface RegistrySearchResult {
 }
 /** A package that has been resolved from a registry and is ready to install. */
 export interface ResolvedPackage {
-    type: 'mcp' | 'skill' | 'git';
+    /** `plugin` is Phase 5 packaging: `agents install plugin:<spec>` → plugins install. */
+    type: 'mcp' | 'skill' | 'git' | 'plugin';
     source: string;
     mcpEntry?: McpServerEntry;
     skillEntry?: SkillEntry;
+    /**
+     * Plugin install spec (`name@url`, path, or bare source) when `type === 'plugin'`.
+     * Same grammar as `agents plugins install <spec>`.
+     */
+    pluginSpec?: string;
 }
 /** Categories of resources that can be synced into an agent version home. */
 export type ResourceType = 'commands' | 'skills' | 'hooks' | 'memory' | 'mcp' | 'permissions' | 'subagents' | 'plugins' | 'workflows';
@@ -937,6 +943,13 @@ export interface Meta {
      * device-config registry (`maxAgents`, `schedulerEnabled`, `notes`). Per-machine by design — unset = today's behavior.
      */
     deviceConfig?: Record<string, unknown>;
+    /**
+     * Routine names enabled on this machine. In memory this stays distinct from
+     * portable user config; state.ts writes it as top-level `routines:` in
+     * `~/.agents/devices/<machine>/agents.yaml`. Presence in the list is the whole
+     * activation state: absent means disabled on this device.
+     */
+    deviceRoutines?: string[];
     /**
      * Agent-host registry keyed by host name (`agents hosts`). Portable user
      * config synced with `agents repo push/pull`. For `ssh-config` hosts this is

package/dist/lib/watchdog/rotate.d.ts

@@ -166,7 +166,7 @@ export declare function isWatchdogRotateEnabled(): boolean;
  * Persist `watchdog.rotate: on|off`. Called by the `agents watchdog rotate
  * on|off` subcommand (commands/watchdog.ts) — the rotate-only switch the
  * Factory migration uses so a user who opted out of autoRotate keeps nudging
- * (rather than `agents watchdog disable`, which kills the whole watchdog).
+ * (rather than `agents watchdog off`, which disables the whole watchdog here).
  */
 export declare function setWatchdogRotateEnabled(on: boolean): void;
 export interface RotateGateResult {

package/dist/lib/watchdog/rotate.js

@@ -291,7 +291,7 @@ export function isWatchdogRotateEnabled() {
  * Persist `watchdog.rotate: on|off`. Called by the `agents watchdog rotate
  * on|off` subcommand (commands/watchdog.ts) — the rotate-only switch the
  * Factory migration uses so a user who opted out of autoRotate keeps nudging
- * (rather than `agents watchdog disable`, which kills the whole watchdog).
+ * (rather than `agents watchdog off`, which disables the whole watchdog here).
  */
 export function setWatchdogRotateEnabled(on) {
     const meta = readMeta();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.13",
+  "version": "1.22.15",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",

package/dist/lib/watchdog/routine.d.ts

@@ -1,44 +0,0 @@
-/**
- * The watchdog, expressed as a routine.
- *
- * The always-on watchdog is not a bespoke subsystem — it is a plain `command`
- * routine the daemon's existing scheduler fires: `agents watchdog --nudge`, once
- * every couple of minutes. Enabling / disabling the watchdog is enabling /
- * disabling that routine, so there is ONE durable, inspectable concept
- * (`agents routines list` shows it; the scheduler catches it up if the daemon was
- * down) instead of a private sentinel file and a hand-rolled `--watch` loop.
- *
- * A `command` routine — not `agent`/`workflow` — because the tick is deterministic
- * housekeeping: no LLM, no auth, no sandbox. Each fire runs ONE bounded tick (the
- * cron is the loop), so the daemon's per-fire model fits without a long-lived
- * process.
- */
-import { type JobConfig } from '../routines.js';
-/** The routine name. `agents routines list` / `readJob` key on this. */
-export declare const WATCHDOG_ROUTINE_NAME = "watchdog";
-/**
- * Fire every 2 minutes. Mirrors the extension's 120s tick, and is well inside the
- * 5m stall threshold and 20m nudge cooldown, so a stall is noticed promptly
- * without the daemon spawning a tick more often than the cooldown can matter.
- */
-export declare const WATCHDOG_ROUTINE_SCHEDULE = "*/2 * * * *";
-/** The plain shell each fire runs: one bounded, deterministic nudge tick. */
-export declare const WATCHDOG_ROUTINE_COMMAND = "agents watchdog --nudge";
-/**
- * Build the watchdog routine config. Pure — touches no disk. `mode`/`effort`/
- * `timeout` are required by JobConfig but ignored for `command` routines;
- * writeJob() drops the default ('auto'/'10m') values so the on-disk file stays
- * to the point (name + schedule + command + enabled).
- */
-export declare function buildWatchdogRoutine(enabled: boolean): JobConfig;
-/** Is the watchdog routine present on disk (user or system layer)? */
-export declare function watchdogRoutineExists(): boolean;
-/** Is the watchdog routine present AND enabled? */
-export declare function isWatchdogRoutineEnabled(): boolean;
-/**
- * Ensure the watchdog routine exists with the requested enabled state, preserving
- * any user edits. Absent → create it; present → only flip `enabled` (never clobber
- * a schedule or command the user tuned). Idempotent: calling it twice with the
- * same state is a no-op after the first.
- */
-export declare function ensureWatchdogRoutine(enabled: boolean): void;

package/dist/lib/watchdog/routine.js

@@ -1,69 +0,0 @@
-/**
- * The watchdog, expressed as a routine.
- *
- * The always-on watchdog is not a bespoke subsystem — it is a plain `command`
- * routine the daemon's existing scheduler fires: `agents watchdog --nudge`, once
- * every couple of minutes. Enabling / disabling the watchdog is enabling /
- * disabling that routine, so there is ONE durable, inspectable concept
- * (`agents routines list` shows it; the scheduler catches it up if the daemon was
- * down) instead of a private sentinel file and a hand-rolled `--watch` loop.
- *
- * A `command` routine — not `agent`/`workflow` — because the tick is deterministic
- * housekeeping: no LLM, no auth, no sandbox. Each fire runs ONE bounded tick (the
- * cron is the loop), so the daemon's per-fire model fits without a long-lived
- * process.
- */
-import { readJob, writeJob, setJobEnabled } from '../routines.js';
-/** The routine name. `agents routines list` / `readJob` key on this. */
-export const WATCHDOG_ROUTINE_NAME = 'watchdog';
-/**
- * Fire every 2 minutes. Mirrors the extension's 120s tick, and is well inside the
- * 5m stall threshold and 20m nudge cooldown, so a stall is noticed promptly
- * without the daemon spawning a tick more often than the cooldown can matter.
- */
-export const WATCHDOG_ROUTINE_SCHEDULE = '*/2 * * * *';
-/** The plain shell each fire runs: one bounded, deterministic nudge tick. */
-export const WATCHDOG_ROUTINE_COMMAND = 'agents watchdog --nudge';
-/**
- * Build the watchdog routine config. Pure — touches no disk. `mode`/`effort`/
- * `timeout` are required by JobConfig but ignored for `command` routines;
- * writeJob() drops the default ('auto'/'10m') values so the on-disk file stays
- * to the point (name + schedule + command + enabled).
- */
-export function buildWatchdogRoutine(enabled) {
-    return {
-        name: WATCHDOG_ROUTINE_NAME,
-        schedule: WATCHDOG_ROUTINE_SCHEDULE,
-        command: WATCHDOG_ROUTINE_COMMAND,
-        enabled,
-        mode: 'auto',
-        effort: 'auto',
-        timeout: '10m',
-        prompt: '',
-    };
-}
-/** Is the watchdog routine present on disk (user or system layer)? */
-export function watchdogRoutineExists() {
-    return readJob(WATCHDOG_ROUTINE_NAME) !== null;
-}
-/** Is the watchdog routine present AND enabled? */
-export function isWatchdogRoutineEnabled() {
-    const job = readJob(WATCHDOG_ROUTINE_NAME);
-    return job !== null && job.enabled === true;
-}
-/**
- * Ensure the watchdog routine exists with the requested enabled state, preserving
- * any user edits. Absent → create it; present → only flip `enabled` (never clobber
- * a schedule or command the user tuned). Idempotent: calling it twice with the
- * same state is a no-op after the first.
- */
-export function ensureWatchdogRoutine(enabled) {
-    const existing = readJob(WATCHDOG_ROUTINE_NAME);
-    if (existing === null) {
-        writeJob(buildWatchdogRoutine(enabled));
-        return;
-    }
-    if (existing.enabled !== enabled) {
-        setJobEnabled(WATCHDOG_ROUTINE_NAME, enabled);
-    }
-}