@phnx-labs/agents-cli 1.22.56 → 1.22.58

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

@@ -35,13 +35,33 @@ export interface OutcomeResult {
     confidence: 'high' | 'medium' | 'low';
     reason: string;
 }
+/**
+ * Did a run that hit tool errors nonetheless *recover and finish*?
+ *
+ * The causal recovery test: a **substantive** tool step (not a human-facing
+ * `AskUserQuestion` / `SendMessage` / `wait`) SUCCEEDED strictly AFTER the last
+ * error's ordinal, AND that success resolves the failed work — its
+ * {@link workSignature} matches an errored step's. A later success of *unrelated*
+ * work does NOT count: a `bun test` failure followed by an incidental `ls` leaves
+ * the failed test unresolved, so the run stays errored, even though the `ls`
+ * succeeded after it. A punt to a human is excluded twice over — human-facing
+ * tools are outside the substantive set, and they never match a failed signature.
+ *
+ * This is the single source of truth for "did this finish", shared by the
+ * false-termination phenotype below and `sync.ts`'s `deriveRunOutcome` — so a
+ * run's console outcome and its failure phenotype can never disagree about
+ * whether it recovered. It reads only the derived steps, never `meta.outcome`,
+ * precisely so `deriveRunOutcome` can call it while it is still *computing*
+ * `meta.outcome`.
+ */
+export declare function recoveredAfterErrors(session: Pick<SessionDetail, 'steps'>): boolean;
 /**
  * Classify the failure phenotype of a session from its derived trajectory.
  *
  * Definitions (from agent-failure research):
- * - `false-termination`  — stopped with an unresolved error.
- * - `premature-completion` — declared done while tests were failing or no
- *   verification step ran for the engineering work.
+ * - `false-termination`  — stopped with an unresolved error (did not causally recover).
+ * - `premature-completion` — declared done with no verification step for the
+ *   engineering work.
  * - `out-of-order` — a write/edit step occurred before any read/plan of the
  *   target.
  * - `failure-to-act` — stalled or produced no meaningful tool use.

package/dist/lib/traces/phenotype.js

@@ -156,30 +156,75 @@ function reasonOutOfOrder(session) {
     const tool = session.steps.find((s) => WRITE_EDIT_TOOLS.has(s.tool ?? s.lane));
     return `write/edit step ${tool?.tool ?? tool?.lane ?? ''} preceded any read/plan`;
 }
+/**
+ * The **work signature** of a step — what work it represents, so a later success
+ * can be matched back to the specific failure it resolves. For a shell step this
+ * is the effective program (`bun`, `git`, `gh`, …, from `TrajectoryStep.program`),
+ * so a failed `bun test` is resolved by a later `bun test` but NOT by an incidental
+ * `ls`. For any other tool it is the tool identity, so a failed `Edit` is resolved
+ * by a later successful `Edit`, not by an unrelated `Read`. A shell step whose
+ * command did not parse (no `program`) degrades to the bare tool name, matching
+ * the pre-`program` behavior only for that unparseable minority.
+ */
+function workSignature(step) {
+    const tool = step.tool ?? step.lane;
+    if (SHELL_TOOLS.has(tool) && step.program)
+        return `${tool}:${step.program}`;
+    return tool;
+}
+/**
+ * Did a run that hit tool errors nonetheless *recover and finish*?
+ *
+ * The causal recovery test: a **substantive** tool step (not a human-facing
+ * `AskUserQuestion` / `SendMessage` / `wait`) SUCCEEDED strictly AFTER the last
+ * error's ordinal, AND that success resolves the failed work — its
+ * {@link workSignature} matches an errored step's. A later success of *unrelated*
+ * work does NOT count: a `bun test` failure followed by an incidental `ls` leaves
+ * the failed test unresolved, so the run stays errored, even though the `ls`
+ * succeeded after it. A punt to a human is excluded twice over — human-facing
+ * tools are outside the substantive set, and they never match a failed signature.
+ *
+ * This is the single source of truth for "did this finish", shared by the
+ * false-termination phenotype below and `sync.ts`'s `deriveRunOutcome` — so a
+ * run's console outcome and its failure phenotype can never disagree about
+ * whether it recovered. It reads only the derived steps, never `meta.outcome`,
+ * precisely so `deriveRunOutcome` can call it while it is still *computing*
+ * `meta.outcome`.
+ */
+export function recoveredAfterErrors(session) {
+    const substantive = substantiveSteps(session);
+    if (substantive.length === 0)
+        return false;
+    const last = substantive[substantive.length - 1];
+    if (last.outcome === 'error')
+        return false;
+    const lastErrorOrdinal = lastStepOrdinalOf(session, (s) => s.outcome === 'error');
+    if (lastErrorOrdinal === undefined)
+        return true;
+    const failedSignatures = new Set();
+    for (const s of session.steps) {
+        if (s.outcome === 'error')
+            failedSignatures.add(workSignature(s));
+    }
+    return substantive.some((s) => s.ordinal > lastErrorOrdinal &&
+        s.outcome === 'ok' &&
+        !HUMAN_FACING_TOOLS.has(s.tool ?? s.lane) &&
+        failedSignatures.has(workSignature(s)));
+}
 /**
  * False-termination: the session stopped with an unresolved error.
  *
  * Rubric:
  * - meta outcome is `errored`, and
  * - at least one step outcome is `error`, and
- * - the last non-thinking step is an error or is followed by no successful recovery.
+ * - the run did not causally recover ({@link recoveredAfterErrors}).
  */
 function isFalseTermination(session) {
     if (session.meta.outcome !== 'errored')
         return false;
     if (session.meta.errorCount === 0)
         return false;
-    const substantive = substantiveSteps(session);
-    if (substantive.length === 0)
-        return true;
-    const last = substantive[substantive.length - 1];
-    if (last.outcome === 'error')
-        return true;
-    const lastErrorOrdinal = lastStepOrdinalOf(session, (s) => s.outcome === 'error');
-    if (lastErrorOrdinal === undefined)
-        return false;
-    const recoveryAfter = substantive.some((s) => s.ordinal > lastErrorOrdinal && s.outcome === 'ok' && !HUMAN_FACING_TOOLS.has(s.tool ?? s.lane));
-    return !recoveryAfter;
+    return !recoveredAfterErrors(session);
 }
 function reasonFalseTermination(session) {
     const substantive = substantiveSteps(session);
@@ -192,13 +237,21 @@ function reasonFalseTermination(session) {
     return 'errored with no successful recovery after the last error';
 }
 /**
- * Premature-completion: declared done while tests were failing or no verification
- * step ran for an engineering task.
+ * Premature-completion: declared done without a verification step for an
+ * engineering task.
  *
  * Rubric:
  * - meta outcome is `completed`, and
  * - the session performed write/edit work, and
- * - either errors were present or no test/build/lint verification step ran.
+ * - no test/build/lint verification step ran.
+ *
+ * `errorCount` is deliberately NOT a signal here. Under truthful outcomes
+ * (PHNX-3387) a `completed` run CAN carry `errorCount > 0` — that is precisely a
+ * recover-then-succeed run, where the errors were *resolved*, not left hanging.
+ * Keying prematurity off `errorCount > 0` would mislabel every such recovery as
+ * premature. (Under the pre-PHNX-3387 `errorCount > 0 ? errored : completed`
+ * derivation this branch was unreachable — a `completed` run always had
+ * `errorCount === 0` — so dropping it changes nothing for a clean-completed run.)
  */
 function isPrematureCompletion(session) {
     if (session.meta.outcome !== 'completed')
@@ -206,8 +259,6 @@ function isPrematureCompletion(session) {
     const didWriteEdit = session.steps.some((s) => WRITE_EDIT_TOOLS.has(s.tool ?? s.lane));
     if (!didWriteEdit)
         return false;
-    if (session.meta.errorCount > 0)
-        return true;
     const verified = session.steps.some((s) => {
         if (!SHELL_TOOLS.has(s.tool ?? s.lane))
             return false;
@@ -216,10 +267,7 @@ function isPrematureCompletion(session) {
     });
     return !verified;
 }
-function reasonPrematureCompletion(session) {
-    if (session.meta.errorCount > 0) {
-        return `declared completed with ${session.meta.errorCount} unresolved error(s)`;
-    }
+function reasonPrematureCompletion(_session) {
     return 'engineering work completed without a test/build/lint verification step';
 }
 /** Ordered rubric: the first matching phenotype wins. */
@@ -391,9 +439,9 @@ const OUTCOME_RULES = [
  * Classify the failure phenotype of a session from its derived trajectory.
  *
  * Definitions (from agent-failure research):
- * - `false-termination`  — stopped with an unresolved error.
- * - `premature-completion` — declared done while tests were failing or no
- *   verification step ran for the engineering work.
+ * - `false-termination`  — stopped with an unresolved error (did not causally recover).
+ * - `premature-completion` — declared done with no verification step for the
+ *   engineering work.
  * - `out-of-order` — a write/edit step occurred before any read/plan of the
  *   target.
  * - `failure-to-act` — stalled or produced no meaningful tool use.

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

@@ -49,6 +49,14 @@ export interface SyncResult {
     parseFailed: number;
     /** Parsed fine but the upload PUT failed (network/5xx) — retried on the next sync. */
     uploadFailed: number;
+    /**
+     * The index shard build or upload failed. Undefined on success. The per-session
+     * data still uploaded (that loop runs first), but the aggregated console shard —
+     * stats, needs-attention, failure clusters, latency — was NOT refreshed, so the
+     * console keeps serving the last good index. Surfaced (not swallowed) so a stale
+     * console is diagnosable instead of looking like a clean sync. See PHNX-3401.
+     */
+    indexError?: string;
 }
 /** Push derived, redacted trajectories for this device to the traces store. */
 export declare function syncTraces(opts?: SyncOpts): Promise<SyncResult>;
@@ -106,6 +114,13 @@ export interface ToolCallRow {
     session_id: string;
     ordinal: number;
     timestamp: string;
+    /**
+     * When the call's result arrived — its own end time (PHNX-3437). Optional
+     * because rows an older extractor stored, and calls that never produced a
+     * result, carry NULL; `computeInsights` falls back to the bounded inter-call
+     * gap when it is absent.
+     */
+    end_timestamp?: string | null;
     tool: string;
     outcome: string;
     exit_code: number | null;

package/dist/lib/traces/sync.js

@@ -22,7 +22,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { getDB, readSessionInsights, readSessionTopics, writeSessionInsights, writeSessionTopics, } from '../session/db.js';
+import { getDB, readSessionInsights, readSessionPhenotypes, readSessionTopics, writeSessionInsights, writeSessionPhenotypes, writeSessionTopics, } from '../session/db.js';
 import { parseSession } from '../session/parse.js';
 import { buildTrajectory } from '../session/trajectory.js';
 import { computeInsightFacets } from '../session/insights.js';
@@ -31,6 +31,7 @@ import { getRuntimeStateDir } from '../state.js';
 import { resolveTracesBackend } from './backend.js';
 import { classifyCause, classifyTopic, computeDriftSignal, } from './classify.js';
 import { computeInsights } from './insights.js';
+import { classifyPhenotype, recoveredAfterErrors } from './phenotype.js';
 /** Push derived, redacted trajectories for this device to the traces store. */
 export async function syncTraces(opts = {}) {
     const dryRun = opts.dryRun === true;
@@ -147,6 +148,7 @@ export async function syncTraces(opts = {}) {
             recordFailure(row, 'upload-failed', err);
         }
     }
+    let indexError;
     if (!opts.skipIndex) {
         try {
             const allRows = db
@@ -172,8 +174,13 @@ export async function syncTraces(opts = {}) {
                 await putIndexShard(backend, device, owner, shard);
             }
         }
-        catch {
-            // index PUT/write failure is not fatal — the per-session data is already written
+        catch (err) {
+            // Not fatal to the per-session upload (that loop already ran), but it DOES
+            // mean the console shard is now stale. Record it so the caller can surface a
+            // warning instead of reporting a clean, green sync — a silent swallow here is
+            // exactly what let a 59h-stale, insight-less index hide in plain sight
+            // (PHNX-3401). Do NOT re-throw: the session data is durable and worth keeping.
+            indexError = err instanceof Error ? err.message : String(err);
         }
     }
     // A dry-run never advances the incremental watermark: it is a read-only export.
@@ -203,6 +210,7 @@ export async function syncTraces(opts = {}) {
         transcriptUnavailable,
         parseFailed,
         uploadFailed,
+        indexError,
     };
 }
 function percentile(values, ratio) {
@@ -247,6 +255,32 @@ function attentionFlags(errorCount, facets) {
         flags.push(`${correctionCount} correction${correctionCount === 1 ? '' : 's'}`);
     return flags;
 }
+/**
+ * Persist a derived-cache warm-up (topics / insights) without letting a
+ * contended DB take down the whole index build.
+ *
+ * These write-backs only speed up the NEXT sync — the shard about to be built
+ * reads from the in-memory `topics` / `insights` maps that were already
+ * populated above, never from what this write persists. So the write is
+ * genuinely optional to the shard's correctness.
+ *
+ * Yet it was the single point that broke the console: on an active machine the
+ * Rush app holds `sessions.db`, this `BEGIN IMMEDIATE` waits out the 30s
+ * `busy_timeout` and throws `SQLITE_BUSY`, the throw escaped `buildIndexShard`,
+ * and `syncTraces` swallowed it — so the index (with wasted-time / failure
+ * clusters / latency) never re-uploaded and the dashboard sat 59h stale
+ * (PHNX-3401). Isolating the failure here keeps the index building; the warning
+ * makes the degraded cache visible instead of silent.
+ */
+function persistDerivedCache(label, write) {
+    try {
+        write();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`traces: ${label} cache warm-up skipped (${msg}) — index still built`);
+    }
+}
 /** Build the redacted rich console shard from indexed metadata and derived caches. */
 export function buildIndexShard(rows, device, owner, prevShard) {
     const db = getDB();
@@ -256,7 +290,7 @@ export function buildIndexShard(rows, device, owner, prevShard) {
     for (let i = 0; i < ids.length; i += 400) {
         const chunk = ids.slice(i, i + 400);
         calls.push(...db.prepare(`
-      SELECT session_id, ordinal, timestamp, tool, outcome, exit_code, status_code, error_code, error, parse_error
+      SELECT session_id, ordinal, timestamp, end_timestamp, tool, outcome, exit_code, status_code, error_code, error, parse_error
       FROM tool_calls
       WHERE session_id IN (${chunk.map(() => '?').join(',')})
     `).all(...chunk));
@@ -283,26 +317,52 @@ export function buildIndexShard(rows, device, owner, prevShard) {
         topics.set(row.id, topic);
         return { id: row.id, fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size, topic };
     });
-    writeSessionTopics(missingTopics);
+    persistDerivedCache('session-topics', () => writeSessionTopics(missingTopics));
+    // Insights (frictionSignals) and phenotype (false-termination / …) both need
+    // the parsed transcript, which flat tool_calls rows don't carry — so both are
+    // lazily derived per-session and cached by transcript mtime+size, then read for
+    // the WHOLE corpus (`rows` = allRows) every sync. That full-corpus read is what
+    // keeps the phenotype grouping dimension consistent: a session synced weeks ago
+    // still contributes its real phenotype from cache, so it can never fragment away
+    // from an identically-signatured session synced this run purely by *when* each
+    // was first seen (PHNX-3327). A cache-miss row is parsed at most once here even
+    // when both derivations are missing.
     const insights = readSessionInsights(ids);
+    const phenotypes = readSessionPhenotypes(ids);
     const missingInsights = [];
-    for (const row of rows.filter((candidate) => !insights.has(candidate.id))) {
+    const missingPhenotypes = [];
+    for (const row of rows) {
+        const needInsights = !insights.has(row.id);
+        const needPhenotype = !phenotypes.has(row.id);
+        if (!needInsights && !needPhenotype)
+            continue;
+        let events;
         try {
-            const events = parseSession(row.file_path, row.agent);
-            const facets = computeInsightFacets(events);
-            insights.set(row.id, facets);
-            missingInsights.push({
-                id: row.id,
-                fileMtimeMs: row.file_mtime_ms,
-                fileSize: row.file_size,
-                facets,
-            });
+            events = parseSession(row.file_path, row.agent);
         }
         catch {
-            continue;
+            continue; // gone/unreadable transcript — leave both uncached, same as before
+        }
+        if (needInsights) {
+            try {
+                const facets = computeInsightFacets(events);
+                insights.set(row.id, facets);
+                missingInsights.push({ id: row.id, fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size, facets });
+            }
+            catch { /* leave this session's facets uncached; recompute next sync */ }
+        }
+        if (needPhenotype) {
+            try {
+                const traj = buildTrajectory(events, rowToMeta(row), { redact: true, knownSecrets });
+                const phenotype = classifyPhenotype(buildSessionDetail(traj));
+                phenotypes.set(row.id, phenotype);
+                missingPhenotypes.push({ id: row.id, fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size, phenotype });
+            }
+            catch { /* leave this session's phenotype uncached; recompute next sync */ }
         }
     }
-    writeSessionInsights(missingInsights);
+    persistDerivedCache('session-insights', () => writeSessionInsights(missingInsights));
+    persistDerivedCache('session-phenotypes', () => writeSessionPhenotypes(missingPhenotypes));
     const needsAttention = rows.flatMap((row) => {
         const facets = insights.get(row.id);
         const errorCount = errorCounts.get(row.id) ?? 0;
@@ -361,7 +421,7 @@ 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(rows, calls, prevShard);
+    const patternInsights = computeInsights(rows, calls, prevShard, phenotypes);
     return {
         schema: 1,
         device,
@@ -404,6 +464,31 @@ function buildWhereItWentWrong(traj) {
         return null;
     return `This run hit ${parts.join('; ')}.`;
 }
+/**
+ * Truthful run-level outcome (PHNX-3387).
+ *
+ * A run with zero tool errors `completed`. A run that hit tool errors is
+ * `completed` ONLY when it *causally recovered* — a substantive, non-human-facing
+ * tool step succeeded strictly after the last error AND resolved the failed work
+ * (its work signature matches an errored step's), the exact predicate the
+ * false-termination phenotype uses ({@link recoveredAfterErrors}). A run whose
+ * last substantive step is the error, whose only post-error steps are human-facing
+ * (a punt to `AskUserQuestion` — the case the broken "last tool call ok" heuristic
+ * mislabeled `completed`), or whose only post-error success is unrelated work (a
+ * failed `bun test` followed by an incidental `ls`) stays `errored`.
+ *
+ * This is what makes `surfacedToolFailures` on a `completed` run honest: those
+ * are failures the run recovered from, not a green status hiding an unresolved
+ * failure. It never flips a run that ended unresolved to `completed` (no
+ * regression vs the old `errorCount > 0 ? errored : completed`), and it does not
+ * flip a run whose failed work was never resolved just because some later,
+ * unrelated call happened to succeed.
+ */
+function deriveRunOutcome(traj) {
+    if (traj.errorCount === 0)
+        return 'completed';
+    return recoveredAfterErrors({ steps: traj.steps }) ? 'completed' : 'errored';
+}
 /**
  * Map the derived trajectory to the console's SessionDetail shape, stripping
  * local-machine PII (full cwd, account) that would expose filesystem paths if
@@ -423,7 +508,7 @@ export function buildSessionDetail(traj) {
             errorCount: traj.errorCount,
             tokens: stats.outputTokens ?? 0,
             costUsd: s.costUsd ?? 0,
-            outcome: traj.errorCount > 0 ? 'errored' : 'completed',
+            outcome: deriveRunOutcome(traj),
             repo,
             agent: s.agent,
             model: s.model ?? 'unknown',

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

@@ -8,9 +8,19 @@
 // Routes (all require Phoenix bearer + userId owner match):
 //   PUT  /<userId>/<device>/index.json            — per-device stats shard
 //   PUT  /<userId>/<device>/sessions/<id>.json    — per-session SessionDetail
-//   GET  /<userId>/...                            — returns the stored object
+//   GET  /<userId>/<device>/...                   — returns the stored object
+//   GET  /<userId>/all/index.json                 — cross-device merge (read-side)
+//   GET  /<userId>/all/sessions/<id>.json         — first device that holds <id>
 //   GET  /                                        — 200 description (no data)
 //
+// The CLI writes per-device (`localDevice()` == hostname); the console asks for
+// the "all agents" view (`/all/`). `all` is not a real device — the worker
+// synthesizes it on read by listing this owner's device prefixes and merging.
+// A single device is an exact passthrough; cross-device stats that need the raw
+// sample (median, latency percentiles) are session-weighted approximations,
+// documented at the merge site. This keeps the CLI unchanged and uploads nothing
+// extra — the per-device shards already in R2 are the source (PHNX-3397).
+//
 // Emitted as a string so it compiles into dist/** and ships with no
 // package.json#files change. `provisionTraces.ts` uploads this verbatim as an
 // ES-module Worker with a BUCKET (R2) binding + a PHOENIX_ID_BASE secret.
@@ -79,6 +89,13 @@ async function handleGet(request, env, path) {
   const auth = await authorizeRead(request, env, path);
   if (auth.error) return auth.error;
 
+  const segments = path.split('/').filter(Boolean);
+  // The "all agents" view is synthesized, not stored: merge this owner's device
+  // shards on read. segments[0] === owner is already enforced by authorizeRead.
+  if (segments[1] === 'all') {
+    return handleAggregate(request, env, segments[0], segments.slice(2).join('/'));
+  }
+
   const object = await env.BUCKET.get(path);
   if (!object) return json({ error: 'not found' }, 404);
 
@@ -87,6 +104,142 @@ async function handleGet(request, env, path) {
   return new Response(object.body, { headers });
 }
 
+// Enumerate this owner's real device names (never 'all') using a delimited list
+// so we read one page of prefixes, not every session object.
+async function listDevices(env, owner) {
+  const listed = await env.BUCKET.list({ prefix: owner + '/', delimiter: '/' });
+  const prefixes = (listed && listed.delimitedPrefixes) || [];
+  const base = owner + '/';
+  return prefixes
+    .map((p) => (p.startsWith(base) ? p.slice(base.length) : p).replace(/\\/+$/, ''))
+    .filter((d) => d && d !== 'all');
+}
+
+async function handleAggregate(request, env, owner, rest) {
+  const devices = await listDevices(env, owner);
+  if (devices.length === 0) return json({ error: 'not found' }, 404);
+
+  // A single session drill-down: the shard lives under whichever device owns it.
+  if (rest.startsWith('sessions/')) {
+    for (const device of devices) {
+      const object = await env.BUCKET.get(owner + '/' + device + '/' + rest);
+      if (object) {
+        const headers = new Headers(object.httpMetadata ?? {});
+        headers.set('cache-control', 'private, no-store');
+        return new Response(object.body, { headers });
+      }
+    }
+    return json({ error: 'not found' }, 404);
+  }
+
+  if (rest === 'index.json') {
+    const shards = [];
+    for (const device of devices) {
+      const object = await env.BUCKET.get(owner + '/' + device + '/index.json');
+      if (!object) continue;
+      try {
+        shards.push(JSON.parse(await object.text()));
+      } catch {
+        // A corrupt per-device shard must not sink the whole aggregate.
+      }
+    }
+    if (shards.length === 0) return json({ error: 'not found' }, 404);
+    return json(mergeIndexShards(shards, owner), 200);
+  }
+
+  return json({ error: 'not found' }, 404);
+}
+
+// Merge per-device index shards into one "all agents" shard. One device is an
+// exact passthrough (relabelled). For many, counts sum and lists concat+resort;
+// median/latency percentiles cannot be recomputed without the raw per-session
+// sample, so they are session-count-weighted approximations — good enough for an
+// at-a-glance fleet view, and exact the moment you filter to a single device.
+function mergeIndexShards(shards, owner) {
+  if (shards.length === 1) {
+    return Object.assign({}, shards[0], { device: 'all', owner });
+  }
+  const sorted = shards.slice().sort((a, b) => (b.syncedAt || 0) - (a.syncedAt || 0));
+  const totalSessions = sorted.reduce((n, s) => n + ((s.stats && s.stats.sessionsImported) || 0), 0) || 1;
+  const wsum = (pick) => sorted.reduce((n, s) => n + (pick(s) || 0) * ((s.stats && s.stats.sessionsImported) || 0), 0) / totalSessions;
+
+  const topicCounts = new Map();
+  for (const s of sorted) for (const t of s.topics || []) {
+    const cur = topicCounts.get(t.key) || Object.assign({}, t, { count: 0 });
+    cur.count += t.count || 0;
+    topicCounts.set(t.key, cur);
+  }
+  const byToolError = new Map();
+  let real = 0, guard = 0, hook = 0;
+  for (const s of sorted) {
+    const f = s.failures || {};
+    for (const e of f.byToolError || []) {
+      const key = e.tool + '\\u0000' + e.desc + '\\u0000' + e.cause;
+      const cur = byToolError.get(key) || Object.assign({}, e, { count: 0 });
+      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;
+  }
+  // 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
+  // AND on CI) is ONE ranked issue with combined counts, not two half-counted rows.
+  const patternById = new Map();
+  for (const s of sorted) for (const p of s.failurePatterns || []) {
+    const cur = patternById.get(p.id);
+    if (!cur) {
+      patternById.set(p.id, Object.assign({}, p, { exampleSessionIds: (p.exampleSessionIds || []).slice(0, 5) }));
+    } else {
+      cur.sessions += p.sessions || 0;
+      cur.occurrences += p.occurrences || 0;
+      cur.wastedMs += p.wastedMs || 0;
+      for (const id of p.exampleSessionIds || []) {
+        if (cur.exampleSessionIds.length < 5 && !cur.exampleSessionIds.includes(id)) cur.exampleSessionIds.push(id);
+      }
+    }
+  }
+  const latencies = sorted.map((s) => s.latency).filter(Boolean);
+
+  return {
+    schema: 1,
+    device: 'all',
+    owner,
+    syncedAt: sorted[0].syncedAt || 0,
+    stats: {
+      sessionsImported: sorted.reduce((n, s) => n + ((s.stats && s.stats.sessionsImported) || 0), 0),
+      medianMs: Math.round(wsum((s) => s.stats && s.stats.medianMs)),
+      p90Ms: Math.max.apply(null, sorted.map((s) => (s.stats && s.stats.p90Ms) || 0)),
+      needAttention: sorted.reduce((n, s) => n + ((s.stats && s.stats.needAttention) || 0), 0),
+      toolErrorRate: wsum((s) => s.stats && s.stats.toolErrorRate),
+    },
+    needsAttention: sorted.flatMap((s) => s.needsAttention || [])
+      .sort((a, b) => (b.severity || 0) - (a.severity || 0) || String(a.id).localeCompare(String(b.id)))
+      .slice(0, 100),
+    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 },
+    },
+    failurePatterns: Array.from(patternById.values())
+      .sort((a, b) => (b.wastedMs || 0) - (a.wastedMs || 0)).slice(0, 25),
+    wastedMsTotal: sorted.reduce((n, s) => n + (s.wastedMsTotal || 0), 0),
+    latency: latencies.length ? {
+      firstToolMs: {
+        p50: Math.round(wsum((s) => s.latency && s.latency.firstToolMs && s.latency.firstToolMs.p50)),
+        p90: Math.max.apply(null, latencies.map((l) => (l.firstToolMs && l.firstToolMs.p90) || 0)),
+        p99: Math.max.apply(null, latencies.map((l) => (l.firstToolMs && l.firstToolMs.p99) || 0)),
+        max: Math.max.apply(null, latencies.map((l) => (l.firstToolMs && l.firstToolMs.max) || 0)),
+      },
+    } : undefined,
+    // Rolling history / drift are per-device time series; the freshest device's
+    // are the most representative for the merged view without double-counting.
+    bucketHistory: sorted[0].bucketHistory || [],
+    driftSignals: sorted[0].driftSignals || [],
+  };
+}
+
 // Require a Phoenix bearer that owns the path prefix.
 async function authorizeRead(request, env, path) {
   const claims = await hooks.verifyPhoenixToken(request, env);

package/package.json

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