@prismatic-io/lux 0.0.2-preview.14 → 0.0.2-preview.16

package/src/core/lifecycle-fixtures.ts

@@ -51,6 +51,7 @@ const activateFixture = async <Context extends SuiteLifecycleHookContext>(
   let useObservations = 0;
   let settled = false;
   let completionError: unknown;
+  let failed = false;
   const completion = (async () => {
     try {
       await fixture(context, () => {
@@ -80,6 +81,7 @@ const activateFixture = async <Context extends SuiteLifecycleHookContext>(
       }
     } catch (error) {
       completionError = error;
+      failed = true;
       if (useObservations === 0) rejectSetup?.(error);
     } finally {
       settled = true;
@@ -90,7 +92,7 @@ const activateFixture = async <Context extends SuiteLifecycleHookContext>(
   await Promise.resolve();
   if (settled) {
     throw new TypeError(
-      completionError
+      failed
         ? `${label} failed before its lifetime began: ${errorMessage(completionError)}`
         : `${label} must await use()`,
       { cause: completionError },
@@ -103,7 +105,7 @@ const activateFixture = async <Context extends SuiteLifecycleHookContext>(
     cleaned = true;
     releaseUse?.();
     await completion;
-    if (completionError) throw completionError;
+    if (failed) throw completionError;
   };
 };
 

package/src/core/platform-process.ts

@@ -175,10 +175,29 @@ const signalPosixGroup = (child: ChildProcess, signal: NodeJS.Signals): void =>
   }
 };
 
+const windowsAncestorPids = (
+  processes: readonly IProcessInfo[],
+  owner: { pid: number; ppid: number },
+): Set<number> => {
+  // Windows retains historical parent PIDs; reuse can make unrelated live
+  // processes appear beneath a new child. Never reap the caller's own ancestry.
+  const protectedPids = new Set([owner.pid]);
+  const byPid = new Map(processes.map((entry) => [entry.pid, entry]));
+  let ancestorPid = owner.ppid;
+  while (ancestorPid > 0 && !protectedPids.has(ancestorPid)) {
+    protectedPids.add(ancestorPid);
+    ancestorPid = byPid.get(ancestorPid)?.ppid ?? 0;
+  }
+  return protectedPids;
+};
+
 export const windowsDescendants = (
   rootPid: number,
   processes: readonly IProcessInfo[],
+  owner: { pid: number; ppid: number } = process,
 ): IProcessInfo[] => {
+  const protectedPids = windowsAncestorPids(processes, owner);
+  if (!validWindowsPid(rootPid) || protectedPids.has(rootPid)) return [];
   const descendants: IProcessInfo[] = [];
   const parentPids = new Set([rootPid]);
   let found = true;
@@ -186,6 +205,8 @@ export const windowsDescendants = (
     found = false;
     for (const candidate of processes) {
       if (
+        validWindowsPid(candidate.pid) &&
+        !protectedPids.has(candidate.pid) &&
         !parentPids.has(candidate.pid) &&
         parentPids.has(candidate.ppid) &&
         !descendants.some((descendant) => descendant.pid === candidate.pid)
@@ -200,17 +221,32 @@ export const windowsDescendants = (
   return root ? [root, ...descendants] : descendants;
 };
 
-const windowsProcessList = async (pid: number): Promise<IProcessInfo[]> => {
+const windowsProcessList = async (): Promise<IProcessInfo[]> => {
   const { getAllProcesses } = await import("@vscode/windows-process-tree");
   return new Promise((resolve) => {
-    getAllProcesses((processes) => resolve(windowsDescendants(pid, processes)));
+    getAllProcesses(resolve);
   });
 };
 
-const forceWindowsTree = async (pid: number): Promise<void> => {
+export const forceWindowsTree = async (
+  pid: number,
+  discover: (pid: number) => Promise<IProcessInfo[]> = windowsProcessList,
+  signal: (pid: number) => void = signalWindowsProcess,
+  discoveryTimeoutMs = 2_000,
+): Promise<void> => {
+  if (!safeWindowsSignalTarget(pid)) return;
   let processes: IProcessInfo[] = [];
+  let timer: NodeJS.Timeout | undefined;
   try {
-    processes = await windowsProcessList(pid);
+    processes = await Promise.race([
+      Promise.resolve().then(() => discover(pid)),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`process discovery timed out after ${discoveryTimeoutMs}ms`)),
+          discoveryTimeoutMs,
+        );
+      }),
+    ]);
   } catch (error) {
     process.emitWarning(
       `Windows descendant discovery failed; only the direct child can be terminated: ${
@@ -218,12 +254,24 @@ const forceWindowsTree = async (pid: number): Promise<void> => {
       }`,
       { code: "LUX_WINDOWS_PROCESS_DISCOVERY" },
     );
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  if (windowsAncestorPids(processes, process).has(pid)) return;
+  const descendants = windowsDescendants(pid, processes);
+  for (const process of descendants.toReversed()) {
+    if (safeWindowsSignalTarget(process.pid)) signal(process.pid);
   }
-  for (const process of processes.toReversed()) signalWindowsProcess(process.pid);
-  if (!processes.some((process) => process.pid === pid)) signalWindowsProcess(pid);
+  if (!descendants.some((process) => process.pid === pid)) signal(pid);
 };
 
+const validWindowsPid = (pid: number): boolean => Number.isSafeInteger(pid) && pid > 0;
+
+const safeWindowsSignalTarget = (pid: number): boolean =>
+  validWindowsPid(pid) && pid !== process.pid && pid !== process.ppid;
+
 const signalWindowsProcess = (pid: number): void => {
+  if (!safeWindowsSignalTarget(pid)) return;
   try {
     process.kill(pid, "SIGKILL");
   } catch {

package/src/core/run.ts

@@ -4,6 +4,7 @@ import { AgentActivitySchema } from "./agent-activity.js";
 import { EvalCaseSchema } from "./case.js";
 import { ArtifactSchema } from "./driver.js";
 import { DriverMetricsSchema } from "./driver-metrics.js";
+import { EnvironmentDeclarationSchema } from "./environment.js";
 import { ErrorEventReasonSchema, ReadyStateSchema, RunEventSchema } from "./events.js";
 import { ToolOutcomeSummarySchema } from "./tool-events.js";
 import { RunUsageSchema } from "./usage.js";
@@ -27,7 +28,24 @@ export const RunProvenanceSchema = z.object({
     arch: z.string(),
     node: z.string(),
     bun: z.exactOptional(z.string()),
+    host: z.exactOptional(
+      z.object({
+        osRelease: z.string(),
+        cpuModels: z.array(z.string()),
+        logicalCpuCount: z.number().int().nonnegative(),
+        availableParallelism: z.number().int().positive(),
+        totalMemoryBytes: z.number().int().nonnegative(),
+      }),
+    ),
   }),
+  environment: z.exactOptional(
+    z.object({
+      /** Declared by the author, not independently verified or enforced by Lux. */
+      declared: z.exactOptional(EnvironmentDeclarationSchema),
+      /** Effective Lux worker limit for this run's suite; direct runs use one. */
+      concurrency: z.number().int().positive(),
+    }),
+  ),
   source: z.exactOptional(
     z.object({
       /** Case path relative to its repository root, when one was found. */
@@ -106,6 +124,8 @@ export const RunMetadataSchema = z.object({
    * eval overhead.
    */
   usage: RunUsageSchema,
+  /** Absent in older records; zero alone did not establish availability. */
+  agentUsageAvailability: z.exactOptional(z.enum(["reported", "unavailable"])),
   modelAccounting: z.exactOptional(
     z.object({
       agentCalls: z.number().int().nonnegative(),

package/src/core/usage.ts

@@ -121,3 +121,11 @@ export const parseAgentUsage = (raw: unknown): TokenUsage | null => {
   if (!AGENT_USAGE_KEYS.some((key) => key in raw)) return null;
   return AgentUsageSchema.safeParse(raw).data ?? null;
 };
+
+/** Legacy nonzero counts remain usable; legacy zero counts are unknown. */
+export const hasAgentUsage = (metadata: {
+  usage: RunUsage;
+  agentUsageAvailability?: "reported" | "unavailable";
+}): boolean =>
+  metadata.agentUsageAvailability === "reported" ||
+  (metadata.agentUsageAvailability === undefined && !isUsageEmpty(metadata.usage.agent));

package/src/drivers/claude-code/index.ts

@@ -9,7 +9,7 @@ import {
   type Artifact,
   DEFAULT_CLAUDE_MODEL,
   type DriverEventMap,
-  type DriverPlugin,
+  defineDriver,
   discoverCliVersion,
   exec,
   type ParsedDriverEvent,
@@ -18,6 +18,12 @@ import {
   TypedEmitter,
 } from "../../core/index.js";
 import { walkArtifacts } from "../shared/artifacts.js";
+import {
+  claudeConfigRoot,
+  claudeUserBehaviorHash,
+  configuredClaudeSourceHashes,
+} from "../shared/experiment-behavior.js";
+import { prepareClaudeExperimentConfig } from "../shared/experiment-policy.js";
 import { copyRegularFileNoFollow } from "../shared/secure-copy.js";
 import { subprocessDriver } from "../subprocess/index.js";
 import { ClaudeCodeLineSchema, makeParseEvent } from "./parse-events.js";
@@ -847,11 +853,36 @@ class ClaudeCodeDriverImpl implements AgentDriver {
   }
 }
 
-export const claudeCodeDriver: DriverPlugin<ClaudeCodeDriverConfig> = {
+export const claudeCodeDriver = defineDriver({
   name: "claude-code",
   configSchema: ClaudeCodeDriverConfigSchema,
+  runtime: (config) => ({
+    commands: [config.command],
+    capabilities: {
+      interactive: true,
+      "tool-calls": true,
+      "tool-results": true,
+      artifacts: true,
+      subagents: true,
+      usage: true,
+      cost: true,
+      isolation: Boolean(config.isolation),
+    },
+  }),
+  experiment: {
+    version: "1",
+    prepare: prepareClaudeExperimentConfig,
+    identity: async (config, { rootDir }) => {
+      const configRoot = claudeConfigRoot({ config });
+      return {
+        configRoot,
+        userBehaviorHash: await claudeUserBehaviorHash(configRoot),
+        sources: await configuredClaudeSourceHashes({ name: "claude-code", config }, rootDir),
+      };
+    },
+  },
   create: (config) => new ClaudeCodeDriverImpl(config),
-};
+});
 
 // Internal exports for testing
 export {

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

@@ -22,10 +22,11 @@ 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";
+const agentCompletionStatus = (status: unknown): "completed" | "failed" | "cancelled" | null => {
+  if (status === "completed") return "completed";
+  if (status === "errored") return "failed";
+  if (status === "shutdown" || status === "interrupted") return "cancelled";
+  return null;
 };
 
 export const appAgentLifecycleProgress = (
@@ -38,36 +39,40 @@ export const appAgentLifecycleProgress = (
   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,
+  if (phase !== "completed") return [];
+  const states = asRecord(item.agentsStates);
+  return receiverThreadIds.flatMap((receiverThreadId): Progress[] => {
+    const events: Progress[] = [];
+    if (item.tool === "spawnAgent" && item.status === "completed") {
+      events.push({
+        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 } : {}),
           },
-          ...(actor ? { agent: actor } : {}),
-          ts,
+          ...(typeof item.prompt === "string" ? { prompt: item.prompt } : {}),
         },
-  );
+        ...(actor ? { agent: actor } : {}),
+        ts,
+      });
+    }
+    const status = agentCompletionStatus(asRecord(states?.[receiverThreadId])?.status);
+    if (status) {
+      events.push({
+        id: `agent-completed-${item.id}-${receiverThreadId}`,
+        kind: "agent-completed",
+        payload: { agentId: receiverThreadId, status },
+        ...(actor ? { agent: actor } : {}),
+        ts,
+      });
+    }
+    return events;
+  });
 };
 
 export type RpcId = string | number;
@@ -82,7 +87,12 @@ export class CodexSubagentTracker {
     spawningThreadId: string | undefined,
     mainThreadId: string | null,
   ): void {
-    if (item?.type !== "collabAgentToolCall" || typeof item.id !== "string") return;
+    if (
+      item?.type !== "collabAgentToolCall" ||
+      item.tool !== "spawnAgent" ||
+      typeof item.id !== "string"
+    )
+      return;
     const receiverThreadIds = Array.isArray(item.receiverThreadIds)
       ? item.receiverThreadIds.filter((value): value is string => typeof value === "string")
       : [];

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

@@ -0,0 +1,258 @@
+import { z } from "zod";
+import { type ParsedDriverEvent, type TokenUsage, toolResultProgress } from "../../core/index.js";
+import type { CodexDriverConfig } from "./config.js";
+
+const CodexUsageSchema = z.object({
+  input_tokens: z.number().nonnegative().catch(0),
+  cached_input_tokens: z.number().nonnegative().catch(0),
+  output_tokens: z.number().nonnegative().catch(0),
+});
+
+const parseUsage = (raw: unknown): TokenUsage | null => {
+  const usage = CodexUsageSchema.safeParse(raw).data;
+  if (!usage) return null;
+  return {
+    input: Math.max(0, usage.input_tokens - usage.cached_input_tokens),
+    output: usage.output_tokens,
+    cacheRead: usage.cached_input_tokens,
+    cacheCreation: 0,
+  };
+};
+
+const resultText = (content: unknown): string => {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter(
+      (block): block is { type: "text"; text: string } =>
+        typeof block === "object" &&
+        block !== null &&
+        (block as { type?: unknown }).type === "text" &&
+        typeof (block as { text?: unknown }).text === "string",
+    )
+    .map((block) => block.text)
+    .join("\n");
+};
+
+const startedItemProgress = (
+  item: Record<string, unknown>,
+  id: string,
+): ParsedDriverEvent | null => {
+  if (item.type === "command_execution") {
+    return {
+      tag: "progress",
+      progress: {
+        id: `tc-${id}`,
+        kind: "tool-call",
+        payload: { name: "command_execution", input: { command: item.command }, toolUseId: id },
+        ts: Date.now(),
+      },
+    };
+  }
+  if (item.type === "mcp_tool_call") {
+    const tool = typeof item.tool === "string" ? item.tool : String(item.name ?? "mcp_tool_call");
+    const server = typeof item.server === "string" ? item.server : undefined;
+    return {
+      tag: "progress",
+      progress: {
+        id: `tc-${id}`,
+        kind: "tool-call",
+        payload: {
+          name: tool,
+          input: item.arguments ?? item.input,
+          toolUseId: id,
+          ...(server ? { server } : {}),
+        },
+        ts: Date.now(),
+      },
+    };
+  }
+  if (item.type === "web_search") {
+    return {
+      tag: "progress",
+      progress: {
+        id: `tc-${id}`,
+        kind: "tool-call",
+        payload: { name: "web_search", input: { query: item.query }, toolUseId: id },
+        ts: Date.now(),
+      },
+    };
+  }
+  if (item.type === "file_change") {
+    return {
+      tag: "progress",
+      progress: {
+        id: `tc-${id}`,
+        kind: "tool-call",
+        payload: { name: "file_change", input: { changes: item.changes }, toolUseId: id },
+        ts: Date.now(),
+      },
+    };
+  }
+  return null;
+};
+
+const completedItemProgress = (
+  item: Record<string, unknown>,
+  id: string,
+): ParsedDriverEvent | null => {
+  if (item.type === "agent_message" && typeof item.text === "string") {
+    return {
+      tag: "progress",
+      progress: {
+        id: `am-${id}`,
+        kind: "agent-message",
+        payload: { text: item.text },
+        ts: Date.now(),
+      },
+    };
+  }
+  if (item.type === "reasoning") {
+    const text = typeof item.text === "string" ? item.text : item.summary;
+    return {
+      tag: "progress",
+      progress: { id: `reasoning-${id}`, kind: "reasoning", payload: { text }, ts: Date.now() },
+    };
+  }
+  if (item.type === "mcp_tool_call") {
+    const tool = typeof item.tool === "string" ? item.tool : String(item.name ?? "mcp_tool_call");
+    const raw =
+      item.result && typeof item.result === "object"
+        ? (item.result as Record<string, unknown>)
+        : item;
+    const content = raw.content ?? item.result ?? [];
+    const structuredContent = raw.structuredContent ?? raw.structured_content;
+    return {
+      tag: "progress",
+      progress: toolResultProgress(
+        0,
+        {
+          name: tool,
+          toolUseId: id,
+          content,
+          ...(structuredContent && typeof structuredContent === "object"
+            ? { structuredContent: structuredContent as Record<string, unknown> }
+            : {}),
+          isError:
+            raw.isError === true ||
+            raw.is_error === true ||
+            item.status === "failed" ||
+            (item.error !== undefined && item.error !== null),
+          text: resultText(content) || (typeof item.error === "string" ? item.error : ""),
+        },
+        Date.now(),
+      ),
+    };
+  }
+  if (item.type === "command_execution") {
+    const output = item.aggregated_output ?? item.output ?? "";
+    const exitCode = typeof item.exit_code === "number" ? item.exit_code : undefined;
+    return {
+      tag: "progress",
+      progress: toolResultProgress(
+        0,
+        {
+          name: "command_execution",
+          toolUseId: id,
+          content: { output, ...(exitCode !== undefined ? { exitCode } : {}) },
+          isError: item.status === "failed" || (exitCode !== undefined && exitCode !== 0),
+          text: typeof output === "string" ? output : JSON.stringify(output),
+        },
+        Date.now(),
+      ),
+    };
+  }
+  if (item.type === "web_search" || item.type === "file_change") {
+    const isWebSearch = item.type === "web_search";
+    const content = isWebSearch
+      ? { query: item.query }
+      : { changes: item.changes, status: item.status };
+    let text = JSON.stringify(item.changes ?? []);
+    if (isWebSearch) text = typeof item.query === "string" ? item.query : "";
+    return {
+      tag: "progress",
+      progress: toolResultProgress(
+        0,
+        {
+          name: item.type,
+          toolUseId: id,
+          content,
+          isError: item.status === "failed",
+          text,
+        },
+        Date.now(),
+      ),
+    };
+  }
+  return null;
+};
+
+const itemProgress = (
+  item: Record<string, unknown>,
+  phase: "started" | "completed",
+): ParsedDriverEvent | null => {
+  const id = typeof item.id === "string" ? item.id : `${String(item.type)}-${Date.now()}`;
+  return phase === "started" ? startedItemProgress(item, id) : completedItemProgress(item, id);
+};
+
+export const makeParseEvent = (config: CodexDriverConfig, cliVersion?: string) => {
+  let threadId: string | undefined;
+  return (line: string): ParsedDriverEvent | ParsedDriverEvent[] | null => {
+    let event: Record<string, unknown>;
+    try {
+      event = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+    if (event.type === "thread.started") {
+      threadId = typeof event.thread_id === "string" ? event.thread_id : undefined;
+      return {
+        tag: "ready",
+        ready: {
+          agentId: "codex",
+          model: config.model,
+          detail: { ...(threadId ? { threadId } : {}), ...(cliVersion ? { cliVersion } : {}) },
+        },
+      };
+    }
+    if (event.type === "item.started" || event.type === "item.completed") {
+      if (!event.item || typeof event.item !== "object") return null;
+      return itemProgress(
+        event.item as Record<string, unknown>,
+        event.type === "item.started" ? "started" : "completed",
+      );
+    }
+    if (event.type === "turn.completed") {
+      const usage = parseUsage(event.usage);
+      const events: ParsedDriverEvent[] = [];
+      if (usage) {
+        events.push({
+          tag: "progress",
+          progress: {
+            id: `usage-${threadId ?? Date.now()}`,
+            kind: "usage",
+            payload: usage,
+            ts: Date.now(),
+          },
+        });
+      }
+      events.push({
+        tag: "done",
+        done: { exitReason: "done", summary: { threadId, ...(usage ? { usage } : {}) } },
+      });
+      return events;
+    }
+    if (event.type === "turn.failed" || event.type === "error") {
+      const nestedMessage =
+        event.error && typeof event.error === "object"
+          ? (event.error as Record<string, unknown>).message
+          : undefined;
+      let message = "codex reported an error";
+      if (typeof event.message === "string") message = event.message;
+      else if (typeof event.error === "string") message = event.error;
+      else if (typeof nestedMessage === "string") message = nestedMessage;
+      return { tag: "error", error: { exitReason: "error", reason: message } };
+    }
+    return null;
+  };
+};