@phnx-labs/agents-cli 1.22.23 → 1.22.25

package/dist/commands/sync.js

@@ -31,6 +31,7 @@
  */
 import * as path from 'path';
 import chalk from 'chalk';
+import { resolveSyncPassphraseFromEnv } from '../lib/secrets/sync-passphrase.js';
 import { agentLabel, resolveAgentName, MANAGED_AGENT_IDS, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
 import { isVersionInstalled, syncResourcesToVersion, parseAgentSpec, resolveVersion, resolveVersionAlias, listInstalledVersions, getAvailableResources, getActuallySyncedResources, getProjectOnlyResources, getNewResources, hasNewResources, promptResourceSelection, promptNewResourceSelection, buildRepoScopedSelection, mergeRepoScopedSelections, listRepoNames, getVersionHomePath, } from '../lib/versions.js';
 import { capableAgents } from '../lib/capabilities.js';
@@ -43,6 +44,10 @@ import { runUmbrellaSync } from '../lib/sync-umbrella.js';
 import { addHostOption } from '../lib/hosts/option.js';
 import { syncRepoGit } from '../lib/git.js';
 import { getSystemAgentsDir, getUserAgentsDir, getEnabledExtraRepos } from '../lib/state.js';
+/** Emit one JSON object to stdout for `--json` callers / fleet fan-out. */
+function emitJson(payload) {
+    console.log(JSON.stringify(payload));
+}
 /** Register the `agents sync` command. */
 export function registerSyncCommand(program) {
     addHostOption(program.command('sync [agentSpec] [repo]'))
@@ -57,6 +62,7 @@ export function registerSyncCommand(program) {
         .option('-y, --yes', 'Skip the interactive preview and auto-sync all detected resources', false)
         .option('--force', 'Re-sync even if no changes are detected since the last sync', false)
         .option('--quiet', 'Suppress all output (exit code indicates success)', false)
+        .option('--json', 'Emit machine-readable JSON (also accepted so fleet fan-out via --host all can parse each peer)', false)
         // Umbrella verb (no agent given): make this machine current.
         .option('--repos', 'Umbrella: git-pull ~/.agents + enabled ~/.agents-* extras', false)
         .option('--secrets', 'Umbrella: pull encrypted secret bundles from the remote', false)
@@ -88,22 +94,47 @@ function resolveRepoGitTarget(repo) {
  * tree, else pull --rebase against origin, pushing local commits for user-owned
  * repos. Delegates the git work to `syncRepoGit`.
  */
-async function runRepoGitSync(repo, quiet, outLog, errLog) {
+async function runRepoGitSync(repo, quiet, outLog, errLog, json = false) {
     const target = resolveRepoGitTarget(repo);
     if (!target) {
-        errLog(chalk.red(`The '${repo}' repo isn't independently git-synced.`));
-        errLog(chalk.gray('Syncable repos: system (pull-only), user, and enabled extra-repo aliases.'));
+        if (json) {
+            emitJson({
+                ok: false,
+                mode: 'repo-git',
+                repo,
+                error: `The '${repo}' repo isn't independently git-synced.`,
+            });
+        }
+        else {
+            errLog(chalk.red(`The '${repo}' repo isn't independently git-synced.`));
+            errLog(chalk.gray('Syncable repos: system (pull-only), user, and enabled extra-repo aliases.'));
+        }
         process.exitCode = 1;
         return;
     }
-    if (!quiet)
+    if (!quiet && !json)
         outLog(chalk.bold(`Syncing ${repo} repo…`) + chalk.gray(` (${target.dir})`));
     const result = await syncRepoGit(target.dir, { push: target.push });
     if (!result.success) {
-        errLog(chalk.red(`sync ${repo} failed: ${result.error}`));
+        if (json) {
+            emitJson({ ok: false, mode: 'repo-git', repo, error: result.error ?? 'sync failed' });
+        }
+        else {
+            errLog(chalk.red(`sync ${repo} failed: ${result.error}`));
+        }
         process.exitCode = 1;
         return;
     }
+    if (json) {
+        emitJson({
+            ok: true,
+            mode: 'repo-git',
+            repo,
+            commit: result.commit,
+            pushed: !!result.pushed,
+        });
+        return;
+    }
     if (!quiet) {
         const note = result.pushed ? ' · pushed' : ' · pull-only';
         outLog(chalk.green(`✓ ${repo} → ${result.commit}${note}`));
@@ -201,12 +232,14 @@ async function runInteractiveReconcile(opts, outLog, errLog) {
  * arrives with `agents login`) and runs the fetch+reconcile stages, then prints
  * a one-line summary. Stage failures are non-fatal and surfaced as warnings.
  */
-async function runUmbrella(opts, quiet, outLog, errLog) {
+async function runUmbrella(opts, quiet, outLog, errLog, json = false) {
     // Interactive bare `agents sync` (a TTY, no --yes, no scope flag) drops into
     // the two-checklist picker: which repos to sync from, which agents to sync
-    // into. Any explicit flag or --yes keeps the non-interactive umbrella below.
+    // into. Any explicit flag, --yes, or --json keeps the non-interactive path.
+    // --json is a machine consumer (and the fleet fan-out injects it), so never
+    // open a picker under it.
     const anyExplicitFlag = !!(opts.repos || opts.secrets || opts.cloud || opts.local);
-    if (!quiet && !opts.yes && !anyExplicitFlag && isInteractiveTerminal()) {
+    if (!quiet && !json && !opts.yes && !anyExplicitFlag && isInteractiveTerminal()) {
         await runInteractiveReconcile(opts, outLog, errLog);
         return;
     }
@@ -216,17 +249,36 @@ async function runUmbrella(opts, quiet, outLog, errLog) {
         cloud: opts.cloud,
         local: opts.local,
     };
-    const passphrase = process.env.AGENTS_SECRETS_PASSPHRASE || undefined;
-    if (!quiet)
+    // Same chokepoint as `agents secrets push/pull` — prefers AGENTS_SYNC_PASSPHRASE,
+    // falls back to the deprecated master-key name with a single warning.
+    const passphrase = resolveSyncPassphraseFromEnv().value ?? undefined;
+    // Fleet fan-out only injects --json (not --yes). Treat --json as non-interactive
+    // so refresh({ skipPrompts }) never tries to prompt over SSH.
+    const yes = !!opts.yes || json;
+    if (!quiet && !json)
         outLog(chalk.bold('Syncing this machine…'));
     try {
         const result = await runUmbrellaSync({
             flags,
-            yes: !!opts.yes,
+            yes,
             passphrase,
-            log: (msg) => { if (!quiet)
+            // quiet under --json so refresh() cannot pollute the JSON stdout the fleet parses.
+            quiet: quiet || json,
+            log: (msg) => { if (!quiet && !json)
                 outLog(chalk.gray(`  ${msg}`)); },
         });
+        if (json) {
+            emitJson({
+                ok: true,
+                mode: 'umbrella',
+                plan: result.plan,
+                repos: result.repos,
+                secrets: result.secrets,
+                devices: result.devices,
+                reconciled: result.reconciled,
+            });
+            return;
+        }
         if (!quiet) {
             const parts = [];
             if (result.repos) {
@@ -245,16 +297,30 @@ async function runUmbrella(opts, quiet, outLog, errLog) {
         }
     }
     catch (err) {
-        errLog(chalk.red(`sync failed: ${err.message}`));
+        if (json) {
+            emitJson({ ok: false, mode: 'umbrella', error: err.message });
+        }
+        else {
+            errLog(chalk.red(`sync failed: ${err.message}`));
+        }
         process.exitCode = 1;
     }
 }
 async function runSync(agentSpec, repoArg, opts) {
-    const quiet = !!opts.quiet;
+    const json = !!opts.json;
+    // --json is a machine consumer: suppress human stdout/stderr chatter so the
+    // single JSON object on stdout stays parseable for fleet fan-out.
+    const quiet = !!opts.quiet || json;
     const errLog = (msg) => { if (!quiet)
         console.error(msg); };
     const outLog = (msg) => { if (!quiet)
         console.log(msg); };
+    // Failures under --json still need a structured line on stdout so fleet
+    // fan-out's safeJsonParse gets a real object (not "unknown option").
+    const failJson = (payload) => {
+        if (json)
+            emitJson({ ok: false, ...payload });
+    };
     // ---------- 1. Resolve agent + version ----------
     let agentId;
     let version;
@@ -271,14 +337,21 @@ async function runSync(agentSpec, repoArg, opts) {
     // below, and it precedes agent-spec parsing because repo names like
     // "system"/"user" would otherwise fail parseAgentSpec.
     if (agentSpec && !opts.agent && !repoArg && listRepoNames().includes(agentSpec)) {
-        await runRepoGitSync(agentSpec, quiet, outLog, errLog);
+        await runRepoGitSync(agentSpec, quiet, outLog, errLog, json);
         return;
     }
     if (agentSpec) {
         const parsed = parseAgentSpec(agentSpec);
         if (!parsed) {
-            errLog(chalk.red(`Invalid agent spec '${agentSpec}'.`));
-            errLog(chalk.gray('Examples: claude, claude@2.1.142, claude@latest, claude@oldest, claude@pinned, claude@all'));
+            failJson({
+                mode: 'agent',
+                error: `Invalid agent spec '${agentSpec}'.`,
+                hint: 'Examples: claude, claude@2.1.142, claude@latest, claude@oldest, claude@pinned, claude@all',
+            });
+            if (!json) {
+                errLog(chalk.red(`Invalid agent spec '${agentSpec}'.`));
+                errLog(chalk.gray('Examples: claude, claude@2.1.142, claude@latest, claude@oldest, claude@pinned, claude@all'));
+            }
             process.exitCode = 1;
             return;
         }
@@ -292,8 +365,11 @@ async function runSync(agentSpec, repoArg, opts) {
     if (repoScope !== undefined) {
         const known = listRepoNames();
         if (!known.includes(repoScope)) {
-            errLog(chalk.red(`Unknown repo '${repoScope}'.`));
-            errLog(chalk.gray(`Known repos: ${known.join(', ')}`));
+            failJson({ mode: 'agent', error: `Unknown repo '${repoScope}'.`, known });
+            if (!json) {
+                errLog(chalk.red(`Unknown repo '${repoScope}'.`));
+                errLog(chalk.gray(`Known repos: ${known.join(', ')}`));
+            }
             process.exitCode = 1;
             return;
         }
@@ -301,14 +377,18 @@ async function runSync(agentSpec, repoArg, opts) {
     if (opts.agent) {
         const resolved = resolveAgentName(opts.agent);
         if (!resolved) {
-            errLog(chalk.red(`Unknown agent '${opts.agent}'.`));
+            failJson({ mode: 'agent', error: `Unknown agent '${opts.agent}'.` });
+            if (!json)
+                errLog(chalk.red(`Unknown agent '${opts.agent}'.`));
             process.exitCode = 1;
             return;
         }
         agentId = resolved;
     }
     if (agentId && isAgentHardDeprecated(agentId)) {
-        errLog(chalk.red(hardDeprecationError(agentId)));
+        failJson({ mode: 'agent', error: hardDeprecationError(agentId) });
+        if (!json)
+            errLog(chalk.red(hardDeprecationError(agentId)));
         process.exitCode = 1;
         return;
     }
@@ -320,7 +400,8 @@ async function runSync(agentSpec, repoArg, opts) {
     if (!agentId) {
         // No agent specified → the umbrella verb: make this machine current
         // (fetch repos + secrets + sessions, then reconcile all installed agents).
-        await runUmbrella(opts, quiet, outLog, errLog);
+        // This is the path fleet fan-out (`--host all`) hits with injected --json.
+        await runUmbrella(opts, quiet, outLog, errLog, json);
         return;
     }
     const projectDir = opts.projectDir;
@@ -332,8 +413,11 @@ async function runSync(agentSpec, repoArg, opts) {
     if (selector === 'all') {
         const installed = listInstalledVersions(agentId);
         if (installed.length === 0) {
-            errLog(chalk.red(`No ${agentLabel(agentId)} versions installed.`));
-            errLog(chalk.gray(`Install one: agents add ${agentId}@latest`));
+            failJson({ mode: 'agent-all', agent: agentId, error: `No ${agentLabel(agentId)} versions installed.` });
+            if (!json) {
+                errLog(chalk.red(`No ${agentLabel(agentId)} versions installed.`));
+                errLog(chalk.gray(`Install one: agents add ${agentId}@latest`));
+            }
             process.exitCode = 1;
             return;
         }
@@ -341,17 +425,43 @@ async function runSync(agentSpec, repoArg, opts) {
         if (repoScope) {
             selection = buildRepoScopedSelection(repoScope, cwd);
             if (Object.keys(selection).length === 0) {
-                outLog(chalk.gray(`Nothing from repo '${repoScope}' to sync.`));
+                if (json)
+                    emitJson({ ok: true, mode: 'agent-all', agent: agentId, repo: repoScope, versions: [], note: 'nothing to sync' });
+                else
+                    outLog(chalk.gray(`Nothing from repo '${repoScope}' to sync.`));
                 return;
             }
         }
         const scopeLabel = repoScope ? chalk.gray(` (repo: ${repoScope})`) : '';
-        outLog(chalk.cyan(`Syncing ${installed.length} ${agentLabel(agentId)} version(s)${scopeLabel}.`));
+        if (!json)
+            outLog(chalk.cyan(`Syncing ${installed.length} ${agentLabel(agentId)} version(s)${scopeLabel}.`));
+        const versions = [];
         for (const v of installed) {
             const result = syncResourcesToVersion(agentId, v, selection, { projectDir, cwd, force });
-            if (!quiet)
+            versions.push({ version: v, result });
+            if (!quiet && !json)
                 printSyncDetail(result, agentId, v, cwd);
         }
+        if (json) {
+            emitJson({
+                ok: true,
+                mode: 'agent-all',
+                agent: agentId,
+                repo: repoScope,
+                versions: versions.map(({ version: v, result }) => ({
+                    version: v,
+                    commands: !!result.commands,
+                    skills: !!result.skills,
+                    hooks: !!result.hooks,
+                    memory: result.memory,
+                    mcp: result.mcp,
+                    permissions: !!result.permissions,
+                    subagents: result.subagents,
+                    plugins: result.plugins,
+                    workflows: result.workflows,
+                })),
+            });
+        }
         return;
     }
     // ---------- 2. Resolve version (project pin → global default → sole installed) ----------
@@ -370,15 +480,26 @@ async function runSync(agentSpec, repoArg, opts) {
                 version = installed[0];
             }
             else if (installed.length === 0) {
-                errLog(chalk.red(`No ${agentLabel(agentId)} versions installed.`));
-                errLog(chalk.gray(`Install one: agents add ${agentId}@latest`));
+                failJson({ mode: 'agent', agent: agentId, error: `No ${agentLabel(agentId)} versions installed.` });
+                if (!json) {
+                    errLog(chalk.red(`No ${agentLabel(agentId)} versions installed.`));
+                    errLog(chalk.gray(`Install one: agents add ${agentId}@latest`));
+                }
                 process.exitCode = 1;
                 return;
             }
             else {
-                errLog(chalk.red(`No default ${agentLabel(agentId)} version pinned. Specify one:`));
-                for (const v of installed) {
-                    errLog(chalk.gray(`  agents sync ${agentId}@${v}`));
+                failJson({
+                    mode: 'agent',
+                    agent: agentId,
+                    error: `No default ${agentLabel(agentId)} version pinned.`,
+                    installed,
+                });
+                if (!json) {
+                    errLog(chalk.red(`No default ${agentLabel(agentId)} version pinned. Specify one:`));
+                    for (const v of installed) {
+                        errLog(chalk.gray(`  agents sync ${agentId}@${v}`));
+                    }
                 }
                 process.exitCode = 1;
                 return;
@@ -386,18 +507,27 @@ async function runSync(agentSpec, repoArg, opts) {
         }
     }
     if (!isVersionInstalled(agentId, version)) {
-        errLog(chalk.red(`${agentLabel(agentId)}@${version} is not installed.`));
         const installed = listInstalledVersions(agentId);
-        if (installed.length > 0) {
-            errLog(chalk.gray(`Installed: ${installed.join(', ')}`));
+        failJson({
+            mode: 'agent',
+            agent: agentId,
+            version,
+            error: `${agentLabel(agentId)}@${version} is not installed.`,
+            installed,
+        });
+        if (!json) {
+            errLog(chalk.red(`${agentLabel(agentId)}@${version} is not installed.`));
+            if (installed.length > 0) {
+                errLog(chalk.gray(`Installed: ${installed.join(', ')}`));
+            }
+            errLog(chalk.gray(`Install it: agents add ${agentId}@${version}`));
         }
-        errLog(chalk.gray(`Install it: agents add ${agentId}@${version}`));
         process.exitCode = 1;
         return;
     }
     // ---------- 3. --launch mode bypasses everything below ----------
     if (opts.launch) {
-        runLaunchMode(agentId, version, cwd, quiet);
+        runLaunchMode(agentId, version, cwd, quiet, json);
         return;
     }
     // ---------- 3b. Repo-scoped single-version sync ----------
@@ -406,16 +536,33 @@ async function runSync(agentSpec, repoArg, opts) {
     if (repoScope) {
         const scoped = buildRepoScopedSelection(repoScope, cwd);
         if (Object.keys(scoped).length === 0) {
-            outLog(chalk.gray(`Nothing from repo '${repoScope}' to sync into ${agentLabel(agentId)}@${version}.`));
+            if (json) {
+                emitJson({
+                    ok: true,
+                    mode: 'agent',
+                    agent: agentId,
+                    version,
+                    repo: repoScope,
+                    note: 'nothing to sync',
+                });
+            }
+            else {
+                outLog(chalk.gray(`Nothing from repo '${repoScope}' to sync into ${agentLabel(agentId)}@${version}.`));
+            }
             return;
         }
         const result = syncResourcesToVersion(agentId, version, scoped, { projectDir, cwd, force });
-        if (!quiet)
+        if (json) {
+            emitJson(agentSyncJson(agentId, version, result, repoScope));
+        }
+        else if (!quiet) {
             printSyncDetail(result, agentId, version, cwd);
+        }
         return;
     }
     // ---------- 4. Decide selection (interactive preview vs auto) ----------
-    const yes = !!opts.yes;
+    // --json forces non-interactive (machine consumer / fleet fan-out).
+    const yes = !!opts.yes || json;
     const interactive = !quiet && !yes && isInteractiveTerminal();
     let selection;
     if (interactive) {
@@ -468,6 +615,20 @@ async function runSync(agentSpec, repoArg, opts) {
         const projectRoot = path.dirname(projectDir);
         projectCompile = compileRulesForProject(projectRoot);
     }
+    if (json) {
+        emitJson({
+            ...agentSyncJson(agentId, version, result),
+            projectCompile: projectCompile
+                ? {
+                    compiled: !!projectCompile.compiled,
+                    agentsPath: projectCompile.agentsPath,
+                    symlinks: projectCompile.symlinks,
+                    skippedClobber: projectCompile.skippedClobber,
+                }
+                : null,
+        });
+        return;
+    }
     if (quiet)
         return;
     // ---------- 6. Detailed output ----------
@@ -482,6 +643,26 @@ async function runSync(agentSpec, repoArg, opts) {
         console.log(chalk.yellow(`Skipped (user-authored, not overwritten): ${projectCompile.skippedClobber.join(', ')}`));
     }
 }
+/** Stable `--json` payload for a single agent@version resource sync. */
+function agentSyncJson(agent, version, result, repo) {
+    return {
+        ok: true,
+        mode: 'agent',
+        agent,
+        version,
+        ...(repo !== undefined ? { repo } : {}),
+        commands: !!result.commands,
+        skills: !!result.skills,
+        hooks: !!result.hooks,
+        memory: result.memory,
+        mcp: result.mcp,
+        permissions: !!result.permissions,
+        subagents: result.subagents,
+        plugins: result.plugins,
+        workflows: result.workflows,
+        projectSkipped: result.projectSkipped,
+    };
+}
 function anyResources(r) {
     return r.commands.length + r.skills.length + r.hooks.length + r.memory.length +
         r.mcp.length + r.permissions.length + r.subagents.length +
@@ -533,17 +714,40 @@ function printSyncDetail(result, agent, version, cwd) {
     if (kept)
         console.log(chalk.gray(kept));
 }
-function runLaunchMode(agent, version, cwd, quiet) {
+function runLaunchMode(agent, version, cwd, quiet, json = false) {
     let result;
     try {
         result = runLaunchSync({ agent, version, cwd });
     }
     catch (err) {
-        if (!quiet) {
+        if (json) {
+            emitJson({
+                ok: false,
+                mode: 'launch',
+                agent,
+                version,
+                error: err.message,
+            });
+            process.exitCode = 1;
+        }
+        else if (!quiet) {
             console.error(chalk.yellow(`agents: launch sync skipped (${err.message})`));
         }
         return;
     }
+    if (json) {
+        emitJson({
+            ok: true,
+            mode: 'launch',
+            agent,
+            version,
+            rulesCompiled: !!result.rulesCompiled,
+            workspaceLinks: result.workspaceLinks,
+            marketplaces: result.marketplaces,
+            workspaceSkipped: result.workspaceSkipped,
+        });
+        return;
+    }
     if (quiet)
         return;
     const bits = [];

package/dist/commands/teams.js

@@ -47,8 +47,9 @@ const AGENT_NAMES = {
     antigravity: 'Antigravity',
     kimi: 'Kimi',
     droid: 'Droid',
+    warp: 'Warp',
 };
-const VALID_AGENTS = ['claude', 'codex', 'cursor', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
+const VALID_AGENTS = ['claude', 'codex', 'cursor', 'opencode', 'grok', 'antigravity', 'kimi', 'droid', 'warp'];
 // 'full' kept as historical alias for 'skip'; normalized to 'skip' downstream.
 const VALID_MODES = ['plan', 'edit', 'auto', 'skip', 'full'];
 const VALID_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'auto'];
@@ -1279,7 +1280,7 @@ export function registerTeamsCommands(program) {
         .alias('a')
         .description("Add a teammate to work on a task. Runs in background; returns immediately. Use 'status' to check in.")
         .option('-n, --name <name>', 'Friendly name for this teammate (e.g. alice). Required if using --after. Unique within team.')
-        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/droid/opencode; kimi/grok/cursor/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
+        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/cursor/droid/opencode; kimi/grok/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
         .option('-e, --effort <effort>', `Reasoning intensity: ${VALID_EFFORTS.join('|')}`, 'medium')
         .option('--model <model>', 'Cost tier (cheap|default|best|ultra) or a concrete id (e.g. claude-opus-4-8); tiers resolve per harness+version to a supported model')
         .option('--env <key=value>', 'Set an environment variable for this teammate (repeatable for multiple vars)', (val, prev) => [...prev, val], [])

package/dist/commands/view.js

@@ -578,6 +578,8 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 const runDefaultBits = [];
                 if (runDefaults.mode)
                     runDefaultBits.push(`mode:${runDefaults.mode}`);
+                if (runDefaults.effort)
+                    runDefaultBits.push('effort:' + runDefaults.effort);
                 if (!hasEmail && !hasUsage && !signedIn) {
                     // No per-version credential. That is NOT the same as unusable: Claude
                     // Code authenticates from `CLAUDE_CODE_OAUTH_TOKEN` when the

package/dist/commands/watchdog.d.ts

@@ -10,12 +10,11 @@
  *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
  *   agents watchdog --watch            manual poll loop (dry unless --nudge)
  *   agents watchdog --json             machine-readable tick output (for the menu-bar)
- *   agents watchdog on|off             turn the always-on watchdog routine on/off
+ *   agents watchdog on|off             turn the device-local daemon pass on/off
  *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
  *
- * The always-on watchdog is a daemon-fired ROUTINE, not a private sentinel + a
- * hand-rolled loop. Its immutable definition comes from the system DotAgents
- * repo; on/off only changes this device's routine membership.
+ * The agents daemon is the sole automatic watchdog scheduler. The menu bar reads
+ * persisted state; it never runs a tick.
  */
 import type { Command } from 'commander';
 /** Register the `agents watchdog` command tree. */