@prismatic-io/lux 0.0.2-preview.25 → 0.0.2-preview.27

package/src/drivers/antigravity/config.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DurationSchema } from "../../core/duration.js";
 import { antigravityCatalog, applyCatalogEffort } from "../../core/index.js";
 
 export const AntigravityDriverConfigSchema = z
@@ -23,7 +24,7 @@ export const AntigravityDriverConfigSchema = z
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
     extraArgs: z.array(z.string()).optional(),
-    idleTimeoutMs: z.number().positive().default(600_000),
+    idleTimeout: DurationSchema.default("10 minutes"),
     maxLineBytes: z.number().positive().default(10_000_000),
   })
   .strict()

package/src/drivers/antigravity/index.ts

@@ -58,7 +58,7 @@ class AntigravityDriver implements AgentDriver {
           `The task workspace is ${JSON.stringify(this.cwd)}. Treat that directory as the current directory for this task and create task artifacts there.\n\n${prompt}`,
         ),
       closeStdinAfterPrompt: true,
-      idleTimeoutMs: this.config.idleTimeoutMs,
+      idleTimeout: this.config.idleTimeout,
       maxLineBytes: this.config.maxLineBytes,
       maxInterrupts: 1,
     });

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,
@@ -108,19 +109,19 @@ export const ClaudeCodeDriverConfigSchema = z
      */
     textQuestionFallback: z.boolean().default(false),
     /** Maximum silence between recognized protocol events; excludes answerer wait time. */
-    idleTimeoutMs: z.number().positive().default(600_000),
+    idleTimeout: DurationSchema.default("10 minutes"),
     /** Optional elapsed-time cap per defer-resume CLI invocation, regardless of activity. */
-    turnTimeoutMs: z.number().positive().optional(),
+    turnTimeout: DurationSchema.optional(),
     /** Cap on outstanding interrupts before the driver aborts. */
     maxInterrupts: z.number().positive().default(20),
   })
   .strict()
   .superRefine((config, ctx) => {
-    if (config.turnTimeoutMs !== undefined && config.interactionMode !== "defer-resume") {
+    if (config.turnTimeout !== undefined && config.interactionMode !== "defer-resume") {
       ctx.addIssue({
         code: "custom",
-        path: ["turnTimeoutMs"],
-        message: "turnTimeoutMs requires defer-resume mode",
+        path: ["turnTimeout"],
+        message: "turnTimeout requires defer-resume mode",
       });
     }
     if (config.interactionMode === "defer-resume") {
@@ -596,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);
@@ -752,10 +753,10 @@ class ClaudeCodeDriverImpl implements AgentDriver {
         ...(answer ? { LUX_CLAUDE_DEFERRED_ANSWER: JSON.stringify(answer) } : {}),
       },
       ...input,
-      idleTimeoutMs: this.config.idleTimeoutMs,
-      ...(this.config.turnTimeoutMs === undefined
+      idleTimeoutMs: durationMs(this.config.idleTimeout),
+      ...(this.config.turnTimeout === undefined
         ? {}
-        : { turnTimeoutMs: this.config.turnTimeoutMs }),
+        : { turnTimeoutMs: durationMs(this.config.turnTimeout) }),
       signal: AbortSignal.any([ctx.abortSignal, this.deferredAbort.signal]),
       parse: (line) => {
         try {

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/shared/artifacts.ts

@@ -6,7 +6,7 @@ import {
   readArtifactSnapshotManifest,
 } from "../../core/index.js";
 
-const IGNORED_DIRS = new Set(["node_modules", "lib", "dist"]);
+const IGNORED_DIRS = new Set(["node_modules", "dist"]);
 
 /** Enumerate agent-authored files without following symlinks or build/dependency trees. */
 export const walkArtifacts = async (root: string, max = 500): Promise<Artifact[]> => {
@@ -71,7 +71,11 @@ export const walkArtifacts = async (root: string, max = 500): Promise<Artifact[]
       const full = join(dir, entry.name);
       if (entry.isDirectory()) {
         if (await collectSnapshot(full)) continue;
-        if (entry.name.startsWith(".") || IGNORED_DIRS.has(entry.name)) continue;
+        if (
+          (entry.name.startsWith(".") && entry.name !== ".spectral") ||
+          IGNORED_DIRS.has(entry.name)
+        )
+          continue;
         await walk(full);
       } else if (entry.isFile()) {
         const metadata = await lstat(full);

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/experiment-evaluation.ts

@@ -2,10 +2,7 @@ import { randomUUID } from "node:crypto";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
-import {
-  createRubricAssertion,
-  RubricModelAccountingDetailSchema,
-} from "../assertions/rubric/index.js";
+import { RubricModelAccountingDetailSchema } from "../assertions/rubric/index.js";
 import {
   addUsage,
   type Candidate,
@@ -26,6 +23,7 @@ import { profileOrThrow } from "./experiment-context.js";
 import type { ExperimentEvaluation, OpenedExperimentRun } from "./experiment-runs.js";
 import { average } from "./experiment-selection.js";
 import { evaluateGraderCandidate } from "./grader-experiment.js";
+import { registryWithHarness } from "./harness-registry.js";
 import { loadEvalCase } from "./loader.js";
 import { Orchestrator, type SuiteCaseResult, type SuiteItem } from "./orchestrator.js";
 import { clusterCaseSamples, groupedCaseMetricSamples } from "./paired-effects.js";
@@ -496,7 +494,7 @@ export const evaluateAgentCandidate = async (options: {
   const profile = profileOrThrow(execution.config, profileId);
   const harness = profile.harness ?? execution.config.harness;
   const defaultDriver = profile.driver ?? execution.config.defaultDriver;
-  const registry = execution.registry.withAssertion(createRubricAssertion(harness));
+  const registry = registryWithHarness(execution.registry, execution.config, harness);
   const orchestrator = new Orchestrator({
     environment: profile.environment ?? execution.config.environment,
     registry,

package/src/orchestrator/grader-experiment.ts

@@ -1,10 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
-import {
-  createRubricAssertion,
-  RubricModelAccountingDetailSchema,
-} from "../assertions/rubric/index.js";
+import { RubricModelAccountingDetailSchema } from "../assertions/rubric/index.js";
 import {
   type Candidate,
   type CandidateEvaluation,
@@ -711,7 +708,7 @@ export const evaluateGraderCandidate = async (options: {
   const registry = buildRegistryFromConfig({
     ...execution.config,
     ...(harness ? { harness } : {}),
-  }).withAssertion(createRubricAssertion(harness));
+  });
   const items: GraderEvidenceItem[] = [];
   for (const annotation of selected) {
     const rubric = await loadRubricDefinition(

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/harness-registry.ts

@@ -0,0 +1,12 @@
+import { createRubricAssertion } from "../assertions/rubric/index.js";
+import type { HarnessModelConfig, Registry } from "../core/index.js";
+import type { ResolvedLuxConfig } from "./config.js";
+
+export const registryWithHarness = (
+  registry: Registry,
+  config: Pick<ResolvedLuxConfig, "assertions">,
+  harness: HarnessModelConfig | undefined,
+): Registry =>
+  config.assertions?.some((assertion) => assertion.type === "rubric")
+    ? registry
+    : registry.withAssertion(createRubricAssertion(harness));

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({