@prismatic-io/lux 0.0.2-preview.24 → 0.0.2-preview.26

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

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join, resolve, sep } from "node:path";
 import { temporaryDirectory } from "tempy";
 import { z } from "zod";
+import { DurationSchema, durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -13,7 +14,6 @@ import {
   type DriverEventMap,
   defineDriver,
   discoverCliVersion,
-  exec,
   type ParsedDriverEvent,
   type ReadyState,
   type StartContext,
@@ -29,6 +29,7 @@ import {
 import { prepareClaudeExperimentConfig } from "../shared/experiment-policy.js";
 import { copyRegularFileNoFollow } from "../shared/secure-copy.js";
 import { subprocessDriver } from "../subprocess/index.js";
+import { runDeferredProcess } from "./deferred-process.js";
 import { ClaudeCodeLineSchema, makeParseEvent } from "./parse-events.js";
 
 const LUX_BOOKKEEPING_FILES = new Set([
@@ -107,13 +108,22 @@ export const ClaudeCodeDriverConfigSchema = z
      * when a weaker model asks in text instead of calling `askToolName`.
      */
     textQuestionFallback: z.boolean().default(false),
-    /** Per-event idle timeout. */
-    idleTimeoutMs: z.number().positive().default(600_000),
+    /** Maximum silence between recognized protocol events; excludes answerer wait time. */
+    idleTimeout: DurationSchema.default("10 minutes"),
+    /** Optional elapsed-time cap per defer-resume CLI invocation, regardless of activity. */
+    turnTimeout: DurationSchema.optional(),
     /** Cap on outstanding interrupts before the driver aborts. */
     maxInterrupts: z.number().positive().default(20),
   })
   .strict()
   .superRefine((config, ctx) => {
+    if (config.turnTimeout !== undefined && config.interactionMode !== "defer-resume") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["turnTimeout"],
+        message: "turnTimeout requires defer-resume mode",
+      });
+    }
     if (config.interactionMode === "defer-resume") {
       const reserved = config.extraArgs?.find((arg) =>
         ["--input-format", "--no-session-persistence", "--resume", "-r", "--settings"].some(
@@ -522,6 +532,7 @@ class ClaudeCodeDriverImpl implements AgentDriver {
   private deferredInterrupts = 0;
   private deferredTerminal = false;
   private deferredTurn: Promise<void> | null = null;
+  private deferredAbort = new AbortController();
 
   constructor(config: ClaudeCodeDriverConfig) {
     this.config = config;
@@ -586,7 +597,7 @@ class ClaudeCodeDriverImpl implements AgentDriver {
       parseEvent: makeParseEvent(this.config, cliVersion),
       formatAnswer,
       formatPrompt,
-      idleTimeoutMs: this.config.idleTimeoutMs,
+      idleTimeout: this.config.idleTimeout,
       maxInterrupts: this.config.maxInterrupts,
     });
     for (const queued of this.pendingAttach) queued.attach(inner);
@@ -620,7 +631,7 @@ class ClaudeCodeDriverImpl implements AgentDriver {
     // A terminal protocol event can arrive before the CLI and its descendants
     // have exited. Quiesce the whole process tree before walking/copying files
     // so it cannot swap a checked regular file into a symlink.
-    await this.inner?.close();
+    await this.quiesce();
     const artifacts = await walkArtifacts(this.collectDir);
     if (this.isolatedWorkspace && this.artifactsDir) {
       await Promise.all(
@@ -652,6 +663,7 @@ class ClaudeCodeDriverImpl implements AgentDriver {
 
   async quiesce(): Promise<void> {
     if (this.config.interactionMode === "defer-resume") {
+      this.deferredAbort.abort();
       await this.deferredTurn;
       return;
     }
@@ -661,6 +673,7 @@ class ClaudeCodeDriverImpl implements AgentDriver {
   async close(): Promise<void> {
     try {
       if (this.config.interactionMode === "defer-resume") {
+        await this.quiesce();
         this.emitter.removeAllListeners();
         if (this.deferredHookPath) {
           await rm(this.deferredHookPath, { force: true });
@@ -728,58 +741,47 @@ class ClaudeCodeDriverImpl implements AgentDriver {
     } else if (resumeWithAnswer && answer?.kind === "ask") {
       input = { input: answer.text };
     }
-    const result = await exec(
-      this.config.command,
-      buildDeferredArgs(this.config, hookPath, this.deferredSessionId ?? undefined),
-      {
-        cwd,
-        env: {
-          ...process.env,
-          LUX_RUN_DIR: ctx.runDir,
-          LUX_ARTIFACTS_DIR: ctx.artifactsDir,
-          ...this.config.env,
-          ...(answer ? { LUX_CLAUDE_DEFERRED_ANSWER: JSON.stringify(answer) } : {}),
-        },
-        ...input,
-        timeoutMs: this.config.idleTimeoutMs,
-        signal: ctx.abortSignal,
+    const terminal = await runDeferredProcess({
+      command: this.config.command,
+      args: buildDeferredArgs(this.config, hookPath, this.deferredSessionId ?? undefined),
+      cwd,
+      env: {
+        ...process.env,
+        LUX_RUN_DIR: ctx.runDir,
+        LUX_ARTIFACTS_DIR: ctx.artifactsDir,
+        ...this.config.env,
+        ...(answer ? { LUX_CLAUDE_DEFERRED_ANSWER: JSON.stringify(answer) } : {}),
       },
-    );
-    if (result.stderr.trim()) {
-      for (const line of result.stderr.trimEnd().split("\n")) {
-        process.stderr.write(`[claude-code] ${line}\n`);
-      }
-    }
-    for (const line of result.stdout.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const envelope = ClaudeCodeLineSchema.safeParse(JSON.parse(line));
-        if (
-          envelope.success &&
-          (envelope.data.type === "system" || envelope.data.type === "result") &&
-          envelope.data.session_id
-        ) {
-          this.deferredSessionId = envelope.data.session_id;
+      ...input,
+      idleTimeoutMs: durationMs(this.config.idleTimeout),
+      ...(this.config.turnTimeout === undefined
+        ? {}
+        : { turnTimeoutMs: durationMs(this.config.turnTimeout) }),
+      signal: AbortSignal.any([ctx.abortSignal, this.deferredAbort.signal]),
+      parse: (line) => {
+        try {
+          const envelope = ClaudeCodeLineSchema.safeParse(JSON.parse(line));
+          if (
+            envelope.success &&
+            (envelope.data.type === "system" || envelope.data.type === "result") &&
+            envelope.data.session_id
+          ) {
+            this.deferredSessionId = envelope.data.session_id;
+          }
+        } catch {
+          // The parser below deliberately ignores unmodeled output.
         }
-      } catch {
-        // The parser below deliberately ignores unmodeled output.
-      }
-      const parsed = parse(line);
-      if (!parsed) continue;
-      for (const event of Array.isArray(parsed) ? parsed : [parsed]) {
-        await this.dispatchDeferred(event);
-      }
-    }
-    if (result.timedOut) {
-      throw new Error(`no event for ${this.config.idleTimeoutMs}ms`);
-    }
-    if (result.signal) throw new Error(`claude exited from signal ${result.signal}`);
-    if (result.exitCode !== 0 && !this.deferredTerminal) {
-      throw new Error(`claude exited ${result.exitCode}`);
-    }
-    if (!resuming && this.deferredReady) {
-      throw new Error("claude exited before ready");
+        return parse(line);
+      },
+      onEvent: (event) => this.dispatchDeferred(event),
+    });
+    if (this.deferredReady) {
+      throw new Error(
+        terminal?.tag === "error" ? terminal.error.reason : "claude exited before ready",
+      );
     }
+    if (terminal) await this.dispatchDeferred(terminal);
+    if (!terminal) throw new Error("claude exited before a terminal result");
   }
 
   private async dispatchDeferred(event: ParsedDriverEvent): Promise<void> {

package/src/drivers/codex/config.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DurationSchema } from "../../core/duration.js";
 import { applyCatalogEffort, codexCatalog, DEFAULT_CODEX_MODEL } from "../../core/index.js";
 
 export type CodexConfigValue =
@@ -51,7 +52,7 @@ export const CodexDriverConfigSchema = z
     isolation: IsolationSchema.optional(),
     maxInterrupts: z.number().positive().default(20),
     maxLineBytes: z.number().positive().default(10_000_000),
-    idleTimeoutMs: z.number().positive().default(600_000),
+    idleTimeout: DurationSchema.default("10 minutes"),
   })
   .strict()
   .superRefine((config, ctx) => {

package/src/drivers/codex/index.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import { temporaryDirectory } from "tempy";
+import { durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -654,8 +655,8 @@ class CodexAppServerDriverImpl implements AgentDriver {
     this.idleTimer = setTimeout(() => {
       this.idleTimer = null;
       if (this.interrupts.size > 0) return;
-      this.fail(`no event for ${this.config.idleTimeoutMs}ms`, "idle-timeout");
-    }, this.config.idleTimeoutMs);
+      this.fail(`no event for ${durationMs(this.config.idleTimeout)}ms`, "idle-timeout");
+    }, durationMs(this.config.idleTimeout));
   }
 
   private clearIdleTimer(): void {
@@ -718,7 +719,7 @@ class CodexExecDriverImpl implements AgentDriver {
       parseEvent: makeParseEvent(this.config, cliVersion),
       formatPrompt: (prompt) => prompt,
       closeStdinAfterPrompt: true,
-      idleTimeoutMs: this.config.idleTimeoutMs,
+      idleTimeout: this.config.idleTimeout,
       maxLineBytes: this.config.maxLineBytes,
       maxInterrupts: 1,
     });

package/src/drivers/copilot/config.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DurationSchema } from "../../core/duration.js";
 import { applyCatalogEffort, copilotCatalog } from "../../core/index.js";
 
 export const CopilotDriverConfigSchema = z
@@ -23,8 +24,8 @@ export const CopilotDriverConfigSchema = z
     extraArgs: z.array(z.string()).optional(),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
-    startupTimeoutMs: z.number().int().positive().default(30_000),
-    idleTimeoutMs: z.number().int().positive().default(600_000),
+    startupTimeout: DurationSchema.default("30 seconds"),
+    idleTimeout: DurationSchema.default("10 minutes"),
     maxInterrupts: z.number().int().positive().default(20),
     maxLineBytes: z.number().int().positive().default(10_000_000),
     maxQueuedBytes: z.number().int().positive().default(20_000_000),

package/src/drivers/copilot/index.ts

@@ -1,4 +1,5 @@
 import { realpath } from "node:fs/promises";
+import { durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -130,7 +131,7 @@ class CopilotDriver implements AgentDriver {
 
   private request(method: string, params: RpcRecord): Promise<RpcRecord> {
     if (!this.transport) throw new Error("Copilot ACP has not started");
-    return this.transport.request(method, params, this.config.startupTimeoutMs);
+    return this.transport.request(method, params, durationMs(this.config.startupTimeout));
   }
 
   private async run(prompt: string): Promise<void> {
@@ -209,10 +210,10 @@ class CopilotDriver implements AgentDriver {
     this.idleTimer = setTimeout(
       () =>
         this.fail(
-          new Error(`Copilot emitted no event for ${this.config.idleTimeoutMs}ms`),
+          new Error(`Copilot emitted no event for ${durationMs(this.config.idleTimeout)}ms`),
           "idle-timeout",
         ),
-      this.config.idleTimeoutMs,
+      durationMs(this.config.idleTimeout),
     );
   }
 

package/src/drivers/cursor/config.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DurationSchema } from "../../core/duration.js";
 import { cursorCatalog } from "../../core/index.js";
 
 export const CursorDriverConfigSchema = z
@@ -9,8 +10,8 @@ export const CursorDriverConfigSchema = z
     mode: z.enum(["agent", "plan", "ask"]).default("agent"),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
-    startupTimeoutMs: z.number().int().positive().default(30_000),
-    idleTimeoutMs: z.number().int().positive().default(600_000),
+    startupTimeout: DurationSchema.default("30 seconds"),
+    idleTimeout: DurationSchema.default("10 minutes"),
     maxInterrupts: z.number().int().positive().default(20),
     maxLineBytes: z.number().int().positive().default(10_000_000),
     maxQueuedBytes: z.number().int().positive().default(20_000_000),

package/src/drivers/cursor/index.ts

@@ -1,4 +1,5 @@
 import { realpath } from "node:fs/promises";
+import { durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -136,7 +137,7 @@ class CursorDriver implements AgentDriver {
 
   private request(method: string, params: RpcRecord): Promise<RpcRecord> {
     if (!this.transport) throw new Error("Cursor ACP has not started");
-    return this.transport.request(method, params, this.config.startupTimeoutMs);
+    return this.transport.request(method, params, durationMs(this.config.startupTimeout));
   }
 
   private async run(prompt: string): Promise<void> {
@@ -237,10 +238,10 @@ class CursorDriver implements AgentDriver {
     this.idleTimer = setTimeout(
       () =>
         this.fail(
-          new Error(`Cursor emitted no event for ${this.config.idleTimeoutMs}ms`),
+          new Error(`Cursor emitted no event for ${durationMs(this.config.idleTimeout)}ms`),
           "idle-timeout",
         ),
-      this.config.idleTimeoutMs,
+      durationMs(this.config.idleTimeout),
     );
   }
 

package/src/drivers/grok-build/README.md

@@ -64,8 +64,8 @@ text and invalid fields still deny the operation. If the agent offers no matchin
 one-operation option, Lux cancels and reports an error rather than widening the
 grant. Native auto decisions are handled inside Grok and are not Lux interrupts.
 
-Permission reviews have a separate `permissionTimeoutMs` (150 seconds by
-default), while ordinary inactivity uses `idleTimeoutMs` (10 minutes). Startup
+Permission reviews have a separate `permissionTimeout` (150 seconds by
+default), while ordinary inactivity uses `idleTimeout` (10 minutes). Startup
 RPCs time out after 30 seconds. Cancelled turns, process failures, unanswered
 reviews, and turns ending with pending approvals cannot count as successful runs.
 A completed turn can still contain denied tool calls: assert the expected files

package/src/drivers/grok-build/config.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DurationSchema } from "../../core/duration.js";
 import { applyCatalogEffort, grokBuildCatalog } from "../../core/index.js";
 
 export const GrokBuildDriverConfigSchema = z
@@ -11,9 +12,9 @@ export const GrokBuildDriverConfigSchema = z
     sandbox: z.enum(["workspace", "read-only", "strict"]).default("workspace"),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
-    startupTimeoutMs: z.number().int().positive().default(30_000),
-    idleTimeoutMs: z.number().int().positive().default(600_000),
-    permissionTimeoutMs: z.number().int().positive().default(150_000),
+    startupTimeout: DurationSchema.default("30 seconds"),
+    idleTimeout: DurationSchema.default("10 minutes"),
+    permissionTimeout: DurationSchema.default("150 seconds"),
     maxInterrupts: z.number().int().positive().default(20),
     maxLineBytes: z.number().int().positive().default(10_000_000),
     maxQueuedBytes: z.number().int().positive().default(20_000_000),

package/src/drivers/grok-build/index.ts

@@ -1,4 +1,5 @@
 import { realpath } from "node:fs/promises";
+import { durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -143,7 +144,7 @@ class GrokBuildDriver implements AgentDriver {
 
   private request(method: string, params: RpcRecord): Promise<RpcRecord> {
     if (!this.transport) throw new Error("Grok.build ACP has not started");
-    return this.transport.request(method, params, this.config.startupTimeoutMs);
+    return this.transport.request(method, params, durationMs(this.config.startupTimeout));
   }
 
   private async run(prompt: string): Promise<void> {
@@ -198,10 +199,10 @@ class GrokBuildDriver implements AgentDriver {
         this.interrupts.delete(interruptId);
         this.fail(
           new Error(
-            `Grok.build permission review timed out after ${this.config.permissionTimeoutMs}ms`,
+            `Grok.build permission review timed out after ${durationMs(this.config.permissionTimeout)}ms`,
           ),
         );
-      }, this.config.permissionTimeoutMs);
+      }, durationMs(this.config.permissionTimeout));
       this.interrupts.set(interruptId, { id, params, timer });
       clearTimeout(this.idleTimer);
       void this.emitter
@@ -243,10 +244,10 @@ class GrokBuildDriver implements AgentDriver {
     this.idleTimer = setTimeout(
       () =>
         this.fail(
-          new Error(`Grok.build emitted no event for ${this.config.idleTimeoutMs}ms`),
+          new Error(`Grok.build emitted no event for ${durationMs(this.config.idleTimeout)}ms`),
           "idle-timeout",
         ),
-      this.config.idleTimeoutMs,
+      durationMs(this.config.idleTimeout),
     );
   }
 

package/src/drivers/mcp/index.ts

@@ -1,6 +1,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { z } from "zod";
+import { DurationSchema, durationMs as parseDuration } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -72,9 +73,9 @@ export const McpProbeDriverConfigSchema = z
     /** The steps to run. Defaults to a single `tools/list` capture. */
     probe: z.array(ProbeStepSchema).default([{ op: "list-tools" }]),
     /** Timeout for the initialize handshake. */
-    startupTimeoutMs: z.number().positive().default(30_000),
+    startupTimeout: DurationSchema.default("30 seconds"),
     /** Timeout for each `tools/list` / `tools/call` request. */
-    stepTimeoutMs: z.number().positive().default(60_000),
+    stepTimeout: DurationSchema.default("1 minute"),
     /** Safety cap for a paginated `tools/list` operation. */
     maxListPages: z.number().int().positive().default(100),
   })
@@ -211,8 +212,8 @@ class McpProbeDriverImpl implements AgentDriver {
 
     try {
       await client.connect(transport, {
-        timeout: this.config.startupTimeoutMs,
-        maxTotalTimeout: this.config.startupTimeoutMs,
+        timeout: parseDuration(this.config.startupTimeout),
+        maxTotalTimeout: parseDuration(this.config.startupTimeout),
         signal: ctx.abortSignal,
       });
     } catch (err) {
@@ -261,8 +262,8 @@ class McpProbeDriverImpl implements AgentDriver {
               throw new Error(`tools/list exceeded ${this.config.maxListPages} pages`);
             }
             const result = await client.listTools(cursor ? { cursor } : undefined, {
-              timeout: this.config.stepTimeoutMs,
-              maxTotalTimeout: this.config.stepTimeoutMs,
+              timeout: parseDuration(this.config.stepTimeout),
+              maxTotalTimeout: parseDuration(this.config.stepTimeout),
               ...(this.abortSignal ? { signal: this.abortSignal } : {}),
             });
             tools.push(...(result.tools as ListedTool[]));
@@ -285,8 +286,8 @@ class McpProbeDriverImpl implements AgentDriver {
             { name: step.tool, arguments: step.args },
             undefined,
             {
-              timeout: this.config.stepTimeoutMs,
-              maxTotalTimeout: this.config.stepTimeoutMs,
+              timeout: parseDuration(this.config.stepTimeout),
+              maxTotalTimeout: parseDuration(this.config.stepTimeout),
               ...(this.abortSignal ? { signal: this.abortSignal } : {}),
             },
           );

package/src/drivers/subprocess/index.ts

@@ -2,6 +2,7 @@ import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
+import { DurationSchema, durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
@@ -36,7 +37,7 @@ export const SubprocessDriverConfigSchema = z
     /** Inherit the host environment. Experiment mode always forces this off. */
     inheritEnv: z.boolean().optional(),
     protocol: z.enum(["lux-jsonl", "custom"]).default("lux-jsonl"),
-    idleTimeoutMs: z.number().positive().default(120_000),
+    idleTimeout: DurationSchema.default("2 minutes"),
     maxInterrupts: z.number().positive().default(20),
     /**
      * Maximum files inventoried from LUX_ARTIFACTS_DIR. Keep the conservative
@@ -485,7 +486,7 @@ class SubprocessDriverImpl implements AgentDriver {
   private bumpIdleTimer(): void {
     this.clearIdleTimer();
     this.idleTimer = setTimeout(() => {
-      const reason = `no event for ${this.config.idleTimeoutMs}ms`;
+      const reason = `no event for ${durationMs(this.config.idleTimeout)}ms`;
       // Idle before ready means start() is still pending; reject it (and kill
       // the child) or the orchestrator waits forever.
       const preReady = this.readyRejected !== null;
@@ -497,7 +498,7 @@ class SubprocessDriverImpl implements AgentDriver {
       // Kill immediately: the run is lost and the child would keep doing
       // billable work until close().
       this.terminate();
-    }, this.config.idleTimeoutMs);
+    }, durationMs(this.config.idleTimeout));
   }
 
   private clearIdleTimer(): void {

package/src/index.ts

@@ -1,3 +1,4 @@
+export { DurationSchema, durationMs } from "./core/duration.js";
 // Public surface of @prismatic-io/lux. The package root exposes authoring
 // contracts, extension points, built-ins, and supported programmatic
 // lifecycles. Explicit exports keep implementation and test helpers private.

package/src/optimization/reflective.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DurationSchema, durationMs } from "../core/duration.js";
 import {
   type CandidateEvaluation,
   type CandidateProposal,
@@ -16,7 +17,7 @@ export const ReflectiveOptimizerConfigSchema = z
     model: z.string().optional(),
     command: z.string().optional(),
     reasoningEffort: ReasoningEffortSchema.optional(),
-    timeoutMs: z.number().int().positive().default(180_000),
+    timeout: DurationSchema.default("3 minutes"),
     maxComponentChars: z.number().int().positive().default(80_000),
     maxAlternativeChars: z.number().int().positive().default(40_000),
     maxFeedbackChars: z.number().int().positive().default(50_000),
@@ -273,7 +274,7 @@ const reflectiveOptimizer = (config: ReflectiveOptimizerConfig): Optimizer => ({
         model,
         command: config.command,
         reasoningEffort: config.reasoningEffort,
-        timeoutMs: config.timeoutMs,
+        timeoutMs: durationMs(config.timeout),
         system: systemPrompt(input.campaign.evaluation.kind),
         signal: input.abortSignal,
         prompt: builtPrompt.prompt,

package/src/orchestrator/candidates.ts

@@ -5,6 +5,7 @@ import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep
 import { temporaryDirectory } from "tempy";
 import { glob } from "tinyglobby";
 import { z } from "zod";
+import { durationMs } from "../core/duration.js";
 import { exec } from "../core/exec.js";
 import {
   type Candidate,
@@ -226,7 +227,7 @@ export const validateCandidate = async (
       try {
         return await exec(validation.command, validation.args, {
           cwd: materializedRoot,
-          timeoutMs: validation.timeoutMs,
+          timeoutMs: durationMs(validation.timeout),
           env,
           ...(signal ? { signal } : {}),
         });
@@ -236,7 +237,7 @@ export const validateCandidate = async (
     })().finally(() => rm(validationHome, { recursive: true, force: true }));
     if (result.timedOut || result.exitCode !== 0) {
       const reason = result.timedOut
-        ? `timed out after ${validation.timeoutMs}ms`
+        ? `timed out after ${durationMs(validation.timeout)}ms`
         : `exited ${result.exitCode}`;
       throw new Error(
         `candidate validation '${validation.command}' ${reason}: ${result.stderr.slice(0, 500)}`,

package/src/orchestrator/grading.ts

@@ -213,7 +213,7 @@ export const gradeRun = async (
       if (validatedConfigs && index >= validatedConfigs.length) {
         throw new Error(`validated assertion plan is missing assertions[${index}]`);
       }
-      // Pass the validated config so schema defaults (e.g. timeoutMs)
+      // Pass the validated config so schema defaults (e.g. timeout)
       // reach evaluate(); the raw assertion object has none applied.
       const result = AssertionResultSchema.parse(
         await impl.evaluate(validated as typeof a, 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({