@phnx-labs/agents-cli 1.22.69 → 1.22.71

package/dist/lib/sink-format.d.ts

@@ -0,0 +1,34 @@
+/**
+ * How loudly a destination can render a link — the one decision that shapes the
+ * shared owner/broadcast `{message}` per channel (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 Slack opts into `mrkdwn`.
+ *
+ * This lives in its own tiny module because both the feed broadcast fan-out
+ * (`feed-broadcast.ts`) and the owner delivery fan-out (`notify.ts`) key on it,
+ * and those two modules already import each other — a shared symbol here keeps
+ * the format decision a single source of truth without a circular import.
+ */
+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 a 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.
+ */
+export declare function sinkMessageFormat(provider: string | undefined): SinkMessageFormat;

package/dist/lib/sink-format.js

@@ -0,0 +1,17 @@
+/**
+ * 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 a 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.
+ */
+export function sinkMessageFormat(provider) {
+    return provider?.trim().toLowerCase() === 'slack' ? 'mrkdwn' : 'plain';
+}

package/dist/lib/staleness/detectors/permissions.js

@@ -202,25 +202,6 @@ function buildDroidDetector() {
         },
     };
 }
-function buildKiroDetector() {
-    return {
-        kind: 'permissions',
-        agent: 'kiro',
-        list({ versionHome }) {
-            const permissionsPath = path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
-            if (!fs.existsSync(permissionsPath))
-                return [];
-            try {
-                const config = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
-                if (config && Array.isArray(config.rules) && config.rules.length > 0) {
-                    return discoverPermissionGroups().map(g => g.name);
-                }
-            }
-            catch { /* parse fail */ }
-            return [];
-        },
-    };
-}
 function buildOpenClawDetector() {
     return {
         kind: 'permissions',
@@ -296,7 +277,6 @@ const handlers = {
     kimi: buildKimiDetector,
     cursor: buildCursorDetector,
     droid: buildDroidDetector,
-    kiro: buildKiroDetector,
     openclaw: buildOpenClawDetector,
     copilot: buildCopilotDetector,
     hermes: buildHermesDetector,

package/dist/lib/staleness/writers/commands.js

@@ -13,7 +13,7 @@
  *
  *  - native command file — `{agentDir}/<commandsSubdir>/<name>.md` (or .toml
  *    when the agent's format is toml). Standard path for Claude, Codex
- *    < 0.117.0, Cursor, OpenCode, Copilot, Amp, Kiro, Roo, Antigravity.
+ *    < 0.117.0, Cursor, OpenCode, Copilot, Amp, Roo, Antigravity.
  *
  * Source resolution is `resolveCommandSource` (user → system → extras —
  * project layer intentionally excluded).

package/dist/lib/staleness/writers/hooks.js

@@ -90,9 +90,9 @@ function buildHooksWriter(agent) {
             // so subrule-bundled guards (absolute paths outside the central hooks/
             // copy set) get registered into ~/.grok/hooks/hooks.json via
             // registerHooksForGrok — file copy alone only sees top-level available.hooks
-            // names (RUSH-1353). Copilot/Kiro/Goose load managed *.json under their
+            // names (RUSH-1353). Copilot/Goose load managed *.json under their
             // hooks dirs the same way.
-            if (agent === 'claude' || agent === 'codex' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes' || agent === 'muse') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes' || agent === 'muse') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced, paths };

package/dist/lib/subagents-registry.js

@@ -15,7 +15,7 @@
  *
  *   - `flatFile`  one `<name><ext>` file, body from a `transform` fn.
  *                 (claude, grok, pi, droid, codex, opencode, copilot,
- *                  cursor, kiro, goose, kimi)
+ *                  cursor, goose, kimi)
  *   - `dirFile`   a `<name>/` directory holding one generated `<file>`.
  *                 (antigravity: `<name>/agent.md`)
  *   - `dirCopy`   copy the whole source directory to `<name>/`, applying
@@ -35,7 +35,7 @@ import * as TOML from 'smol-toml';
 import * as yaml from 'yaml';
 import { safeJoin } from './paths.js';
 import { filesContentMatch, normalizeResourceContent } from './resource-content-diff.js';
-import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForKiro, transformSubagentForOpenCode, transformSubagentForAntigravity, } from './subagents.js';
+import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForOpenCode, transformSubagentForAntigravity, } from './subagents.js';
 /** Read a file's UTF-8 content, or null when it is missing/unreadable. */
 function readFileSafe(filePath) {
     try {
@@ -54,7 +54,6 @@ function metaFrontmatterSkip(filePath) {
 function metaFrontmatterFallback(filePath, name) {
     return parseSubagentFrontmatter(filePath) ?? { name, description: '' };
 }
-/** Kiro custom-agent JSON: read name/description/model; skip on parse error. */
 function metaJson(filePath, name) {
     try {
         const cfg = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
@@ -283,9 +282,6 @@ export const SUBAGENT_TARGETS = {
     // Tier 1 -- flat markdown, Claude-compatible flatten.
     claude: flatFile({ subdir: ['.claude', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
     grok: flatFile({ subdir: ['.grok', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
-    // Oh My Pi discovers Claude-shaped agent markdown from ~/.omp/agent/agents/
-    // (`omp agents unpack` writes there); frontmatter name/description + body.
-    pi: flatFile({ subdir: ['.omp', 'agent', 'agents'], ext: '.md', transform: transformSubagentForClaude, readMeta: metaFrontmatterFallback }),
     droid: flatFile({ subdir: ['.factory', 'droids'], ext: '.md', transform: transformSubagentForDroid }),
     // Bespoke frontmatter/format, still one flat file.
     codex: flatFile({
@@ -312,12 +308,6 @@ export const SUBAGENT_TARGETS = {
         transform: transformSubagentForCursor,
         readMeta: metaFrontmatterFallback,
     }),
-    kiro: flatFile({
-        subdir: ['.kiro', 'agents'],
-        ext: '.json',
-        transform: transformSubagentForKiro,
-        readMeta: metaJson,
-    }),
     goose: flatFile({
         subdir: ['.config', 'goose', 'agents'],
         ext: '.yaml',

package/dist/lib/subagents.d.ts

@@ -106,16 +106,6 @@ export declare function transformSubagentForOpenCode(subagentDir: string): strin
  * https://developers.openai.com/codex/subagents (custom agents section)
  */
 export declare function transformSubagentForCodex(subagentDir: string): string;
-/**
- * Transform a subagent into a Kiro CLI custom-agent JSON file.
- *
- * Kiro custom agents live in `~/.kiro/agents/<name>.json` (or `.kiro/agents/`
- * workspace-local) and declare name, description, prompt, tools, and optional
- * model. We flatten the AGENT.md frontmatter + body plus any sibling .md files
- * as sections into a single `prompt`, and expose the standard built-in tool
- * set so the subagent can actually run.
- */
-export declare function transformSubagentForKiro(subagentDir: string): string;
 /**
  * Transform a subagent into a Goose recipe YAML file.
  *

package/dist/lib/subagents.js

@@ -403,43 +403,6 @@ function flattenSubagentInstructions(subagentDir) {
     }
     return instructions;
 }
-/**
- * Transform a subagent into a Kiro CLI custom-agent JSON file.
- *
- * Kiro custom agents live in `~/.kiro/agents/<name>.json` (or `.kiro/agents/`
- * workspace-local) and declare name, description, prompt, tools, and optional
- * model. We flatten the AGENT.md frontmatter + body plus any sibling .md files
- * as sections into a single `prompt`, and expose the standard built-in tool
- * set so the subagent can actually run.
- */
-export function transformSubagentForKiro(subagentDir) {
-    const agentMd = path.join(subagentDir, 'AGENT.md');
-    const frontmatter = parseSubagentFrontmatter(agentMd);
-    const body = getSubagentBody(agentMd);
-    if (!frontmatter) {
-        throw new Error(`Invalid AGENT.md in ${subagentDir}`);
-    }
-    const files = fs.readdirSync(subagentDir)
-        .filter(f => f.endsWith('.md') && f !== 'AGENT.md')
-        .sort();
-    let prompt = body;
-    for (const file of files) {
-        const content = fs.readFileSync(path.join(subagentDir, file), 'utf-8').trim();
-        const sectionName = file.replace('.md', '');
-        const title = sectionName.charAt(0).toUpperCase() + sectionName.slice(1).toLowerCase();
-        prompt += `\n\n## ${title}\n\n${content}`;
-    }
-    const config = {
-        name: frontmatter.name,
-        description: frontmatter.description,
-        prompt,
-        tools: ['read', 'write', 'shell', 'web_search', 'web_fetch'],
-    };
-    if (frontmatter.model) {
-        config.model = frontmatter.model;
-    }
-    return JSON.stringify(config, null, 2);
-}
 /**
  * Transform a subagent into a Goose recipe YAML file.
  *

package/dist/lib/tmux/orphan-reap.js

@@ -99,7 +99,7 @@
  * helper); it is not a parsing bug {@link parseTmuxSessionMarker} can fix.
  */
 import { execFile } from 'child_process';
-import * as fs from 'fs';
+import * as fsp from 'fs/promises';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
 /** Ceiling on the `ps` snapshot so a wedged `ps` can never stall the daemon tick. */
@@ -407,7 +407,9 @@ export async function readAgentProcesses(opts = {}) {
     if (process.platform === 'win32')
         return [];
     const scope = opts.pids && opts.pids.length > 0 ? ['-p', opts.pids.join(',')] : ['-A'];
-    const hasProc = fs.existsSync('/proc/self/environ');
+    // Async /proc reads — this runs on the daemon's tmux-reap tick, so a sync scan
+    // of the whole process table's environ files would freeze the loop (PHNX-3695).
+    const hasProc = await fsp.access('/proc/self/environ').then(() => true, () => false);
     const args = hasProc ? [...scope, '-o', 'pid=,ppid=,args='] : [...scope, '-E', '-o', 'pid=,ppid=,args='];
     let stdout;
     try {
@@ -426,7 +428,7 @@ export async function readAgentProcesses(opts = {}) {
     for (const row of rows) {
         let blob;
         try {
-            blob = fs.readFileSync(`/proc/${row.pid}/environ`, 'utf8');
+            blob = await fsp.readFile(`/proc/${row.pid}/environ`, 'utf8');
         }
         catch {
             continue; // exited between ps and the read, or not ours to inspect
@@ -450,7 +452,7 @@ export async function readPaneOwners(socket) {
     // No socket file at all means no server was ever started here — for the
     // shared agents socket this is reliable (tmux unlinks its own socket on
     // exit), so this is a confident, reliable EMPTY read, not an unknown one.
-    if (!fs.existsSync(socket))
+    if (!(await fsp.access(socket).then(() => true, () => false)))
         return { ok: true, owners: new Map(), panePids: new Set() };
     const { runTmux } = await import('./binary.js');
     try {

package/dist/lib/tmux/session.js

@@ -10,6 +10,7 @@
  * `tmux list-sessions` and prunes stale entries on the fly.
  */
 import * as fs from 'fs';
+import * as fsp from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
 import { runTmux, TmuxCommandError } from './binary.js';
@@ -412,7 +413,9 @@ export async function reapDeadTmuxPanes(socket, opts = {}) {
     result.warnings = orphans.warnings;
     result.processes = opts.dryRun ? orphans.candidates.length : orphans.killed;
     result.processDetails = orphans.details;
-    if (!fs.existsSync(sock))
+    // Async existence check — this runs on the daemon's tmux-reap tick, so a sync
+    // `existsSync` would block the shared event loop (PHNX-3695).
+    if (!(await fsp.access(sock).then(() => true, () => false)))
         return result;
     const res = await runTmux({
         socket: sock,

package/dist/lib/traces/classify.d.ts

@@ -1,5 +1,12 @@
 export type TraceTopicGroup = 'code' | 'research' | 'review' | 'content' | 'ops';
-export type TraceFailureCause = 'real' | 'guard' | 'hook';
+/**
+ * `real`/`guard`/`hook` are the cause buckets of a FAILED tool call (`classifyCause`).
+ * `behavioral` is different in kind: a silent failure with no error code at all — the
+ * agent went idle after its last event and a human had to nudge it. It is derived from
+ * per-session friction facets (`computeBehavioralPatterns` in `insights.ts`), never from
+ * `classifyCause`, so a failed-tool-call classifier never returns it.
+ */
+export type TraceFailureCause = 'real' | 'guard' | 'hook' | 'behavioral';
 /** Per-bucket aggregate stats for one day, stored in the rolling bucketHistory. */
 export interface BucketStats {
     key: string;

package/dist/lib/traces/insights.d.ts

@@ -29,6 +29,7 @@ import { type TraceFailureCause } from './classify.js';
 import type { FailurePhenotype } from './phenotype.js';
 import { type LatencyInsight } from './segments.js';
 import { type SyncRow, type ToolCallRow, type TracesIndexShard } from './sync.js';
+import type { InsightFacets } from '../session/insights.js';
 export interface FailureSignature {
     tool: string;
     cause: TraceFailureCause;
@@ -97,4 +98,15 @@ export declare function normalizeErrorKey(desc: string, raw: string | null): str
  * estimate, not ground truth; it is not inflated by folding in ordinary
  * processing time between unrelated calls.
  */
-export declare function computeInsights(rows: readonly SyncRow[], calls: readonly ToolCallRow[], prevShard?: TracesIndexShard | null, phenotypes?: ReadonlyMap<string, FailurePhenotype | null>): ComputedInsights;
+export declare function computeInsights(rows: readonly SyncRow[], calls: readonly ToolCallRow[], prevShard?: TracesIndexShard | null, phenotypes?: ReadonlyMap<string, FailurePhenotype | null>, behavioralPatterns?: readonly FailurePattern[]): ComputedInsights;
+/**
+ * Promote the per-session silent-stall friction signals — already computed by
+ * `computeInsightFacets` in `session/insights.ts` and keyed `silent stall: <bucket>`
+ * — into cross-session behavioral `FailurePattern`s. These are silent failures
+ * with NO error code: the agent went idle after its last event and a human had to
+ * nudge it. They never surface through `computeInsights` (which only clusters
+ * `outcome === 'error'` tool calls) and were previously only a `needsAttention`
+ * friction counter, never a ranked issue. Cause is `behavioral`; the signature
+ * `tool` is the synthetic `silent-stall` and `key` is the duration bucket.
+ */
+export declare function computeBehavioralPatterns(facetsBySession: ReadonlyMap<string, Pick<InsightFacets, 'frictionSignals'>>, prevShard?: TracesIndexShard | null): FailurePattern[];

package/dist/lib/traces/insights.js

@@ -132,7 +132,7 @@ function labelFor(tool, cause, key) {
  * estimate, not ground truth; it is not inflated by folding in ordinary
  * processing time between unrelated calls.
  */
-export function computeInsights(rows, calls, prevShard, phenotypes) {
+export function computeInsights(rows, calls, prevShard, phenotypes, behavioralPatterns = []) {
     const bySession = new Map();
     for (const call of calls) {
         const list = bySession.get(call.session_id);
@@ -226,13 +226,88 @@ export function computeInsights(rows, calls, prevShard, phenotypes) {
             drift,
         };
     });
-    const wastedMsTotal = allPatterns.reduce((sum, p) => sum + p.wastedMs, 0);
-    const failurePatterns = [...allPatterns]
+    // Behavioral patterns (silent stalls — no failed tool call, so absent from the
+    // error-anchored clustering above) join the SAME ranking and total, so the top-K
+    // is by impact across both kinds and `wastedMsTotal` counts the idle time too.
+    const combined = [...allPatterns, ...behavioralPatterns];
+    const wastedMsTotal = combined.reduce((sum, p) => sum + p.wastedMs, 0);
+    const failurePatterns = [...combined]
         .sort((a, b) => b.wastedMs - a.wastedMs || b.occurrences - a.occurrences || a.id.localeCompare(b.id))
         .slice(0, TOP_K_PATTERNS);
     const latency = computeLatency(firstToolSegments(rows, bySession));
     return { failurePatterns, wastedMsTotal, latency };
 }
+// ---------------------------------------------------------------------------
+// Behavioral patterns — silent failures with no error code
+// ---------------------------------------------------------------------------
+/**
+ * Estimated agent-owned idle ms per silent-stall bucket. A bucket's midpoint,
+ * capped at MAX_GAP_ATTRIBUTION_MS exactly like the tool-error gap attribution
+ * above so one long overnight stall can't book hours of "waste" — the same
+ * honesty bound the error path uses. The open-ended buckets are the cap.
+ */
+const SILENT_STALL_WASTED_MS = {
+    '5-15m': 10 * 60_000,
+    '15-60m': MAX_GAP_ATTRIBUTION_MS,
+    '1h+': MAX_GAP_ATTRIBUTION_MS,
+};
+/**
+ * Promote the per-session silent-stall friction signals — already computed by
+ * `computeInsightFacets` in `session/insights.ts` and keyed `silent stall: <bucket>`
+ * — into cross-session behavioral `FailurePattern`s. These are silent failures
+ * with NO error code: the agent went idle after its last event and a human had to
+ * nudge it. They never surface through `computeInsights` (which only clusters
+ * `outcome === 'error'` tool calls) and were previously only a `needsAttention`
+ * friction counter, never a ranked issue. Cause is `behavioral`; the signature
+ * `tool` is the synthetic `silent-stall` and `key` is the duration bucket.
+ */
+export function computeBehavioralPatterns(facetsBySession, prevShard) {
+    const groups = new Map();
+    for (const [sessionId, facets] of facetsBySession) {
+        for (const [signal, count] of Object.entries(facets.frictionSignals ?? {})) {
+            if (count <= 0)
+                continue;
+            const match = /^silent stall: (.+)$/.exec(signal);
+            if (!match)
+                continue;
+            const bucket = match[1];
+            let group = groups.get(bucket);
+            if (!group) {
+                group = { bucket, sessions: new Set(), occurrences: 0, wastedMs: 0, examples: [] };
+                groups.set(bucket, group);
+            }
+            group.occurrences += count;
+            group.sessions.add(sessionId);
+            group.wastedMs += (SILENT_STALL_WASTED_MS[bucket] ?? MAX_GAP_ATTRIBUTION_MS) * count;
+            if (group.examples.length < MAX_EXAMPLE_SESSIONS && !group.examples.includes(sessionId)) {
+                group.examples.push(sessionId);
+            }
+        }
+    }
+    const prevById = new Map((prevShard?.failurePatterns ?? []).map((p) => [p.id, p]));
+    return [...groups.values()].map((group) => {
+        const id = hashSignature('silent-stall', 'behavioral', group.bucket, null);
+        const prev = prevById.get(id);
+        const drift = !prev
+            ? 'up'
+            : group.occurrences > prev.occurrences
+                ? 'up'
+                : group.occurrences < prev.occurrences
+                    ? 'down'
+                    : 'flat';
+        return {
+            id,
+            label: `Agent silent stall (${group.bucket}) — idle until nudged`,
+            signature: { tool: 'silent-stall', cause: 'behavioral', key: group.bucket },
+            phenotype: null,
+            sessions: group.sessions.size,
+            occurrences: group.occurrences,
+            wastedMs: group.wastedMs,
+            exampleSessionIds: group.examples,
+            drift,
+        };
+    });
+}
 /** Synthesize one-step SegmentSessions carrying only the time-to-first-tool offset, for computeLatency() reuse. */
 function firstToolSegments(rows, bySession) {
     return rows.flatMap((row) => {

package/dist/lib/traces/sync.js

@@ -30,7 +30,7 @@ import { knownSecretValuesFromEnv, redactSecrets } from '../redact.js';
 import { getRuntimeStateDir } from '../state.js';
 import { resolveTracesBackend } from './backend.js';
 import { classifyCause, classifyTopic, computeDriftSignal, } from './classify.js';
-import { computeInsights } from './insights.js';
+import { computeBehavioralPatterns, computeInsights } from './insights.js';
 import { classifyPhenotype, recoveredAfterErrors } from './phenotype.js';
 import { buildSessionDetailV2 } from './schema2-build.js';
 /**
@@ -529,7 +529,9 @@ export function buildIndexShard(rows, device, owner, prevShard) {
         topicCounts.set(topic.key, bucket);
     }
     const failedCalls = agentCalls.filter((call) => call.outcome === 'error');
-    const byCause = { real: 0, guard: 0, hook: 0 };
+    // `behavioral` is not a failed-tool-call cause (classifyCause never returns it),
+    // so it stays 0 in this tool-error split; it surfaces as its own failurePatterns.
+    const byCause = { real: 0, guard: 0, hook: 0, behavioral: 0 };
     const failureCounts = new Map();
     for (const call of failedCalls) {
         const cause = classifyCause(call);
@@ -585,7 +587,10 @@ export function buildIndexShard(rows, device, owner, prevShard) {
     const prevHistory = prevShard?.bucketHistory ?? [];
     const bucketHistory = [...prevHistory, todayStats].slice(-14);
     const driftSignals = computeDriftSignal(prevHistory, todayStats);
-    const patternInsights = computeInsights(agentRows, agentCalls, prevShard, phenotypes);
+    // Silent-stall friction (per-session, no failed tool call) becomes cross-session
+    // behavioral FailurePatterns, ranked into the same top-K by wasted idle time.
+    const behavioralPatterns = computeBehavioralPatterns(insights, prevShard);
+    const patternInsights = computeInsights(agentRows, agentCalls, prevShard, phenotypes, behavioralPatterns);
     // Per-session roster (PHNX-3483): one flat scalar row per agent session, the raw
     // material the Rush console filters and re-aggregates client-side. `durationMs`
     // reuses `sessionActiveMs` (the value behind `stats.medianMs`; 0 for a null-duration

package/dist/lib/traces/worker-template.js

@@ -170,7 +170,11 @@ function mergeIndexShards(shards, owner) {
     topicCounts.set(t.key, cur);
   }
   const byToolError = new Map();
-  let real = 0, guard = 0, hook = 0;
+  // Accumulate byCause over WHATEVER cause keys each shard carries (real / guard /
+  // hook / behavioral / any future TraceFailureCause) rather than a hand-enumerated
+  // set — a hardcoded {real,guard,hook} silently dropped a new member from the /all
+  // view and made the cause sum NaN (RUSH-2988).
+  const byCause = {};
   for (const s of sorted) {
     const f = s.failures || {};
     for (const e of f.byToolError || []) {
@@ -179,9 +183,9 @@ function mergeIndexShards(shards, owner) {
       cur.count += e.count || 0;
       byToolError.set(key, cur);
     }
-    real += (f.byCause && f.byCause.real) || 0;
-    guard += (f.byCause && f.byCause.guard) || 0;
-    hook += (f.byCause && f.byCause.hook) || 0;
+    for (const [cause, n] of Object.entries((f.byCause) || {})) {
+      byCause[cause] = (byCause[cause] || 0) + (n || 0);
+    }
   }
   // Fold failure patterns by their stable id, the same way topics/byToolError fold
   // by key above — a signature that fired on two devices (a rate limit on the laptop
@@ -220,7 +224,7 @@ function mergeIndexShards(shards, owner) {
     topics: Array.from(topicCounts.values()).sort((a, b) => b.count - a.count),
     failures: {
       byToolError: Array.from(byToolError.values()).sort((a, b) => b.count - a.count).slice(0, 50),
-      byCause: { real, guard, hook },
+      byCause,
     },
     failurePatterns: Array.from(patternById.values())
       .sort((a, b) => (b.wastedMs || 0) - (a.wastedMs || 0)).slice(0, 25),

package/dist/lib/types.d.ts

@@ -8,7 +8,7 @@
 import type { CloudProviderId } from './cloud/types.js';
 import type { FeedBroadcastConfig } from './feed-broadcast.js';
 /** Unique identifier for a current or legacy AI coding agent. */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi' | 'muse' | 'warp';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'muse' | 'warp';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
 export type RunStrategy = 'pinned' | 'available' | 'balanced';
 export type RunEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.69",
+  "version": "1.22.71",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",