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

package/src/orchestrator/paired-effects.ts

@@ -0,0 +1,214 @@
+import { z } from "zod";
+import { clusterKey } from "../core/evaluation-clusters.js";
+import {
+  bootstrapMeanConfidenceInterval,
+  type CandidateEvaluation,
+  type ConfidenceConfig,
+  ConfidenceIntervalSchema,
+} from "../core/index.js";
+
+type CaseSamples = NonNullable<CandidateEvaluation["caseSamples"]>;
+type Evaluation = CandidateEvaluation & { repetitions: number };
+
+export const clusterCaseSamples = (
+  groups: readonly (CaseSamples | undefined)[],
+): CaseSamples | undefined => {
+  if (groups.some((group) => group === undefined)) return undefined;
+  const result = new Map<string, CaseSamples[string]>();
+  for (const group of groups) {
+    for (const [id, sample] of Object.entries(group ?? {})) {
+      const current = result.get(id);
+      if (!current) {
+        result.set(id, structuredClone(sample));
+        continue;
+      }
+      if (current.identityHash !== sample.identityHash) current.identityHash = null;
+      if (current.clusterId !== sample.clusterId) current.identityHash = null;
+      if (current.scoreBasis !== sample.scoreBasis) current.scoreBasis = null;
+      const metrics = new Map(Object.entries(current.metrics));
+      for (const [metric, value] of Object.entries(sample.metrics)) {
+        const before = metrics.get(metric);
+        metrics.set(
+          metric,
+          before
+            ? {
+                mean: (before.mean * before.n + value.mean * value.n) / (before.n + value.n),
+                n: before.n + value.n,
+              }
+            : { ...value },
+        );
+      }
+      current.metrics = Object.fromEntries(metrics);
+    }
+  }
+  return Object.fromEntries(result);
+};
+
+const caseGroups = (samples: CaseSamples): Map<string, string[]> => {
+  const groups = new Map<string, string[]>();
+  for (const id of Object.keys(samples).sort()) {
+    const key = clusterKey(id, samples[id]?.clusterId);
+    groups.set(key, [...(groups.get(key) ?? []), id]);
+  }
+  return groups;
+};
+
+export const groupedCaseMetricSamples = (
+  samples: CaseSamples | undefined,
+  repetitions: number,
+): Record<string, number[]> | undefined => {
+  if (!samples || !Object.values(samples).some((sample) => sample.clusterId !== undefined))
+    return undefined;
+  const groups = caseGroups(samples);
+  const metrics = new Set(Object.values(samples).flatMap((sample) => Object.keys(sample.metrics)));
+  return Object.fromEntries(
+    [...metrics].flatMap((metric) => {
+      if (
+        Object.values(samples).some(
+          (sample) =>
+            !Object.hasOwn(sample.metrics, metric) ||
+            sample.metrics[metric]?.n !== repetitions ||
+            (metric === "score" && !sample.scoreBasis),
+        )
+      )
+        return [];
+      return [
+        [
+          metric,
+          [...groups.values()].map(
+            (ids) =>
+              ids.reduce((sum, id) => sum + (samples[id]?.metrics[metric]?.mean ?? 0), 0) /
+              ids.length,
+          ),
+        ],
+      ];
+    }),
+  );
+};
+
+export const PairedEffectSchema = z.object({
+  caseIds: z.array(z.string()),
+  n: z.number().int().nonnegative(),
+  caseCount: z.number().int().nonnegative().optional(),
+  clusters: z.record(z.string(), z.array(z.string())).optional(),
+  meanDelta: z.number().finite().nullable(),
+  interval: ConfidenceIntervalSchema.nullable(),
+  note: z.string().nullable(),
+});
+export type PairedEffect = z.infer<typeof PairedEffectSchema>;
+
+export const confidenceGateIssue = (
+  interval: z.infer<typeof ConfidenceIntervalSchema>,
+): string | undefined =>
+  interval.method === "percentile-bootstrap" && interval.lower === interval.upper
+    ? "zero-width percentile-bootstrap interval cannot establish promotion confidence; use Hoeffding for bounded means or collect more varied independent evidence"
+    : undefined;
+
+const pairedDeltas = (
+  before: Evaluation | undefined,
+  after: Evaluation | undefined,
+  metric: string,
+): { caseIds: string[]; values: number[]; clusters: Record<string, string[]> } => {
+  if (!before?.caseSamples || !after?.caseSamples)
+    throw new Error("keyed case evidence unavailable");
+  if (
+    before.profileId !== after.profileId ||
+    before.split !== after.split ||
+    before.repetitions !== after.repetitions
+  ) {
+    throw new Error("paired evidence requires matching profile, split, and repetitions");
+  }
+  const caseIds = Object.keys(before.caseSamples).sort();
+  const afterIds = Object.keys(after.caseSamples).sort();
+  const beforeCases = Object.keys(before.casePassRates).sort();
+  const afterCases = Object.keys(after.casePassRates).sort();
+  if (
+    caseIds.length === 0 ||
+    [afterIds, beforeCases, afterCases].some(
+      (ids) => JSON.stringify(ids) !== JSON.stringify(caseIds),
+    )
+  ) {
+    throw new Error("paired evidence requires identical canonical case sets");
+  }
+  const values = caseIds.map((id) => {
+    const a = before.caseSamples?.[id];
+    const b = after.caseSamples?.[id];
+    if (!a?.identityHash || a.identityHash !== b?.identityHash)
+      throw new Error(`paired case '${id}' has incompatible evaluation identity`);
+    if (metric === "score" && (!a.scoreBasis || a.scoreBasis !== b.scoreBasis))
+      throw new Error(`paired score for case '${id}' has different or unavailable scoring basis`);
+    if (a.clusterId !== b.clusterId)
+      throw new Error(`paired case '${id}' has incompatible cluster membership`);
+    const av = Object.hasOwn(a.metrics, metric) ? a.metrics[metric] : undefined;
+    const bv = Object.hasOwn(b.metrics, metric) ? b.metrics[metric] : undefined;
+    if (!av || !bv || av.n !== before.repetitions || bv.n !== after.repetitions) {
+      throw new Error(
+        `paired metric '${metric}' lacks complete repetition coverage for case '${id}'`,
+      );
+    }
+    return bv.mean - av.mean;
+  });
+  const byCase = new Map(caseIds.map((id, index) => [id, values[index] ?? 0]));
+  const groups = caseGroups(before.caseSamples);
+  return {
+    caseIds,
+    clusters: Object.fromEntries(groups),
+    values: [...groups.values()].map(
+      (ids) => ids.reduce((sum, id) => sum + (byCase.get(id) ?? 0), 0) / ids.length,
+    ),
+  };
+};
+
+export const pairedEffect = (
+  before: Evaluation | undefined,
+  after: Evaluation | undefined,
+  metric: string,
+  confidence?: ConfidenceConfig,
+): PairedEffect => {
+  let paired: ReturnType<typeof pairedDeltas>;
+  try {
+    paired = pairedDeltas(before, after, metric);
+  } catch (error) {
+    return {
+      caseIds: [],
+      n: 0,
+      caseCount: 0,
+      clusters: {},
+      meanDelta: null,
+      interval: null,
+      note: error instanceof Error ? error.message : String(error),
+    };
+  }
+  const result: PairedEffect = {
+    caseIds: paired.caseIds,
+    n: paired.values.length,
+    caseCount: paired.caseIds.length,
+    clusters: paired.clusters,
+    meanDelta: paired.values.reduce((sum, value) => sum + value, 0) / paired.values.length,
+    interval: null,
+    note: null,
+  };
+  if (!confidence) return result;
+  try {
+    if (confidence.method === "wilson")
+      throw new Error("Wilson cannot estimate paired differences");
+    if (confidence.method === "hoeffding") {
+      const interval = bootstrapMeanConfidenceInterval(
+        paired.values.map((value) => (value + 1) / 2),
+        confidence,
+      );
+      result.interval = {
+        ...interval,
+        estimate: 2 * interval.estimate - 1,
+        lower: 2 * interval.lower - 1,
+        upper: 2 * interval.upper - 1,
+      };
+    } else {
+      result.interval = bootstrapMeanConfidenceInterval(paired.values, confidence);
+    }
+    result.note = confidenceGateIssue(result.interval) ?? null;
+  } catch (error) {
+    result.note = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+};

package/src/orchestrator/profile.ts

@@ -0,0 +1,24 @@
+import {
+  mergeAnswererReference,
+  mergeDriverReference,
+  withDriverDefaults,
+} from "../core/reference-defaults.js";
+import type { ExperimentProfile, ResolvedLuxConfig } from "./config.js";
+
+/** Used by ordinary runs, doctor, and experiment execution and identity alike. */
+export const resolveProfile = (
+  config: Pick<
+    ResolvedLuxConfig,
+    "defaultDriver" | "defaultAnswerer" | "harness" | "environment" | "driverDefaults"
+  >,
+  profile: ExperimentProfile = {},
+): ExperimentProfile => ({
+  ...profile,
+  driver: withDriverDefaults(
+    mergeDriverReference(config.defaultDriver, profile.driver),
+    config.driverDefaults,
+  ),
+  answerer: mergeAnswererReference(config.defaultAnswerer, profile.answerer),
+  harness: profile.harness ?? config.harness,
+  environment: profile.environment ?? config.environment,
+});

package/src/orchestrator/provenance.ts

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
 import { lstat, readFile, readlink } from "node:fs/promises";
+import { availableParallelism, cpus, release, totalmem } from "node:os";
 import { dirname, join, parse, relative, resolve, sep } from "node:path";
+import type { EnvironmentDeclaration } from "../core/environment.js";
 import type { RunProvenance } from "../core/index.js";
 import { contentHash, exec, valueHash } from "../core/index.js";
 
@@ -113,13 +115,30 @@ export const runtimeIdentity = (): RunProvenance["runtime"] => ({
   arch: process.arch,
   node: process.version,
   ...(process.versions.bun ? { bun: process.versions.bun } : {}),
+  host: {
+    osRelease: release(),
+    cpuModels: [...new Set(cpus().map((cpu) => cpu.model))].sort(),
+    logicalCpuCount: cpus().length,
+    availableParallelism: availableParallelism(),
+    totalMemoryBytes: totalmem(),
+  },
 });
 
-export const runProvenance = async (casePath: string | null): Promise<RunProvenance> => {
+export const runProvenance = async (
+  casePath: string | null,
+  options: {
+    environment?: EnvironmentDeclaration | undefined;
+    concurrency?: number | undefined;
+  } = {},
+): Promise<RunProvenance> => {
   const runtime = runtimeIdentity();
-  if (!casePath) return { runtime };
+  const environment = {
+    ...(options.environment ? { declared: options.environment } : {}),
+    concurrency: options.concurrency ?? 1,
+  };
+  if (!casePath) return { runtime, environment };
   const root = gitRootAbove(casePath);
-  if (!root) return { runtime, source: { casePath: resolve(casePath) } };
+  if (!root) return { runtime, environment, source: { casePath: resolve(casePath) } };
   let git = repositories.get(root);
   if (!git) {
     git = inspectRepository(root);
@@ -128,6 +147,7 @@ export const runProvenance = async (casePath: string | null): Promise<RunProvena
   const state = await git;
   return {
     runtime,
+    environment,
     source: {
       casePath: portablePath(relative(root, resolve(casePath))),
       ...(state ? { git: state } : {}),

package/src/orchestrator/regrade.ts

@@ -33,6 +33,7 @@ import {
   readRunArtifactBytes,
   valueHash,
 } from "../core/index.js";
+import { HarnessModelConfigSchema, resolveHarnessForDriver } from "../core/model-cli.js";
 import { registryForEvalCase } from "./case-extensions.js";
 import { evaluatorImplementationHash } from "./evaluator-identity.js";
 import { parsePersistedJson, readBoundedHandle, safeReadJson } from "./fs-read.js";
@@ -539,12 +540,15 @@ export const regradeRun = async (options: {
     const validatedAssertionsHash = valueHash(validatedAssertionConfigs);
     const assertionEvaluators = assertionEvaluatorIdentities(run.case.assertions ?? [], registry);
     const assertionPlugins = assertionPluginIdentities(run.case.assertions ?? [], registry);
+    const configuredHarness = HarnessModelConfigSchema.safeParse(options.graderContext);
     const graderHash = graderConfigHash({
       luxVersion: LUX_VERSION,
       implementationHash: await currentEvaluatorImplementationHash(),
       assertions: assertionEvaluators,
       validatedAssertionsHash,
-      graderContext: options.graderContext,
+      graderContext: configuredHarness.success
+        ? configuredHarness.data
+        : (options.graderContext ?? resolveHarnessForDriver(undefined, run.metadata.driver)),
     });
     const report: GradingReport = await gradeRun(
       run,

package/src/orchestrator/rubric-loader.ts

@@ -9,7 +9,7 @@ const CANDIDATE_FORBIDDEN_FIELDS = [
   "provider",
   "model",
   "reasoningEffort",
-  "timeoutMs",
+  "timeout",
   "promptOverride",
 ] as const;
 const RawRubricDefinitionSchema = z.looseObject({

package/src/orchestrator/run-dir.ts

@@ -154,6 +154,8 @@ export type OpenRunDirOptions = {
   runsRoot: string;
   caseId: string;
   driverName: string;
+  /** Files the run under the permutation instead of the bare driver name. */
+  permutationId?: string | undefined;
   startedAt?: Date | undefined;
   /** Tap on the event stream, called for every appended event. Must not throw. */
   onEvent?: ((event: RunEvent) => void) | undefined;
@@ -164,7 +166,12 @@ export type OpenRunDirOptions = {
 export const openRunDir = async (options: OpenRunDirOptions): Promise<OpenedRunDir> => {
   const ts = isoTimestampSafe(options.startedAt ?? new Date());
   const slug = slugifyCaseId(options.caseId);
-  const basePath = join(options.runsRoot, slug, slugifyCaseId(options.driverName), ts);
+  const basePath = join(
+    options.runsRoot,
+    slug,
+    slugifyCaseId(options.permutationId ?? options.driverName),
+    ts,
+  );
   await mkdir(dirname(basePath), { recursive: true });
   // Same case+driver+millisecond must not share a dir — their events.jsonl
   // streams (opened with flags "a") would interleave silently. A bare mkdir

package/src/orchestrator/run-execution.ts

@@ -1,6 +1,7 @@
 import { cp } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { z } from "zod";
+import type { EnvironmentDeclaration } from "../core/environment.js";
 import {
   type AgentDriver,
   type Answerer,
@@ -10,6 +11,8 @@ import {
   AnswererModelCallAccountingSchema,
   type AnswerHistoryEntry,
   type Artifact,
+  actionTiming,
+  bindRunExecutionWorkspace,
   type EvalCase,
   emptyUsage,
   type FixturesRef,
@@ -18,6 +21,7 @@ import {
   guardRunObserver,
   inspectRunArtifact,
   type LifecycleStage,
+  normalizeDriverMetrics,
   type OperationalFailure,
   type PhaseDurations,
   type ReadyState,
@@ -28,12 +32,14 @@ import {
   type RunMetadata,
   type RunProvenance,
   type RunUsage,
+  summarizeAgentActivity,
   summarizeToolOutcomes,
   sumUsage,
   type TokenUsage,
   TokenUsageSchema,
   valueHash,
 } from "../core/index.js";
+import { identifyArtifactOrigins } from "./artifact-origin.js";
 import {
   createDriverSession,
   type DriverSession,
@@ -49,6 +55,7 @@ import {
   type RunFailurePhase,
   type RunLifecycleEffects,
 } from "./run-lifecycle.js";
+import { RunWorkspace } from "./run-workspace.js";
 import { isRunTraceLimit, type RunTraceLimitFailure } from "./trace-limits.js";
 
 /** Sentinel `casePath` for a pre-loaded case that has no file behind it. */
@@ -57,6 +64,7 @@ export const INLINE_CASE_PATH = "<inline>";
 type RunDirCarrier = { luxRunDir?: string };
 type InterruptCounts = { ask: number; approve: number; custom: number };
 export type RunWithPluginsArgs = {
+  environment?: EnvironmentDeclaration | undefined;
   request: RunRequest;
   casePath: string;
   authoredCase: EvalCase;
@@ -64,6 +72,7 @@ export type RunWithPluginsArgs = {
   validatedAssertionConfigs: readonly unknown[];
   caseId: string;
   driverName: string;
+  permutationId?: string | undefined;
   answererName: string;
   answererConfig: unknown;
   driverConfigHash: string;
@@ -108,7 +117,9 @@ const readAnswererUsage = (answerer: Answerer): TokenUsage =>
 const stageFixtures = async (
   ref: FixturesRef | undefined,
   options: { fixturesRoot?: string; casePath: string; artifactsDir: string },
-): Promise<{ fixtures: ResolvedFixtures; hash: string } | undefined> => {
+): Promise<
+  { fixtures: ResolvedFixtures; hash: string; fileHashes: ReadonlyMap<string, string> } | undefined
+> => {
   if (!ref) return undefined;
   const path = typeof ref === "string" ? ref : ref.path;
   if (!isAbsolute(path) && !options.fixturesRoot && options.casePath === INLINE_CASE_PATH) {
@@ -123,7 +134,11 @@ const stageFixtures = async (
   if (staged.hash !== source.hash) {
     throw new Error(`fixtures: tree changed while staging: ${source.rootDir}`);
   }
-  return { fixtures: { rootDir: source.rootDir }, hash: staged.hash };
+  return {
+    fixtures: { rootDir: source.rootDir },
+    hash: staged.hash,
+    fileHashes: staged.fileHashes,
+  };
 };
 
 export const runDirOfError = (error: unknown): string | null =>
@@ -170,8 +185,17 @@ const SummaryModelAccountingSchema = z.object({
   unpricedModelCalls: z.number().int().nonnegative().optional(),
 });
 
-const usageFromSummary = (summary: unknown): TokenUsage | null =>
-  SummaryUsageSchema.safeParse(summary).data?.usage ?? null;
+const usageFromSummary = (summary: unknown): TokenUsage | null => {
+  if (!summary || typeof summary !== "object") return null;
+  const raw = (summary as { usage?: unknown }).usage;
+  if (!raw || typeof raw !== "object") return null;
+  const counts = raw as Record<string, unknown>;
+  const hasCount = ["input", "output", "cacheRead", "cacheCreation"].some((key) => {
+    const value = counts[key];
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+  });
+  return hasCount ? (SummaryUsageSchema.safeParse(summary).data?.usage ?? null) : null;
+};
 
 const costFromSummary = (summary: unknown): number | undefined => {
   if (!summary || typeof summary !== "object") return undefined;
@@ -183,6 +207,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,
@@ -287,12 +316,14 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
   private loop: DriverSession | undefined;
   private ready: ReadyState | undefined;
   private fixturesHash: string | undefined;
+  private fixtureFileHashes: ReadonlyMap<string, string> = new Map();
   private startAttempted = false;
   private loopOutcome: DriverSessionOutcome | undefined;
   private collection: Collection = { artifacts: [] };
   private metadata: RunMetadata | undefined;
   private usage: RunUsage | undefined;
   private run: Run | undefined;
+  private workspace: RunWorkspace | undefined;
 
   private constructor(
     args: RunWithPluginsArgs,
@@ -312,12 +343,14 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     const startedAt = args.request.startedAt ?? new Date();
     const provenance = await runProvenance(
       args.casePath === INLINE_CASE_PATH ? null : args.casePath,
+      { environment: args.environment, concurrency: args.request.suiteConcurrency },
     );
     const observer = guardRunObserver(args.request.observer);
     const runDir = await openRunDir({
       runsRoot: resolve(args.request.runsRoot),
       caseId: args.caseId,
       driverName: args.driverName,
+      permutationId: args.permutationId,
       startedAt,
       onEvent: observer?.event,
     });
@@ -347,12 +380,14 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     const { request, evalCase, casePath, driver } = this.args;
     this.lifecycle("run-loop");
     if (request.abortSignal?.aborted) return;
+    this.workspace = await RunWorkspace.create();
     const staged = await stageFixtures(evalCase.fixtures, {
       ...(request.fixturesRoot ? { fixturesRoot: request.fixturesRoot } : {}),
       casePath,
-      artifactsDir: this.runDir.artifactsDir,
+      artifactsDir: this.workspace.path,
     });
     this.fixturesHash = staged?.hash;
+    this.fixtureFileHashes = staged?.fileHashes ?? new Map();
     if (request.abortSignal?.aborted) return;
 
     this.lifecycle("start-driver");
@@ -365,7 +400,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       ...(this.args.fixtureValues.length > 0 ? { fixtureValues: this.args.fixtureValues } : {}),
       runsRoot: resolve(request.runsRoot),
       runDir: this.runDir.path,
-      artifactsDir: this.runDir.artifactsDir,
+      artifactsDir: this.workspace.path,
       abortSignal: request.abortSignal ?? new AbortController().signal,
     });
     this.append({ type: "ready", ...this.ready });
@@ -390,6 +425,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,9 +443,12 @@ 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;
+    const executionWorkspace = await this.args.driver.verificationWorkspace?.();
+    if (executionWorkspace) bindRunExecutionWorkspace(this.run, executionWorkspace);
     await writeFrozenCase(this.runDir.path, this.args.authoredCase, this.args.casePath);
     await this.runDir.writeJson("run.json", completed.metadata);
     await this.runDir.writeJson("artifacts.json", this.collection.artifacts);
@@ -430,6 +469,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);
@@ -438,6 +478,12 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
   }
 
   async close(primaryError: unknown | null): Promise<void> {
+    if (this.workspace) {
+      await closeQuietly(async () => {
+        await this.args.driver.close();
+        await this.workspace?.archive(this.runDir.artifactsDir);
+      }, `run workspace ${this.workspace.path}`);
+    }
     if (primaryError instanceof Error) {
       (primaryError as Error & RunDirCarrier).luxRunDir = this.runDir.path;
     }
@@ -506,6 +552,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,8 +561,9 @@ 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),
+      agentUsageAvailability: "unavailable",
       usage: {
         agent: emptyUsage(),
         answerer: readAnswererUsage(this.args.answerer),
@@ -530,6 +578,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(),
     };
@@ -539,7 +588,16 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     if (!this.ready) return { artifacts: [] };
     try {
       await this.args.driver.quiesce?.();
-      return { artifacts: await this.args.driver.collect() };
+      const artifacts = await this.args.driver.collect();
+      const archived =
+        (await this.workspace?.archive(this.runDir.artifactsDir, artifacts)) ?? artifacts;
+      return {
+        artifacts: await identifyArtifactOrigins(
+          this.runDir.path,
+          archived,
+          this.fixtureFileHashes,
+        ),
+      };
     } catch (error) {
       const reason = errorMessage(error);
       this.runDir.events.append({
@@ -563,14 +621,17 @@ 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);
+    const agentUsage = usageFromSummary(summary);
     const usage: RunUsage = {
-      agent: usageFromSummary(summary) ?? emptyUsage(),
+      agent: agentUsage ?? emptyUsage(),
       answerer: readAnswererUsage(this.args.answerer),
       grading: emptyUsage(),
     };
+    const ready = this.ready ?? { agentId: "not-started" };
     const metadata: RunMetadata = {
       schemaVersion: 1,
       luxVersion: this.args.luxVersion,
@@ -579,9 +640,10 @@ 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,
+      agentUsageAvailability: agentUsage === null ? "unavailable" : "reported",
       modelAccounting: {
         agentCalls,
         answererCalls: answererAccounting.calls,
@@ -593,10 +655,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,
@@ -621,6 +685,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       ...(this.fixturesHash ? { fixturesHash: this.fixturesHash } : {}),
       ...(request.subjectHash ? { subjectHash: request.subjectHash } : {}),
       ...(request.profileId ? { profileId: request.profileId } : {}),
+      ...(this.args.permutationId ? { permutationId: this.args.permutationId } : {}),
       ...(request.experimentId ? { experimentId: request.experimentId } : {}),
       ...(request.variantId ? { variantId: request.variantId } : {}),
       ...(request.candidateId ? { candidateId: request.candidateId } : {}),

package/src/orchestrator/run-lifecycle.ts

@@ -23,6 +23,7 @@ type RunLifecycleContext = {
   phase: RunFailurePhase;
   result: unknown;
   error: unknown;
+  failed: boolean;
 };
 type RunLifecycleInput = { effects: ErasedEffects };
 type RunLifecycleOutcome =
@@ -56,7 +57,7 @@ const runLifecycleMachine = setup({
   actions: {
     captureError: assign(({ context, event }) => {
       const error = "error" in event ? event.error : new Error("run lifecycle failed");
-      return { error, phase: isRunTraceLimit(error) ? "trace" : context.phase };
+      return { error, failed: true, phase: isRunTraceLimit(error) ? "trace" : context.phase };
     }),
     captureResult: assign({
       result: ({ event }) => ("output" in event ? event.output : undefined),
@@ -73,6 +74,7 @@ const runLifecycleMachine = setup({
     phase: "setup",
     result: undefined,
     error: undefined,
+    failed: false,
   }),
   initial: "preparing",
   states: {
@@ -153,7 +155,7 @@ const runLifecycleMachine = setup({
     failed: { type: "final" },
   },
   output: ({ context }) => {
-    if (context.error !== undefined) {
+    if (context.failed) {
       return { status: "failed", error: context.error };
     }
     return { status: "succeeded", result: context.result };