@phnx-labs/agents-cli 1.21.1 → 1.21.2

package/dist/lib/feed-broadcast.js

@@ -23,8 +23,20 @@
  *
  * Delivery is best-effort and reported: a sink that fails prints a warning and
  * the post still stands. Losing a mirror must never cost the operator the post.
+ *
+ * A second sink shape (RUSH-2123) delivers **in-process** through the same
+ * channel-provider registry `agents send` uses (`channel:` instead of
+ * `command:`) — no spawn, no argv templating. `channel: owner` is the address
+ * alias that expands to `notify.owner.{channel,to}`, matching `agents notify`.
+ * When the operator has never written a `feed.broadcast` block at all, an
+ * important-level post falls back to that owner address implicitly
+ * ({@link effectiveBroadcastConfig}) rather than reaching nobody — see that
+ * function's doc for why this was a silent failure before.
  */
 import { spawnSync } from 'child_process';
+import { isOwnerAlias, readOwnerDest, resolveSendEnvelope, deliverEnvelope } from './channels/send.js';
+import { lookupTransport } from './channels/resolve.js';
+import { registerBuiltinProviders } from './channels/providers/index.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) {
@@ -251,17 +263,39 @@ export function renderSinkArgv(template, ctx) {
 /**
  * Which sinks this post reaches, in config order. Pure — the dry-run listing and
  * the real fan-out plan through here, so what `--dry-run` shows is what runs.
+ *
+ * A `channel:` sink is gated by the same `minLevel` rule as a `command:` sink —
+ * one level check for both shapes, so a dry-run plan is truthful regardless of
+ * which shape an operator's sink uses.
  */
 export function planFeedBroadcast(config, ctx) {
     if (!config)
         return [];
     const planned = [];
     for (const [name, sink] of Object.entries(config)) {
-        if (!Array.isArray(sink?.command) || sink.command.length === 0)
+        if (!sink)
             continue;
         const min = sink.minLevel ?? 'milestone';
         if (LEVEL_RANK[ctx.level] < LEVEL_RANK[min])
             continue;
+        const channel = sink.channel?.trim();
+        if (channel) {
+            // The owner alias resolves its recipient from notify.owner at delivery
+            // time; any other channel name needs an explicit recipient now, or the
+            // sink can never fire with a hole in it (same contract as a missing argv
+            // placeholder below).
+            if (!isOwnerAlias(channel) && !sink.to?.trim())
+                continue;
+            planned.push({
+                name,
+                channel,
+                to: isOwnerAlias(channel) ? undefined : sink.to.trim(),
+                text: composeBroadcastMessage(ctx),
+            });
+            continue;
+        }
+        if (!Array.isArray(sink.command) || sink.command.length === 0)
+            continue;
         const argv = renderSinkArgv(sink.command, ctx);
         if (!argv)
             continue;
@@ -270,24 +304,97 @@ export function planFeedBroadcast(config, ctx) {
     return planned;
 }
 /**
- * Run the planned sinks. Each is a direct spawn with a bounded lifetime; a sink
- * that fails or is not installed is reported, never thrown — the post is already
- * written and must not be undone by a mirror that could not be reached.
+ * The effective sink config for a post: the operator's `feed.broadcast`, or —
+ * when that is unset or empty — an implicit fallback straight to
+ * `notify.owner`, for a post worth interrupting someone over.
+ *
+ * Before this, `broadcastPostedEvent`/`broadcastBlock` returned early the
+ * moment `feed.broadcast` was empty, even when `notify.owner` was fully
+ * configured — so the common case (an operator who set up owner notifications
+ * but never wrote a `feed.broadcast` block) produced a `--blocked` post that
+ * looked recorded and reached nobody. `agents notify` already treats
+ * `notify.owner` as the default human destination; this makes an important
+ * feed post/block use that same default instead of requiring a second,
+ * redundant config block that says the same thing.
+ *
+ * The fallback only fires for `important` — a routine `milestone` post stays
+ * record-only, matching the `minLevel` contract every declared sink already
+ * follows. An operator-declared `feed.broadcast` (any non-empty config)
+ * always wins outright; the fallback never layers on top of it.
  */
-export function runFeedBroadcast(planned, timeoutMs = 20_000) {
-    return planned.map(({ name, argv }) => {
-        const result = spawnSync(argv[0], argv.slice(1), {
-            encoding: 'utf-8',
-            timeout: timeoutMs,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        if (result.error) {
-            return { name, ok: false, error: result.error.message };
+export function effectiveBroadcastConfig(config, level, meta) {
+    if (config && Object.keys(config).length > 0)
+        return config;
+    if (level !== 'important')
+        return undefined;
+    if (!readOwnerDest(meta))
+        return undefined;
+    return { owner: { channel: 'owner' } };
+}
+function runCommandSink(name, argv, timeoutMs) {
+    const result = spawnSync(argv[0], argv.slice(1), {
+        encoding: 'utf-8',
+        timeout: timeoutMs,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        return { name, ok: false, error: result.error.message };
+    }
+    if (result.status !== 0) {
+        const tail = (result.stderr || result.stdout || '').trim().split('\n').slice(-1)[0];
+        return { name, ok: false, error: tail || `exited ${result.status}` };
+    }
+    return { name, ok: true };
+}
+/**
+ * Deliver one `channel:` sink through the real provider registry —
+ * `resolveSendEnvelope` reuses `agents notify`'s owner-alias expansion, and
+ * `deliverEnvelope` is the same seam `agents send` calls. A bad channel name
+ * is checked with `lookupTransport` (the non-throwing lookup) BEFORE handing
+ * off to `deliverEnvelope`: that function's own resolution `die()`s on an
+ * unregistered provider, which is the right answer for an interactive `agents
+ * send` typo but would take the whole broadcast fan-out down with it here —
+ * one misconfigured sink must report a failure, not kill the process running
+ * every other sink.
+ */
+async function runChannelSink(sink, meta) {
+    const name = sink.name;
+    // Registration is idempotent and normally happens inside deliverEnvelope();
+    // it has to happen before the lookupTransport pre-check below too, or the
+    // very first channel sink in a process would report "no channel provider"
+    // for a name that is, in fact, registered.
+    registerBuiltinProviders();
+    const owner = isOwnerAlias(sink.channel);
+    const resolved = resolveSendEnvelope({
+        text: sink.text ?? '',
+        channel: owner ? undefined : sink.channel,
+        to: owner ? 'owner' : sink.to,
+        ownerMode: owner,
+    }, meta);
+    if (!resolved.ok)
+        return { name, ok: false, error: resolved.error };
+    const { provider, error } = lookupTransport(resolved.envelope.channel, meta);
+    if (!provider)
+        return { name, ok: false, error };
+    const result = await deliverEnvelope(resolved.envelope, meta);
+    return result.ok ? { name, ok: true } : { name, ok: false, error: result.error };
+}
+/**
+ * Run the planned sinks. A `command:` sink is a direct spawn with a bounded
+ * lifetime; a `channel:` sink delivers in-process. Either way a sink that
+ * fails or is not installed/registered is reported, never thrown — the post
+ * is already written and must not be undone by a mirror that could not be
+ * reached.
+ */
+export async function runFeedBroadcast(planned, meta, timeoutMs = 20_000) {
+    const outcomes = [];
+    for (const sink of planned) {
+        if (sink.channel) {
+            outcomes.push(await runChannelSink(sink, meta));
         }
-        if (result.status !== 0) {
-            const tail = (result.stderr || result.stdout || '').trim().split('\n').slice(-1)[0];
-            return { name, ok: false, error: tail || `exited ${result.status}` };
+        else {
+            outcomes.push(runCommandSink(sink.name, sink.argv ?? [], timeoutMs));
         }
-        return { name, ok: true };
-    });
+    }
+    return outcomes;
 }

package/dist/lib/fleet-cache.d.ts

@@ -0,0 +1,37 @@
+/**
+ * One synchronous, disk-only read facade over the fleet/usage caches.
+ *
+ * These readers NEVER touch the network and NEVER SSH — they read the caches
+ * the daemon keeps warm (usage snapshot, projected headroom, fleet status) and
+ * return instantly. That is the whole point: the routing hot path
+ * (`agents run` → rotate.ts), device affinity (smart-launch.ts), and Factory can
+ * consult live-ish fleet state without paying a provider fetch or an ssh probe
+ * on a latency-sensitive path.
+ *
+ * Writers live elsewhere (the daemon's `runUsageRefresh` for usage/headroom,
+ * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
+ * side only.
+ */
+import { type UsageSnapshot } from './usage.js';
+import { type FleetStatusRow } from './fleet-status.js';
+/**
+ * The fleet-status union the daemon publishes (own row) and the fleet-status
+ * command unions (peer rows) — this host's stats + agent workload for every
+ * known host, keyed by host. Cache-only: a cold mirror yields an empty map.
+ */
+export declare function readFleetStatus(): Record<string, FleetStatusRow>;
+export type { FleetStatusRow };
+/** The last cached usage snapshot for an account, or null. Cache-only. */
+export declare function readAccountUsage(usageKey: string): UsageSnapshot | null;
+/** An account's projected headroom, as published by the daemon refresher. */
+export interface AccountHeadroom {
+    status: 'available' | 'rate_limited' | null;
+    /** Projected minutes until the session window caps; null = unknown/idle. */
+    minutesToLimit: number | null;
+}
+/**
+ * The daemon-computed headroom for an account, or null when nothing has been
+ * published yet. Cache-only — a cold cache simply yields null, and callers
+ * degrade to snapshot-only behavior.
+ */
+export declare function readAccountHeadroom(usageKey: string): AccountHeadroom | null;

package/dist/lib/fleet-cache.js

@@ -0,0 +1,40 @@
+/**
+ * One synchronous, disk-only read facade over the fleet/usage caches.
+ *
+ * These readers NEVER touch the network and NEVER SSH — they read the caches
+ * the daemon keeps warm (usage snapshot, projected headroom, fleet status) and
+ * return instantly. That is the whole point: the routing hot path
+ * (`agents run` → rotate.ts), device affinity (smart-launch.ts), and Factory can
+ * consult live-ish fleet state without paying a provider fetch or an ssh probe
+ * on a latency-sensitive path.
+ *
+ * Writers live elsewhere (the daemon's `runUsageRefresh` for usage/headroom,
+ * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
+ * side only.
+ */
+import { readClaudeUsageCache } from './usage.js';
+import { readHeadroomEntry } from './usage-refresh.js';
+import { readFleetStatus as readFleetStatusMirror } from './fleet-status.js';
+/**
+ * The fleet-status union the daemon publishes (own row) and the fleet-status
+ * command unions (peer rows) — this host's stats + agent workload for every
+ * known host, keyed by host. Cache-only: a cold mirror yields an empty map.
+ */
+export function readFleetStatus() {
+    return readFleetStatusMirror();
+}
+/** The last cached usage snapshot for an account, or null. Cache-only. */
+export function readAccountUsage(usageKey) {
+    return readClaudeUsageCache(usageKey);
+}
+/**
+ * The daemon-computed headroom for an account, or null when nothing has been
+ * published yet. Cache-only — a cold cache simply yields null, and callers
+ * degrade to snapshot-only behavior.
+ */
+export function readAccountHeadroom(usageKey) {
+    const entry = readHeadroomEntry(usageKey);
+    if (!entry)
+        return null;
+    return { status: entry.status, minutesToLimit: entry.minutesToLimit };
+}

package/dist/lib/fleet-status.d.ts

@@ -0,0 +1,53 @@
+import { type DeviceStats } from './devices/health.js';
+/** Live agent workload on a host. */
+export interface FleetAgentCounts {
+    /** Sessions actively working (status === 'running'). */
+    running: number;
+    /** Total live sessions regardless of status (running/idle/input-required/…). */
+    live: number;
+    /** Running count broken down by context: terminal / teams / cloud / headless. */
+    byContext: Record<string, number>;
+    /** Running count broken down by agent CLI: claude / codex / cursor / … */
+    byAgent: Record<string, number>;
+}
+/** One host's published status row. */
+export interface FleetStatusRow {
+    host: string;
+    agents: FleetAgentCounts;
+    /** Resource stats from the local probe; null when the probe produced nothing. */
+    stats: DeviceStats | null;
+    /** Epoch ms this row was computed. */
+    capturedAt: number;
+}
+/** Minimal shape needed to count workload — a subset of ActiveSession. */
+type CountableSession = {
+    status?: string;
+    context?: string;
+    kind?: string;
+    pidAlive?: boolean;
+};
+/**
+ * Tally running-agent workload from a host's live sessions. "running" is the
+ * actively-working set (`status === 'running'`); `live` is every session the
+ * host is tracking. Pure so the tally is unit-tested without a live scan.
+ */
+export declare function computeAgentCounts(sessions: ReadonlyArray<CountableSession>): FleetAgentCounts;
+/**
+ * Probe THIS host's status — resource stats locally (no SSH) and agent workload
+ * from the local live-session set (`getActiveSessions({ localOnly: true })`,
+ * which never dials a remote host). Never throws: a failed sub-probe degrades to
+ * null stats / zero counts.
+ */
+export declare function probeLocalFleetStatus(host: string, now?: number): Promise<FleetStatusRow>;
+export declare function setFleetStatusMirrorPathForTest(mirrorPath: string | null): string | null;
+/** Read the whole fleet-status mirror (best-effort; missing/corrupt → empty). */
+export declare function readFleetStatus(): Record<string, FleetStatusRow>;
+/** Merge rows into the mirror (best-effort; preserves other hosts' rows). */
+export declare function writeFleetStatusRows(entries: Record<string, FleetStatusRow>): void;
+/**
+ * Publish THIS host's row into the mirror (probe self, no SSH). The daemon calls
+ * this on its warm tick; it is the whole of the daemon's fleet-status duty now
+ * that cross-host probing is gone.
+ */
+export declare function publishLocalFleetStatus(host: string): Promise<FleetStatusRow>;
+export {};

package/dist/lib/fleet-status.js

@@ -0,0 +1,120 @@
+/**
+ * Per-host fleet-status rows: this machine's resource stats PLUS its live agent
+ * workload (running-agent count + per-context / per-agent breakdown), published
+ * to a shared local mirror.
+ *
+ * ## Why this exists (RUSH-2061)
+ *
+ * The daemon's fleet-cache warm used to `loadFleetStats({ forceRefresh: true })`
+ * every 3 minutes — an SSH resource probe of EVERY device. With N daemons each
+ * probing N devices that is N² SSH round trips across the fleet every 3 minutes,
+ * each a remote `uptime;vm_stat;nproc` compute with a timeout that (pre-RUSH-2114)
+ * could orphan the remote child. This module replaces that with a
+ * **publish-own / read-union** model:
+ *
+ *  - Each daemon probes ONLY ITSELF (`probeLocalFleetStatus`, no SSH) and writes
+ *    its own row into the mirror. Zero cross-host SSH from the daemon → the N²
+ *    probe is gone.
+ *  - A READER (the `agents fleet status` command) unions the fleet's rows on
+ *    demand — a bounded, kill-on-timeout SSH read of each peer's already-computed
+ *    `--local` row (a cheap `cat`-equivalent, not a fresh remote probe) — and
+ *    writes them into the same mirror. `readFleetStatus` then serves the union
+ *    synchronously with no network at all.
+ *
+ * The mirror file matches the `stats-cache` / `auth-health` convention exactly:
+ * `{ version: 1, entries: Record<host, FleetStatusRow> }` under `getCacheDir()`,
+ * keyed by `machineId()`, best-effort read/write that never throws.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getCacheDir } from './state.js';
+import { probeLocalStats } from './devices/health.js';
+import { getActiveSessions } from './session/active.js';
+/**
+ * Tally running-agent workload from a host's live sessions. "running" is the
+ * actively-working set (`status === 'running'`); `live` is every session the
+ * host is tracking. Pure so the tally is unit-tested without a live scan.
+ */
+export function computeAgentCounts(sessions) {
+    const byContext = {};
+    const byAgent = {};
+    let running = 0;
+    let live = 0;
+    for (const s of sessions) {
+        live += 1;
+        if (s.status !== 'running')
+            continue;
+        running += 1;
+        const ctx = s.context ?? 'unknown';
+        const agent = s.kind ?? 'unknown';
+        byContext[ctx] = (byContext[ctx] ?? 0) + 1;
+        byAgent[agent] = (byAgent[agent] ?? 0) + 1;
+    }
+    return { running, live, byContext, byAgent };
+}
+/**
+ * Probe THIS host's status — resource stats locally (no SSH) and agent workload
+ * from the local live-session set (`getActiveSessions({ localOnly: true })`,
+ * which never dials a remote host). Never throws: a failed sub-probe degrades to
+ * null stats / zero counts.
+ */
+export async function probeLocalFleetStatus(host, now = Date.now()) {
+    const [stats, sessions] = await Promise.all([
+        probeLocalStats(host).catch(() => null),
+        getActiveSessions({ localOnly: true }).catch(() => []),
+    ]);
+    return {
+        host,
+        agents: computeAgentCounts(sessions),
+        stats: stats ?? null,
+        capturedAt: now,
+    };
+}
+/** Test seam for the mirror path (see usage.ts `setClaudeUsageCachePathForTest`). */
+let mirrorPathOverride = null;
+export function setFleetStatusMirrorPathForTest(mirrorPath) {
+    const prev = mirrorPathOverride;
+    mirrorPathOverride = mirrorPath;
+    return prev;
+}
+function mirrorPath() {
+    return mirrorPathOverride ?? path.join(getCacheDir(), '.fleet-status.json');
+}
+/** Read the whole fleet-status mirror (best-effort; missing/corrupt → empty). */
+export function readFleetStatus() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(mirrorPath(), 'utf-8'));
+        if (parsed && parsed.entries && typeof parsed.entries === 'object')
+            return parsed.entries;
+    }
+    catch {
+        // missing or corrupt — treat as empty
+    }
+    return {};
+}
+/** Merge rows into the mirror (best-effort; preserves other hosts' rows). */
+export function writeFleetStatusRows(entries) {
+    try {
+        const dir = getCacheDir();
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const merged = {
+            version: 1,
+            entries: { ...readFleetStatus(), ...entries },
+        };
+        fs.writeFileSync(mirrorPath(), JSON.stringify(merged, null, 2));
+    }
+    catch {
+        // best-effort; a failed write just means the reader sees an older union
+    }
+}
+/**
+ * Publish THIS host's row into the mirror (probe self, no SSH). The daemon calls
+ * this on its warm tick; it is the whole of the daemon's fleet-status duty now
+ * that cross-host probing is gone.
+ */
+export async function publishLocalFleetStatus(host) {
+    const row = await probeLocalFleetStatus(host);
+    writeFleetStatusRows({ [host]: row });
+    return row;
+}

package/dist/lib/friction-heuristics.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cheap heuristic readers over the `friction` event sink (emitFriction in
+ * events.ts). Guard hooks (git-guard, rm-guard, git-require-clean-tree) call
+ * `agents _internal friction --surface guard --id <failureId>` when they block
+ * a destructive command, so it exists in the log — but nothing reads it back
+ * yet. This is a starting point: one detector for the most actionable pattern,
+ * an agent stuck retrying the SAME denied action instead of adapting.
+ */
+import type { EventRecord } from './events.js';
+export interface RepeatedGuardBlockFinding {
+    /** Session id the repeated blocks happened in, or 'unknown' when the
+     *  friction event carried no session (e.g. a guard fired outside any
+     *  tracked agent session). */
+    session: string;
+    surface: string;
+    failureId: string;
+    /** Number of times this exact (session, surface, failureId) blocked. */
+    count: number;
+    firstTs: string;
+    lastTs: string;
+}
+/**
+ * Group `friction` events by (session, surface, failureId) and flag groups
+ * that repeat at least `minRepeats` times — the signature of an agent hitting
+ * the same guard over and over rather than changing approach after the first
+ * block. `events` is expected to already be filtered/queried for
+ * `eventTypes: ['friction']` (see events.ts `query()`); non-friction records
+ * are ignored defensively rather than assumed absent.
+ */
+export declare function detectRepeatedGuardBlocks(events: EventRecord[], opts?: {
+    minRepeats?: number;
+}): RepeatedGuardBlockFinding[];

package/dist/lib/friction-heuristics.js

@@ -0,0 +1,47 @@
+function asNonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/**
+ * Group `friction` events by (session, surface, failureId) and flag groups
+ * that repeat at least `minRepeats` times — the signature of an agent hitting
+ * the same guard over and over rather than changing approach after the first
+ * block. `events` is expected to already be filtered/queried for
+ * `eventTypes: ['friction']` (see events.ts `query()`); non-friction records
+ * are ignored defensively rather than assumed absent.
+ */
+export function detectRepeatedGuardBlocks(events, opts = {}) {
+    const minRepeats = opts.minRepeats ?? 3;
+    const groups = new Map();
+    for (const e of events) {
+        if (e.event !== 'friction')
+            continue;
+        const surface = asNonEmptyString(e.surface);
+        const failureId = asNonEmptyString(e.failureId);
+        if (!surface || !failureId)
+            continue;
+        const session = e.session ?? 'unknown';
+        const key = `${session}\0${surface}\0${failureId}`;
+        const bucket = groups.get(key);
+        if (bucket)
+            bucket.push(e);
+        else
+            groups.set(key, [e]);
+    }
+    const out = [];
+    for (const [key, evs] of groups) {
+        if (evs.length < minRepeats)
+            continue;
+        const [session, surface, failureId] = key.split('\0');
+        const sortedTs = evs.map((e) => e.ts).sort();
+        out.push({
+            session,
+            surface,
+            failureId,
+            count: evs.length,
+            firstTs: sortedTs[0],
+            lastTs: sortedTs[sortedTs.length - 1],
+        });
+    }
+    out.sort((a, b) => b.count - a.count);
+    return out;
+}

package/dist/lib/hooks/cache.js

@@ -308,8 +308,8 @@ printf '{"ts":"%s","event":"hook.fire","hook":"%s","ms":%d,"cache":"%s","exit":%
 mkdir -p "$PERF_DIR" 2>/dev/null || true
 TS_MS=$("$PY" -c 'import time; print(int(time.time()*1000))' 2>/dev/null || echo 0)
 HOST=$(hostname 2>/dev/null || echo unknown)
-printf '{"ts_ms":%s,"kind":"hook.fire","label":"%s","duration_ms":%d,"cache":"%s","exit_code":%d,"hostname":"%s"}\\n' \\
-  "$TS_MS" "$HOOK_NAME" "$MS" "none" "$EXIT" "$HOST" >>"$PERF_SPOOL" 2>/dev/null || true
+printf '{"ts_ms":%s,"kind":"hook.fire","label":"%s","duration_ms":%d,"cache":"%s","exit_code":%d,"hostname":"%s"%s}\\n' \\
+  "$TS_MS" "$HOOK_NAME" "$MS" "none" "$EXIT" "$HOST" "$HOOK_EXTRA_JSON" >>"$PERF_SPOOL" 2>/dev/null || true
 
 exit "$EXIT"`;
 /**
@@ -375,6 +375,28 @@ done
 # Read stdin once (Claude/Codex/Gemini pass JSON on stdin to every hook).
 STDIN_PAYLOAD="$(cat || true)"
 
+# cwd + session_id from the hook's own stdin JSON, pre-escaped as a ready-to-
+# splice JSON fragment (e.g. ,"cwd":"/repo","session_id":"abc") so every
+# hook.fire perf-spool line below can carry them without re-parsing stdin per
+# site. This is what lets \`agents perf --project\` (project-key.ts resolves
+# cwd -> project) and session-scoped rollups work for hook.fire samples.
+# Fail-safe: any parse error yields an empty fragment, never breaks the write.
+HOOK_EXTRA_JSON="$(printf '%s' "$STDIN_PAYLOAD" | "$PY" -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    d = {}
+out = {}
+cwd = d.get("cwd")
+if isinstance(cwd, str) and cwd:
+    out["cwd"] = cwd
+sid = d.get("session_id") or d.get("sessionId")
+if isinstance(sid, str) and sid:
+    out["session_id"] = sid
+print("".join("," + json.dumps(k) + ":" + json.dumps(v) for k, v in out.items()))
+' 2>/dev/null || true)"
+
 # --- matches: gate (issue #744 / RUSH-1506) -------------------------------
 # Enforce the hook's declared \`matches:\` predicates at fire time. Mirrors
 # shouldFire() in src/lib/hooks/match.ts: all declared predicates AND together;
@@ -393,8 +415,8 @@ if [ -n "$MATCHES_JSON" ]; then
     mkdir -p "$PERF_DIR" 2>/dev/null || true
     _TS_MS=$("$PY" -c 'import time; print(int(time.time()*1000))' 2>/dev/null || echo 0)
     _HOST=$(hostname 2>/dev/null || echo unknown)
-    printf '{"ts_ms":%s,"kind":"hook.fire","label":"%s","duration_ms":0,"cache":"skip","exit_code":0,"hostname":"%s"}\\n' \\
-      "$_TS_MS" "$HOOK_NAME" "$_HOST" >>"$PERF_SPOOL" 2>/dev/null || true
+    printf '{"ts_ms":%s,"kind":"hook.fire","label":"%s","duration_ms":0,"cache":"skip","exit_code":0,"hostname":"%s"%s}\\n' \\
+      "$_TS_MS" "$HOOK_NAME" "$_HOST" "$HOOK_EXTRA_JSON" >>"$PERF_SPOOL" 2>/dev/null || true
     exit 0
   fi
 fi
@@ -495,8 +517,8 @@ printf '{"ts":"%s","event":"hook.fire","hook":"%s","ms":%d,"cache":"%s","exit":%
 # Disposable perf spool → drained into perf.db (see lib/perf/db.ts). Soft keys only.
 TS_MS=$("$PY" -c 'import time; print(int(time.time()*1000))' 2>/dev/null || echo 0)
 HOST=$(hostname 2>/dev/null || echo unknown)
-printf '{"ts_ms":%s,"kind":"hook.fire","label":"%s","duration_ms":%d,"cache":"%s","exit_code":%d,"hostname":"%s"}\\n' \\
-  "$TS_MS" "$HOOK_NAME" "$MS" "$CACHE_STATUS" "$EXIT" "$HOST" >>"$PERF_SPOOL" 2>/dev/null || true
+printf '{"ts_ms":%s,"kind":"hook.fire","label":"%s","duration_ms":%d,"cache":"%s","exit_code":%d,"hostname":"%s"%s}\\n' \\
+  "$TS_MS" "$HOOK_NAME" "$MS" "$CACHE_STATUS" "$EXIT" "$HOST" "$HOOK_EXTRA_JSON" >>"$PERF_SPOOL" 2>/dev/null || true
 
 exit "$EXIT"
 `;

package/dist/lib/hooks/profile.d.ts

@@ -2,6 +2,7 @@ export interface HookProfileRow {
     hook: string;
     n: number;
     p50Ms: number;
+    p95Ms: number;
     p99Ms: number;
     meanMs: number;
     maxMs: number;
@@ -9,6 +10,13 @@ export interface HookProfileRow {
     cacheStalePct: number;
     cacheMissPct: number;
     errorCount: number;
+    /** Fraction (0-1) of fires with a nonzero exit code. */
+    errorRate?: number;
+    /** Fraction (0-1) of fires that hit their configured timeout. */
+    timeoutRate?: number;
+    /** Project key the row is scoped to (see project-key.ts) — set only when
+     *  a `--project` filter narrowed the underlying query. */
+    project?: string;
 }
 interface RawFireEvent {
     event?: string;

package/dist/lib/hooks/profile.js

@@ -3,10 +3,11 @@
  * generated shims (see `cache.ts`) emit on every invocation, and aggregates
  * per-hook timing + cache stats.
  *
- * Only hooks declared with `cache:` get instrumented today, because only those
- * are wrapped by a generated shim. Hooks without `cache:` are not in the
- * profile output — that's deliberate: opting into the primitive is what
- * surfaces the data.
+ * Every hook gets a generated shim now (resolveHookCommand in hooks.ts) —
+ * `cache:`, `matches:`, or a bare `matcher:` (e.g. git-guard/rm-guard) are all
+ * enough to opt in. The only hooks NOT in this profile are ones with none of
+ * the three, since a pure lifecycle hook with nothing to gate/cache/match runs
+ * the raw script path with no timing wrapper at all.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -89,6 +90,7 @@ export function aggregateHookProfile(events) {
             hook,
             n,
             p50Ms: Math.round(percentile(sortedMs, 50)),
+            p95Ms: Math.round(percentile(sortedMs, 95)),
             p99Ms: Math.round(percentile(sortedMs, 99)),
             meanMs: Math.round(sum / n),
             maxMs: sortedMs[sortedMs.length - 1],
@@ -96,6 +98,14 @@ export function aggregateHookProfile(events) {
             cacheStalePct: Math.round((stale / n) * 100),
             cacheMissPct: Math.round((misses / n) * 100),
             errorCount: errors,
+            ...(errors > 0 ? { errorRate: Math.round((errors / n) * 1000) / 1000 } : {}),
+            // timeoutRate is not derivable here: the daily JSONL a shim writes only
+            // covers fires that reached their own trailing printf — an externally
+            // enforced timeout (the agent harness killing the process) never gets
+            // that far, so this log has no timeout signal at all. The warehouse
+            // path (asHookRows in commands/perf.ts) is the one that can see it,
+            // via the perf-spool `status:"timeout"` sample OpenCode's generated
+            // plugin writes directly (hooks.ts's recordTimeoutSample).
         });
     }
     rows.sort((a, b) => b.p99Ms - a.p99Ms);