@phnx-labs/agents-cli 1.22.70 → 1.22.72

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.70",
+  "version": "1.22.72",
   "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",