assertledger 1.0.0

package/dist/contracts/index.d.ts

@@ -0,0 +1,3908 @@
+import * as z from "zod";
+export * from "./runtime-doctor.js";
+export declare const SCHEMA_VERSION: "1.0.0";
+export declare const POLICY_VERSION: "1.0.0";
+export declare const ObservationOutcomeSchema: z.ZodEnum<{
+    ASSERTION_FAILURE: "ASSERTION_FAILURE";
+    COLLECTION_FAILURE: "COLLECTION_FAILURE";
+    COMPILE_FAILURE: "COMPILE_FAILURE";
+    INFRA_ERROR: "INFRA_ERROR";
+    NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+    PASS: "PASS";
+    PROCESS_CRASH: "PROCESS_CRASH";
+    TIMEOUT: "TIMEOUT";
+}>;
+export declare const FileOverlaySchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>;
+export declare const WorldSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        NEUTRAL: "NEUTRAL";
+        REFERENCE: "REFERENCE";
+        TARGET: "TARGET";
+    }>;
+    required: z.ZodBoolean;
+    weight: z.ZodInt;
+    provenance: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const CandidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const NodeTestAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"node-test">;
+    executable: z.ZodString;
+    baseTestFiles: z.ZodArray<z.ZodString>;
+    extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const StructuredCommandAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"testforge-command">;
+    executable: z.ZodString;
+    arguments: z.ZodArray<z.ZodString>;
+    protocolVersion: z.ZodLiteral<"1.0.0">;
+}, z.core.$strict>;
+export declare const AdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"node-test">;
+    executable: z.ZodString;
+    baseTestFiles: z.ZodArray<z.ZodString>;
+    extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"testforge-command">;
+    executable: z.ZodString;
+    arguments: z.ZodArray<z.ZodString>;
+    protocolVersion: z.ZodLiteral<"1.0.0">;
+}, z.core.$strict>], "kind">;
+export declare const StructuredCommandSchema: z.ZodObject<{
+    executable: z.ZodString;
+    arguments: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const TrustedLocalIsolationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"trusted-local">;
+    acknowledgedUnsafeExecution: z.ZodBoolean;
+    environmentAllowlist: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const BudgetsSchema: z.ZodObject<{
+    maximumCandidates: z.ZodInt;
+    maximumWorlds: z.ZodInt;
+    maximumExecutions: z.ZodInt;
+    maximumRepositoryFiles: z.ZodInt;
+    maximumRepositoryBytes: z.ZodInt;
+    maximumWorldOverlayBytes: z.ZodInt;
+    maximumCandidateBytes: z.ZodInt;
+    maximumTotalCandidateBytes: z.ZodInt;
+    timeoutMsPerExecution: z.ZodInt;
+    maximumOutputBytes: z.ZodInt;
+}, z.core.$strict>;
+export declare const PolicySchema: z.ZodObject<{
+    policyVersion: z.ZodLiteral<"1.0.0">;
+    requiredAttempts: z.ZodInt;
+    minimumTargetWeightPermille: z.ZodInt;
+    maximumSelectedCandidates: z.ZodInt;
+    acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+}, z.core.$strict>;
+export declare const VerificationRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    repository: z.ZodObject<{
+        root: z.ZodString;
+        exclude: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node-test">;
+        executable: z.ZodString;
+        baseTestFiles: z.ZodArray<z.ZodString>;
+        extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"testforge-command">;
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>], "kind">;
+    isolation: z.ZodObject<{
+        kind: z.ZodLiteral<"trusted-local">;
+        acknowledgedUnsafeExecution: z.ZodBoolean;
+        environmentAllowlist: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    candidateRoots: z.ZodArray<z.ZodString>;
+    budgets: z.ZodObject<{
+        maximumCandidates: z.ZodInt;
+        maximumWorlds: z.ZodInt;
+        maximumExecutions: z.ZodInt;
+        maximumRepositoryFiles: z.ZodInt;
+        maximumRepositoryBytes: z.ZodInt;
+        maximumWorldOverlayBytes: z.ZodInt;
+        maximumCandidateBytes: z.ZodInt;
+        maximumTotalCandidateBytes: z.ZodInt;
+        timeoutMsPerExecution: z.ZodInt;
+        maximumOutputBytes: z.ZodInt;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        policyVersion: z.ZodLiteral<"1.0.0">;
+        requiredAttempts: z.ZodInt;
+        minimumTargetWeightPermille: z.ZodInt;
+        maximumSelectedCandidates: z.ZodInt;
+        acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+    }, z.core.$strict>;
+    worlds: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            NEUTRAL: "NEUTRAL";
+            REFERENCE: "REFERENCE";
+            TARGET: "TARGET";
+        }>;
+        required: z.ZodBoolean;
+        weight: z.ZodInt;
+        provenance: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const RepositoryAnalysisSchema: z.ZodObject<{
+    root: z.ZodString;
+    fileCount: z.ZodInt;
+    files: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        files: z.ZodInt;
+    }, z.core.$strict>>;
+    detectedTestFrameworks: z.ZodArray<z.ZodString>;
+    repositoryDigest: z.ZodString;
+    capabilities: z.ZodObject<{
+        canExecuteCandidates: z.ZodBoolean;
+        supportedAdapters: z.ZodArray<z.ZodEnum<{
+            "node-test": "node-test";
+            "testforge-command": "testforge-command";
+        }>>;
+        isolationLevels: z.ZodArray<z.ZodLiteral<"UNSANDBOXED">>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const RepositoryAuditSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    root: z.ZodString;
+    repositoryDigest: z.ZodString;
+    fileCount: z.ZodInt;
+    repositoryBytes: z.ZodInt;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    git: z.ZodObject<{
+        supported: z.ZodBoolean;
+        headTimestamp: z.ZodNullable<z.ZodInt>;
+        windowDays: z.ZodLiteral<90>;
+        maximumCommits: z.ZodLiteral<1000>;
+        shallow: z.ZodNullable<z.ZodBoolean>;
+        truncated: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        language: z.ZodNullable<z.ZodString>;
+        supported: z.ZodBoolean;
+        bytes: z.ZodInt;
+        decisionPoints: z.ZodNullable<z.ZodInt>;
+        declaredExports: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        noObservedTestReference: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        associatedTests: z.ZodArray<z.ZodString>;
+        sourceChangedAfterAssociatedTest: z.ZodNullable<z.ZodBoolean>;
+        commitsInWindow: z.ZodNullable<z.ZodInt>;
+        fixCommitsInWindow: z.ZodNullable<z.ZodInt>;
+        weakAssertions: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            category: z.ZodEnum<{
+                CONSTANT_BOOLEAN_EQUALITY: "CONSTANT_BOOLEAN_EQUALITY";
+                DEFINEDNESS_ONLY: "DEFINEDNESS_ONLY";
+                NON_THROW_ONLY: "NON_THROW_ONLY";
+                TRUTHINESS_ONLY: "TRUTHINESS_ONLY";
+                TYPE_ONLY: "TYPE_ONLY";
+            }>;
+            count: z.ZodInt;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    modules: z.ZodArray<z.ZodObject<{
+        pathPrefix: z.ZodString;
+        rank: z.ZodInt;
+        files: z.ZodInt;
+        factualTuple: z.ZodTuple<[z.ZodInt, z.ZodInt, z.ZodInt, z.ZodInt, z.ZodInt, z.ZodInt], null>;
+    }, z.core.$strict>>;
+    cost: z.ZodObject<{
+        candidates: z.ZodInt;
+        worlds: z.ZodInt;
+        attempts: z.ZodInt;
+        executions: z.ZodString;
+        controlExecutions: z.ZodString;
+        candidateExecutions: z.ZodString;
+        overlayBytes: z.ZodString;
+        materializationBytes: z.ZodString;
+        timeoutLimitMs: z.ZodString;
+        capturedStreamLimitBytes: z.ZodString;
+    }, z.core.$strict>;
+    verificationRequest: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repository: z.ZodObject<{
+            root: z.ZodString;
+            exclude: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+            executable: z.ZodString;
+            baseTestFiles: z.ZodArray<z.ZodString>;
+            extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            acknowledgedUnsafeExecution: z.ZodBoolean;
+            environmentAllowlist: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        candidateRoots: z.ZodArray<z.ZodString>;
+        budgets: z.ZodObject<{
+            maximumCandidates: z.ZodInt;
+            maximumWorlds: z.ZodInt;
+            maximumExecutions: z.ZodInt;
+            maximumRepositoryFiles: z.ZodInt;
+            maximumRepositoryBytes: z.ZodInt;
+            maximumWorldOverlayBytes: z.ZodInt;
+            maximumCandidateBytes: z.ZodInt;
+            maximumTotalCandidateBytes: z.ZodInt;
+            timeoutMsPerExecution: z.ZodInt;
+            maximumOutputBytes: z.ZodInt;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+            provenance: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const RepositoryInitDetectionsSchema: z.ZodObject<{
+    packageManager: z.ZodNullable<z.ZodEnum<{
+        bun: "bun";
+        npm: "npm";
+        pip: "pip";
+        pnpm: "pnpm";
+        poetry: "poetry";
+        uv: "uv";
+        yarn: "yarn";
+    }>>;
+    framework: z.ZodNullable<z.ZodEnum<{
+        "bun:test": "bun:test";
+        jest: "jest";
+        "node:test": "node:test";
+        pytest: "pytest";
+        vitest: "vitest";
+    }>>;
+    testCommand: z.ZodNullable<z.ZodObject<{
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    ciProviders: z.ZodArray<z.ZodEnum<{
+        "azure-pipelines": "azure-pipelines";
+        circleci: "circleci";
+        "github-actions": "github-actions";
+        "gitlab-ci": "gitlab-ci";
+    }>>;
+    adapterRecommendation: z.ZodEnum<{
+        "node-test": "node-test";
+        "operator-supplied": "operator-supplied";
+        unavailable: "unavailable";
+    }>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const RepositoryInitConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    repository: z.ZodObject<{
+        root: z.ZodLiteral<".">;
+        exclude: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    packageManager: z.ZodEnum<{
+        bun: "bun";
+        npm: "npm";
+        pip: "pip";
+        pnpm: "pnpm";
+        poetry: "poetry";
+        uv: "uv";
+        yarn: "yarn";
+    }>;
+    framework: z.ZodEnum<{
+        "bun:test": "bun:test";
+        jest: "jest";
+        "node:test": "node:test";
+        pytest: "pytest";
+        vitest: "vitest";
+    }>;
+    testCommand: z.ZodObject<{
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node-test">;
+        executable: z.ZodString;
+        baseTestFiles: z.ZodArray<z.ZodString>;
+        extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"testforge-command">;
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>], "kind">;
+    candidateRoots: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const RepositoryInitLockSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    configDigest: z.ZodString;
+    detector: z.ZodObject<{
+        name: z.ZodLiteral<"assertledger-init">;
+        version: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>;
+    evidence: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        kind: z.ZodEnum<{
+            ADAPTER_CONFIG: "ADAPTER_CONFIG";
+            CI_CONFIG: "CI_CONFIG";
+            LOCKFILE: "LOCKFILE";
+            PACKAGE_MANIFEST: "PACKAGE_MANIFEST";
+            TEST_SOURCE: "TEST_SOURCE";
+        }>;
+    }, z.core.$strict>>;
+    detections: z.ZodObject<{
+        packageManager: z.ZodNullable<z.ZodEnum<{
+            bun: "bun";
+            npm: "npm";
+            pip: "pip";
+            pnpm: "pnpm";
+            poetry: "poetry";
+            uv: "uv";
+            yarn: "yarn";
+        }>>;
+        framework: z.ZodNullable<z.ZodEnum<{
+            "bun:test": "bun:test";
+            jest: "jest";
+            "node:test": "node:test";
+            pytest: "pytest";
+            vitest: "vitest";
+        }>>;
+        testCommand: z.ZodNullable<z.ZodObject<{
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        ciProviders: z.ZodArray<z.ZodEnum<{
+            "azure-pipelines": "azure-pipelines";
+            circleci: "circleci";
+            "github-actions": "github-actions";
+            "gitlab-ci": "gitlab-ci";
+        }>>;
+        adapterRecommendation: z.ZodEnum<{
+            "node-test": "node-test";
+            "operator-supplied": "operator-supplied";
+            unavailable: "unavailable";
+        }>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    lockDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const RepositoryInitResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    status: z.ZodEnum<{
+        BLOCKED: "BLOCKED";
+        CONFLICT: "CONFLICT";
+        CREATED: "CREATED";
+        UNCHANGED: "UNCHANGED";
+        WOULD_CREATE: "WOULD_CREATE";
+    }>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    detections: z.ZodObject<{
+        packageManager: z.ZodNullable<z.ZodEnum<{
+            bun: "bun";
+            npm: "npm";
+            pip: "pip";
+            pnpm: "pnpm";
+            poetry: "poetry";
+            uv: "uv";
+            yarn: "yarn";
+        }>>;
+        framework: z.ZodNullable<z.ZodEnum<{
+            "bun:test": "bun:test";
+            jest: "jest";
+            "node:test": "node:test";
+            pytest: "pytest";
+            vitest: "vitest";
+        }>>;
+        testCommand: z.ZodNullable<z.ZodObject<{
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        ciProviders: z.ZodArray<z.ZodEnum<{
+            "azure-pipelines": "azure-pipelines";
+            circleci: "circleci";
+            "github-actions": "github-actions";
+            "gitlab-ci": "gitlab-ci";
+        }>>;
+        adapterRecommendation: z.ZodEnum<{
+            "node-test": "node-test";
+            "operator-supplied": "operator-supplied";
+            unavailable: "unavailable";
+        }>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    actions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            CREATE: "CREATE";
+            REGENERATE: "REGENERATE";
+        }>;
+        path: z.ZodEnum<{
+            "assertledger.config.json": "assertledger.config.json";
+            "assertledger.lock.json": "assertledger.lock.json";
+        }>;
+    }, z.core.$strict>>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodEnum<{
+            "assertledger.config.json": "assertledger.config.json";
+            "assertledger.lock.json": "assertledger.lock.json";
+        }>;
+        digest: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+    requiredOperatorInputs: z.ZodTuple<[z.ZodLiteral<"worlds">, z.ZodLiteral<"candidates">], null>;
+    nextCommands: z.ZodArray<z.ZodObject<{
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const GateResultSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        COMPLETENESS: "COMPLETENESS";
+        DISCOVERY: "DISCOVERY";
+        NEUTRAL: "NEUTRAL";
+        REFERENCE: "REFERENCE";
+        STABILITY: "STABILITY";
+        TARGET_STRENGTH: "TARGET_STRENGTH";
+    }>;
+    status: z.ZodEnum<{
+        FAILED: "FAILED";
+        NOT_RUN: "NOT_RUN";
+        PASSED: "PASSED";
+    }>;
+    evidenceRunIds: z.ZodArray<z.ZodString>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvidenceObservationSchema: z.ZodObject<{
+    runId: z.ZodString;
+    candidateId: z.ZodNullable<z.ZodString>;
+    worldId: z.ZodString;
+    attempt: z.ZodInt;
+    outcome: z.ZodEnum<{
+        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+        COMPILE_FAILURE: "COMPILE_FAILURE";
+        INFRA_ERROR: "INFRA_ERROR";
+        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+        PASS: "PASS";
+        PROCESS_CRASH: "PROCESS_CRASH";
+        TIMEOUT: "TIMEOUT";
+    }>;
+    testsDiscovered: z.ZodInt;
+    candidateTestsDiscovered: z.ZodInt;
+    attributed: z.ZodBoolean;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    stdoutDigest: z.ZodOptional<z.ZodString>;
+    stderrDigest: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const CandidateAssessmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    digest: z.ZodString;
+    sizeBytes: z.ZodInt;
+    status: z.ZodEnum<{
+        ELIGIBLE: "ELIGIBLE";
+        INCONCLUSIVE: "INCONCLUSIVE";
+        INVALID: "INVALID";
+        UNSTABLE: "UNSTABLE";
+        WEAK_ORACLE: "WEAK_ORACLE";
+    }>;
+    killedTargetIds: z.ZodArray<z.ZodString>;
+    targetWeightKilled: z.ZodInt;
+    gates: z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            COMPLETENESS: "COMPLETENESS";
+            DISCOVERY: "DISCOVERY";
+            NEUTRAL: "NEUTRAL";
+            REFERENCE: "REFERENCE";
+            STABILITY: "STABILITY";
+            TARGET_STRENGTH: "TARGET_STRENGTH";
+        }>;
+        status: z.ZodEnum<{
+            FAILED: "FAILED";
+            NOT_RUN: "NOT_RUN";
+            PASSED: "PASSED";
+        }>;
+        evidenceRunIds: z.ZodArray<z.ZodString>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvidenceManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+    evidenceContext: z.ZodObject<{
+        engine: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        adapter: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            configuration: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        execution: z.ZodObject<{
+            isolation: z.ZodString;
+            environmentAllowlist: z.ZodArray<z.ZodString>;
+            budgets: z.ZodJSONSchema;
+            candidateRoots: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            provenance: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    policy: z.ZodUnion<readonly [z.ZodObject<{
+        policyVersion: z.ZodLiteral<"1.0.0">;
+        requiredAttempts: z.ZodInt;
+        minimumTargetWeightPermille: z.ZodInt;
+        maximumSelectedCandidates: z.ZodInt;
+        acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+    }, z.core.$strict>, z.ZodObject<{
+        policyVersion: z.ZodLiteral<"invalid">;
+        requiredAttempts: z.ZodLiteral<1>;
+        minimumTargetWeightPermille: z.ZodLiteral<1000>;
+        maximumSelectedCandidates: z.ZodLiteral<0>;
+        acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+    }, z.core.$strict>]>;
+    worlds: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            NEUTRAL: "NEUTRAL";
+            REFERENCE: "REFERENCE";
+            TARGET: "TARGET";
+        }>;
+        required: z.ZodBoolean;
+        weight: z.ZodInt;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        sizeBytes: z.ZodInt;
+        status: z.ZodEnum<{
+            ELIGIBLE: "ELIGIBLE";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            INVALID: "INVALID";
+            UNSTABLE: "UNSTABLE";
+            WEAK_ORACLE: "WEAK_ORACLE";
+        }>;
+        killedTargetIds: z.ZodArray<z.ZodString>;
+        targetWeightKilled: z.ZodInt;
+        gates: z.ZodArray<z.ZodObject<{
+            name: z.ZodEnum<{
+                COMPLETENESS: "COMPLETENESS";
+                DISCOVERY: "DISCOVERY";
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                STABILITY: "STABILITY";
+                TARGET_STRENGTH: "TARGET_STRENGTH";
+            }>;
+            status: z.ZodEnum<{
+                FAILED: "FAILED";
+                NOT_RUN: "NOT_RUN";
+                PASSED: "PASSED";
+            }>;
+            evidenceRunIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    observations: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        candidateId: z.ZodNullable<z.ZodString>;
+        worldId: z.ZodString;
+        attempt: z.ZodInt;
+        outcome: z.ZodEnum<{
+            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+            COMPILE_FAILURE: "COMPILE_FAILURE";
+            INFRA_ERROR: "INFRA_ERROR";
+            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+            PASS: "PASS";
+            PROCESS_CRASH: "PROCESS_CRASH";
+            TIMEOUT: "TIMEOUT";
+        }>;
+        testsDiscovered: z.ZodInt;
+        candidateTestsDiscovered: z.ZodInt;
+        attributed: z.ZodBoolean;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        stdoutDigest: z.ZodOptional<z.ZodString>;
+        stderrDigest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    decision: z.ZodObject<{
+        status: z.ZodEnum<{
+            ENGINE_ERROR: "ENGINE_ERROR";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            REJECTED: "REJECTED";
+            VERIFIED: "VERIFIED";
+        }>;
+        selectedCandidateIds: z.ZodArray<z.ZodString>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    decisionDigest: z.ZodString;
+    artifactDigest: z.ZodString;
+    adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node-test">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"testforge-command">;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>], "kind">;
+    isolation: z.ZodObject<{
+        kind: z.ZodLiteral<"trusted-local">;
+        level: z.ZodLiteral<"UNSANDBOXED">;
+        acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const ReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    decisionDigestValid: z.ZodBoolean;
+    artifactDigestValid: z.ZodBoolean;
+    decisionSemanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticProfileLaneSchema: z.ZodObject<{
+    id: z.ZodString;
+    maximumReferenceP95Ms: z.ZodInt;
+}, z.core.$strict>;
+export declare const AgenticProfilePolicySchema: z.ZodObject<{
+    profileVersion: z.ZodLiteral<"1.0.0">;
+    profileId: z.ZodString;
+    mode: z.ZodLiteral<"HARDENING">;
+    minimumTimingSamples: z.ZodInt;
+    lanes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        maximumReferenceP95Ms: z.ZodInt;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const AgenticProfileRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    manifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+        evidenceContext: z.ZodObject<{
+            engine: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            adapter: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                configuration: z.ZodJSONSchema;
+            }, z.core.$strict>;
+            execution: z.ZodObject<{
+                isolation: z.ZodString;
+                environmentAllowlist: z.ZodArray<z.ZodString>;
+                budgets: z.ZodJSONSchema;
+                candidateRoots: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                provenance: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        policy: z.ZodUnion<readonly [z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>, z.ZodObject<{
+            policyVersion: z.ZodLiteral<"invalid">;
+            requiredAttempts: z.ZodLiteral<1>;
+            minimumTargetWeightPermille: z.ZodLiteral<1000>;
+            maximumSelectedCandidates: z.ZodLiteral<0>;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>]>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            digest: z.ZodString;
+            sizeBytes: z.ZodInt;
+            status: z.ZodEnum<{
+                ELIGIBLE: "ELIGIBLE";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                INVALID: "INVALID";
+                UNSTABLE: "UNSTABLE";
+                WEAK_ORACLE: "WEAK_ORACLE";
+            }>;
+            killedTargetIds: z.ZodArray<z.ZodString>;
+            targetWeightKilled: z.ZodInt;
+            gates: z.ZodArray<z.ZodObject<{
+                name: z.ZodEnum<{
+                    COMPLETENESS: "COMPLETENESS";
+                    DISCOVERY: "DISCOVERY";
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    STABILITY: "STABILITY";
+                    TARGET_STRENGTH: "TARGET_STRENGTH";
+                }>;
+                status: z.ZodEnum<{
+                    FAILED: "FAILED";
+                    NOT_RUN: "NOT_RUN";
+                    PASSED: "PASSED";
+                }>;
+                evidenceRunIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        observations: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            candidateId: z.ZodNullable<z.ZodString>;
+            worldId: z.ZodString;
+            attempt: z.ZodInt;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PASS: "PASS";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            testsDiscovered: z.ZodInt;
+            candidateTestsDiscovered: z.ZodInt;
+            attributed: z.ZodBoolean;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            stdoutDigest: z.ZodOptional<z.ZodString>;
+            stderrDigest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        decision: z.ZodObject<{
+            status: z.ZodEnum<{
+                ENGINE_ERROR: "ENGINE_ERROR";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                REJECTED: "REJECTED";
+                VERIFIED: "VERIFIED";
+            }>;
+            selectedCandidateIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        decisionDigest: z.ZodString;
+        artifactDigest: z.ZodString;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            level: z.ZodLiteral<"UNSANDBOXED">;
+            acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        profileVersion: z.ZodLiteral<"1.0.0">;
+        profileId: z.ZodString;
+        mode: z.ZodLiteral<"HARDENING">;
+        minimumTimingSamples: z.ZodInt;
+        lanes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            maximumReferenceP95Ms: z.ZodInt;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AgenticProfileReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    sourceManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+        evidenceContext: z.ZodObject<{
+            engine: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            adapter: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                configuration: z.ZodJSONSchema;
+            }, z.core.$strict>;
+            execution: z.ZodObject<{
+                isolation: z.ZodString;
+                environmentAllowlist: z.ZodArray<z.ZodString>;
+                budgets: z.ZodJSONSchema;
+                candidateRoots: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                provenance: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        policy: z.ZodUnion<readonly [z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>, z.ZodObject<{
+            policyVersion: z.ZodLiteral<"invalid">;
+            requiredAttempts: z.ZodLiteral<1>;
+            minimumTargetWeightPermille: z.ZodLiteral<1000>;
+            maximumSelectedCandidates: z.ZodLiteral<0>;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>]>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            digest: z.ZodString;
+            sizeBytes: z.ZodInt;
+            status: z.ZodEnum<{
+                ELIGIBLE: "ELIGIBLE";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                INVALID: "INVALID";
+                UNSTABLE: "UNSTABLE";
+                WEAK_ORACLE: "WEAK_ORACLE";
+            }>;
+            killedTargetIds: z.ZodArray<z.ZodString>;
+            targetWeightKilled: z.ZodInt;
+            gates: z.ZodArray<z.ZodObject<{
+                name: z.ZodEnum<{
+                    COMPLETENESS: "COMPLETENESS";
+                    DISCOVERY: "DISCOVERY";
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    STABILITY: "STABILITY";
+                    TARGET_STRENGTH: "TARGET_STRENGTH";
+                }>;
+                status: z.ZodEnum<{
+                    FAILED: "FAILED";
+                    NOT_RUN: "NOT_RUN";
+                    PASSED: "PASSED";
+                }>;
+                evidenceRunIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        observations: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            candidateId: z.ZodNullable<z.ZodString>;
+            worldId: z.ZodString;
+            attempt: z.ZodInt;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PASS: "PASS";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            testsDiscovered: z.ZodInt;
+            candidateTestsDiscovered: z.ZodInt;
+            attributed: z.ZodBoolean;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            stdoutDigest: z.ZodOptional<z.ZodString>;
+            stderrDigest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        decision: z.ZodObject<{
+            status: z.ZodEnum<{
+                ENGINE_ERROR: "ENGINE_ERROR";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                REJECTED: "REJECTED";
+                VERIFIED: "VERIFIED";
+            }>;
+            selectedCandidateIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        decisionDigest: z.ZodString;
+        artifactDigest: z.ZodString;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            level: z.ZodLiteral<"UNSANDBOXED">;
+            acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    sourceArtifactDigest: z.ZodString;
+    policy: z.ZodObject<{
+        profileVersion: z.ZodLiteral<"1.0.0">;
+        profileId: z.ZodString;
+        mode: z.ZodLiteral<"HARDENING">;
+        minimumTimingSamples: z.ZodInt;
+        lanes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            maximumReferenceP95Ms: z.ZodInt;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    policyDigest: z.ZodString;
+    status: z.ZodEnum<{
+        BUDGET_MISSED: "BUDGET_MISSED";
+        INSUFFICIENT_TIMING_EVIDENCE: "INSUFFICIENT_TIMING_EVIDENCE";
+        NOT_QUALIFIED: "NOT_QUALIFIED";
+        QUALIFIED: "QUALIFIED";
+    }>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        evidenceStatus: z.ZodEnum<{
+            ELIGIBLE: "ELIGIBLE";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            INVALID: "INVALID";
+            UNSTABLE: "UNSTABLE";
+            WEAK_ORACLE: "WEAK_ORACLE";
+        }>;
+        classification: z.ZodEnum<{
+            BUDGET_MISSED: "BUDGET_MISSED";
+            INSUFFICIENT_TIMING_EVIDENCE: "INSUFFICIENT_TIMING_EVIDENCE";
+            NOT_QUALIFIED: "NOT_QUALIFIED";
+            QUALIFIED: "QUALIFIED";
+        }>;
+        satisfiedLaneIds: z.ZodArray<z.ZodString>;
+        bestLaneId: z.ZodNullable<z.ZodString>;
+        targetWeightKilled: z.ZodInt;
+        totalTargetWeight: z.ZodInt;
+        targetWeightPermille: z.ZodInt;
+        requiredTargetsKilled: z.ZodInt;
+        requiredTargetsTotal: z.ZodInt;
+        killedTargetIds: z.ZodArray<z.ZodString>;
+        marginalTargetWeight: z.ZodInt;
+        consistency: z.ZodObject<{
+            claim: z.ZodEnum<{
+                OBSERVED_CONSISTENT: "OBSERVED_CONSISTENT";
+                OBSERVED_INCONSISTENT: "OBSERVED_INCONSISTENT";
+            }>;
+            attempts: z.ZodInt;
+        }, z.core.$strict>;
+        latency: z.ZodObject<{
+            kind: z.ZodLiteral<"RECORDED_REFERENCE_WALL_TIME">;
+            samples: z.ZodInt;
+            minimumMs: z.ZodNullable<z.ZodNumber>;
+            p50Ms: z.ZodNullable<z.ZodNumber>;
+            p95Ms: z.ZodNullable<z.ZodNumber>;
+            maximumMs: z.ZodNullable<z.ZodNumber>;
+            totalCandidateDurationMs: z.ZodNumber;
+        }, z.core.$strict>;
+        paretoFrontier: z.ZodBoolean;
+    }, z.core.$strict>>;
+    portfolios: z.ZodArray<z.ZodObject<{
+        laneId: z.ZodString;
+        budgetMs: z.ZodInt;
+        selectedCandidateIds: z.ZodArray<z.ZodString>;
+        totalReferenceP95Ms: z.ZodNumber;
+        targetWeight: z.ZodInt;
+        targetWeightPermille: z.ZodInt;
+        requiredTargetsKilled: z.ZodInt;
+        requiredTargetsTotal: z.ZodInt;
+    }, z.core.$strict>>;
+    qualifiedCandidateIds: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+    reportDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticProfileReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    sourceManifestValid: z.ZodBoolean;
+    policyDigestValid: z.ZodBoolean;
+    reportDigestValid: z.ZodBoolean;
+    semanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkPolicySchema: z.ZodObject<{
+    benchmarkVersion: z.ZodLiteral<"1.0.0">;
+    minimumMeasuredSamplesPerRegime: z.ZodInt;
+    coldMeasuredSamples: z.ZodInt;
+    warmupSamples: z.ZodInt;
+    warmMeasuredSamples: z.ZodInt;
+    maximumExecutions: z.ZodInt;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkProtocolSchema: z.ZodObject<{
+    protocolVersion: z.ZodLiteral<"1.0.0">;
+    clock: z.ZodLiteral<"MONOTONIC">;
+    unit: z.ZodLiteral<"MICROSECOND">;
+    quantile: z.ZodLiteral<"NEAREST_RANK">;
+    phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+    coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+    warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkFingerprintSchema: z.ZodObject<{
+    environmentId: z.ZodString;
+    os: z.ZodObject<{
+        platform: z.ZodString;
+        release: z.ZodString;
+        arch: z.ZodString;
+    }, z.core.$strict>;
+    cpu: z.ZodObject<{
+        arch: z.ZodString;
+        model: z.ZodString;
+        logicalCores: z.ZodInt;
+    }, z.core.$strict>;
+    logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+    memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+    executionBoundary: z.ZodLiteral<"UNSANDBOXED">;
+    tools: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+        configurationDigest: z.ZodString;
+    }, z.core.$strict>>;
+    dependencyGraphDigest: z.ZodString;
+    phaseReporterDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    candidateId: z.ZodString;
+    candidateDigest: z.ZodString;
+    regime: z.ZodEnum<{
+        COLD: "COLD";
+        WARM: "WARM";
+    }>;
+    role: z.ZodEnum<{
+        MEASUREMENT: "MEASUREMENT";
+        WARMUP: "WARMUP";
+    }>;
+    ordinal: z.ZodInt;
+    status: z.ZodLiteral<"COMPLETE">;
+    outcome: z.ZodLiteral<"PASS">;
+    phases: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            COMPILE_OR_COLLECTION: "COMPILE_OR_COLLECTION";
+            EXECUTION: "EXECUTION";
+            PREPARATION: "PREPARATION";
+            STARTUP: "STARTUP";
+        }>;
+        durationUs: z.ZodInt;
+    }, z.core.$strict>>;
+    totalUs: z.ZodInt;
+    cpuTimeUs: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    candidateId: z.ZodString;
+    candidateDigest: z.ZodString;
+    regime: z.ZodEnum<{
+        COLD: "COLD";
+        WARM: "WARM";
+    }>;
+    role: z.ZodEnum<{
+        MEASUREMENT: "MEASUREMENT";
+        WARMUP: "WARMUP";
+    }>;
+    ordinal: z.ZodInt;
+    status: z.ZodLiteral<"INCOMPLETE">;
+    outcome: z.ZodEnum<{
+        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+        COMPILE_FAILURE: "COMPILE_FAILURE";
+        INFRA_ERROR: "INFRA_ERROR";
+        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+        PROCESS_CRASH: "PROCESS_CRASH";
+        TIMEOUT: "TIMEOUT";
+    }>;
+    phases: z.ZodNull;
+    totalUs: z.ZodNull;
+    cpuTimeUs: z.ZodNull;
+}, z.core.$strict>], "status">;
+export declare const AgenticBenchmarkRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    sourceManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+        evidenceContext: z.ZodObject<{
+            engine: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            adapter: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                configuration: z.ZodJSONSchema;
+            }, z.core.$strict>;
+            execution: z.ZodObject<{
+                isolation: z.ZodString;
+                environmentAllowlist: z.ZodArray<z.ZodString>;
+                budgets: z.ZodJSONSchema;
+                candidateRoots: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                provenance: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        policy: z.ZodUnion<readonly [z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>, z.ZodObject<{
+            policyVersion: z.ZodLiteral<"invalid">;
+            requiredAttempts: z.ZodLiteral<1>;
+            minimumTargetWeightPermille: z.ZodLiteral<1000>;
+            maximumSelectedCandidates: z.ZodLiteral<0>;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>]>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            digest: z.ZodString;
+            sizeBytes: z.ZodInt;
+            status: z.ZodEnum<{
+                ELIGIBLE: "ELIGIBLE";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                INVALID: "INVALID";
+                UNSTABLE: "UNSTABLE";
+                WEAK_ORACLE: "WEAK_ORACLE";
+            }>;
+            killedTargetIds: z.ZodArray<z.ZodString>;
+            targetWeightKilled: z.ZodInt;
+            gates: z.ZodArray<z.ZodObject<{
+                name: z.ZodEnum<{
+                    COMPLETENESS: "COMPLETENESS";
+                    DISCOVERY: "DISCOVERY";
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    STABILITY: "STABILITY";
+                    TARGET_STRENGTH: "TARGET_STRENGTH";
+                }>;
+                status: z.ZodEnum<{
+                    FAILED: "FAILED";
+                    NOT_RUN: "NOT_RUN";
+                    PASSED: "PASSED";
+                }>;
+                evidenceRunIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        observations: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            candidateId: z.ZodNullable<z.ZodString>;
+            worldId: z.ZodString;
+            attempt: z.ZodInt;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PASS: "PASS";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            testsDiscovered: z.ZodInt;
+            candidateTestsDiscovered: z.ZodInt;
+            attributed: z.ZodBoolean;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            stdoutDigest: z.ZodOptional<z.ZodString>;
+            stderrDigest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        decision: z.ZodObject<{
+            status: z.ZodEnum<{
+                ENGINE_ERROR: "ENGINE_ERROR";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                REJECTED: "REJECTED";
+                VERIFIED: "VERIFIED";
+            }>;
+            selectedCandidateIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        decisionDigest: z.ZodString;
+        artifactDigest: z.ZodString;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            level: z.ZodLiteral<"UNSANDBOXED">;
+            acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    referenceWorldId: z.ZodString;
+    policy: z.ZodObject<{
+        benchmarkVersion: z.ZodLiteral<"1.0.0">;
+        minimumMeasuredSamplesPerRegime: z.ZodInt;
+        coldMeasuredSamples: z.ZodInt;
+        warmupSamples: z.ZodInt;
+        warmMeasuredSamples: z.ZodInt;
+        maximumExecutions: z.ZodInt;
+    }, z.core.$strict>;
+    protocol: z.ZodObject<{
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+        clock: z.ZodLiteral<"MONOTONIC">;
+        unit: z.ZodLiteral<"MICROSECOND">;
+        quantile: z.ZodLiteral<"NEAREST_RANK">;
+        phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+        coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+        warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+    }, z.core.$strict>;
+    fingerprint: z.ZodObject<{
+        environmentId: z.ZodString;
+        os: z.ZodObject<{
+            platform: z.ZodString;
+            release: z.ZodString;
+            arch: z.ZodString;
+        }, z.core.$strict>;
+        cpu: z.ZodObject<{
+            arch: z.ZodString;
+            model: z.ZodString;
+            logicalCores: z.ZodInt;
+        }, z.core.$strict>;
+        logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+        memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+        executionBoundary: z.ZodLiteral<"UNSANDBOXED">;
+        tools: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+            digest: z.ZodString;
+            configurationDigest: z.ZodString;
+        }, z.core.$strict>>;
+        dependencyGraphDigest: z.ZodString;
+        phaseReporterDigest: z.ZodString;
+    }, z.core.$strict>;
+    runs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        candidateId: z.ZodString;
+        candidateDigest: z.ZodString;
+        regime: z.ZodEnum<{
+            COLD: "COLD";
+            WARM: "WARM";
+        }>;
+        role: z.ZodEnum<{
+            MEASUREMENT: "MEASUREMENT";
+            WARMUP: "WARMUP";
+        }>;
+        ordinal: z.ZodInt;
+        status: z.ZodLiteral<"COMPLETE">;
+        outcome: z.ZodLiteral<"PASS">;
+        phases: z.ZodArray<z.ZodObject<{
+            phase: z.ZodEnum<{
+                COMPILE_OR_COLLECTION: "COMPILE_OR_COLLECTION";
+                EXECUTION: "EXECUTION";
+                PREPARATION: "PREPARATION";
+                STARTUP: "STARTUP";
+            }>;
+            durationUs: z.ZodInt;
+        }, z.core.$strict>>;
+        totalUs: z.ZodInt;
+        cpuTimeUs: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        candidateId: z.ZodString;
+        candidateDigest: z.ZodString;
+        regime: z.ZodEnum<{
+            COLD: "COLD";
+            WARM: "WARM";
+        }>;
+        role: z.ZodEnum<{
+            MEASUREMENT: "MEASUREMENT";
+            WARMUP: "WARMUP";
+        }>;
+        ordinal: z.ZodInt;
+        status: z.ZodLiteral<"INCOMPLETE">;
+        outcome: z.ZodEnum<{
+            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+            COMPILE_FAILURE: "COMPILE_FAILURE";
+            INFRA_ERROR: "INFRA_ERROR";
+            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+            PROCESS_CRASH: "PROCESS_CRASH";
+            TIMEOUT: "TIMEOUT";
+        }>;
+        phases: z.ZodNull;
+        totalUs: z.ZodNull;
+        cpuTimeUs: z.ZodNull;
+    }, z.core.$strict>], "status">>;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    sourceManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+        evidenceContext: z.ZodObject<{
+            engine: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            adapter: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                configuration: z.ZodJSONSchema;
+            }, z.core.$strict>;
+            execution: z.ZodObject<{
+                isolation: z.ZodString;
+                environmentAllowlist: z.ZodArray<z.ZodString>;
+                budgets: z.ZodJSONSchema;
+                candidateRoots: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                provenance: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        policy: z.ZodUnion<readonly [z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>, z.ZodObject<{
+            policyVersion: z.ZodLiteral<"invalid">;
+            requiredAttempts: z.ZodLiteral<1>;
+            minimumTargetWeightPermille: z.ZodLiteral<1000>;
+            maximumSelectedCandidates: z.ZodLiteral<0>;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>]>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            digest: z.ZodString;
+            sizeBytes: z.ZodInt;
+            status: z.ZodEnum<{
+                ELIGIBLE: "ELIGIBLE";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                INVALID: "INVALID";
+                UNSTABLE: "UNSTABLE";
+                WEAK_ORACLE: "WEAK_ORACLE";
+            }>;
+            killedTargetIds: z.ZodArray<z.ZodString>;
+            targetWeightKilled: z.ZodInt;
+            gates: z.ZodArray<z.ZodObject<{
+                name: z.ZodEnum<{
+                    COMPLETENESS: "COMPLETENESS";
+                    DISCOVERY: "DISCOVERY";
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    STABILITY: "STABILITY";
+                    TARGET_STRENGTH: "TARGET_STRENGTH";
+                }>;
+                status: z.ZodEnum<{
+                    FAILED: "FAILED";
+                    NOT_RUN: "NOT_RUN";
+                    PASSED: "PASSED";
+                }>;
+                evidenceRunIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        observations: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            candidateId: z.ZodNullable<z.ZodString>;
+            worldId: z.ZodString;
+            attempt: z.ZodInt;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PASS: "PASS";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            testsDiscovered: z.ZodInt;
+            candidateTestsDiscovered: z.ZodInt;
+            attributed: z.ZodBoolean;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            stdoutDigest: z.ZodOptional<z.ZodString>;
+            stderrDigest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        decision: z.ZodObject<{
+            status: z.ZodEnum<{
+                ENGINE_ERROR: "ENGINE_ERROR";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                REJECTED: "REJECTED";
+                VERIFIED: "VERIFIED";
+            }>;
+            selectedCandidateIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        decisionDigest: z.ZodString;
+        artifactDigest: z.ZodString;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            level: z.ZodLiteral<"UNSANDBOXED">;
+            acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    sourceArtifactDigest: z.ZodString;
+    sourceDecisionDigest: z.ZodString;
+    referenceWorldId: z.ZodString;
+    policy: z.ZodObject<{
+        benchmarkVersion: z.ZodLiteral<"1.0.0">;
+        minimumMeasuredSamplesPerRegime: z.ZodInt;
+        coldMeasuredSamples: z.ZodInt;
+        warmupSamples: z.ZodInt;
+        warmMeasuredSamples: z.ZodInt;
+        maximumExecutions: z.ZodInt;
+    }, z.core.$strict>;
+    protocol: z.ZodObject<{
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+        clock: z.ZodLiteral<"MONOTONIC">;
+        unit: z.ZodLiteral<"MICROSECOND">;
+        quantile: z.ZodLiteral<"NEAREST_RANK">;
+        phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+        coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+        warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+    }, z.core.$strict>;
+    fingerprint: z.ZodObject<{
+        environmentId: z.ZodString;
+        os: z.ZodObject<{
+            platform: z.ZodString;
+            release: z.ZodString;
+            arch: z.ZodString;
+        }, z.core.$strict>;
+        cpu: z.ZodObject<{
+            arch: z.ZodString;
+            model: z.ZodString;
+            logicalCores: z.ZodInt;
+        }, z.core.$strict>;
+        logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+        memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+        executionBoundary: z.ZodLiteral<"UNSANDBOXED">;
+        tools: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+            digest: z.ZodString;
+            configurationDigest: z.ZodString;
+        }, z.core.$strict>>;
+        dependencyGraphDigest: z.ZodString;
+        phaseReporterDigest: z.ZodString;
+    }, z.core.$strict>;
+    policyDigest: z.ZodString;
+    protocolDigest: z.ZodString;
+    fingerprintDigest: z.ZodString;
+    comparisonScopeDigest: z.ZodString;
+    runs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        candidateId: z.ZodString;
+        candidateDigest: z.ZodString;
+        regime: z.ZodEnum<{
+            COLD: "COLD";
+            WARM: "WARM";
+        }>;
+        role: z.ZodEnum<{
+            MEASUREMENT: "MEASUREMENT";
+            WARMUP: "WARMUP";
+        }>;
+        ordinal: z.ZodInt;
+        status: z.ZodLiteral<"COMPLETE">;
+        outcome: z.ZodLiteral<"PASS">;
+        phases: z.ZodArray<z.ZodObject<{
+            phase: z.ZodEnum<{
+                COMPILE_OR_COLLECTION: "COMPILE_OR_COLLECTION";
+                EXECUTION: "EXECUTION";
+                PREPARATION: "PREPARATION";
+                STARTUP: "STARTUP";
+            }>;
+            durationUs: z.ZodInt;
+        }, z.core.$strict>>;
+        totalUs: z.ZodInt;
+        cpuTimeUs: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        candidateId: z.ZodString;
+        candidateDigest: z.ZodString;
+        regime: z.ZodEnum<{
+            COLD: "COLD";
+            WARM: "WARM";
+        }>;
+        role: z.ZodEnum<{
+            MEASUREMENT: "MEASUREMENT";
+            WARMUP: "WARMUP";
+        }>;
+        ordinal: z.ZodInt;
+        status: z.ZodLiteral<"INCOMPLETE">;
+        outcome: z.ZodEnum<{
+            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+            COMPILE_FAILURE: "COMPILE_FAILURE";
+            INFRA_ERROR: "INFRA_ERROR";
+            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+            PROCESS_CRASH: "PROCESS_CRASH";
+            TIMEOUT: "TIMEOUT";
+        }>;
+        phases: z.ZodNull;
+        totalUs: z.ZodNull;
+        cpuTimeUs: z.ZodNull;
+    }, z.core.$strict>], "status">>;
+    summaries: z.ZodArray<z.ZodObject<{
+        candidateId: z.ZodString;
+        candidateDigest: z.ZodString;
+        regime: z.ZodEnum<{
+            COLD: "COLD";
+            WARM: "WARM";
+        }>;
+        status: z.ZodEnum<{
+            INSUFFICIENT_SAMPLES: "INSUFFICIENT_SAMPLES";
+            MEASURED: "MEASURED";
+            OBSERVED_RUN_FAILURE: "OBSERVED_RUN_FAILURE";
+        }>;
+        counters: z.ZodObject<{
+            planned: z.ZodInt;
+            recorded: z.ZodInt;
+            accepted: z.ZodInt;
+            failed: z.ZodInt;
+            warmup: z.ZodInt;
+        }, z.core.$strict>;
+        wall: z.ZodObject<{
+            total: z.ZodNullable<z.ZodObject<{
+                minimumUs: z.ZodInt;
+                p50Us: z.ZodInt;
+                p95Us: z.ZodInt;
+                maximumUs: z.ZodInt;
+            }, z.core.$strict>>;
+            phases: z.ZodObject<{
+                PREPARATION: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+                STARTUP: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+                COMPILE_OR_COLLECTION: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+                EXECUTION: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        cpu: z.ZodObject<{
+            availability: z.ZodEnum<{
+                COMPLETE: "COMPLETE";
+                PARTIAL: "PARTIAL";
+                UNAVAILABLE: "UNAVAILABLE";
+            }>;
+            quantiles: z.ZodNullable<z.ZodObject<{
+                minimumUs: z.ZodInt;
+                p50Us: z.ZodInt;
+                p95Us: z.ZodInt;
+                maximumUs: z.ZodInt;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    limitations: z.ZodArray<z.ZodString>;
+    artifactDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    sourceManifestValid: z.ZodBoolean;
+    sourceBindingValid: z.ZodBoolean;
+    policyDigestValid: z.ZodBoolean;
+    protocolDigestValid: z.ZodBoolean;
+    fingerprintDigestValid: z.ZodBoolean;
+    comparisonScopeDigestValid: z.ZodBoolean;
+    artifactDigestValid: z.ZodBoolean;
+    summarySemanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkAcquisitionRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    verificationRequest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repository: z.ZodObject<{
+            root: z.ZodString;
+            exclude: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+            executable: z.ZodString;
+            baseTestFiles: z.ZodArray<z.ZodString>;
+            extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            acknowledgedUnsafeExecution: z.ZodBoolean;
+            environmentAllowlist: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        candidateRoots: z.ZodArray<z.ZodString>;
+        budgets: z.ZodObject<{
+            maximumCandidates: z.ZodInt;
+            maximumWorlds: z.ZodInt;
+            maximumExecutions: z.ZodInt;
+            maximumRepositoryFiles: z.ZodInt;
+            maximumRepositoryBytes: z.ZodInt;
+            maximumWorldOverlayBytes: z.ZodInt;
+            maximumCandidateBytes: z.ZodInt;
+            maximumTotalCandidateBytes: z.ZodInt;
+            timeoutMsPerExecution: z.ZodInt;
+            maximumOutputBytes: z.ZodInt;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+            provenance: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    referenceWorldId: z.ZodString;
+    policy: z.ZodObject<{
+        benchmarkVersion: z.ZodLiteral<"1.0.0">;
+        minimumMeasuredSamplesPerRegime: z.ZodInt;
+        coldMeasuredSamples: z.ZodInt;
+        warmupSamples: z.ZodInt;
+        warmMeasuredSamples: z.ZodInt;
+        maximumExecutions: z.ZodInt;
+    }, z.core.$strict>;
+    protocol: z.ZodObject<{
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+        clock: z.ZodLiteral<"MONOTONIC">;
+        unit: z.ZodLiteral<"MICROSECOND">;
+        quantile: z.ZodLiteral<"NEAREST_RANK">;
+        phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+        coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+        warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+    }, z.core.$strict>;
+    environment: z.ZodObject<{
+        environmentId: z.ZodString;
+        logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+        memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>;
+    identityFiles: z.ZodObject<{
+        phaseReporter: z.ZodString;
+        dependencyGraph: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkAcquisitionResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    requestDigest: z.ZodString;
+    status: z.ZodEnum<{
+        COMPLETE: "COMPLETE";
+        INSUFFICIENT_SAMPLES: "INSUFFICIENT_SAMPLES";
+        OBSERVED_RUN_FAILURE: "OBSERVED_RUN_FAILURE";
+        SOURCE_NOT_VERIFIED: "SOURCE_NOT_VERIFIED";
+    }>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    sourceManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+        evidenceContext: z.ZodObject<{
+            engine: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            adapter: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                configuration: z.ZodJSONSchema;
+            }, z.core.$strict>;
+            execution: z.ZodObject<{
+                isolation: z.ZodString;
+                environmentAllowlist: z.ZodArray<z.ZodString>;
+                budgets: z.ZodJSONSchema;
+                candidateRoots: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                provenance: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        policy: z.ZodUnion<readonly [z.ZodObject<{
+            policyVersion: z.ZodLiteral<"1.0.0">;
+            requiredAttempts: z.ZodInt;
+            minimumTargetWeightPermille: z.ZodInt;
+            maximumSelectedCandidates: z.ZodInt;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>, z.ZodObject<{
+            policyVersion: z.ZodLiteral<"invalid">;
+            requiredAttempts: z.ZodLiteral<1>;
+            minimumTargetWeightPermille: z.ZodLiteral<1000>;
+            maximumSelectedCandidates: z.ZodLiteral<0>;
+            acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+        }, z.core.$strict>]>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            digest: z.ZodString;
+            sizeBytes: z.ZodInt;
+            status: z.ZodEnum<{
+                ELIGIBLE: "ELIGIBLE";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                INVALID: "INVALID";
+                UNSTABLE: "UNSTABLE";
+                WEAK_ORACLE: "WEAK_ORACLE";
+            }>;
+            killedTargetIds: z.ZodArray<z.ZodString>;
+            targetWeightKilled: z.ZodInt;
+            gates: z.ZodArray<z.ZodObject<{
+                name: z.ZodEnum<{
+                    COMPLETENESS: "COMPLETENESS";
+                    DISCOVERY: "DISCOVERY";
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    STABILITY: "STABILITY";
+                    TARGET_STRENGTH: "TARGET_STRENGTH";
+                }>;
+                status: z.ZodEnum<{
+                    FAILED: "FAILED";
+                    NOT_RUN: "NOT_RUN";
+                    PASSED: "PASSED";
+                }>;
+                evidenceRunIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        observations: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            candidateId: z.ZodNullable<z.ZodString>;
+            worldId: z.ZodString;
+            attempt: z.ZodInt;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PASS: "PASS";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            testsDiscovered: z.ZodInt;
+            candidateTestsDiscovered: z.ZodInt;
+            attributed: z.ZodBoolean;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            stdoutDigest: z.ZodOptional<z.ZodString>;
+            stderrDigest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        decision: z.ZodObject<{
+            status: z.ZodEnum<{
+                ENGINE_ERROR: "ENGINE_ERROR";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                REJECTED: "REJECTED";
+                VERIFIED: "VERIFIED";
+            }>;
+            selectedCandidateIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        decisionDigest: z.ZodString;
+        artifactDigest: z.ZodString;
+        adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"node-test">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"testforge-command">;
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+        }, z.core.$strict>], "kind">;
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            level: z.ZodLiteral<"UNSANDBOXED">;
+            acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    benchmarkArtifact: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        sourceManifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0.0">;
+            repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+            evidenceContext: z.ZodObject<{
+                engine: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>;
+                adapter: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                    configuration: z.ZodJSONSchema;
+                }, z.core.$strict>;
+                execution: z.ZodObject<{
+                    isolation: z.ZodString;
+                    environmentAllowlist: z.ZodArray<z.ZodString>;
+                    budgets: z.ZodJSONSchema;
+                    candidateRoots: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                worlds: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    provenance: z.ZodString;
+                    digest: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            policy: z.ZodUnion<readonly [z.ZodObject<{
+                policyVersion: z.ZodLiteral<"1.0.0">;
+                requiredAttempts: z.ZodInt;
+                minimumTargetWeightPermille: z.ZodInt;
+                maximumSelectedCandidates: z.ZodInt;
+                acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+            }, z.core.$strict>, z.ZodObject<{
+                policyVersion: z.ZodLiteral<"invalid">;
+                requiredAttempts: z.ZodLiteral<1>;
+                minimumTargetWeightPermille: z.ZodLiteral<1000>;
+                maximumSelectedCandidates: z.ZodLiteral<0>;
+                acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+            }, z.core.$strict>]>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    TARGET: "TARGET";
+                }>;
+                required: z.ZodBoolean;
+                weight: z.ZodInt;
+            }, z.core.$strict>>;
+            candidates: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                digest: z.ZodString;
+                sizeBytes: z.ZodInt;
+                status: z.ZodEnum<{
+                    ELIGIBLE: "ELIGIBLE";
+                    INCONCLUSIVE: "INCONCLUSIVE";
+                    INVALID: "INVALID";
+                    UNSTABLE: "UNSTABLE";
+                    WEAK_ORACLE: "WEAK_ORACLE";
+                }>;
+                killedTargetIds: z.ZodArray<z.ZodString>;
+                targetWeightKilled: z.ZodInt;
+                gates: z.ZodArray<z.ZodObject<{
+                    name: z.ZodEnum<{
+                        COMPLETENESS: "COMPLETENESS";
+                        DISCOVERY: "DISCOVERY";
+                        NEUTRAL: "NEUTRAL";
+                        REFERENCE: "REFERENCE";
+                        STABILITY: "STABILITY";
+                        TARGET_STRENGTH: "TARGET_STRENGTH";
+                    }>;
+                    status: z.ZodEnum<{
+                        FAILED: "FAILED";
+                        NOT_RUN: "NOT_RUN";
+                        PASSED: "PASSED";
+                    }>;
+                    evidenceRunIds: z.ZodArray<z.ZodString>;
+                    reasonCodes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            observations: z.ZodArray<z.ZodObject<{
+                runId: z.ZodString;
+                candidateId: z.ZodNullable<z.ZodString>;
+                worldId: z.ZodString;
+                attempt: z.ZodInt;
+                outcome: z.ZodEnum<{
+                    ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                    COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                    COMPILE_FAILURE: "COMPILE_FAILURE";
+                    INFRA_ERROR: "INFRA_ERROR";
+                    NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                    PASS: "PASS";
+                    PROCESS_CRASH: "PROCESS_CRASH";
+                    TIMEOUT: "TIMEOUT";
+                }>;
+                testsDiscovered: z.ZodInt;
+                candidateTestsDiscovered: z.ZodInt;
+                attributed: z.ZodBoolean;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                stdoutDigest: z.ZodOptional<z.ZodString>;
+                stderrDigest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            decision: z.ZodObject<{
+                status: z.ZodEnum<{
+                    ENGINE_ERROR: "ENGINE_ERROR";
+                    INCONCLUSIVE: "INCONCLUSIVE";
+                    REJECTED: "REJECTED";
+                    VERIFIED: "VERIFIED";
+                }>;
+                selectedCandidateIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            decisionDigest: z.ZodString;
+            artifactDigest: z.ZodString;
+            adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"node-test">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"testforge-command">;
+                protocolVersion: z.ZodLiteral<"1.0.0">;
+            }, z.core.$strict>], "kind">;
+            isolation: z.ZodObject<{
+                kind: z.ZodLiteral<"trusted-local">;
+                level: z.ZodLiteral<"UNSANDBOXED">;
+                acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+            limitations: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        sourceArtifactDigest: z.ZodString;
+        sourceDecisionDigest: z.ZodString;
+        referenceWorldId: z.ZodString;
+        policy: z.ZodObject<{
+            benchmarkVersion: z.ZodLiteral<"1.0.0">;
+            minimumMeasuredSamplesPerRegime: z.ZodInt;
+            coldMeasuredSamples: z.ZodInt;
+            warmupSamples: z.ZodInt;
+            warmMeasuredSamples: z.ZodInt;
+            maximumExecutions: z.ZodInt;
+        }, z.core.$strict>;
+        protocol: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+            clock: z.ZodLiteral<"MONOTONIC">;
+            unit: z.ZodLiteral<"MICROSECOND">;
+            quantile: z.ZodLiteral<"NEAREST_RANK">;
+            phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+            coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+            warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+        }, z.core.$strict>;
+        fingerprint: z.ZodObject<{
+            environmentId: z.ZodString;
+            os: z.ZodObject<{
+                platform: z.ZodString;
+                release: z.ZodString;
+                arch: z.ZodString;
+            }, z.core.$strict>;
+            cpu: z.ZodObject<{
+                arch: z.ZodString;
+                model: z.ZodString;
+                logicalCores: z.ZodInt;
+            }, z.core.$strict>;
+            logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+            memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+            executionBoundary: z.ZodLiteral<"UNSANDBOXED">;
+            tools: z.ZodArray<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+                digest: z.ZodString;
+                configurationDigest: z.ZodString;
+            }, z.core.$strict>>;
+            dependencyGraphDigest: z.ZodString;
+            phaseReporterDigest: z.ZodString;
+        }, z.core.$strict>;
+        policyDigest: z.ZodString;
+        protocolDigest: z.ZodString;
+        fingerprintDigest: z.ZodString;
+        comparisonScopeDigest: z.ZodString;
+        runs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            role: z.ZodEnum<{
+                MEASUREMENT: "MEASUREMENT";
+                WARMUP: "WARMUP";
+            }>;
+            ordinal: z.ZodInt;
+            status: z.ZodLiteral<"COMPLETE">;
+            outcome: z.ZodLiteral<"PASS">;
+            phases: z.ZodArray<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    COMPILE_OR_COLLECTION: "COMPILE_OR_COLLECTION";
+                    EXECUTION: "EXECUTION";
+                    PREPARATION: "PREPARATION";
+                    STARTUP: "STARTUP";
+                }>;
+                durationUs: z.ZodInt;
+            }, z.core.$strict>>;
+            totalUs: z.ZodInt;
+            cpuTimeUs: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            role: z.ZodEnum<{
+                MEASUREMENT: "MEASUREMENT";
+                WARMUP: "WARMUP";
+            }>;
+            ordinal: z.ZodInt;
+            status: z.ZodLiteral<"INCOMPLETE">;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            phases: z.ZodNull;
+            totalUs: z.ZodNull;
+            cpuTimeUs: z.ZodNull;
+        }, z.core.$strict>], "status">>;
+        summaries: z.ZodArray<z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            status: z.ZodEnum<{
+                INSUFFICIENT_SAMPLES: "INSUFFICIENT_SAMPLES";
+                MEASURED: "MEASURED";
+                OBSERVED_RUN_FAILURE: "OBSERVED_RUN_FAILURE";
+            }>;
+            counters: z.ZodObject<{
+                planned: z.ZodInt;
+                recorded: z.ZodInt;
+                accepted: z.ZodInt;
+                failed: z.ZodInt;
+                warmup: z.ZodInt;
+            }, z.core.$strict>;
+            wall: z.ZodObject<{
+                total: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+                phases: z.ZodObject<{
+                    PREPARATION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    STARTUP: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    COMPILE_OR_COLLECTION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    EXECUTION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            cpu: z.ZodObject<{
+                availability: z.ZodEnum<{
+                    COMPLETE: "COMPLETE";
+                    PARTIAL: "PARTIAL";
+                    UNAVAILABLE: "UNAVAILABLE";
+                }>;
+                quantiles: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        limitations: z.ZodArray<z.ZodString>;
+        artifactDigest: z.ZodString;
+    }, z.core.$strict>>;
+    acquisitionContext: z.ZodObject<{
+        snapshotRepositoryDigest: z.ZodString;
+        referenceWorldId: z.ZodString;
+        candidateIds: z.ZodArray<z.ZodString>;
+        adapter: z.ZodObject<{
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+            executableDigest: z.ZodString;
+            identityFilePath: z.ZodString;
+            identityDigest: z.ZodString;
+        }, z.core.$strict>;
+        dependencyFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        dependencyGraphDigest: z.ZodString;
+        cachePolicy: z.ZodObject<{
+            cold: z.ZodLiteral<"UNIQUE_EMPTY_DIRECTORY_PER_RUN">;
+            warm: z.ZodLiteral<"ONE_INITIALLY_EMPTY_DIRECTORY_PER_CANDIDATE">;
+            sharedAcrossCandidates: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+    resultDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticBenchmarkAcquisitionReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    sourceManifestValid: z.ZodBoolean;
+    sourceBindingValid: z.ZodBoolean;
+    artifactReplayValid: z.ZodBoolean;
+    contextBindingValid: z.ZodBoolean;
+    resultDigestValid: z.ZodBoolean;
+    statusSemanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticProfileLaneV2Schema: z.ZodObject<{
+    id: z.ZodString;
+    maximumWarmTotalWallP95Us: z.ZodInt;
+}, z.core.$strict>;
+export declare const AgenticProfileCostBasisV2Schema: z.ZodObject<{
+    regime: z.ZodLiteral<"WARM">;
+    measure: z.ZodLiteral<"WALL">;
+    aggregation: z.ZodLiteral<"TOTAL">;
+    statistic: z.ZodLiteral<"P95">;
+    unit: z.ZodLiteral<"MICROSECOND">;
+    portfolioAggregation: z.ZodLiteral<"SUM_OF_INDIVIDUAL_P95">;
+}, z.core.$strict>;
+export declare const AgenticProfilePolicyV2Schema: z.ZodObject<{
+    profileVersion: z.ZodLiteral<"2.0.0">;
+    profileId: z.ZodString;
+    mode: z.ZodLiteral<"HARDENING">;
+    requiredComparisonScopeDigest: z.ZodString;
+    costBasis: z.ZodObject<{
+        regime: z.ZodLiteral<"WARM">;
+        measure: z.ZodLiteral<"WALL">;
+        aggregation: z.ZodLiteral<"TOTAL">;
+        statistic: z.ZodLiteral<"P95">;
+        unit: z.ZodLiteral<"MICROSECOND">;
+        portfolioAggregation: z.ZodLiteral<"SUM_OF_INDIVIDUAL_P95">;
+    }, z.core.$strict>;
+    lanes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        maximumWarmTotalWallP95Us: z.ZodInt;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const AgenticProfileRequestV2Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    benchmarkArtifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        sourceManifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0.0">;
+            repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+            evidenceContext: z.ZodObject<{
+                engine: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>;
+                adapter: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                    configuration: z.ZodJSONSchema;
+                }, z.core.$strict>;
+                execution: z.ZodObject<{
+                    isolation: z.ZodString;
+                    environmentAllowlist: z.ZodArray<z.ZodString>;
+                    budgets: z.ZodJSONSchema;
+                    candidateRoots: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                worlds: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    provenance: z.ZodString;
+                    digest: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            policy: z.ZodUnion<readonly [z.ZodObject<{
+                policyVersion: z.ZodLiteral<"1.0.0">;
+                requiredAttempts: z.ZodInt;
+                minimumTargetWeightPermille: z.ZodInt;
+                maximumSelectedCandidates: z.ZodInt;
+                acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+            }, z.core.$strict>, z.ZodObject<{
+                policyVersion: z.ZodLiteral<"invalid">;
+                requiredAttempts: z.ZodLiteral<1>;
+                minimumTargetWeightPermille: z.ZodLiteral<1000>;
+                maximumSelectedCandidates: z.ZodLiteral<0>;
+                acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+            }, z.core.$strict>]>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    TARGET: "TARGET";
+                }>;
+                required: z.ZodBoolean;
+                weight: z.ZodInt;
+            }, z.core.$strict>>;
+            candidates: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                digest: z.ZodString;
+                sizeBytes: z.ZodInt;
+                status: z.ZodEnum<{
+                    ELIGIBLE: "ELIGIBLE";
+                    INCONCLUSIVE: "INCONCLUSIVE";
+                    INVALID: "INVALID";
+                    UNSTABLE: "UNSTABLE";
+                    WEAK_ORACLE: "WEAK_ORACLE";
+                }>;
+                killedTargetIds: z.ZodArray<z.ZodString>;
+                targetWeightKilled: z.ZodInt;
+                gates: z.ZodArray<z.ZodObject<{
+                    name: z.ZodEnum<{
+                        COMPLETENESS: "COMPLETENESS";
+                        DISCOVERY: "DISCOVERY";
+                        NEUTRAL: "NEUTRAL";
+                        REFERENCE: "REFERENCE";
+                        STABILITY: "STABILITY";
+                        TARGET_STRENGTH: "TARGET_STRENGTH";
+                    }>;
+                    status: z.ZodEnum<{
+                        FAILED: "FAILED";
+                        NOT_RUN: "NOT_RUN";
+                        PASSED: "PASSED";
+                    }>;
+                    evidenceRunIds: z.ZodArray<z.ZodString>;
+                    reasonCodes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            observations: z.ZodArray<z.ZodObject<{
+                runId: z.ZodString;
+                candidateId: z.ZodNullable<z.ZodString>;
+                worldId: z.ZodString;
+                attempt: z.ZodInt;
+                outcome: z.ZodEnum<{
+                    ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                    COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                    COMPILE_FAILURE: "COMPILE_FAILURE";
+                    INFRA_ERROR: "INFRA_ERROR";
+                    NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                    PASS: "PASS";
+                    PROCESS_CRASH: "PROCESS_CRASH";
+                    TIMEOUT: "TIMEOUT";
+                }>;
+                testsDiscovered: z.ZodInt;
+                candidateTestsDiscovered: z.ZodInt;
+                attributed: z.ZodBoolean;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                stdoutDigest: z.ZodOptional<z.ZodString>;
+                stderrDigest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            decision: z.ZodObject<{
+                status: z.ZodEnum<{
+                    ENGINE_ERROR: "ENGINE_ERROR";
+                    INCONCLUSIVE: "INCONCLUSIVE";
+                    REJECTED: "REJECTED";
+                    VERIFIED: "VERIFIED";
+                }>;
+                selectedCandidateIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            decisionDigest: z.ZodString;
+            artifactDigest: z.ZodString;
+            adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"node-test">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"testforge-command">;
+                protocolVersion: z.ZodLiteral<"1.0.0">;
+            }, z.core.$strict>], "kind">;
+            isolation: z.ZodObject<{
+                kind: z.ZodLiteral<"trusted-local">;
+                level: z.ZodLiteral<"UNSANDBOXED">;
+                acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+            limitations: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        sourceArtifactDigest: z.ZodString;
+        sourceDecisionDigest: z.ZodString;
+        referenceWorldId: z.ZodString;
+        policy: z.ZodObject<{
+            benchmarkVersion: z.ZodLiteral<"1.0.0">;
+            minimumMeasuredSamplesPerRegime: z.ZodInt;
+            coldMeasuredSamples: z.ZodInt;
+            warmupSamples: z.ZodInt;
+            warmMeasuredSamples: z.ZodInt;
+            maximumExecutions: z.ZodInt;
+        }, z.core.$strict>;
+        protocol: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+            clock: z.ZodLiteral<"MONOTONIC">;
+            unit: z.ZodLiteral<"MICROSECOND">;
+            quantile: z.ZodLiteral<"NEAREST_RANK">;
+            phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+            coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+            warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+        }, z.core.$strict>;
+        fingerprint: z.ZodObject<{
+            environmentId: z.ZodString;
+            os: z.ZodObject<{
+                platform: z.ZodString;
+                release: z.ZodString;
+                arch: z.ZodString;
+            }, z.core.$strict>;
+            cpu: z.ZodObject<{
+                arch: z.ZodString;
+                model: z.ZodString;
+                logicalCores: z.ZodInt;
+            }, z.core.$strict>;
+            logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+            memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+            executionBoundary: z.ZodLiteral<"UNSANDBOXED">;
+            tools: z.ZodArray<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+                digest: z.ZodString;
+                configurationDigest: z.ZodString;
+            }, z.core.$strict>>;
+            dependencyGraphDigest: z.ZodString;
+            phaseReporterDigest: z.ZodString;
+        }, z.core.$strict>;
+        policyDigest: z.ZodString;
+        protocolDigest: z.ZodString;
+        fingerprintDigest: z.ZodString;
+        comparisonScopeDigest: z.ZodString;
+        runs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            role: z.ZodEnum<{
+                MEASUREMENT: "MEASUREMENT";
+                WARMUP: "WARMUP";
+            }>;
+            ordinal: z.ZodInt;
+            status: z.ZodLiteral<"COMPLETE">;
+            outcome: z.ZodLiteral<"PASS">;
+            phases: z.ZodArray<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    COMPILE_OR_COLLECTION: "COMPILE_OR_COLLECTION";
+                    EXECUTION: "EXECUTION";
+                    PREPARATION: "PREPARATION";
+                    STARTUP: "STARTUP";
+                }>;
+                durationUs: z.ZodInt;
+            }, z.core.$strict>>;
+            totalUs: z.ZodInt;
+            cpuTimeUs: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            role: z.ZodEnum<{
+                MEASUREMENT: "MEASUREMENT";
+                WARMUP: "WARMUP";
+            }>;
+            ordinal: z.ZodInt;
+            status: z.ZodLiteral<"INCOMPLETE">;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            phases: z.ZodNull;
+            totalUs: z.ZodNull;
+            cpuTimeUs: z.ZodNull;
+        }, z.core.$strict>], "status">>;
+        summaries: z.ZodArray<z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            status: z.ZodEnum<{
+                INSUFFICIENT_SAMPLES: "INSUFFICIENT_SAMPLES";
+                MEASURED: "MEASURED";
+                OBSERVED_RUN_FAILURE: "OBSERVED_RUN_FAILURE";
+            }>;
+            counters: z.ZodObject<{
+                planned: z.ZodInt;
+                recorded: z.ZodInt;
+                accepted: z.ZodInt;
+                failed: z.ZodInt;
+                warmup: z.ZodInt;
+            }, z.core.$strict>;
+            wall: z.ZodObject<{
+                total: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+                phases: z.ZodObject<{
+                    PREPARATION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    STARTUP: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    COMPILE_OR_COLLECTION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    EXECUTION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            cpu: z.ZodObject<{
+                availability: z.ZodEnum<{
+                    COMPLETE: "COMPLETE";
+                    PARTIAL: "PARTIAL";
+                    UNAVAILABLE: "UNAVAILABLE";
+                }>;
+                quantiles: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        limitations: z.ZodArray<z.ZodString>;
+        artifactDigest: z.ZodString;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        profileVersion: z.ZodLiteral<"2.0.0">;
+        profileId: z.ZodString;
+        mode: z.ZodLiteral<"HARDENING">;
+        requiredComparisonScopeDigest: z.ZodString;
+        costBasis: z.ZodObject<{
+            regime: z.ZodLiteral<"WARM">;
+            measure: z.ZodLiteral<"WALL">;
+            aggregation: z.ZodLiteral<"TOTAL">;
+            statistic: z.ZodLiteral<"P95">;
+            unit: z.ZodLiteral<"MICROSECOND">;
+            portfolioAggregation: z.ZodLiteral<"SUM_OF_INDIVIDUAL_P95">;
+        }, z.core.$strict>;
+        lanes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            maximumWarmTotalWallP95Us: z.ZodInt;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AgenticProfileReportV2Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    benchmarkArtifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        sourceManifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0.0">;
+            repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+            evidenceContext: z.ZodObject<{
+                engine: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>;
+                adapter: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                    configuration: z.ZodJSONSchema;
+                }, z.core.$strict>;
+                execution: z.ZodObject<{
+                    isolation: z.ZodString;
+                    environmentAllowlist: z.ZodArray<z.ZodString>;
+                    budgets: z.ZodJSONSchema;
+                    candidateRoots: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                worlds: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    provenance: z.ZodString;
+                    digest: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            policy: z.ZodUnion<readonly [z.ZodObject<{
+                policyVersion: z.ZodLiteral<"1.0.0">;
+                requiredAttempts: z.ZodInt;
+                minimumTargetWeightPermille: z.ZodInt;
+                maximumSelectedCandidates: z.ZodInt;
+                acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+            }, z.core.$strict>, z.ZodObject<{
+                policyVersion: z.ZodLiteral<"invalid">;
+                requiredAttempts: z.ZodLiteral<1>;
+                minimumTargetWeightPermille: z.ZodLiteral<1000>;
+                maximumSelectedCandidates: z.ZodLiteral<0>;
+                acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+            }, z.core.$strict>]>;
+            worlds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    TARGET: "TARGET";
+                }>;
+                required: z.ZodBoolean;
+                weight: z.ZodInt;
+            }, z.core.$strict>>;
+            candidates: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                digest: z.ZodString;
+                sizeBytes: z.ZodInt;
+                status: z.ZodEnum<{
+                    ELIGIBLE: "ELIGIBLE";
+                    INCONCLUSIVE: "INCONCLUSIVE";
+                    INVALID: "INVALID";
+                    UNSTABLE: "UNSTABLE";
+                    WEAK_ORACLE: "WEAK_ORACLE";
+                }>;
+                killedTargetIds: z.ZodArray<z.ZodString>;
+                targetWeightKilled: z.ZodInt;
+                gates: z.ZodArray<z.ZodObject<{
+                    name: z.ZodEnum<{
+                        COMPLETENESS: "COMPLETENESS";
+                        DISCOVERY: "DISCOVERY";
+                        NEUTRAL: "NEUTRAL";
+                        REFERENCE: "REFERENCE";
+                        STABILITY: "STABILITY";
+                        TARGET_STRENGTH: "TARGET_STRENGTH";
+                    }>;
+                    status: z.ZodEnum<{
+                        FAILED: "FAILED";
+                        NOT_RUN: "NOT_RUN";
+                        PASSED: "PASSED";
+                    }>;
+                    evidenceRunIds: z.ZodArray<z.ZodString>;
+                    reasonCodes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            observations: z.ZodArray<z.ZodObject<{
+                runId: z.ZodString;
+                candidateId: z.ZodNullable<z.ZodString>;
+                worldId: z.ZodString;
+                attempt: z.ZodInt;
+                outcome: z.ZodEnum<{
+                    ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                    COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                    COMPILE_FAILURE: "COMPILE_FAILURE";
+                    INFRA_ERROR: "INFRA_ERROR";
+                    NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                    PASS: "PASS";
+                    PROCESS_CRASH: "PROCESS_CRASH";
+                    TIMEOUT: "TIMEOUT";
+                }>;
+                testsDiscovered: z.ZodInt;
+                candidateTestsDiscovered: z.ZodInt;
+                attributed: z.ZodBoolean;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                stdoutDigest: z.ZodOptional<z.ZodString>;
+                stderrDigest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            decision: z.ZodObject<{
+                status: z.ZodEnum<{
+                    ENGINE_ERROR: "ENGINE_ERROR";
+                    INCONCLUSIVE: "INCONCLUSIVE";
+                    REJECTED: "REJECTED";
+                    VERIFIED: "VERIFIED";
+                }>;
+                selectedCandidateIds: z.ZodArray<z.ZodString>;
+                reasonCodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            decisionDigest: z.ZodString;
+            artifactDigest: z.ZodString;
+            adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"node-test">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"testforge-command">;
+                protocolVersion: z.ZodLiteral<"1.0.0">;
+            }, z.core.$strict>], "kind">;
+            isolation: z.ZodObject<{
+                kind: z.ZodLiteral<"trusted-local">;
+                level: z.ZodLiteral<"UNSANDBOXED">;
+                acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+            limitations: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        sourceArtifactDigest: z.ZodString;
+        sourceDecisionDigest: z.ZodString;
+        referenceWorldId: z.ZodString;
+        policy: z.ZodObject<{
+            benchmarkVersion: z.ZodLiteral<"1.0.0">;
+            minimumMeasuredSamplesPerRegime: z.ZodInt;
+            coldMeasuredSamples: z.ZodInt;
+            warmupSamples: z.ZodInt;
+            warmMeasuredSamples: z.ZodInt;
+            maximumExecutions: z.ZodInt;
+        }, z.core.$strict>;
+        protocol: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<"1.0.0">;
+            clock: z.ZodLiteral<"MONOTONIC">;
+            unit: z.ZodLiteral<"MICROSECOND">;
+            quantile: z.ZodLiteral<"NEAREST_RANK">;
+            phases: z.ZodTuple<[z.ZodLiteral<"PREPARATION">, z.ZodLiteral<"STARTUP">, z.ZodLiteral<"COMPILE_OR_COLLECTION">, z.ZodLiteral<"EXECUTION">], null>;
+            coldDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RESET_DECLARED_CACHES">;
+            warmDefinition: z.ZodLiteral<"FRESH_WORKSPACE_FRESH_PROCESS_RETAIN_DECLARED_CACHES">;
+        }, z.core.$strict>;
+        fingerprint: z.ZodObject<{
+            environmentId: z.ZodString;
+            os: z.ZodObject<{
+                platform: z.ZodString;
+                release: z.ZodString;
+                arch: z.ZodString;
+            }, z.core.$strict>;
+            cpu: z.ZodObject<{
+                arch: z.ZodString;
+                model: z.ZodString;
+                logicalCores: z.ZodInt;
+            }, z.core.$strict>;
+            logicalCpuLimit: z.ZodNullable<z.ZodInt>;
+            memoryLimitBytes: z.ZodNullable<z.ZodInt>;
+            executionBoundary: z.ZodLiteral<"UNSANDBOXED">;
+            tools: z.ZodArray<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+                digest: z.ZodString;
+                configurationDigest: z.ZodString;
+            }, z.core.$strict>>;
+            dependencyGraphDigest: z.ZodString;
+            phaseReporterDigest: z.ZodString;
+        }, z.core.$strict>;
+        policyDigest: z.ZodString;
+        protocolDigest: z.ZodString;
+        fingerprintDigest: z.ZodString;
+        comparisonScopeDigest: z.ZodString;
+        runs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            role: z.ZodEnum<{
+                MEASUREMENT: "MEASUREMENT";
+                WARMUP: "WARMUP";
+            }>;
+            ordinal: z.ZodInt;
+            status: z.ZodLiteral<"COMPLETE">;
+            outcome: z.ZodLiteral<"PASS">;
+            phases: z.ZodArray<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    COMPILE_OR_COLLECTION: "COMPILE_OR_COLLECTION";
+                    EXECUTION: "EXECUTION";
+                    PREPARATION: "PREPARATION";
+                    STARTUP: "STARTUP";
+                }>;
+                durationUs: z.ZodInt;
+            }, z.core.$strict>>;
+            totalUs: z.ZodInt;
+            cpuTimeUs: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            role: z.ZodEnum<{
+                MEASUREMENT: "MEASUREMENT";
+                WARMUP: "WARMUP";
+            }>;
+            ordinal: z.ZodInt;
+            status: z.ZodLiteral<"INCOMPLETE">;
+            outcome: z.ZodEnum<{
+                ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                COMPILE_FAILURE: "COMPILE_FAILURE";
+                INFRA_ERROR: "INFRA_ERROR";
+                NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                PROCESS_CRASH: "PROCESS_CRASH";
+                TIMEOUT: "TIMEOUT";
+            }>;
+            phases: z.ZodNull;
+            totalUs: z.ZodNull;
+            cpuTimeUs: z.ZodNull;
+        }, z.core.$strict>], "status">>;
+        summaries: z.ZodArray<z.ZodObject<{
+            candidateId: z.ZodString;
+            candidateDigest: z.ZodString;
+            regime: z.ZodEnum<{
+                COLD: "COLD";
+                WARM: "WARM";
+            }>;
+            status: z.ZodEnum<{
+                INSUFFICIENT_SAMPLES: "INSUFFICIENT_SAMPLES";
+                MEASURED: "MEASURED";
+                OBSERVED_RUN_FAILURE: "OBSERVED_RUN_FAILURE";
+            }>;
+            counters: z.ZodObject<{
+                planned: z.ZodInt;
+                recorded: z.ZodInt;
+                accepted: z.ZodInt;
+                failed: z.ZodInt;
+                warmup: z.ZodInt;
+            }, z.core.$strict>;
+            wall: z.ZodObject<{
+                total: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+                phases: z.ZodObject<{
+                    PREPARATION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    STARTUP: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    COMPILE_OR_COLLECTION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                    EXECUTION: z.ZodNullable<z.ZodObject<{
+                        minimumUs: z.ZodInt;
+                        p50Us: z.ZodInt;
+                        p95Us: z.ZodInt;
+                        maximumUs: z.ZodInt;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            cpu: z.ZodObject<{
+                availability: z.ZodEnum<{
+                    COMPLETE: "COMPLETE";
+                    PARTIAL: "PARTIAL";
+                    UNAVAILABLE: "UNAVAILABLE";
+                }>;
+                quantiles: z.ZodNullable<z.ZodObject<{
+                    minimumUs: z.ZodInt;
+                    p50Us: z.ZodInt;
+                    p95Us: z.ZodInt;
+                    maximumUs: z.ZodInt;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        limitations: z.ZodArray<z.ZodString>;
+        artifactDigest: z.ZodString;
+    }, z.core.$strict>;
+    sourceBenchmarkArtifactDigest: z.ZodString;
+    comparisonScopeDigest: z.ZodString;
+    policy: z.ZodObject<{
+        profileVersion: z.ZodLiteral<"2.0.0">;
+        profileId: z.ZodString;
+        mode: z.ZodLiteral<"HARDENING">;
+        requiredComparisonScopeDigest: z.ZodString;
+        costBasis: z.ZodObject<{
+            regime: z.ZodLiteral<"WARM">;
+            measure: z.ZodLiteral<"WALL">;
+            aggregation: z.ZodLiteral<"TOTAL">;
+            statistic: z.ZodLiteral<"P95">;
+            unit: z.ZodLiteral<"MICROSECOND">;
+            portfolioAggregation: z.ZodLiteral<"SUM_OF_INDIVIDUAL_P95">;
+        }, z.core.$strict>;
+        lanes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            maximumWarmTotalWallP95Us: z.ZodInt;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    policyDigest: z.ZodString;
+    status: z.ZodEnum<{
+        BUDGET_MISSED: "BUDGET_MISSED";
+        COMPARISON_SCOPE_MISMATCH: "COMPARISON_SCOPE_MISMATCH";
+        INSUFFICIENT_TIMING_EVIDENCE: "INSUFFICIENT_TIMING_EVIDENCE";
+        OBSERVED_BENCHMARK_FAILURE: "OBSERVED_BENCHMARK_FAILURE";
+        QUALIFIED: "QUALIFIED";
+    }>;
+    candidateUniverse: z.ZodObject<{
+        kind: z.ZodLiteral<"SOURCE_SELECTED_ELIGIBLE">;
+        candidateIds: z.ZodArray<z.ZodString>;
+        excludedEligibleCandidateIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        candidateDigest: z.ZodString;
+        evidenceStatus: z.ZodLiteral<"ELIGIBLE">;
+        classification: z.ZodEnum<{
+            BUDGET_MISSED: "BUDGET_MISSED";
+            COMPARISON_SCOPE_MISMATCH: "COMPARISON_SCOPE_MISMATCH";
+            INSUFFICIENT_TIMING_EVIDENCE: "INSUFFICIENT_TIMING_EVIDENCE";
+            OBSERVED_BENCHMARK_FAILURE: "OBSERVED_BENCHMARK_FAILURE";
+            QUALIFIED: "QUALIFIED";
+        }>;
+        status: z.ZodEnum<{
+            INSUFFICIENT_SAMPLES: "INSUFFICIENT_SAMPLES";
+            MEASURED: "MEASURED";
+            OBSERVED_RUN_FAILURE: "OBSERVED_RUN_FAILURE";
+        }>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+        strength: z.ZodObject<{
+            targetWeightKilled: z.ZodInt;
+            totalTargetWeight: z.ZodInt;
+            targetWeightPermille: z.ZodInt;
+            requiredTargetsKilled: z.ZodInt;
+            requiredTargetsTotal: z.ZodInt;
+            killedTargetIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        consistency: z.ZodObject<{
+            claim: z.ZodEnum<{
+                OBSERVED_CONSISTENT: "OBSERVED_CONSISTENT";
+                OBSERVED_INCONSISTENT: "OBSERVED_INCONSISTENT";
+            }>;
+            attempts: z.ZodInt;
+        }, z.core.$strict>;
+        cost: z.ZodObject<{
+            kind: z.ZodLiteral<"BENCHMARK_WARM_TOTAL_WALL_P95">;
+            acceptedSamples: z.ZodInt;
+            p95Us: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strict>;
+        paretoStatus: z.ZodEnum<{
+            DOMINATED: "DOMINATED";
+            NOT_EVALUATED: "NOT_EVALUATED";
+            ON_FRONTIER: "ON_FRONTIER";
+        }>;
+    }, z.core.$strict>>;
+    portfolios: z.ZodArray<z.ZodObject<{
+        laneId: z.ZodString;
+        maximumWarmTotalWallP95Us: z.ZodInt;
+        costModel: z.ZodLiteral<"SUM_OF_INDIVIDUAL_P95">;
+        selectedCandidateIds: z.ZodArray<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            ordinal: z.ZodInt;
+            candidateId: z.ZodString;
+            marginalTargetIds: z.ZodArray<z.ZodString>;
+            marginalTargetWeight: z.ZodInt;
+            candidateWarmTotalWallP95Us: z.ZodInt;
+            cumulativeCostUs: z.ZodInt;
+            cumulativeTargetWeight: z.ZodInt;
+        }, z.core.$strict>>;
+        sumIndividualWarmTotalWallP95Us: z.ZodInt;
+        targetWeight: z.ZodInt;
+        targetWeightPermille: z.ZodInt;
+        requiredTargetsKilled: z.ZodInt;
+        requiredTargetsTotal: z.ZodInt;
+    }, z.core.$strict>>;
+    limitations: z.ZodArray<z.ZodString>;
+    reportDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticProfileReplayResultV2Schema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    sourceBenchmarkValid: z.ZodBoolean;
+    sourceBindingValid: z.ZodBoolean;
+    policyDigestValid: z.ZodBoolean;
+    reportDigestValid: z.ZodBoolean;
+    semanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticCorpusTrustPolicySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    policyId: z.ZodString;
+    keys: z.ZodArray<z.ZodObject<{
+        keyId: z.ZodString;
+        subjectId: z.ZodString;
+        roles: z.ZodArray<z.ZodEnum<{
+            AUTHOR: "AUTHOR";
+            REVIEWER: "REVIEWER";
+        }>>;
+        publicKey: z.ZodObject<{
+            algorithm: z.ZodLiteral<"Ed25519">;
+            format: z.ZodLiteral<"SPKI_DER_BASE64URL">;
+            data: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+        authorizedAuthorSubjectIds: z.ZodArray<z.ZodString>;
+        authorizedReviewerSubjectIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    policyDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusProvenanceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    domain: z.ZodLiteral<"TESTFORGE_AGENTIC_CORPUS_CASE_V1">;
+    trustPolicyDigest: z.ZodString;
+    caseId: z.ZodString;
+    caseDigest: z.ZodString;
+    source: z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceRevision: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+    }, z.core.$strict>;
+    execution: z.ZodObject<{
+        status: z.ZodLiteral<"EXECUTED">;
+        protocolId: z.ZodString;
+        evidenceDigests: z.ZodArray<z.ZodString>;
+        receiptDigest: z.ZodString;
+    }, z.core.$strict>;
+    author: z.ZodObject<{
+        keyId: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strict>;
+    reviewer: z.ZodObject<{
+        keyId: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strict>;
+    provenanceDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusAllocationRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    allocationId: z.ZodString;
+    seedDigest: z.ZodString;
+    strata: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+        calibrationCount: z.ZodInt;
+        caseIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const AgenticCorpusAllocationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    allocationId: z.ZodString;
+    algorithm: z.ZodLiteral<"SHA256_ASCENDING_SPLIT_V1">;
+    seedDigest: z.ZodString;
+    calibrationCount: z.ZodInt;
+    sourceCaseIds: z.ZodArray<z.ZodString>;
+    strata: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+        calibrationCount: z.ZodInt;
+        sourceCaseIds: z.ZodArray<z.ZodString>;
+        calibrationCaseIds: z.ZodArray<z.ZodString>;
+        holdoutCaseIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    calibrationCaseIds: z.ZodArray<z.ZodString>;
+    holdoutCaseIds: z.ZodArray<z.ZodString>;
+    assignments: z.ZodArray<z.ZodObject<{
+        caseId: z.ZodString;
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+        scoreDigest: z.ZodString;
+        partition: z.ZodEnum<{
+            CALIBRATION: "CALIBRATION";
+            HOLDOUT: "HOLDOUT";
+        }>;
+    }, z.core.$strict>>;
+    allocationDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusAllocationReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    allocationDigestValid: z.ZodBoolean;
+    sourceCaseIdsValid: z.ZodBoolean;
+    assignmentScoresValid: z.ZodBoolean;
+    partitionSemanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticCorpusAllocationCommitmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    commitmentVersion: z.ZodLiteral<"1.0.0">;
+    commitmentId: z.ZodString;
+    allocationId: z.ZodString;
+    trustPolicyDigest: z.ZodString;
+    caseSet: z.ZodArray<z.ZodObject<{
+        caseId: z.ZodString;
+        caseDigest: z.ZodString;
+        provenanceDigest: z.ZodString;
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+    }, z.core.$strict>>;
+    strata: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+        calibrationCount: z.ZodInt;
+    }, z.core.$strict>>;
+    signers: z.ZodTuple<[z.ZodObject<{
+        keyId: z.ZodString;
+        role: z.ZodEnum<{
+            AUTHOR: "AUTHOR";
+            REVIEWER: "REVIEWER";
+        }>;
+        shareCommitmentDigest: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        keyId: z.ZodString;
+        role: z.ZodEnum<{
+            AUTHOR: "AUTHOR";
+            REVIEWER: "REVIEWER";
+        }>;
+        shareCommitmentDigest: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strict>], null>;
+    commitmentDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusAllocationRevealSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    revealVersion: z.ZodLiteral<"1.0.0">;
+    commitmentDigest: z.ZodString;
+    shares: z.ZodTuple<[z.ZodObject<{
+        keyId: z.ZodString;
+        secret: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        keyId: z.ZodString;
+        secret: z.ZodString;
+    }, z.core.$strict>], null>;
+    revealDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusAllocationCommitmentReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    externalTrustAnchorValid: z.ZodBoolean;
+    externalCommitmentAnchorValid: z.ZodBoolean;
+    commitmentDigestValid: z.ZodBoolean;
+    caseSetValid: z.ZodBoolean;
+    commitmentSignaturesValid: z.ZodBoolean;
+    principalsDistinct: z.ZodBoolean;
+    revealValid: z.ZodBoolean;
+    finalSeedDigestValid: z.ZodBoolean;
+    allocationReplayValid: z.ZodBoolean;
+    allocationBindingValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    planVersion: z.ZodLiteral<"1.0.0">;
+    experimentId: z.ZodString;
+    hypothesis: z.ZodLiteral<"H3">;
+    partition: z.ZodLiteral<"HOLDOUT">;
+    trustPolicyDigest: z.ZodString;
+    allocationCommitmentDigest: z.ZodString;
+    allocationDigest: z.ZodString;
+    protocol: z.ZodObject<{
+        protocolId: z.ZodString;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+        minimumStableAttempts: z.ZodInt;
+        taxonomy: z.ZodLiteral<"TESTFORGE_OBSERVATION_V1">;
+        detectionRule: z.ZodLiteral<"ATTRIBUTED_ASSERTION_FAILURE_ON_BUGGY_PASS_ON_FIXED">;
+        nonEvidenceRule: z.ZodLiteral<"ERRORS_ARE_INSUFFICIENT_NOT_DETECTIONS">;
+        maximumDetectionDeficitCases: z.ZodInt;
+    }, z.core.$strict>;
+    subjects: z.ZodArray<z.ZodObject<{
+        caseId: z.ZodString;
+        caseDigest: z.ZodString;
+        provenanceDigest: z.ZodString;
+        sourceId: z.ZodString;
+        sourceIdentityDigest: z.ZodString;
+        buggyRevisionDigest: z.ZodString;
+        fixedRevisionDigest: z.ZodString;
+        reconstructionDigest: z.ZodString;
+        requiredSuiteDigest: z.ZodString;
+        qualificationReceiptDigest: z.ZodString;
+    }, z.core.$strict>>;
+    adapters: z.ZodArray<z.ZodObject<{
+        adapterId: z.ZodString;
+        adapterVersion: z.ZodLiteral<"1.0.0">;
+        identityDigest: z.ZodString;
+        resultProtocol: z.ZodLiteral<"TESTFORGE_H3_STRUCTURED_RESULT_V1">;
+    }, z.core.$strict>>;
+    arms: z.ZodObject<{
+        baseline: z.ZodObject<{
+            candidateUniverse: z.ZodArray<z.ZodObject<{
+                candidateId: z.ZodString;
+                candidateDigest: z.ZodString;
+            }, z.core.$strict>>;
+            selectedCandidates: z.ZodArray<z.ZodObject<{
+                candidateId: z.ZodString;
+                candidateDigest: z.ZodString;
+            }, z.core.$strict>>;
+            selectedSuiteDigest: z.ZodString;
+        }, z.core.$strict>;
+        profile: z.ZodObject<{
+            candidateUniverse: z.ZodArray<z.ZodObject<{
+                candidateId: z.ZodString;
+                candidateDigest: z.ZodString;
+            }, z.core.$strict>>;
+            selectedCandidates: z.ZodArray<z.ZodObject<{
+                candidateId: z.ZodString;
+                candidateDigest: z.ZodString;
+            }, z.core.$strict>>;
+            selectedSuiteDigest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    commands: z.ZodArray<z.ZodObject<{
+        commandId: z.ZodString;
+        adapterId: z.ZodString;
+        arm: z.ZodEnum<{
+            BASELINE: "BASELINE";
+            PROFILE: "PROFILE";
+        }>;
+        executableIdentityDigest: z.ZodString;
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+        subjectState: z.ZodEnum<{
+            BUGGY: "BUGGY";
+            FIXED: "FIXED";
+            REQUIRED_SUITE: "REQUIRED_SUITE";
+        }>;
+        testSuiteDigest: z.ZodString;
+        timeoutMs: z.ZodInt;
+        maxStdoutBytes: z.ZodInt;
+        maxStderrBytes: z.ZodInt;
+    }, z.core.$strict>>;
+    schedule: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        caseId: z.ZodString;
+        arm: z.ZodEnum<{
+            BASELINE: "BASELINE";
+            PROFILE: "PROFILE";
+        }>;
+        attemptOrdinal: z.ZodInt;
+        subjectState: z.ZodEnum<{
+            BUGGY: "BUGGY";
+            FIXED: "FIXED";
+            REQUIRED_SUITE: "REQUIRED_SUITE";
+        }>;
+        commandId: z.ZodString;
+    }, z.core.$strict>>;
+    budget: z.ZodObject<{
+        unit: z.ZodLiteral<"PLANNED_PROCESS_EXECUTION">;
+        baselinePlannedProcessExecutions: z.ZodInt;
+        profilePlannedProcessExecutions: z.ZodInt;
+        equalPlannedProcessExecutions: z.ZodBoolean;
+        baselinePlannedTimeoutMs: z.ZodInt;
+        profilePlannedTimeoutMs: z.ZodInt;
+        equalPlannedTimeoutBudget: z.ZodBoolean;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+    planDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentPlanReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    externalPlanAnchorValid: z.ZodBoolean;
+    planDigestValid: z.ZodBoolean;
+    allocationBindingValid: z.ZodBoolean;
+    subjectSetValid: z.ZodBoolean;
+    armsValid: z.ZodBoolean;
+    commandsValid: z.ZodBoolean;
+    scheduleValid: z.ZodBoolean;
+    budgetValid: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    receiptVersion: z.ZodLiteral<"1.0.0">;
+    runId: z.ZodString;
+    planDigest: z.ZodString;
+    commandId: z.ZodString;
+    commandDigest: z.ZodString;
+    caseId: z.ZodString;
+    arm: z.ZodEnum<{
+        BASELINE: "BASELINE";
+        PROFILE: "PROFILE";
+    }>;
+    attemptOrdinal: z.ZodInt;
+    subjectState: z.ZodEnum<{
+        BUGGY: "BUGGY";
+        FIXED: "FIXED";
+        REQUIRED_SUITE: "REQUIRED_SUITE";
+    }>;
+    repositoryDigest: z.ZodString;
+    testSuiteDigest: z.ZodString;
+    appliedTimeoutMs: z.ZodInt;
+    process: z.ZodObject<{
+        exitCode: z.ZodNullable<z.ZodInt>;
+        timedOut: z.ZodBoolean;
+        stdoutDigest: z.ZodString;
+        stderrDigest: z.ZodString;
+    }, z.core.$strict>;
+    structuredResultDigest: z.ZodString;
+    receiptDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentStructuredResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    protocol: z.ZodLiteral<"TESTFORGE_H3_STRUCTURED_RESULT_V1">;
+    outcome: z.ZodEnum<{
+        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+        COMPILE_FAILURE: "COMPILE_FAILURE";
+        INFRA_ERROR: "INFRA_ERROR";
+        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+        PASS: "PASS";
+        PROCESS_CRASH: "PROCESS_CRASH";
+        TIMEOUT: "TIMEOUT";
+    }>;
+    attributed: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    experimentVersion: z.ZodLiteral<"1.0.0">;
+    experimentId: z.ZodString;
+    hypothesis: z.ZodLiteral<"H3">;
+    partition: z.ZodLiteral<"HOLDOUT">;
+    planDigest: z.ZodString;
+    allocationDigest: z.ZodString;
+    trustPolicyDigest: z.ZodString;
+    evidenceBindings: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        receiptDigest: z.ZodString;
+        receiptContentDigest: z.ZodString;
+    }, z.core.$strict>>;
+    payloadSchemaId: z.ZodLiteral<"https://testforge.dev/payloads/agentic-corpus-experiment-h3.v1.json">;
+    payload: z.ZodObject<{
+        cases: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            baselineAttempts: z.ZodArray<z.ZodObject<{
+                ordinal: z.ZodInt;
+                buggy: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                fixed: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                requiredSuite: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                runIds: z.ZodObject<{
+                    buggy: z.ZodString;
+                    fixed: z.ZodString;
+                    requiredSuite: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            profileAttempts: z.ZodArray<z.ZodObject<{
+                ordinal: z.ZodInt;
+                buggy: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                fixed: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                requiredSuite: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                runIds: z.ZodObject<{
+                    buggy: z.ZodString;
+                    fixed: z.ZodString;
+                    requiredSuite: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    experimentVersion: z.ZodLiteral<"1.0.0">;
+    experimentId: z.ZodString;
+    hypothesis: z.ZodLiteral<"H3">;
+    partition: z.ZodLiteral<"HOLDOUT">;
+    planDigest: z.ZodString;
+    allocationDigest: z.ZodString;
+    trustPolicyDigest: z.ZodString;
+    evidenceBindings: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        receiptDigest: z.ZodString;
+        receiptContentDigest: z.ZodString;
+    }, z.core.$strict>>;
+    payloadSchemaId: z.ZodLiteral<"https://testforge.dev/payloads/agentic-corpus-experiment-h3.v1.json">;
+    payload: z.ZodObject<{
+        cases: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            baselineAttempts: z.ZodArray<z.ZodObject<{
+                ordinal: z.ZodInt;
+                buggy: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                fixed: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                requiredSuite: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                runIds: z.ZodObject<{
+                    buggy: z.ZodString;
+                    fixed: z.ZodString;
+                    requiredSuite: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            profileAttempts: z.ZodArray<z.ZodObject<{
+                ordinal: z.ZodInt;
+                buggy: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                fixed: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                requiredSuite: z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                        COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                        COMPILE_FAILURE: "COMPILE_FAILURE";
+                        INFRA_ERROR: "INFRA_ERROR";
+                        NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                        PASS: "PASS";
+                        PROCESS_CRASH: "PROCESS_CRASH";
+                        TIMEOUT: "TIMEOUT";
+                    }>;
+                    attributed: z.ZodBoolean;
+                }, z.core.$strict>;
+                runIds: z.ZodObject<{
+                    buggy: z.ZodString;
+                    fixed: z.ZodString;
+                    requiredSuite: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+    candidateSetDigest: z.ZodString;
+    evidenceSetDigest: z.ZodString;
+    payloadDigest: z.ZodString;
+    result: z.ZodObject<{
+        status: z.ZodEnum<{
+            INSUFFICIENT: "INSUFFICIENT";
+            NOT_SUPPORTED: "NOT_SUPPORTED";
+            SUPPORTED: "SUPPORTED";
+        }>;
+        evaluatedCaseIds: z.ZodArray<z.ZodString>;
+        baselineDetectedCaseIds: z.ZodArray<z.ZodString>;
+        profileDetectedCaseIds: z.ZodArray<z.ZodString>;
+        insufficientCaseIds: z.ZodArray<z.ZodString>;
+        baselineDetectedCount: z.ZodInt;
+        profileDetectedCount: z.ZodInt;
+        maximumDetectionDeficitCases: z.ZodInt;
+        nonInferior: z.ZodBoolean;
+        sourceResults: z.ZodArray<z.ZodObject<{
+            sourceId: z.ZodString;
+            sourceIdentityDigest: z.ZodString;
+            evaluatedCaseIds: z.ZodArray<z.ZodString>;
+            baselineDetectedCount: z.ZodInt;
+            profileDetectedCount: z.ZodInt;
+            nonInferior: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    artifactDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentReplayRequestSchema: z.ZodObject<{
+    artifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        experimentVersion: z.ZodLiteral<"1.0.0">;
+        experimentId: z.ZodString;
+        hypothesis: z.ZodLiteral<"H3">;
+        partition: z.ZodLiteral<"HOLDOUT">;
+        planDigest: z.ZodString;
+        allocationDigest: z.ZodString;
+        trustPolicyDigest: z.ZodString;
+        evidenceBindings: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            receiptDigest: z.ZodString;
+            receiptContentDigest: z.ZodString;
+        }, z.core.$strict>>;
+        payloadSchemaId: z.ZodLiteral<"https://testforge.dev/payloads/agentic-corpus-experiment-h3.v1.json">;
+        payload: z.ZodObject<{
+            cases: z.ZodArray<z.ZodObject<{
+                caseId: z.ZodString;
+                baselineAttempts: z.ZodArray<z.ZodObject<{
+                    ordinal: z.ZodInt;
+                    buggy: z.ZodObject<{
+                        outcome: z.ZodEnum<{
+                            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                            COMPILE_FAILURE: "COMPILE_FAILURE";
+                            INFRA_ERROR: "INFRA_ERROR";
+                            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                            PASS: "PASS";
+                            PROCESS_CRASH: "PROCESS_CRASH";
+                            TIMEOUT: "TIMEOUT";
+                        }>;
+                        attributed: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    fixed: z.ZodObject<{
+                        outcome: z.ZodEnum<{
+                            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                            COMPILE_FAILURE: "COMPILE_FAILURE";
+                            INFRA_ERROR: "INFRA_ERROR";
+                            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                            PASS: "PASS";
+                            PROCESS_CRASH: "PROCESS_CRASH";
+                            TIMEOUT: "TIMEOUT";
+                        }>;
+                        attributed: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    requiredSuite: z.ZodObject<{
+                        outcome: z.ZodEnum<{
+                            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                            COMPILE_FAILURE: "COMPILE_FAILURE";
+                            INFRA_ERROR: "INFRA_ERROR";
+                            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                            PASS: "PASS";
+                            PROCESS_CRASH: "PROCESS_CRASH";
+                            TIMEOUT: "TIMEOUT";
+                        }>;
+                        attributed: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    runIds: z.ZodObject<{
+                        buggy: z.ZodString;
+                        fixed: z.ZodString;
+                        requiredSuite: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                profileAttempts: z.ZodArray<z.ZodObject<{
+                    ordinal: z.ZodInt;
+                    buggy: z.ZodObject<{
+                        outcome: z.ZodEnum<{
+                            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                            COMPILE_FAILURE: "COMPILE_FAILURE";
+                            INFRA_ERROR: "INFRA_ERROR";
+                            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                            PASS: "PASS";
+                            PROCESS_CRASH: "PROCESS_CRASH";
+                            TIMEOUT: "TIMEOUT";
+                        }>;
+                        attributed: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    fixed: z.ZodObject<{
+                        outcome: z.ZodEnum<{
+                            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                            COMPILE_FAILURE: "COMPILE_FAILURE";
+                            INFRA_ERROR: "INFRA_ERROR";
+                            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                            PASS: "PASS";
+                            PROCESS_CRASH: "PROCESS_CRASH";
+                            TIMEOUT: "TIMEOUT";
+                        }>;
+                        attributed: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    requiredSuite: z.ZodObject<{
+                        outcome: z.ZodEnum<{
+                            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                            COMPILE_FAILURE: "COMPILE_FAILURE";
+                            INFRA_ERROR: "INFRA_ERROR";
+                            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                            PASS: "PASS";
+                            PROCESS_CRASH: "PROCESS_CRASH";
+                            TIMEOUT: "TIMEOUT";
+                        }>;
+                        attributed: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    runIds: z.ZodObject<{
+                        buggy: z.ZodString;
+                        fixed: z.ZodString;
+                        requiredSuite: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+        candidateSetDigest: z.ZodString;
+        evidenceSetDigest: z.ZodString;
+        payloadDigest: z.ZodString;
+        result: z.ZodObject<{
+            status: z.ZodEnum<{
+                INSUFFICIENT: "INSUFFICIENT";
+                NOT_SUPPORTED: "NOT_SUPPORTED";
+                SUPPORTED: "SUPPORTED";
+            }>;
+            evaluatedCaseIds: z.ZodArray<z.ZodString>;
+            baselineDetectedCaseIds: z.ZodArray<z.ZodString>;
+            profileDetectedCaseIds: z.ZodArray<z.ZodString>;
+            insufficientCaseIds: z.ZodArray<z.ZodString>;
+            baselineDetectedCount: z.ZodInt;
+            profileDetectedCount: z.ZodInt;
+            maximumDetectionDeficitCases: z.ZodInt;
+            nonInferior: z.ZodBoolean;
+            sourceResults: z.ZodArray<z.ZodObject<{
+                sourceId: z.ZodString;
+                sourceIdentityDigest: z.ZodString;
+                evaluatedCaseIds: z.ZodArray<z.ZodString>;
+                baselineDetectedCount: z.ZodInt;
+                profileDetectedCount: z.ZodInt;
+                nonInferior: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        artifactDigest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AgenticCorpusExperimentReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    artifactDigestValid: z.ZodBoolean;
+    externalTrustAnchorValid: z.ZodBoolean;
+    externalCommitmentAnchorValid: z.ZodBoolean;
+    commitmentRevealValid: z.ZodBoolean;
+    allocationReplayValid: z.ZodBoolean;
+    allocationBindingValid: z.ZodBoolean;
+    externalPlanAnchorValid: z.ZodBoolean;
+    planDigestValid: z.ZodBoolean;
+    planSemanticsValid: z.ZodBoolean;
+    subjectDigestsValid: z.ZodBoolean;
+    provenanceReplayValid: z.ZodBoolean;
+    scheduleValid: z.ZodBoolean;
+    budgetValid: z.ZodBoolean;
+    evidenceSetDigestValid: z.ZodBoolean;
+    receiptBindingsValid: z.ZodBoolean;
+    candidateEvidenceValid: z.ZodBoolean;
+    outputBytesResolved: z.ZodBoolean;
+    structuredResultsValid: z.ZodBoolean;
+    payloadSupported: z.ZodBoolean;
+    payloadDigestValid: z.ZodBoolean;
+    observationSemanticsValid: z.ZodBoolean;
+    resultSemanticsValid: z.ZodBoolean;
+}, z.core.$strict>;
+export type ObservationOutcome = z.infer<typeof ObservationOutcomeSchema>;
+export type FileOverlay = z.infer<typeof FileOverlaySchema>;
+export type World = z.infer<typeof WorldSchema>;
+export type Candidate = z.infer<typeof CandidateSchema>;
+export type VerificationRequest = z.infer<typeof VerificationRequestSchema>;
+export type NodeTestAdapter = z.infer<typeof NodeTestAdapterSchema>;
+export type StructuredCommandAdapter = z.infer<typeof StructuredCommandAdapterSchema>;
+export type RepositoryAnalysis = z.infer<typeof RepositoryAnalysisSchema>;
+export type RepositoryAudit = z.infer<typeof RepositoryAuditSchema>;
+export type RepositoryInitConfig = z.infer<typeof RepositoryInitConfigSchema>;
+export type RepositoryInitLock = z.infer<typeof RepositoryInitLockSchema>;
+export type RepositoryInitResult = z.infer<typeof RepositoryInitResultSchema>;
+export type RepositoryInitDetections = z.infer<typeof RepositoryInitDetectionsSchema>;
+export type EvidenceManifestContract = z.infer<typeof EvidenceManifestSchema>;
+export type ReplayResult = z.infer<typeof ReplayResultSchema>;
+export type AgenticProfilePolicy = z.infer<typeof AgenticProfilePolicySchema>;
+export type AgenticProfileRequest = z.infer<typeof AgenticProfileRequestSchema>;
+export type AgenticProfileReport = z.infer<typeof AgenticProfileReportSchema>;
+export type AgenticProfileReplayResult = z.infer<typeof AgenticProfileReplayResultSchema>;
+export type AgenticBenchmarkPolicy = z.infer<typeof AgenticBenchmarkPolicySchema>;
+export type AgenticBenchmarkProtocol = z.infer<typeof AgenticBenchmarkProtocolSchema>;
+export type AgenticBenchmarkFingerprint = z.infer<typeof AgenticBenchmarkFingerprintSchema>;
+export type AgenticBenchmarkRun = z.infer<typeof AgenticBenchmarkRunSchema>;
+export type AgenticBenchmarkRequest = z.infer<typeof AgenticBenchmarkRequestSchema>;
+export type AgenticBenchmarkArtifact = z.infer<typeof AgenticBenchmarkArtifactSchema>;
+export type AgenticBenchmarkReplayResult = z.infer<typeof AgenticBenchmarkReplayResultSchema>;
+export type AgenticBenchmarkAcquisitionRequest = z.infer<typeof AgenticBenchmarkAcquisitionRequestSchema>;
+export type AgenticBenchmarkAcquisitionResult = z.infer<typeof AgenticBenchmarkAcquisitionResultSchema>;
+export type AgenticBenchmarkAcquisitionReplayResult = z.infer<typeof AgenticBenchmarkAcquisitionReplayResultSchema>;
+export type AgenticProfilePolicyV2 = z.infer<typeof AgenticProfilePolicyV2Schema>;
+export type AgenticProfileRequestV2 = z.infer<typeof AgenticProfileRequestV2Schema>;
+export type AgenticProfileReportV2 = z.infer<typeof AgenticProfileReportV2Schema>;
+export type AgenticProfileReplayResultV2 = z.infer<typeof AgenticProfileReplayResultV2Schema>;
+export type AgenticCorpusTrustPolicy = z.infer<typeof AgenticCorpusTrustPolicySchema>;
+export type AgenticCorpusProvenance = z.infer<typeof AgenticCorpusProvenanceSchema>;
+export type AgenticCorpusAllocationRequest = z.infer<typeof AgenticCorpusAllocationRequestSchema>;
+export type AgenticCorpusAllocation = z.infer<typeof AgenticCorpusAllocationSchema>;
+export type AgenticCorpusAllocationReplayResult = z.infer<typeof AgenticCorpusAllocationReplayResultSchema>;
+export type AgenticCorpusAllocationCommitment = z.infer<typeof AgenticCorpusAllocationCommitmentSchema>;
+export type AgenticCorpusAllocationReveal = z.infer<typeof AgenticCorpusAllocationRevealSchema>;
+export type AgenticCorpusAllocationCommitmentReplayResult = z.infer<typeof AgenticCorpusAllocationCommitmentReplayResultSchema>;
+export type AgenticCorpusExperimentPlan = z.infer<typeof AgenticCorpusExperimentPlanSchema>;
+export type AgenticCorpusExperimentPlanReplayResult = z.infer<typeof AgenticCorpusExperimentPlanReplayResultSchema>;
+export type AgenticCorpusExperimentRequest = z.infer<typeof AgenticCorpusExperimentRequestSchema>;
+export type AgenticCorpusExperimentArtifact = z.infer<typeof AgenticCorpusExperimentArtifactSchema>;
+export type AgenticCorpusExperimentReplayRequest = z.infer<typeof AgenticCorpusExperimentReplayRequestSchema>;
+export type AgenticCorpusExperimentReplayResult = z.infer<typeof AgenticCorpusExperimentReplayResultSchema>;
+export type AgenticCorpusExperimentReceipt = z.infer<typeof AgenticCorpusExperimentReceiptSchema>;
+export type AgenticCorpusExperimentStructuredResult = z.infer<typeof AgenticCorpusExperimentStructuredResultSchema>;
+export declare class ContractError extends Error {
+    readonly code: string;
+    constructor(code: string, detail?: string);
+}
+export declare function parseVerificationRequest(value: unknown): VerificationRequest;
+export declare function parseRepositoryAnalysis(value: unknown): RepositoryAnalysis;
+export declare function parseRepositoryAudit(value: unknown): RepositoryAudit;
+export declare function parseRepositoryInitConfig(value: unknown): RepositoryInitConfig;
+export declare function repositoryInitConfigDigest(config: RepositoryInitConfig): string;
+export declare function repositoryInitLockDigest(lock: Omit<RepositoryInitLock, "lockDigest">): string;
+export declare function parseRepositoryInitLock(value: unknown): RepositoryInitLock;
+export declare function parseRepositoryInitResult(value: unknown): RepositoryInitResult;
+export declare function parseEvidenceManifest(value: unknown): EvidenceManifestContract;
+export declare function parseReplayResult(value: unknown): ReplayResult;
+export declare function parseAgenticProfileRequest(value: unknown): AgenticProfileRequest;
+export declare function parseAgenticProfileReport(value: unknown): AgenticProfileReport;
+export declare function parseAgenticProfileReplayResult(value: unknown): AgenticProfileReplayResult;
+export declare function parseAgenticBenchmarkRequest(value: unknown): AgenticBenchmarkRequest;
+export declare function parseAgenticBenchmarkArtifact(value: unknown): AgenticBenchmarkArtifact;
+export declare function parseAgenticBenchmarkReplayResult(value: unknown): AgenticBenchmarkReplayResult;
+export declare function parseAgenticBenchmarkAcquisitionRequest(value: unknown): AgenticBenchmarkAcquisitionRequest;
+export declare function parseAgenticBenchmarkAcquisitionResult(value: unknown): AgenticBenchmarkAcquisitionResult;
+export declare function parseAgenticBenchmarkAcquisitionReplayResult(value: unknown): AgenticBenchmarkAcquisitionReplayResult;
+export declare function parseAgenticProfileRequestV2(value: unknown): AgenticProfileRequestV2;
+export declare function parseAgenticProfileReportV2(value: unknown): AgenticProfileReportV2;
+export declare function parseAgenticProfileReplayResultV2(value: unknown): AgenticProfileReplayResultV2;
+export declare function parseAgenticCorpusTrustPolicy(value: unknown): AgenticCorpusTrustPolicy;
+export declare function parseAgenticCorpusProvenance(value: unknown): AgenticCorpusProvenance;
+export declare function parseAgenticCorpusAllocationRequest(value: unknown): AgenticCorpusAllocationRequest;
+export declare function parseAgenticCorpusAllocation(value: unknown): AgenticCorpusAllocation;
+export declare function parseAgenticCorpusAllocationReplayResult(value: unknown): AgenticCorpusAllocationReplayResult;
+export declare function parseAgenticCorpusAllocationCommitment(value: unknown): AgenticCorpusAllocationCommitment;
+export declare function parseAgenticCorpusAllocationReveal(value: unknown): AgenticCorpusAllocationReveal;
+export declare function parseAgenticCorpusAllocationCommitmentReplayResult(value: unknown): AgenticCorpusAllocationCommitmentReplayResult;
+export declare function parseAgenticCorpusExperimentPlan(value: unknown): AgenticCorpusExperimentPlan;
+export declare function parseAgenticCorpusExperimentPlanReplayResult(value: unknown): AgenticCorpusExperimentPlanReplayResult;
+export declare function parseAgenticCorpusExperimentRequest(value: unknown): AgenticCorpusExperimentRequest;
+export declare function parseAgenticCorpusExperimentArtifact(value: unknown): AgenticCorpusExperimentArtifact;
+export declare function parseAgenticCorpusExperimentReplayRequest(value: unknown): AgenticCorpusExperimentReplayRequest;
+export declare function parseAgenticCorpusExperimentReplayResult(value: unknown): AgenticCorpusExperimentReplayResult;
+export declare function parseAgenticCorpusExperimentReceipt(value: unknown): AgenticCorpusExperimentReceipt;
+export declare function parseAgenticCorpusExperimentStructuredResult(value: unknown): AgenticCorpusExperimentStructuredResult;
+export declare function verificationRequestJsonSchema(): Record<string, unknown>;
+export declare function repositoryAnalysisJsonSchema(): Record<string, unknown>;
+export declare function repositoryAuditJsonSchema(): Record<string, unknown>;
+export declare function repositoryInitConfigJsonSchema(): Record<string, unknown>;
+export declare function repositoryInitLockJsonSchema(): Record<string, unknown>;
+export declare function repositoryInitResultJsonSchema(): Record<string, unknown>;
+export declare function evidenceManifestJsonSchema(): Record<string, unknown>;
+export declare function replayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticProfileRequestJsonSchema(): Record<string, unknown>;
+export declare function agenticProfileReportJsonSchema(): Record<string, unknown>;
+export declare function agenticProfileReplayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticBenchmarkRequestJsonSchema(): Record<string, unknown>;
+export declare function agenticBenchmarkArtifactJsonSchema(): Record<string, unknown>;
+export declare function agenticBenchmarkReplayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticBenchmarkAcquisitionRequestJsonSchema(): Record<string, unknown>;
+export declare function agenticBenchmarkAcquisitionResultJsonSchema(): Record<string, unknown>;
+export declare function agenticBenchmarkAcquisitionReplayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticProfileRequestV2JsonSchema(): Record<string, unknown>;
+export declare function agenticProfileReportV2JsonSchema(): Record<string, unknown>;
+export declare function agenticProfileReplayResultV2JsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusTrustPolicyJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusProvenanceJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusAllocationRequestJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusAllocationJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusAllocationReplayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusAllocationCommitmentJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusAllocationRevealJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusAllocationCommitmentReplayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusExperimentPlanJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusExperimentPlanReplayResultJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusExperimentRequestJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusExperimentArtifactJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusExperimentReplayRequestJsonSchema(): Record<string, unknown>;
+export declare function agenticCorpusExperimentReplayResultJsonSchema(): Record<string, unknown>;
+//# sourceMappingURL=index.d.ts.map