@phnx-labs/agents-cli 1.22.69 → 1.22.71

package/dist/lib/feed-broadcast.d.ts

@@ -1,4 +1,5 @@
 import type { Meta } from './types.js';
+import { type SinkMessageFormat } from './sink-format.js';
 /** How loudly a post asks to be heard. Ordered — `important` implies milestone. */
 export type FeedPostLevel = 'milestone' | 'important';
 /** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
@@ -122,6 +123,17 @@ export interface PlannedSink {
     to?: string;
     /** Channel sink body — the composed `{message}` for this post. */
     text?: string;
+    /**
+     * Owner-alias sinks only: the post context + its `message:` template, carried
+     * so the owner fan-out can re-render the body PER DESTINATION — Slack in the
+     * policy gets `mrkdwn` labeled links while iMessage stays plain (PHNX-3698).
+     * `text` above is the plain default (dry-run display + the fallback when a
+     * destination has no resolvable provider); this drives the real send. A
+     * direct `channel:` sink resolves its one provider's format at plan time and
+     * needs neither field.
+     */
+    ctx?: FeedBroadcastContext;
+    messageTemplate?: string;
 }
 export interface SinkOutcome {
     name: string;
@@ -157,35 +169,6 @@ export declare function sessionConsoleUrl(session: string | undefined): string |
  * Collapses whitespace; does not invent meaning.
  */
 export declare function scrubOutboundDashes(text: string): string;
-/**
- * The rendering vocabulary a sink can display, which decides how the shared
- * `{message}` surfaces its links (PHNX-3698):
- *
- *   - `mrkdwn` — Slack, which renders `<url|label>` as blue tappable text. The
- *     session crumb and every ticket key the prose NAMES become inline labeled
- *     links, so nothing rides a trailing naked-URL line.
- *   - `plain` — iMessage, the owner-scoped rush message, a spawned `command:`
- *     sink, desktop banners: none can render a labeled link and a dumped naked
- *     URL reads as noise, so the message stays the human sentence with no URLs.
- *
- * The default is `plain`; only a Slack `channel:` sink opts into `mrkdwn`.
- */
-export type SinkMessageFormat = 'plain' | 'mrkdwn';
-/**
- * Only Slack renders `<url|label>`, so it is the one format that gets labeled
- * links. iMessage / owner-scoped rush / command / desktop sinks stay `plain`
- * (they can't turn `claude/6fc1db18` blue, and dumping the raw URL is worse than
- * leaving the crumb unlinked — PHNX-3698).
- *
- * The argument is the **resolved provider name**, not the sink's declared
- * channel: an operator can point an arbitrary channel name at the Slack provider
- * through `notify.transports` (e.g. `eng-alerts -> slack`), and delivery keys off
- * that resolved provider (`lookupTransport`), so the format decision must too —
- * otherwise an aliased Slack sink would compose plain while delivering to Slack,
- * or a name remapped AWAY from Slack would emit `<url|label>` markup a non-Slack
- * transport shows literally. {@link resolveSinkProvider} does the mapping.
- */
-export declare function sinkMessageFormat(provider: string | undefined): SinkMessageFormat;
 /**
  * Footer like "Sent from my iPhone" — who posted, a session crumb, which box.
  *

package/dist/lib/feed-broadcast.js

@@ -41,6 +41,7 @@ import { sendToOwner } from './notify.js';
 import { linearIssueUrl, linearIssueKeys } from './session/linear.js';
 import { isValidMailboxId } from './mailbox.js';
 import { forwardOwnerNotifyToPeer } from './channels/owner-forward.js';
+import { sinkMessageFormat } from './sink-format.js';
 const LEVEL_RANK = { milestone: 0, important: 1 };
 /** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
 export function parseFeedPostLevel(raw) {
@@ -184,23 +185,6 @@ export function scrubOutboundDashes(text) {
 function slackLink(url, label) {
     return `<${url}|${label}>`;
 }
-/**
- * Only Slack renders `<url|label>`, so it is the one format that gets labeled
- * links. iMessage / owner-scoped rush / command / desktop sinks stay `plain`
- * (they can't turn `claude/6fc1db18` blue, and dumping the raw URL is worse than
- * leaving the crumb unlinked — PHNX-3698).
- *
- * The argument is the **resolved provider name**, not the sink's declared
- * channel: an operator can point an arbitrary channel name at the Slack provider
- * through `notify.transports` (e.g. `eng-alerts -> slack`), and delivery keys off
- * that resolved provider (`lookupTransport`), so the format decision must too —
- * otherwise an aliased Slack sink would compose plain while delivering to Slack,
- * or a name remapped AWAY from Slack would emit `<url|label>` markup a non-Slack
- * transport shows literally. {@link resolveSinkProvider} does the mapping.
- */
-export function sinkMessageFormat(provider) {
-    return provider?.trim().toLowerCase() === 'slack' ? 'mrkdwn' : 'plain';
-}
 /**
  * The provider a channel name actually delivers through — the same
  * `notify.transports` remap `lookupTransport` applies at delivery — so the format
@@ -481,21 +465,28 @@ export function planFeedBroadcast(config, ctx, meta) {
             // placeholder below).
             if (!isOwnerAlias(channel) && !sink.to?.trim())
                 continue;
-            // Slack renders labeled links; every other channel (owner alias, iMessage,
-            // telegram, discord, mailbox, desktop) stays plain (PHNX-3698). The owner
-            // alias is deliberately plain even when it fans out to a Slack destination:
-            // it delivers ONE shared string to every channel in owner.policy.normal, so
-            // mrkdwn markup would corrupt a sibling iMessage copy. Keying on the
-            // resolved provider (not the raw name) matches what delivery does.
-            const provider = isOwnerAlias(channel) ? channel : resolveSinkProvider(channel, meta);
-            const text = renderSinkMessage(sink.message ?? '{message}', ctx, sinkMessageFormat(provider));
+            // Slack renders labeled links; every other channel (iMessage, telegram,
+            // discord, mailbox, desktop) stays plain (PHNX-3698). A DIRECT channel sink
+            // has one known provider, so its format is resolved here. The OWNER ALIAS
+            // fans out to every channel in owner.policy.normal — each with its OWN
+            // provider — so it can't pick one format now: it carries the ctx + template
+            // and re-renders per destination inside the owner fan-out (runChannelSink →
+            // sendToOwner), so the Slack destination turns blue while a sibling iMessage
+            // copy stays plain. The plain body computed here is the dry-run/fallback
+            // default. Keying on the resolved provider (not the raw name) matches what
+            // delivery does.
+            const owner = isOwnerAlias(channel);
+            const template = sink.message ?? '{message}';
+            const provider = owner ? channel : resolveSinkProvider(channel, meta);
+            const text = renderSinkMessage(template, ctx, sinkMessageFormat(provider));
             if (!text)
                 continue;
             planned.push({
                 name,
                 channel,
-                to: isOwnerAlias(channel) ? undefined : sink.to.trim(),
+                to: owner ? undefined : sink.to.trim(),
                 text,
+                ...(owner ? { ctx, messageTemplate: template } : {}),
             });
             continue;
         }
@@ -604,7 +595,17 @@ async function runChannelSink(sink, meta) {
     registerBuiltinProviders();
     const owner = isOwnerAlias(sink.channel);
     if (owner) {
-        const result = await sendToOwner(sink.text ?? '', { meta });
+        // Re-render the body PER owner destination so a Slack channel in the policy
+        // gets mrkdwn labeled links while iMessage stays plain (PHNX-3698). The
+        // fan-out (sendToOwner) resolves each destination's provider and asks this
+        // composer for the matching format. renderSinkMessage is fail-closed on a
+        // missing placeholder — the plan already dropped the sink if the template
+        // couldn't fill, so here it always resolves; `?? sink.text` is a belt-and-
+        // braces guard, never the normal path.
+        const composeForFormat = sink.ctx
+            ? (format) => renderSinkMessage(sink.messageTemplate ?? '{message}', sink.ctx, format) ?? sink.text ?? ''
+            : undefined;
+        const result = await sendToOwner(sink.text ?? '', { meta, composeForFormat });
         return { name, ok: result.ok, ...(result.error ? { error: result.error } : {}) };
     }
     const resolved = resolveSendEnvelope({

package/dist/lib/fleet-shared-state.d.ts

@@ -25,14 +25,21 @@ export interface FleetSharedStateReadResult {
 }
 /** Path owned by one device in the conflict-free tracked device-doc tree. */
 export declare function fleetSharedStatePath(device: string, userAgentsDir?: string): string;
-/**
- * Merge one daemon-owned field into this device's shared file under a real
- * inter-process lock. Stable serialization avoids dirtying the user repo when
- * neither usage nor auth state changed.
- */
 export declare function updateFleetSharedDeviceState(device: string, patch: FleetSharedStatePatch, userAgentsDir?: string): {
     changed: boolean;
     path: string;
 };
+/**
+ * Async, non-blocking twin of {@link updateFleetSharedDeviceState} for the
+ * daemon's usage-sync / auth-sync ticks (PHNX-3695). The sync version acquires
+ * the file lock with `sleepSync` (`Atomics.wait`), freezing the shared event
+ * loop for up to 30s under contention on EVERY tick; this uses
+ * `withFileLockAsync`. The under-lock read is async; the atomic write is a tiny
+ * bounded write held inside the lock.
+ */
+export declare function updateFleetSharedDeviceStateAsync(device: string, patch: FleetSharedStatePatch, userAgentsDir?: string): Promise<{
+    changed: boolean;
+    path: string;
+}>;
 /** Read every valid peer-owned state file; malformed peers fail separately. */
 export declare function readFleetSharedDeviceStates(userAgentsDir?: string): FleetSharedStateReadResult;

package/dist/lib/fleet-shared-state.js

@@ -8,9 +8,10 @@
  * remains the one path that may carry secret material.
  */
 import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { assertValidDeviceName } from './devices/registry.js';
-import { atomicWriteFileSync, ensureLockTarget, withFileLock } from './fs-atomic.js';
+import { atomicWriteFileSync, ensureLockTarget, withFileLock, withFileLockAsync } from './fs-atomic.js';
 import { getUserAgentsDir } from './state.js';
 export const FLEET_SHARED_STATE_VERSION = 1;
 export const FLEET_SHARED_STATE_FILE = 'daemon-state.json';
@@ -43,32 +44,61 @@ function parseFleetSharedDeviceState(raw, owner) {
  * inter-process lock. Stable serialization avoids dirtying the user repo when
  * neither usage nor auth state changed.
  */
+/** Merge `patch` onto the current on-disk state; returns the serialized next state, or null when unchanged. Shared by the sync and async writers. */
+function mergeFleetState(currentRaw, device, patch) {
+    let current = { version: FLEET_SHARED_STATE_VERSION, device };
+    const trimmed = currentRaw.trim();
+    if (trimmed) {
+        try {
+            current = parseFleetSharedDeviceState(trimmed, device);
+        }
+        catch { /* owning device repairs its own malformed file; peers are never repaired here */ }
+    }
+    const next = {
+        ...current,
+        ...(patch.usage !== undefined ? { usage: patch.usage } : {}),
+        ...(patch.auth !== undefined ? { auth: patch.auth } : {}),
+        version: FLEET_SHARED_STATE_VERSION,
+        device,
+    };
+    const serialized = `${JSON.stringify(next, null, 2)}\n`;
+    return { serialized, changed: currentRaw !== serialized };
+}
 export function updateFleetSharedDeviceState(device, patch, userAgentsDir = getUserAgentsDir()) {
     const file = fleetSharedStatePath(device, userAgentsDir);
     ensureLockTarget(file, '');
     return withFileLock(file, () => {
-        let current = {
-            version: FLEET_SHARED_STATE_VERSION,
-            device,
-        };
+        let raw = '';
         try {
-            const raw = fs.readFileSync(file, 'utf-8').trim();
-            if (raw)
-                current = parseFleetSharedDeviceState(raw, device);
+            raw = fs.readFileSync(file, 'utf-8');
         }
-        catch {
-            // The owning device repairs its own malformed file from authoritative
-            // local state. Peer files are never repaired by this writer.
+        catch { /* missing → treat as empty */ }
+        const { serialized, changed } = mergeFleetState(raw, device, patch);
+        if (!changed)
+            return { changed: false, path: file };
+        atomicWriteFileSync(file, serialized, 'utf-8');
+        return { changed: true, path: file };
+    });
+}
+/**
+ * Async, non-blocking twin of {@link updateFleetSharedDeviceState} for the
+ * daemon's usage-sync / auth-sync ticks (PHNX-3695). The sync version acquires
+ * the file lock with `sleepSync` (`Atomics.wait`), freezing the shared event
+ * loop for up to 30s under contention on EVERY tick; this uses
+ * `withFileLockAsync`. The under-lock read is async; the atomic write is a tiny
+ * bounded write held inside the lock.
+ */
+export async function updateFleetSharedDeviceStateAsync(device, patch, userAgentsDir = getUserAgentsDir()) {
+    const file = fleetSharedStatePath(device, userAgentsDir);
+    ensureLockTarget(file, '');
+    return withFileLockAsync(file, async () => {
+        let raw = '';
+        try {
+            raw = await fsp.readFile(file, 'utf-8');
         }
-        const next = {
-            ...current,
-            ...(patch.usage !== undefined ? { usage: patch.usage } : {}),
-            ...(patch.auth !== undefined ? { auth: patch.auth } : {}),
-            version: FLEET_SHARED_STATE_VERSION,
-            device,
-        };
-        const serialized = `${JSON.stringify(next, null, 2)}\n`;
-        if (fs.readFileSync(file, 'utf-8') === serialized)
+        catch { /* missing → treat as empty */ }
+        const { serialized, changed } = mergeFleetState(raw, device, patch);
+        if (!changed)
             return { changed: false, path: file };
         atomicWriteFileSync(file, serialized, 'utf-8');
         return { changed: true, path: file };

package/dist/lib/fs-atomic.d.ts

@@ -42,3 +42,14 @@ export interface FileLockOptions {
     acquireTimeoutMs?: number;
 }
 export declare function withFileLock<T>(filePath: string, fn: (heartbeat: () => void) => T, opts?: FileLockOptions): T;
+/**
+ * Async counterpart of {@link withFileLock} for callers on the daemon's shared
+ * event loop (PHNX-3695). The sync version retries acquisition with
+ * {@link sleepSync} (`Atomics.wait`), which HALTS the thread for up to
+ * {@link LOCK_ACQUIRE_TIMEOUT_MS} on contention — on a daemon tick that freezes
+ * every service and the browser IPC server. This variant awaits proper-lockfile's
+ * async `lock()` and yields with a real timer between retries, so the loop keeps
+ * turning while a peer holds the lock. Same stale-break, same acquire budget,
+ * same compromised-lock surfacing.
+ */
+export declare function withFileLockAsync<T>(filePath: string, fn: (heartbeat: () => void) => Promise<T> | T, opts?: FileLockOptions): Promise<T>;

package/dist/lib/fs-atomic.js

@@ -126,3 +126,63 @@ export function withFileLock(filePath, fn, opts = {}) {
         catch { /* already gone */ }
     }
 }
+/**
+ * Async counterpart of {@link withFileLock} for callers on the daemon's shared
+ * event loop (PHNX-3695). The sync version retries acquisition with
+ * {@link sleepSync} (`Atomics.wait`), which HALTS the thread for up to
+ * {@link LOCK_ACQUIRE_TIMEOUT_MS} on contention — on a daemon tick that freezes
+ * every service and the browser IPC server. This variant awaits proper-lockfile's
+ * async `lock()` and yields with a real timer between retries, so the loop keeps
+ * turning while a peer holds the lock. Same stale-break, same acquire budget,
+ * same compromised-lock surfacing.
+ */
+export async function withFileLockAsync(filePath, fn, opts = {}) {
+    let release = null;
+    let lastError;
+    let compromised = null;
+    const staleMs = opts.staleMs ?? LOCK_STALE_MS;
+    const acquireTimeoutMs = opts.acquireTimeoutMs ?? LOCK_ACQUIRE_TIMEOUT_MS;
+    const deadline = Date.now() + acquireTimeoutMs;
+    for (let attempt = 0;; attempt++) {
+        try {
+            release = await lockfile.lock(filePath, {
+                stale: staleMs,
+                onCompromised: (err) => { compromised = err; },
+            });
+            break;
+        }
+        catch (err) {
+            lastError = err;
+            if (Date.now() >= deadline)
+                break;
+            const backoff = Math.min(LOCK_RETRY_MIN_MS * (attempt + 1), LOCK_RETRY_MAX_MS);
+            await new Promise((r) => setTimeout(r, Math.min(backoff, Math.max(0, deadline - Date.now()))));
+        }
+    }
+    if (!release) {
+        const message = lastError instanceof Error ? lastError.message : String(lastError);
+        throw new Error(`Could not acquire lock for ${filePath} after ${acquireTimeoutMs}ms: ${message}`);
+    }
+    const lockDir = `${filePath}.lock`;
+    const heartbeat = () => {
+        try {
+            const now = new Date();
+            fs.utimesSync(lockDir, now, now);
+        }
+        catch { /* best effort */ }
+    };
+    try {
+        const result = await fn(heartbeat);
+        if (compromised) {
+            throw new Error(`Lock for ${filePath} was broken by another process while held: ` +
+                `${compromised.message}`);
+        }
+        return result;
+    }
+    finally {
+        try {
+            await release();
+        }
+        catch { /* already gone */ }
+    }
+}

package/dist/lib/hooks/install.js

@@ -1845,9 +1845,6 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     if (agentId === 'copilot') {
         return registerHooksForCopilot(versionHome, manifest, resolveScript, managedPrefixes);
     }
-    if (agentId === 'kiro') {
-        return registerHooksForKiro(versionHome, manifest, resolveScript, managedPrefixes);
-    }
     if (agentId === 'goose') {
         return registerHooksForGoose(versionHome, manifest, resolveScript, managedPrefixes);
     }
@@ -2846,90 +2843,6 @@ function registerHooksForCopilot(versionHome, manifest, resolveScript, _managedP
     }
     return { registered, errors };
 }
-/**
- * Canonical hooks.yaml event names → Kiro v3 trigger names.
- * Kiro v3 uses PascalCase triggers under `.kiro/hooks/*.json`
- * (https://kiro.dev/docs/cli/v3/hooks/). Unmapped events are skipped.
- */
-const KIRO_EVENT_MAP = {
-    SessionStart: 'SessionStart',
-    Stop: 'Stop',
-    PreToolUse: 'PreToolUse',
-    PostToolUse: 'PostToolUse',
-    UserPromptSubmit: 'UserPromptSubmit',
-};
-/**
- * Kiro triggers that evaluate the `matcher` regex (tool name, file path, or
- * prompt text depending on the trigger). Lifecycle SessionStart/Stop always fire.
- */
-const KIRO_MATCHER_EVENTS = new Set([
-    'PreToolUse',
-    'PostToolUse',
-    'UserPromptSubmit',
-]);
-/** Managed filename under ~/.kiro/hooks/ — we own this file entirely. */
-const KIRO_MANAGED_HOOKS_FILE = 'agents-cli-hooks.json';
-/**
- * Register hooks for Kiro CLI (v3 standalone hooks format).
- *
- * Each file under `~/.kiro/hooks/*.json` is:
- *   { "version": "v1", "hooks": [ { name, trigger, matcher?, action, timeout?, enabled? } ] }
- *
- * We rewrite a single managed file so GC is a rewrite and user-authored sibling
- * JSON files are never touched. Embedded agent-config hooks (2.x) still work
- * in Kiro but we only write the v3 path.
- */
-function registerHooksForKiro(versionHome, manifest, resolveScript, _managedPrefixes) {
-    const registered = [];
-    const errors = [];
-    const kiroHooksDir = path.join(versionHome, '.kiro', 'hooks');
-    fs.mkdirSync(kiroHooksDir, { recursive: true });
-    const hooks = [];
-    for (const [name, hookDef] of Object.entries(manifest)) {
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
-        if (!commandPath) {
-            errors.push(`${name}: script not found in user or system hooks dir`);
-            continue;
-        }
-        const timeout = hookDef.timeout ?? 60;
-        for (const event of hookDef.events) {
-            const trigger = KIRO_EVENT_MAP[event];
-            if (!trigger)
-                continue;
-            const entry = {
-                name,
-                trigger,
-                action: { type: 'command', command: commandPath },
-                timeout,
-                enabled: true,
-            };
-            if (KIRO_MATCHER_EVENTS.has(trigger) && hookDef.matcher) {
-                entry.matcher = hookDef.matcher;
-            }
-            // De-dupe on (name, trigger, matcher)
-            const existingIdx = hooks.findIndex((h) => h.name === entry.name &&
-                h.trigger === entry.trigger &&
-                (h.matcher ?? '') === (entry.matcher ?? ''));
-            if (existingIdx >= 0) {
-                hooks[existingIdx] = entry;
-            }
-            else {
-                hooks.push(entry);
-            }
-            registered.push(`${name} -> ${trigger}`);
-        }
-    }
-    const outPath = path.join(kiroHooksDir, KIRO_MANAGED_HOOKS_FILE);
-    try {
-        fs.writeFileSync(outPath, JSON.stringify({ version: 'v1', hooks }, null, 2) + '\n', 'utf-8');
-    }
-    catch (err) {
-        errors.push(`Failed to write ${KIRO_MANAGED_HOOKS_FILE}: ${err.message}`);
-    }
-    return { registered, errors };
-}
 /**
  * Canonical hooks.yaml event names that goose supports (Open Plugins PascalCase).
  * Unmapped events are skipped. Goose ≥ 1.34.0.

package/dist/lib/hosts/reconcile.d.ts

@@ -30,18 +30,25 @@ export type RemoteExitState = {
  * empty stdout, and a truncate-then-write mid-race is a sub-ms empty window).
  */
 export declare function classifyExit(res: Pick<SshExecResult, 'code' | 'stdout' | 'timedOut'>): RemoteExitState;
+export declare function readRemoteExit(target: string, remoteExit: string, timeoutMs?: number, identityFile?: string, remoteShell?: 'posix' | 'powershell'): RemoteExitState;
 /**
- * Read a task's remote `.exit` over ssh and classify it. `remoteExit` is a
- * $HOME-prefixed path with a safe (hex) basename — intentionally unquoted so the
- * remote shell expands $HOME (same contract as progress.ts's fetch).
+ * Async twin of {@link readRemoteExit} for the daemon's heartbeat tick — the ssh
+ * read runs on the shared event loop, so it MUST NOT block it with a synchronous
+ * `spawnSync('ssh', …)` (PHNX-3695). `sshExecAsync` applies the same
+ * timeout/kill-grace bound.
  */
-export declare function readRemoteExit(target: string, remoteExit: string, timeoutMs?: number, identityFile?: string, remoteShell?: 'posix' | 'powershell'): RemoteExitState;
+export declare function readRemoteExitAsync(target: string, remoteExit: string, timeoutMs?: number, identityFile?: string, remoteShell?: 'posix' | 'powershell'): Promise<RemoteExitState>;
 /**
  * Heal one record. Terminal records are immutable (and never re-probed); a
  * `running` record is resolved to completed/failed only when the remote `.exit`
  * holds a code. Returns the (possibly updated) task.
  */
 export declare function reconcileTask(task: HostTask): HostTask;
+/**
+ * Async twin of {@link reconcileTask} for the daemon heartbeat tick (PHNX-3695):
+ * identical healing logic, non-blocking ssh read via {@link readRemoteExitAsync}.
+ */
+export declare function reconcileTaskAsync(task: HostTask): Promise<HostTask>;
 /**
  * Heal a list of records for a listing (`agents devices ps`). Only `running` tasks
  * are probed; each host is reachability-checked ONCE (deduped by target) so a

package/dist/lib/hosts/reconcile.js

@@ -10,7 +10,7 @@
  * record. We only ever CONFIRM completion; an unreachable host or an absent
  * `.exit` leaves the record `running` (we never guess failure).
  */
-import { sshExec } from '../ssh-exec.js';
+import { sshExec, sshExecAsync } from '../ssh-exec.js';
 import { updateTask, terminalPatch } from './tasks.js';
 import { encodePowershell } from './remote-cmd.js';
 /**
@@ -36,15 +36,29 @@ export function classifyExit(res) {
  * $HOME-prefixed path with a safe (hex) basename — intentionally unquoted so the
  * remote shell expands $HOME (same contract as progress.ts's fetch).
  */
-export function readRemoteExit(target, remoteExit, timeoutMs = 6000, identityFile, remoteShell = 'posix') {
-    const command = remoteShell === 'powershell'
+function remoteExitCommand(remoteExit, remoteShell) {
+    return remoteShell === 'powershell'
         ? `powershell -NoProfile -EncodedCommand ${encodePowershell(`$path = Join-Path $HOME '${remoteExit.replace(/^\$HOME\//, '').replace(/'/g, "''")}'; if (Test-Path -LiteralPath $path) { Get-Content -LiteralPath $path -Raw }`)}`
         : `cat ${remoteExit} 2>/dev/null`;
-    return classifyExit(sshExec(target, command, {
+}
+function remoteExitSshOpts(timeoutMs, identityFile) {
+    return {
         timeoutMs,
         multiplex: true,
         extraSshArgs: identityFile ? ['-i', identityFile, '-o', 'IdentitiesOnly=yes'] : undefined,
-    }));
+    };
+}
+export function readRemoteExit(target, remoteExit, timeoutMs = 6000, identityFile, remoteShell = 'posix') {
+    return classifyExit(sshExec(target, remoteExitCommand(remoteExit, remoteShell), remoteExitSshOpts(timeoutMs, identityFile)));
+}
+/**
+ * Async twin of {@link readRemoteExit} for the daemon's heartbeat tick — the ssh
+ * read runs on the shared event loop, so it MUST NOT block it with a synchronous
+ * `spawnSync('ssh', …)` (PHNX-3695). `sshExecAsync` applies the same
+ * timeout/kill-grace bound.
+ */
+export async function readRemoteExitAsync(target, remoteExit, timeoutMs = 6000, identityFile, remoteShell = 'posix') {
+    return classifyExit(await sshExecAsync(target, remoteExitCommand(remoteExit, remoteShell), remoteExitSshOpts(timeoutMs, identityFile)));
 }
 /**
  * Heal one record. Terminal records are immutable (and never re-probed); a
@@ -59,6 +73,18 @@ export function reconcileTask(task) {
         return task;
     return updateTask(task.id, terminalPatch(st.code)) ?? task;
 }
+/**
+ * Async twin of {@link reconcileTask} for the daemon heartbeat tick (PHNX-3695):
+ * identical healing logic, non-blocking ssh read via {@link readRemoteExitAsync}.
+ */
+export async function reconcileTaskAsync(task) {
+    if (task.status !== 'running')
+        return task;
+    const st = await readRemoteExitAsync(task.target, task.remoteExit, 6000, task.identityFile, task.remoteShell);
+    if (st.state !== 'done')
+        return task;
+    return updateTask(task.id, terminalPatch(st.code)) ?? task;
+}
 /**
  * Heal a list of records for a listing (`agents devices ps`). Only `running` tasks
  * are probed; each host is reachability-checked ONCE (deduped by target) so a

package/dist/lib/installations/strategies.js

@@ -177,7 +177,7 @@ const globalBinaryStrategy = {
 };
 /**
  * Harnesses installed by an official script that keeps a per-installation copy
- * or symlink farm (grok, cursor, antigravity, hermes, kiro, goose, …). The
+ * or symlink farm (grok, cursor, antigravity, hermes, goose, …). The
  * vendor artifact lands in a global location the installer owns, so the fetch
  * itself is not reversible; what IS per-installation — the version dir's binary
  * link farm — is staged and swapped so a failed re-import cannot strand the

package/dist/lib/mcp-registry.js

@@ -108,13 +108,6 @@ export const MCP_TARGETS = {
         project: (cwd) => path.join(cwd, '.hermes', 'config.yaml'),
         format: 'yaml',
     },
-    pi: {
-        // omp reads user-scope MCP from ~/.omp/agent/.mcp.json and project MCP from
-        // <root>/.mcp.json (both the Claude schema).
-        home: (h) => path.join(h, '.omp', 'agent', '.mcp.json'),
-        project: (cwd) => path.join(cwd, '.mcp.json'),
-        format: 'claude-json',
-    },
     muse: {
         home: (h) => path.join(h, '.config', 'muse', 'settings.json'),
         project: (cwd) => path.join(cwd, '.muse', 'settings.json'),
@@ -143,12 +136,6 @@ export const MCP_TARGETS = {
         format: null,
         unsupportedReason: 'Amp nests MCP under a settings key rather than a top-level map; schema not verified',
     },
-    kiro: {
-        home: (h) => path.join(h, '.kiro', 'settings', 'mcp.json'),
-        project: (cwd) => path.join(cwd, '.kiro', 'settings', 'mcp.json'),
-        format: null,
-        unsupportedReason: 'mcp.json schema not verified against an installed Kiro',
-    },
     goose: {
         home: (h) => path.join(h, '.config', 'goose', 'config.yaml'),
         project: (cwd) => path.join(cwd, '.goose', 'config.yaml'),

package/dist/lib/mcp.js

@@ -529,8 +529,8 @@ export function writeMcpConfig(agentId, configPath, servers, mode = 'overwrite')
     }
     const format = target.format;
     switch (format) {
-        // Claude's `{ "mcpServers": {...} }` schema, shared by cursor, kimi, droid,
-        // omp (.mcp.json) and Oz (.warp/.mcp.json): stdio carries command/args/env,
+        // Claude's `{ "mcpServers": {...} }` schema, shared by cursor, kimi, droid
+        // and Oz (.warp/.mcp.json): stdio carries command/args/env,
         // remote carries url + optional headers.
         case 'claude-json': {
             const config = readExistingConfig(configPath, JSON.parse);

package/dist/lib/model-tiers.js

@@ -127,7 +127,7 @@ function rankCatalog(agent, models) {
     // Cursor and Pi (Oh My Pi) are cross-provider aggregators: their ids are
     // provider-qualified (`anthropic/…`, `openai/…`) and span vendors, so price of
     // the normalized base id is the only unifying rank signal.
-    const aggregator = agent === 'cursor' || agent === 'pi';
+    const aggregator = agent === 'cursor';
     const scored = usable.map((m) => {
         const rawId = m.id;
         const baseId = aggregator ? normalizeAggregatorId(rawId) : rawId;