@phnx-labs/agents-cli 1.20.72 → 1.20.73

package/dist/commands/logs.js

@@ -62,7 +62,7 @@ async function showSession(session, follow, full, json = false) {
             console.error(chalk.red(`Tailing is supported for claude and codex sessions only (got ${session.agent}).`));
             process.exit(2);
         }
-        await streamSessionTail(session, {});
+        await streamSessionTail(session, { raw: full });
         return;
     }
     await renderSessionLog(session, full ? 'markdown' : 'summary');

package/dist/commands/mine.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `agents mine` — white-label the CLI under your own name.
+ *
+ * `agents mine init <name>` mints a personally-named binary (e.g. `jack`) that
+ * IS agents-cli: a pure pass-through shim on PATH that runs every `agents` verb
+ * under the brand's name, with the brand's disabled commands and curated
+ * resource profile applied. `list` / `toggle` / `remove` manage brands.
+ *
+ * The discoverable entry point is the `agents setup mine` wizard
+ * (see setup-mine.ts), which delegates to `initBrand` here.
+ *
+ * Storage: brand config in `meta.brands` (agents.yaml); the curated resource set
+ * reuses the resource-profile engine — each brand owns a preset named
+ * `mine-<name>` in `meta.profiles.presets`. See lib/brand.ts.
+ */
+import type { Command } from 'commander';
+/**
+ * Create (or re-mint) a brand. Shared by `mine init` and the `setup mine`
+ * wizard. Writes the shim, the brand config, and an empty resource preset.
+ */
+export declare function initBrand(name: string, opts?: {
+    disabledCommands?: string[];
+    force?: boolean;
+}): {
+    pathWarning: boolean;
+};
+export declare function registerMineCommand(program: Command): void;

package/dist/commands/mine.js

@@ -0,0 +1,207 @@
+import chalk from 'chalk';
+import { validateBrandName, listBrands, getBrandConfig, upsertBrand, removeBrand, brandPresetName, } from '../lib/brand.js';
+import { createBrandShim, removeBrandShim, isShimsInPath } from '../lib/shims.js';
+import { updateMeta } from '../lib/state.js';
+import { COMMAND_LOADERS } from '../lib/startup/command-registry.js';
+/** Built-in top-level command names, for validating `--disable <cmd>`. */
+function knownCommandNames() {
+    const names = new Set(Object.keys(COMMAND_LOADERS));
+    // Inline aliases registered outside COMMAND_LOADERS (see src/index.ts).
+    for (const n of ['perms', 'exec', 'jobs', 'cron', 'upgrade'])
+        names.add(n);
+    return names;
+}
+/**
+ * Add/remove a `!name` exclusion on a preset's pattern list for one kind,
+ * keeping `*` so everything not explicitly disabled stays enabled. Deletes the
+ * key entirely once nothing but `*` remains, so a clean brand has an empty preset.
+ */
+function applyResourceToggle(preset, kind, name, enable) {
+    // Cast to a plain string-bag: writing through the union-keyed `preset[kind]`
+    // collapses to `never` under strict TS, so index the bag instead.
+    const bag = preset;
+    const arr = [...(bag[kind] ?? [])];
+    if (arr.length === 0)
+        arr.push('*');
+    const excl = `!${name}`;
+    const idx = arr.indexOf(excl);
+    if (enable) {
+        if (idx !== -1)
+            arr.splice(idx, 1);
+    }
+    else if (idx === -1) {
+        arr.push(excl);
+    }
+    const onlyStar = arr.length === 1 && arr[0] === '*';
+    if (onlyStar)
+        delete bag[kind];
+    else
+        bag[kind] = arr;
+}
+/** Ensure the brand's preset exists in meta.profiles.presets and return a mutable copy path. */
+function ensurePresetExists(name) {
+    const presetName = brandPresetName(name);
+    updateMeta((meta) => {
+        const profiles = meta.profiles ?? {};
+        const presets = { ...(profiles.presets ?? {}) };
+        if (!presets[presetName]) {
+            presets[presetName] = { description: `Resource set for the "${name}" brand` };
+        }
+        return { ...meta, profiles: { ...profiles, presets } };
+    });
+}
+/** Mutate the brand's resource preset under lock. */
+function editPreset(name, fn) {
+    const presetName = brandPresetName(name);
+    updateMeta((meta) => {
+        const profiles = meta.profiles ?? {};
+        const presets = { ...(profiles.presets ?? {}) };
+        const preset = { ...(presets[presetName] ?? {}) };
+        fn(preset);
+        presets[presetName] = preset;
+        return { ...meta, profiles: { ...profiles, presets } };
+    });
+}
+/**
+ * Create (or re-mint) a brand. Shared by `mine init` and the `setup mine`
+ * wizard. Writes the shim, the brand config, and an empty resource preset.
+ */
+export function initBrand(name, opts = {}) {
+    const err = validateBrandName(name);
+    if (err) {
+        console.error(chalk.red(err));
+        process.exit(1);
+    }
+    if (getBrandConfig(name) && !opts.force) {
+        console.error(chalk.red(`Brand "${name}" already exists. Use --force to re-mint, or 'agents mine toggle ${name}'.`));
+        process.exit(1);
+    }
+    ensurePresetExists(name);
+    const disabled = (opts.disabledCommands ?? []).filter((c) => c.length > 0);
+    const known = knownCommandNames();
+    for (const c of disabled) {
+        if (!known.has(c))
+            console.error(chalk.yellow(`  note: "${c}" is not a known command — kept anyway.`));
+    }
+    const cfg = {
+        name,
+        enabled: true,
+        profile: brandPresetName(name),
+        ...(disabled.length > 0 ? { disabledCommands: disabled } : {}),
+    };
+    upsertBrand(cfg);
+    createBrandShim(name);
+    const pathWarning = !isShimsInPath();
+    return { pathWarning };
+}
+function printMinted(name, pathWarning) {
+    console.log(`${chalk.green('Minted')} ${chalk.bold(name)} — your own agents CLI.`);
+    console.log(chalk.dim(`  try:  ${name} --help    ${name} run claude "hello"`));
+    if (pathWarning) {
+        console.log(chalk.yellow(`  note: the shims dir isn't on your PATH yet — run 'agents setup' or open a new shell.`));
+    }
+}
+export function registerMineCommand(program) {
+    const cmd = program
+        .command('mine')
+        .description('White-label the CLI: your own personally-named binary (e.g. `jack`)');
+    cmd
+        .command('init <name>')
+        .description('Mint your own branded CLI that runs every agents verb under <name>')
+        .option('--disable <commands...>', 'Built-in commands to hide from this brand (e.g. teams cloud)')
+        .option('--force', 'Re-mint even if the brand already exists')
+        .action((name, options) => {
+        const { pathWarning } = initBrand(name, {
+            disabledCommands: options.disable,
+            force: options.force,
+        });
+        printMinted(name, pathWarning);
+    });
+    cmd
+        .command('list')
+        .alias('ls')
+        .description('Show your brands and what each has turned off')
+        .action(() => {
+        const brands = listBrands();
+        const entries = Object.entries(brands);
+        if (entries.length === 0) {
+            console.log(chalk.gray("No brands yet. Try: agents setup mine   (or: agents mine init jack)"));
+            return;
+        }
+        const width = entries.reduce((m, [n]) => Math.max(m, n.length), 0);
+        for (const [name, cfg] of entries) {
+            const off = cfg.disabledCommands?.length ? `disabled: ${cfg.disabledCommands.join(', ')}` : 'all commands on';
+            const state = cfg.enabled === false ? chalk.yellow('(disabled) ') : '';
+            console.log(`  ${chalk.bold(name.padEnd(width))}  ${state}${chalk.dim(off)}`);
+        }
+    });
+    cmd
+        .command('toggle <name>')
+        .description('Enable/disable features for a brand')
+        .option('--disable <commands...>', 'Hide these built-in commands')
+        .option('--enable <commands...>', 'Un-hide these built-in commands')
+        .option('--disable-plugin <names...>', 'Disable these plugins for the brand')
+        .option('--enable-plugin <names...>', 'Re-enable these plugins')
+        .option('--disable-skill <names...>', 'Disable these skills for the brand')
+        .option('--enable-skill <names...>', 'Re-enable these skills')
+        .action((name, options) => {
+        const cfg = getBrandConfig(name);
+        if (!cfg) {
+            console.error(chalk.red(`No brand named "${name}". Create it with 'agents mine init ${name}'.`));
+            process.exit(1);
+        }
+        // Built-in command toggles → brand.disabledCommands.
+        const disabledSet = new Set(cfg.disabledCommands ?? []);
+        const known = knownCommandNames();
+        for (const c of options.disable ?? []) {
+            if (!known.has(c))
+                console.error(chalk.yellow(`  note: "${c}" is not a known command — kept anyway.`));
+            disabledSet.add(c);
+        }
+        for (const c of options.enable ?? [])
+            disabledSet.delete(c);
+        const nextDisabled = [...disabledSet];
+        const nextCfg = { ...cfg };
+        if (nextDisabled.length > 0)
+            nextCfg.disabledCommands = nextDisabled;
+        else
+            delete nextCfg.disabledCommands;
+        upsertBrand(nextCfg);
+        // Resource toggles → the brand's profile preset.
+        const resourceOps = [];
+        for (const p of options.disablePlugin ?? [])
+            resourceOps.push(['plugins', p, false]);
+        for (const p of options.enablePlugin ?? [])
+            resourceOps.push(['plugins', p, true]);
+        for (const s of options.disableSkill ?? [])
+            resourceOps.push(['skills', s, false]);
+        for (const s of options.enableSkill ?? [])
+            resourceOps.push(['skills', s, true]);
+        if (resourceOps.length > 0) {
+            ensurePresetExists(name);
+            editPreset(name, (preset) => {
+                for (const [kind, n, enable] of resourceOps)
+                    applyResourceToggle(preset, kind, n, enable);
+            });
+        }
+        console.log(`${chalk.green('Updated')} ${chalk.bold(name)}.`);
+        const finalCfg = getBrandConfig(name);
+        const off = finalCfg.disabledCommands?.length ? finalCfg.disabledCommands.join(', ') : '(none)';
+        console.log(chalk.dim(`  disabled commands: ${off}`));
+    });
+    cmd
+        .command('remove <name>')
+        .alias('rm')
+        .description('Remove a brand (its shim + config)')
+        .option('--purge', "Also delete the brand's resource profile preset")
+        .action((name, options) => {
+        const existed = getBrandConfig(name) !== undefined;
+        const shimRemoved = removeBrandShim(name);
+        if (!existed && !shimRemoved) {
+            console.error(chalk.red(`No brand named "${name}".`));
+            process.exit(1);
+        }
+        removeBrand(name, options.purge === true);
+        console.log(`${chalk.yellow('Removed')} brand ${chalk.bold(name)}`);
+    });
+}

package/dist/commands/monitors.js

@@ -23,6 +23,12 @@ import { machineId, normalizeHost } from '../lib/machine-id.js';
 import { loadDevices } from '../lib/devices/registry.js';
 import { setHelpSections } from '../lib/help.js';
 import { isInteractiveTerminal, requireInteractiveSelection } from './utils.js';
+function stdoutJson(payload) {
+    process.stdout.write(JSON.stringify(payload) + '\n');
+}
+function stderrLine(message) {
+    process.stderr.write(message + '\n');
+}
 /** A one-line human label for what a monitor watches. */
 function sourceLabel(source) {
     switch (source.type) {
@@ -70,7 +76,7 @@ function ownerLabel(monitor) {
 function ensureDaemonRunning() {
     if (isDaemonRunning()) {
         signalDaemonReload();
-        console.log(chalk.gray('Daemon reloaded'));
+        stderrLine(chalk.gray('Daemon reloaded'));
         return;
     }
     const result = startDaemon();
@@ -79,22 +85,22 @@ function ensureDaemonRunning() {
         console.log(chalk.gray('Stop anytime with: agents routines stop'));
     }
     else {
-        console.log(chalk.yellow('Could not start the daemon. Start it manually with: agents routines start'));
+        stderrLine(chalk.yellow('Could not start the daemon. Start it manually with: agents routines start'));
     }
 }
 /** Validate a single device name against the registered fleet; exit on miss. */
 async function validateDevice(name) {
     const normalized = normalizeHost(name.trim());
     if (!normalized) {
-        console.log(chalk.red('device name must be non-empty'));
+        stderrLine(chalk.red('device name must be non-empty'));
         process.exit(1);
     }
     const registry = await loadDevices();
     const registered = new Set(Object.keys(registry).map((k) => normalizeHost(k)));
     if (!registered.has(normalized)) {
-        console.log(chalk.red(`Unknown device: ${normalized}`));
-        console.log(chalk.gray(`Registered: ${[...registered].sort().join(', ') || '(none)'}`));
-        console.log(chalk.gray('Enroll devices with: agents devices sync'));
+        stderrLine(chalk.red(`Unknown device: ${normalized}`));
+        stderrLine(chalk.gray(`Registered: ${[...registered].sort().join(', ') || '(none)'}`));
+        stderrLine(chalk.gray('Enroll devices with: agents devices sync'));
         process.exit(1);
     }
     return normalized;
@@ -126,7 +132,7 @@ function buildSource(options) {
         const raw = String(options.on);
         const [src, event] = raw.includes(':') ? raw.split(':', 2) : ['github', raw];
         if (src !== 'github' && src !== 'linear') {
-            console.log(chalk.red('--on source must be github or linear'));
+            stderrLine(chalk.red('--on source must be github or linear'));
             process.exit(1);
         }
         const webhook = { source: src, event };
@@ -143,11 +149,11 @@ function buildSource(options) {
         chosen.push({ type: 'webhook', source: { type: 'webhook', webhook } });
     }
     if (chosen.length === 0) {
-        console.log(chalk.red('A source is required: --watch, --poll, --poll-http, --ws, --watch-file, --watch-device, or --on'));
+        stderrLine(chalk.red('A source is required: --watch, --poll, --poll-http, --ws, --watch-file, --watch-device, or --on'));
         process.exit(1);
     }
     if (chosen.length > 1) {
-        console.log(chalk.red(`Exactly one source is allowed; got ${chosen.map((c) => c.type).join(', ')}`));
+        stderrLine(chalk.red(`Exactly one source is allowed; got ${chosen.map((c) => c.type).join(', ')}`));
         process.exit(1);
     }
     return chosen[0].source;
@@ -162,7 +168,7 @@ function buildCondition(options) {
     if (options.every)
         modes.push('every');
     if (modes.length > 1) {
-        console.log(chalk.red('--on-change, --match, and --every are mutually exclusive'));
+        stderrLine(chalk.red('--on-change, --match, and --every are mutually exclusive'));
         process.exit(1);
     }
     const mode = modes[0] ?? (options.match ? 'match' : 'on-change');
@@ -196,11 +202,11 @@ function buildAction(options) {
     if (options.webhookOut)
         chosen.push({ type: 'webhook-out', url: options.webhookOut });
     if (chosen.length === 0) {
-        console.log(chalk.red('An action is required: --run <agent> --prompt, --routine, --notify, or --webhook-out'));
+        stderrLine(chalk.red('An action is required: --run <agent> --prompt, --routine, --notify, or --webhook-out'));
         process.exit(1);
     }
     if (chosen.length > 1) {
-        console.log(chalk.red(`Exactly one action is allowed; got ${chosen.map((c) => c.type).join(', ')}`));
+        stderrLine(chalk.red(`Exactly one action is allowed; got ${chosen.map((c) => c.type).join(', ')}`));
         process.exit(1);
     }
     return chosen[0];
@@ -209,7 +215,7 @@ function buildAction(options) {
 async function pickMonitor(message, alternatives = []) {
     const monitors = listMonitors();
     if (monitors.length === 0) {
-        console.log(chalk.yellow('No monitors configured'));
+        stderrLine(chalk.yellow('No monitors configured'));
         return null;
     }
     if (!isInteractiveTerminal()) {
@@ -227,7 +233,7 @@ async function pickMonitor(message, alternatives = []) {
     }
     catch (err) {
         if (err instanceof Error && (err.name === 'ExitPromptError' || err.message.includes('User force closed'))) {
-            console.log(chalk.gray('Cancelled'));
+            stderrLine(chalk.gray('Cancelled'));
             return null;
         }
         throw err;
@@ -322,16 +328,16 @@ export function registerMonitorsCommands(program) {
                 parsed = yaml.parse(fs.readFileSync(resolved, 'utf-8'));
             }
             catch (err) {
-                console.log(chalk.red(`Invalid YAML: ${err.message}`));
+                stderrLine(chalk.red(`Invalid YAML: ${err.message}`));
                 process.exit(1);
             }
             const name = parsed?.name || path.basename(resolved).replace(/\.ya?ml$/, '');
             const config = { enabled: true, ...parsed, name };
             const errors = validateMonitor(config);
             if (errors.length > 0) {
-                console.log(chalk.red('Validation errors:'));
+                stderrLine(chalk.red('Validation errors:'));
                 for (const err of errors)
-                    console.log(chalk.red(`  - ${err}`));
+                    stderrLine(chalk.red(`  - ${err}`));
                 process.exit(1);
             }
             writeMonitor(config);
@@ -340,8 +346,8 @@ export function registerMonitorsCommands(program) {
             return;
         }
         if (!nameOrPath) {
-            console.log(chalk.red('Monitor name is required'));
-            console.log(chalk.gray('Usage: agents monitors add <name> --poll "<cmd>" 30s --match fail --run claude --prompt "..."'));
+            stderrLine(chalk.red('Monitor name is required'));
+            stderrLine(chalk.gray('Usage: agents monitors add <name> --poll "<cmd>" 30s --match fail --run claude --prompt "..."'));
             process.exit(1);
         }
         const source = buildSource(options);
@@ -357,7 +363,7 @@ export function registerMonitorsCommands(program) {
         let device;
         let devices;
         if (options.device && options.devices) {
-            console.log(chalk.red('--device (single owner) and --devices (allowlist) are mutually exclusive'));
+            stderrLine(chalk.red('--device (single owner) and --devices (allowlist) are mutually exclusive'));
             process.exit(1);
         }
         if (options.device)
@@ -371,13 +377,13 @@ export function registerMonitorsCommands(program) {
         // --run-on with no owner pin would fire from every daemon → duplicate actions.
         if (options.runOn && !device && !devices) {
             device = machineId();
-            console.log(chalk.gray(`--run-on set with no --device/--devices: pinned owner to this machine (${device}).`));
+            stderrLine(chalk.gray(`--run-on set with no --device/--devices: pinned owner to this machine (${device}).`));
         }
         let rateLimit;
         if (options.rateLimit) {
             const m = String(options.rateLimit).match(/^(\d+)\/(.+)$/);
             if (!m) {
-                console.log(chalk.red('--rate-limit must be N/<interval>, e.g. 5/1m'));
+                stderrLine(chalk.red('--rate-limit must be N/<interval>, e.g. 5/1m'));
                 process.exit(1);
             }
             rateLimit = { max: parseInt(m[1], 10), per: m[2] };
@@ -395,15 +401,15 @@ export function registerMonitorsCommands(program) {
         };
         const errors = validateMonitor(config);
         if (errors.length > 0) {
-            console.log(chalk.red('Validation errors:'));
+            stderrLine(chalk.red('Validation errors:'));
             for (const err of errors)
-                console.log(chalk.red(`  - ${err}`));
+                stderrLine(chalk.red(`  - ${err}`));
             process.exit(1);
         }
         // Coverage lint (Anthropic's "silence is not success"): warn when a --match
         // names only a success-shaped token with no failure branch.
         if (condition.mode === 'match' && condition.match && /^(issued|success|ok|pass(ed)?|done|ready)$/i.test(condition.match)) {
-            console.log(chalk.yellow(`  Note: --match '${condition.match}' only fires on success — it stays silent if the source breaks or never matches.`));
+            stderrLine(chalk.yellow(`  Note: --match '${condition.match}' only fires on success — it stays silent if the source breaks or never matches.`));
         }
         writeMonitor(config);
         console.log(chalk.green(`Monitor '${nameOrPath}' added`));
@@ -432,7 +438,7 @@ export function registerMonitorsCommands(program) {
                     lastFiredAt: state?.lastFiredAt ?? null,
                 };
             });
-            process.stdout.write(JSON.stringify(payload) + '\n');
+            stdoutJson(payload);
             return;
         }
         if (monitors.length === 0) {
@@ -456,7 +462,8 @@ export function registerMonitorsCommands(program) {
     monitorsCmd
         .command('view [name]')
         .description('Show a monitor’s full YAML config plus its current watched-state and recent fires.')
-        .action(async (name) => {
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async (name, options) => {
         if (!name) {
             name = (await pickMonitor('Select monitor to view', ['agents monitors view <name>'])) ?? undefined;
             if (!name)
@@ -464,12 +471,24 @@ export function registerMonitorsCommands(program) {
         }
         const monitor = readMonitor(name);
         if (!monitor) {
-            console.log(chalk.red(`Monitor '${name}' not found`));
+            stderrLine(chalk.red(`Monitor '${name}' not found`));
             process.exit(1);
         }
+        const state = readState(name);
+        const recentFires = listFires(name).slice(-5);
+        if (options.json) {
+            stdoutJson({
+                name,
+                monitor,
+                owner: ownerLabel(monitor),
+                runsHere: monitorRunsOnThisDevice(monitor),
+                state,
+                recentFires,
+            });
+            return;
+        }
         console.log(chalk.bold(`Monitor: ${name}\n`));
         console.log(yaml.stringify(monitor));
-        const state = readState(name);
         if (state) {
             console.log(chalk.bold('Watched state'));
             console.log(chalk.gray(`  last seen:  ${state.lastSeenAt}`));
@@ -477,10 +496,9 @@ export function registerMonitorsCommands(program) {
                 console.log(chalk.gray(`  last fired: ${state.lastFiredAt}`));
             console.log(chalk.gray(`  last value: ${state.lastValue.replace(/\s+/g, ' ').slice(0, 120)}`));
         }
-        const fires = listFires(name).slice(-5);
-        if (fires.length > 0) {
+        if (recentFires.length > 0) {
             console.log(chalk.bold('\nRecent fires'));
-            for (const f of fires) {
+            for (const f of recentFires) {
                 console.log(`  ${chalk.gray(f.firedAt)}  ${f.action ?? '?'}  ${f.ok === false ? chalk.red('failed') : chalk.green('ok')}`);
             }
         }
@@ -489,7 +507,8 @@ export function registerMonitorsCommands(program) {
     monitorsCmd
         .command('test [name]')
         .description('DRY-RUN: evaluate the source once and print the emitted event + whether it would fire. No action is taken.')
-        .action(async (name) => {
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async (name, options) => {
         if (!name) {
             name = (await pickMonitor('Select monitor to test', ['agents monitors test <name>'])) ?? undefined;
             if (!name)
@@ -497,12 +516,24 @@ export function registerMonitorsCommands(program) {
         }
         const monitor = readMonitor(name);
         if (!monitor) {
-            console.log(chalk.red(`Monitor '${name}' not found`));
+            stderrLine(chalk.red(`Monitor '${name}' not found`));
             process.exit(1);
         }
+        const { observation, decision } = await evaluateMonitorOnce(monitor);
+        const wouldFire = Boolean(decision?.fire);
+        if (options.json) {
+            stdoutJson({
+                name,
+                dryRun: true,
+                monitor,
+                observation,
+                decision,
+                wouldFire,
+            });
+            return;
+        }
         console.log(chalk.bold(`Dry-run: ${name}\n`));
         console.log(chalk.gray(`  ${sourceLabel(monitor.source)}  ·  [${monitor.condition.mode}]  ·  ${actionLabel(monitor.action)}\n`));
-        const { observation, decision } = await evaluateMonitorOnce(monitor);
         if (!observation) {
             console.log(chalk.yellow('No observation — this source is push-only (ws/webhook) or produced nothing this tick.'));
             return;
@@ -511,7 +542,6 @@ export function registerMonitorsCommands(program) {
         console.log(observation.raw.split('\n').slice(0, 20).map((l) => `  ${l}`).join('\n'));
         if (observation.meta)
             console.log(chalk.gray(`  meta: ${JSON.stringify(observation.meta)}`));
-        const wouldFire = Boolean(decision?.fire);
         console.log('');
         console.log(`Would fire: ${wouldFire ? chalk.green('yes') : chalk.gray('no')}`);
         if (decision?.event) {
@@ -560,15 +590,15 @@ export function registerMonitorsCommands(program) {
                 return;
             const errors = validateMonitor(monitor);
             if (errors.length > 0) {
-                console.log(chalk.yellow('\nWarning: monitor has validation errors:'));
+                stderrLine(chalk.yellow('\nWarning: monitor has validation errors:'));
                 for (const err of errors)
-                    console.log(chalk.yellow(`  - ${err}`));
+                    stderrLine(chalk.yellow(`  - ${err}`));
             }
             else {
                 console.log(chalk.green(`\nMonitor '${name}' saved`));
                 if (isDaemonRunning()) {
                     signalDaemonReload();
-                    console.log(chalk.gray('Daemon reloaded'));
+                    stderrLine(chalk.gray('Daemon reloaded'));
                 }
             }
         });
@@ -587,14 +617,14 @@ export function registerMonitorsCommands(program) {
         }
         const run = options.run ? listRuns(name).find((r) => r.runId === options.run) : getLatestRun(name);
         if (!run) {
-            console.log(chalk.yellow(`No action runs found for monitor '${name}'`));
-            console.log(chalk.gray('  (notify / webhook-out actions have no run log — see: agents monitors runs)'));
+            stderrLine(chalk.yellow(`No action runs found for monitor '${name}'`));
+            stderrLine(chalk.gray('  (notify / webhook-out actions have no run log — see: agents monitors runs)'));
             return;
         }
         const logPath = path.join(getRunDir(name, run.runId), 'stdout.log');
         if (options.full) {
             if (!fs.existsSync(logPath)) {
-                console.log(chalk.yellow(`Log not found: ${logPath}`));
+                stderrLine(chalk.yellow(`Log not found: ${logPath}`));
                 return;
             }
             console.log(chalk.gray(`Run: ${run.runId}\n`));
@@ -628,7 +658,7 @@ export function registerMonitorsCommands(program) {
         }
         const fires = listFires(name);
         if (fires.length === 0) {
-            console.log(chalk.yellow(`No fires recorded for monitor '${name}'`));
+            stderrLine(chalk.yellow(`No fires recorded for monitor '${name}'`));
             return;
         }
         console.log(chalk.bold(`Fire history: ${name}\n`));
@@ -656,7 +686,7 @@ export function registerMonitorsCommands(program) {
                 signalDaemonReload();
         }
         catch (err) {
-            console.log(chalk.red(err.message));
+            stderrLine(chalk.red(err.message));
             process.exit(1);
         }
     });
@@ -676,7 +706,7 @@ export function registerMonitorsCommands(program) {
                 signalDaemonReload();
         }
         catch (err) {
-            console.log(chalk.red(err.message));
+            stderrLine(chalk.red(err.message));
             process.exit(1);
         }
     });
@@ -688,7 +718,7 @@ export function registerMonitorsCommands(program) {
         .option('--clear', 'Remove the owner pin so the monitor runs on every device')
         .action(async (name, options) => {
         if (options.set !== undefined && options.clear) {
-            console.log(chalk.red('--set and --clear are mutually exclusive'));
+            stderrLine(chalk.red('--set and --clear are mutually exclusive'));
             process.exit(1);
         }
         if (!name) {
@@ -698,7 +728,7 @@ export function registerMonitorsCommands(program) {
         }
         const monitor = readMonitor(name);
         if (!monitor) {
-            console.log(chalk.red(`Monitor '${name}' not found`));
+            stderrLine(chalk.red(`Monitor '${name}' not found`));
             process.exit(1);
         }
         if (options.clear) {
@@ -737,11 +767,11 @@ export function registerMonitorsCommands(program) {
             console.log(chalk.green(`Monitor '${name}' removed`));
             if (isDaemonRunning()) {
                 signalDaemonReload();
-                console.log(chalk.gray('Daemon reloaded'));
+                stderrLine(chalk.gray('Daemon reloaded'));
             }
         }
         else {
-            console.log(chalk.red(`Monitor '${name}' not found`));
+            stderrLine(chalk.red(`Monitor '${name}' not found`));
             process.exit(1);
         }
     });

package/dist/commands/plugins.js

@@ -493,6 +493,7 @@ Examples:
     // agents plugins install <spec>
     pluginsCmd
         .command('install <spec>')
+        .alias('add')
         .description('Install a plugin from a git URL or local path (format: name@source or source)')
         .option('--allow-exec-surfaces', 'Allow installing plugins that ship executable surfaces')
         .addHelpText('after', `