@prismatic-io/lux 0.0.2-preview.4 → 0.0.2-preview.7

package/src/drivers/codex/app-events.ts

@@ -1,5 +1,7 @@
 import {
+  type AgentAttribution,
   type ParsedDriverEvent,
+  type Progress,
   type TokenUsage,
   TURN_GLYPHS,
   toolResultProgress,
@@ -20,8 +22,98 @@ const resultText = (content: unknown): string => {
     .join("\n");
 };
 
+const agentCompletionStatus = (status: unknown): "completed" | "failed" | "cancelled" => {
+  if (status === "failed") return "failed";
+  if (status === "cancelled" || status === "interrupted") return "cancelled";
+  return "completed";
+};
+
+export const appAgentLifecycleProgress = (
+  item: RpcRecord,
+  phase: "started" | "completed",
+  actor?: AgentAttribution,
+  ts = Date.now(),
+): Progress[] => {
+  if (item.type !== "collabAgentToolCall" || typeof item.id !== "string") return [];
+  const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+    ? item.receiverThreadIds.filter((value): value is string => typeof value === "string")
+    : [];
+  const completionStatus = agentCompletionStatus(item.status);
+  return receiverThreadIds.map((receiverThreadId) =>
+    phase === "started"
+      ? {
+          id: `agent-spawn-${item.id}-${receiverThreadId}`,
+          kind: "agent-spawn",
+          payload: {
+            agent: {
+              id: receiverThreadId,
+              role: "subagent",
+              parentId: actor?.id ?? "codex",
+              spawnToolUseId: item.id as string,
+              ...(typeof item.model === "string" ? { model: item.model } : {}),
+            },
+            ...(typeof item.prompt === "string" ? { prompt: item.prompt } : {}),
+          },
+          ...(actor ? { agent: actor } : {}),
+          ts,
+        }
+      : {
+          id: `agent-completed-${item.id}-${receiverThreadId}`,
+          kind: "agent-completed",
+          payload: {
+            agentId: receiverThreadId,
+            status: completionStatus,
+          },
+          ...(actor ? { agent: actor } : {}),
+          ts,
+        },
+  );
+};
+
 export type RpcId = string | number;
 export type RpcRecord = Record<string, unknown>;
+
+export class CodexSubagentTracker {
+  private readonly spawnToolByThread = new Map<string, string>();
+  private readonly parentAgentByThread = new Map<string, string>();
+
+  record(
+    item: RpcRecord | null,
+    spawningThreadId: string | undefined,
+    mainThreadId: string | null,
+  ): void {
+    if (item?.type !== "collabAgentToolCall" || typeof item.id !== "string") return;
+    const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+      ? item.receiverThreadIds.filter((value): value is string => typeof value === "string")
+      : [];
+    for (const receiverThreadId of receiverThreadIds) {
+      this.spawnToolByThread.set(receiverThreadId, item.id);
+      if (spawningThreadId) {
+        this.parentAgentByThread.set(
+          receiverThreadId,
+          spawningThreadId === mainThreadId ? "codex" : spawningThreadId,
+        );
+      }
+    }
+  }
+
+  attribution(
+    threadId: string | undefined,
+    mainThreadId: string | null,
+  ): AgentAttribution | undefined {
+    if (!threadId) return undefined;
+    const spawnToolUseId = this.spawnToolByThread.get(threadId);
+    if (!spawnToolUseId) {
+      return { id: threadId === mainThreadId ? "codex" : threadId, role: "main" };
+    }
+    return {
+      id: threadId,
+      role: "subagent",
+      parentId: this.parentAgentByThread.get(threadId) ?? mainThreadId ?? "codex",
+      spawnToolUseId,
+    };
+  }
+}
 export type AppTurnFacets = {
   tools: string[];
   asked: boolean;
@@ -131,8 +223,10 @@ const appItemResultText = (item: RpcRecord, error: RpcRecord | null, content: un
 export const appItemProgress = (
   item: RpcRecord,
   phase: "started" | "completed",
-  parentToolUseId?: string,
+  attribution?: AgentAttribution | string,
 ): ParsedDriverEvent | null => {
+  const agent = typeof attribution === "string" ? undefined : attribution;
+  const parentToolUseId = typeof attribution === "string" ? attribution : agent?.spawnToolUseId;
   const id = typeof item.id === "string" ? item.id : `${String(item.type)}-${Date.now()}`;
   if (item.type === "agentMessage" && phase === "completed" && typeof item.text === "string") {
     return {
@@ -142,6 +236,7 @@ export const appItemProgress = (
         kind: "agent-message",
         payload: { text: item.text, ...(parentToolUseId ? { parentToolUseId } : {}) },
         ts: Date.now(),
+        ...(agent ? { agent } : {}),
       },
     };
   }
@@ -162,6 +257,7 @@ export const appItemProgress = (
           ...(parentToolUseId ? { parentToolUseId } : {}),
         },
         ts: Date.now(),
+        ...(agent ? { agent } : {}),
       },
     };
   }
@@ -184,6 +280,7 @@ export const appItemProgress = (
           ...(parentToolUseId ? { parentToolUseId } : {}),
         },
         ts: Date.now(),
+        ...(agent ? { agent } : {}),
       },
     };
   }
@@ -199,20 +296,23 @@ export const appItemProgress = (
     error !== null;
   return {
     tag: "progress",
-    progress: toolResultProgress(
-      0,
-      {
-        name: tool,
-        toolUseId: id,
-        content,
-        ...(asRecord(structuredContent)
-          ? { structuredContent: asRecord(structuredContent) ?? {} }
-          : {}),
-        isError,
-        text: appItemResultText(item, error, content),
-        ...(parentToolUseId ? { parentToolUseId } : {}),
-      },
-      Date.now(),
-    ),
+    progress: {
+      ...toolResultProgress(
+        0,
+        {
+          name: tool,
+          toolUseId: id,
+          content,
+          ...(asRecord(structuredContent)
+            ? { structuredContent: asRecord(structuredContent) ?? {} }
+            : {}),
+          isError,
+          text: appItemResultText(item, error, content),
+          ...(parentToolUseId ? { parentToolUseId } : {}),
+        },
+        Date.now(),
+      ),
+      ...(agent ? { agent } : {}),
+    },
   };
 };

package/src/drivers/codex/index.ts

@@ -24,11 +24,13 @@ import { copyRegularFileNoFollow } from "../shared/secure-copy.js";
 import { subprocessDriver } from "../subprocess/index.js";
 import {
   type AppTurnFacets,
+  appAgentLifecycleProgress,
   appItemProgress,
   appItemToolName,
   appTurnLabel,
   appUsage,
   asRecord,
+  CodexSubagentTracker,
   messageOf,
   type RpcId,
   type RpcRecord,
@@ -316,7 +318,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
     { resolve: (result: RpcRecord) => void; reject: (error: Error) => void }
   >();
   private readonly interrupts = new Map<string, { id: RpcId; method: string; params: RpcRecord }>();
-  private readonly subagentParents = new Map<string, string>();
+  private readonly subagents = new CodexSubagentTracker();
   private readonly turnFacets = new Map<string, AppTurnFacets>();
   private interruptCount = 0;
   private idleTimer: NodeJS.Timeout | null = null;
@@ -702,22 +704,22 @@ class CodexAppServerDriverImpl implements AgentDriver {
     const toolName = item ? appItemToolName(item) : null;
     if (toolName && !facets.tools.includes(toolName)) facets.tools.push(toolName);
     if (turnId) this.turnFacets.set(turnId, facets);
-    this.recordSubagentParents(item);
-    const parentToolUseId =
-      typeof params.threadId === "string" ? this.subagentParents.get(params.threadId) : undefined;
+    const threadId = typeof params.threadId === "string" ? params.threadId : undefined;
+    this.subagents.record(item, threadId, this.threadId);
+    const agent = this.subagents.attribution(threadId, this.threadId);
     const event = item
-      ? appItemProgress(item, method === "item/started" ? "started" : "completed", parentToolUseId)
+      ? appItemProgress(item, method === "item/started" ? "started" : "completed", agent)
       : null;
     if (event?.tag === "progress") await this.emitter.emit("progress", event.progress);
-  }
-
-  private recordSubagentParents(item: RpcRecord | null): void {
-    if (item?.type !== "collabAgentToolCall" || typeof item.id !== "string") return;
-    const receiverThreadIds = Array.isArray(item.receiverThreadIds)
-      ? item.receiverThreadIds.filter((value): value is string => typeof value === "string")
-      : [];
-    for (const receiverThreadId of receiverThreadIds) {
-      this.subagentParents.set(receiverThreadId, item.id);
+    if (item) {
+      for (const lifecycle of appAgentLifecycleProgress(
+        item,
+        method === "item/started" ? "started" : "completed",
+        agent,
+        event?.tag === "progress" ? event.progress.ts : Date.now(),
+      )) {
+        await this.emitter.emit("progress", lifecycle);
+      }
     }
   }
 

package/src/index.ts

@@ -87,6 +87,8 @@ export {
   registerCoreAssertions,
   runSucceededAssertion,
   subagentToolCalls,
+  type TimeToFirstActionUnderConfig,
+  TimeToFirstActionUnderConfigSchema,
   type TokensUnderConfig,
   TokensUnderConfigSchema,
   type ToolCall,
@@ -104,6 +106,7 @@ export {
   ToolResultIsErrorConfigSchema,
   type ToolResultJsonPointerEqualsConfig,
   ToolResultJsonPointerEqualsConfigSchema,
+  timeToFirstActionUnderAssertion,
   tokensUnderAssertion,
   toolCallCountAssertion,
   toolCalledAssertion,
@@ -141,6 +144,28 @@ export {
   rubricAssertion,
 } from "./assertions/rubric/index.js";
 // Authoring and extension contracts.
+export {
+  type ActionCategory,
+  ActionCategorySchema,
+  type ActionProgressPayload,
+  ActionProgressPayloadSchema,
+  type ActionTiming,
+  ActionTimingSchema,
+  actionTiming,
+} from "./core/action-events.js";
+export {
+  type AgentActivity,
+  AgentActivitySchema,
+  summarizeAgentActivity,
+} from "./core/agent-activity.js";
+export {
+  AGENT_COMPLETED_KIND,
+  AGENT_SPAWN_KIND,
+  type AgentCompletedPayload,
+  AgentCompletedPayloadSchema,
+  type AgentSpawnPayload,
+  AgentSpawnPayloadSchema,
+} from "./core/agent-events.js";
 export {
   defineGraderAnnotations,
   type GraderAnnotation,
@@ -227,8 +252,23 @@ export {
   ResolvedFixturesSchema,
   type StartContext,
 } from "./core/driver.js";
+export {
+  type DriverMetric,
+  type DriverMetricDescriptor,
+  DriverMetricDescriptorSchema,
+  DriverMetricSchema,
+  type DriverMetrics,
+  DriverMetricsSchema,
+  type DriverMetricUnit,
+  DriverMetricUnitSchema,
+  normalizeDriverMetrics,
+  type ReportedDriverMetrics,
+  ReportedDriverMetricsSchema,
+} from "./core/driver-metrics.js";
 export { type EventHandler, TypedEmitter } from "./core/emitter.js";
 export {
+  type AgentAttribution,
+  AgentAttributionSchema,
   type Answer,
   AnswerSchema,
   ApproveAnswerSchema,

package/src/orchestrator/compare.ts

@@ -2,6 +2,9 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import {
+  type ActionTiming,
+  type AgentActivity,
+  type DriverMetrics,
   emptyRunUsage,
   type GradingReport,
   GradingReportSchema,
@@ -48,6 +51,9 @@ export type RunComparison = {
     exitReason: { a: string; b: string };
     durationMsA: number | null;
     durationMsB: number | null;
+    actionTiming: { a: ActionTiming; b: ActionTiming };
+    driverMetrics: { a: DriverMetrics; b: DriverMetrics };
+    agentActivity: { a: AgentActivity[]; b: AgentActivity[] };
     interruptCounts: {
       a: { ask: number; approve: number; custom: number };
       b: { ask: number; approve: number; custom: number };
@@ -260,6 +266,18 @@ export const compareRuns = async (input: ComparisonInput): Promise<RunComparison
           },
           durationMsA: durationFromMeta(a.runJson),
           durationMsB: durationFromMeta(b.runJson),
+          actionTiming: {
+            a: a.runJson?.actionTiming ?? {},
+            b: b.runJson?.actionTiming ?? {},
+          },
+          driverMetrics: {
+            a: a.runJson?.driverMetrics ?? {},
+            b: b.runJson?.driverMetrics ?? {},
+          },
+          agentActivity: {
+            a: a.runJson?.agentActivity ?? [],
+            b: b.runJson?.agentActivity ?? [],
+          },
           interruptCounts: {
             a: a.runJson?.interruptCounts ?? { ask: 0, approve: 0, custom: 0 },
             b: b.runJson?.interruptCounts ?? { ask: 0, approve: 0, custom: 0 },

package/src/orchestrator/experiment-evaluation.ts

@@ -101,6 +101,23 @@ const evaluationMetrics = (
   ),
 });
 
+const evaluationMetricDefinitions = (summary: SuiteSummary) =>
+  Object.fromEntries(
+    Object.entries(summary.metrics).flatMap(([name, metric]) => {
+      if (!metric.unit && !metric.label && !metric.better) return [];
+      return [
+        [
+          name,
+          {
+            unit: metric.unit ?? "number",
+            better: metric.better ?? "neutral",
+            ...(metric.label ? { label: metric.label } : {}),
+          },
+        ],
+      ];
+    }),
+  );
+
 const summaryUsage = (summary: SuiteSummary) =>
   summary.samples.reduce(
     (usage, sample) =>
@@ -277,6 +294,7 @@ const agentEvaluationFromSuite = (input: {
       summary.cases.map((entry) => [entry.canonicalCaseId, entry.passRate]),
     ),
     metrics: evaluationMetrics(summary, candidate),
+    metricDefinitions: evaluationMetricDefinitions(summary),
     samples: evaluationSamples(summary),
     metricCalls: summary.samples.length,
     judgeCalls: results.reduce(
@@ -352,6 +370,10 @@ const aggregateAgentUnits = (
         .map(([, values]) => average(values)),
     ]),
   );
+  const metricDefinitions = Object.assign(
+    {},
+    ...units.map(({ evaluation }) => evaluation.metricDefinitions ?? {}),
+  );
   return {
     candidateId: candidate.id,
     profileId,
@@ -367,6 +389,7 @@ const aggregateAgentUnits = (
         name === "subject.bytes" ? candidate.sourceBytes : average(values),
       ]),
     ),
+    metricDefinitions,
     samples,
     metricCalls: units.reduce((total, unit) => total + (unit.evaluation.metricCalls ?? 0), 0),
     judgeCalls: units.reduce((total, unit) => total + (unit.evaluation.judgeCalls ?? 0), 0),

package/src/orchestrator/index.ts

@@ -122,6 +122,7 @@ export {
   formatRunsTable,
   type ListedRun,
   listRuns,
+  loadRunArtifacts,
   loadRunDetail,
   type RunDetail,
 } from "./list-runs.js";

package/src/orchestrator/list-runs.ts

@@ -2,6 +2,11 @@ import { existsSync } from "node:fs";
 import { constants, lstat, open, readdir } from "node:fs/promises";
 import { basename, join, relative, sep } from "node:path";
 import {
+  ActionProgressPayloadSchema,
+  AgentCompletedPayloadSchema,
+  AgentSpawnPayloadSchema,
+  type Artifact,
+  ArtifactSchema,
   type GradingReport,
   GradingReportSchema,
   harnessUsage,
@@ -31,6 +36,11 @@ export type ListedRun = {
   startedAt: string | null;
   endedAt: string | null;
   durationMs: number | null;
+  timeToFirstActionMs: number | null;
+  timeToFirstMutationMs: number | null;
+  timeToFirstDurableMutationMs: number | null;
+  driverMetrics: NonNullable<RunMetadata["driverMetrics"]>;
+  subagentCount: number;
   casePassed: boolean | null;
   caseScore: number | null;
   assertionPassed: number;
@@ -63,6 +73,12 @@ const summarizeRun = async (
     startedAt,
     endedAt,
     durationMs,
+    timeToFirstActionMs: meta?.actionTiming?.timeToFirstActionMs ?? null,
+    timeToFirstMutationMs: meta?.actionTiming?.timeToFirstMutationMs ?? null,
+    timeToFirstDurableMutationMs: meta?.actionTiming?.timeToFirstDurableMutationMs ?? null,
+    driverMetrics: meta?.driverMetrics ?? {},
+    subagentCount:
+      meta?.agentActivity?.filter((activity) => activity.agent.role === "subagent").length ?? 0,
     casePassed: grading?.casePassed ?? null,
     caseScore: grading?.caseScore ?? null,
     assertionPassed: passing,
@@ -127,7 +143,7 @@ export const listRuns = async (runsRoot: string): Promise<ListedRun[]> => {
 export const formatRunsTable = (runs: ListedRun[]): string => {
   if (runs.length === 0) return "(no runs found)";
   const rows: string[][] = [
-    ["status", "case", "driver", "ts", "exit", "score", "duration"],
+    ["status", "case", "driver", "agents", "ts", "exit", "score", "duration"],
     ...runs.map((r) => {
       let status = "ungraded";
       if (r.casePassed === true) status = "PASS";
@@ -137,7 +153,8 @@ export const formatRunsTable = (runs: ListedRun[]): string => {
           ? `${(r.caseScore * 100).toFixed(0)}% (${r.assertionPassed}/${r.assertionTotal})`
           : "—";
       const duration = r.durationMs !== null ? `${(r.durationMs / 1000).toFixed(1)}s` : "—";
-      return [status, r.caseSlug, r.driverName, r.ts, r.exitReason ?? "?", score, duration];
+      const agents = r.subagentCount > 0 ? `1+${r.subagentCount}` : "1";
+      return [status, r.caseSlug, r.driverName, agents, r.ts, r.exitReason ?? "?", score, duration];
     }),
   ];
   const header = rows[0] ?? [];
@@ -156,6 +173,9 @@ export type RunDetail = {
   artifacts: string[];
 };
 
+export const loadRunArtifacts = async (runDir: string): Promise<Artifact[]> =>
+  (await safeReadJson(join(runDir, "artifacts.json"), ArtifactSchema.array())) ?? [];
+
 const readEventsJsonl = async (path: string): Promise<RunEvent[]> => {
   if (!existsSync(path)) return [];
   if ((await lstat(path)).isSymbolicLink()) {
@@ -291,6 +311,27 @@ const appendMetadataDetail = (lines: string[], detail: RunDetail): void => {
         `phases: agent=${secs(phases.agent)} collect=${secs(phases.collect)} grading=${secs(phases.grading)}`,
       );
     }
+    const actions = detail.metadata.actionTiming;
+    if (actions) {
+      const value = (ms: number | undefined): string => (ms === undefined ? "—" : `${ms}ms`);
+      lines.push(
+        `first action: any=${value(actions.timeToFirstActionMs)} mutation=${value(actions.timeToFirstMutationMs)} durable-mutation=${value(actions.timeToFirstDurableMutationMs)}`,
+      );
+    }
+    const activities = detail.metadata.agentActivity ?? [];
+    const subagents = activities.filter((activity) => activity.agent.role === "subagent");
+    if (subagents.length > 0) {
+      lines.push(`subagents: ${subagents.length}`);
+      for (const activity of subagents) {
+        const label = activity.agent.name
+          ? `${activity.agent.name} (${activity.agent.id})`
+          : activity.agent.id;
+        const agentActions = activity.actions;
+        lines.push(
+          `  ${label}: ${activity.status}, ${(activity.durationMs / 1000).toFixed(1)}s, events=${activity.eventCount}, tokens=${totalTokens(activity.usage)}, tools=${activity.toolCalls.total} (${activity.toolCalls.succeeded} ok/${activity.toolCalls.failed} failed/${activity.toolCalls.unresolved} unresolved), actions=${agentActions.total}, mutations=${agentActions.mutations}`,
+        );
+      }
+    }
   }
 };
 
@@ -361,17 +402,37 @@ const formatEventLine = (event: RunEvent): string => {
         }`;
       }
       return `responded(custom): ${JSON.stringify(event.payload).slice(0, 80)}`;
-    case "progress":
+    case "progress": {
+      const agent = event.agent?.role === "subagent" ? ` [subagent ${event.agent.id}]` : "";
+      if (event.kind === "agent-spawn") {
+        const payload = AgentSpawnPayloadSchema.safeParse(event.payload).data;
+        return payload
+          ? `agent-spawn: ${payload.agent.name ?? payload.agent.id} (${payload.agent.id})`
+          : "agent-spawn: malformed";
+      }
+      if (event.kind === "agent-completed") {
+        const payload = AgentCompletedPayloadSchema.safeParse(event.payload).data;
+        return payload
+          ? `agent-completed: ${payload.agentId} (${payload.status})`
+          : "agent-completed: malformed";
+      }
+      if (event.kind === "action") {
+        const payload = ActionProgressPayloadSchema.safeParse(event.payload).data;
+        return payload
+          ? `action${agent}: ${payload.name} (${payload.category})`
+          : "action: malformed";
+      }
       if (event.kind === "tool-call") {
         const payload = ToolCallPayloadSchema.safeParse(event.payload).data;
-        return payload ? `tool-call: ${payload.name}` : "tool-call: malformed";
+        return payload ? `tool-call${agent}: ${payload.name}` : "tool-call: malformed";
       }
       if (event.kind === "tool-result") {
         const payload = ToolResultPayloadSchema.safeParse(event.payload).data;
         if (!payload) return "tool-result: malformed";
-        return `tool-result: ${payload.name} (${payload.isError ? "failed" : "succeeded"})`;
+        return `tool-result${agent}: ${payload.name} (${payload.isError ? "failed" : "succeeded"})`;
       }
       return `progress(${event.kind})`;
+    }
     case "lifecycle":
       return `lifecycle: ${event.stage}`;
     case "ready":

package/src/orchestrator/run-execution.ts

@@ -10,6 +10,7 @@ import {
   AnswererModelCallAccountingSchema,
   type AnswerHistoryEntry,
   type Artifact,
+  actionTiming,
   type EvalCase,
   emptyUsage,
   type FixturesRef,
@@ -18,6 +19,7 @@ import {
   guardRunObserver,
   inspectRunArtifact,
   type LifecycleStage,
+  normalizeDriverMetrics,
   type OperationalFailure,
   type PhaseDurations,
   type ReadyState,
@@ -28,6 +30,7 @@ import {
   type RunMetadata,
   type RunProvenance,
   type RunUsage,
+  summarizeAgentActivity,
   summarizeToolOutcomes,
   sumUsage,
   type TokenUsage,
@@ -183,6 +186,11 @@ const modelAccountingFromSummary = (
 ): { modelCalls: number; unpricedModelCalls?: number | undefined } | null =>
   SummaryModelAccountingSchema.safeParse(summary).data ?? null;
 
+const metricsFromSummary = (summary: unknown) => {
+  if (!summary || typeof summary !== "object") return {};
+  return normalizeDriverMetrics((summary as { metrics?: unknown }).metrics);
+};
+
 const artifactMeasurements = async (
   artifacts: readonly Artifact[],
   runDir: string,
@@ -390,6 +398,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     metadata.exitReason = "error";
     metadata.operationalFailure = { phase: operationalPhase, reason };
     metadata.phaseDurationMs = phaseDurations(this.runDir.recorded);
+    metadata.actionTiming = actionTiming(this.runDir.recorded);
     await this.runDir.writeJson("run.json", metadata);
     await this.args.request.recordPreGradingAccounting?.(metadata);
     await this.args.request.recordModelAttemptsComplete?.(this.subjectAttemptIds);
@@ -407,6 +416,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     this.lifecycle("collect-end");
     await this.runDir.events.drain();
     const completed = await this.completedAgentRun();
+    completed.metadata.actionTiming = actionTiming(this.runDir.recorded);
     this.metadata = completed.metadata;
     this.usage = completed.usage;
     this.run = completed.run;
@@ -430,6 +440,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       grading.assertions.flatMap((assertion) => (assertion.usage ? [assertion.usage] : [])),
     );
     metadata.phaseDurationMs = phaseDurations(this.runDir.recorded);
+    metadata.actionTiming = actionTiming(this.runDir.recorded);
     await this.runDir.events.drain();
     await this.runDir.writeJson("run.json", metadata);
     await this.runDir.writeJson("artifacts.json", this.collection.artifacts);
@@ -506,6 +517,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
   private fallbackFailureMetadata(): RunMetadata {
     const failedAt = new Date();
     const answererAccounting = readAnswererModelAccounting(this.args.answerer);
+    const ready = this.ready ?? { agentId: "start-failed" };
     return {
       schemaVersion: 1,
       luxVersion: this.args.luxVersion,
@@ -514,7 +526,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       agentEndedAt: failedAt.toISOString(),
       endedAt: failedAt.toISOString(),
       exitReason: "error",
-      driver: { name: this.args.driverName, ...(this.ready ?? { agentId: "start-failed" }) },
+      driver: { name: this.args.driverName, ...ready },
       answerer: answererMetadata(this.args.answererName, this.args.answererConfig),
       usage: {
         agent: emptyUsage(),
@@ -530,6 +542,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       interruptCounts: this.interruptCounts,
       toolCallCount: this.toolCallCount,
       toolOutcomes: summarizeToolOutcomes(this.runDir.recorded),
+      agentActivity: summarizeAgentActivity(this.runDir.recorded, ready),
       artifacts: { count: this.collection.artifacts.length },
       provenance: this.runProvenance(),
     };
@@ -563,6 +576,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     const summary = outcome.kind === "done" ? outcome.done.summary : outcome.error.summary;
     const driverCost = costFromSummary(summary);
     const reportedModelAccounting = modelAccountingFromSummary(summary);
+    const driverMetrics = metricsFromSummary(summary);
     const answererAccounting = readAnswererModelAccounting(this.args.answerer);
     const agentCalls = this.ready ? (reportedModelAccounting?.modelCalls ?? 1) : 0;
     const operationalFailure = loopFailure(outcome, this.collection.error);
@@ -571,6 +585,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       answerer: readAnswererUsage(this.args.answerer),
       grading: emptyUsage(),
     };
+    const ready = this.ready ?? { agentId: "not-started" };
     const metadata: RunMetadata = {
       schemaVersion: 1,
       luxVersion: this.args.luxVersion,
@@ -579,7 +594,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       agentEndedAt: agentEndedAt.toISOString(),
       endedAt: agentEndedAt.toISOString(),
       exitReason,
-      driver: { name: this.args.driverName, ...(this.ready ?? { agentId: "not-started" }) },
+      driver: { name: this.args.driverName, ...ready },
       answerer: answererMetadata(this.args.answererName, this.args.answererConfig),
       usage,
       modelAccounting: {
@@ -593,10 +608,12 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       interruptCounts: this.interruptCounts,
       toolCallCount: this.toolCallCount,
       toolOutcomes: summarizeToolOutcomes(this.runDir.recorded),
+      agentActivity: summarizeAgentActivity(this.runDir.recorded, ready),
       artifacts: await artifactMeasurements(this.collection.artifacts, this.runDir.path),
       ...(operationalFailure ? { operationalFailure } : {}),
       provenance: this.runProvenance(),
       ...(driverCost !== undefined ? { cost: { usd: driverCost } } : {}),
+      ...(Object.keys(driverMetrics).length > 0 ? { driverMetrics } : {}),
     };
     return {
       metadata,