@prismatic-io/lux 0.0.1 → 0.0.2-preview.11

package/src/core/events.ts

@@ -57,11 +57,22 @@ export const AnswerSchema = z.discriminatedUnion("kind", [
 ]);
 export type Answer = z.infer<typeof AnswerSchema>;
 
+export const AgentAttributionSchema = z.object({
+  id: z.string().min(1),
+  role: z.enum(["main", "subagent"]),
+  parentId: z.exactOptional(z.string().min(1)),
+  spawnToolUseId: z.exactOptional(z.string().min(1)),
+  name: z.exactOptional(z.string().min(1)),
+  model: z.exactOptional(z.string().min(1)),
+});
+export type AgentAttribution = z.infer<typeof AgentAttributionSchema>;
+
 export const ProgressSchema = z.object({
   id: z.string(),
   kind: z.string(),
   payload: z.unknown(),
   ts: z.number(),
+  agent: z.exactOptional(AgentAttributionSchema),
 });
 export type Progress = z.infer<typeof ProgressSchema>;
 
@@ -69,8 +80,8 @@ export const DoneSchema = z.object({
   exitReason: z.literal("done"),
   /**
    * Driver-defined summary. The orchestrator recognizes `usage`, `cost`,
-   * `modelCalls`, and `unpricedModelCalls` when present while preserving room
-   * for domain-specific measurements.
+   * `modelCalls`, `unpricedModelCalls`, and scalar `metrics` when present while
+   * preserving room for other domain-specific evidence.
    */
   summary: z.unknown().optional(),
 });
@@ -82,6 +93,7 @@ export type ErrorEventReason = z.infer<typeof ErrorEventReasonSchema>;
 export const ErrorEventSchema = z.object({
   exitReason: ErrorEventReasonSchema,
   reason: z.string(),
+  summary: z.unknown().optional(),
 });
 export type ErrorEvent = z.infer<typeof ErrorEventSchema>;
 

package/src/core/experiment.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DriverMetricDescriptorSchema } from "./driver-metrics.js";
 import { ConfidenceConfigSchema } from "./statistics.js";
 import { TokenUsageSchema } from "./usage.js";
 import { formatZodIssues } from "./zod.js";
@@ -415,6 +416,7 @@ export const CandidateEvaluationSchema = z.object({
   passRate: z.number().min(0).max(1),
   casePassRates: z.record(z.string(), z.number().min(0).max(1)),
   metrics: z.record(z.string(), z.number()),
+  metricDefinitions: z.exactOptional(z.record(z.string(), DriverMetricDescriptorSchema)),
   metricCalls: z.exactOptional(z.number().int().nonnegative()),
   judgeCalls: z.exactOptional(z.number().int().nonnegative()),
   unpricedModelCalls: z.exactOptional(z.number().int().nonnegative()),

package/src/core/index.ts

@@ -1,3 +1,6 @@
+export * from "./action-events.js";
+export * from "./agent-activity.js";
+export * from "./agent-events.js";
 export * from "./annotation.js";
 export * from "./answerer.js";
 export * from "./artifact-evidence.js";
@@ -6,6 +9,7 @@ export * from "./assertion.js";
 export * from "./case.js";
 export * from "./conversation-turn.js";
 export * from "./driver.js";
+export * from "./driver-metrics.js";
 export * from "./emitter.js";
 export * from "./events.js";
 export * from "./exec.js";

package/src/core/lifecycle-fixtures.ts

@@ -2,6 +2,7 @@ import { valueHash } from "./hash.js";
 import {
   type CaseLifecycleHookContext,
   defineLifecycleHooks,
+  type FixtureValue,
   type LifecycleHookCleanup,
   type LifecycleHooksPlugin,
   type SuiteLifecycleHookContext,
@@ -22,6 +23,8 @@ export type LifecycleFixturesDefinition = {
    * to execution identity.
    */
   identity?: unknown;
+  /** Public, serializable data made available to the selected case's driver. */
+  value?: FixtureValue;
   suite?: LifecycleFixture<SuiteLifecycleHookContext>;
   case?: LifecycleFixture<CaseLifecycleHookContext>;
 };
@@ -109,8 +112,8 @@ const activateFixture = async <Context extends SuiteLifecycleHookContext>(
  * Setup belongs before `use`; teardown belongs after it.
  */
 export const defineFixtures = (definition: LifecycleFixturesDefinition): LifecycleHooksPlugin => {
-  if (!definition.suite && !definition.case) {
-    throw new TypeError("fixtures plugin must define suite or case");
+  if (!definition.suite && !definition.case && definition.value === undefined) {
+    throw new TypeError("fixtures plugin must define value, suite, or case");
   }
   if (definition.suite !== undefined && typeof definition.suite !== "function") {
     throw new TypeError("fixtures plugin suite must be a function");
@@ -123,8 +126,10 @@ export const defineFixtures = (definition: LifecycleFixturesDefinition): Lifecyc
   return defineLifecycleHooks({
     name: definition.name,
     pluginVersion: definition.pluginVersion,
+    ...(definition.value === undefined ? {} : { value: definition.value }),
     ...(definition.identity === undefined ? {} : { identity: definition.identity }),
     implementationHash: valueHash({
+      value: definition.value,
       identity: definition.identity,
       suite: definition.suite,
       case: definition.case,

package/src/core/lifecycle-hooks.ts

@@ -1,7 +1,15 @@
+import { z } from "zod";
 import { valueHash } from "./hash.js";
 
 export type LifecycleHookCleanup = () => void | Promise<void>;
 export type LifecycleHookSetupResult = LifecycleHookCleanup | undefined;
+export const FixtureValueSchema = z.json();
+export type FixtureValue = z.infer<typeof FixtureValueSchema>;
+
+export type FixtureValueBinding = {
+  name: string;
+  value: FixtureValue;
+};
 
 export type SuiteLifecycleHookItem = {
   id: string;
@@ -27,6 +35,8 @@ export type LifecycleHooksPlugin = {
   name: string;
   /** Author-maintained identity for setup and teardown behavior. */
   pluginVersion: string;
+  /** Public, serializable data made available to the selected case's driver. */
+  value?: FixtureValue;
   /**
    * Public, non-secret values captured by hook closures and relevant to
    * execution identity. Included in the implementation hash.
@@ -75,8 +85,11 @@ export const lifecycleHooksPluginIssue = (
   if (definition.setupCase !== undefined && typeof definition.setupCase !== "function") {
     return "lifecycle hooks plugin setupCase must be a function";
   }
-  if (!definition.setupSuite && !definition.setupCase) {
-    return "lifecycle hooks plugin must define setupSuite or setupCase";
+  if (definition.value !== undefined && !FixtureValueSchema.safeParse(definition.value).success) {
+    return "lifecycle hooks plugin value must be JSON-serializable";
+  }
+  if (!definition.setupSuite && !definition.setupCase && definition.value === undefined) {
+    return "lifecycle hooks plugin must define a value, setupSuite, or setupCase";
   }
   return undefined;
 };
@@ -93,6 +106,7 @@ export const defineLifecycleHooks = (definition: LifecycleHooksPlugin): Lifecycl
     implementationHash:
       definition.implementationHash ??
       valueHash({
+        value: definition.value,
         identity: definition.identity,
         setupSuite: definition.setupSuite,
         setupCase: definition.setupCase,

package/src/core/run.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
+import { ActionTimingSchema } from "./action-events.js";
+import { AgentActivitySchema } from "./agent-activity.js";
 import { EvalCaseSchema } from "./case.js";
 import { ArtifactSchema } from "./driver.js";
+import { DriverMetricsSchema } from "./driver-metrics.js";
 import { ErrorEventReasonSchema, ReadyStateSchema, RunEventSchema } from "./events.js";
 import { ToolOutcomeSummarySchema } from "./tool-events.js";
 import { RunUsageSchema } from "./usage.js";
@@ -112,6 +115,8 @@ export const RunMetadataSchema = z.object({
     }),
   ),
   cost: z.exactOptional(z.object({ usd: z.exactOptional(z.number()) })),
+  /** Driver-defined scalar measurements with display and optimization semantics. */
+  driverMetrics: z.exactOptional(DriverMetricsSchema),
   interruptCounts: z.object({ ask: z.number(), approve: z.number(), custom: z.number() }),
   /** Legacy raw count of progress events whose kind is `tool-call`. */
   toolCallCount: z.exactOptional(z.number()),
@@ -124,6 +129,10 @@ export const RunMetadataSchema = z.object({
   ),
   /** Wall-clock per phase, derived from the lifecycle event stream. */
   phaseDurationMs: z.exactOptional(PhaseDurationsSchema),
+  /** Driver-reported semantic action latency, measured from `start-driver`. */
+  actionTiming: z.exactOptional(ActionTimingSchema),
+  /** Per-agent lifecycle and activity derived from the attributed event stream. */
+  agentActivity: z.exactOptional(z.array(AgentActivitySchema)),
   /**
    * Harness/infrastructure failure that invalidates this run as candidate
    * evidence. A driver-reported subject failure intentionally leaves this

package/src/core/wire.ts

@@ -47,6 +47,7 @@ const ErrorEventSchema = z.object({
   type: z.literal("error"),
   exitReason: ErrorEventReasonSchema.default("error"),
   reason: z.string(),
+  summary: z.unknown().optional(),
 });
 
 export const WireEventSchema = z.discriminatedUnion("type", [
@@ -85,7 +86,10 @@ const wireEventToParsed = (event: WireEvent): ParsedDriverEvent => {
   if (event.type === "done") {
     return { tag: "done", done: { exitReason: "done", summary: event.summary } };
   }
-  return { tag: "error", error: { exitReason: event.exitReason, reason: event.reason } };
+  return {
+    tag: "error",
+    error: { exitReason: event.exitReason, reason: event.reason, summary: event.summary },
+  };
 };
 
 /**

package/src/drivers/claude-code/parse-events.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import {
+  type AgentAttribution,
   type Interrupt,
   type ParsedDriverEvent,
   parseAgentUsage,
@@ -8,6 +9,39 @@ import {
   toolResultProgress,
 } from "../../core/index.js";
 
+const claudeAgent = (parentToolUseId?: string): AgentAttribution =>
+  parentToolUseId
+    ? {
+        id: `claude-code:${parentToolUseId}`,
+        role: "subagent",
+        parentId: "claude-code",
+        spawnToolUseId: parentToolUseId,
+      }
+    : { id: "claude-code", role: "main" };
+
+const isSubagentTool = (name: string): boolean => name === "Agent" || name === "Task";
+
+const spawnedClaudeAgent = (
+  toolUseId: string,
+  input: unknown,
+  parentToolUseId?: string,
+): AgentAttribution => {
+  const details =
+    typeof input === "object" && input !== null ? (input as Record<string, unknown>) : {};
+  const name = [details.name, details.subagent_type, details.agent, details.role].find(
+    (value): value is string => typeof value === "string" && value.length > 0,
+  );
+  const model = typeof details.model === "string" && details.model ? details.model : undefined;
+  return {
+    id: `claude-code:${toolUseId}`,
+    role: "subagent",
+    parentId: claudeAgent(parentToolUseId).id,
+    spawnToolUseId: toolUseId,
+    ...(name ? { name } : {}),
+    ...(model ? { model } : {}),
+  };
+};
+
 const ContentBlockSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), text: z.string() }),
   z.object({ type: z.literal("tool_use"), id: z.string(), name: z.string(), input: z.unknown() }),
@@ -88,6 +122,7 @@ type PendingTurn = {
   asked: boolean;
   thought: boolean;
   text?: string;
+  agent: AgentAttribution;
 };
 
 type AssistantContent = {
@@ -96,6 +131,7 @@ type AssistantContent = {
   asked: boolean;
   thought: boolean;
   firstText?: string;
+  agent: AgentAttribution;
 };
 
 const questionTextOf = (raw: unknown): string =>
@@ -225,6 +261,30 @@ class ClaudeEventParser {
       if (!block) continue;
       events.push(block);
       if (block.tag !== "progress") continue;
+      const resultPayload = block.progress.payload as {
+        name?: unknown;
+        toolUseId?: unknown;
+        isError?: unknown;
+      };
+      if (
+        typeof resultPayload.name === "string" &&
+        isSubagentTool(resultPayload.name) &&
+        typeof resultPayload.toolUseId === "string"
+      ) {
+        events.push({
+          tag: "progress",
+          progress: {
+            id: `agent-completed-${resultPayload.toolUseId}`,
+            kind: "agent-completed",
+            payload: {
+              agentId: `claude-code:${resultPayload.toolUseId}`,
+              status: resultPayload.isError === true ? "failed" : "completed",
+            },
+            agent: claudeAgent(),
+            ts: block.progress.ts,
+          },
+        });
+      }
       const text = (block.progress.payload as { text?: unknown }).text;
       const failure = typeof text === "string" ? toolInfrastructureFailure(text) : null;
       if (failure) {
@@ -244,20 +304,21 @@ class ClaudeEventParser {
 
     const toolUseId = block.tool_use_id;
     const content = block.content ?? [];
+    const progress = toolResultProgress(
+      this.eventSequence++,
+      {
+        name: this.toolNames.get(toolUseId) ?? "unknown",
+        toolUseId,
+        content,
+        isError: block.is_error === true,
+        text: toolResultText(content),
+        ...(parentToolUseId ? { parentToolUseId } : {}),
+      },
+      Date.now(),
+    );
     return {
       tag: "progress",
-      progress: toolResultProgress(
-        this.eventSequence++,
-        {
-          name: this.toolNames.get(toolUseId) ?? "unknown",
-          toolUseId,
-          content,
-          isError: block.is_error === true,
-          text: toolResultText(content),
-          ...(parentToolUseId ? { parentToolUseId } : {}),
-        },
-        Date.now(),
-      ),
+      progress: { ...progress, agent: claudeAgent(parentToolUseId) },
     };
   }
 
@@ -284,6 +345,7 @@ class ClaudeEventParser {
       tools: [],
       asked: false,
       thought: false,
+      agent: claudeAgent(event.parent_tool_use_id),
     };
     for (const rawBlock of event.message.content) {
       const block = ContentBlockSchema.safeParse(rawBlock).data;
@@ -323,6 +385,7 @@ class ClaudeEventParser {
         kind: "agent-message",
         payload: { text, ...(parentToolUseId ? { parentToolUseId } : {}) },
         ts: Date.now(),
+        agent: claudeAgent(parentToolUseId),
       },
     });
   }
@@ -354,8 +417,29 @@ class ClaudeEventParser {
           ...(parentToolUseId ? { parentToolUseId } : {}),
         },
         ts: Date.now(),
+        agent: claudeAgent(parentToolUseId),
       },
     });
+    if (isSubagentTool(block.name)) {
+      const agent = spawnedClaudeAgent(block.id, block.input, parentToolUseId);
+      const details =
+        typeof block.input === "object" && block.input !== null
+          ? (block.input as Record<string, unknown>)
+          : {};
+      content.events.push({
+        tag: "progress",
+        progress: {
+          id: `agent-spawn-${block.id}`,
+          kind: "agent-spawn",
+          payload: {
+            agent,
+            ...(typeof details.prompt === "string" ? { prompt: details.prompt } : {}),
+          },
+          agent: claudeAgent(parentToolUseId),
+          ts: Date.now(),
+        },
+      });
+    }
   }
 
   private recordTurn(
@@ -376,6 +460,7 @@ class ClaudeEventParser {
       tools: [],
       asked: false,
       thought: false,
+      agent: content.agent,
     };
     this.pendingTurn.usage = usage;
     this.pendingTurn.asked ||= content.asked;
@@ -451,6 +536,7 @@ class ClaudeEventParser {
         kind: "usage",
         payload: { ...this.pendingTurn.usage, ...(label ? { label } : {}) },
         ts: Date.now(),
+        agent: this.pendingTurn.agent,
       },
     };
     this.pendingTurn = null;

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/drivers/subprocess/index.ts

@@ -82,6 +82,7 @@ const KILL_GRACE_MS = 5_000;
 const DEFAULT_MAX_LINE_BYTES = 10_000_000;
 const MAX_STDERR_TAIL_CHARS = 8_192;
 const DEFAULT_MAX_ARTIFACT_FILES = 500;
+const MAX_FIXTURE_VALUES_BYTES = 64 * 1024;
 const ARTIFACT_SNAPSHOT_MODULE = fileURLToPath(
   new URL("../../core/artifact-snapshot.js", import.meta.url),
 );
@@ -139,6 +140,10 @@ class SubprocessDriverImpl implements AgentDriver {
 
   async start(ctx: StartContext): Promise<ReadyState> {
     this.artifactsDir = ctx.artifactsDir;
+    const fixtureValues = JSON.stringify(ctx.fixtureValues ?? []);
+    if (Buffer.byteLength(fixtureValues) > MAX_FIXTURE_VALUES_BYTES) {
+      throw new Error(`subprocess fixture values exceed ${MAX_FIXTURE_VALUES_BYTES} bytes`);
+    }
     const managed = spawnManagedProcess(this.config.command, this.config.args ?? [], {
       cwd: this.config.cwd ?? ctx.runDir,
       env: {
@@ -147,6 +152,7 @@ class SubprocessDriverImpl implements AgentDriver {
         ...(ctx.caseId ? { LUX_CASE_ID: ctx.caseId } : {}),
         LUX_RUN_DIR: ctx.runDir,
         LUX_ARTIFACTS_DIR: ctx.artifactsDir,
+        LUX_FIXTURE_VALUES: fixtureValues,
         LUX_PROMPT: ctx.prompt,
         LUX_ARTIFACT_SNAPSHOT_MODULE: ARTIFACT_SNAPSHOT_MODULE,
       },