@phnx-labs/agents-cli 1.22.69 → 1.22.71

package/dist/lib/device-config.d.ts

@@ -113,6 +113,16 @@ export declare function readFleetConfigDefaults(): Record<string, unknown>;
 export declare function readDeviceConfigValues(device: string): Record<string, unknown>;
 /** Get one config key's effective value and the layer that set it. */
 export declare function getConfigValue(name: string, opts?: ConfigTarget): ConfigEntry;
+/**
+ * Async, non-blocking twin of {@link getConfigValue} for the daemon's tick paths
+ * (PHNX-3695) — e.g. the watchdog tick reading `watchdog.enabled` every ~3min.
+ * Same layer precedence (device doc → fleet defaults → default), but the
+ * per-device doc READ is async. The user/fleet layers go through `readMeta`,
+ * which serves from an mtime-stamped in-memory cache (≈ 2 stat syscalls on the
+ * hot path, no file read), and `ensureDeviceConfigMigrated` is a one-shot no-op
+ * after the first process-wide fold — neither blocks the loop meaningfully.
+ */
+export declare function getConfigValueAsync(name: string, opts?: ConfigTarget): Promise<ConfigEntry>;
 /**
  * List every known key with its effective value and the layer that set it.
  *
@@ -250,7 +260,8 @@ export declare function assertDaemonEnabled(): void;
  * minutes. Read by the daemon's periodic tick and, as the fallback when a
  * caller omits `--idle-minutes`, by the `gc` IPC action.
  */
-export declare function resolveBrowserTaskIdleMs(): number | null;
+/** Async so the daemon's browser-task-reap tick reads the config off the shared event loop (PHNX-3695). */
+export declare function resolveBrowserTaskIdleMs(): Promise<number | null>;
 /**
  * Read the effective `agents.max-concurrent` cap for each named device (fleet
  * defaults layered under the per-device doc; no SSH). Devices without a cap

package/dist/lib/device-config.js

@@ -31,6 +31,7 @@
  * Unset always means today's behavior (the documented default).
  */
 import * as fs from 'fs';
+import * as fsp from 'fs/promises';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { META_HEADER, getUserAgentsDir, readMeta, updateMeta, withMetaLock } from './state.js';
@@ -372,17 +373,8 @@ function deviceDocPath(device) {
  * file is a hard error — silently returning null would let the next write wipe
  * the device's routines/config (same contract as routine-activation's reader).
  */
-function readDeviceDoc(device) {
-    const p = deviceDocPath(device);
-    let raw;
-    try {
-        raw = fs.readFileSync(p, 'utf-8');
-    }
-    catch (err) {
-        if (err && err.code === 'ENOENT')
-            return null;
-        throw err;
-    }
+/** Parse + validate a device doc's raw YAML. Shared by the sync and async readers. */
+function parseDeviceDoc(raw, p) {
     const corrupted = (detail) => new Error(`Device config corrupted at ${p}: ${detail}. Inspect and restore from backup.`);
     let parsed;
     try {
@@ -402,6 +394,33 @@ function readDeviceDoc(device) {
     }
     return doc;
 }
+function readDeviceDoc(device) {
+    const p = deviceDocPath(device);
+    let raw;
+    try {
+        raw = fs.readFileSync(p, 'utf-8');
+    }
+    catch (err) {
+        if (err && err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+    return parseDeviceDoc(raw, p);
+}
+/** Async twin of {@link readDeviceDoc} for the daemon's tick paths (PHNX-3695) — the device-doc read must not block the shared event loop. */
+async function readDeviceDocAsync(device) {
+    const p = deviceDocPath(device);
+    let raw;
+    try {
+        raw = await fsp.readFile(p, 'utf-8');
+    }
+    catch (err) {
+        if (err && err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+    return parseDeviceDoc(raw, p);
+}
 /** Write a device doc (atomic), preserving keys this module does not own
  * (`routines:`). A doc left empty is removed instead of leaving an empty
  * tracked file behind. */
@@ -476,6 +495,36 @@ export function getConfigValue(name, opts) {
         return { spec, value: fleetConfig[spec.yamlKey], source: 'fleet' };
     return { spec, value: undefined, source: 'default' };
 }
+/**
+ * Async, non-blocking twin of {@link getConfigValue} for the daemon's tick paths
+ * (PHNX-3695) — e.g. the watchdog tick reading `watchdog.enabled` every ~3min.
+ * Same layer precedence (device doc → fleet defaults → default), but the
+ * per-device doc READ is async. The user/fleet layers go through `readMeta`,
+ * which serves from an mtime-stamped in-memory cache (≈ 2 stat syscalls on the
+ * hot path, no file read), and `ensureDeviceConfigMigrated` is a one-shot no-op
+ * after the first process-wide fold — neither blocks the loop meaningfully.
+ */
+export async function getConfigValueAsync(name, opts) {
+    ensureDeviceConfigMigrated();
+    const spec = configKeySpec(name);
+    if (spec.scope === 'user') {
+        const value = readMeta().config?.[spec.yamlKey];
+        return { spec, value, source: value !== undefined ? 'user' : 'default' };
+    }
+    if (opts?.fleet) {
+        const value = readFleetConfigDefaults()[spec.yamlKey];
+        return { spec, value, source: value !== undefined ? 'fleet' : 'default' };
+    }
+    const device = targetDevice(opts);
+    assertLocalTarget(spec, device);
+    const docConfig = (await readDeviceDocAsync(device))?.config ?? {};
+    if (spec.yamlKey in docConfig)
+        return { spec, value: docConfig[spec.yamlKey], source: 'device' };
+    const fleetConfig = readFleetConfigDefaults();
+    if (spec.yamlKey in fleetConfig)
+        return { spec, value: fleetConfig[spec.yamlKey], source: 'fleet' };
+    return { spec, value: undefined, source: 'default' };
+}
 /**
  * List every known key with its effective value and the layer that set it.
  *
@@ -844,8 +893,9 @@ export function assertDaemonEnabled() {
  * minutes. Read by the daemon's periodic tick and, as the fallback when a
  * caller omits `--idle-minutes`, by the `gc` IPC action.
  */
-export function resolveBrowserTaskIdleMs() {
-    const minutes = getConfigValue('browser.task-idle-minutes').value ?? 30;
+/** Async so the daemon's browser-task-reap tick reads the config off the shared event loop (PHNX-3695). */
+export async function resolveBrowserTaskIdleMs() {
+    const minutes = (await getConfigValueAsync('browser.task-idle-minutes')).value ?? 30;
     return minutes === 0 ? null : minutes * 60_000;
 }
 /**

package/dist/lib/exec-bounded.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Async, deadline-bounded, process-group-killable subprocess exec (PHNX-3695).
+ *
+ * The daemon runs every background service on ONE Node event loop. A
+ * synchronous `execFileSync`/`spawnSync` on a service tick blocks that loop for
+ * the whole life of the child — and while it is blocked NOTHING else on the loop
+ * runs, including the supervisor's per-tick deadline timer and the browser IPC
+ * server's socket handlers. That is the wedge PHNX-3411 fixed the *symptom* of:
+ * the browser `version` probe (a trivial synchronous handler) "accepts but never
+ * replies" because the loop that would reply is frozen inside a sync spawn.
+ *
+ * `execFileBounded` is the non-blocking replacement for those tick-path spawns.
+ * It spawns with async `child_process.spawn`, so the event loop keeps serving
+ * other work while the child runs, and it bounds the child two ways:
+ *
+ *  - a `timeoutMs` deadline: on expiry it SIGTERMs the child, then SIGKILLs it
+ *    after {@link KILL_GRACE_MS} if it ignored the term — the same escalation
+ *    `sshExecAsync` uses (ssh-exec.ts).
+ *  - a process GROUP kill: the child is spawned as its own group leader
+ *    (`detached` on POSIX) so the signal reaches the whole subtree, not just the
+ *    direct child. A bare `child.kill()` would leave grandchildren running — the
+ *    orphaned-`ps`/`powershell` leak class. Windows uses `taskkill /T`.
+ *
+ * It never throws for a non-zero exit, a signal, or a spawn error: every outcome
+ * is reported in the returned {@link BoundedExecResult} so a caller on a tick
+ * path can branch on it instead of wrapping every call in try/catch.
+ */
+/** Grace between SIGTERM and SIGKILL for a child that overran its deadline. */
+export declare const KILL_GRACE_MS = 250;
+export interface ExecFileBoundedOptions {
+    /** Hard wall-clock cap. On expiry the child's process group is SIGTERMed, then SIGKILLed after {@link KILL_GRACE_MS}. Required — an unbounded tick-path spawn is the bug this helper exists to prevent. */
+    timeoutMs: number;
+    /** Working directory for the child. */
+    cwd?: string;
+    /** Environment for the child (defaults to the current process env). */
+    env?: NodeJS.ProcessEnv;
+    /** Optional stdin to write to the child. */
+    input?: string;
+}
+export interface BoundedExecResult {
+    stdout: string;
+    stderr: string;
+    /** Exit code, or null when the process was killed by a signal (including our timeout kill) or never spawned. */
+    code: number | null;
+    /** True when the deadline elapsed and we killed the child, distinguishing a timeout from an ordinary non-zero exit. */
+    timedOut: boolean;
+}
+/**
+ * Run `file args` with a hard deadline, killing the whole process group on
+ * timeout. Resolves (never rejects) with the captured output and outcome.
+ */
+export declare function execFileBounded(file: string, args: string[], opts: ExecFileBoundedOptions): Promise<BoundedExecResult>;

package/dist/lib/exec-bounded.js

@@ -0,0 +1,113 @@
+/**
+ * Async, deadline-bounded, process-group-killable subprocess exec (PHNX-3695).
+ *
+ * The daemon runs every background service on ONE Node event loop. A
+ * synchronous `execFileSync`/`spawnSync` on a service tick blocks that loop for
+ * the whole life of the child — and while it is blocked NOTHING else on the loop
+ * runs, including the supervisor's per-tick deadline timer and the browser IPC
+ * server's socket handlers. That is the wedge PHNX-3411 fixed the *symptom* of:
+ * the browser `version` probe (a trivial synchronous handler) "accepts but never
+ * replies" because the loop that would reply is frozen inside a sync spawn.
+ *
+ * `execFileBounded` is the non-blocking replacement for those tick-path spawns.
+ * It spawns with async `child_process.spawn`, so the event loop keeps serving
+ * other work while the child runs, and it bounds the child two ways:
+ *
+ *  - a `timeoutMs` deadline: on expiry it SIGTERMs the child, then SIGKILLs it
+ *    after {@link KILL_GRACE_MS} if it ignored the term — the same escalation
+ *    `sshExecAsync` uses (ssh-exec.ts).
+ *  - a process GROUP kill: the child is spawned as its own group leader
+ *    (`detached` on POSIX) so the signal reaches the whole subtree, not just the
+ *    direct child. A bare `child.kill()` would leave grandchildren running — the
+ *    orphaned-`ps`/`powershell` leak class. Windows uses `taskkill /T`.
+ *
+ * It never throws for a non-zero exit, a signal, or a spawn error: every outcome
+ * is reported in the returned {@link BoundedExecResult} so a caller on a tick
+ * path can branch on it instead of wrapping every call in try/catch.
+ */
+import { spawn } from 'child_process';
+/** Grace between SIGTERM and SIGKILL for a child that overran its deadline. */
+export const KILL_GRACE_MS = 250;
+/**
+ * Run `file args` with a hard deadline, killing the whole process group on
+ * timeout. Resolves (never rejects) with the captured output and outcome.
+ */
+export function execFileBounded(file, args, opts) {
+    const isWin = process.platform === 'win32';
+    return new Promise((resolve) => {
+        const child = spawn(file, args, {
+            cwd: opts.cwd,
+            env: opts.env ?? process.env,
+            // POSIX: lead a new process group so a timeout kill(-pid) reaches the
+            // whole subtree, not just the direct child. Windows has no process
+            // groups here — taskkill /T handles the tree instead.
+            detached: !isWin,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        let killTimer = null;
+        // Signal the whole group on POSIX (negative pid); on Windows tear the tree
+        // down with taskkill. Best-effort — an already-dead child is fine.
+        const killGroup = (signal) => {
+            if (child.pid === undefined)
+                return;
+            try {
+                if (isWin) {
+                    // taskkill is itself a child; spawn it detached and forget it.
+                    spawn('taskkill', ['/F', '/T', '/PID', String(child.pid)], { stdio: 'ignore', windowsHide: true }).on('error', () => { });
+                }
+                else {
+                    process.kill(-child.pid, signal);
+                }
+            }
+            catch { /* group already gone */ }
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killGroup('SIGTERM');
+            // SIGTERM is advisory; a wedged child can ignore it and keep the Promise
+            // (and the caller's tick) pending forever. Enforce a hard SIGKILL bound.
+            killTimer = setTimeout(() => {
+                if (!settled)
+                    killGroup('SIGKILL');
+            }, KILL_GRACE_MS);
+            killTimer.unref?.();
+        }, opts.timeoutMs);
+        timer.unref?.();
+        const clearTimers = () => {
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+        };
+        child.stdout?.setEncoding('utf-8');
+        child.stderr?.setEncoding('utf-8');
+        child.stdout?.on('data', (chunk) => { stdout += chunk; });
+        child.stderr?.on('data', (chunk) => { stderr += chunk; });
+        // A child that closes stdin early makes end()/write emit EPIPE; with no
+        // listener Node escalates it to an uncaught exception. Swallow it — the real
+        // outcome is still reported by 'close'/'error' below.
+        child.stdin?.on('error', () => { });
+        if (opts.input !== undefined)
+            child.stdin?.end(opts.input);
+        else
+            child.stdin?.end();
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            resolve({ code: null, stdout, stderr: stderr + err.message, timedOut });
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            resolve({ code, stdout, stderr, timedOut });
+        });
+    });
+}

package/dist/lib/exec.d.ts

@@ -44,7 +44,7 @@ export declare function headlessPlanStallCommand(args: {
  *   (every agent supports edit-like behavior as its default).
  * - `plan` on an agent without a read-only mode degrades to the agent's
  *   safest native mode (`capabilities.modes[0]`, typically `edit`). Agents
- *   like antigravity/kiro have no plan flag; hard-failing made
+ *   like antigravity have no plan flag; hard-failing made
  *   multi-agent scripts (`--mode plan` for everyone) unusable and diverged
  *   from `agents teams add`, which already defaults to `edit`. Callers that
  *   care (the `agents run` CLI) must surface a warning when requested ≠
@@ -64,7 +64,7 @@ export declare function resolveMode(agent: AgentId, requested: Mode): Mode;
  * its ExitPlanMode gate. For those agents, a headless plan request degrades to
  * `auto` (kimi -p auto-runs; grok maps auto→edit via resolveMode) with a visible
  * one-line stderr warning, mirroring the graceful plan→edit degrade antigravity
- * and kiro get for having no plan flag at all. Interactive runs are never
+ * get for having no plan flag at all. Interactive runs are never
  * downgraded. This is the single source of truth shared by buildExecCommand
  * (agents run / teams) and the routine runner.
  */

package/dist/lib/exec.js

@@ -96,7 +96,7 @@ export function headlessPlanStallCommand(args) {
  *   (every agent supports edit-like behavior as its default).
  * - `plan` on an agent without a read-only mode degrades to the agent's
  *   safest native mode (`capabilities.modes[0]`, typically `edit`). Agents
- *   like antigravity/kiro have no plan flag; hard-failing made
+ *   like antigravity have no plan flag; hard-failing made
  *   multi-agent scripts (`--mode plan` for everyone) unusable and diverged
  *   from `agents teams add`, which already defaults to `edit`. Callers that
  *   care (the `agents run` CLI) must surface a warning when requested ≠
@@ -116,7 +116,7 @@ export function resolveMode(agent, requested) {
     }
     if (requested === 'plan') {
         // No read-only mode on this agent. modes[0] is the declared safest mode
-        // (edit for antigravity/kiro/…). Prefer that over hard-fail so
+        // (edit for antigravity/…). Prefer that over hard-fail so
         // uniform multi-agent `--mode plan` dispatches still run.
         return supported[0];
     }
@@ -132,7 +132,7 @@ export function resolveMode(agent, requested) {
  * its ExitPlanMode gate. For those agents, a headless plan request degrades to
  * `auto` (kimi -p auto-runs; grok maps auto→edit via resolveMode) with a visible
  * one-line stderr warning, mirroring the graceful plan→edit degrade antigravity
- * and kiro get for having no plan flag at all. Interactive runs are never
+ * get for having no plan flag at all. Interactive runs are never
  * downgraded. This is the single source of truth shared by buildExecCommand
  * (agents run / teams) and the routine runner.
  */
@@ -522,25 +522,6 @@ export const AGENT_COMMANDS = {
         jsonFlags: ['--format', 'json'],
         modelFlag: '--model',
     },
-    // Oh My Pi (`omp`). Headless is the positional MESSAGES arg + `-p/--print`.
-    // Approval modes map to omp's `--approval-mode`: always-ask (read-only tools
-    // auto-approved, writes gated -> our `plan`), write (read + workspace writes
-    // auto-approved -> `edit`), yolo (all tiers auto-approved -> `skip`). JSON is
-    // omp's `--mode json` event stream. `--model` fuzzy-matches a provider/model
-    // selector. Native resume is `-r/--resume <id-prefix>`.
-    pi: {
-        base: ['omp'],
-        promptFlag: 'positional',
-        modeFlags: {
-            plan: ['--approval-mode', 'always-ask'],
-            edit: ['--approval-mode', 'write'],
-            skip: ['--approval-mode', 'yolo'],
-        },
-        jsonFlags: ['--mode', 'json'],
-        modelFlag: '--model',
-        printFlags: ['-p'],
-        resume: { flag: '--resume' },
-    },
     openclaw: {
         base: ['openclaw'],
         promptFlag: 'positional',
@@ -584,18 +565,6 @@ export const AGENT_COMMANDS = {
         },
         modelFlag: '--model',
     },
-    kiro: {
-        // Standalone hooks live under ~/.kiro/hooks/*.json and only fire on the
-        // v3 engine (opt-in via --v3; see https://kiro.dev/docs/cli/v3/hooks/).
-        // Without this flag agents-cli would write v3 hook files that never run.
-        base: ['kiro-cli', '--v3'],
-        promptFlag: 'positional',
-        modeFlags: {
-            // kiro-cli has no permission flags — edit is the default behavior.
-            edit: [],
-        },
-        modelFlag: '--model',
-    },
     goose: {
         base: ['goose', 'run'],
         promptFlag: 'positional',

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

@@ -110,21 +110,21 @@ export interface CallerIdentity {
 }
 /** Identify the environment that invoked agents-cli, not the source callsite. */
 export declare function detectCaller(env?: NodeJS.ProcessEnv, stdoutIsTTY?: boolean): CallerIdentity;
-/**
- * Emit a structured event to the append-only audit log.
- *
- * @param event - The event type
- * @param payload - Event-specific data (agent, version, cwd, etc.)
- * @param overrides - Envelope fields the CALLER owns rather than the writer.
- *   Only `ts` today: a batched out-of-process producer (`agents events emit`)
- *   records when each event HAPPENED, but flushes them together later, so
- *   stamping write-time would collapse a whole batch onto the flush instant and
- *   corrupt every `--since` boundary. `ts` stays in RESERVED_META_KEYS so a
- *   *payload* still cannot inject it — this explicit channel is the only way in.
- */
 export declare function emit(event: EventType, payload?: EventPayload, overrides?: {
     ts?: string;
 }): void;
+/**
+ * Async, non-blocking counterpart of {@link emit} for callers on the daemon's
+ * shared event loop (PHNX-3695). `emit` acquires the event-log lock with
+ * `withFileLock` → `sleepSync` (`Atomics.wait`), which HALTS the loop for up to
+ * 30s under contention (a peer appending to the same log). `emitAsync` acquires
+ * it with `withFileLockAsync`, so the loop keeps turning. The under-lock body is
+ * identical (a µs-scale append + a rare rotate). Best-effort like `emit`: never
+ * throws; a caller on a tick fires it and moves on.
+ */
+export declare function emitAsync(event: EventType, payload?: EventPayload, overrides?: {
+    ts?: string;
+}): Promise<void>;
 /**
  * Convenience wrapper for timed operations.
  * Returns a function to call when the operation completes.
@@ -135,14 +135,21 @@ export declare function emit(event: EventType, payload?: EventPayload, overrides
  * done({ exitCode: 0 }); // emits agent.run.end with durationMs
  */
 export declare function emitStart(startEvent: EventType, payload?: EventPayload): (endPayload?: EventPayload) => void;
-export declare function emitRoutineEnd(meta: {
+interface RoutineEndMeta {
     jobName: string;
     runId?: string;
     status: string;
     duration?: number;
     exitCode?: number | null;
     detail?: string;
-}): void;
+}
+export declare function emitRoutineEnd(meta: RoutineEndMeta): void;
+/**
+ * Async, non-blocking `routine.end` for the daemon heartbeat tick (PHNX-3695):
+ * the reaper (`reapExitedRunningJobs`) runs on the shared event loop, so it emits
+ * through {@link emitAsync} rather than the `sleepSync`-locked {@link emit}.
+ */
+export declare function emitRoutineEndAsync(meta: RoutineEndMeta): Promise<void>;
 /**
  * Measure execution time of a synchronous function.
  * Emits a perf.timing event with the duration.
@@ -272,3 +279,4 @@ export declare function stats(options?: {
 }): EventStats;
 export declare function getLogsPath(): string;
 export declare function _resetForTest(overrideEventsPath?: string, overrideUserAgentsDir?: string): void;
+export {};

package/dist/lib/feed/events.js

@@ -16,7 +16,7 @@ import * as path from 'path';
 import * as os from 'os';
 import { createHash } from 'node:crypto';
 import { gzipSync, gunzipSync } from 'node:zlib';
-import { ensureLockTarget, withFileLock } from '../fs-atomic.js';
+import { ensureLockTarget, withFileLock, withFileLockAsync } from '../fs-atomic.js';
 import { getUserAgentsDir } from '../state.js';
 import { stampProvenance, resetEventProvenanceForTest } from '../event-provenance.js';
 import { recordSample } from '../perf/spool.js';
@@ -493,48 +493,77 @@ export function detectCaller(env = process.env, stdoutIsTTY = Boolean(process.st
  *   corrupt every `--since` boundary. `ts` stays in RESERVED_META_KEYS so a
  *   *payload* still cannot inject it — this explicit channel is the only way in.
  */
-export function emit(event, payload = {}, overrides = {}) {
+/** Build the JSONL line + target path for an event, or null when logging is disabled. Shared by {@link emit} and {@link emitAsync}. */
+function prepareEventWrite(event, payload, overrides) {
     if (isDisabled())
-        return;
+        return null;
+    ensureLogsDir();
+    const caller = detectCaller();
+    const safePayload = sanitizePayload(payload);
+    const record = {
+        // Provenance floor first: env-sourced defaults an explicit payload overrides.
+        ...stampProvenance(),
+        ...safePayload,
+        ts: overrides.ts ?? new Date().toISOString(),
+        tz: getTimezoneOffset(),
+        tzName: getTimezoneName(),
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        pid: process.pid,
+        ppid: process.ppid,
+        event,
+        level: levelFor(event),
+        caller: caller.kind,
+        ...(caller.session ? { session: caller.session } : {}),
+    };
+    const line = JSON.stringify(record) + '\n';
+    const logPath = eventsPath();
+    const isNew = !fs.existsSync(logPath);
+    ensureLockTarget(logPath, '', DIR_MODE);
+    return { logPath, line, isNew };
+}
+/** The under-lock append + chmod + rotate/prune. Tiny local writes (µs), safe inside either the sync or async lock. */
+function appendEventLocked(logPath, line, isNew) {
+    fs.appendFileSync(logPath, line, { mode: FILE_MODE });
+    if (isNew || logPath !== _chmoddedPath) {
+        _chmoddedPath = logPath;
+        try {
+            fs.chmodSync(logPath, FILE_MODE);
+        }
+        catch {
+            // May fail if not owner
+        }
+    }
+    const rotated = maybeGzipRotateLocked(logPath);
+    maybePruneLocked(rotated);
+}
+export function emit(event, payload = {}, overrides = {}) {
     try {
-        ensureLogsDir();
-        const caller = detectCaller();
-        const safePayload = sanitizePayload(payload);
-        const record = {
-            // Provenance floor first: env-sourced defaults an explicit payload overrides.
-            ...stampProvenance(),
-            ...safePayload,
-            ts: overrides.ts ?? new Date().toISOString(),
-            tz: getTimezoneOffset(),
-            tzName: getTimezoneName(),
-            hostname: os.hostname(),
-            platform: os.platform(),
-            arch: os.arch(),
-            pid: process.pid,
-            ppid: process.ppid,
-            event,
-            level: levelFor(event),
-            caller: caller.kind,
-            ...(caller.session ? { session: caller.session } : {}),
-        };
-        const line = JSON.stringify(record) + '\n';
-        const logPath = eventsPath();
-        const isNew = !fs.existsSync(logPath);
-        ensureLockTarget(logPath, '', DIR_MODE);
-        withFileLock(logPath, () => {
-            fs.appendFileSync(logPath, line, { mode: FILE_MODE });
-            if (isNew || logPath !== _chmoddedPath) {
-                _chmoddedPath = logPath;
-                try {
-                    fs.chmodSync(logPath, FILE_MODE);
-                }
-                catch {
-                    // May fail if not owner
-                }
-            }
-            const rotated = maybeGzipRotateLocked(logPath);
-            maybePruneLocked(rotated);
-        });
+        const prepared = prepareEventWrite(event, payload, overrides);
+        if (!prepared)
+            return;
+        withFileLock(prepared.logPath, () => appendEventLocked(prepared.logPath, prepared.line, prepared.isNew));
+    }
+    catch {
+        // Silent failure - logging should never break the CLI
+    }
+}
+/**
+ * Async, non-blocking counterpart of {@link emit} for callers on the daemon's
+ * shared event loop (PHNX-3695). `emit` acquires the event-log lock with
+ * `withFileLock` → `sleepSync` (`Atomics.wait`), which HALTS the loop for up to
+ * 30s under contention (a peer appending to the same log). `emitAsync` acquires
+ * it with `withFileLockAsync`, so the loop keeps turning. The under-lock body is
+ * identical (a µs-scale append + a rare rotate). Best-effort like `emit`: never
+ * throws; a caller on a tick fires it and moves on.
+ */
+export async function emitAsync(event, payload = {}, overrides = {}) {
+    try {
+        const prepared = prepareEventWrite(event, payload, overrides);
+        if (!prepared)
+            return;
+        await withFileLockAsync(prepared.logPath, () => appendEventLocked(prepared.logPath, prepared.line, prepared.isNew));
     }
     catch {
         // Silent failure - logging should never break the CLI
@@ -558,8 +587,8 @@ export function emitStart(startEvent, payload = {}) {
         emit(startEvent.replace('.start', '.end'), { ...payload, ...endPayload, durationMs: Date.now() - startTime });
     };
 }
-export function emitRoutineEnd(meta) {
-    emit('routine.end', {
+function routineEndPayload(meta) {
+    return {
         module: 'routine',
         name: meta.jobName,
         status: meta.status,
@@ -567,7 +596,18 @@ export function emitRoutineEnd(meta) {
         ...(meta.duration != null ? { durationMs: meta.duration } : {}),
         ...(meta.exitCode != null ? { exitCode: meta.exitCode } : {}),
         ...(meta.detail ? { detail: meta.detail } : {}),
-    });
+    };
+}
+export function emitRoutineEnd(meta) {
+    emit('routine.end', routineEndPayload(meta));
+}
+/**
+ * Async, non-blocking `routine.end` for the daemon heartbeat tick (PHNX-3695):
+ * the reaper (`reapExitedRunningJobs`) runs on the shared event loop, so it emits
+ * through {@link emitAsync} rather than the `sleepSync`-locked {@link emit}.
+ */
+export async function emitRoutineEndAsync(meta) {
+    await emitAsync('routine.end', routineEndPayload(meta));
 }
 // ─── Timing Utilities ─────────────────────────────────────────────────────────
 /**