@prismatic-io/lux 0.0.1

package/lib/core/registry.d.ts

@@ -0,0 +1,22 @@
+import type { AnswererPlugin } from "./answerer.js";
+import type { AssertionImpl } from "./assertion.js";
+import type { Assertion } from "./case.js";
+import type { DriverPlugin } from "./driver.js";
+type StoredDriver = DriverPlugin<unknown>;
+type StoredAnswerer = AnswererPlugin<unknown>;
+type StoredAssertion = AssertionImpl;
+export declare class Registry {
+    private readonly drivers;
+    private readonly answerers;
+    private readonly assertions;
+    registerDriver<Cfg>(plugin: DriverPlugin<Cfg>): void;
+    registerAnswerer<Cfg>(plugin: AnswererPlugin<Cfg>): void;
+    registerAssertion<C extends Assertion>(impl: AssertionImpl<C>): void;
+    getDriver(name: string): StoredDriver | undefined;
+    getAnswerer(name: string): StoredAnswerer | undefined;
+    getAssertion(type: string): StoredAssertion | undefined;
+    /** Copy the registry while replacing one assertion implementation. */
+    withAssertion<C extends Assertion>(impl: AssertionImpl<C>): Registry;
+}
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/lib/core/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/core/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,KAAK,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;AAC1C,KAAK,cAAc,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;AAC9C,KAAK,eAAe,GAAG,aAAa,CAAC;AAErC,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IAEjE,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,CAKnD;IAED,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,IAAI,CAKvD;IAED,iBAAiB,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAKnE;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEhD;IAED,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEpD;IAED,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEtD;IAED,sEAAsE;IACtE,aAAa,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAOnE;CACF"}

package/lib/core/registry.js

@@ -0,0 +1,45 @@
+export class Registry {
+    drivers = new Map();
+    answerers = new Map();
+    assertions = new Map();
+    registerDriver(plugin) {
+        if (this.drivers.has(plugin.name)) {
+            throw new Error(`driver already registered: ${plugin.name}`);
+        }
+        this.drivers.set(plugin.name, plugin);
+    }
+    registerAnswerer(plugin) {
+        if (this.answerers.has(plugin.name)) {
+            throw new Error(`answerer already registered: ${plugin.name}`);
+        }
+        this.answerers.set(plugin.name, plugin);
+    }
+    registerAssertion(impl) {
+        if (this.assertions.has(impl.type)) {
+            throw new Error(`assertion already registered: ${impl.type}`);
+        }
+        this.assertions.set(impl.type, impl);
+    }
+    getDriver(name) {
+        return this.drivers.get(name);
+    }
+    getAnswerer(name) {
+        return this.answerers.get(name);
+    }
+    getAssertion(type) {
+        return this.assertions.get(type);
+    }
+    /** Copy the registry while replacing one assertion implementation. */
+    withAssertion(impl) {
+        const registry = new Registry();
+        for (const [name, driver] of this.drivers)
+            registry.drivers.set(name, driver);
+        for (const [name, answerer] of this.answerers)
+            registry.answerers.set(name, answerer);
+        for (const [type, assertion] of this.assertions)
+            registry.assertions.set(type, assertion);
+        registry.assertions.set(impl.type, impl);
+        return registry;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/lib/core/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/core/registry.ts"],"names":[],"mappings":"AASA,MAAM,OAAO,QAAQ;IACF,OAAO,GAAG,IAAI,GAAG,EAAwB,CAAC;IAC1C,SAAS,GAAG,IAAI,GAAG,EAA0B,CAAC;IAC9C,UAAU,GAAG,IAAI,GAAG,EAA2B,CAAC;IAEjE,cAAc,CAAM,MAAyB;QAC3C,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,8BAA8B,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAiC,CAAC,CAAC;IACnE,CAAC;IAED,gBAAgB,CAAM,MAA2B;QAC/C,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,gCAAgC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAmC,CAAC,CAAC;IACvE,CAAC;IAED,iBAAiB,CAAsB,IAAsB;QAC3D,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAkC,CAAC,CAAC;IACrE,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED,YAAY,CAAC,IAAY;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,sEAAsE;IACtE,aAAa,CAAsB,IAAsB;QACvD,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;QAChC,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO;YAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC9E,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,SAAS;YAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACtF,KAAK,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,IAAI,CAAC,UAAU;YAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC1F,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAkC,CAAC,CAAC;QACvE,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF"}

package/lib/core/rubric.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const RubricDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    assertions: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    description: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type RubricDefinitionInput = z.input<typeof RubricDefinitionSchema>;
+export type RubricDefinition = z.output<typeof RubricDefinitionSchema>;
+export declare const defineRubric: (input: RubricDefinitionInput) => RubricDefinition;
+//# sourceMappingURL=rubric.d.ts.map

package/lib/core/rubric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rubric.d.ts","sourceRoot":"","sources":["../../src/core/rubric.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;kBAqC/B,CAAC;AACL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC3E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE,eAAO,MAAM,YAAY,UAAW,qBAAqB,KAAG,gBAM3D,CAAC"}

package/lib/core/rubric.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { AssertionSchema } from "./case.js";
+import { formatZodIssues } from "./zod.js";
+export const RubricDefinitionSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    /** Stable rubric identity, normally the canonical case id. */
+    id: z.string().min(1),
+    assertions: z.array(AssertionSchema).min(1),
+    description: z.string().optional(),
+    meta: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict()
+    .superRefine((rubric, ctx) => {
+    const ids = new Set();
+    for (const [index, assertion] of rubric.assertions.entries()) {
+        if (!assertion.id) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["assertions", index, "id"],
+                message: "grader-alignment rubrics require an explicit stable assertion id",
+            });
+            continue;
+        }
+        if (!/^[a-z0-9][a-z0-9_-]*$/.test(assertion.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["assertions", index, "id"],
+                message: "stable assertion ids must be lowercase safe slugs",
+            });
+        }
+        if (ids.has(assertion.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["assertions", index, "id"],
+                message: `duplicate assertion id '${assertion.id}'`,
+            });
+        }
+        ids.add(assertion.id);
+    }
+});
+export const defineRubric = (input) => {
+    const parsed = RubricDefinitionSchema.safeParse(input);
+    if (!parsed.success) {
+        throw new Error(`Invalid Lux rubric: ${formatZodIssues(parsed.error)}`);
+    }
+    return parsed.data;
+};
+//# sourceMappingURL=rubric.js.map

package/lib/core/rubric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rubric.js","sourceRoot":"","sources":["../../src/core/rubric.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,MAAM,CAAC;IACN,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3B,8DAA8D;IAC9D,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACnD,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;IAC3B,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;QAC7D,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;YAClB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC;gBACjC,OAAO,EAAE,kEAAkE;aAC5E,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QACD,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC;YAChD,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC;gBACjC,OAAO,EAAE,mDAAmD;aAC7D,CAAC,CAAC;QACL,CAAC;QACD,IAAI,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC;YAC1B,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC;gBACjC,OAAO,EAAE,2BAA2B,SAAS,CAAC,EAAE,GAAG;aACpD,CAAC,CAAC;QACL,CAAC;QACD,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;AACH,CAAC,CAAC,CAAC;AAIL,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAA4B,EAAoB,EAAE;IAC7E,MAAM,MAAM,GAAG,sBAAsB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACvD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,uBAAuB,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC,CAAC"}

package/lib/core/run.d.ts

@@ -0,0 +1,419 @@
+import { z } from "zod";
+export declare const RUN_SCHEMA_VERSION: 1;
+/**
+ * Wall-clock split of a run. `agent` is the driver working, `grading` is the
+ * assertions running (an LLM judge dominates it), `collect` is artifact capture.
+ */
+export declare const PhaseDurationsSchema: z.ZodObject<{
+    agent: z.ZodNumber;
+    collect: z.ZodNumber;
+    grading: z.ZodNumber;
+}, z.core.$strip>;
+export type PhaseDurations = z.infer<typeof PhaseDurationsSchema>;
+export declare const RunProvenanceSchema: z.ZodObject<{
+    runtime: z.ZodObject<{
+        platform: z.ZodString;
+        arch: z.ZodString;
+        node: z.ZodString;
+        bun: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strip>;
+    source: z.ZodExactOptional<z.ZodObject<{
+        casePath: z.ZodString;
+        git: z.ZodExactOptional<z.ZodObject<{
+            commit: z.ZodString;
+            dirty: z.ZodBoolean;
+            workingTreeHash: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    caseHash: z.ZodExactOptional<z.ZodString>;
+    assertionsHash: z.ZodExactOptional<z.ZodString>;
+    validatedAssertionsHash: z.ZodExactOptional<z.ZodString>;
+    fixturesHash: z.ZodExactOptional<z.ZodString>;
+    subjectHash: z.ZodExactOptional<z.ZodString>;
+    profileId: z.ZodExactOptional<z.ZodString>;
+    experimentId: z.ZodExactOptional<z.ZodString>;
+    variantId: z.ZodExactOptional<z.ZodString>;
+    candidateId: z.ZodExactOptional<z.ZodString>;
+    driverConfigHash: z.ZodExactOptional<z.ZodString>;
+    answererConfigHash: z.ZodExactOptional<z.ZodString>;
+    graderConfigHash: z.ZodExactOptional<z.ZodString>;
+    evaluatorConfigHash: z.ZodExactOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunProvenance = z.infer<typeof RunProvenanceSchema>;
+export declare const OperationalFailureSchema: z.ZodObject<{
+    phase: z.ZodEnum<{
+        abort: "abort";
+        answerer: "answerer";
+        close: "close";
+        collection: "collection";
+        "driver-transport": "driver-transport";
+        grading: "grading";
+        setup: "setup";
+        trace: "trace";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type OperationalFailure = z.infer<typeof OperationalFailureSchema>;
+export declare const RunMetadataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    luxVersion: z.ZodString;
+    suiteId: z.ZodExactOptional<z.ZodString>;
+    startedAt: z.ZodString;
+    agentEndedAt: z.ZodExactOptional<z.ZodString>;
+    endedAt: z.ZodString;
+    exitReason: z.ZodUnion<readonly [z.ZodLiteral<"done">, z.ZodEnum<{
+        error: "error";
+        "idle-timeout": "idle-timeout";
+        "max-interactions": "max-interactions";
+    }>]>;
+    driver: z.ZodObject<{
+        agentId: z.ZodString;
+        agentVersion: z.ZodExactOptional<z.ZodString>;
+        model: z.ZodExactOptional<z.ZodString>;
+        detail: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        name: z.ZodString;
+        version: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strip>;
+    answerer: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodExactOptional<z.ZodString>;
+        provider: z.ZodExactOptional<z.ZodString>;
+        model: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strip>;
+    usage: z.ZodObject<{
+        agent: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheCreation: z.ZodNumber;
+        }, z.core.$strip>;
+        answerer: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheCreation: z.ZodNumber;
+        }, z.core.$strip>;
+        grading: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheCreation: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    modelAccounting: z.ZodExactOptional<z.ZodObject<{
+        agentCalls: z.ZodNumber;
+        answererCalls: z.ZodNumber;
+        reportedCostUsd: z.ZodNumber;
+        unpricedModelCalls: z.ZodNumber;
+    }, z.core.$strip>>;
+    cost: z.ZodExactOptional<z.ZodObject<{
+        usd: z.ZodExactOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    interruptCounts: z.ZodObject<{
+        ask: z.ZodNumber;
+        approve: z.ZodNumber;
+        custom: z.ZodNumber;
+    }, z.core.$strip>;
+    toolCallCount: z.ZodExactOptional<z.ZodNumber>;
+    toolOutcomes: z.ZodExactOptional<z.ZodObject<{
+        reportedCalls: z.ZodNumber;
+        total: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        failed: z.ZodNumber;
+        unresolved: z.ZodNumber;
+        unmatchedResults: z.ZodNumber;
+        malformedEvents: z.ZodNumber;
+    }, z.core.$strip>>;
+    artifacts: z.ZodExactOptional<z.ZodObject<{
+        count: z.ZodNumber;
+        bytes: z.ZodExactOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    phaseDurationMs: z.ZodExactOptional<z.ZodObject<{
+        agent: z.ZodNumber;
+        collect: z.ZodNumber;
+        grading: z.ZodNumber;
+    }, z.core.$strip>>;
+    operationalFailure: z.ZodExactOptional<z.ZodObject<{
+        phase: z.ZodEnum<{
+            abort: "abort";
+            answerer: "answerer";
+            close: "close";
+            collection: "collection";
+            "driver-transport": "driver-transport";
+            grading: "grading";
+            setup: "setup";
+            trace: "trace";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    provenance: z.ZodExactOptional<z.ZodObject<{
+        runtime: z.ZodObject<{
+            platform: z.ZodString;
+            arch: z.ZodString;
+            node: z.ZodString;
+            bun: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>;
+        source: z.ZodExactOptional<z.ZodObject<{
+            casePath: z.ZodString;
+            git: z.ZodExactOptional<z.ZodObject<{
+                commit: z.ZodString;
+                dirty: z.ZodBoolean;
+                workingTreeHash: z.ZodExactOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        caseHash: z.ZodExactOptional<z.ZodString>;
+        assertionsHash: z.ZodExactOptional<z.ZodString>;
+        validatedAssertionsHash: z.ZodExactOptional<z.ZodString>;
+        fixturesHash: z.ZodExactOptional<z.ZodString>;
+        subjectHash: z.ZodExactOptional<z.ZodString>;
+        profileId: z.ZodExactOptional<z.ZodString>;
+        experimentId: z.ZodExactOptional<z.ZodString>;
+        variantId: z.ZodExactOptional<z.ZodString>;
+        candidateId: z.ZodExactOptional<z.ZodString>;
+        driverConfigHash: z.ZodExactOptional<z.ZodString>;
+        answererConfigHash: z.ZodExactOptional<z.ZodString>;
+        graderConfigHash: z.ZodExactOptional<z.ZodString>;
+        evaluatorConfigHash: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunMetadata = z.infer<typeof RunMetadataSchema>;
+export declare const RunSchema: z.ZodObject<{
+    case: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodString;
+        persona: z.ZodOptional<z.ZodString>;
+        driver: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            config: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>]>>;
+        answerer: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            config: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>]>>;
+        fixtures: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            kind: z.ZodLiteral<"dir">;
+            path: z.ZodString;
+        }, z.core.$strict>]>>;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            weight: z.ZodOptional<z.ZodNumber>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    metadata: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        luxVersion: z.ZodString;
+        suiteId: z.ZodExactOptional<z.ZodString>;
+        startedAt: z.ZodString;
+        agentEndedAt: z.ZodExactOptional<z.ZodString>;
+        endedAt: z.ZodString;
+        exitReason: z.ZodUnion<readonly [z.ZodLiteral<"done">, z.ZodEnum<{
+            error: "error";
+            "idle-timeout": "idle-timeout";
+            "max-interactions": "max-interactions";
+        }>]>;
+        driver: z.ZodObject<{
+            agentId: z.ZodString;
+            agentVersion: z.ZodExactOptional<z.ZodString>;
+            model: z.ZodExactOptional<z.ZodString>;
+            detail: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            name: z.ZodString;
+            version: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>;
+        answerer: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodExactOptional<z.ZodString>;
+            provider: z.ZodExactOptional<z.ZodString>;
+            model: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>;
+        usage: z.ZodObject<{
+            agent: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+            }, z.core.$strip>;
+            answerer: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+            }, z.core.$strip>;
+            grading: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        modelAccounting: z.ZodExactOptional<z.ZodObject<{
+            agentCalls: z.ZodNumber;
+            answererCalls: z.ZodNumber;
+            reportedCostUsd: z.ZodNumber;
+            unpricedModelCalls: z.ZodNumber;
+        }, z.core.$strip>>;
+        cost: z.ZodExactOptional<z.ZodObject<{
+            usd: z.ZodExactOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        interruptCounts: z.ZodObject<{
+            ask: z.ZodNumber;
+            approve: z.ZodNumber;
+            custom: z.ZodNumber;
+        }, z.core.$strip>;
+        toolCallCount: z.ZodExactOptional<z.ZodNumber>;
+        toolOutcomes: z.ZodExactOptional<z.ZodObject<{
+            reportedCalls: z.ZodNumber;
+            total: z.ZodNumber;
+            succeeded: z.ZodNumber;
+            failed: z.ZodNumber;
+            unresolved: z.ZodNumber;
+            unmatchedResults: z.ZodNumber;
+            malformedEvents: z.ZodNumber;
+        }, z.core.$strip>>;
+        artifacts: z.ZodExactOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            bytes: z.ZodExactOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        phaseDurationMs: z.ZodExactOptional<z.ZodObject<{
+            agent: z.ZodNumber;
+            collect: z.ZodNumber;
+            grading: z.ZodNumber;
+        }, z.core.$strip>>;
+        operationalFailure: z.ZodExactOptional<z.ZodObject<{
+            phase: z.ZodEnum<{
+                abort: "abort";
+                answerer: "answerer";
+                close: "close";
+                collection: "collection";
+                "driver-transport": "driver-transport";
+                grading: "grading";
+                setup: "setup";
+                trace: "trace";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        provenance: z.ZodExactOptional<z.ZodObject<{
+            runtime: z.ZodObject<{
+                platform: z.ZodString;
+                arch: z.ZodString;
+                node: z.ZodString;
+                bun: z.ZodExactOptional<z.ZodString>;
+            }, z.core.$strip>;
+            source: z.ZodExactOptional<z.ZodObject<{
+                casePath: z.ZodString;
+                git: z.ZodExactOptional<z.ZodObject<{
+                    commit: z.ZodString;
+                    dirty: z.ZodBoolean;
+                    workingTreeHash: z.ZodExactOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            caseHash: z.ZodExactOptional<z.ZodString>;
+            assertionsHash: z.ZodExactOptional<z.ZodString>;
+            validatedAssertionsHash: z.ZodExactOptional<z.ZodString>;
+            fixturesHash: z.ZodExactOptional<z.ZodString>;
+            subjectHash: z.ZodExactOptional<z.ZodString>;
+            profileId: z.ZodExactOptional<z.ZodString>;
+            experimentId: z.ZodExactOptional<z.ZodString>;
+            variantId: z.ZodExactOptional<z.ZodString>;
+            candidateId: z.ZodExactOptional<z.ZodString>;
+            driverConfigHash: z.ZodExactOptional<z.ZodString>;
+            answererConfigHash: z.ZodExactOptional<z.ZodString>;
+            graderConfigHash: z.ZodExactOptional<z.ZodString>;
+            evaluatorConfigHash: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        agentId: z.ZodString;
+        agentVersion: z.ZodExactOptional<z.ZodString>;
+        model: z.ZodExactOptional<z.ZodString>;
+        detail: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"ready">;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ask">;
+        id: z.ZodString;
+        question: z.ZodString;
+        context: z.ZodOptional<z.ZodUnknown>;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"interrupt">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"approve">;
+        id: z.ZodString;
+        request: z.ZodString;
+        context: z.ZodOptional<z.ZodUnknown>;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"interrupt">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        id: z.ZodString;
+        payload: z.ZodUnknown;
+        context: z.ZodOptional<z.ZodUnknown>;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"interrupt">;
+    }, z.core.$strip>], "kind">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ask">;
+        id: z.ZodString;
+        text: z.ZodString;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"responded">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"approve">;
+        id: z.ZodString;
+        approved: z.ZodBoolean;
+        reason: z.ZodExactOptional<z.ZodString>;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"responded">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        id: z.ZodString;
+        payload: z.ZodUnknown;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"responded">;
+    }, z.core.$strip>], "kind">, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        payload: z.ZodUnknown;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"progress">;
+    }, z.core.$strip>, z.ZodObject<{
+        exitReason: z.ZodLiteral<"done">;
+        summary: z.ZodOptional<z.ZodUnknown>;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"done">;
+    }, z.core.$strip>, z.ZodObject<{
+        exitReason: z.ZodEnum<{
+            error: "error";
+            "idle-timeout": "idle-timeout";
+            "max-interactions": "max-interactions";
+        }>;
+        reason: z.ZodString;
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"error">;
+    }, z.core.$strip>, z.ZodObject<{
+        ts: z.ZodNumber;
+        type: z.ZodLiteral<"lifecycle">;
+        stage: z.ZodEnum<{
+            close: "close";
+            "collect-end": "collect-end";
+            "collect-start": "collect-start";
+            "grade-end": "grade-end";
+            "grade-start": "grade-start";
+            load: "load";
+            "prepare-answerer": "prepare-answerer";
+            "run-loop": "run-loop";
+            "start-driver": "start-driver";
+        }>;
+    }, z.core.$strip>], "type">>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        root: z.ZodExactOptional<z.ZodString>;
+        contentType: z.ZodExactOptional<z.ZodString>;
+        size: z.ZodExactOptional<z.ZodNumber>;
+        meta: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    runDir: z.ZodString;
+}, z.core.$strip>;
+export type Run = z.infer<typeof RunSchema>;
+//# sourceMappingURL=run.d.ts.map

package/lib/core/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/core/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,kBAAkB,EAAG,CAAU,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;iBAI/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;kBAc1B,CAAC;AACZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsD5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMpB,CAAC;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}