@phnx-labs/agents-cli 1.22.58 → 1.22.60

package/dist/lib/teams/delivery.js

@@ -17,6 +17,10 @@ import { AgentStatus } from './agents.js';
  * When the process completed with a `prUrl` and merge is unknown or false,
  * delivery is `pr_open` — pessimistic: assume open until proven merged so an
  * orchestrator never mistakes "agent stopped" for "work on main".
+ *
+ * When the process completed with no PR and uncommitted changes remain in the
+ * worktree, delivery is `stranded` — the work exists only locally and will be
+ * lost if the worktree is cleaned up (PHNX-2951).
  */
 export function resolveTeammateDelivery(opts) {
     const status = String(opts.status);
@@ -30,8 +34,9 @@ export function resolveTeammateDelivery(opts) {
         return 'stopped';
     if (status === AgentStatus.COMPLETED || status === 'completed') {
         const prUrl = opts.prUrl?.trim();
-        if (!prUrl)
-            return 'no_pr';
+        if (!prUrl) {
+            return opts.hasUncommittedChanges ? 'stranded' : 'no_pr';
+        }
         if (opts.prMerged === true)
             return 'pr_merged';
         return 'pr_open';
@@ -40,21 +45,26 @@ export function resolveTeammateDelivery(opts) {
 }
 /**
  * Human label for `teams status` rows. Replaces bare COMPLETED with PR OPEN
- * when delivery is still pending merge.
+ * when delivery is still pending merge, and with STRANDED when uncommitted
+ * work is stranded in the worktree.
  */
 export function deliveryDisplayLabel(delivery, processStatus) {
     if (delivery === 'pr_open')
         return 'PR OPEN';
     if (delivery === 'pr_merged')
         return 'COMPLETED';
+    if (delivery === 'stranded')
+        return 'STRANDED';
     return String(processStatus).toUpperCase();
 }
 /**
- * Color key for statusColor-style switches. `pr_open` is its own key so the
- * row is visually distinct from green COMPLETED.
+ * Color key for statusColor-style switches. `pr_open` and `stranded` get their
+ * own keys so the rows are visually distinct from green COMPLETED.
  */
 export function deliveryColorKey(delivery, processStatus) {
     if (delivery === 'pr_open')
         return 'pr_open';
+    if (delivery === 'stranded')
+        return 'stranded';
     return String(processStatus);
 }

package/dist/lib/teams/scheduler.d.ts

@@ -48,6 +48,16 @@ export interface PlacementOptions {
     /** Human label of the requested agent (e.g. `claude@2.1.112`) for the
      * fail-loud message. */
     agentLabel?: string;
+    /**
+     * Normalized hosts boosted with `auto-launch.preferred` (set by
+     * `agents devices prefer <name>`). A preferred device ranks ahead of a
+     * non-preferred one among the eligible survivors — after the signed-in tier
+     * (a preferred box that can't run the agent is still no use) and before load,
+     * so an operator boost overrides load-based ordering without overriding hard
+     * health. Empty/undefined leaves the ranking unchanged. See
+     * {@link autoLaunchPreferredSet}.
+     */
+    preferred?: ReadonlySet<string>;
 }
 /** Why a device was excluded from the viable set, for the fail-loud message. */
 export type ExclusionReason = 'unreachable' | 'overloaded' | 'capped' | 'not-installed';

package/dist/lib/teams/scheduler.js

@@ -266,6 +266,14 @@ export function pickBestDevice(devices, roster, opts) {
         const signedIn = (sa?.signedIn === true ? 0 : 1) - (sb?.signedIn === true ? 0 : 1);
         if (signedIn !== 0)
             return signedIn;
+        // (a2) operator-preferred device next — `agents devices prefer <name>`
+        // boosts a box above its load-equal peers, overriding load-based order.
+        const preferred = opts?.preferred;
+        if (preferred && preferred.size > 0) {
+            const pref = (preferred.has(a) ? 0 : 1) - (preferred.has(b) ? 0 : 1);
+            if (pref !== 0)
+                return pref;
+        }
         // (b) lower load — coarse headroom tier, then raw load cost.
         const tier = headroomTier(sa?.headroom) - headroomTier(sb?.headroom);
         if (tier !== 0)

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

@@ -67,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;
@@ -104,11 +132,56 @@ 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;
@@ -129,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. */
@@ -138,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

@@ -213,12 +213,109 @@ export async function syncTraces(opts = {}) {
         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')
@@ -297,6 +394,7 @@ export function buildIndexShard(rows, device, owner, prevShard) {
     }
     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;
@@ -304,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,
@@ -327,11 +443,11 @@ export function buildIndexShard(rows, device, owner, prevShard) {
     // 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 insights = readSessionInsights(agentIds);
+    const phenotypes = readSessionPhenotypes(agentIds);
     const missingInsights = [];
     const missingPhenotypes = [];
-    for (const row of rows) {
+    for (const row of agentRows) {
         const needInsights = !insights.has(row.id);
         const needPhenotype = !phenotypes.has(row.id);
         if (!needInsights && !needPhenotype)
@@ -363,7 +479,7 @@ export function buildIndexShard(rows, device, owner, prevShard) {
     }
     persistDerivedCache('session-insights', () => writeSessionInsights(missingInsights));
     persistDerivedCache('session-phenotypes', () => writeSessionPhenotypes(missingPhenotypes));
-    const needsAttention = rows.flatMap((row) => {
+    const needsAttention = agentRows.flatMap((row) => {
         const facets = insights.get(row.id);
         const errorCount = errorCounts.get(row.id) ?? 0;
         const flags = attentionFlags(errorCount, facets);
@@ -378,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) {
@@ -400,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) => {
@@ -421,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, phenotypes);
+    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,
@@ -503,6 +676,7 @@ 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,

package/dist/lib/view-types.d.ts

@@ -9,6 +9,18 @@ export interface ViewJsonVersion {
     isolated: boolean;
     isIsolatedDefault: boolean;
     signedIn: boolean;
+    /**
+     * Whether THIS version home can actually spawn a signed-in agent — the strict
+     * per-version launch truth (`isLaunchableSignedIn`), not the display `signedIn`
+     * above. `signedIn` is true when the version *inherits* the active/global HOME
+     * login even with no per-version credential of its own; such a home shows "who
+     * is logged in" but dies at spawn once launch isolates HOME to it. Automatic
+     * `--device auto` placement gates on THIS field so a remote box is judged by
+     * the same launchability the local candidate uses (`collectRunCandidates` →
+     * `isLaunchableSignedIn`), closing the local/remote asymmetry (PHNX-3466).
+     * Absent on an older remote CLI, whose consumers fall back to `signedIn`.
+     */
+    launchable: boolean;
     /** Live cached authentication verdict for this installed version. */
     authVerdict: AuthVerdict | null;
     email: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.58",
+  "version": "1.22.60",
   "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",
@@ -88,7 +88,7 @@
   "dependencies": {
     "@fontsource/inter": "^5.3.0",
     "@fontsource/jetbrains-mono": "^5.3.0",
-    "@homebridge/node-pty-prebuilt-multiarch": "0.13.1",
+    "@homebridge/node-pty-prebuilt-multiarch": "0.14.1",
     "@inquirer/prompts": "8.5.2",
     "@resvg/resvg-wasm": "^2.6.2",
     "@types/proper-lockfile": "4.1.4",