@phnx-labs/agents-cli 1.22.66 → 1.22.68

package/dist/lib/daemon-health.js

@@ -23,6 +23,7 @@
 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';
 /** Stable subsystem identifiers shared by the daemon (writer) and `agents daemon` (reader). */
 export const SUBSYSTEM_SECRETS_BROKER = 'secrets-broker';
@@ -61,15 +62,19 @@ function readAll() {
  * dropped health update, never escape as an unhandled rejection that would
  * hit the process-wide handler and take down every OTHER service too.
  */
-function writeAll(records) {
+function updateAll(update) {
     try {
         const healthPath = getHealthPath();
-        fs.mkdirSync(path.dirname(healthPath), { recursive: true });
-        fs.writeFileSync(healthPath, JSON.stringify(records), 'utf-8');
-        try {
-            fs.chmodSync(healthPath, 0o600);
-        }
-        catch { /* best effort */ }
+        ensureLockTarget(healthPath, '{}');
+        withFileLock(healthPath, () => {
+            const records = readAll();
+            update(records);
+            atomicWriteFileSync(healthPath, JSON.stringify(records), { encoding: 'utf-8', mode: 0o600 });
+            try {
+                fs.chmodSync(healthPath, 0o600);
+            }
+            catch { /* best effort */ }
+        });
     }
     catch { /* see docblock above — health recording must never crash a caller */ }
 }
@@ -78,23 +83,23 @@ function blankRecord(subsystem) {
 }
 /** Record a successful subsystem check-in — clears the failure streak. */
 export function recordSubsystemOk(subsystem, at = new Date().toISOString()) {
-    const all = readAll();
-    const existing = all[subsystem] ?? blankRecord(subsystem);
-    all[subsystem] = { ...existing, subsystem, consecutiveFailures: 0, lastOkAt: at };
-    writeAll(all);
+    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()) {
-    const all = readAll();
-    const existing = all[subsystem] ?? blankRecord(subsystem);
-    all[subsystem] = {
-        ...existing,
-        subsystem,
-        lastError: error,
-        lastErrorAt: at,
-        consecutiveFailures: existing.consecutiveFailures + 1,
-    };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem] ?? blankRecord(subsystem);
+        all[subsystem] = {
+            ...existing,
+            subsystem,
+            lastError: error,
+            lastErrorAt: at,
+            consecutiveFailures: existing.consecutiveFailures + 1,
+        };
+    });
 }
 /**
  * Refine the reason on an already-counted failure, without bumping the streak.
@@ -109,12 +114,12 @@ export function recordSubsystemError(subsystem, error, at = new Date().toISOStri
  * subsystem is left alone rather than given a blank record to decorate.
  */
 export function recordSubsystemErrorReason(subsystem, error, at = new Date().toISOString()) {
-    const all = readAll();
-    const existing = all[subsystem];
-    if (!existing)
-        return;
-    all[subsystem] = { ...existing, lastError: error, lastErrorAt: at };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem];
+        if (!existing)
+            return;
+        all[subsystem] = { ...existing, lastError: error, lastErrorAt: at };
+    });
 }
 /**
  * Record a `ServiceSupervisor` lifecycle-state transition, without touching
@@ -123,10 +128,10 @@ export function recordSubsystemErrorReason(subsystem, error, at = new Date().toI
  * status` runs as a separate process from the daemon (see module docblock).
  */
 export function recordSubsystemState(subsystem, state) {
-    const all = readAll();
-    const existing = all[subsystem] ?? blankRecord(subsystem);
-    all[subsystem] = { ...existing, subsystem, state };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem] ?? blankRecord(subsystem);
+        all[subsystem] = { ...existing, subsystem, state };
+    });
 }
 /** Read one subsystem's health record, or null if it has never reported in. */
 export function readSubsystemHealth(subsystem) {

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

@@ -7,7 +7,7 @@
  * enabled without pulling in the whole daemon lifecycle.
  */
 /** Every service the daemon can host. IDs are kebab-case and stable. */
-export type DaemonServiceId = 'secrets-broker' | 'scheduler' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'keychain-reap' | 'account-state' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state';
+export type DaemonServiceId = 'secrets-broker' | 'scheduler' | 'catchup' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'keychain-reap' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state';
 /** Human-readable metadata for each service. */
 export interface DaemonServiceDef {
     id: DaemonServiceId;

package/dist/lib/daemon-services.js

@@ -22,6 +22,11 @@ export const DAEMON_SERVICES = [
         title: 'Routine scheduler',
         description: 'Fires cron-scheduled routines and catches up missed fires.',
     },
+    {
+        id: 'catchup',
+        title: 'Catch-up recovery',
+        description: 'Supervised pass that re-runs routines whose scheduled fire this device missed (sleep, wedge, or suspend). No-ops while the scheduler gate is off.',
+    },
     {
         id: 'monitors',
         title: 'Monitor engine',
@@ -49,8 +54,13 @@ export const DAEMON_SERVICES = [
     },
     {
         id: 'account-state',
-        title: 'Account state',
-        description: 'Refreshes account quota/usage and publishes the local fleet-status row.',
+        title: 'Account usage refresh',
+        description: 'Refreshes account quota/usage on its own tick (PHNX-3608: independent circuit breaker from account-auth).',
+    },
+    {
+        id: 'account-auth',
+        title: 'Account auth refresh',
+        description: 'Publishes this host\'s fleet-status row and refreshes auth health on its own slower tick (PHNX-3608: independent circuit breaker from account-state).',
     },
     {
         id: 'watchdog',

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

@@ -2,10 +2,12 @@
  * Daemon account-state tick bodies.
  *
  * These two bodies are the `refreshUsage` / `refreshAuth` implementations the
- * daemon's `account-state-service.ts` timers call directly, in-process, on a
- * plain `setInterval` (usage every 60s, auth every ~3 min). They are NOT
- * routines and are never fired through the scheduler — the daemon owns usage and
- * authentication health as first-party device state (RUSH-2451).
+ * supervised `AccountStateDaemonService` (daemon/account-state-daemon-service.ts)
+ * runs on its tick, in-process (usage every tick, auth on the slower ~3 min
+ * cadence). They are NOT routines and are never fired through the scheduler — the
+ * daemon owns usage and authentication health as first-party device state
+ * (RUSH-2451); the supervisor bounds each tick with a deadline + AbortSignal so a
+ * hung refresh is abandoned and restarted instead of latching (PHNX-3608).
  *
  * `refreshLocalFleetAuthState` is also called by `agents fleet`/`ssh` surfaces
  * that need a fresh local auth snapshot on demand; provider-level work is guarded
@@ -59,11 +61,12 @@ export declare function shouldReuseCachedAuthProbe(force: boolean, cached: AuthP
  */
 export declare function refreshLocalFleetAuthState(opts?: {
     force?: boolean;
+    signal?: AbortSignal;
 }): Promise<{
     row: FleetStatusRow;
     authRows: import('./auth-health.js').AuthProbeRow[];
 }>;
-export declare function runFleetCacheWarmTick(): Promise<void>;
+export declare function runFleetCacheWarmTick(signal?: AbortSignal): Promise<void>;
 /**
  * Usage refresh: keep the usage cache the `agents run` router reads
  * (RUSH-2061, readOnly hot path) fresh, WITHOUT the hot path ever fetching.
@@ -71,7 +74,7 @@ export declare function runFleetCacheWarmTick(): Promise<void>;
  * accounts it holds credentials for, straight from the provider APIs
  * (RUSH-3193 #15; no cross-host broadcast).
  */
-export declare function runUsageRefreshTick(): Promise<void>;
+export declare function runUsageRefreshTick(signal?: AbortSignal): Promise<void>;
 /**
  * Active-sessions warm (RUSH-2062 / RUSH-2484): publish THIS host's live session
  * rows so `agents sessions watch` (and the extension that tails it) receive

package/dist/lib/daemon-ticks.js

@@ -2,10 +2,12 @@
  * Daemon account-state tick bodies.
  *
  * These two bodies are the `refreshUsage` / `refreshAuth` implementations the
- * daemon's `account-state-service.ts` timers call directly, in-process, on a
- * plain `setInterval` (usage every 60s, auth every ~3 min). They are NOT
- * routines and are never fired through the scheduler — the daemon owns usage and
- * authentication health as first-party device state (RUSH-2451).
+ * supervised `AccountStateDaemonService` (daemon/account-state-daemon-service.ts)
+ * runs on its tick, in-process (usage every tick, auth on the slower ~3 min
+ * cadence). They are NOT routines and are never fired through the scheduler — the
+ * daemon owns usage and authentication health as first-party device state
+ * (RUSH-2451); the supervisor bounds each tick with a deadline + AbortSignal so a
+ * hung refresh is abandoned and restarted instead of latching (PHNX-3608).
  *
  * `refreshLocalFleetAuthState` is also called by `agents fleet`/`ssh` surfaces
  * that need a fresh local auth snapshot on demand; provider-level work is guarded
@@ -62,6 +64,7 @@ export function shouldReuseCachedAuthProbe(force, cached, now, maxAgeMs = AUTH_P
  */
 export async function refreshLocalFleetAuthState(opts) {
     const force = opts?.force === true;
+    const signal = opts?.signal;
     const { machineId } = await import('./machine-id.js');
     const { probeLocalFleetAuth, readFleetAuthRows, writeFleetAuthRows } = await import('./auth-health.js');
     const { getCliVersion } = await import('./version.js');
@@ -89,7 +92,7 @@ export async function refreshLocalFleetAuthState(opts) {
             // Fleet status publishes every tick regardless — it does not ride that endpoint.
             const cached = readFleetAuthRows(self);
             const reuse = shouldReuseCachedAuthProbe(force, cached, requestedAt);
-            const authRows = reuse ? cached : await probeLocalFleetAuth({ cliVersion: getCliVersion(), forceLive: force });
+            const authRows = reuse ? cached : await probeLocalFleetAuth({ cliVersion: getCliVersion(), forceLive: force, signal });
             if (!reuse)
                 writeFleetAuthRows(self, authRows);
             const row = await publishLocalFleetStatus(self);
@@ -97,8 +100,8 @@ export async function refreshLocalFleetAuthState(opts) {
         },
     });
 }
-export async function runFleetCacheWarmTick() {
-    const result = await refreshLocalFleetAuthState();
+export async function runFleetCacheWarmTick(signal) {
+    const result = await refreshLocalFleetAuthState({ signal });
     // A waiter receives the already-published fleet row. The auth-row count is
     // available only to the process that performed the provider probes.
     const row = result.row;
@@ -112,7 +115,7 @@ export async function runFleetCacheWarmTick() {
  * accounts it holds credentials for, straight from the provider APIs
  * (RUSH-3193 #15; no cross-host broadcast).
  */
-export async function runUsageRefreshTick() {
+export async function runUsageRefreshTick(signal) {
     const { runUsageRefresh, buildLocalUsageAccounts } = await import('./usage-refresh.js');
     const { writeClaudeUsageCache, readClaudeUsageCache } = await import('./accounting/usage.js');
     const { usageRateLimitedUntil } = await import('./usage-backoff.js');
@@ -124,6 +127,9 @@ export async function runUsageRefreshTick() {
         // so a recent capture means the account is already fresh at zero API cost —
         // the refresher re-derives headroom from it and skips the API fetch.
         readCachedSnapshot: (usageKey) => readClaudeUsageCache(usageKey),
+        // Thread the supervisor deadline into each provider fetch so the tick's I/O
+        // is bounded by deadlineMs, not just each fetch's own 5s timeout (PHNX-3608).
+        signal,
     });
     const { listProfiles } = await import('./profiles.js');
     const { refreshDueByokUsage } = await import('./byok-usage.js');

package/dist/lib/devices/registry.js

@@ -21,6 +21,7 @@ import { getDevicesRegistryPath, readMeta, updateMeta } from '../state.js';
 import { atomicWriteJsonSync } from '../fs-atomic.js';
 import { machineId } from '../machine-id.js';
 import { addIgnoredEntry, unionDeviceIgnored } from './device-docs.js';
+import { logAndContinueOnLockCompromised } from '../lock-compromise.js';
 /**
  * Whether a fan-out should dial this device, honouring the preference stated on
  * {@link DeviceProfile.reachability}: the live SSH probe wins over the cached
@@ -141,6 +142,7 @@ async function withRegistryLock(p, fn) {
     const release = await lockfile.lock(p, {
         retries: { retries: 60, minTimeout: 25, maxTimeout: 250, factor: 1.5 },
         stale: 10_000,
+        onCompromised: logAndContinueOnLockCompromised('devices registry'),
     });
     try {
         return await fn();

package/dist/lib/exec.js

@@ -409,6 +409,17 @@ export function buildExecEnv(options) {
     // re-parsing harness-specific transcripts.
     result.AGENTS_RUN_MODE = resolveHeadlessMode(options.agent, normalizeMode(options.mode), resolveInteractive(options), options.modeWarningContext, options.modeWarningState);
     result.AGENTS_HISTORY_DIR = getHistoryDir();
+    // Durable origin version for a later native resume. The SessionStart hook joins
+    // this to the harness's real session id (like AGENTS_RUN_MODE), so recovery can
+    // pin the exact origin version even when the transcript carries no derivable one
+    // (codex's `.codex-homes/<version>/` home) — the "version not recorded" fallback
+    // to `/continue` this closes (PHNX-3626). Resolve the concrete version-home id
+    // the same way the spawn path does; only stamp a real one.
+    if (options.agent) {
+        const runVersion = options.version ?? resolveVersion(options.agent, options.cwd || process.cwd());
+        if (runVersion)
+            result.AGENTS_RUN_VERSION = runVersion;
+    }
     // So activity / feed posts stamp the right harness without re-detecting.
     // A custom-harness run (`agents run deepseek`) must stamp the PROFILE name,
     // not the host CLI (`claude`) — otherwise sessions and feed posts cannot

package/dist/lib/feed/watch.d.ts

@@ -18,6 +18,9 @@ export type FeedWatchEnvelope = Base & {
     type: 'agent.upsert';
     rowKey: string;
     agent: SessionWatchRow;
+} | Base & {
+    type: 'agent.remove';
+    rowKey: string;
 } | Base & {
     type: 'attention.upsert';
     rowKey: string;

package/dist/lib/feed/watch.js

@@ -21,13 +21,20 @@ export class FeedWatchState {
     }
 }
 async function attentionFor(agent) {
-    if (!agent.sessionId)
+    // Durable Previous rows share the operator stream for Sessions history, but
+    // they are not live work and must never synthesize Needs-you attention.
+    if (!agent.sessionId || agent.previous || agent.context === 'recent')
         return undefined;
     const blockId = blockIdForSession(agent.sessionId);
     // ActiveSession.host names the terminal app; the feed contract's host is the
     // device scope. Normalize only the reconciler input so lifecycle/PR keys are
     // routable across the fleet while the projected agent row stays compatible.
-    const session = { ...agent, host: agent.sourceDevice, viewingIn: undefined };
+    const session = {
+        ...agent,
+        context: agent.context,
+        host: agent.sourceDevice,
+        viewingIn: undefined,
+    };
     return reconcileAttention({
         block: readBlock(blockId), session,
         resolution: readResolution(blockId),
@@ -49,7 +56,10 @@ export async function projectSessionEnvelope(event, state) {
         ];
     }
     if (event.type === 'remove')
-        return [state.emit({ type: 'attention.remove', scope: event.scope, rowKey: event.rowKey })];
+        return [
+            state.emit({ type: 'agent.remove', scope: event.scope, rowKey: event.rowKey }),
+            state.emit({ type: 'attention.remove', scope: event.scope, rowKey: event.rowKey }),
+        ];
     if (event.type === 'scope')
         return [state.emit({ type: 'scope', capturedAt: event.capturedAt, scope: event.scope, status: event.status, ...(event.reason ? { reason: event.reason } : {}) })];
     return [state.emit({ type: 'heartbeat', capturedAt: event.capturedAt, scope: event.scope })];

package/dist/lib/fleet-shared-repo-sync.d.ts

@@ -0,0 +1,36 @@
+export declare const FLEET_SHARED_REPO_SYNC_DEADLINE_MS = 45000;
+export declare const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
+export interface BoundedProcessResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+export interface FleetSharedRepoSyncOptions {
+    userAgentsDir?: string;
+    device?: string;
+    timeoutMs?: number;
+    /** Test-only redirection for the untracked cross-process lock target. */
+    lockPath?: string;
+}
+export interface FleetSharedRepoSyncResult {
+    success: boolean;
+    committed: boolean;
+    pushed: boolean;
+    commit: string | null;
+    timedOut: boolean;
+    skipped: string | null;
+    error: string | null;
+}
+/** Run one real process asynchronously with a hard wall-clock/process-tree bound. */
+export declare function runBoundedProcess(command: string, args: string[], options: {
+    cwd: string;
+    timeoutMs: number;
+    env?: NodeJS.ProcessEnv;
+}): Promise<BoundedProcessResult>;
+/**
+ * Commit/pull/push this device's shared state under one cross-process lock.
+ * Callers publish their local fields first and consume peer fields only after
+ * this resolves successfully.
+ */
+export declare function syncFleetSharedStateRepo(options?: FleetSharedRepoSyncOptions): Promise<FleetSharedRepoSyncResult>;