assertledger 1.0.0 → 1.1.0

package/dist/contracts/index.d.ts

@@ -70,6 +70,28 @@ export declare const TrustedLocalIsolationSchema: z.ZodObject<{
     acknowledgedUnsafeExecution: z.ZodBoolean;
     environmentAllowlist: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
+export declare const VERIFICATION_SCHEMA_VERSION_V2: "2.0.0";
+export declare const ContainerImageReferenceSchema: z.ZodString;
+export declare const ContainerLimitsSchema: z.ZodObject<{
+    memoryBytes: z.ZodInt;
+    cpuMillicores: z.ZodInt;
+    pids: z.ZodInt;
+    temporaryDirectoryBytes: z.ZodInt;
+}, z.core.$strict>;
+export declare const ContainerIsolationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"container">;
+    image: z.ZodString;
+    environment: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        memoryBytes: z.ZodInt;
+        cpuMillicores: z.ZodInt;
+        pids: z.ZodInt;
+        temporaryDirectoryBytes: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const BudgetsSchema: z.ZodObject<{
     maximumCandidates: z.ZodInt;
     maximumWorlds: z.ZodInt;
@@ -154,6 +176,84 @@ export declare const VerificationRequestSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const VerificationRequestV2Schema: z.ZodObject<{
+    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">;
+    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>>;
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    isolation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"trusted-local">;
+        acknowledgedUnsafeExecution: z.ZodBoolean;
+        environmentAllowlist: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"container">;
+        image: z.ZodString;
+        environment: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        limits: z.ZodObject<{
+            memoryBytes: z.ZodInt;
+            cpuMillicores: z.ZodInt;
+            pids: z.ZodInt;
+            temporaryDirectoryBytes: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
 export declare const RepositoryAnalysisSchema: z.ZodObject<{
     root: z.ZodString;
     fileCount: z.ZodInt;
@@ -690,6 +790,222 @@ export declare const EvidenceManifestSchema: z.ZodObject<{
     }, z.core.$strict>;
     limitations: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
+declare const ExecutionBackendRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"trusted-local">;
+    level: z.ZodLiteral<"UNSANDBOXED">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"container">;
+    level: z.ZodLiteral<"CONTAINER">;
+    image: z.ZodObject<{
+        reference: z.ZodString;
+        id: z.ZodString;
+        os: z.ZodLiteral<"linux">;
+        architecture: z.ZodString;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        clientVersion: z.ZodString;
+        serverVersion: z.ZodString;
+        serverOs: z.ZodLiteral<"linux">;
+        serverArchitecture: z.ZodString;
+        cgroupVersion: z.ZodString;
+        securityOptions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    controls: z.ZodObject<{
+        network: z.ZodLiteral<"none">;
+        rootFilesystem: z.ZodLiteral<"read-only">;
+        hostMounts: z.ZodLiteral<"none">;
+        workspace: z.ZodLiteral<"anonymous-volume">;
+        user: z.ZodLiteral<"65534:65534">;
+        capabilities: z.ZodLiteral<"none">;
+        noNewPrivileges: z.ZodLiteral<true>;
+        imagePull: z.ZodLiteral<"never">;
+        logDriver: z.ZodLiteral<"none">;
+        environment: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        limits: z.ZodObject<{
+            memoryBytes: z.ZodInt;
+            cpuMillicores: z.ZodInt;
+            pids: z.ZodInt;
+            temporaryDirectoryBytes: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export declare const EvidenceManifestV2Schema: z.ZodObject<{
+    repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+    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">;
+    limitations: z.ZodArray<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    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>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            provenance: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        execution: z.ZodObject<{
+            isolation: z.ZodString;
+            environmentAllowlist: z.ZodArray<z.ZodString>;
+            budgets: z.ZodJSONSchema;
+            candidateRoots: z.ZodArray<z.ZodString>;
+            backend: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"trusted-local">;
+                level: z.ZodLiteral<"UNSANDBOXED">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"container">;
+                level: z.ZodLiteral<"CONTAINER">;
+                image: z.ZodObject<{
+                    reference: z.ZodString;
+                    id: z.ZodString;
+                    os: z.ZodLiteral<"linux">;
+                    architecture: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodObject<{
+                    clientVersion: z.ZodString;
+                    serverVersion: z.ZodString;
+                    serverOs: z.ZodLiteral<"linux">;
+                    serverArchitecture: z.ZodString;
+                    cgroupVersion: z.ZodString;
+                    securityOptions: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                controls: z.ZodObject<{
+                    network: z.ZodLiteral<"none">;
+                    rootFilesystem: z.ZodLiteral<"read-only">;
+                    hostMounts: z.ZodLiteral<"none">;
+                    workspace: z.ZodLiteral<"anonymous-volume">;
+                    user: z.ZodLiteral<"65534:65534">;
+                    capabilities: z.ZodLiteral<"none">;
+                    noNewPrivileges: z.ZodLiteral<true>;
+                    imagePull: z.ZodLiteral<"never">;
+                    logDriver: z.ZodLiteral<"none">;
+                    environment: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strict>>;
+                    limits: z.ZodObject<{
+                        memoryBytes: z.ZodInt;
+                        cpuMillicores: z.ZodInt;
+                        pids: z.ZodInt;
+                        temporaryDirectoryBytes: z.ZodInt;
+                    }, z.core.$strict>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    isolation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"trusted-local">;
+        level: z.ZodLiteral<"UNSANDBOXED">;
+        acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"container">;
+        level: z.ZodLiteral<"CONTAINER">;
+        runtimeCommand: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
 export declare const ReplayResultSchema: z.ZodObject<{
     valid: z.ZodBoolean;
     schemaValid: z.ZodBoolean;
@@ -3780,11 +4096,615 @@ export declare const AgenticCorpusExperimentReplayResultSchema: z.ZodObject<{
     observationSemanticsValid: z.ZodBoolean;
     resultSemanticsValid: z.ZodBoolean;
 }, z.core.$strict>;
+export declare const EvidenceProviderManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    provider: z.ZodObject<{
+        name: z.ZodLiteral<"assertledger">;
+        version: z.ZodString;
+        sourceRevision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"RECORDED">;
+            commit: z.ZodString;
+            worktree: z.ZodEnum<{
+                CLEAN: "CLEAN";
+                DIRTY: "DIRTY";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"UNKNOWN">;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    scope: z.ZodString;
+    formats: z.ZodObject<{
+        accepts: z.ZodArray<z.ZodObject<{
+            schemaId: z.ZodString;
+            schemaVersion: z.ZodString;
+        }, z.core.$strict>>;
+        emits: z.ZodArray<z.ZodObject<{
+            schemaId: z.ZodString;
+            schemaVersion: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            SUPPORTED: "SUPPORTED";
+            SUPPORTED_WHEN_RECORDED: "SUPPORTED_WHEN_RECORDED";
+            UNSUPPORTED: "UNSUPPORTED";
+        }>;
+        modality: z.ZodEnum<{
+            NONE: "NONE";
+            RECORDED_METADATA: "RECORDED_METADATA";
+            TEST_OBSERVED: "TEST_OBSERVED";
+        }>;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    adapters: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "node-test": "node-test";
+            "testforge-command": "testforge-command";
+        }>;
+        profileId: z.ZodNullable<z.ZodString>;
+        profileVersion: z.ZodNullable<z.ZodString>;
+        official: z.ZodBoolean;
+    }, z.core.$strict>>;
+    cost: z.ZodObject<{
+        unit: z.ZodLiteral<"PROCESS_EXECUTIONS">;
+        estimate: z.ZodString;
+        assumptions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    limits: z.ZodArray<z.ZodString>;
+    manifestDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const EvidenceExportRequestSchema: 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>;
+    consumerRequest: z.ZodNullable<z.ZodObject<{
+        reference: z.ZodNullable<z.ZodString>;
+        profileId: z.ZodNullable<z.ZodString>;
+        obligations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            control: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const EvidenceExportSchema: 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;
+    consumerRequest: z.ZodNullable<z.ZodObject<{
+        reference: z.ZodNullable<z.ZodString>;
+        profileId: z.ZodNullable<z.ZodString>;
+        obligations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            control: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    result: z.ZodObject<{
+        detection: z.ZodEnum<{
+            NOT_ESTABLISHED: "NOT_ESTABLISHED";
+            NOT_OBSERVED: "NOT_OBSERVED";
+            OBSERVED: "OBSERVED";
+        }>;
+        modality: z.ZodEnum<{
+            NONE: "NONE";
+            TEST_OBSERVED: "TEST_OBSERVED";
+        }>;
+        reasonCode: z.ZodEnum<{
+            CANDIDATE_EVIDENCE_INCONCLUSIVE: "CANDIDATE_EVIDENCE_INCONCLUSIVE";
+            CANDIDATE_EVIDENCE_INVALID: "CANDIDATE_EVIDENCE_INVALID";
+            CONTROL_EVIDENCE_INVALID: "CONTROL_EVIDENCE_INVALID";
+            ENGINE_ERROR: "ENGINE_ERROR";
+            OPERATIONAL_OUTCOME_NOT_DETECTION: "OPERATIONAL_OUTCOME_NOT_DETECTION";
+            REGRESSION_ASSERTION_OBSERVED: "REGRESSION_ASSERTION_OBSERVED";
+            TARGET_PASSED_WITHOUT_DETECTION: "TARGET_PASSED_WITHOUT_DETECTION";
+            TARGET_STRENGTH_INSUFFICIENT: "TARGET_STRENGTH_INSUFFICIENT";
+        }>;
+        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>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            digest: z.ZodString;
+            status: z.ZodEnum<{
+                ELIGIBLE: "ELIGIBLE";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                INVALID: "INVALID";
+                UNSTABLE: "UNSTABLE";
+                WEAK_ORACLE: "WEAK_ORACLE";
+            }>;
+            selected: z.ZodBoolean;
+            reasonCodes: z.ZodArray<z.ZodString>;
+            worlds: z.ZodArray<z.ZodObject<{
+                worldId: z.ZodString;
+                kind: z.ZodEnum<{
+                    NEUTRAL: "NEUTRAL";
+                    REFERENCE: "REFERENCE";
+                    TARGET: "TARGET";
+                }>;
+                required: z.ZodBoolean;
+                weight: z.ZodInt;
+                outcome: z.ZodEnum<{
+                    ASSERTION_FAILURE: "ASSERTION_FAILURE";
+                    COLLECTION_FAILURE: "COLLECTION_FAILURE";
+                    COMPILE_FAILURE: "COMPILE_FAILURE";
+                    DIVERGENT: "DIVERGENT";
+                    INFRA_ERROR: "INFRA_ERROR";
+                    MISSING: "MISSING";
+                    NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+                    PASS: "PASS";
+                    PROCESS_CRASH: "PROCESS_CRASH";
+                    TIMEOUT: "TIMEOUT";
+                }>;
+                attempts: z.ZodInt;
+                signal: z.ZodEnum<{
+                    GREEN: "GREEN";
+                    NONE: "NONE";
+                    RED: "RED";
+                }>;
+                detection: z.ZodEnum<{
+                    NOT_APPLICABLE: "NOT_APPLICABLE";
+                    NOT_ESTABLISHED: "NOT_ESTABLISHED";
+                    NOT_OBSERVED: "NOT_OBSERVED";
+                    OBSERVED: "OBSERVED";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    integrity: z.ZodObject<{
+        sourceReplay: z.ZodLiteral<"VALID">;
+        verifiedRails: z.ZodTuple<[z.ZodLiteral<"SCHEMA">, z.ZodLiteral<"DECISION_DIGEST">, z.ZodLiteral<"ARTIFACT_DIGEST">, z.ZodLiteral<"DECISION_SEMANTICS">], null>;
+        bindings: z.ZodObject<{
+            artifactDigest: z.ZodString;
+            decisionDigest: z.ZodString;
+            repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+            policyDigest: z.ZodString;
+            worldDigests: z.ZodArray<z.ZodObject<{
+                worldId: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    authenticity: z.ZodObject<{
+        status: z.ZodLiteral<"UNAUTHENTICATED">;
+        attestation: z.ZodLiteral<"NONE">;
+        declaredProducer: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    environment: z.ZodObject<{
+        isolation: z.ZodObject<{
+            kind: z.ZodLiteral<"trusted-local">;
+            level: z.ZodLiteral<"UNSANDBOXED">;
+        }, z.core.$strict>;
+        environmentAllowlist: z.ZodArray<z.ZodString>;
+        adapter: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "node-test": "node-test";
+                "testforge-command": "testforge-command";
+            }>;
+            name: z.ZodString;
+            version: z.ZodString;
+            framework: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"RECORDED">;
+                profileId: z.ZodString;
+                profileVersion: z.ZodString;
+                official: z.ZodBoolean;
+                nodeVersion: z.ZodNullable<z.ZodString>;
+                executableDigest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"UNKNOWN">;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    confidence: z.ZodObject<{
+        level: z.ZodLiteral<"REPLAY_CONSISTENT_UNAUTHENTICATED">;
+        established: z.ZodArray<z.ZodEnum<{
+            ARTIFACT_DIGEST_RECOMPUTED: "ARTIFACT_DIGEST_RECOMPUTED";
+            DECISION_DIGEST_RECOMPUTED: "DECISION_DIGEST_RECOMPUTED";
+            DECISION_RECOMPUTED_FROM_RECORDED_OBSERVATIONS: "DECISION_RECOMPUTED_FROM_RECORDED_OBSERVATIONS";
+            SOURCE_SCHEMA_VALID: "SOURCE_SCHEMA_VALID";
+        }>>;
+        notEstablished: z.ZodArray<z.ZodEnum<{
+            EXECUTION_FRESHNESS: "EXECUTION_FRESHNESS";
+            EXECUTION_ISOLATION: "EXECUTION_ISOLATION";
+            OBSERVATION_TRUTHFULNESS: "OBSERVATION_TRUTHFULNESS";
+            PRODUCER_AUTHENTICITY: "PRODUCER_AUTHENTICITY";
+            WORLD_SEMANTIC_RELEVANCE: "WORLD_SEMANTIC_RELEVANCE";
+        }>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        requiredAttempts: z.ZodInt;
+        candidates: z.ZodInt;
+        observations: z.ZodInt;
+        gitRevisions: z.ZodEnum<{
+            NOT_RECORDED: "NOT_RECORDED";
+            PARTIAL: "PARTIAL";
+            RECORDED: "RECORDED";
+        }>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                TARGET: "TARGET";
+            }>;
+            required: z.ZodBoolean;
+            weight: z.ZodInt;
+            digest: z.ZodString;
+            declaredProvenance: z.ZodString;
+            git: z.ZodNullable<z.ZodObject<{
+                role: z.ZodEnum<{
+                    neutral: "neutral";
+                    reference: "reference";
+                    target: "target";
+                }>;
+                commit: z.ZodString;
+                tree: z.ZodString;
+                objectFormat: z.ZodEnum<{
+                    sha1: "sha1";
+                    sha256: "sha256";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    controls: z.ZodObject<{
+        executed: z.ZodArray<z.ZodObject<{
+            control: z.ZodEnum<{
+                CONTROL_WITHOUT_CANDIDATE: "CONTROL_WITHOUT_CANDIDATE";
+                NEUTRAL_PASS: "NEUTRAL_PASS";
+                REFERENCE_PASS: "REFERENCE_PASS";
+                REGRESSION_DETECTION: "REGRESSION_DETECTION";
+                STABILITY_REPETITION: "STABILITY_REPETITION";
+            }>;
+            status: z.ZodEnum<{
+                EXECUTED: "EXECUTED";
+                NOT_EXECUTED: "NOT_EXECUTED";
+            }>;
+            observations: z.ZodInt;
+        }, z.core.$strict>>;
+        requested: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"NOT_SUPPLIED">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                COVERED: "COVERED";
+                NOT_COVERED: "NOT_COVERED";
+                NO_OBLIGATIONS: "NO_OBLIGATIONS";
+                PARTIAL: "PARTIAL";
+            }>;
+            obligations: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                control: z.ZodString;
+                coverage: z.ZodEnum<{
+                    EXECUTED: "EXECUTED";
+                    NOT_EXECUTED: "NOT_EXECUTED";
+                    UNSUPPORTED: "UNSUPPORTED";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>]>;
+        omittedGates: z.ZodArray<z.ZodObject<{
+            candidateId: z.ZodString;
+            gate: z.ZodEnum<{
+                COMPLETENESS: "COMPLETENESS";
+                DISCOVERY: "DISCOVERY";
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                STABILITY: "STABILITY";
+                TARGET_STRENGTH: "TARGET_STRENGTH";
+            }>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    profile: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"NOT_REQUESTED">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"UNKNOWN_PROFILE">;
+        requestedProfileId: z.ZodString;
+    }, z.core.$strict>]>;
+    policy: z.ZodObject<{
+        policyVersion: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    cost: z.ZodObject<{
+        estimated: z.ZodObject<{
+            unit: z.ZodLiteral<"PROCESS_EXECUTIONS">;
+            value: z.ZodInt;
+            basis: z.ZodLiteral<"RECORDED_CAMPAIGN_SHAPE">;
+            assumptions: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            unit: z.ZodLiteral<"PROCESS_EXECUTIONS">;
+            executions: z.ZodInt;
+            recordedWallTimeMs: z.ZodNullable<z.ZodNumber>;
+            wallTimeCoverage: z.ZodEnum<{
+                COMPLETE: "COMPLETE";
+                NOT_RECORDED: "NOT_RECORDED";
+                PARTIAL: "PARTIAL";
+            }>;
+        }, z.core.$strict>;
+        execution: z.ZodObject<{
+            freshness: z.ZodLiteral<"UNKNOWN">;
+            cache: z.ZodLiteral<"NOT_RECORDED">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+    exportDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const EvidenceExportReplayResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    schemaValid: z.ZodBoolean;
+    sourceManifestValid: z.ZodBoolean;
+    exportDigestValid: z.ZodBoolean;
+    semanticsValid: 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 VerificationRequestV2 = z.infer<typeof VerificationRequestV2Schema>;
+export type ContainerIsolation = z.infer<typeof ContainerIsolationSchema>;
+export type ContainerLimits = z.infer<typeof ContainerLimitsSchema>;
 export type NodeTestAdapter = z.infer<typeof NodeTestAdapterSchema>;
 export type StructuredCommandAdapter = z.infer<typeof StructuredCommandAdapterSchema>;
 export type RepositoryAnalysis = z.infer<typeof RepositoryAnalysisSchema>;
@@ -3794,6 +4714,8 @@ 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 EvidenceManifestV2Contract = z.infer<typeof EvidenceManifestV2Schema>;
+export type ExecutionBackendRecord = z.infer<typeof ExecutionBackendRecordSchema>;
 export type ReplayResult = z.infer<typeof ReplayResultSchema>;
 export type AgenticProfilePolicy = z.infer<typeof AgenticProfilePolicySchema>;
 export type AgenticProfileRequest = z.infer<typeof AgenticProfileRequestSchema>;
@@ -3829,11 +4751,19 @@ export type AgenticCorpusExperimentReplayRequest = z.infer<typeof AgenticCorpusE
 export type AgenticCorpusExperimentReplayResult = z.infer<typeof AgenticCorpusExperimentReplayResultSchema>;
 export type AgenticCorpusExperimentReceipt = z.infer<typeof AgenticCorpusExperimentReceiptSchema>;
 export type AgenticCorpusExperimentStructuredResult = z.infer<typeof AgenticCorpusExperimentStructuredResultSchema>;
+export type EvidenceProviderManifest = z.infer<typeof EvidenceProviderManifestSchema>;
+export type EvidenceExportRequest = z.infer<typeof EvidenceExportRequestSchema>;
+export type EvidenceExport = z.infer<typeof EvidenceExportSchema>;
+export type EvidenceExportReplayResult = z.infer<typeof EvidenceExportReplayResultSchema>;
 export declare class ContractError extends Error {
     readonly code: string;
     constructor(code: string, detail?: string);
 }
 export declare function parseVerificationRequest(value: unknown): VerificationRequest;
+/** Parses either the frozen v1 request or the v2 request that adds container isolation. */
+export declare function parseVersionedVerificationRequest(value: unknown): VerificationRequest | VerificationRequestV2;
+/** Parses only the v2 request, which adds container isolation to the frozen v1 request. */
+export declare function parseVerificationRequestV2(value: unknown): VerificationRequestV2;
 export declare function parseRepositoryAnalysis(value: unknown): RepositoryAnalysis;
 export declare function parseRepositoryAudit(value: unknown): RepositoryAudit;
 export declare function parseRepositoryInitConfig(value: unknown): RepositoryInitConfig;
@@ -3842,6 +4772,9 @@ export declare function repositoryInitLockDigest(lock: Omit<RepositoryInitLock,
 export declare function parseRepositoryInitLock(value: unknown): RepositoryInitLock;
 export declare function parseRepositoryInitResult(value: unknown): RepositoryInitResult;
 export declare function parseEvidenceManifest(value: unknown): EvidenceManifestContract;
+export declare function parseEvidenceManifestV2(value: unknown): EvidenceManifestV2Contract;
+/** Parses either a frozen v1 manifest or a v2 manifest with an execution backend record. */
+export declare function parseVersionedEvidenceManifest(value: unknown): EvidenceManifestContract | EvidenceManifestV2Contract;
 export declare function parseReplayResult(value: unknown): ReplayResult;
 export declare function parseAgenticProfileRequest(value: unknown): AgenticProfileRequest;
 export declare function parseAgenticProfileReport(value: unknown): AgenticProfileReport;
@@ -3871,6 +4804,10 @@ export declare function parseAgenticCorpusExperimentReplayRequest(value: unknown
 export declare function parseAgenticCorpusExperimentReplayResult(value: unknown): AgenticCorpusExperimentReplayResult;
 export declare function parseAgenticCorpusExperimentReceipt(value: unknown): AgenticCorpusExperimentReceipt;
 export declare function parseAgenticCorpusExperimentStructuredResult(value: unknown): AgenticCorpusExperimentStructuredResult;
+export declare function parseEvidenceProviderManifest(value: unknown): EvidenceProviderManifest;
+export declare function parseEvidenceExportRequest(value: unknown): EvidenceExportRequest;
+export declare function parseEvidenceExport(value: unknown): EvidenceExport;
+export declare function parseEvidenceExportReplayResult(value: unknown): EvidenceExportReplayResult;
 export declare function verificationRequestJsonSchema(): Record<string, unknown>;
 export declare function repositoryAnalysisJsonSchema(): Record<string, unknown>;
 export declare function repositoryAuditJsonSchema(): Record<string, unknown>;
@@ -3878,6 +4815,8 @@ 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 verificationRequestV2JsonSchema(): Record<string, unknown>;
+export declare function evidenceManifestV2JsonSchema(): Record<string, unknown>;
 export declare function replayResultJsonSchema(): Record<string, unknown>;
 export declare function agenticProfileRequestJsonSchema(): Record<string, unknown>;
 export declare function agenticProfileReportJsonSchema(): Record<string, unknown>;
@@ -3905,4 +4844,8 @@ export declare function agenticCorpusExperimentRequestJsonSchema(): Record<strin
 export declare function agenticCorpusExperimentArtifactJsonSchema(): Record<string, unknown>;
 export declare function agenticCorpusExperimentReplayRequestJsonSchema(): Record<string, unknown>;
 export declare function agenticCorpusExperimentReplayResultJsonSchema(): Record<string, unknown>;
+export declare function evidenceProviderManifestJsonSchema(): Record<string, unknown>;
+export declare function evidenceExportRequestJsonSchema(): Record<string, unknown>;
+export declare function evidenceExportJsonSchema(): Record<string, unknown>;
+export declare function evidenceExportReplayResultJsonSchema(): Record<string, unknown>;
 //# sourceMappingURL=index.d.ts.map