@phnx-labs/agents-cli 1.22.57 → 1.22.59

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>;
@@ -59,18 +67,46 @@ export interface TracesIndexShard {
     owner: string;
     stats: {
         sessionsImported: number;
+        /**
+         * Median ACTIVE duration (span − idle gaps > 120s), ms — the meaningful figure
+         * (PHNX-3457). Same key/shape as before this change, so the fleet-aggregate
+         * worker (`worker-template.ts`) keeps weighted-averaging it unchanged; only its
+         * VALUE moved from raw span to active time. The raw span stays available per
+         * session on `SessionDetail.meta.spanMs`.
+         */
         medianMs: number;
+        /** p90 ACTIVE duration, ms. */
         p90Ms: number;
+        /**
+         * SEGMENTED active-time stats (PHNX-3472). The blended `medianMs`/`p90Ms`
+         * above conflate one-shot interactive queries (63% of the corpus, ~15s
+         * median) with substantial agent runs (~15min median), so they headline
+         * neither. A session is an AGENT run when it made any tool call OR has more
+         * than 8 messages; otherwise INTERACTIVE. These segment the same active-time
+         * figure so the console can headline agent runs on their own axis. Each is
+         * computed only over sessions with a non-null duration.
+         */
+        agentMedianMs: number;
+        /** p90 ACTIVE duration over AGENT sessions, ms. */
+        agentP90Ms: number;
+        /** Median ACTIVE duration over INTERACTIVE sessions, ms. */
+        interactiveMedianMs: number;
+        /** (sessions with a non-null duration) / (total sessions), 0..1 — coverage of the duration stats. */
+        measuredFraction: number;
         needAttention: number;
         toolErrorRate: number;
     };
+    /**
+     * Sessions excluded from the eval corpus as internal utility plumbing (PHNX-3474):
+     * single-shot machine calls (no tool call AND ≤2 messages) or a known
+     * internal-prompt signature (title generation, watchdog, commit-message, factory
+     * worker). Every `stats` figure above, `topics` counts, and `needsAttention` are
+     * computed over the AGENT set ONLY — `sessionsImported` is the real agent count,
+     * not the raw row count. This is the number that was dropped.
+     */
+    utilityCount: number;
     needsAttention: IndexedSession[];
-    topics: Array<{
-        key: string;
-        label: string;
-        count: number;
-        group: TraceTopicGroup;
-    }>;
+    topics: TopicItem[];
     failures: {
         byToolError: Array<{
             tool: string;
@@ -96,16 +132,68 @@ export interface IndexedSession {
     title: string;
     repo: string;
     device: string;
+    /** The harness that produced the session (claude/codex/rush/grok/…). Same as `harness`. */
     agent: string;
     model: string;
+    /** Corpus classification (PHNX-3474). Always `'agent'` here — utility rows are excluded. */
+    kind: SessionKind;
     severity: number;
     flags: string[];
 }
+/**
+ * One example session under a topic tile — the shape the console drill-down consumes.
+ * Carries `kind` + `harness` (PHNX-3474) so the console can filter a tile's session
+ * list by corpus class and by harness. Refs on a topic tile are always `'agent'`
+ * (utility rows never reach a bucket), but the field is explicit for the consumer.
+ */
+export interface TopicSessionRef {
+    id: string;
+    title: string;
+    kind: SessionKind;
+    harness: string;
+}
+/**
+ * Corpus class of a session (PHNX-3474). `utility` is internal machine plumbing —
+ * a single-shot call with no tool use and ≤2 messages, or one whose topic/label
+ * matches a known internal-prompt signature (title generation, watchdog,
+ * commit-message writer, factory worker). Everything else is `agent`: real agent
+ * work the Evals console counts and scores. Utility rows are tagged, never deleted,
+ * and excluded from every index statistic.
+ */
+export type SessionKind = 'utility' | 'agent';
+/**
+ * Classify a session as internal `utility` plumbing vs real `agent` work (PHNX-3474).
+ * `toolCallCount` is the AUTHORITATIVE per-session tool-call count from the loaded
+ * `tool_calls` rows (the row's own `tool_call_count` column is a fallback for a row
+ * whose calls weren't loaded). A session is `utility` when a known internal-prompt
+ * signature matches its topic/label, OR it made no tool call AND has ≤2 messages —
+ * the single-shot machine-call shape. Otherwise it is `agent`.
+ */
+export declare function classifySessionKind(row: Pick<SyncRow, 'topic' | 'label' | 'message_count' | 'tool_call_count'>, toolCallCount: number): SessionKind;
+/**
+ * One topic bucket in the treemap. `sessions` carries up to {@link TOPIC_SESSION_CAP}
+ * example refs so the console can drill from the tile into its session list — a tile
+ * with no refs renders display-only (PHNX-3408). `count` stays the true total.
+ */
+export interface TopicItem {
+    key: string;
+    label: string;
+    count: number;
+    group: TraceTopicGroup;
+    sessions: TopicSessionRef[];
+}
 /** A row from `tool_calls`. `ordinal`/`timestamp` order calls within a session for computeInsights(). */
 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;
@@ -114,6 +202,31 @@ export interface ToolCallRow {
     error: string | null;
     parse_error: string | null;
 }
+/**
+ * Active time for a session in the index shard: its recorded span minus every idle
+ * gap > 120s (PHNX-3457). The index build already holds the ordered `tool_calls`
+ * rows for the whole corpus, so idle is derived from them here — no transcript
+ * re-parse. A cursor sweeps the span from `sessionStartMs`: each stretch where the
+ * cursor sits idle for more than the threshold before the next call starts is
+ * subtracted, and idle is measured from a call's END (its own `end_timestamp` when
+ * known, else its start) so a call's own blocking duration is never mistaken for
+ * idle. Crucially the sweep also books the gaps at the two BOUNDARIES — before the
+ * first call and after the last call to the session end — so a session with a lone
+ * tool call that was then abandoned and resumed hours later (the case a
+ * between-calls-only measure missed entirely, leaving the whole 345h span counted
+ * as active) has that trailing idle stripped. A session end is `sessionStartMs +
+ * spanMs`, so the two agree by construction.
+ *
+ * Bounded to `[0, spanMs]`. A session with NO tool calls returns the full span
+ * unchanged rather than a fabricated zero: there is no tool-call evidence of idle
+ * either way, and treating a chat-only turn as 100% idle would be a worse error
+ * than leaving its span uncorrected. Where the full event stream IS available (a
+ * per-session `SessionDetail`), {@link activeMsFromTrajectory} is used instead —
+ * it sees message events this call-only approximation cannot, so the two are close
+ * but not identical by design (the corpus-scale index build cannot afford the
+ * per-session parse the detail view does).
+ */
+export declare function sessionActiveMs(spanMs: number, sessionCalls: ToolCallRow[], sessionStartMs: number): number;
 /** Human description of a failed call, keyed by (tool, desc, cause) for grouping. Exported for computeInsights(). */
 export declare function failureDescription(call: ToolCallRow, cause: TraceFailureCause): string;
 /** Build the redacted rich console shard from indexed metadata and derived caches. */
@@ -123,7 +236,16 @@ export interface SessionDetail {
     schema: 1;
     id: string;
     meta: {
+        /** Raw wall-clock span (last event − first event), idle time included. */
         spanMs: number;
+        /**
+         * Active time: `spanMs` minus every idle gap > 120s (PHNX-3457). A session
+         * resumed hours later, or left idle mid-turn, inflates `spanMs` with wall-clock
+         * the agent did no work in — active time strips those gaps so a duration reads
+         * as effort, not calendar span. This is what the console's duration median/p90
+         * should trust; `spanMs` stays available as the raw figure.
+         */
+        activeMs: number;
         turns: number;
         tools: number;
         errorCount: number;

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,14 +210,112 @@ export async function syncTraces(opts = {}) {
         transcriptUnavailable,
         parseFailed,
         uploadFailed,
+        indexError,
     };
 }
+/**
+ * Topic/label substrings that identify an internal-prompt session regardless of its
+ * message/tool shape. These are the harness-spawned utility prompts the Rush app
+ * fires (they run under the `claude` harness): title generation writes the 3–4 word
+ * session title, the watchdog polls for stalled agents, the commit-message writer
+ * drafts a conventional commit, and factory workers are dispatched sub-agents. The
+ * title-generation prompt lives in the `topic` column, the rest can land in either
+ * `topic` or `label`, so both are matched.
+ */
+const UTILITY_PROMPT_SIGNATURES = [
+    /generate a 3-4 word title/i, // title generation
+    /you are a watchdog|watchdog monitoring/i, // watchdog tick
+    /conventional[- ]commit/i, // commit-message writer
+    /factory worker/i, // dispatched factory worker
+];
+/**
+ * Classify a session as internal `utility` plumbing vs real `agent` work (PHNX-3474).
+ * `toolCallCount` is the AUTHORITATIVE per-session tool-call count from the loaded
+ * `tool_calls` rows (the row's own `tool_call_count` column is a fallback for a row
+ * whose calls weren't loaded). A session is `utility` when a known internal-prompt
+ * signature matches its topic/label, OR it made no tool call AND has ≤2 messages —
+ * the single-shot machine-call shape. Otherwise it is `agent`.
+ */
+export function classifySessionKind(row, toolCallCount) {
+    const haystack = `${row.topic ?? ''}\n${row.label ?? ''}`;
+    if (UTILITY_PROMPT_SIGNATURES.some((re) => re.test(haystack)))
+        return 'utility';
+    const hasToolCalls = toolCallCount > 0 || (row.tool_call_count ?? 0) > 0;
+    const messages = row.message_count ?? 0;
+    if (!hasToolCalls && messages <= 2)
+        return 'utility';
+    return 'agent';
+}
 function percentile(values, ratio) {
     if (values.length === 0)
         return 0;
     const sorted = [...values].sort((a, b) => a - b);
     return sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * ratio) - 1)];
 }
+/**
+ * A delta between consecutive events longer than this reads as an idle stall, not
+ * work — the same threshold the trajectory uses for its gap detection
+ * (`DEFAULT_IDLE_THRESHOLD_MS`, trajectory.ts). Kept in lockstep so active time
+ * here and the gaps drawn in a session's detail view agree on what "idle" means.
+ */
+const IDLE_GAP_THRESHOLD_MS = 120_000;
+/** Max example session refs carried per topic tile so a tile is drillable (PHNX-3408). */
+const TOPIC_SESSION_CAP = 30;
+/**
+ * Active time for a session in the index shard: its recorded span minus every idle
+ * gap > 120s (PHNX-3457). The index build already holds the ordered `tool_calls`
+ * rows for the whole corpus, so idle is derived from them here — no transcript
+ * re-parse. A cursor sweeps the span from `sessionStartMs`: each stretch where the
+ * cursor sits idle for more than the threshold before the next call starts is
+ * subtracted, and idle is measured from a call's END (its own `end_timestamp` when
+ * known, else its start) so a call's own blocking duration is never mistaken for
+ * idle. Crucially the sweep also books the gaps at the two BOUNDARIES — before the
+ * first call and after the last call to the session end — so a session with a lone
+ * tool call that was then abandoned and resumed hours later (the case a
+ * between-calls-only measure missed entirely, leaving the whole 345h span counted
+ * as active) has that trailing idle stripped. A session end is `sessionStartMs +
+ * spanMs`, so the two agree by construction.
+ *
+ * Bounded to `[0, spanMs]`. A session with NO tool calls returns the full span
+ * unchanged rather than a fabricated zero: there is no tool-call evidence of idle
+ * either way, and treating a chat-only turn as 100% idle would be a worse error
+ * than leaving its span uncorrected. Where the full event stream IS available (a
+ * per-session `SessionDetail`), {@link activeMsFromTrajectory} is used instead —
+ * it sees message events this call-only approximation cannot, so the two are close
+ * but not identical by design (the corpus-scale index build cannot afford the
+ * per-session parse the detail view does).
+ */
+export function sessionActiveMs(spanMs, sessionCalls, sessionStartMs) {
+    if (spanMs <= 0)
+        return Math.max(0, spanMs);
+    if (!Number.isFinite(sessionStartMs))
+        return spanMs; // can't place calls on the span
+    const spanEndMs = sessionStartMs + spanMs;
+    const ordered = sessionCalls
+        .map((c) => ({ startMs: Date.parse(c.timestamp), endMs: Date.parse(c.end_timestamp ?? c.timestamp) }))
+        .filter((c) => Number.isFinite(c.startMs))
+        .sort((a, b) => a.startMs - b.startMs);
+    if (ordered.length === 0)
+        return spanMs; // no tool-call evidence of idle
+    let idleMs = 0;
+    let cursor = sessionStartMs;
+    for (const call of ordered) {
+        if (call.startMs > cursor + IDLE_GAP_THRESHOLD_MS)
+            idleMs += call.startMs - cursor;
+        const endMs = Number.isFinite(call.endMs) ? Math.max(call.endMs, call.startMs) : call.startMs;
+        if (endMs > cursor)
+            cursor = endMs;
+    }
+    // Trailing idle: the stretch from the last call's end to the session's end.
+    if (spanEndMs > cursor + IDLE_GAP_THRESHOLD_MS)
+        idleMs += spanEndMs - cursor;
+    return Math.max(0, spanMs - Math.min(idleMs, spanMs));
+}
+/** Active time from an already-built trajectory: span minus its idle gaps (all > threshold). */
+function activeMsFromTrajectory(traj) {
+    const idleMs = traj.gaps.reduce((sum, gap) => sum + gap.durationMs, 0);
+    return Math.max(0, traj.spanMs - Math.min(idleMs, traj.spanMs));
+}
 /** Human description of a failed call, keyed by (tool, desc, cause) for grouping. Exported for computeInsights(). */
 export function failureDescription(call, cause) {
     if (cause === 'guard')
@@ -247,6 +352,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,13 +387,14 @@ 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));
     }
     const toolMix = new Map();
     const errorCounts = new Map();
+    const callsBySession = new Map();
     for (const call of calls) {
         const mix = toolMix.get(call.session_id) ?? {};
         mix[call.tool] = (mix[call.tool] ?? 0) + 1;
@@ -270,9 +402,27 @@ export function buildIndexShard(rows, device, owner, prevShard) {
         if (call.outcome === 'error') {
             errorCounts.set(call.session_id, (errorCounts.get(call.session_id) ?? 0) + 1);
         }
+        const list = callsBySession.get(call.session_id);
+        if (list)
+            list.push(call);
+        else
+            callsBySession.set(call.session_id, [call]);
     }
-    const topics = readSessionTopics(ids);
-    const missingTopics = rows.filter((row) => !topics.has(row.id)).map((row) => {
+    // Classify every row as real `agent` work or internal `utility` plumbing, then run
+    // the ENTIRE rest of the shard build over the agent set ONLY (PHNX-3474). Utility
+    // rows — title-gen / watchdog / commit-message / factory-worker calls, ~68% of the
+    // corpus — are tagged and excluded here, never deleted from sessions.db, so the
+    // console counts and scores real agent work: `sessionsImported`, the medians,
+    // needs-attention, tool-error-rate, and the topic buckets all measure `agentRows`.
+    const kindOf = new Map(rows.map((row) => [row.id, classifySessionKind(row, callsBySession.get(row.id)?.length ?? 0)]));
+    const agentRows = rows.filter((row) => kindOf.get(row.id) === 'agent');
+    const agentIds = agentRows.map((row) => row.id);
+    const utilityCount = rows.length - agentRows.length;
+    // Tool calls belonging to utility rows never contribute to the failure/latency
+    // stats or the tool-error rate — filter them out at the source alongside the rows.
+    const agentCalls = calls.filter((call) => kindOf.get(call.session_id) === 'agent');
+    const topics = readSessionTopics(agentIds);
+    const missingTopics = agentRows.filter((row) => !topics.has(row.id)).map((row) => {
         const topic = classifyTopic({
             cwd: row.cwd,
             gitBranch: row.git_branch,
@@ -283,27 +433,53 @@ 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);
-    const insights = readSessionInsights(ids);
+    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(agentIds);
+    const phenotypes = readSessionPhenotypes(agentIds);
     const missingInsights = [];
-    for (const row of rows.filter((candidate) => !insights.has(candidate.id))) {
+    const missingPhenotypes = [];
+    for (const row of agentRows) {
+        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);
-    const needsAttention = rows.flatMap((row) => {
+    persistDerivedCache('session-insights', () => writeSessionInsights(missingInsights));
+    persistDerivedCache('session-phenotypes', () => writeSessionPhenotypes(missingPhenotypes));
+    const needsAttention = agentRows.flatMap((row) => {
         const facets = insights.get(row.id);
         const errorCount = errorCounts.get(row.id) ?? 0;
         const flags = attentionFlags(errorCount, facets);
@@ -318,17 +494,28 @@ export function buildIndexShard(rows, device, owner, prevShard) {
                 device,
                 agent: row.agent,
                 model: row.model ?? 'unknown',
+                kind: 'agent',
                 severity: errorCount * 2 + friction * 3 + corrections * 2,
                 flags,
             }];
     }).sort((a, b) => b.severity - a.severity || a.id.localeCompare(b.id));
     const topicCounts = new Map();
-    for (const topic of topics.values()) {
-        const current = topicCounts.get(topic.key) ?? { ...topic, count: 0 };
-        current.count++;
-        topicCounts.set(topic.key, current);
+    for (const row of agentRows) {
+        const topic = topics.get(row.id);
+        if (!topic)
+            continue;
+        const bucket = topicCounts.get(topic.key)
+            ?? { key: topic.key, label: topic.label, group: topic.group, count: 0, refs: [] };
+        bucket.count++;
+        bucket.refs.push({
+            id: row.id,
+            title: redactSecrets(row.label ?? row.topic ?? topic.label ?? 'Untitled session', knownSecrets),
+            harness: row.agent,
+            recencyMs: Date.parse(row.last_activity ?? row.timestamp) || 0,
+        });
+        topicCounts.set(topic.key, bucket);
     }
-    const failedCalls = calls.filter((call) => call.outcome === 'error');
+    const failedCalls = agentCalls.filter((call) => call.outcome === 'error');
     const byCause = { real: 0, guard: 0, hook: 0 };
     const failureCounts = new Map();
     for (const call of failedCalls) {
@@ -340,14 +527,38 @@ export function buildIndexShard(rows, device, owner, prevShard) {
         current.count++;
         failureCounts.set(key, current);
     }
-    const durations = rows.flatMap((row) => row.duration_ms == null ? [] : [row.duration_ms]);
+    // Duration stats run over ACTIVE time, not raw span (PHNX-3457): span minus idle
+    // gaps > 120s, derived per session from the tool_calls already loaded above. A
+    // session resumed after hours, or left idle mid-turn, otherwise inflates the
+    // median/p90 with wall-clock the agent did no work in (real corpus max span:
+    // 345h). The raw span stays available per session on `SessionDetail.meta.spanMs`.
+    const activeDurations = agentRows.flatMap((row) => row.duration_ms == null
+        ? []
+        : [sessionActiveMs(row.duration_ms, callsBySession.get(row.id) ?? [], Date.parse(row.timestamp))]);
+    // Segment the same active-time figure into AGENT vs INTERACTIVE runs (PHNX-3472).
+    // A session is an AGENT run when it made any tool call OR has more than 8
+    // messages; otherwise INTERACTIVE (a one-shot query). Only sessions with a
+    // non-null duration contribute to the medians; `measuredFraction` reports how
+    // much of the corpus that covers.
+    const agentActive = [];
+    const interactiveActive = [];
+    let measured = 0;
+    for (const row of agentRows) {
+        if (row.duration_ms == null)
+            continue;
+        measured++;
+        const active = sessionActiveMs(row.duration_ms, callsBySession.get(row.id) ?? [], Date.parse(row.timestamp));
+        const isAgent = (callsBySession.get(row.id)?.length ?? 0) > 0 || (row.message_count ?? 0) > 8;
+        (isAgent ? agentActive : interactiveActive).push(active);
+    }
+    const measuredFraction = agentRows.length === 0 ? 0 : measured / agentRows.length;
     // Build today's per-bucket stats for the rolling drift window.
     const todayDate = new Date().toISOString().slice(0, 10);
     const todayStats = [...topicCounts.values()].map(({ key }) => {
         const sessionsInBucket = [...topics.entries()]
             .filter(([, t]) => t.key === key)
             .map(([id]) => id);
-        const bucketCalls = calls.filter((c) => sessionsInBucket.includes(c.session_id));
+        const bucketCalls = agentCalls.filter((c) => sessionsInBucket.includes(c.session_id));
         const bucketErrors = bucketCalls.filter((c) => c.outcome === 'error').length;
         const errorRate = bucketCalls.length === 0 ? 0 : bucketErrors / bucketCalls.length;
         const stallCount = sessionsInBucket.filter((id) => {
@@ -361,21 +572,43 @@ 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(agentRows, agentCalls, prevShard, phenotypes);
     return {
         schema: 1,
         device,
         syncedAt: Date.now(),
         owner,
         stats: {
-            sessionsImported: rows.length,
-            medianMs: percentile(durations, 0.5),
-            p90Ms: percentile(durations, 0.9),
+            sessionsImported: agentRows.length,
+            medianMs: percentile(activeDurations, 0.5),
+            p90Ms: percentile(activeDurations, 0.9),
+            agentMedianMs: percentile(agentActive, 0.5),
+            agentP90Ms: percentile(agentActive, 0.9),
+            interactiveMedianMs: percentile(interactiveActive, 0.5),
+            measuredFraction,
             needAttention: needsAttention.length,
-            toolErrorRate: calls.length === 0 ? 0 : failedCalls.length / calls.length,
+            toolErrorRate: agentCalls.length === 0 ? 0 : failedCalls.length / agentCalls.length,
         },
+        utilityCount,
         needsAttention,
-        topics: [...topicCounts.values()].sort((a, b) => b.count - a.count || a.key.localeCompare(b.key)),
+        topics: [...topicCounts.values()]
+            .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key))
+            .map((bucket) => ({
+            key: bucket.key,
+            label: bucket.label,
+            count: bucket.count,
+            group: bucket.group,
+            // Up to TOPIC_SESSION_CAP most-recent example sessions, so the console can
+            // drill from a tile into its session list. Capped to keep the shard small;
+            // the tile's `count` remains the true total. These are correct on this
+            // per-device shard; the fleet-aggregate `/all` view (worker-template.ts,
+            // a must-not-touch R2 worker here) carries only the first device's refs
+            // per topic until PHNX-3464 merges them across devices.
+            sessions: bucket.refs
+                .sort((a, b) => b.recencyMs - a.recencyMs)
+                .slice(0, TOPIC_SESSION_CAP)
+                .map(({ id, title, harness }) => ({ id, title, kind: 'agent', harness })),
+        })),
         failures: {
             byToolError: [...failureCounts.values()].sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool)),
             byCause,
@@ -404,6 +637,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
@@ -418,12 +676,13 @@ export function buildSessionDetail(traj) {
         id: s.id,
         meta: {
             spanMs: traj.spanMs,
+            activeMs: activeMsFromTrajectory(traj),
             turns: (stats.userTurns ?? 0) + (stats.assistantTurns ?? 0),
             tools: stats.toolCount ?? 0,
             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',