@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/daemon/testdata/process-view-start.js

@@ -6,8 +6,6 @@ import { spawn } from 'node:child_process';
 import { serviceManagerRegistrationAllowed } from '../../service-manifest.js';
 import { startDaemon, stopDaemon } from '../daemon.js';
 import { getDaemonDir, getTerminalsDir, getCacheDir } from '../../state.js';
-// Tripwire precedes ALL lifecycle calls. Some older Bun versions return HOME
-// from os.userInfo(), which would incorrectly allow the real service manager.
 assert.equal(serviceManagerRegistrationAllowed().allowed, false, 'isolated fixture must never access the production service manager');
 const cold = process.argv[3] === 'cold';
 const child = cold ? spawn('bun', [process.argv[4], '__daemon-run'], { stdio: 'ignore', env: process.env }) : undefined;
@@ -18,9 +16,6 @@ fs.writeFileSync(path.join(process.env.HOME, 'test-child.pid'), String(started.p
 try {
     if (!cold)
         assert.ok(fs.existsSync(path.join(getDaemonDir(), 'health.json')), 'ordinary launcher publishes health before daemon starts');
-    // Daemon-liveness socket: the browser IPC socket left with the standalone
-    // browser CLI (PHNX-4101), so this waits on the feed-stream hub socket the
-    // daemon binds unconditionally on boot.
     const socket = path.join(getCacheDir(), 'helpers', 'feed', 'feed-stream.sock');
     let ready = false;
     for (let i = 0; i < 80 && !ready; i++) {

package/dist/lib/daemon/tmux-reap-service.d.ts

@@ -1,4 +1,3 @@
-/** Dead managed tmux session and orphan-helper cleanup under supervision. */
 import type { DaemonServiceId } from '../daemon-services.js';
 import { BasePeriodicService, type DaemonContext } from './service.js';
 export declare class TmuxReapService extends BasePeriodicService {

package/dist/lib/daemon/tmux-reap-service.js

@@ -1,4 +1,3 @@
-/** Dead managed tmux session and orphan-helper cleanup under supervision. */
 import { getDefaultSocketPath } from '../tmux/paths.js';
 import { reapDeadTmuxPanes } from '../tmux/session.js';
 import { BasePeriodicService } from './service.js';

package/dist/lib/daemon/usage-sync-service.d.ts

@@ -1,25 +1,3 @@
-/**
- * Fleet state exchange as a `PeriodicService` (PHNX-3392 usage-sync,
- * PHNX-3792 session mirror, PHNX-4051 auth verdict, PHNX-4116 SSH transport).
- *
- * Each tick: (1) refreshes every field this box owns in its own
- * `devices/<device>/daemon-state.json` — a headed box's Claude usage snapshot,
- * EVERY box's lightweight session digests, and the reserved-auth readiness
- * verdict; (2) on a headed box (`personal`/`desktop`) only, dials every dialable
- * peer in parallel with `agents __usage-ingest --reply`, sending that envelope
- * on stdin and storing each peer's reply as `devices/<peer>/daemon-state.json`
- * stamped `receivedAt` (`exchangeFleetStateWithPeers`); (3) folds the peers'
- * session digests into the local index so the picker renders remote-host
- * previews inline. A worker never initiates: its state leaves the box only as
- * the reply to a headed peer's dial, and a headed peer's usage rows arrive on
- * that same dial.
- *
- * There is no git in this tick. The exchange used to be a commit/rebase/push of
- * the fleet-synced user repo, which needed a cross-process lock, a 45 s
- * process-tree deadline, an 8-minute kickoff offset from auth-sync to dodge that
- * lock, and untracked-collision backups — and still wedged every clone behind a
- * bloated remote. Peers that time out are skipped this tick; none blocks another.
- */
 import { BasePeriodicService, type DaemonContext } from './service.js';
 import type { DaemonServiceId } from '../daemon-services.js';
 /**
@@ -31,7 +9,6 @@ import type { DaemonServiceId } from '../daemon-services.js';
  * second literal, so the two files can't drift out of sync with each other.
  */
 export declare const USAGE_SYNC_TICK_MS: number;
-/** Let the daemon's registry/device probes settle before the first fan-out. */
 export declare const USAGE_SYNC_KICKOFF_MS = 90000;
 export declare class UsageSyncService extends BasePeriodicService {
     readonly id: DaemonServiceId;

package/dist/lib/daemon/usage-sync-service.js

@@ -1,25 +1,3 @@
-/**
- * Fleet state exchange as a `PeriodicService` (PHNX-3392 usage-sync,
- * PHNX-3792 session mirror, PHNX-4051 auth verdict, PHNX-4116 SSH transport).
- *
- * Each tick: (1) refreshes every field this box owns in its own
- * `devices/<device>/daemon-state.json` — a headed box's Claude usage snapshot,
- * EVERY box's lightweight session digests, and the reserved-auth readiness
- * verdict; (2) on a headed box (`personal`/`desktop`) only, dials every dialable
- * peer in parallel with `agents __usage-ingest --reply`, sending that envelope
- * on stdin and storing each peer's reply as `devices/<peer>/daemon-state.json`
- * stamped `receivedAt` (`exchangeFleetStateWithPeers`); (3) folds the peers'
- * session digests into the local index so the picker renders remote-host
- * previews inline. A worker never initiates: its state leaves the box only as
- * the reply to a headed peer's dial, and a headed peer's usage rows arrive on
- * that same dial.
- *
- * There is no git in this tick. The exchange used to be a commit/rebase/push of
- * the fleet-synced user repo, which needed a cross-process lock, a 45 s
- * process-tree deadline, an 8-minute kickoff offset from auth-sync to dodge that
- * lock, and untracked-collision backups — and still wedged every clone behind a
- * bloated remote. Peers that time out are skipped this tick; none blocks another.
- */
 import { BasePeriodicService } from './service.js';
 import { USAGE_SYNC_INTERVAL_MS } from '../accounting/usage-sync.js';
 /**
@@ -32,7 +10,6 @@ import { USAGE_SYNC_INTERVAL_MS } from '../accounting/usage-sync.js';
  */
 export const USAGE_SYNC_TICK_MS = USAGE_SYNC_INTERVAL_MS;
 const USAGE_SYNC_DEADLINE_MS = 2 * 60_000;
-/** Let the daemon's registry/device probes settle before the first fan-out. */
 export const USAGE_SYNC_KICKOFF_MS = 90_000;
 export class UsageSyncService extends BasePeriodicService {
     id = 'usage-sync';
@@ -40,15 +17,12 @@ export class UsageSyncService extends BasePeriodicService {
     deadlineMs = USAGE_SYNC_DEADLINE_MS;
     startupDelayMs = USAGE_SYNC_KICKOFF_MS;
     async onStart(_ctx) {
-        // No connections to open — each tick re-reads the local cache + registry.
     }
     async onStop() {
-        // Nothing to release — the supervisor's timer teardown is the only cleanup.
     }
     async onTick(ctx) {
         const { exchangeFleetStateWithPeers, publishOwnFleetState } = await import('../accounting/usage-sync.js');
         const { isHeadedDeviceRole, selfConfiguredDeviceRole } = await import('../device-config.js');
-        // Refresh every owned field BEFORE the fan-out so peers receive this tick's state.
         const published = await publishOwnFleetState();
         if (published.usage.changed)
             ctx.log('INFO', `usage-sync: published usage snapshot to ${published.usage.path}`);

package/dist/lib/daemon/watchdog-service.d.ts

@@ -1,12 +1,3 @@
-/**
- * Watchdog tick as a `PeriodicService` (RUSH-3193 P3).
- *
- * Nudges this host's own stalled agent sessions. Gated on the `watchdog.enabled`
- * device-config flag (`agents watchdog enable`), so the timer always fires but
- * only does work when the user opted in — the check happens inside the tick
- * itself, not the enable/disable registration gate, matching the pre-migration
- * inline behavior (daemon.ts previously `WATCHDOG_TICK_MS`-interval closure).
- */
 import { BasePeriodicService, type DaemonContext } from './service.js';
 import type { DaemonServiceId } from '../daemon-services.js';
 export declare class WatchdogService extends BasePeriodicService {

package/dist/lib/daemon/watchdog-service.js

@@ -1,28 +1,15 @@
-/**
- * Watchdog tick as a `PeriodicService` (RUSH-3193 P3).
- *
- * Nudges this host's own stalled agent sessions. Gated on the `watchdog.enabled`
- * device-config flag (`agents watchdog enable`), so the timer always fires but
- * only does work when the user opted in — the check happens inside the tick
- * itself, not the enable/disable registration gate, matching the pre-migration
- * inline behavior (daemon.ts previously `WATCHDOG_TICK_MS`-interval closure).
- */
 import { BasePeriodicService } from './service.js';
 import { getConfigValueAsync } from '../device-config.js';
 import { emitAsync } from '../feed/events.js';
-/** Matches the historical inline interval (daemon.ts WATCHDOG_TICK_MS). */
 const WATCHDOG_TICK_MS = 3 * 60_000;
-/** Hard cap per tick — `runWatchdogPass` is host-local (adds no SSH fan-out of its own, `watchdog/runner.ts:580`); short enough that a hang never freezes the service for long. */
 const WATCHDOG_DEADLINE_MS = 120_000;
 export class WatchdogService extends BasePeriodicService {
     id = 'watchdog';
     intervalMs = WATCHDOG_TICK_MS;
     deadlineMs = WATCHDOG_DEADLINE_MS;
     async onStart(_ctx) {
-        // No connections/handles to open — each tick re-reads the enable flag.
     }
     async onStop() {
-        // Nothing to release — the supervisor's timer teardown is the only cleanup needed.
     }
     async onTick(ctx) {
         if ((await getConfigValueAsync('watchdog.enabled')).value !== true)

package/dist/lib/daemon/webhook-receiver-service.d.ts

@@ -1,4 +1,3 @@
-/** Signed webhook receiver lifecycle under the daemon service supervisor. */
 import type { DaemonServiceId } from '../daemon-services.js';
 import { BaseDaemonService, type DaemonContext } from './service.js';
 export declare class WebhookReceiverService extends BaseDaemonService {

package/dist/lib/daemon/webhook-receiver-service.js

@@ -1,4 +1,3 @@
-/** Signed webhook receiver lifecycle under the daemon service supervisor. */
 import { startHostedWebhookReceivers } from '../daemon-webhooks.js';
 import { BaseDaemonService } from './service.js';
 export class WebhookReceiverService extends BaseDaemonService {

package/dist/lib/daemon-health.d.ts

@@ -1,77 +1,22 @@
-/**
- * Daemon startup itself (RUSH-2418). Unlike the two above, this record is
- * written from BOTH sides: the launching CLI records a start that produced no
- * live daemon, and the daemon records its own successful claim. Its
- * `consecutiveFailures` is what `ensureDaemonStarted` reads to open the
- * auto-start circuit breaker, so a daemon dying on boot stops being relaunched
- * by every foreground command that happens to want one.
- */
 export declare const SUBSYSTEM_DAEMON_START = "daemon-start";
-/** One subsystem's health as of the last time it reported in. */
 export interface SubsystemHealth {
-    /** Stable identifier, e.g. 'browser-ipc', 'monitors'. */
     subsystem: string;
-    /** Most recent error message, or null if it has never failed. */
     lastError: string | null;
-    /** ISO timestamp of the most recent error, or null. */
     lastErrorAt: string | null;
-    /** Consecutive failures since the last success (0 when currently healthy). */
     consecutiveFailures: number;
-    /** ISO timestamp of the most recent success, or null if it has never succeeded. */
     lastOkAt: string | null;
-    /**
-     * `ServiceSupervisor`'s lifecycle state (`idle`/`running`/`stopped`), written
-     * by `recordSubsystemState` on every transition. Only present for
-     * supervisor-managed subsystems (RUSH-3193 P4) — a subsystem that predates the
-     * supervisor (e.g. `daemon-start`) never has this field, which is how `agents
-     * daemon services` tells a measured state from an inferred one.
-     */
     state?: string;
 }
-/** Record a successful subsystem check-in — clears the failure streak. */
 export declare function recordSubsystemOk(subsystem: string, at?: string): void;
-/** Record a subsystem failure — bumps the consecutive-failure streak. */
 export declare function recordSubsystemError(subsystem: string, error: string, at?: string): void;
-/**
- * Refine the reason on an already-counted failure, without bumping the streak.
- *
- * Exists because a start is counted BEFORE its outcome is known (RUSH-2418):
- * the launcher marks the attempt, then replaces the provisional reason with the
- * real one if it fails outright. Calling `recordSubsystemError` a second time
- * would count one failed start as two.
- *
- * Describing a failure that was never counted would be a lie in the other
- * direction — a `lastError` with `consecutiveFailures: 0` — so an unreported
- * subsystem is left alone rather than given a blank record to decorate.
- */
 export declare function recordSubsystemErrorReason(subsystem: string, error: string, at?: string): void;
-/**
- * Record a `ServiceSupervisor` lifecycle-state transition, without touching
- * the ok/error streak. Cross-process readers (`agents daemon services`) have
- * no other way to see `stopped`/`idle` vs `running` — `agents daemon
- * status` runs as a separate process from the daemon (see module docblock).
- */
 export declare function recordSubsystemState(subsystem: string, state: string): void;
-/** One supervised restart: the service whose deadline breach forced the daemon to exit, and when. */
 export interface DaemonRestartRecord {
-    /** ISO timestamp of the breach that forced the restart. */
     at: string;
-    /** The service id whose tick or lifecycle call breached its deadline. */
     subsystem: string;
-    /** The deadline-breach message. */
     cause: string;
 }
-/**
- * Append a supervised-restart record and flush it to disk SYNCHRONOUSLY. The
- * caller is `ServiceSupervisor.exitForRestart`, which calls `process.exit`
- * immediately after, so the write must be durable before the process dies.
- * Never throws (same contract as the health file above) — a dropped ledger entry
- * must not keep the process from exiting for its restart.
- */
 export declare function recordDaemonRestart(subsystem: string, cause: string, at?: string): void;
-/** Every supervised restart recorded at or after `sinceMs`, oldest first. */
 export declare function readRecentDaemonRestarts(sinceMs: number): DaemonRestartRecord[];
-/** Read one subsystem's health record, or null if it has never reported in. */
 export declare function readSubsystemHealth(subsystem: string): SubsystemHealth | null;
-/** Read every subsystem's health record, sorted by subsystem name. */
 export declare function readAllSubsystemHealth(): SubsystemHealth[];

package/dist/lib/daemon-health.js

@@ -1,40 +1,8 @@
-/**
- * Per-subsystem health record for the always-on daemon.
- *
- * Today a subsystem failure inside `runDaemon()` (daemon.ts) is a single
- * `log('ERROR', ...)` line that scrolls out of the log file and is never
- * surfaced anywhere else — `agents daemon status` has no way to answer "is the
- * browser IPC server actually healthy right now?" beyond "the daemon process
- * is alive". This module gives every subsystem a small persisted record —
- * {@link SubsystemHealth} — so `agents daemon status` / `agents daemon
- * services` can report health, not just liveness (RUSH-2354).
- *
- * Scheduled routines get this for free once migrated onto `agents routines`
- * (their run history already carries success/failure — `agents routines
- * stats`). This module exists for the subsystems that predate routines and have
- * no run history of their own: the browser IPC server, plus the daemon's own
- * startup (`SUBSYSTEM_DAEMON_START`, RUSH-2418) — which is the one record that
- * also GATES behaviour rather than only reporting it. The secrets broker moved
- * with the standalone `secrets` engine (PHNX-3989 OWN-1) — this daemon no
- * longer hosts or supervises it, so it carries no health record here.
- *
- * File-backed (one JSON object keyed by subsystem name) rather than in-memory
- * because `agents daemon status` runs as a SEPARATE process from the daemon —
- * it must read what the daemon last recorded, not maintain its own state.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import { getDaemonDir } from './state.js';
 import { atomicWriteFileSync, ensureLockTarget, withFileLock } from './fs-atomic.js';
 const HEALTH_FILE = 'health.json';
-/**
- * Daemon startup itself (RUSH-2418). Unlike the two above, this record is
- * written from BOTH sides: the launching CLI records a start that produced no
- * live daemon, and the daemon records its own successful claim. Its
- * `consecutiveFailures` is what `ensureDaemonStarted` reads to open the
- * auto-start circuit breaker, so a daemon dying on boot stops being relaunched
- * by every foreground command that happens to want one.
- */
 export const SUBSYSTEM_DAEMON_START = 'daemon-start';
 function getHealthPath() {
     return path.join(getDaemonDir(), HEALTH_FILE);
@@ -52,15 +20,6 @@ function readAll() {
         return {};
     }
 }
-/**
- * Never throws. `recordSubsystemOk`/`recordSubsystemError` are called from
- * inside a service's error boundary (`ServiceSupervisor.runTick`'s catch, and
- * its own catch-of-a-catch in `recordFailure`) — a write failure here (disk
- * full, permission, or the state dir removed mid-run, which this daemon
- * explicitly anticipates via the state-dir self-check) must degrade to a
- * dropped health update, never escape as an unhandled rejection that would
- * hit the process-wide handler and take down every OTHER service too.
- */
 function updateAll(update) {
     try {
         const healthPath = getHealthPath();
@@ -72,22 +31,20 @@ function updateAll(update) {
             try {
                 fs.chmodSync(healthPath, 0o600);
             }
-            catch { /* best effort */ }
+            catch { }
         });
     }
-    catch { /* see docblock above — health recording must never crash a caller */ }
+    catch { }
 }
 function blankRecord(subsystem) {
     return { subsystem, lastError: null, lastErrorAt: null, consecutiveFailures: 0, lastOkAt: null };
 }
-/** Record a successful subsystem check-in — clears the failure streak. */
 export function recordSubsystemOk(subsystem, at = new Date().toISOString()) {
     updateAll((all) => {
         const existing = all[subsystem] ?? blankRecord(subsystem);
         all[subsystem] = { ...existing, subsystem, consecutiveFailures: 0, lastOkAt: at };
     });
 }
-/** Record a subsystem failure — bumps the consecutive-failure streak. */
 export function recordSubsystemError(subsystem, error, at = new Date().toISOString()) {
     updateAll((all) => {
         const existing = all[subsystem] ?? blankRecord(subsystem);
@@ -100,18 +57,6 @@ export function recordSubsystemError(subsystem, error, at = new Date().toISOStri
         };
     });
 }
-/**
- * Refine the reason on an already-counted failure, without bumping the streak.
- *
- * Exists because a start is counted BEFORE its outcome is known (RUSH-2418):
- * the launcher marks the attempt, then replaces the provisional reason with the
- * real one if it fails outright. Calling `recordSubsystemError` a second time
- * would count one failed start as two.
- *
- * Describing a failure that was never counted would be a lie in the other
- * direction — a `lastError` with `consecutiveFailures: 0` — so an unreported
- * subsystem is left alone rather than given a blank record to decorate.
- */
 export function recordSubsystemErrorReason(subsystem, error, at = new Date().toISOString()) {
     updateAll((all) => {
         const existing = all[subsystem];
@@ -120,21 +65,13 @@ export function recordSubsystemErrorReason(subsystem, error, at = new Date().toI
         all[subsystem] = { ...existing, lastError: error, lastErrorAt: at };
     });
 }
-/**
- * Record a `ServiceSupervisor` lifecycle-state transition, without touching
- * the ok/error streak. Cross-process readers (`agents daemon services`) have
- * no other way to see `stopped`/`idle` vs `running` — `agents daemon
- * status` runs as a separate process from the daemon (see module docblock).
- */
 export function recordSubsystemState(subsystem, state) {
     updateAll((all) => {
         const existing = all[subsystem] ?? blankRecord(subsystem);
         all[subsystem] = { ...existing, subsystem, state };
     });
 }
-// ─── Supervised-restart ledger (PHNX-4116) ────────────────────────────────────
 const RESTARTS_FILE = 'restarts.json';
-/** Bound so a crash loop cannot grow the ledger file without limit. */
 const MAX_RESTART_RECORDS = 200;
 function getRestartsPath() {
     return path.join(getDaemonDir(), RESTARTS_FILE);
@@ -148,13 +85,6 @@ function readRestarts() {
         return [];
     }
 }
-/**
- * Append a supervised-restart record and flush it to disk SYNCHRONOUSLY. The
- * caller is `ServiceSupervisor.exitForRestart`, which calls `process.exit`
- * immediately after, so the write must be durable before the process dies.
- * Never throws (same contract as the health file above) — a dropped ledger entry
- * must not keep the process from exiting for its restart.
- */
 export function recordDaemonRestart(subsystem, cause, at = new Date().toISOString()) {
     try {
         const restartsPath = getRestartsPath();
@@ -166,23 +96,20 @@ export function recordDaemonRestart(subsystem, cause, at = new Date().toISOStrin
             try {
                 fs.chmodSync(restartsPath, 0o600);
             }
-            catch { /* best effort */ }
+            catch { }
         });
     }
-    catch { /* a dropped restart record must never block the exit-for-restart */ }
+    catch { }
 }
-/** Every supervised restart recorded at or after `sinceMs`, oldest first. */
 export function readRecentDaemonRestarts(sinceMs) {
     return readRestarts().filter((r) => {
         const t = Date.parse(r.at);
         return Number.isFinite(t) && t >= sinceMs;
     });
 }
-/** Read one subsystem's health record, or null if it has never reported in. */
 export function readSubsystemHealth(subsystem) {
     return readAll()[subsystem] ?? null;
 }
-/** Read every subsystem's health record, sorted by subsystem name. */
 export function readAllSubsystemHealth() {
     return Object.values(readAll()).sort((a, b) => a.subsystem.localeCompare(b.subsystem));
 }

package/dist/lib/daemon-services.d.ts

@@ -1,58 +1,22 @@
-/**
- * Daemon service catalog + persistent toggle config.
- *
- * Defines the services the daemon hosts, loads their on/off state from
- * ~/.agents/daemon/services.yaml, and exposes lightweight helpers so both the
- * daemon and service clients (e.g. secrets) can check whether a service is
- * enabled without pulling in the whole daemon lifecycle.
- */
-/** Every service the daemon can host. IDs are kebab-case and stable. */
 export type DaemonServiceId = 'scheduler' | 'catchup' | 'monitors' | 'webhook-receiver' | 'self-heal' | 'self-update' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'session-title' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'session-state' | 'feed-stream' | 'session-summarizer' | 'attention-notify' | 'harness-update';
-/** Human-readable metadata for each service. */
 interface DaemonServiceDef {
     id: DaemonServiceId;
     title: string;
     description: string;
 }
 export declare const DAEMON_SERVICES: DaemonServiceDef[];
-/** Stable order of service IDs. */
 export declare const DAEMON_SERVICE_IDS: DaemonServiceId[];
-/** Persistent service toggles. */
 export interface DaemonServicesConfig {
     services: Record<DaemonServiceId, boolean>;
 }
-/** Path to ~/.agents/daemon/services.yaml. */
 export declare function getDaemonServicesConfigPath(): string;
-/**
- * Read the services config from disk. Missing or malformed files return the
- * default (all services enabled). Never throws.
- */
 export declare function readDaemonServicesConfig(): DaemonServicesConfig;
-/**
- * Write the services config to disk, creating the daemon config dir if needed.
- * Preserves unknown keys/ordering in the existing file when possible.
- */
 export declare function writeDaemonServicesConfig(cfg: DaemonServicesConfig): void;
-/**
- * Check whether a single service is enabled. Returns true (enabled) when the
- * config file is missing or the ID is unknown, so disabling must be explicit.
- */
 export declare function isDaemonServiceEnabled(id: DaemonServiceId): boolean;
-/**
- * Toggle one service and persist. Returns the new config.
- */
 export declare function setDaemonServiceEnabled(id: DaemonServiceId, enabled: boolean): DaemonServicesConfig;
-/**
- * List every known service with its current enabled state and metadata.
- */
 export declare function listDaemonServiceStates(): Array<DaemonServiceDef & {
     enabled: boolean;
 }>;
-/** Queue a live restart for `id`, to be picked up on the next SIGHUP reload. */
 export declare function queueDaemonServiceRestart(id: DaemonServiceId): void;
-/**
- * Drain every queued restart request. Called once per SIGHUP reload by the
- * daemon; never throws. Clears the file so a request is applied at most once.
- */
 export declare function drainDaemonServiceRestartQueue(): DaemonServiceId[];
 export {};

package/dist/lib/daemon-services.js

@@ -1,11 +1,3 @@
-/**
- * Daemon service catalog + persistent toggle config.
- *
- * Defines the services the daemon hosts, loads their on/off state from
- * ~/.agents/daemon/services.yaml, and exposes lightweight helpers so both the
- * daemon and service clients (e.g. secrets) can check whether a service is
- * enabled without pulling in the whole daemon lifecycle.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
@@ -123,7 +115,6 @@ export const DAEMON_SERVICES = [
         description: 'Moves eligible, non-pinned npm-package harness installations (Claude, Codex, …) to their latest release via a bounded child process, subject to updates.auto / updates.<agent>.auto and each installation\'s own update policy (PHNX-3940).',
     },
 ];
-/** Stable order of service IDs. */
 export const DAEMON_SERVICE_IDS = DAEMON_SERVICES.map((s) => s.id);
 function defaultServicesConfig() {
     const services = {};
@@ -131,14 +122,9 @@ function defaultServicesConfig() {
         services[id] = true;
     return { services };
 }
-/** Path to ~/.agents/daemon/services.yaml. */
 export function getDaemonServicesConfigPath() {
     return path.join(getDaemonConfigDir(), 'services.yaml');
 }
-/**
- * Read the services config from disk. Missing or malformed files return the
- * default (all services enabled). Never throws.
- */
 export function readDaemonServicesConfig() {
     const cfg = defaultServicesConfig();
     try {
@@ -153,19 +139,13 @@ export function readDaemonServicesConfig() {
         }
     }
     catch {
-        // Missing or corrupt -> defaults.
     }
     return cfg;
 }
-/**
- * Write the services config to disk, creating the daemon config dir if needed.
- * Preserves unknown keys/ordering in the existing file when possible.
- */
 export function writeDaemonServicesConfig(cfg) {
     const dir = getDaemonConfigDir();
     fs.mkdirSync(dir, { recursive: true });
     const filePath = getDaemonServicesConfigPath();
-    // Preserve any extra top-level fields the user may have added.
     let preserved = {};
     try {
         const raw = fs.readFileSync(filePath, 'utf-8');
@@ -174,7 +154,6 @@ export function writeDaemonServicesConfig(cfg) {
             preserved = parsed;
     }
     catch {
-        // ignore
     }
     const services = {};
     for (const id of DAEMON_SERVICE_IDS)
@@ -182,40 +161,22 @@ export function writeDaemonServicesConfig(cfg) {
     const out = yaml.stringify({ ...preserved, services }, { sortMapEntries: false });
     atomicWriteFileSync(filePath, out, 'utf-8');
 }
-/**
- * Check whether a single service is enabled. Returns true (enabled) when the
- * config file is missing or the ID is unknown, so disabling must be explicit.
- */
 export function isDaemonServiceEnabled(id) {
     return readDaemonServicesConfig().services[id] !== false;
 }
-/**
- * Toggle one service and persist. Returns the new config.
- */
 export function setDaemonServiceEnabled(id, enabled) {
     const cfg = readDaemonServicesConfig();
     cfg.services[id] = enabled;
     writeDaemonServicesConfig(cfg);
     return cfg;
 }
-/**
- * List every known service with its current enabled state and metadata.
- */
 export function listDaemonServiceStates() {
     const cfg = readDaemonServicesConfig();
     return DAEMON_SERVICES.map((s) => ({ ...s, enabled: cfg.services[s.id] !== false }));
 }
-/**
- * A tiny cross-process action queue for `agents daemon services restart <id>`
- * (RUSH-3193 P4) — SIGHUP can only signal "reload", it carries no payload, so a
- * restart request is dropped here first and the daemon's reload handler drains
- * it. Same file-backed pattern as `services.yaml` above, for the same reason:
- * the CLI invocation and the daemon are separate processes.
- */
 function getDaemonServiceActionsPath() {
     return path.join(getDaemonConfigDir(), 'service-actions.json');
 }
-/** Queue a live restart for `id`, to be picked up on the next SIGHUP reload. */
 export function queueDaemonServiceRestart(id) {
     const filePath = getDaemonServiceActionsPath();
     let ids = [];
@@ -225,17 +186,12 @@ export function queueDaemonServiceRestart(id) {
             ids = parsed.restart;
     }
     catch {
-        // Missing or corrupt -> start a fresh queue.
     }
     if (!ids.includes(id))
         ids.push(id);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     atomicWriteFileSync(filePath, JSON.stringify({ restart: ids }), 'utf-8');
 }
-/**
- * Drain every queued restart request. Called once per SIGHUP reload by the
- * daemon; never throws. Clears the file so a request is applied at most once.
- */
 export function drainDaemonServiceRestartQueue() {
     const filePath = getDaemonServiceActionsPath();
     let ids = [];
@@ -251,7 +207,6 @@ export function drainDaemonServiceRestartQueue() {
         fs.unlinkSync(filePath);
     }
     catch {
-        // Already gone.
     }
     return ids;
 }