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

package/lib/cli/output-schemas.d.ts

@@ -0,0 +1,1399 @@
+import { z } from "incur";
+export declare const ViewOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    runDir: z.ZodString;
+    case: z.ZodNullable<z.ZodObject<{
+        id: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        prompt: z.ZodOptional<z.ZodString>;
+        persona: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        requires: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            artifacts: "artifacts";
+            cost: "cost";
+            interactive: "interactive";
+            isolation: "isolation";
+            subagents: "subagents";
+            "tool-calls": "tool-calls";
+            "tool-results": "tool-results";
+            usage: "usage";
+        }>>>>;
+        assertions: z.ZodOptional<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>>>>;
+        casePath: z.ZodExactOptional<z.ZodString>;
+        driver: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            config: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$loose>]>>;
+        answerer: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            config: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$loose>]>>;
+        fixtures: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            kind: z.ZodLiteral<"dir">;
+            path: z.ZodString;
+        }, z.core.$loose>]>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    metadata: z.ZodNullable<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>;
+        agentUsageAvailability: z.ZodExactOptional<z.ZodEnum<{
+            reported: "reported";
+            unavailable: "unavailable";
+        }>>;
+        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>>;
+        driverMetrics: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            unit: z.ZodDefault<z.ZodEnum<{
+                bytes: "bytes";
+                count: "count";
+                milliseconds: "milliseconds";
+                number: "number";
+                percent: "percent";
+                ratio: "ratio";
+                score: "score";
+                tokens: "tokens";
+                usd: "usd";
+            }>>;
+            label: z.ZodOptional<z.ZodString>;
+            better: z.ZodDefault<z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+                neutral: "neutral";
+            }>>;
+            value: z.ZodNumber;
+        }, z.core.$strict>>>;
+        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>>;
+        actionTiming: z.ZodExactOptional<z.ZodObject<{
+            timeToFirstActionMs: z.ZodExactOptional<z.ZodNumber>;
+            timeToFirstMutationMs: z.ZodExactOptional<z.ZodNumber>;
+            timeToFirstDurableMutationMs: z.ZodExactOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        agentActivity: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodObject<{
+                id: z.ZodString;
+                role: z.ZodEnum<{
+                    main: "main";
+                    subagent: "subagent";
+                }>;
+                parentId: z.ZodExactOptional<z.ZodString>;
+                spawnToolUseId: z.ZodExactOptional<z.ZodString>;
+                name: z.ZodExactOptional<z.ZodString>;
+                model: z.ZodExactOptional<z.ZodString>;
+            }, z.core.$strip>;
+            startedAt: z.ZodNumber;
+            endedAt: z.ZodNumber;
+            durationMs: z.ZodNumber;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                unknown: "unknown";
+            }>;
+            eventCount: z.ZodNumber;
+            usage: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+                total: z.ZodNumber;
+            }, z.core.$strip>;
+            toolCalls: z.ZodObject<{
+                total: z.ZodNumber;
+                succeeded: z.ZodNumber;
+                failed: z.ZodNumber;
+                unresolved: z.ZodNumber;
+            }, z.core.$strip>;
+            actions: z.ZodObject<{
+                total: z.ZodNumber;
+                mutations: z.ZodNumber;
+                durableMutations: z.ZodNumber;
+                timeToFirstActionMs: z.ZodExactOptional<z.ZodNumber>;
+                timeToFirstMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                timeToFirstDurableMutationMs: z.ZodExactOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, 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>;
+                host: z.ZodExactOptional<z.ZodObject<{
+                    osRelease: z.ZodString;
+                    cpuModels: z.ZodArray<z.ZodString>;
+                    logicalCpuCount: z.ZodNumber;
+                    availableParallelism: z.ZodNumber;
+                    totalMemoryBytes: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            environment: z.ZodExactOptional<z.ZodObject<{
+                declared: z.ZodExactOptional<z.ZodObject<{
+                    imageDigest: z.ZodOptional<z.ZodString>;
+                    toolchains: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    network: z.ZodOptional<z.ZodEnum<{
+                        disabled: "disabled";
+                        restricted: "restricted";
+                        unrestricted: "unrestricted";
+                    }>>;
+                    resources: z.ZodOptional<z.ZodObject<{
+                        cpuCount: z.ZodOptional<z.ZodNumber>;
+                        memoryBytes: z.ZodOptional<z.ZodNumber>;
+                        diskBytes: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                concurrency: z.ZodNumber;
+            }, 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>>;
+    grading: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        casePassed: z.ZodNullable<z.ZodBoolean>;
+        caseScore: z.ZodNullable<z.ZodNumber>;
+        assertions: z.ZodArray<z.ZodObject<{
+            id: z.ZodExactOptional<z.ZodString>;
+            type: z.ZodString;
+            name: z.ZodString;
+            passed: z.ZodBoolean;
+            score: z.ZodNumber;
+            weight: z.ZodNumber;
+            threshold: z.ZodNumber;
+            durationMs: z.ZodNumber;
+            comment: z.ZodExactOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodUnknown>;
+            abstention: z.ZodExactOptional<z.ZodLiteral<"insufficient-evidence">>;
+            errorMessage: z.ZodExactOptional<z.ZodString>;
+            usage: z.ZodExactOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        skippedAssertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodString;
+            reason: z.ZodLiteral<"judge-disabled">;
+        }, z.core.$strip>>>;
+        incomplete: z.ZodExactOptional<z.ZodObject<{
+            exitReason: z.ZodEnum<{
+                error: "error";
+                "idle-timeout": "idle-timeout";
+                "max-interactions": "max-interactions";
+            }>;
+            phase: z.ZodOptional<z.ZodEnum<{
+                collection: "collection";
+                grading: "grading";
+                run: "run";
+            }>>;
+        }, 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;
+        agent: z.ZodExactOptional<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                main: "main";
+                subagent: "subagent";
+            }>;
+            parentId: z.ZodExactOptional<z.ZodString>;
+            spawnToolUseId: z.ZodExactOptional<z.ZodString>;
+            name: z.ZodExactOptional<z.ZodString>;
+            model: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        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;
+        summary: z.ZodOptional<z.ZodUnknown>;
+        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.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    suiteId: z.ZodString;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        aborted: "aborted";
+        failed: "failed";
+        passed: "passed";
+        running: "running";
+    }>;
+    aborted: z.ZodBoolean;
+    concurrency: z.ZodNumber;
+    profileId: z.ZodExactOptional<z.ZodString>;
+    experimentId: z.ZodExactOptional<z.ZodString>;
+    experimentUnitId: z.ZodExactOptional<z.ZodString>;
+    experimentAttemptId: z.ZodExactOptional<z.ZodString>;
+    variantId: z.ZodExactOptional<z.ZodString>;
+    candidateId: z.ZodExactOptional<z.ZodString>;
+    subjectHash: z.ZodExactOptional<z.ZodString>;
+    errorMessage: z.ZodExactOptional<z.ZodString>;
+    fixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        pluginVersion: z.ZodString;
+    }, z.core.$strip>>>;
+    items: z.ZodArray<z.ZodObject<{
+        caseId: z.ZodString;
+        canonicalCaseId: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            pending: "pending";
+            running: "running";
+        }>;
+        runDir: z.ZodNullable<z.ZodString>;
+        exitReason: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"done">, z.ZodString]>>;
+        casePassed: z.ZodNullable<z.ZodBoolean>;
+        errorMessage: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    suiteDir: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    experimentId: z.ZodString;
+    campaignId: z.ZodString;
+    campaignPath: z.ZodString;
+    campaignHash: z.ZodString;
+    campaignSnapshot: z.ZodObject<{
+        id: z.ZodString;
+        subject: z.ZodObject<{
+            root: z.ZodString;
+            mutable: z.ZodArray<z.ZodString>;
+            exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            validate: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                command: z.ZodString;
+                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                unsafeHostExecution: z.ZodLiteral<true>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        evaluation: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"grader">;
+            annotations: z.ZodString;
+            allowedAssertionAdditions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+            scoreTolerance: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>], "kind">>;
+        profiles: z.ZodArray<z.ZodString>;
+        splits: z.ZodObject<{
+            train: z.ZodOptional<z.ZodObject<{
+                patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            validation: z.ZodObject<{
+                patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+            test: z.ZodOptional<z.ZodObject<{
+                patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        repetitions: z.ZodDefault<z.ZodObject<{
+            search: z.ZodDefault<z.ZodNumber>;
+            promotion: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            parentIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            components: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>>;
+        objectives: z.ZodDefault<z.ZodObject<{
+            constraints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                metric: z.ZodString;
+                relativeTo: z.ZodExactOptional<z.ZodLiteral<"baseline">>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                profile: z.ZodOptional<z.ZodString>;
+                split: z.ZodDefault<z.ZodEnum<{
+                    test: "test";
+                    train: "train";
+                    validation: "validation";
+                }>>;
+                confidence: z.ZodOptional<z.ZodObject<{
+                    method: z.ZodEnum<{
+                        hoeffding: "hoeffding";
+                        "percentile-bootstrap": "percentile-bootstrap";
+                        wilson: "wilson";
+                    }>;
+                    level: z.ZodDefault<z.ZodNumber>;
+                    resamples: z.ZodDefault<z.ZodNumber>;
+                    seed: z.ZodDefault<z.ZodNumber>;
+                    minSamples: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            minimize: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                metric: z.ZodString;
+                profile: z.ZodOptional<z.ZodString>;
+                split: z.ZodDefault<z.ZodEnum<{
+                    test: "test";
+                    train: "train";
+                    validation: "validation";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        optimizer: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodLiteral<"reflective">;
+            config: z.ZodOptional<z.ZodUnknown>;
+            candidateSelection: z.ZodDefault<z.ZodEnum<{
+                "current-best": "current-best";
+                pareto: "pareto";
+            }>>;
+            mergeFrontier: z.ZodDefault<z.ZodBoolean>;
+            promotionTopK: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        budget: z.ZodDefault<z.ZodObject<{
+            maxCandidates: z.ZodDefault<z.ZodNumber>;
+            patience: z.ZodDefault<z.ZodNumber>;
+            maxMetricCalls: z.ZodDefault<z.ZodNumber>;
+            maxJudgeCalls: z.ZodDefault<z.ZodNumber>;
+            maxProposalCalls: z.ZodDefault<z.ZodNumber>;
+            maxTokens: z.ZodDefault<z.ZodNumber>;
+            maxCostUsd: z.ZodDefault<z.ZodNumber>;
+            maxUnpricedModelCalls: z.ZodDefault<z.ZodNumber>;
+            maxWallTimeMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    resolvedProfiles: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    evaluatorVersion: z.ZodLiteral<1>;
+    luxVersion: z.ZodString;
+    evaluationKind: z.ZodDefault<z.ZodEnum<{
+        agent: "agent";
+        grader: "grader";
+    }>>;
+    evaluationHash: z.ZodExactOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        experiment: "experiment";
+        optimize: "optimize";
+    }>;
+    status: z.ZodEnum<{
+        aborted: "aborted";
+        failed: "failed";
+        passed: "passed";
+        running: "running";
+    }>;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    activeTimeMs: z.ZodDefault<z.ZodNumber>;
+    activeSegmentStartedAt: z.ZodExactOptional<z.ZodString>;
+    subjectRoot: z.ZodString;
+    baseSourceHash: z.ZodString;
+    candidateIntegrityVersion: z.ZodExactOptional<z.ZodLiteral<1>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        candidateHash: z.ZodString;
+        sourceBytes: z.ZodNumber;
+        candidateEnvelopeHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    evaluations: z.ZodArray<z.ZodObject<{
+        profileId: z.ZodString;
+        split: z.ZodEnum<{
+            test: "test";
+            train: "train";
+            validation: "validation";
+        }>;
+        suiteDir: z.ZodExactOptional<z.ZodString>;
+        passRate: z.ZodNumber;
+        casePassRates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        metricDefinitions: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            unit: z.ZodDefault<z.ZodEnum<{
+                bytes: "bytes";
+                count: "count";
+                milliseconds: "milliseconds";
+                number: "number";
+                percent: "percent";
+                ratio: "ratio";
+                score: "score";
+                tokens: "tokens";
+                usd: "usd";
+            }>>;
+            label: z.ZodOptional<z.ZodString>;
+            better: z.ZodDefault<z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+                neutral: "neutral";
+            }>>;
+        }, z.core.$strict>>>;
+        metricCalls: z.ZodExactOptional<z.ZodNumber>;
+        judgeCalls: z.ZodExactOptional<z.ZodNumber>;
+        unpricedModelCalls: z.ZodExactOptional<z.ZodNumber>;
+        usage: z.ZodExactOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheCreation: z.ZodNumber;
+        }, z.core.$strip>>;
+        costUsd: z.ZodExactOptional<z.ZodNumber>;
+        samples: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+        caseSamples: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            identityHash: z.ZodNullable<z.ZodString>;
+            clusterId: z.ZodExactOptional<z.ZodString>;
+            metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+                mean: z.ZodNumber;
+                n: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        failedCases: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            score: z.ZodNullable<z.ZodNumber>;
+            feedback: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        candidateId: z.ZodString;
+        repetitions: z.ZodNumber;
+        summaryPath: z.ZodExactOptional<z.ZodString>;
+        evidencePath: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    accountedEvaluationUnits: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    accountingJournalEntries: z.ZodDefault<z.ZodNumber>;
+    budgetUsage: z.ZodObject<{
+        metricCalls: z.ZodNumber;
+        judgeCalls: z.ZodNumber;
+        unpricedModelCalls: z.ZodOptional<z.ZodNumber>;
+        proposalCalls: z.ZodNumber;
+        usage: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheCreation: z.ZodNumber;
+        }, z.core.$strip>;
+        costUsd: z.ZodNumber;
+    }, z.core.$strip>;
+    championCandidateId: z.ZodExactOptional<z.ZodString>;
+    selection: z.ZodExactOptional<z.ZodObject<{
+        decidedAt: z.ZodString;
+        decisionCandidateIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        promotionFinalistCandidateIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rankedCandidateIds: z.ZodArray<z.ZodString>;
+        eligibleCandidateIds: z.ZodArray<z.ZodString>;
+        championCandidateId: z.ZodExactOptional<z.ZodString>;
+        constraints: z.ZodArray<z.ZodObject<{
+            candidateId: z.ZodString;
+            metric: z.ZodString;
+            relativeTo: z.ZodExactOptional<z.ZodLiteral<"baseline">>;
+            profile: z.ZodExactOptional<z.ZodString>;
+            split: z.ZodEnum<{
+                test: "test";
+                train: "train";
+                validation: "validation";
+            }>;
+            values: z.ZodArray<z.ZodNumber>;
+            passed: z.ZodBoolean;
+            interval: z.ZodExactOptional<z.ZodObject<{
+                method: z.ZodEnum<{
+                    hoeffding: "hoeffding";
+                    "percentile-bootstrap": "percentile-bootstrap";
+                    wilson: "wilson";
+                }>;
+                level: z.ZodNumber;
+                estimate: z.ZodNumber;
+                lower: z.ZodNumber;
+                upper: z.ZodNumber;
+                n: z.ZodNumber;
+                resamples: z.ZodNumber;
+            }, z.core.$strict>>;
+            note: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    errorMessage: z.ZodExactOptional<z.ZodString>;
+    experimentDir: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    runsRoot: z.ZodString;
+    readErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    runs: z.ZodArray<z.ZodObject<{
+        caseSlug: z.ZodString;
+        driverName: z.ZodString;
+        ts: z.ZodString;
+        runDir: z.ZodString;
+        exitReason: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"done">, z.ZodEnum<{
+            error: "error";
+            "idle-timeout": "idle-timeout";
+            "max-interactions": "max-interactions";
+        }>]>>;
+        driverAgentId: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        endedAt: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        timeToFirstActionMs: z.ZodNullable<z.ZodNumber>;
+        timeToFirstMutationMs: z.ZodNullable<z.ZodNumber>;
+        timeToFirstDurableMutationMs: z.ZodNullable<z.ZodNumber>;
+        driverMetrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+            unit: z.ZodDefault<z.ZodEnum<{
+                bytes: "bytes";
+                count: "count";
+                milliseconds: "milliseconds";
+                number: "number";
+                percent: "percent";
+                ratio: "ratio";
+                score: "score";
+                tokens: "tokens";
+                usd: "usd";
+            }>>;
+            label: z.ZodOptional<z.ZodString>;
+            better: z.ZodDefault<z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+                neutral: "neutral";
+            }>>;
+            value: z.ZodNumber;
+        }, z.core.$strict>>;
+        subagentCount: z.ZodNumber;
+        casePassed: z.ZodNullable<z.ZodBoolean>;
+        caseScore: z.ZodNullable<z.ZodNumber>;
+        assertionPassed: z.ZodNumber;
+        assertionTotal: z.ZodNumber;
+        readErrors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    suites: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        suiteId: z.ZodString;
+        startedAt: z.ZodString;
+        endedAt: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            aborted: "aborted";
+            failed: "failed";
+            passed: "passed";
+            running: "running";
+        }>;
+        aborted: z.ZodBoolean;
+        concurrency: z.ZodNumber;
+        profileId: z.ZodExactOptional<z.ZodString>;
+        experimentId: z.ZodExactOptional<z.ZodString>;
+        experimentUnitId: z.ZodExactOptional<z.ZodString>;
+        experimentAttemptId: z.ZodExactOptional<z.ZodString>;
+        variantId: z.ZodExactOptional<z.ZodString>;
+        candidateId: z.ZodExactOptional<z.ZodString>;
+        subjectHash: z.ZodExactOptional<z.ZodString>;
+        errorMessage: z.ZodExactOptional<z.ZodString>;
+        fixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            pluginVersion: z.ZodString;
+        }, z.core.$strip>>>;
+        items: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            canonicalCaseId: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                pending: "pending";
+                running: "running";
+            }>;
+            runDir: z.ZodNullable<z.ZodString>;
+            exitReason: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"done">, z.ZodString]>>;
+            casePassed: z.ZodNullable<z.ZodBoolean>;
+            errorMessage: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        suiteDir: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    runsRoot: z.ZodString;
+    readErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    suites: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        suiteId: z.ZodString;
+        startedAt: z.ZodString;
+        endedAt: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            aborted: "aborted";
+            failed: "failed";
+            passed: "passed";
+            running: "running";
+        }>;
+        aborted: z.ZodBoolean;
+        concurrency: z.ZodNumber;
+        profileId: z.ZodExactOptional<z.ZodString>;
+        experimentId: z.ZodExactOptional<z.ZodString>;
+        experimentUnitId: z.ZodExactOptional<z.ZodString>;
+        experimentAttemptId: z.ZodExactOptional<z.ZodString>;
+        variantId: z.ZodExactOptional<z.ZodString>;
+        candidateId: z.ZodExactOptional<z.ZodString>;
+        subjectHash: z.ZodExactOptional<z.ZodString>;
+        errorMessage: z.ZodExactOptional<z.ZodString>;
+        fixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            pluginVersion: z.ZodString;
+        }, z.core.$strip>>>;
+        items: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            canonicalCaseId: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                pending: "pending";
+                running: "running";
+            }>;
+            runDir: z.ZodNullable<z.ZodString>;
+            exitReason: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"done">, z.ZodString]>>;
+            casePassed: z.ZodNullable<z.ZodBoolean>;
+            errorMessage: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        suiteDir: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    runsRoot: z.ZodString;
+    readErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    experiments: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        experimentId: z.ZodString;
+        campaignId: z.ZodString;
+        campaignPath: z.ZodString;
+        campaignHash: z.ZodString;
+        campaignSnapshot: z.ZodObject<{
+            id: z.ZodString;
+            subject: z.ZodObject<{
+                root: z.ZodString;
+                mutable: z.ZodArray<z.ZodString>;
+                exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                validate: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    command: z.ZodString;
+                    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    timeoutMs: z.ZodDefault<z.ZodNumber>;
+                    unsafeHostExecution: z.ZodLiteral<true>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            evaluation: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"grader">;
+                annotations: z.ZodString;
+                allowedAssertionAdditions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+                scoreTolerance: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>], "kind">>;
+            profiles: z.ZodArray<z.ZodString>;
+            splits: z.ZodObject<{
+                train: z.ZodOptional<z.ZodObject<{
+                    patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
+                validation: z.ZodObject<{
+                    patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>;
+                test: z.ZodOptional<z.ZodObject<{
+                    patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            repetitions: z.ZodDefault<z.ZodObject<{
+                search: z.ZodDefault<z.ZodNumber>;
+                promotion: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                parentIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                components: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>>;
+            objectives: z.ZodDefault<z.ZodObject<{
+                constraints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    metric: z.ZodString;
+                    relativeTo: z.ZodExactOptional<z.ZodLiteral<"baseline">>;
+                    min: z.ZodOptional<z.ZodNumber>;
+                    max: z.ZodOptional<z.ZodNumber>;
+                    profile: z.ZodOptional<z.ZodString>;
+                    split: z.ZodDefault<z.ZodEnum<{
+                        test: "test";
+                        train: "train";
+                        validation: "validation";
+                    }>>;
+                    confidence: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            hoeffding: "hoeffding";
+                            "percentile-bootstrap": "percentile-bootstrap";
+                            wilson: "wilson";
+                        }>;
+                        level: z.ZodDefault<z.ZodNumber>;
+                        resamples: z.ZodDefault<z.ZodNumber>;
+                        seed: z.ZodDefault<z.ZodNumber>;
+                        minSamples: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                minimize: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    metric: z.ZodString;
+                    profile: z.ZodOptional<z.ZodString>;
+                    split: z.ZodDefault<z.ZodEnum<{
+                        test: "test";
+                        train: "train";
+                        validation: "validation";
+                    }>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            optimizer: z.ZodOptional<z.ZodObject<{
+                algorithm: z.ZodLiteral<"reflective">;
+                config: z.ZodOptional<z.ZodUnknown>;
+                candidateSelection: z.ZodDefault<z.ZodEnum<{
+                    "current-best": "current-best";
+                    pareto: "pareto";
+                }>>;
+                mergeFrontier: z.ZodDefault<z.ZodBoolean>;
+                promotionTopK: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            budget: z.ZodDefault<z.ZodObject<{
+                maxCandidates: z.ZodDefault<z.ZodNumber>;
+                patience: z.ZodDefault<z.ZodNumber>;
+                maxMetricCalls: z.ZodDefault<z.ZodNumber>;
+                maxJudgeCalls: z.ZodDefault<z.ZodNumber>;
+                maxProposalCalls: z.ZodDefault<z.ZodNumber>;
+                maxTokens: z.ZodDefault<z.ZodNumber>;
+                maxCostUsd: z.ZodDefault<z.ZodNumber>;
+                maxUnpricedModelCalls: z.ZodDefault<z.ZodNumber>;
+                maxWallTimeMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+        resolvedProfiles: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        evaluatorVersion: z.ZodLiteral<1>;
+        luxVersion: z.ZodString;
+        evaluationKind: z.ZodDefault<z.ZodEnum<{
+            agent: "agent";
+            grader: "grader";
+        }>>;
+        evaluationHash: z.ZodExactOptional<z.ZodString>;
+        mode: z.ZodEnum<{
+            experiment: "experiment";
+            optimize: "optimize";
+        }>;
+        status: z.ZodEnum<{
+            aborted: "aborted";
+            failed: "failed";
+            passed: "passed";
+            running: "running";
+        }>;
+        startedAt: z.ZodString;
+        endedAt: z.ZodNullable<z.ZodString>;
+        activeTimeMs: z.ZodDefault<z.ZodNumber>;
+        activeSegmentStartedAt: z.ZodExactOptional<z.ZodString>;
+        subjectRoot: z.ZodString;
+        baseSourceHash: z.ZodString;
+        candidateIntegrityVersion: z.ZodExactOptional<z.ZodLiteral<1>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            candidateHash: z.ZodString;
+            sourceBytes: z.ZodNumber;
+            candidateEnvelopeHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        evaluations: z.ZodArray<z.ZodObject<{
+            profileId: z.ZodString;
+            split: z.ZodEnum<{
+                test: "test";
+                train: "train";
+                validation: "validation";
+            }>;
+            suiteDir: z.ZodExactOptional<z.ZodString>;
+            passRate: z.ZodNumber;
+            casePassRates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            metricDefinitions: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                unit: z.ZodDefault<z.ZodEnum<{
+                    bytes: "bytes";
+                    count: "count";
+                    milliseconds: "milliseconds";
+                    number: "number";
+                    percent: "percent";
+                    ratio: "ratio";
+                    score: "score";
+                    tokens: "tokens";
+                    usd: "usd";
+                }>>;
+                label: z.ZodOptional<z.ZodString>;
+                better: z.ZodDefault<z.ZodEnum<{
+                    higher: "higher";
+                    lower: "lower";
+                    neutral: "neutral";
+                }>>;
+            }, z.core.$strict>>>;
+            metricCalls: z.ZodExactOptional<z.ZodNumber>;
+            judgeCalls: z.ZodExactOptional<z.ZodNumber>;
+            unpricedModelCalls: z.ZodExactOptional<z.ZodNumber>;
+            usage: z.ZodExactOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+            }, z.core.$strip>>;
+            costUsd: z.ZodExactOptional<z.ZodNumber>;
+            samples: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+            caseSamples: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                identityHash: z.ZodNullable<z.ZodString>;
+                clusterId: z.ZodExactOptional<z.ZodString>;
+                metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    mean: z.ZodNumber;
+                    n: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            failedCases: z.ZodArray<z.ZodObject<{
+                caseId: z.ZodString;
+                score: z.ZodNullable<z.ZodNumber>;
+                feedback: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            candidateId: z.ZodString;
+            repetitions: z.ZodNumber;
+            summaryPath: z.ZodExactOptional<z.ZodString>;
+            evidencePath: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        accountedEvaluationUnits: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        accountingJournalEntries: z.ZodDefault<z.ZodNumber>;
+        budgetUsage: z.ZodObject<{
+            metricCalls: z.ZodNumber;
+            judgeCalls: z.ZodNumber;
+            unpricedModelCalls: z.ZodOptional<z.ZodNumber>;
+            proposalCalls: z.ZodNumber;
+            usage: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheCreation: z.ZodNumber;
+            }, z.core.$strip>;
+            costUsd: z.ZodNumber;
+        }, z.core.$strip>;
+        championCandidateId: z.ZodExactOptional<z.ZodString>;
+        selection: z.ZodExactOptional<z.ZodObject<{
+            decidedAt: z.ZodString;
+            decisionCandidateIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            promotionFinalistCandidateIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rankedCandidateIds: z.ZodArray<z.ZodString>;
+            eligibleCandidateIds: z.ZodArray<z.ZodString>;
+            championCandidateId: z.ZodExactOptional<z.ZodString>;
+            constraints: z.ZodArray<z.ZodObject<{
+                candidateId: z.ZodString;
+                metric: z.ZodString;
+                relativeTo: z.ZodExactOptional<z.ZodLiteral<"baseline">>;
+                profile: z.ZodExactOptional<z.ZodString>;
+                split: z.ZodEnum<{
+                    test: "test";
+                    train: "train";
+                    validation: "validation";
+                }>;
+                values: z.ZodArray<z.ZodNumber>;
+                passed: z.ZodBoolean;
+                interval: z.ZodExactOptional<z.ZodObject<{
+                    method: z.ZodEnum<{
+                        hoeffding: "hoeffding";
+                        "percentile-bootstrap": "percentile-bootstrap";
+                        wilson: "wilson";
+                    }>;
+                    level: z.ZodNumber;
+                    estimate: z.ZodNumber;
+                    lower: z.ZodNumber;
+                    upper: z.ZodNumber;
+                    n: z.ZodNumber;
+                    resamples: z.ZodNumber;
+                }, z.core.$strict>>;
+                note: z.ZodExactOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        errorMessage: z.ZodExactOptional<z.ZodString>;
+        experimentDir: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    url: z.ZodString;
+    runsRoot: z.ZodString;
+}, z.core.$strip>]>;
+export declare const CompareOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    pathA: z.ZodString;
+    pathB: z.ZodString;
+    passRateTolerance: z.ZodNumber;
+    before: z.ZodObject<{
+        attempts: z.ZodNumber;
+        passRate: z.ZodNumber;
+    }, z.core.$strict>;
+    after: z.ZodObject<{
+        attempts: z.ZodNumber;
+        passRate: z.ZodNumber;
+    }, z.core.$strict>;
+    passRateDelta: z.ZodNumber;
+    cases: z.ZodArray<z.ZodObject<{
+        canonicalCaseId: z.ZodString;
+        before: z.ZodNullable<z.ZodObject<{
+            attempts: z.ZodNumber;
+            passRate: z.ZodNumber;
+        }, z.core.$strict>>;
+        after: z.ZodNullable<z.ZodObject<{
+            attempts: z.ZodNumber;
+            passRate: z.ZodNumber;
+        }, z.core.$strict>>;
+        passRateDelta: z.ZodNullable<z.ZodNumber>;
+        regressed: z.ZodBoolean;
+        pairedMetricDeltas: z.ZodRecord<z.ZodString, z.ZodObject<{
+            n: z.ZodNumber;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+            mean: z.ZodNumber;
+            median: z.ZodNumber;
+            p90: z.ZodNumber;
+            unit: z.ZodExactOptional<z.ZodEnum<{
+                bytes: "bytes";
+                count: "count";
+                milliseconds: "milliseconds";
+                number: "number";
+                percent: "percent";
+                ratio: "ratio";
+                score: "score";
+                tokens: "tokens";
+                usd: "usd";
+            }>>;
+            label: z.ZodExactOptional<z.ZodString>;
+            better: z.ZodExactOptional<z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+                neutral: "neutral";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>;
+    identityMismatches: z.ZodArray<z.ZodObject<{
+        canonicalCaseId: z.ZodString;
+        repetition: z.ZodNumber;
+        before: z.ZodNullable<z.ZodString>;
+        after: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    regressions: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    pathA: z.ZodString;
+    pathB: z.ZodString;
+    caseMismatch: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        a: z.ZodUnknown;
+        b: z.ZodUnknown;
+    }, z.core.$strip>>;
+    runDelta: z.ZodNullable<z.ZodObject<{
+        exitReason: z.ZodObject<{
+            a: z.ZodString;
+            b: z.ZodString;
+        }, z.core.$strip>;
+        durationMsA: z.ZodNullable<z.ZodNumber>;
+        durationMsB: z.ZodNullable<z.ZodNumber>;
+        actionTiming: z.ZodObject<{
+            a: z.ZodObject<{
+                timeToFirstActionMs: z.ZodExactOptional<z.ZodNumber>;
+                timeToFirstMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                timeToFirstDurableMutationMs: z.ZodExactOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            b: z.ZodObject<{
+                timeToFirstActionMs: z.ZodExactOptional<z.ZodNumber>;
+                timeToFirstMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                timeToFirstDurableMutationMs: z.ZodExactOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        driverMetrics: z.ZodObject<{
+            a: z.ZodRecord<z.ZodString, z.ZodObject<{
+                unit: z.ZodDefault<z.ZodEnum<{
+                    bytes: "bytes";
+                    count: "count";
+                    milliseconds: "milliseconds";
+                    number: "number";
+                    percent: "percent";
+                    ratio: "ratio";
+                    score: "score";
+                    tokens: "tokens";
+                    usd: "usd";
+                }>>;
+                label: z.ZodOptional<z.ZodString>;
+                better: z.ZodDefault<z.ZodEnum<{
+                    higher: "higher";
+                    lower: "lower";
+                    neutral: "neutral";
+                }>>;
+                value: z.ZodNumber;
+            }, z.core.$strict>>;
+            b: z.ZodRecord<z.ZodString, z.ZodObject<{
+                unit: z.ZodDefault<z.ZodEnum<{
+                    bytes: "bytes";
+                    count: "count";
+                    milliseconds: "milliseconds";
+                    number: "number";
+                    percent: "percent";
+                    ratio: "ratio";
+                    score: "score";
+                    tokens: "tokens";
+                    usd: "usd";
+                }>>;
+                label: z.ZodOptional<z.ZodString>;
+                better: z.ZodDefault<z.ZodEnum<{
+                    higher: "higher";
+                    lower: "lower";
+                    neutral: "neutral";
+                }>>;
+                value: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strip>;
+        agentActivity: z.ZodObject<{
+            a: z.ZodArray<z.ZodObject<{
+                agent: z.ZodObject<{
+                    id: z.ZodString;
+                    role: z.ZodEnum<{
+                        main: "main";
+                        subagent: "subagent";
+                    }>;
+                    parentId: z.ZodExactOptional<z.ZodString>;
+                    spawnToolUseId: z.ZodExactOptional<z.ZodString>;
+                    name: z.ZodExactOptional<z.ZodString>;
+                    model: z.ZodExactOptional<z.ZodString>;
+                }, z.core.$strip>;
+                startedAt: z.ZodNumber;
+                endedAt: z.ZodNumber;
+                durationMs: z.ZodNumber;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    completed: "completed";
+                    failed: "failed";
+                    unknown: "unknown";
+                }>;
+                eventCount: z.ZodNumber;
+                usage: z.ZodObject<{
+                    input: z.ZodNumber;
+                    output: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheCreation: z.ZodNumber;
+                    total: z.ZodNumber;
+                }, z.core.$strip>;
+                toolCalls: z.ZodObject<{
+                    total: z.ZodNumber;
+                    succeeded: z.ZodNumber;
+                    failed: z.ZodNumber;
+                    unresolved: z.ZodNumber;
+                }, z.core.$strip>;
+                actions: z.ZodObject<{
+                    total: z.ZodNumber;
+                    mutations: z.ZodNumber;
+                    durableMutations: z.ZodNumber;
+                    timeToFirstActionMs: z.ZodExactOptional<z.ZodNumber>;
+                    timeToFirstMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                    timeToFirstDurableMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            b: z.ZodArray<z.ZodObject<{
+                agent: z.ZodObject<{
+                    id: z.ZodString;
+                    role: z.ZodEnum<{
+                        main: "main";
+                        subagent: "subagent";
+                    }>;
+                    parentId: z.ZodExactOptional<z.ZodString>;
+                    spawnToolUseId: z.ZodExactOptional<z.ZodString>;
+                    name: z.ZodExactOptional<z.ZodString>;
+                    model: z.ZodExactOptional<z.ZodString>;
+                }, z.core.$strip>;
+                startedAt: z.ZodNumber;
+                endedAt: z.ZodNumber;
+                durationMs: z.ZodNumber;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    completed: "completed";
+                    failed: "failed";
+                    unknown: "unknown";
+                }>;
+                eventCount: z.ZodNumber;
+                usage: z.ZodObject<{
+                    input: z.ZodNumber;
+                    output: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheCreation: z.ZodNumber;
+                    total: z.ZodNumber;
+                }, z.core.$strip>;
+                toolCalls: z.ZodObject<{
+                    total: z.ZodNumber;
+                    succeeded: z.ZodNumber;
+                    failed: z.ZodNumber;
+                    unresolved: z.ZodNumber;
+                }, z.core.$strip>;
+                actions: z.ZodObject<{
+                    total: z.ZodNumber;
+                    mutations: z.ZodNumber;
+                    durableMutations: z.ZodNumber;
+                    timeToFirstActionMs: z.ZodExactOptional<z.ZodNumber>;
+                    timeToFirstMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                    timeToFirstDurableMutationMs: z.ZodExactOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        interruptCounts: z.ZodObject<{
+            a: z.ZodObject<{
+                ask: z.ZodNumber;
+                approve: z.ZodNumber;
+                custom: z.ZodNumber;
+            }, z.core.$strip>;
+            b: z.ZodObject<{
+                ask: z.ZodNumber;
+                approve: z.ZodNumber;
+                custom: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        usage: z.ZodObject<{
+            a: 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>;
+            b: 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>;
+        }, z.core.$strip>;
+        agentUsageAvailable: z.ZodOptional<z.ZodObject<{
+            a: z.ZodBoolean;
+            b: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    grading: z.ZodObject<{
+        casePassedA: z.ZodNullable<z.ZodBoolean>;
+        casePassedB: z.ZodNullable<z.ZodBoolean>;
+        caseScoreA: z.ZodNullable<z.ZodNumber>;
+        caseScoreB: z.ZodNullable<z.ZodNumber>;
+        deltas: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodString;
+            before: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodBoolean;
+                score: z.ZodNumber;
+            }, z.core.$strip>>;
+            after: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodBoolean;
+                score: z.ZodNumber;
+            }, z.core.$strip>>;
+            status: z.ZodEnum<{
+                added: "added";
+                improved: "improved";
+                regressed: "regressed";
+                removed: "removed";
+                unchanged: "unchanged";
+            }>;
+        }, z.core.$strip>>;
+        improvements: z.ZodNumber;
+        regressions: z.ZodNumber;
+    }, z.core.$strip>;
+    artifactsDelta: z.ZodObject<{
+        added: z.ZodArray<z.ZodString>;
+        removed: z.ZodArray<z.ZodString>;
+        changed: z.ZodArray<z.ZodString>;
+        unchanged: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+//# sourceMappingURL=output-schemas.d.ts.map