@phnx-labs/agents-cli 1.22.59 → 1.22.61

package/dist/lib/traces/schema2-danger.js

@@ -0,0 +1,185 @@
+/**
+ * Danger classifier for a single shell action's argv (PHNX-3442, producer side).
+ *
+ * Safety-sensitive: the schema-2 `BashAction.danger` drives the console's
+ * destructive-operation surfacing and risk scoring. So this is CONSERVATIVE by
+ * construction — it defaults to `normal` and only escalates on CLEAR structural
+ * evidence in the tokenized argv, never on a substring of raw command text. The
+ * argv it reads is one tokenizeBash segment (see `tokenizeBash` in
+ * `session/bash-command.ts`): the executable at argv[0] and its already-split
+ * arguments, so a flag like `-rf` is a whole token, not a substring hunt.
+ *
+ * The three levels mirror the shipped consumer union (`BashDanger`):
+ *   - DESTRUCTIVE            — irrecoverable data loss / history rewrite / force
+ *                              overwrite of an important path. Requires a WHERE-less
+ *                              DELETE, a recursive/force delete, a hard reset, etc.
+ *   - potentially-destructive — plain `rm`, soft/mixed `git reset`, `mv` over a
+ *                              path, plain `kill` — recoverable-ish but worth a flag.
+ *   - normal                 — everything else.
+ *
+ * `destructiveOperation` is a short stable label (never raw text) naming WHY the
+ * action was flagged, so the console can group by operation without re-parsing.
+ */
+const NORMAL = { danger: 'normal' };
+/** basename of an executable token so `/bin/rm` and `rm` classify alike. */
+function baseName(token) {
+    const noArgs = token.replace(/^.*\//, '');
+    return noArgs.toLowerCase();
+}
+/** True when any argv token is exactly one of `names`. */
+function hasToken(argv, names) {
+    return argv.some((t) => names.has(t));
+}
+/** A single-dash cluster flag that CONTAINS every letter in `letters` (e.g. `-rf` ⊇ r,f). */
+function hasClusterFlag(argv, letters) {
+    return argv.some((t) => {
+        if (!/^-[a-zA-Z]+$/.test(t))
+            return false; // single-dash short cluster only
+        const body = t.slice(1);
+        return letters.every((l) => body.includes(l));
+    });
+}
+/** A GNU long flag present as its own token (e.g. `--force`, `--hard`). */
+function hasLongFlag(argv, flag) {
+    return argv.includes(flag);
+}
+const RM_TOKEN = new Set(['rm']);
+const KILL_TOKEN = new Set(['kill', 'pkill', 'killall']);
+/** Paths that are catastrophic to force-overwrite via a redirect target. */
+const IMPORTANT_REDIRECT_TARGET = /^\/dev\/(?:sd|nvme|disk|hd|mmcblk|vd)/i;
+/**
+ * SQL-ish argv reconstruction: for a `psql -c "DROP TABLE x"` the SQL lives in a
+ * single quoted token, so danger scanning of SQL joins the argv back into one
+ * lower-cased string and matches structural SQL, not shell tokens. Bounded to the
+ * argv we already hold — no new parse.
+ */
+function joinedSql(argv) {
+    return argv.join(' ').toLowerCase();
+}
+/**
+ * Classify one tokenized shell action. `argvComplete` is false when a dynamic node
+ * (command substitution / glob / var expansion) kept the argv incomplete; when a
+ * DESTRUCTIVE signal depends on a token that could have been mangled by expansion
+ * we DO still flag it (a `rm -rf $DIR` is destructive regardless of what `$DIR`
+ * expands to), because the operation itself is the danger, not its target.
+ */
+export function classifyActionDanger(argv, _argvComplete = true) {
+    if (argv.length === 0)
+        return NORMAL;
+    const exe = baseName(argv[0]);
+    // Everything after the executable — the flags/args the danger tests read.
+    const rest = argv.slice(1);
+    // ── rm ──────────────────────────────────────────────────────────────────
+    if (exe === 'rm' || hasToken(argv, RM_TOKEN)) {
+        // Only treat a real `rm` invocation (argv[0]) — a stray `rm` argument to some
+        // other tool is not an rm call.
+        if (exe === 'rm') {
+            const recursive = hasClusterFlag(rest, ['r']) || hasLongFlag(rest, '--recursive');
+            const force = hasClusterFlag(rest, ['f']) || hasLongFlag(rest, '--force');
+            if (recursive && force) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'recursive-force-delete' };
+            }
+            if (recursive) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'recursive-delete' };
+            }
+            // Plain `rm file` (or `rm -f file` without recursion) — recoverable-ish.
+            return { danger: 'potentially-destructive', destructiveOperation: 'delete' };
+        }
+    }
+    // ── git ─────────────────────────────────────────────────────────────────
+    if (exe === 'git') {
+        const sub = rest.find((t) => !t.startsWith('-'));
+        if (sub === 'reset') {
+            if (hasLongFlag(rest, '--hard')) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'git-reset-hard' };
+            }
+            // soft / mixed reset — moves HEAD but keeps the working tree.
+            return { danger: 'potentially-destructive', destructiveOperation: 'git-reset' };
+        }
+        if (sub === 'clean') {
+            // `git clean -fd` / `-fdx` — deletes untracked files irrecoverably.
+            if (hasClusterFlag(rest, ['f'])) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'git-clean-force' };
+            }
+            return { danger: 'potentially-destructive', destructiveOperation: 'git-clean' };
+        }
+        if (sub === 'push') {
+            // A leading-`+` refspec (`git push origin +main`, `+refs/heads/main:main`,
+            // `+HEAD:main`) forces the push just like `--force`, with no flag to catch.
+            // Match a `+` followed by a ref char — not a lone `+` or a `+-`-style flag.
+            const forceRefspec = rest.some((t) => /^\+[^-\s]/.test(t));
+            if (hasLongFlag(rest, '--force') ||
+                hasClusterFlag(rest, ['f']) ||
+                rest.includes('--force-with-lease') ||
+                forceRefspec) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'git-push-force' };
+            }
+        }
+        if (sub === 'checkout') {
+            // `git checkout -- .` / `git checkout -- <path>` throws away working changes.
+            if (rest.includes('--')) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'git-checkout-discard' };
+            }
+        }
+        if (sub === 'stash') {
+            const after = rest.slice(rest.indexOf('stash') + 1);
+            if (after.includes('drop') || after.includes('clear')) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'git-stash-drop' };
+            }
+        }
+        return NORMAL;
+    }
+    // ── kill ────────────────────────────────────────────────────────────────
+    if (exe === 'kill' || exe === 'pkill' || exe === 'killall') {
+        if (hasToken(rest, new Set(['-9', '-SIGKILL', '-KILL']))) {
+            return { danger: 'DESTRUCTIVE', destructiveOperation: 'kill-9' };
+        }
+        if (hasToken(argv, KILL_TOKEN)) {
+            return { danger: 'potentially-destructive', destructiveOperation: 'kill' };
+        }
+    }
+    // ── mv (over an existing path — we cannot know if the target exists, so this is
+    // the recoverable-ish tier, never DESTRUCTIVE) ────────────────────────────
+    if (exe === 'mv') {
+        return { danger: 'potentially-destructive', destructiveOperation: 'move-overwrite' };
+    }
+    // ── dd / mkfs (disk writers) ──────────────────────────────────────────────
+    if (exe === 'dd') {
+        if (rest.some((t) => /^of=/.test(t))) {
+            return { danger: 'DESTRUCTIVE', destructiveOperation: 'dd-write' };
+        }
+    }
+    if (/^mkfs(\.|$)/.test(exe)) {
+        return { danger: 'DESTRUCTIVE', destructiveOperation: 'mkfs' };
+    }
+    // ── redirect to a raw device / important path ─────────────────────────────
+    // A `> /dev/sda`-style redirect target appears as a token in the argv (the
+    // tokenizer keeps `>` and its target). Flag only clearly catastrophic targets.
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        if (t === '>' || t === '>>') {
+            const target = argv[i + 1];
+            if (target && IMPORTANT_REDIRECT_TARGET.test(target)) {
+                return { danger: 'DESTRUCTIVE', destructiveOperation: 'overwrite-device' };
+            }
+        }
+        // Fused form `>/dev/sda`.
+        const fused = t.match(/^>>?(\/\S+)$/);
+        if (fused && IMPORTANT_REDIRECT_TARGET.test(fused[1])) {
+            return { danger: 'DESTRUCTIVE', destructiveOperation: 'overwrite-device' };
+        }
+    }
+    // ── SQL (psql/mysql/sqlite3 -c "…", or a bare SQL statement) ───────────────
+    const sql = joinedSql(argv);
+    if (/\bdrop\s+table\b/.test(sql)) {
+        return { danger: 'DESTRUCTIVE', destructiveOperation: 'sql-drop-table' };
+    }
+    if (/\btruncate\b/.test(sql)) {
+        return { danger: 'DESTRUCTIVE', destructiveOperation: 'sql-truncate' };
+    }
+    // DELETE FROM without a WHERE clause. A DELETE with WHERE is scoped → normal.
+    if (/\bdelete\s+from\b/.test(sql) && !/\bwhere\b/.test(sql)) {
+        return { danger: 'DESTRUCTIVE', destructiveOperation: 'sql-delete-no-where' };
+    }
+    return NORMAL;
+}

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

@@ -0,0 +1,149 @@
+export type StepOutcome = 'ok' | 'error' | 'running' | 'unknown';
+export interface SessionStepBase {
+    ordinal: number;
+    startMs: number;
+    durationMs: number;
+    /**
+     * Whether `durationMs` was measured from a paired result (`false`) or inferred
+     * from the next event (`true`). Mandatory — the console must visually
+     * distinguish measured from inferred duration.
+     */
+    durationEstimated: boolean;
+    outcome: StepOutcome;
+    label: string;
+}
+export interface ThinkingStep extends SessionStepBase {
+    kind: 'thinking';
+    lane: 'think';
+    outcome: 'ok' | 'running' | 'unknown';
+}
+export interface ExecutionBase extends SessionStepBase {
+    kind: 'execution';
+    lane: string;
+    callId?: string;
+    /** The tool call this execution targets (hook/permission → the guarded call). */
+    targetCallId?: string;
+}
+export type ToolExecutionType = 'bash' | 'edit' | 'write' | 'read' | 'grep' | 'generic';
+export interface ToolExecutionBase extends ExecutionBase {
+    executionType: ToolExecutionType;
+    tool: string;
+    result: ExecutionResult;
+}
+export interface ExecutionResult {
+    exitCode?: number;
+    statusCode?: number;
+    errorCode?: string;
+    stdout?: TextPreview;
+    stderr?: TextPreview;
+    combined?: TextPreview;
+}
+export interface TextPreview {
+    text: string;
+    truncated: boolean;
+    originalBytes: number;
+}
+export type BashCategory = 'build' | 'test' | 'git' | 'network' | 'other';
+export type BashDanger = 'normal' | 'potentially-destructive' | 'DESTRUCTIVE';
+export interface BashAction {
+    ordinal: number;
+    source: string;
+    argv: string[];
+    /** false when a dynamic node (substitution/expansion) kept argv incomplete. */
+    argvComplete: boolean;
+    program?: string;
+    categories: BashCategory[];
+    danger: BashDanger;
+    destructiveOperation?: string;
+}
+export interface BashExecution extends ToolExecutionBase {
+    executionType: 'bash';
+    /** Redacted outer command. */
+    command: string;
+    /** Redacted shell payload after unwrapping `/bin/zsh -lc "…"`. */
+    unwrappedCommand: string;
+    parseStatus: 'parsed' | 'partial' | 'unparseable';
+    parseDiagnostics: string[];
+    actions: BashAction[];
+}
+export type FileOperation = 'create' | 'update' | 'overwrite' | 'delete' | 'rename' | 'unknown';
+export interface FileHunk {
+    id: string;
+    oldStart?: number;
+    oldLines?: number;
+    newStart?: number;
+    newLines?: number;
+    addedLines: number;
+    removedLines: number;
+    beforeHash?: string;
+    afterHash?: string;
+    before?: TextPreview;
+    after?: TextPreview;
+    revertedByStep?: number;
+}
+export interface FileMutation {
+    path: string;
+    operation: FileOperation;
+    hunks: FileHunk[];
+    revertedByStep?: number;
+}
+export interface RevertLink {
+    revertedStep: number;
+    path: string;
+    revertedHunkIds: string[];
+}
+export interface EditExecution extends ToolExecutionBase {
+    executionType: 'edit';
+    files: FileMutation[];
+    reverts: RevertLink[];
+}
+export interface WriteExecution extends ToolExecutionBase {
+    executionType: 'write';
+    files: FileMutation[];
+    reverts: RevertLink[];
+}
+export interface CountResult {
+    value: number;
+    relation: 'exact' | 'at-least';
+}
+export interface ReadExecution extends ToolExecutionBase {
+    executionType: 'read';
+    file: string;
+    offset?: number;
+    limit?: number;
+    returnedLines?: CountResult;
+    returnedBytes?: CountResult;
+}
+export interface GrepExecution extends ToolExecutionBase {
+    executionType: 'grep';
+    query: string;
+    path?: string;
+    glob?: string;
+    outputMode?: 'content' | 'files' | 'count' | 'unknown';
+    hits?: CountResult;
+}
+export interface GenericToolExecution extends ToolExecutionBase {
+    executionType: 'generic';
+    input?: TextPreview;
+}
+/** A permission request/decision — a first-class sibling, NOT a fake tool. */
+export interface PermissionExecution extends ExecutionBase {
+    executionType: 'permission';
+    lane: 'permission';
+    requestId?: string;
+    permissionKind: 'command' | 'filesystem' | 'network' | 'mcp' | 'other';
+    decision: 'approved' | 'denied' | 'cancelled' | 'pending';
+    scope?: string;
+    reason?: TextPreview;
+}
+/** A hook firing — a first-class sibling, NOT a fake tool. */
+export interface HookExecution extends ExecutionBase {
+    executionType: 'hook';
+    lane: 'hook';
+    hookName?: string;
+    hookEvent?: string;
+    phase: 'pre' | 'post' | 'session' | 'other';
+    decision: 'allowed' | 'blocked' | 'error' | 'unknown';
+    result: ExecutionResult;
+}
+export type SessionStepV2 = ThinkingStep | BashExecution | EditExecution | WriteExecution | ReadExecution | GrepExecution | GenericToolExecution | PermissionExecution | HookExecution;

package/dist/lib/traces/schema2.js

@@ -0,0 +1,20 @@
+/* ────────────────────────────────────────────────────────────────────────
+ * Schema 2 — canonical ToolExecution session detail (PHNX-3442, producer side).
+ *
+ * This is the PRODUCER's authoring contract for the `schema: 2` per-session
+ * detail shard. It mirrors, field for field, the CONSUMER contract already
+ * shipped and live in `prix/web/lib/traces/types.ts` (SessionDetailV2). The
+ * split is deliberate: the command / patch / output PARSING lives here in
+ * agents-cli — the worker stores the shard opaquely and the console reads the
+ * union directly and NEVER reparses (spec §3, §5).
+ *
+ * Step 1 (the consumer decoder that reads BOTH schema 1 and schema 2) is merged
+ * and live in prod, so emitting schema 2 from here is safe: an old console
+ * would still read it, a new one reads it richly.
+ *
+ * This module is TYPES ONLY. The per-tool mappers that populate these shapes
+ * (bash argv + classification, edit/write hunks + the cross-step revert ledger,
+ * read/grep counts, first-class permission/hook steps) land in follow-up
+ * increments alongside `buildSessionDetailV2`.
+ * ──────────────────────────────────────────────────────────────────────── */
+export {};

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

@@ -23,6 +23,17 @@ import { type SessionTrajectory } from '../session/trajectory.js';
 import { type BucketStats, type DriftSignal, type TraceFailureCause, type TraceTopicGroup } from './classify.js';
 import { type FailurePattern } from './insights.js';
 import type { LatencyInsight } from './segments.js';
+import { buildSessionDetailV2 } from './schema2-build.js';
+import type { SessionEvent } from '../session/types.js';
+/**
+ * The per-session shard body: the schema-2 rich `ToolExecution` detail. The
+ * console decoder (prix/web) reads BOTH schema 1 and schema 2 and is the only
+ * shard consumer, so emitting schema 2 is backward-compatible by construction —
+ * no rollout flag is needed and none should exist (a producer that runs across
+ * the fleet must not depend on an operator setting an env var). Both the upload
+ * and dry-run paths call this one builder.
+ */
+export declare function buildSessionShard(traj: SessionTrajectory, events: SessionEvent[], knownSecrets: readonly string[] | undefined): ReturnType<typeof buildSessionDetailV2>;
 export interface SyncOpts {
     /** Limit to N sessions (for testing / --dry-run); no limit when undefined. */
     limit?: number;
@@ -126,6 +137,57 @@ export interface TracesIndexShard {
     wastedMsTotal: number;
     /** Time-to-first-tool percentiles across this device's sessions. */
     latency: LatencyInsight;
+    /**
+     * Per-session roster — one flat scalar row per AGENT session (PHNX-3483), the
+     * raw material the Rush console filters and re-aggregates live. Every `stats`
+     * figure above is a pre-rolled scalar over the whole agent corpus; the console
+     * cannot re-derive a filtered headline (e.g. "median for `claude` only") from a
+     * scalar, so it needs the underlying rows. `durationMs` is the ACTIVE duration
+     * (`sessionActiveMs`, the same value backing `stats.medianMs`; 0 when the span is
+     * unmeasured), and `mode` encodes the AGENT-vs-INTERACTIVE segmentation
+     * (`headless` = an agent run, `interactive` = a one-shot query) — the SAME
+     * partition behind `stats.agentMedianMs` / `stats.interactiveMedianMs`, so a
+     * mode-split median over the MEASURED rows reproduces them. The segmented stats
+     * skip unmeasured (null-duration) sessions, which the roster still carries at
+     * `durationMs: 0`, so a consumer reproducing the medians must exclude those the
+     * same way (`measuredFraction` reports the covered share). Utility rows are
+     * excluded, exactly like every other index statistic, so the roster length equals
+     * the agent count (`stats.sessionsImported`). Optional here for schema
+     * compatibility with a shard produced before this field.
+     */
+    sessions?: SessionRosterRow[];
+}
+/**
+ * One per-session row in the index roster (PHNX-3483) — flat scalars only, so the
+ * Rush console can filter the session set and re-aggregate the headline metrics
+ * client-side without re-parsing transcripts. Built over AGENT rows only.
+ */
+export interface SessionRosterRow {
+    id: string;
+    /** `label ?? topic ?? classified-topic label`, secret-redacted. */
+    title: string;
+    /** The producing harness (`row.agent`). */
+    harness: string;
+    model: string;
+    /** Short repo name from `project` / `cwd` basename / `git_branch`. */
+    repo: string;
+    /**
+     * `headless` = an agent run (any tool call OR more than 8 messages),
+     * `interactive` = a one-shot query — the SAME split behind
+     * `stats.agentMedianMs` / `stats.interactiveMedianMs`.
+     */
+    mode: 'interactive' | 'headless';
+    /** Corpus topic group of the session; `code` when unclassified. */
+    projectType: TraceTopicGroup;
+    /** Session start, epoch ms. */
+    startedAt: number;
+    /** ACTIVE duration in ms (`sessionActiveMs`); 0 when the span is unmeasured. */
+    durationMs: number;
+    toolCount: number;
+    errorCount: number;
+    needsAttention: boolean;
+    /** Best-effort — omitted when the source figure is unavailable. */
+    costUsd?: number;
 }
 export interface IndexedSession {
     id: string;
@@ -227,6 +289,8 @@ export interface ToolCallRow {
  * per-session parse the detail view does).
  */
 export declare function sessionActiveMs(spanMs: number, sessionCalls: ToolCallRow[], sessionStartMs: number): number;
+/** Active time from an already-built trajectory: span minus its idle gaps (all > threshold). */
+export declare function activeMsFromTrajectory(traj: SessionTrajectory): 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. */
@@ -272,11 +336,40 @@ export interface SessionDetail {
         detail?: string;
     }>;
 }
+/** Plain-language summary of the friction in a run, or null when it ran clean. */
+export declare function buildWhereItWentWrong(traj: SessionTrajectory): string | null;
+/**
+ * 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.
+ */
+export declare function deriveRunOutcome(traj: SessionTrajectory): '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
  * written to R2. `repo` is the cwd basename only.
  */
+/**
+ * The `meta` block shared by the schema-1 {@link SessionDetail} and the schema-2
+ * `SessionDetailV2`. Strips local-machine PII (full cwd, account): `repo` is the
+ * cwd basename only. Factored so both producers stamp identical meta.
+ */
+export declare function buildDetailMeta(traj: SessionTrajectory): SessionDetail['meta'];
 export declare function buildSessionDetail(traj: SessionTrajectory): SessionDetail;
 /** How a session failed to sync. Only parse/upload failures are re-queried every run. */
 export type SyncFailureKind = 'transcript-unavailable' | 'parse-failed' | 'upload-failed';

package/dist/lib/traces/sync.js

@@ -32,6 +32,18 @@ import { resolveTracesBackend } from './backend.js';
 import { classifyCause, classifyTopic, computeDriftSignal, } from './classify.js';
 import { computeInsights } from './insights.js';
 import { classifyPhenotype, recoveredAfterErrors } from './phenotype.js';
+import { buildSessionDetailV2 } from './schema2-build.js';
+/**
+ * The per-session shard body: the schema-2 rich `ToolExecution` detail. The
+ * console decoder (prix/web) reads BOTH schema 1 and schema 2 and is the only
+ * shard consumer, so emitting schema 2 is backward-compatible by construction —
+ * no rollout flag is needed and none should exist (a producer that runs across
+ * the fleet must not depend on an operator setting an env var). Both the upload
+ * and dry-run paths call this one builder.
+ */
+export function buildSessionShard(traj, events, knownSecrets) {
+    return buildSessionDetailV2(traj, events, { redact: true, knownSecrets });
+}
 /** Push derived, redacted trajectories for this device to the traces store. */
 export async function syncTraces(opts = {}) {
     const dryRun = opts.dryRun === true;
@@ -114,9 +126,10 @@ export async function syncTraces(opts = {}) {
             continue;
         }
         let traj;
+        let events = [];
         try {
             const session = rowToMeta(row);
-            const events = parseSession(row.file_path, row.agent);
+            events = parseSession(row.file_path, row.agent);
             traj = buildTrajectory(events, session, { redact: true, knownSecrets });
         }
         catch (err) {
@@ -134,10 +147,10 @@ export async function syncTraces(opts = {}) {
         }
         try {
             if (dryRun && outDir) {
-                fs.writeFileSync(path.join(outDir, 'sessions', `${row.id}.json`), JSON.stringify(buildSessionDetail(traj)));
+                fs.writeFileSync(path.join(outDir, 'sessions', `${row.id}.json`), JSON.stringify(buildSessionShard(traj, events, knownSecrets)));
             }
             else {
-                await putSessionTrace(backend, device, row.id, traj);
+                await putSessionTrace(backend, device, row.id, traj, events, knownSecrets);
             }
             uploaded++;
             maxSuccessMtime = Math.max(maxSuccessMtime, row.file_mtime_ms ?? 0);
@@ -312,7 +325,7 @@ export function sessionActiveMs(spanMs, sessionCalls, sessionStartMs) {
     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) {
+export 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));
 }
@@ -573,6 +586,36 @@ export function buildIndexShard(rows, device, owner, prevShard) {
     const bucketHistory = [...prevHistory, todayStats].slice(-14);
     const driftSignals = computeDriftSignal(prevHistory, todayStats);
     const patternInsights = computeInsights(agentRows, agentCalls, prevShard, phenotypes);
+    // Per-session roster (PHNX-3483): one flat scalar row per agent session, the raw
+    // material the Rush console filters and re-aggregates client-side. `durationMs`
+    // reuses `sessionActiveMs` (the value behind `stats.medianMs`; 0 for a null-duration
+    // row, which the segmented stats above skip entirely), and `mode` reuses the
+    // AGENT-vs-INTERACTIVE predicate from the segmentation above so a mode-split median
+    // over the MEASURED rows reproduces `stats.agentMedianMs` / `interactiveMedianMs`.
+    const needsAttentionIds = new Set(needsAttention.map((s) => s.id));
+    const sessions = agentRows.map((row) => {
+        const isAgent = (callsBySession.get(row.id)?.length ?? 0) > 0 || (row.message_count ?? 0) > 8;
+        const durationMs = row.duration_ms == null
+            ? 0
+            : sessionActiveMs(row.duration_ms, callsBySession.get(row.id) ?? [], Date.parse(row.timestamp));
+        const rosterRow = {
+            id: row.id,
+            title: redactSecrets(row.label ?? row.topic ?? topics.get(row.id)?.label ?? 'Untitled session', knownSecrets),
+            harness: row.agent,
+            model: row.model ?? 'unknown',
+            repo: row.project ?? (row.cwd ? path.basename(row.cwd) : (row.git_branch ?? 'unknown')),
+            mode: isAgent ? 'headless' : 'interactive',
+            projectType: topics.get(row.id)?.group ?? 'code',
+            startedAt: Date.parse(row.timestamp) || 0,
+            durationMs,
+            toolCount: row.tool_call_count ?? 0,
+            errorCount: errorCounts.get(row.id) ?? 0,
+            needsAttention: needsAttentionIds.has(row.id),
+        };
+        if (row.cost_usd != null)
+            rosterRow.costUsd = row.cost_usd;
+        return rosterRow;
+    });
     return {
         schema: 1,
         device,
@@ -618,10 +661,11 @@ export function buildIndexShard(rows, device, owner, prevShard) {
         failurePatterns: patternInsights.failurePatterns,
         wastedMsTotal: patternInsights.wastedMsTotal,
         latency: patternInsights.latency,
+        sessions,
     };
 }
 /** Plain-language summary of the friction in a run, or null when it ran clean. */
-function buildWhereItWentWrong(traj) {
+export function buildWhereItWentWrong(traj) {
     const errorSteps = traj.steps.filter((s) => s.outcome === 'error');
     const biggestGap = traj.gaps.reduce((max, g) => (!max || g.durationMs > max.durationMs ? g : max), null);
     const parts = [];
@@ -657,7 +701,7 @@ function buildWhereItWentWrong(traj) {
  * flip a run whose failed work was never resolved just because some later,
  * unrelated call happened to succeed.
  */
-function deriveRunOutcome(traj) {
+export function deriveRunOutcome(traj) {
     if (traj.errorCount === 0)
         return 'completed';
     return recoveredAfterErrors({ steps: traj.steps }) ? 'completed' : 'errored';
@@ -667,26 +711,35 @@ function deriveRunOutcome(traj) {
  * local-machine PII (full cwd, account) that would expose filesystem paths if
  * written to R2. `repo` is the cwd basename only.
  */
-export function buildSessionDetail(traj) {
+/**
+ * The `meta` block shared by the schema-1 {@link SessionDetail} and the schema-2
+ * `SessionDetailV2`. Strips local-machine PII (full cwd, account): `repo` is the
+ * cwd basename only. Factored so both producers stamp identical meta.
+ */
+export function buildDetailMeta(traj) {
     const s = traj.session;
     const stats = traj.stats;
     const repo = s.project ?? (s.cwd ? path.basename(s.cwd) : 'unknown');
+    return {
+        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: deriveRunOutcome(traj),
+        repo,
+        agent: s.agent,
+        model: s.model ?? 'unknown',
+    };
+}
+export function buildSessionDetail(traj) {
+    const s = traj.session;
     return {
         schema: 1,
         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: deriveRunOutcome(traj),
-            repo,
-            agent: s.agent,
-            model: s.model ?? 'unknown',
-        },
+        meta: buildDetailMeta(traj),
         steps: traj.steps,
         gaps: traj.gaps,
         truncatedSteps: traj.truncatedSteps,
@@ -710,7 +763,7 @@ async function getIndexShard(backend, device) {
         return null;
     }
 }
-async function putSessionTrace(backend, device, sessionId, traj) {
+async function putSessionTrace(backend, device, sessionId, traj, events, knownSecrets) {
     const url = `${backend.baseUrl}/${backend.userId}/${device}/sessions/${sessionId}.json`;
     const res = await fetch(url, {
         method: 'PUT',
@@ -718,7 +771,7 @@ async function putSessionTrace(backend, device, sessionId, traj) {
             authorization: `Bearer ${backend.token}`,
             'content-type': 'application/json; charset=utf-8',
         },
-        body: JSON.stringify(buildSessionDetail(traj)),
+        body: JSON.stringify(buildSessionShard(traj, events, knownSecrets)),
     });
     if (!res.ok) {
         throw new Error(`PUT ${url} → ${res.status}`);

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

@@ -225,6 +225,11 @@ function mergeIndexShards(shards, owner) {
     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),
+    // Per-session roster (PHNX-3483): concat every device's rows so the "all"
+    // view can filter + re-aggregate client-side exactly like a single device.
+    // Devices still on a pre-roster CLI contribute none (|| []) and degrade to
+    // the pre-rolled stats, so coverage grows as devices update — never crashes.
+    sessions: sorted.flatMap((s) => s.sessions || []),
     latency: latencies.length ? {
       firstToolMs: {
         p50: Math.round(wsum((s) => s.latency && s.latency.firstToolMs && s.latency.firstToolMs.p50)),