@phnx-labs/agents-cli 1.22.116 → 1.22.118

package/dist/commands/daemon.d.ts

@@ -2,11 +2,12 @@
  * `agents daemon` — runtime, hosted services, and failure visibility for the
  * always-on daemon (RUSH-2354).
  *
- * The daemon holds the routines scheduler, the browser IPC server, and the
+ * The daemon holds the routines scheduler, the session/usage sync, and the
  * watchdog pass — but until this command group existed it had no user-facing
  * surface: no way to see it, restart it, or turn it off. The secrets broker
  * moved out of this daemon entirely with the standalone `secrets` engine
- * (PHNX-3989 OWN-1); `agents daemon status` only probes its reachability.
+ * (PHNX-3989 OWN-1), and the browser IPC server with the standalone `browser`
+ * CLI (PHNX-4101); `agents daemon status` only probes the broker's reachability.
  * `daemon.ts` (the runtime) has always implemented every mechanism this file
  * wires up; nothing here is new machinery, only the missing CLI surface.
  *
@@ -17,6 +18,42 @@
  * duplicating it.
  */
 import type { Command } from 'commander';
+import { type SubsystemHealth } from '../lib/daemon-health.js';
 /** Elapsed wall-clock seconds since `pid` started, or null if unavailable (best-effort, POSIX only). */
 export declare function uptimeSeconds(pid: number): number | null;
+interface SecretsBrokerHealth {
+    reachable: boolean;
+    /**
+     * True when this box routes `keychain`-backend items to the standalone's
+     * encrypted file store (a headless worker with no reachable keyring). The
+     * broker exists only to hold an UNLOCKED keychain across reads without a
+     * Touch ID prompt — a file-backed box reads every secret one-shot with no
+     * broker at all, so an absent broker there is normal, not a fault (PHNX-4116).
+     */
+    fileBacked: boolean;
+    /**
+     * Always `null` — the broker's socket now lives entirely inside the
+     * standalone `secrets` engine's own process (PHNX-3989 OWN-1); the daemon
+     * neither hosts it nor knows its transport details. Kept in the shape for
+     * `--json` compatibility.
+     */
+    socketPath: string | null;
+    heldBundles: number | null;
+    /**
+     * Always `null` — no daemon service writes a health record for the broker
+     * anymore (the daemon does not host or supervise it). Kept in the shape for
+     * `--json` compatibility.
+     */
+    record: SubsystemHealth | null;
+}
+/**
+ * The `secrets broker` health line. Reachable → healthy. Unreachable is a FAULT
+ * (`down`) only when the store is keychain-backed — there the broker is what
+ * holds the unlocked keychain across reads. On a file-backed box (every
+ * headless worker) no broker is needed: secrets read one-shot, so an absent
+ * broker is expected and reads as INFO, not `down` (PHNX-4116). Pure, so the
+ * three cases are unit-tested with no live daemon.
+ */
+export declare function secretsBrokerHealthLine(secrets: SecretsBrokerHealth): string;
 export declare function registerDaemonCommand(program: Command): void;
+export {};

package/dist/commands/daemon.js

@@ -2,11 +2,12 @@
  * `agents daemon` — runtime, hosted services, and failure visibility for the
  * always-on daemon (RUSH-2354).
  *
- * The daemon holds the routines scheduler, the browser IPC server, and the
+ * The daemon holds the routines scheduler, the session/usage sync, and the
  * watchdog pass — but until this command group existed it had no user-facing
  * surface: no way to see it, restart it, or turn it off. The secrets broker
  * moved out of this daemon entirely with the standalone `secrets` engine
- * (PHNX-3989 OWN-1); `agents daemon status` only probes its reachability.
+ * (PHNX-3989 OWN-1), and the browser IPC server with the standalone `browser`
+ * CLI (PHNX-4101); `agents daemon status` only probes the broker's reachability.
  * `daemon.ts` (the runtime) has always implemented every mechanism this file
  * wires up; nothing here is new machinery, only the missing CLI surface.
  *
@@ -21,10 +22,10 @@ import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
-import { getDaemonStatus, isDaemonRunning, isDaemonWedged, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, RedirectedHomeDaemonError, } from '../lib/daemon/daemon.js';
+import { getDaemonStatus, isDaemonRunning, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, RedirectedHomeDaemonError, } from '../lib/daemon/daemon.js';
 import { listDaemonRunProcesses } from '../lib/daemon/leaked-daemons.js';
 import { getConfigValue, setConfigValue, isDaemonEnabled } from '../lib/device-config.js';
-import { readSubsystemHealth, readAllSubsystemHealth, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START, } from '../lib/daemon-health.js';
+import { readSubsystemHealth, readAllSubsystemHealth, 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';
@@ -293,25 +294,24 @@ function humanDuration(seconds) {
 }
 /** Reachability probe only — the daemon does not host, supervise, or take over the broker (OWN-1). */
 async function probeSecretsBroker() {
+    const { agentPing, agentStatus, keychainUsesFileFallback } = await import('../lib/secrets-client.js');
     try {
-        const { agentPing, agentStatus } = await import('../lib/secrets-client.js');
         const ping = await agentPing();
-        if (!ping.reachable)
-            return { reachable: false, socketPath: null, heldBundles: null, record: null };
-        const entries = await agentStatus();
-        return { reachable: true, socketPath: null, heldBundles: entries.length, record: null };
+        if (ping.reachable) {
+            const entries = await agentStatus();
+            return { reachable: true, fileBacked: false, socketPath: null, heldBundles: entries.length, record: null };
+        }
     }
-    catch {
-        return { reachable: false, socketPath: null, heldBundles: null, record: null };
+    catch { /* fall through to the unreachable classification below */ }
+    // Unreachable: distinguish "broker needed and absent" (a keychain-backed box)
+    // from "no broker needed" (a file-backed worker reads secrets one-shot). An
+    // unknown store defaults to broker-needed, the louder verdict.
+    let fileBacked = false;
+    try {
+        fileBacked = await keychainUsesFileFallback();
     }
-}
-async function probeBrowserIPC() {
-    const record = readSubsystemHealth(SUBSYSTEM_BROWSER_IPC);
-    const { isBrowserServiceReachable, getSocketPath } = await import('../lib/browser/ipc.js');
-    const { listAllProfileSnapshots } = await import('../lib/browser/runtime-state.js');
-    const bound = await isBrowserServiceReachable();
-    const sessionCount = listAllProfileSnapshots().filter((s) => s.pidAlive && s.daemonAlive).length;
-    return { bound, socketPath: getSocketPath(), sessionCount, record };
+    catch { /* unknown → not file-backed */ }
+    return { reachable: false, fileBacked, socketPath: null, heldBundles: null, record: null };
 }
 function schedulerSummary() {
     const jobs = listJobs();
@@ -357,6 +357,23 @@ function healthLine(label, live, record) {
             : '';
     return `  ${chalk.red('down')}  ${label} ${detail}`;
 }
+/**
+ * The `secrets broker` health line. Reachable → healthy. Unreachable is a FAULT
+ * (`down`) only when the store is keychain-backed — there the broker is what
+ * holds the unlocked keychain across reads. On a file-backed box (every
+ * headless worker) no broker is needed: secrets read one-shot, so an absent
+ * broker is expected and reads as INFO, not `down` (PHNX-4116). Pure, so the
+ * three cases are unit-tested with no live daemon.
+ */
+export function secretsBrokerHealthLine(secrets) {
+    if (secrets.reachable) {
+        return healthLine(`secrets broker  (${secrets.socketPath}, ${secrets.heldBundles} bundle(s) held)`, true, secrets.record);
+    }
+    if (secrets.fileBacked) {
+        return `  ${chalk.cyan('info')}  secrets agent not running (file-backed stores)`;
+    }
+    return healthLine('secrets broker  (unreachable)', false, secrets.record);
+}
 async function runStatus(opts) {
     const status = getDaemonStatus();
     const enabled = isDaemonEnabled();
@@ -378,7 +395,7 @@ async function runStatus(opts) {
     const staleTiers = staleDaemons(processes, pid ?? null, registeredPids);
     const stale = staleTiers.visible;
     const ownerEntryGone = owner ? entryIsGone(owner) : false;
-    const [secrets, browserIpc] = await Promise.all([probeSecretsBroker(), probeBrowserIPC()]);
+    const secrets = await probeSecretsBroker();
     const scheduler = schedulerSummary();
     if (opts.json) {
         console.log(JSON.stringify({
@@ -386,6 +403,9 @@ async function runStatus(opts) {
             pid,
             uptimeSeconds: uptime,
             heartbeatAgeMs,
+            restarts24h: status.restarts24h,
+            lastRestartCause: status.lastRestartCause,
+            lastRestartAt: status.lastRestartAt,
             logPath: status.logPath,
             binaryPath: owner?.entry ?? status.binaryPath,
             binaryVersion: owner?.version ?? null,
@@ -409,12 +429,6 @@ async function runStatus(opts) {
                     heldBundles: secrets.heldBundles,
                     health: secrets.record,
                 },
-                browserIpc: {
-                    bound: browserIpc.bound,
-                    socketPath: browserIpc.socketPath,
-                    sessionCount: browserIpc.sessionCount,
-                    health: browserIpc.record,
-                },
             },
             scheduler: {
                 enabled: getConfigValue('scheduler.enabled').value !== false,
@@ -427,9 +441,8 @@ async function runStatus(opts) {
         return;
     }
     const stateLabel = state === 'running' ? chalk.green('running')
-        : state === 'wedged' ? chalk.red('wedged')
-            : state === 'disabled' ? chalk.yellow('disabled')
-                : chalk.gray('stopped');
+        : state === 'disabled' ? chalk.yellow('disabled')
+            : chalk.gray('stopped');
     console.log(chalk.bold('Identity\n'));
     console.log(`  State:      ${stateLabel}`);
     if (pid)
@@ -438,6 +451,12 @@ async function runStatus(opts) {
         console.log(`  Uptime:     ${humanDuration(uptime)}`);
     if (heartbeatAgeMs !== null)
         console.log(`  Heartbeat:  ${Math.round(heartbeatAgeMs / 1000)}s ago`);
+    if (status.restarts24h > 0) {
+        const when = status.lastRestartAt ? ` (last ${new Date(status.lastRestartAt).toLocaleString()})` : '';
+        console.log(`  Restarts:   ${status.restarts24h} in the last 24h${when}`);
+        if (status.lastRestartCause)
+            console.log(`  Last cause: ${chalk.gray(status.lastRestartCause)}`);
+    }
     const binaryLabel = owner?.entry ?? status.binaryPath ?? 'unknown';
     console.log(`  Binary:     ${ownerEntryGone ? chalk.red(`${binaryLabel}  (MISSING from disk)`) : chalk.gray(binaryLabel)}`);
     console.log(`  Version:    ${chalk.gray(owner?.version ?? 'unknown')}`);
@@ -476,17 +495,13 @@ async function runStatus(opts) {
         console.log(chalk.gray('\n  Only one install should own the daemon. Stop the stray(s): kill <pid>'));
     }
     console.log(chalk.bold('\nHealth\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(secretsBrokerHealthLine(secrets));
     const schedulerEnabled = getConfigValue('scheduler.enabled').value !== false;
     console.log(`  ${schedulerEnabled ? chalk.green('enabled') : chalk.yellow('disabled')}  scheduler — ${scheduler.enabledCount}/${scheduler.routineCount} routine(s) enabled` +
         (scheduler.nextFire ? `, next ${scheduler.nextFire.toLocaleString()}` : ''));
     if (scheduler.failingCount > 0) {
         console.log(chalk.red(`  ${scheduler.failingCount} routine(s) failing their last run — see: agents routines stats`));
     }
-    if (state === 'wedged') {
-        console.log(chalk.red('\nThe daemon is wedged (heartbeat stale). Restart: agents daemon restart'));
-    }
 }
 /**
  * Combine the persisted enable/disable toggles with whatever health the
@@ -503,8 +518,8 @@ function buildServiceRows(daemonRunning) {
         // 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).
+        // says — trusting a stale 'running'/'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';
@@ -524,8 +539,6 @@ function buildServiceRows(daemonRunning) {
 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')
@@ -533,13 +546,12 @@ function serviceStateLabel(state) {
     return chalk.yellow(state); // 'running (unsupervised)' or any future label
 }
 async function runServices(opts) {
-    const [secrets, browserIpc] = await Promise.all([probeSecretsBroker(), probeBrowserIPC()]);
+    const secrets = await probeSecretsBroker();
     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));
@@ -554,8 +566,7 @@ async function runServices(opts) {
             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(secretsBrokerHealthLine(secrets));
     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.'));
 }
@@ -633,8 +644,6 @@ async function runDoctor(opts) {
     const problems = [];
     if (!status.running && enabled)
         problems.push('Daemon is not running. Start it: agents daemon start');
-    if (status.running && isDaemonWedged())
-        problems.push('Daemon is wedged (heartbeat stale). Restart: agents daemon restart');
     // RUSH-2418: an open auto-start circuit breaker is the FIRST thing to report
     // for a stopped daemon — otherwise the only advice is "agents daemon start",
     // which is the exact action the breaker just refused, with no hint that a
@@ -672,12 +681,6 @@ async function runDoctor(opts) {
     if (secrets.record && secrets.record.consecutiveFailures > 0) {
         problems.push(`Secrets broker has ${secrets.record.consecutiveFailures} consecutive failure(s): ${secrets.record.lastError}`);
     }
-    const browserIpc = await probeBrowserIPC();
-    if (!browserIpc.bound)
-        problems.push('Browser IPC is unbound.');
-    if (browserIpc.record && browserIpc.record.consecutiveFailures > 0) {
-        problems.push(`Browser IPC has ${browserIpc.record.consecutiveFailures} consecutive failure(s): ${browserIpc.record.lastError}`);
-    }
     const scheduler = schedulerSummary();
     if (scheduler.failingCount > 0) {
         problems.push(`${scheduler.failingCount} routine(s) failing their last run. See: agents routines stats`);
@@ -841,7 +844,7 @@ function runWebhooksList(json) {
 export function registerDaemonCommand(program) {
     const cmd = program
         .command('daemon')
-        .description('The always-on daemon: browser IPC, watchdog, and the routines scheduler. Bare `agents daemon` shows status.')
+        .description('The always-on daemon: watchdog, session/usage sync, and the routines scheduler. Bare `agents daemon` shows status.')
         .option('--json', 'Emit as JSON')
         .action(async (opts, command) => {
         await runStatus({ json: command.optsWithGlobals().json === true });
@@ -870,12 +873,12 @@ export function registerDaemonCommand(program) {
       agents daemon services
 
       # Toggle or restart a service live — applies without a daemon restart
-      # for supervisor-managed services (browser-ipc, account-state,
-      # session-index, monitors' off-transition, watchdog, device-probe,
-      # self-heal, state-dir-check)
-      agents daemon services disable browser-ipc
-      agents daemon services enable browser-ipc
-      agents daemon services restart browser-ipc
+      # for supervisor-managed services (account-state, session-index,
+      # monitors' off-transition, watchdog, device-probe, self-heal,
+      # state-dir-check)
+      agents daemon services disable account-state
+      agents daemon services enable account-state
+      agents daemon services restart account-state
 
       # Host a signed webhook receiver here, supervised and restarted on crash
       agents daemon webhooks add --secrets-bundle linear-webhook
@@ -912,12 +915,10 @@ export function registerDaemonCommand(program) {
 
       'agents daemon services enable|disable|restart <id>' applies live (no
       daemon restart) for supervisor-managed services that were registered at
-      boot. browser-ipc is also registered while disabled, specifically so a
-      browser client can enable it live. The inline scheduler re-evaluates its
-      toggle on every reload as well. A boot-disabled service other than
-      browser-ipc, the monitor on-transition, and webhook-receiver still need an
-      operator 'agents daemon restart'. 'agents daemon services' names which
-      case you're in per row.
+      boot. The inline scheduler re-evaluates its toggle on every reload as
+      well. A boot-disabled service other than the monitor on-transition and
+      webhook-receiver still needs an operator 'agents daemon restart'. 'agents
+      daemon services' names which case you're in per row.
     `,
     });
     cmd.command('status')
@@ -1033,16 +1034,15 @@ export function registerDaemonCommand(program) {
       agents daemon services list
 
       # Toggle or restart live — no daemon restart for a supervisor-managed
-      # service (browser-ipc, account-state, session-index)
-      agents daemon services disable browser-ipc
-      agents daemon services enable browser-ipc
-      agents daemon services restart browser-ipc
+      # service (account-state, session-index)
+      agents daemon services disable account-state
+      agents daemon services enable account-state
+      agents daemon services restart account-state
     `,
         notes: `
       A service disabled at daemon boot is normally not registered on the
-      supervisor, so enabling it needs an operator restart. browser-ipc is the
-      exception: it is registered stopped and can be enabled live. The inline
-      scheduler also applies enable/disable on reload; webhook-receiver and the
+      supervisor, so enabling it needs an operator restart. The inline
+      scheduler applies enable/disable on reload; webhook-receiver and the
       monitor on-transition still require 'agents daemon restart'. Each row in
       the plain-text view names which case it is; 'supervised: true/false' does
       the same in --json.
@@ -1077,9 +1077,8 @@ export function registerDaemonCommand(program) {
      * 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 supervisor-managed services registered at boot. browser-ipc is
-     * registered even when disabled so it can be enabled live; the inline
-     * scheduler also re-evaluates its toggle on reload. webhook-receiver,
+     * needed for supervisor-managed services registered at boot. The inline
+     * scheduler re-evaluates its toggle on reload. webhook-receiver,
      * monitors' on-transition, and other boot-disabled services still need a
      * deliberate operator restart — the daemon's own reload log says so.
      */

package/dist/commands/events.js

@@ -203,7 +203,7 @@ export function addEventsReadOptions(command) {
         .option('--command <path>', 'Only this command path — prefix match (e.g. "teams create")')
         .option('--event <type>', 'Only this typed event (repeatable, e.g. secrets.get, run.dispatched, pr.opened)', collect, [])
         .option('--agent <name>', 'Only events tagged with this agent')
-        .option('--caller <kind>', 'Only this caller kind (claude-code, codex, gemini, cursor, terminal, script)')
+        .option('--caller <kind>', 'Only this caller kind (claude-code, codex, cursor, terminal, script)')
         .option('--level <level>', 'Only this level: audit, warn, info, debug')
         .option('--session <id>', 'Only events from this session (the provenance sessionId) — e.g. trace which session read a secret')
         .option('--bundle <name>', 'Only events carrying this bundle in their payload — e.g. `--module secrets --bundle share` for every read of the share bundle')

package/dist/commands/exec.d.ts

@@ -62,6 +62,7 @@ interface ExecCommandActionOptions {
     until?: string;
     interval?: string;
     where?: string;
+    local?: boolean;
     host?: string;
     device?: string;
     on?: string;
@@ -130,6 +131,20 @@ export declare function hostTargetGiven(options: {
     on?: string;
     computer?: string;
 }): string[];
+/**
+ * Turn a host target that names THIS machine into an explicit local pin: the
+ * host-family flags are cleared and `local` is set, so no dispatch path
+ * self-SSHes and the bare-interactive default (`bareInteractiveRunDefaultsToDeviceAuto`)
+ * sees a decided placement. Returns true when the pin was applied. Pure over
+ * the `isSelf` predicate so the rule is testable without a device registry.
+ */
+export declare function pinLocalWhenTargetIsSelf(options: {
+    host?: string;
+    device?: string;
+    on?: string;
+    computer?: string;
+    local?: boolean;
+}, isSelf: (name: string) => boolean): boolean;
 /**
  * Return every option whose selection semantics conflict with an account
  * choice (`agent#`). Device routing is deliberately absent: the marker rides
@@ -159,6 +174,7 @@ export declare function runDevicePickerConflicts(options: {
     device?: string;
     on?: string;
     computer?: string;
+    local?: boolean;
 }): string[];
 export { RUN_AUTO_KEYWORD };
 /**
@@ -179,6 +195,7 @@ export declare function runAutoDefaultsToAffinity(options: {
     device?: string;
     on?: string;
     computer?: string;
+    local?: boolean;
 }, env?: NodeJS.ProcessEnv): boolean;
 /**
  * Whether a bare human-facing `agents run <harness>` — no prompt, so an
@@ -210,6 +227,7 @@ export declare function bareInteractiveRunDefaultsToDeviceAuto(options: {
     lease?: string | boolean;
     box?: string;
     cloud?: boolean;
+    local?: boolean;
 }, run: {
     prompt?: string;
     devicePickerRequested?: boolean;