@phnx-labs/agents-cli 1.22.35 → 1.22.37

package/dist/lib/startup/command-registry.js

@@ -39,20 +39,19 @@ export const loadCli = async () => (await import('../../commands/cli.js')).regis
 export const loadSubagents = async () => (await import('../../commands/subagents.js')).registerSubagentsCommands;
 export const loadPlugins = async () => (await import('../../commands/plugins.js')).registerPluginsCommands;
 export const loadWorkflows = async () => (await import('../../commands/workflows.js')).registerWorkflowsCommands;
-export const loadWorktree = async () => (await import('../../commands/worktree.js')).registerWorktreeCommands;
 export const loadVersions = async () => (await import('../../commands/versions.js')).registerVersionsCommands;
 export const loadUpdate = async () => (await import('../../commands/update.js')).registerUpdateCommand;
 export const loadImport = async () => (await import('../../commands/import.js')).registerImportCommand;
-export const loadExport = async () => (await import('../../commands/export.js')).registerExportCommand;
 export const loadPackages = async () => (await import('../../commands/packages.js')).registerPackagesCommands;
 export const loadRoutines = async () => (await import('../../commands/routines.js')).registerRoutinesCommands;
 export const loadMonitors = async () => (await import('../../commands/monitors.js')).registerMonitorsCommands;
 export const loadProjects = async () => (await import('../../commands/projects.js')).registerProjectsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
 export const loadResume = async () => (await import('../../commands/resume.js')).registerResumeCommand;
+export const loadOpen = async () => (await import('../../commands/open.js')).registerOpenCommand;
 export const loadReconnect = async () => (await import('../../commands/reconnect.js')).registerReconnectCommand;
 export const loadFork = async () => (await import('../../commands/fork.js')).registerForkCommand;
-export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
+export const loadConfig = async () => (await import('../../commands/config.js')).registerConfigCommand;
 export const loadSet = async () => (await import('../../commands/set.js')).registerSetCommand;
 export const loadModels = async () => (await import('../../commands/models.js')).registerModelsCommand;
 export const loadModes = async () => (await import('../../commands/modes.js')).registerModesCommand;
@@ -67,12 +66,9 @@ export const loadProfiles = async () => (await import('../../commands/profiles.j
 export const loadHarness = async () => (await import('../../commands/harness.js')).registerHarnessCommands;
 export const loadSecrets = async () => (await import('../../commands/secrets.js')).registerSecretsCommands;
 export const loadLogin = async () => (await import('../../commands/login.js')).registerLoginCommands;
-export const loadWallet = async () => (await import('../../commands/wallet.js')).registerWalletCommands;
-export const loadHelper = async () => (await import('../../commands/helper.js')).registerHelperCommand;
 export const loadMenubar = async () => (await import('../../commands/menubar.js')).registerMenubarCommands;
 export const loadBeta = async () => (await import('../../commands/beta.js')).registerBetaCommands;
 export const loadSync = async () => (await import('../../commands/sync.js')).registerSyncCommand;
-export const loadLock = async () => (await import('../../commands/lock.js')).registerLockCommand;
 export const loadRefreshRules = async () => (await import('../../commands/refresh-rules.js')).registerRefreshRulesCommand;
 export const loadFactory = async () => (await import('../../commands/factory.js')).registerFactoryCommands;
 export const loadUsage = async () => (await import('../../commands/usage.js')).registerUsageCommand;
@@ -91,19 +87,16 @@ export const loadTmux = async () => (await import('../../commands/tmux.js')).reg
 export const loadWatchdog = async () => (await import('../../commands/watchdog.js')).registerWatchdogCommand;
 export const loadBrowser = async () => (await import('../../commands/browser.js')).registerBrowserCommand;
 export const loadComputer = async () => (await import('../../commands/computer.js')).registerComputerCommand;
-export const loadHosts = async () => (await import('../../commands/hosts.js')).registerHostsCommand;
-export const loadLease = async () => (await import('../../commands/lease.js')).registerLeaseCommand;
 export const loadLogs = async () => (await import('../../commands/logs.js')).registerLogsCommand;
 export const loadEvents = async () => (await import('../../commands/events.js')).registerEventsCommand;
 export const loadSsh = async () => (await import('../../commands/ssh.js')).registerSshCommands;
-export const loadPull = async () => (await import('../../commands/pull.js')).registerPullCommand;
-export const loadPush = async () => (await import('../../commands/push.js')).registerPushCommand;
 export const loadRepo = async () => (await import('../../commands/repo.js')).registerRepoCommands;
 export const loadSetup = async () => (await import('../../commands/setup.js')).registerSetupCommand;
 export const loadUninstall = async () => (await import('../../commands/uninstall.js')).registerUninstallCommands;
 export const loadUpgrade = async () => (await import('../../commands/upgrade.js')).registerUpgradeCommand;
 export const loadSessions = async () => (await import('../../commands/sessions.js')).registerSessionsCommands;
 export const loadTeams = async () => (await import('../../commands/teams.js')).registerTeamsCommands;
+export const loadTickets = async () => (await import('../../commands/tickets.js')).registerTicketsCommand;
 export const loadCloud = async () => (await import('../../commands/cloud.js')).registerCloudCommands;
 export const loadMessage = async () => (await import('../../commands/message.js')).registerMessageCommand;
 export const loadSend = async () => (await import('../../commands/send.js')).registerSendCommand;
@@ -112,11 +105,11 @@ export const loadMailboxes = async () => (await import('../../commands/mailboxes
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadShare = async () => (await import('../../commands/share.js')).registerShareCommands;
 export const loadAudit = async () => (await import('../../commands/audit.js')).registerAuditCommands;
-export const loadWebhook = async () => (await import('../../commands/webhook.js')).registerWebhookCommand;
-export const loadFunnel = async () => (await import('../../commands/funnel.js')).registerFunnelCommand;
+export const loadWebhooks = async () => (await import('../../commands/webhook.js')).registerWebhooksCommand;
 export const loadHumans = async () => (await import('../../commands/humans.js')).registerHumansCommands;
 export const loadAccounts = async () => (await import('../../commands/accounts.js')).registerAccountsCommand;
 export const loadDaemon = async () => (await import('../../commands/daemon.js')).registerDaemonCommand;
+export const loadCp = async () => (await import('../../commands/cp.js')).registerCpCommand;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help
@@ -166,7 +159,6 @@ export const COMMAND_LOADERS = {
     subagents: [loadSubagents],
     plugins: [loadPlugins],
     workflows: [loadWorkflows],
-    worktree: [loadWorktree],
     add: [loadVersions],
     use: [loadVersions],
     list: [loadVersions],
@@ -176,23 +168,18 @@ export const COMMAND_LOADERS = {
     update: [loadUpdate],
     prune: [loadVersions, loadPrune],
     import: [loadImport],
-    export: [loadExport],
     registry: [loadPackages],
     search: [loadPackages],
     install: [loadPackages],
-    // packages.ts also registers `publish` at top level (commands/packages.ts:435).
-    // It was missing here, so `agents publish` only worked via the unknown-command
-    // fallback that registers the whole tree — and the --host router could not see
-    // it as a real command at all (RUSH-2022).
-    publish: [loadPackages],
     routines: [loadRoutines],
     monitors: [loadMonitors],
     projects: [loadProjects],
     run: [loadRun],
     resume: [loadResume],
+    open: [loadOpen],
     reconnect: [loadReconnect],
     fork: [loadFork],
-    defaults: [loadDefaults],
+    config: [loadConfig],
     set: [loadSet],
     models: [loadModels],
     modes: [loadModes],
@@ -202,20 +189,15 @@ export const COMMAND_LOADERS = {
     apply: [loadApply],
     status: [loadStatus],
     snapshot: [loadSnapshot],
-    profile: [loadProfiles],
     profiles: [loadProfiles],
     harness: [loadHarness],
     harnesses: [loadHarness],
     secrets: [loadSecrets],
     login: [loadLogin],
     logout: [loadLogin],
-    whoami: [loadLogin],
-    wallet: [loadWallet],
-    helper: [loadHelper],
     menubar: [loadMenubar],
     beta: [loadBeta],
     sync: [loadSync],
-    lock: [loadLock],
     'refresh-rules': [loadRefreshRules],
     factory: [loadFactory],
     usage: [loadUsage],
@@ -233,8 +215,6 @@ export const COMMAND_LOADERS = {
     watchdog: [loadWatchdog],
     browser: [loadBrowser],
     computer: [loadComputer],
-    hosts: [loadHosts],
-    lease: [loadLease],
     logs: [loadLogs],
     events: [loadEvents],
     ssh: [loadSsh],
@@ -242,8 +222,6 @@ export const COMMAND_LOADERS = {
     // `fleet` is a commander alias of `devices` (see commands/ssh.ts); list it so
     // lazy registration loads the devices tree when the user types `agents fleet`.
     fleet: [loadSsh],
-    pull: [loadPull],
-    push: [loadPush],
     // `repos` is the canonical command name; `repo` remains a convenience alias
     // (see commands/repo.ts). List both so lazy registration loads the tree
     // whichever the user types.
@@ -256,6 +234,7 @@ export const COMMAND_LOADERS = {
     // Observe-umbrella alias of sessions --active (same lazy module).
     roster: [loadSessions],
     teams: [loadTeams],
+    tickets: [loadTickets],
     cloud: [loadCloud],
     message: [loadMessage],
     send: [loadSend],
@@ -272,10 +251,10 @@ export const COMMAND_LOADERS = {
     // commands/share.ts) — same module, registered as its own program.command().
     unshare: [loadShare],
     audit: [loadAudit],
-    webhook: [loadWebhook],
-    funnel: [loadFunnel],
+    webhooks: [loadWebhooks],
     humans: [loadHumans],
     daemon: [loadDaemon],
+    cp: [loadCp],
 };
 /**
  * Top-level names that {@link COMMAND_LOADERS} does not carry because they are
@@ -309,6 +288,7 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
     ...Object.keys(COMMAND_LOADERS),
     ...INLINE_COMMAND_NAMES,
 ]);
+export const RETIRED_TOP_LEVEL_COMMANDS = new Set(['webhook']);
 /** Whether `name` is a top-level command this CLI registers. See {@link KNOWN_TOP_LEVEL_COMMANDS}. */
 export function isKnownTopLevelCommand(name) {
     return KNOWN_TOP_LEVEL_COMMANDS.has(name);

package/dist/lib/startup/dev-build.d.ts

@@ -19,4 +19,14 @@
  * actually be the agents-cli package (its package.json `name`), not some
  * unrelated ancestor that happens to be version-controlled.
  */
+/**
+ * Whether a version string is the `0.0.0-dev.<sha>[-dirty]` stamp
+ * `scripts/install.sh` writes for a side-by-side dev install (`install.sh:61`).
+ *
+ * Split out from {@link detectDevBuild} because a caller holding only a version
+ * string — a fleet rollout reading `agents --version` off a remote box — cannot
+ * run signal 2 (it needs that machine's filesystem), and must not re-spell the
+ * stamp prefix.
+ */
+export declare function isDevVersionStamp(version: string): boolean;
 export declare function detectDevBuild(argv1: string, version: string): boolean;

package/dist/lib/startup/dev-build.js

@@ -21,8 +21,20 @@ import * as path from 'path';
  * actually be the agents-cli package (its package.json `name`), not some
  * unrelated ancestor that happens to be version-controlled.
  */
+/**
+ * Whether a version string is the `0.0.0-dev.<sha>[-dirty]` stamp
+ * `scripts/install.sh` writes for a side-by-side dev install (`install.sh:61`).
+ *
+ * Split out from {@link detectDevBuild} because a caller holding only a version
+ * string — a fleet rollout reading `agents --version` off a remote box — cannot
+ * run signal 2 (it needs that machine's filesystem), and must not re-spell the
+ * stamp prefix.
+ */
+export function isDevVersionStamp(version) {
+    return version.startsWith('0.0.0-dev');
+}
 export function detectDevBuild(argv1, version) {
-    if (version.startsWith('0.0.0-dev'))
+    if (isDevVersionStamp(version))
         return true;
     try {
         const cliPath = fs.realpathSync(argv1 || '');

package/dist/lib/startup/spellcheck.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Top-level command spellcheck (RUSH-2329).
+ *
+ * Candidates are plain strings from KNOWN_TOP_LEVEL_COMMANDS — never the live
+ * commander registry — so an unknown / typo'd invocation does not pay for
+ * registerAllEagerCommands (~250-330ms of dynamic import + module eval).
+ */
+/** Calculate the Levenshtein edit distance between two strings. */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Closest top-level command name by Levenshtein distance.
+ * Iterates candidates in first-seen order so ties break the same way as the
+ * historical registerAllEagerCommands registration order (RUSH-2329).
+ */
+export declare function closestTopLevelCommand(unknown: string, candidates: Iterable<string>): {
+    closest: string | null;
+    minDist: number;
+};

package/dist/lib/startup/spellcheck.js

@@ -0,0 +1,45 @@
+/**
+ * Top-level command spellcheck (RUSH-2329).
+ *
+ * Candidates are plain strings from KNOWN_TOP_LEVEL_COMMANDS — never the live
+ * commander registry — so an unknown / typo'd invocation does not pay for
+ * registerAllEagerCommands (~250-330ms of dynamic import + module eval).
+ */
+/** Calculate the Levenshtein edit distance between two strings. */
+export function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array(m + 1)
+        .fill(null)
+        .map(() => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] =
+                a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1]
+                    : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+/**
+ * Closest top-level command name by Levenshtein distance.
+ * Iterates candidates in first-seen order so ties break the same way as the
+ * historical registerAllEagerCommands registration order (RUSH-2329).
+ */
+export function closestTopLevelCommand(unknown, candidates) {
+    let closest = null;
+    let minDist = Infinity;
+    for (const cmd of candidates) {
+        const dist = levenshtein(unknown, cmd);
+        if (dist < minDist) {
+            minDist = dist;
+            closest = cmd;
+        }
+    }
+    return { closest, minDist };
+}

package/dist/lib/state.d.ts

@@ -29,7 +29,7 @@ export declare function getHumansFilePath(): string;
  * Header prepended to every agents.yaml the CLI writes (central and per-device
  * docs). Carries the yaml-language-server schema hint so editors validate the
  * file against `schema/agents-yaml.schema.json`. Exported so
- * `lib/device-config.ts` writes a sibling device's doc with the same header.
+ * `lib/devices/config-migration.ts` rewrites a device doc with the same header.
  */
 export declare const META_HEADER = "# agents-cli metadata\n# Auto-generated - do not edit manually\n# https://github.com/phnx-labs/agents-cli\n# yaml-language-server: $schema=https://raw.githubusercontent.com/phnx-labs/agents-cli/main/apps/cli/schema/agents-yaml.schema.json\n\n";
 /** Root of the system data directory (~/.agents/.system/). */
@@ -140,6 +140,8 @@ export declare function getPackagesDir(): string;
 export declare function getRoutinesDir(): string;
 /** Path to named project definitions (~/.agents/projects/). */
 export declare function getProjectsDir(): string;
+/** Path to daemon config directory (~/.agents/daemon/). Holds service toggles. */
+export declare function getDaemonConfigDir(): string;
 /**
  * Path to webhook handler YAML definitions (~/.agents/webhooks/). Handlers are
  * one-off triggers for agents/workflows/commands/routines, layered the same way
@@ -164,12 +166,12 @@ export declare function getSystemWebhooksDir(): string;
  * or null when no project `.agents/` is found by walking up from cwd.
  *
  * Project routines participate in `list`/`view` for inspection always. Daemon
- * firing requires an explicit opt-in via `agents routines enable-project`
- * (writes `meta.routines.projects`); after opt-in, `agents routines sync`
- * materialises them into the user layer with `source:` provenance so the
- * daemon (which loads user + system only) can fire them safely. A project's
- * own `agents.yaml` `routines.enable: true` is a documentation signal only —
- * it does not auto-enable firing. See `lib/routines-project.ts`.
+ * firing requires `agents routines enable <name>`, which materialises the
+ * routine into the user layer with `source:` provenance (so the daemon, which
+ * loads user + system only, can see it) and turns on the device flag in one
+ * step. Enablement lives solely in `meta.deviceRoutines`; a project YAML's own
+ * `enabled:` field never turns firing on, so a cloned repo cannot auto-run.
+ * See `lib/routines-project.ts`.
  */
 export declare function getProjectRoutinesDir(cwd?: string): string | null;
 /**
@@ -182,6 +184,16 @@ export declare function getProjectWebhooksDir(cwd?: string): string | null;
 export declare function getRunsDir(): string;
 /** Path to monitor YAML definitions (~/.agents/monitors/). */
 export declare function getMonitorsDir(): string;
+/**
+ * Path to built-in monitor definitions shipped in the system repo
+ * (`~/.agents/.system/monitors/`). Unioned under the user monitors dir by
+ * listMonitors()/readMonitor(): a monitor shipped here is available on every
+ * install, and a user monitor of the same name overrides it. A built-in with no
+ * `enabled:` field is opt-in — it stays disabled until the user enables it,
+ * which materializes a user copy (writes never touch this pull-only mirror). The
+ * directory need not exist.
+ */
+export declare function getSystemMonitorsDir(): string;
 /** Path to the durable per-monitor state-diff store + fire history
  * (~/.agents/.history/monitors/). */
 export declare function getMonitorsHistoryDir(): string;
@@ -238,7 +250,7 @@ export declare function getTeamsRegistryPath(): string;
 export declare function getDevicesRegistryPath(): string;
 /** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
 export declare function getDevicesIgnoredPath(): string;
-/** Path to the device auto-launch preference file — which registered devices are eligible/preferred for Factory's auto-host selection. Per-machine, same dir as the registry. */
+/** Path to the LEGACY device auto-launch preference file — which registered devices are eligible/preferred for the ext's auto-host selection. Superseded by the central `fleet.devices.<name>.config` block; only lib/devices/config-migration.ts still reads it (to fold + remove it). */
 export declare function getDevicesAutoLaunchPath(): string;
 /** Dir of "pending device" sentinels (~/.agents/.cache/state/devices-pending/) — one empty-ish file per newly-discovered, not-yet-approved tailnet node. Written by the daemon probe, read by the menu-bar helper (mirrors the attention sentinel dir). */
 export declare function getDevicesPendingDir(): string;
@@ -266,7 +278,22 @@ export declare function getPerfDir(): string;
 export declare function getPerfDbPath(): string;
 /** Path to the hook-shim NDJSON spool drained into perf.db on open. */
 export declare function getPerfSpoolPath(): string;
-/** Path to per-process runtime state (~/.agents/.cache/state/). */
+/**
+ * Path to per-process runtime state (~/.agents/.cache/state/).
+ *
+ * `AGENTS_STATE_DIR` redirects it in tests — the same test-isolation escape
+ * hatch as `AGENTS_DEVICES_DIR` / `AGENTS_LOGS_DIR`, and resolved at call time
+ * for the same reason (a suite pins it after this module is imported).
+ *
+ * Without it the suite writes into the operator's LIVE state. Concretely: the
+ * device registry and ignore-list already redirect via `AGENTS_DEVICES_DIR`, so
+ * under test both read empty — and any code path reaching
+ * `reconcilePendingSentinels` then computed "every tailnet node is new" and
+ * wrote those sentinels into the real `devices-pending/`, which is exactly what
+ * the menu bar renders. Running the suite on a dev machine surfaced all 20
+ * tailnet nodes as NEW DEVICES, including registered and explicitly ignored
+ * ones, and looked like the operator's ignore list had been lost.
+ */
 export declare function getRuntimeStateDir(): string;
 /** Path to companion-extension scratch (~/.agents/.cache/companion/). */
 export declare function getCompanionDir(): string;

package/dist/lib/state.js

@@ -26,6 +26,7 @@ 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 { execFileSync } from 'child_process';
 import { ensureLockTarget, atomicWriteFileSync, withFileLock } from './fs-atomic.js';
 import { DEFAULT_SYSTEM_REPO, systemRepoSlug } from './types.js';
@@ -78,6 +79,11 @@ const SYSTEM_PLUGINS_DIR = path.join(SYSTEM_AGENTS_DIR, 'plugins');
 // Unioned under user routines by listJobs()/readJob() so a routine shipped here
 // fires for every install, while a user routine of the same name overrides it.
 const SYSTEM_ROUTINES_DIR = path.join(SYSTEM_AGENTS_DIR, 'routines');
+// Built-in monitors shipped in the system repo (gh:phnx-labs/.agents-system).
+// Unioned under user monitors by listMonitors()/readMonitor() so a monitor
+// shipped here is available on every install, while a user monitor of the same
+// name overrides it (a built-in with no `enabled:` field stays opt-in).
+const SYSTEM_MONITORS_DIR = path.join(SYSTEM_AGENTS_DIR, 'monitors');
 const SYSTEM_WEBHOOKS_DIR = path.join(SYSTEM_AGENTS_DIR, 'webhooks');
 const SYSTEM_PROMPTCUTS_FILE = path.join(SYSTEM_AGENTS_DIR, 'hooks', 'promptcuts.yaml');
 const SYSTEM_MCP_CONFIG_FILE = path.join(SYSTEM_AGENTS_DIR, 'mcp.json');
@@ -97,6 +103,9 @@ const TEAMS_DIR = path.join(USER_AGENTS_DIR, 'teams');
 // Named project definitions (the layer above the --project convention). Sibling
 // of ROUTINES_DIR/TEAMS_DIR: hand-editable YAML, synced across machines by push/pull.
 const PROJECTS_DIR = path.join(USER_AGENTS_DIR, 'projects');
+// Daemon service toggles and persistent daemon config. Top-level config/definitions
+// dir like routines/webhooks; runtime state (pid/heartbeat/logs) stays in .cache.
+const DAEMON_CONFIG_DIR = path.join(USER_AGENTS_DIR, 'daemon');
 // History bucket (durable).
 const SESSIONS_DIR = path.join(HISTORY_DIR, 'sessions');
 const SESSIONS_DB_PATH = path.join(SESSIONS_DIR, 'sessions.db');
@@ -154,7 +163,7 @@ const USER_PROMPTCUTS_FILE = path.join(USER_AGENTS_DIR, 'hooks', 'promptcuts.yam
  * Header prepended to every agents.yaml the CLI writes (central and per-device
  * docs). Carries the yaml-language-server schema hint so editors validate the
  * file against `schema/agents-yaml.schema.json`. Exported so
- * `lib/device-config.ts` writes a sibling device's doc with the same header.
+ * `lib/devices/config-migration.ts` rewrites a device doc with the same header.
  */
 export const META_HEADER = `# agents-cli metadata
 # Auto-generated - do not edit manually
@@ -411,6 +420,8 @@ export function getPackagesDir() { return PACKAGES_DIR; }
 export function getRoutinesDir() { return process.env.AGENTS_ROUTINES_DIR ?? ROUTINES_DIR; }
 /** Path to named project definitions (~/.agents/projects/). */
 export function getProjectsDir() { return process.env.AGENTS_PROJECTS_DIR ?? PROJECTS_DIR; }
+/** Path to daemon config directory (~/.agents/daemon/). Holds service toggles. */
+export function getDaemonConfigDir() { return process.env.AGENTS_DAEMON_CONFIG_DIR ?? DAEMON_CONFIG_DIR; }
 /**
  * Path to webhook handler YAML definitions (~/.agents/webhooks/). Handlers are
  * one-off triggers for agents/workflows/commands/routines, layered the same way
@@ -435,12 +446,12 @@ export function getSystemWebhooksDir() { return process.env.AGENTS_SYSTEM_WEBHOO
  * or null when no project `.agents/` is found by walking up from cwd.
  *
  * Project routines participate in `list`/`view` for inspection always. Daemon
- * firing requires an explicit opt-in via `agents routines enable-project`
- * (writes `meta.routines.projects`); after opt-in, `agents routines sync`
- * materialises them into the user layer with `source:` provenance so the
- * daemon (which loads user + system only) can fire them safely. A project's
- * own `agents.yaml` `routines.enable: true` is a documentation signal only —
- * it does not auto-enable firing. See `lib/routines-project.ts`.
+ * firing requires `agents routines enable <name>`, which materialises the
+ * routine into the user layer with `source:` provenance (so the daemon, which
+ * loads user + system only, can see it) and turns on the device flag in one
+ * step. Enablement lives solely in `meta.deviceRoutines`; a project YAML's own
+ * `enabled:` field never turns firing on, so a cloned repo cannot auto-run.
+ * See `lib/routines-project.ts`.
  */
 export function getProjectRoutinesDir(cwd = process.cwd()) {
     const projectAgentsDir = getProjectAgentsDir(cwd);
@@ -462,7 +473,17 @@ export function getProjectWebhooksDir(cwd = process.cwd()) {
 /** Path to routine execution logs (~/.agents/.history/runs/). */
 export function getRunsDir() { return RUNS_DIR; }
 /** Path to monitor YAML definitions (~/.agents/monitors/). */
-export function getMonitorsDir() { return MONITORS_DIR; }
+export function getMonitorsDir() { return process.env.AGENTS_MONITORS_DIR ?? MONITORS_DIR; }
+/**
+ * Path to built-in monitor definitions shipped in the system repo
+ * (`~/.agents/.system/monitors/`). Unioned under the user monitors dir by
+ * listMonitors()/readMonitor(): a monitor shipped here is available on every
+ * install, and a user monitor of the same name overrides it. A built-in with no
+ * `enabled:` field is opt-in — it stays disabled until the user enables it,
+ * which materializes a user copy (writes never touch this pull-only mirror). The
+ * directory need not exist.
+ */
+export function getSystemMonitorsDir() { return process.env.AGENTS_SYSTEM_MONITORS_DIR ?? SYSTEM_MONITORS_DIR; }
 /** Path to the durable per-monitor state-diff store + fire history
  * (~/.agents/.history/monitors/). */
 export function getMonitorsHistoryDir() { return MONITORS_HISTORY_DIR; }
@@ -543,10 +564,10 @@ function getDevicesDir() {
 export function getDevicesRegistryPath() { return path.join(getDevicesDir(), 'registry.json'); }
 /** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
 export function getDevicesIgnoredPath() { return path.join(getDevicesDir(), 'ignored.json'); }
-/** Path to the device auto-launch preference file — which registered devices are eligible/preferred for Factory's auto-host selection. Per-machine, same dir as the registry. */
+/** Path to the LEGACY device auto-launch preference file — which registered devices are eligible/preferred for the ext's auto-host selection. Superseded by the central `fleet.devices.<name>.config` block; only lib/devices/config-migration.ts still reads it (to fold + remove it). */
 export function getDevicesAutoLaunchPath() { return path.join(getDevicesDir(), 'auto-launch.json'); }
 /** Dir of "pending device" sentinels (~/.agents/.cache/state/devices-pending/) — one empty-ish file per newly-discovered, not-yet-approved tailnet node. Written by the daemon probe, read by the menu-bar helper (mirrors the attention sentinel dir). */
-export function getDevicesPendingDir() { return path.join(RUNTIME_STATE_DIR, 'devices-pending'); }
+export function getDevicesPendingDir() { return path.join(getRuntimeStateDir(), 'devices-pending'); }
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */
 export function getCloudDir() { return CLOUD_DIR; }
 /** Path to terminal session metadata (~/.agents/.cache/terminals/). */
@@ -575,8 +596,23 @@ export function getPerfDir() {
 export function getPerfDbPath() { return path.join(getPerfDir(), 'perf.db'); }
 /** Path to the hook-shim NDJSON spool drained into perf.db on open. */
 export function getPerfSpoolPath() { return path.join(getPerfDir(), 'spool.jsonl'); }
-/** Path to per-process runtime state (~/.agents/.cache/state/). */
-export function getRuntimeStateDir() { return RUNTIME_STATE_DIR; }
+/**
+ * Path to per-process runtime state (~/.agents/.cache/state/).
+ *
+ * `AGENTS_STATE_DIR` redirects it in tests — the same test-isolation escape
+ * hatch as `AGENTS_DEVICES_DIR` / `AGENTS_LOGS_DIR`, and resolved at call time
+ * for the same reason (a suite pins it after this module is imported).
+ *
+ * Without it the suite writes into the operator's LIVE state. Concretely: the
+ * device registry and ignore-list already redirect via `AGENTS_DEVICES_DIR`, so
+ * under test both read empty — and any code path reaching
+ * `reconcilePendingSentinels` then computed "every tailnet node is new" and
+ * wrote those sentinels into the real `devices-pending/`, which is exactly what
+ * the menu bar renders. Running the suite on a dev machine surfaced all 20
+ * tailnet nodes as NEW DEVICES, including registered and explicitly ignored
+ * ones, and looked like the operator's ignore list had been lost.
+ */
+export function getRuntimeStateDir() { return process.env.AGENTS_STATE_DIR ?? RUNTIME_STATE_DIR; }
 /** Path to companion-extension scratch (~/.agents/.cache/companion/). */
 export function getCompanionDir() { return COMPANION_CACHE_DIR; }
 /** Path to browser runtime data — chrome-data, pids (~/.agents/.cache/browser/). */
@@ -787,9 +823,10 @@ function writeIfChanged(filePath, content) {
 /**
  * Partition the in-memory Meta across three files by sync-domain:
  *   - central  `~/.agents/agents.yaml`             — portable, everything else
- *              (including the user-scope `config:` block)
+ *              (including the user-scope `config:` block and the per-device
+ *              operator config under `fleet.devices.<name>.config`)
  *   - device   `~/.agents/devices/<machine>/agents.yaml` — `agents:` pins +
- *              `defaultBrowserProfile:` + device-scope `config:` (all per-device)
+ *              `routines:` (all per-machine)
  *   - history  `~/.agents/.history/version-resources.json` — `versions:` (machine-local)
  * All callers funnel through writeMeta → here, so nothing else changes. Empty
  * `agents:` / `versions:` are not written (no empty committed files).
@@ -810,10 +847,11 @@ const META_KEY_SCOPE = {
     agents: 'device',
     isolatedAgents: 'device',
     versions: 'device',
-    defaultBrowserProfile: 'device',
-    deviceConfig: 'device',
     deviceRoutines: 'device',
+    deviceConfig: 'device',
+    deviceBrowser: 'device',
     // Central — synced via agents.yaml.
+    accounts: 'central',
     run: 'central',
     model: 'central',
     watchdog: 'central',
@@ -825,7 +863,7 @@ const META_KEY_SCOPE = {
     registries: 'central',
     profiles: 'central',
     source: 'central',
-    projectRoot: 'central',
+    projectRoot: 'device',
     extraRepos: 'central',
     brands: 'central',
     actors: 'central',
@@ -837,7 +875,6 @@ const META_KEY_SCOPE = {
     fleet: 'central',
     share: 'central',
     notify: 'central',
-    routines: 'central',
 };
 /**
  * Every key this version models (central + device). serializeCentral deletes an
@@ -903,14 +940,16 @@ function serializeCentral(central) {
     if (!changed)
         return existing;
     // Everything cleared → header only (never leave a flow `{}` behind).
-    // Otherwise force BLOCK style: an existing flow root (e.g. a legacy `{}`) would
-    // otherwise make the edited nodes render flow (`disabledCommands: [ teams ]`
-    // instead of a `- teams` block list). collectionStyle pins the whole doc block
-    // while parseDocument still preserves comments + key ordering.
-    return isEmpty ? META_HEADER : doc.toString({ collectionStyle: 'block' });
+    // Otherwise stringifyDoc: it still normalizes a legacy flow root (`{}`) to
+    // block, so edited nodes do not render flow (`disabledCommands: [ teams ]`
+    // instead of a `- teams` block list), but it no longer forces block on a
+    // normal document — that flattened committed flow sequences and made this
+    // writer disagree with feed.ts/activity.ts/migrate.ts on the same file
+    // (RUSH-2505). parseDocument still preserves comments + key ordering.
+    return isEmpty ? META_HEADER : stringifyDoc(doc);
 }
 function writeMetaUnlocked(meta) {
-    const { agents, isolatedAgents, versions, defaultBrowserProfile, deviceConfig, deviceRoutines, ...central } = meta;
+    const { agents, isolatedAgents, versions, deviceRoutines, deviceConfig, deviceBrowser, projectRoot, ...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();
@@ -920,26 +959,32 @@ function writeMetaUnlocked(meta) {
     // central doc that syncs — otherwise another machine inherits a pointer to a copy
     // it does not have.
     const hasIsolatedAgents = !!isolatedAgents && Object.keys(isolatedAgents).length > 0;
-    const hasDefaultBrowser = !!defaultBrowserProfile;
-    // 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;
     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).
+    // Machine-visibility operator config. Lives here rather than in the synced
+    // central file because nothing off-box reads it — and because
+    // browser.remote-control is a consent flag that must not propagate on pull.
+    const hasDeviceConfig = !!deviceConfig && Object.keys(deviceConfig).length > 0;
+    const hasDeviceBrowser = !!deviceBrowser && Object.keys(deviceBrowser).length > 0;
+    // An inferred local filesystem path — machine state, never fleet policy.
+    const hasProjectRoot = typeof projectRoot === 'string' && projectRoot.length > 0;
+    if (hasAgents || hasIsolatedAgents || hasDeviceRoutines || hasDeviceConfig || hasDeviceBrowser || hasProjectRoot) {
+        // Device-local doc carries `agents:` pins and `routines:` — per-machine and
+        // must never land in central agents.yaml (which syncs). Operator config
+        // used to ride this doc under `config:`; it now lives centrally under
+        // `fleet.devices.<name>.config` (see lib/device-config.ts).
         const deviceDoc = {};
         if (hasAgents)
             deviceDoc.agents = agents;
         if (hasIsolatedAgents)
             deviceDoc.isolatedAgents = isolatedAgents;
-        if (hasDefaultBrowser)
-            deviceDoc.defaultBrowserProfile = defaultBrowserProfile;
-        if (hasDeviceConfig)
-            deviceDoc.config = deviceConfig;
         if (hasDeviceRoutines)
             deviceDoc.routines = deviceRoutines;
+        if (hasDeviceConfig)
+            deviceDoc.config = deviceConfig;
+        if (hasDeviceBrowser)
+            deviceDoc.browser = deviceBrowser;
+        if (hasProjectRoot)
+            deviceDoc.projectRoot = projectRoot;
         fs.mkdirSync(path.dirname(devicePath), { recursive: true });
         writeIfChanged(devicePath, META_HEADER + yaml.stringify(deviceDoc));
     }
@@ -963,14 +1008,15 @@ function writeMetaUnlocked(meta) {
  *   - `agents:` and `isolatedAgents:` from the device file (device wins; the union
  *     both preserves the one-level merge and self-heals a pre-migration central that
  *     still has pins)
- *   - `defaultBrowserProfile:` from the device file (device is the sole source;
- *     the field is stripped from central on write, so nothing to merge against)
- *   - `config:` from the device file into `deviceConfig` (device is the sole
- *     source for device-scope config, same routing as `defaultBrowserProfile`;
- *     the in-memory field is named `deviceConfig` so it can never collide with
- *     the user-scope `config:` central carries)
+ *   - `routines:` from the device file into `deviceRoutines` (device-local
+ *     routine activation)
  *   - `versions:` from the history JSON (wholesale replace; falls back to
  *     whatever central carried when the history file doesn't exist yet)
+ *
+ * (Device operator config is NOT overlaid here: it lives centrally under
+ * `fleet.devices.<name>.config` — see lib/device-config.ts. The legacy
+ * `config:`/`defaultBrowserProfile:` keys in a device doc are folded into the
+ * central block by lib/devices/config-migration.ts.)
  */
 function overlayMachineLocal(meta) {
     const devicePath = getDeviceMetaPath();
@@ -985,10 +1031,14 @@ function overlayMachineLocal(meta) {
                 meta.agents = { ...meta.agents, ...dm.agents };
             if (dm?.isolatedAgents)
                 meta.isolatedAgents = { ...meta.isolatedAgents, ...dm.isolatedAgents };
-            if (dm?.defaultBrowserProfile)
-                meta.defaultBrowserProfile = dm.defaultBrowserProfile;
-            if (dm?.config)
-                meta.deviceConfig = dm.config;
+            if (typeof dm?.projectRoot === 'string')
+                meta.projectRoot = dm.projectRoot;
+            if (dm?.browser && typeof dm.browser === 'object' && !Array.isArray(dm.browser)) {
+                meta.deviceBrowser = { ...meta.deviceBrowser, ...dm.browser };
+            }
+            if (dm?.config && typeof dm.config === 'object' && !Array.isArray(dm.config)) {
+                meta.deviceConfig = { ...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.`);