@phnx-labs/agents-cli 1.22.46 → 1.22.49

package/dist/commands/config.d.ts

@@ -5,7 +5,6 @@
  *   - run defaults (model, mode, effort)
  *   - tier overrides (folded into the run namespace)
  *   - interactive host
- *   - usage primary host
  *   - browser profile
  *   - local projects root
  *   - per-device config keys

package/dist/commands/config.js

@@ -5,7 +5,6 @@
  *   - run defaults (model, mode, effort)
  *   - tier overrides (folded into the run namespace)
  *   - interactive host
- *   - usage primary host
  *   - browser profile
  *   - local projects root
  *   - per-device config keys
@@ -40,8 +39,6 @@ function parseValue(key, parsed, raw) {
             return raw.trim();
         case 'interactive':
             return raw.trim();
-        case 'usage':
-            return raw.trim();
         case 'auto':
             return raw.trim();
         case 'browser':
@@ -72,6 +69,7 @@ function parseValue(key, parsed, raw) {
                 case 'notes':
                     return raw.trim();
                 case 'browser.profile':
+                case 'browser.viewer':
                     return raw.trim();
             }
             // A device property with no arm above used to fall out of the switch and
@@ -108,10 +106,6 @@ function setConfig(parsed, value) {
             setConfigValue('interactive.host', value);
             return;
         }
-        case 'usage': {
-            setConfigValue('usage.primary-host', value);
-            return;
-        }
         case 'auto': {
             setConfigValue('auto.pool', value);
             return;
@@ -121,7 +115,7 @@ function setConfig(parsed, value) {
             // (same store `agents devices config` / getConfigValue use). Bare
             // browser.profile targets this machine; devices.<name>.browser.profile
             // targets a peer.
-            setConfigValue('browser.profile', value, parsed.device ? { device: parsed.device } : undefined);
+            setConfigValue(parsed.property === 'viewer' ? 'browser.viewer' : 'browser.profile', value, parsed.device ? { device: parsed.device } : undefined);
             return;
         }
         case 'project':
@@ -155,11 +149,6 @@ function unsetConfig(parsed) {
             unsetConfigValue('interactive.host');
             return had;
         }
-        case 'usage': {
-            const had = getConfigValue('usage.primary-host').value !== undefined;
-            unsetConfigValue('usage.primary-host');
-            return had;
-        }
         case 'auto': {
             const had = getConfigValue('auto.pool').value !== undefined;
             unsetConfigValue('auto.pool');
@@ -167,8 +156,12 @@ function unsetConfig(parsed) {
         }
         case 'browser': {
             const target = parsed.device ? { device: parsed.device } : undefined;
-            const had = getConfigValue('browser.profile', target).value !== undefined;
-            unsetConfigValue('browser.profile', target);
+            // Must follow parsed.property. Hardcoding 'browser.profile' here meant
+            // `config unset browser.viewer` deleted the user's browser.profile while
+            // printing success, and left browserViewer in place.
+            const name = parsed.property === 'viewer' ? 'browser.viewer' : 'browser.profile';
+            const had = getConfigValue(name, target).value !== undefined;
+            unsetConfigValue(name, target);
             return had;
         }
         case 'project': {
@@ -199,12 +192,10 @@ function getConfig(parsed) {
         }
         case 'interactive':
             return getConfigValue('interactive.host').value;
-        case 'usage':
-            return getConfigValue('usage.primary-host').value;
         case 'auto':
             return getConfigValue('auto.pool').value;
         case 'browser': {
-            return getConfigValue('browser.profile', parsed.device ? { device: parsed.device } : undefined).value;
+            return getConfigValue(parsed.property === 'viewer' ? 'browser.viewer' : 'browser.profile', parsed.device ? { device: parsed.device } : undefined).value;
         }
         case 'project':
             return getProjectRoot();
@@ -258,9 +249,6 @@ function* listCentralConfigEntries() {
     if (meta.config?.interactiveHost !== undefined) {
         yield { key: 'interactive.host', value: meta.config.interactiveHost, hint: 'config.interactiveHost' };
     }
-    if (meta.config?.usagePrimaryHost !== undefined) {
-        yield { key: 'usage.primary-host', value: meta.config.usagePrimaryHost, hint: 'config.usagePrimaryHost' };
-    }
     if (meta.config?.autoPool !== undefined) {
         yield { key: 'auto.pool', value: meta.config.autoPool, hint: 'config.autoPool' };
     }
@@ -274,6 +262,11 @@ function* listCentralConfigEntries() {
         const key = 'browser.profile';
         yield { key, value: browserProfile, hint: configKeyStorageHint(parseConfigKey(key)) };
     }
+    const browserViewer = getConfigValue('browser.viewer').value;
+    if (browserViewer !== undefined) {
+        const key = 'browser.viewer';
+        yield { key, value: browserViewer, hint: configKeyStorageHint(parseConfigKey(key)) };
+    }
 }
 /** Collect device-scope config entries. */
 function* listDeviceConfigEntries(device) {
@@ -314,7 +307,19 @@ function* listDeviceConfigEntries(device) {
                     continue;
                 key = `${prefix}browser.profile`;
                 break;
+            case 'browser.viewer':
+                // Same duplication rule as browser.profile above.
+                if (device === machineId())
+                    continue;
+                key = `${prefix}browser.viewer`;
+                break;
             default:
+                // A `default: continue` here silently drops any device property with no
+                // arm — which is how browser.viewer was invisible to `config list` after
+                // being added everywhere else. This is the fourth switch enumerating
+                // DeviceConfigProperty; unlike parseValue's it cannot use a `never`
+                // binding (it must keep skipping properties that are deliberately not
+                // listed), so the completeness test in config.test.ts is the guard.
                 continue;
         }
         yield { key, value: entry.value, hint: configKeyStorageHint(parseConfigKey(key)) };
@@ -331,14 +336,11 @@ export function registerConfigCommand(program) {
       agents config set run.claude@2.1.45.model claude-opus-4-8
       agents config set run.claude@*.mode auto
       agents config set interactive.host zion
-      agents config set usage.primary-host zion
       agents config set browser.profile work
       agents config set project.root ~/src/github.com/<you>
       agents config set devices.mac-mini.max-agents 4
       agents config get run.claude@*.model
-      agents config get usage.primary-host
       agents config unset run.claude@*.tier.best
-      agents config unset usage.primary-host
       agents config list
       agents config budget
       agents config budget set per_day 50

package/dist/commands/cost.d.ts

@@ -5,7 +5,7 @@
  * This is the read side of issue #323. Cost and duration are computed and
  * persisted at scan time (see src/lib/session/discover.ts + db.ts); this
  * command only queries and renders them — a pure SQLite/CLI win, no server,
- * no telemetry. Distinct from `agents usage`, which reports live rate-limit /
+ * no telemetry. Distinct from `agents view`, which reports live rate-limit /
  * quota status per agent and is left untouched.
  */
 import type { Command } from 'commander';

package/dist/commands/daemon.d.ts

@@ -15,4 +15,25 @@
  * duplicating it.
  */
 import type { Command } from 'commander';
+import { type DaemonServiceId } from '../lib/daemon-services.js';
+/** One row of the roster every registered daemon service — supervisor-managed or legacy — renders in `agents daemon services`. */
+export interface DaemonServiceRow {
+    id: DaemonServiceId;
+    title: string;
+    description: string;
+    enabled: boolean;
+    /**
+     * `ServiceSupervisor`'s real lifecycle state when `supervised` is true
+     * (`idle`/`running`/`parked`/`stopped`, written cross-process via
+     * `recordSubsystemState`). A legacy `setInterval`-driven service has no such
+     * record, so its state is inferred from `enabled` + whether the daemon
+     * process is up — labelled distinctly so a reader can't mistake it for a
+     * measured value.
+     */
+    state: string;
+    supervised: boolean;
+    lastRunMs: number | null;
+    lastError: string | null;
+    consecutiveFailures: number;
+}
 export declare function registerDaemonCommand(program: Command): void;

package/dist/commands/daemon.js

@@ -21,8 +21,8 @@ import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
 import { getDaemonStatus, isDaemonRunning, isDaemonWedged, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, } from '../lib/daemon/daemon.js';
 import { getConfigValue, setConfigValue, isDaemonEnabled } from '../lib/device-config.js';
-import { readSubsystemHealth, SUBSYSTEM_SECRETS_BROKER, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START, } from '../lib/daemon-health.js';
-import { DAEMON_SERVICE_IDS, listDaemonServiceStates, setDaemonServiceEnabled, getDaemonServicesConfigPath, } from '../lib/daemon-services.js';
+import { readSubsystemHealth, readAllSubsystemHealth, SUBSYSTEM_SECRETS_BROKER, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START, } from '../lib/daemon-health.js';
+import { DAEMON_SERVICE_IDS, listDaemonServiceStates, setDaemonServiceEnabled, getDaemonServicesConfigPath, queueDaemonServiceRestart, } from '../lib/daemon-services.js';
 import { listJobs, getLatestRun } from '../lib/scheduling/routines.js';
 import { JobScheduler } from '../lib/scheduler.js';
 import { followFile } from '../lib/log-follow.js';
@@ -474,19 +474,76 @@ async function runStatus(opts) {
         console.log(chalk.red('\nThe daemon is wedged (heartbeat stale). Restart: agents daemon restart'));
     }
 }
+/**
+ * Combine the persisted enable/disable toggles with whatever health the
+ * `ServiceSupervisor` (or a legacy subsystem) has reported. Pure — reads two
+ * on-disk files, makes no probes — so it's cheap to call from both the
+ * non-interactive renderer and the interactive picker's refresh tick.
+ */
+function buildServiceRows(daemonRunning) {
+    const states = listDaemonServiceStates();
+    const healthById = new Map(readAllSubsystemHealth().map((h) => [h.subsystem, h]));
+    return states.map((s) => {
+        const h = healthById.get(s.id);
+        const supervised = h?.state !== undefined;
+        // A persisted supervisor state (health.json) is only trustworthy while the
+        // daemon is actually up. If it is not running (crash / kill -9 / never
+        // started), every service is stopped no matter what the last-written record
+        // says — trusting a stale 'running'/'parked'/'idle' here would print a
+        // report that contradicts the live-probed socket rows below (RUSH-2368).
+        const state = daemonRunning
+            ? (h?.state ?? (s.enabled ? 'running (unsupervised)' : 'stopped'))
+            : 'stopped';
+        return {
+            id: s.id,
+            title: s.title,
+            description: s.description,
+            enabled: s.enabled,
+            state,
+            supervised,
+            lastRunMs: h?.lastOkAt ? Date.parse(h.lastOkAt) : null,
+            lastError: h?.lastError ?? null,
+            consecutiveFailures: h?.consecutiveFailures ?? 0,
+        };
+    });
+}
+function serviceStateLabel(state) {
+    if (state === 'running')
+        return chalk.green('running');
+    if (state === 'parked')
+        return chalk.red('parked');
+    if (state === 'stopped')
+        return chalk.gray('stopped');
+    if (state === 'idle')
+        return chalk.gray('idle');
+    return chalk.yellow(state); // 'running (unsupervised)' or any future label
+}
 async function runServices(opts) {
     const [secrets, browserIpc] = await Promise.all([probeSecretsBroker(), probeBrowserIPC()]);
+    const rows = buildServiceRows(isDaemonRunning());
     if (opts.json) {
         console.log(JSON.stringify({
+            // Existing fields — unchanged shape, agents/CI consume these directly.
             secretsBroker: { reachable: secrets.reachable, socketPath: secrets.socketPath, heldBundles: secrets.heldBundles, health: secrets.record },
             browserIpc: { bound: browserIpc.bound, socketPath: browserIpc.socketPath, sessionCount: browserIpc.sessionCount, health: browserIpc.record },
+            // Additive: every registered service, supervised or legacy.
+            services: rows,
         }, null, 2));
         return;
     }
-    console.log(chalk.bold('Hosted services\n'));
+    console.log(chalk.bold('Daemon services\n'));
+    for (const row of rows) {
+        const lastRun = row.lastRunMs ? new Date(row.lastRunMs).toLocaleString() : '-';
+        console.log(`  ${row.id.padEnd(16)} ${serviceStateLabel(row.state).padEnd(20)} `
+            + `enabled=${row.enabled ? 'yes' : 'no '}  fails=${row.consecutiveFailures}  last-run=${lastRun}`);
+        if (row.lastError)
+            console.log(chalk.gray(`    last-error: ${row.lastError}`));
+    }
+    console.log(chalk.bold('\nHosted sockets\n'));
     console.log(healthLine(`secrets broker  ${secrets.reachable ? `(${secrets.socketPath}, ${secrets.heldBundles} bundle(s) held)` : '(unreachable)'}`, secrets.reachable, secrets.record));
     console.log(healthLine(`browser IPC     ${browserIpc.bound ? `(${browserIpc.socketPath}, ${browserIpc.sessionCount} session(s))` : '(unbound)'}`, browserIpc.bound, browserIpc.record));
     console.log(chalk.gray('\nScheduled routines run through `agents routines` — see: agents routines stats'));
+    console.log(chalk.gray('agents daemon services enable|disable|restart <id> apply live for supervised services.'));
 }
 function parseLogLines(raw) {
     const out = [];
@@ -795,9 +852,17 @@ export function registerDaemonCommand(program) {
       # Reload config (SIGHUP) without restarting — picks up routine/scheduler-gate changes
       agents daemon reload
 
-      # Every hosted service (secrets broker, browser IPC, webhook receiver, ...)
+      # Every registered service — state, enabled, failures, last error
       agents daemon services
 
+      # Toggle or restart a service live — applies without a daemon restart
+      # for supervisor-managed services (secrets-broker, browser-ipc,
+      # account-state, session-index, monitors' off-transition, watchdog,
+      # device-probe, self-heal, keychain-reap, state-dir-check)
+      agents daemon services disable secrets-broker
+      agents daemon services enable secrets-broker
+      agents daemon services restart secrets-broker
+
       # Host a signed webhook receiver here, supervised and restarted on crash
       agents daemon webhooks add --secrets-bundle linear-webhook
       agents daemon webhooks list
@@ -821,6 +886,16 @@ export function registerDaemonCommand(program) {
       the daemon (daemon.enabled: false in ~/.agents/devices/<host>/agents.yaml).
       'agents daemon start' still starts it explicitly, same as
       'systemctl start' on a disabled unit.
+
+      'agents daemon services enable|disable|restart <id>' applies live (no
+      daemon restart) for the 10 supervisor-managed services: secrets-broker,
+      browser-ipc, account-state, session-index, monitors (off only — turning
+      monitors back on still needs a restart), watchdog, device-probe,
+      self-heal, keychain-reap, and state-dir-check. The other 2 services
+      (scheduler, webhook-receiver) are still bare interval/socket setups with
+      no live start/stop hook, so a toggle there — and 'enable' on any service
+      that was disabled at daemon boot — still needs 'agents daemon restart'.
+      'agents daemon services' names which case you're in per row.
     `,
     });
     cmd.command('status')
@@ -917,11 +992,38 @@ export function registerDaemonCommand(program) {
     });
     const servicesCmd = cmd
         .command('services')
-        .description('The hosted services: health, bound state, socket path, and per-service toggles.')
+        .description('Every registered daemon service: live health, enabled state, and live enable/disable/restart.')
         .option('--json', 'Emit as JSON')
         .action(async (opts, command) => {
         await runServices({ json: command.optsWithGlobals().json === true });
     });
+    setHelpSections(servicesCmd, {
+        examples: `
+      # State, enabled, consecutive failures, last error for every service
+      agents daemon services
+
+      # Machine-readable — additive: also carries the pre-existing
+      # secretsBroker/browserIpc hosted-socket fields
+      agents daemon services --json
+
+      # Just the enable/disable metadata, no health probe
+      agents daemon services list
+
+      # Toggle or restart live — no daemon restart for a supervisor-managed
+      # service (secrets-broker, browser-ipc, account-state, session-index)
+      agents daemon services disable secrets-broker
+      agents daemon services enable secrets-broker
+      agents daemon services restart secrets-broker
+    `,
+        notes: `
+      A service disabled at daemon boot was never registered on the
+      supervisor, so 'enable' on it — and any toggle/restart on the 2
+      services the supervisor doesn't manage yet (scheduler,
+      webhook-receiver) — falls back to 'restart the daemon to apply'. Each
+      row in the plain-text view names which case it is; 'supervised:
+      true/false' does the same in --json.
+    `,
+    });
     servicesCmd
         .command('list')
         .description('List every daemon service and whether it is enabled.')
@@ -947,9 +1049,28 @@ export function registerDaemonCommand(program) {
         console.log(chalk.gray(`\nConfig: ${getDaemonServicesConfigPath()}`));
         console.log(chalk.gray('Changes take effect on the next daemon reload or restart.'));
     });
+    /**
+     * Apply an enable/disable toggle live (RUSH-3193 P4): persist it, then signal
+     * the running daemon to reload — its handler diffs the toggle and drives
+     * `supervisor.start/stop(id)` for a supervised service, so no restart is
+     * needed for the 10 supervisor-managed services (secrets-broker,
+     * browser-ipc, account-state, session-index, monitors' off-transition,
+     * watchdog, device-probe, self-heal, keychain-reap, state-dir-check). The 2
+     * remaining `setInterval`/socket-driven services (scheduler,
+     * webhook-receiver) and monitors' on-transition still need a restart — the
+     * daemon's own reload log says so.
+     */
+    function applyServiceToggleLive(service) {
+        if (!isDaemonRunning())
+            return;
+        const ok = signalDaemonReload();
+        console.log(ok
+            ? chalk.gray('Signalled the daemon to apply live. Confirm: agents daemon services')
+            : chalk.yellow('Reload signal not delivered — restart the daemon to apply: agents daemon restart'));
+    }
     servicesCmd
         .command('enable <service>')
-        .description('Enable a daemon service.')
+        .description('Enable a daemon service. Applies live for supervised services; a legacy service needs a restart.')
         .action((service) => {
         if (!DAEMON_SERVICE_IDS.includes(service)) {
             console.error(chalk.red(`Unknown service '${service}'. Run 'agents daemon services list' for valid services.`));
@@ -957,13 +1078,11 @@ export function registerDaemonCommand(program) {
         }
         setDaemonServiceEnabled(service, true);
         console.log(chalk.green(`Enabled '${service}'.`));
-        if (isDaemonRunning()) {
-            console.log(chalk.gray('Run `agents daemon reload` (or restart) to apply.'));
-        }
+        applyServiceToggleLive(service);
     });
     servicesCmd
         .command('disable <service>')
-        .description('Disable a daemon service.')
+        .description('Disable a daemon service. Applies live for supervised services; a legacy service needs a restart.')
         .action((service) => {
         if (!DAEMON_SERVICE_IDS.includes(service)) {
             console.error(chalk.red(`Unknown service '${service}'. Run 'agents daemon services list' for valid services.`));
@@ -971,9 +1090,25 @@ export function registerDaemonCommand(program) {
         }
         setDaemonServiceEnabled(service, false);
         console.log(chalk.green(`Disabled '${service}'.`));
-        if (isDaemonRunning()) {
-            console.log(chalk.gray('Run `agents daemon reload` (or restart) to apply.'));
+        applyServiceToggleLive(service);
+    });
+    servicesCmd
+        .command('restart <service>')
+        .description('Restart a supervised daemon service live, right now, outside its normal backoff schedule.')
+        .action((service) => {
+        if (!DAEMON_SERVICE_IDS.includes(service)) {
+            console.error(chalk.red(`Unknown service '${service}'. Run 'agents daemon services list' for valid services.`));
+            process.exit(1);
         }
+        if (!isDaemonRunning()) {
+            console.log(chalk.yellow('Daemon is not running — nothing to restart. Start it: agents daemon start'));
+            process.exit(1);
+        }
+        queueDaemonServiceRestart(service);
+        const ok = signalDaemonReload();
+        console.log(ok
+            ? chalk.green(`Restart requested for '${service}'.`) + chalk.gray(' Confirm: agents daemon services')
+            : chalk.yellow('Reload signal not delivered (unsupported on this platform, or the daemon just exited).'));
     });
     registerWebhooksSubcommand(cmd);
     registerFunnelCommand(cmd);

package/dist/commands/detach.d.ts

@@ -1,5 +1,18 @@
 import type { Command } from 'commander';
+import type { ActiveSession } from '../lib/session/active.js';
 export declare function registerDetachCommand(program: Command): void;
+/**
+ * Stop a live agent's interactive process and tear down its mux. tmux-hosted
+ * sessions are killed by session (closes the pane, ends the agent, reaps its
+ * helper processes); a plain process is SIGTERM'd (then SIGKILLed) by pid. Either
+ * way we wait for the process to actually exit before returning.
+ *
+ * Shared by two callers: `detach` (stop the terminal so the headless resume it
+ * spawns next doesn't fight the old process over the same transcript) and `stop`
+ * (end the session outright — no resume). `socket` defaults to the shared agents
+ * socket; it is a parameter only so a test can drive an isolated tmux server.
+ */
+export declare function stopInteractive(s: ActiveSession, socket?: string): Promise<void>;
 export declare function detachAction(id: string, opts?: {
     local?: boolean;
 }): Promise<void>;

package/dist/commands/detach.js

@@ -34,17 +34,20 @@ export function registerDetachCommand(program) {
     });
 }
 /**
- * Stop the interactive process so it can't fight the headless resume over the
- * same transcript. tmux-hosted sessions are killed by session (closes the pane
- * and ends the agent); a plain process is SIGTERM'd by pid. Either way we then
- * wait for the process to actually exit before returning, so the headless
- * continuation never starts writing the transcript while the old process is
- * still flushing it.
+ * Stop a live agent's interactive process and tear down its mux. tmux-hosted
+ * sessions are killed by session (closes the pane, ends the agent, reaps its
+ * helper processes); a plain process is SIGTERM'd (then SIGKILLed) by pid. Either
+ * way we wait for the process to actually exit before returning.
+ *
+ * Shared by two callers: `detach` (stop the terminal so the headless resume it
+ * spawns next doesn't fight the old process over the same transcript) and `stop`
+ * (end the session outright — no resume). `socket` defaults to the shared agents
+ * socket; it is a parameter only so a test can drive an isolated tmux server.
  */
-async function stopInteractive(s) {
+export async function stopInteractive(s, socket = getDefaultSocketPath()) {
     if (s.tmuxTarget) {
         const name = s.tmuxTarget.split(':')[0];
-        await killSession(name, getDefaultSocketPath());
+        await killSession(name, socket);
     }
     else if (s.pid && s.pid > 0) {
         try {