@phnx-labs/agents-cli 1.22.14 → 1.22.15

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/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.14",
+  "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);
-    }
-}