assertledger 1.0.0 → 1.1.1

package/dist/contracts/index.js

@@ -71,6 +71,31 @@ export const TrustedLocalIsolationSchema = z.strictObject({
     acknowledgedUnsafeExecution: z.boolean(),
     environmentAllowlist: z.array(EnvironmentVariableSchema).max(100),
 });
+export const VERIFICATION_SCHEMA_VERSION_V2 = "2.0.0";
+// Only digest-pinned references are accepted; the leading alphanumeric also keeps a reference
+// from being parsed as a container runtime option.
+export const ContainerImageReferenceSchema = z
+    .string()
+    .max(512)
+    .regex(/^(?:[A-Za-z0-9][A-Za-z0-9.-]*(?::[0-9]{1,5})?\/)?[a-z0-9]+(?:(?:[._]|__|-+)[a-z0-9]+)*(?:\/[a-z0-9]+(?:(?:[._]|__|-+)[a-z0-9]+)*)*(?::[A-Za-z0-9_][A-Za-z0-9._-]{0,127})?@sha256:[a-f0-9]{64}$/);
+const ContainerEnvironmentVariableSchema = z.strictObject({
+    name: EnvironmentVariableSchema,
+    value: z.string().max(4_096),
+});
+export const ContainerLimitsSchema = z.strictObject({
+    memoryBytes: z.int().min(67_108_864).max(68_719_476_736),
+    cpuMillicores: z.int().min(100).max(256_000),
+    pids: z.int().min(16).max(65_536),
+    temporaryDirectoryBytes: z.int().min(1_048_576).max(17_179_869_184),
+});
+// The host runtime command is operator configuration, never request data: a request cannot choose
+// which host executable starts the container, and it cannot forward host environment values.
+export const ContainerIsolationSchema = z.strictObject({
+    kind: z.literal("container"),
+    image: ContainerImageReferenceSchema,
+    environment: z.array(ContainerEnvironmentVariableSchema).max(100),
+    limits: ContainerLimitsSchema,
+});
 export const BudgetsSchema = z.strictObject({
     maximumCandidates: z.int().min(1).max(1_000),
     maximumWorlds: z.int().min(3).max(1_000),
@@ -110,6 +135,20 @@ export const VerificationRequestSchema = z
     title: "TestForge verification request",
     description: "A versioned campaign describing operator-owned worlds, candidate test overlays, budgets, and evidence policy.",
 });
+export const VerificationRequestV2Schema = z
+    .strictObject({
+    ...VerificationRequestSchema.shape,
+    schemaVersion: z.literal(VERIFICATION_SCHEMA_VERSION_V2),
+    isolation: z.discriminatedUnion("kind", [
+        TrustedLocalIsolationSchema,
+        ContainerIsolationSchema,
+    ]),
+})
+    .meta({
+    id: "https://testforge.dev/schemas/verification-request.v2.json",
+    title: "AssertLedger verification request v2",
+    description: "A versioned campaign executed either in a digest-pinned container backend or in explicitly acknowledged unsandboxed trusted-local mode.",
+});
 export const RepositoryAnalysisSchema = z
     .strictObject({
     root: z.string().min(1),
@@ -388,6 +427,71 @@ export const EvidenceManifestSchema = z
     title: "TestForge evidence manifest",
     description: "The final auditable campaign artifact, including evidence, deterministic gates, decisions, and integrity digests.",
 });
+const ContainerExecutionControlsSchema = z.strictObject({
+    network: z.literal("none"),
+    rootFilesystem: z.literal("read-only"),
+    hostMounts: z.literal("none"),
+    workspace: z.literal("anonymous-volume"),
+    user: z.literal("65534:65534"),
+    capabilities: z.literal("none"),
+    noNewPrivileges: z.literal(true),
+    imagePull: z.literal("never"),
+    logDriver: z.literal("none"),
+    environment: z.array(ContainerEnvironmentVariableSchema).max(100),
+    limits: ContainerLimitsSchema,
+});
+const ExecutionBackendRecordSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("trusted-local"), level: z.literal("UNSANDBOXED") }),
+    z.strictObject({
+        kind: z.literal("container"),
+        level: z.literal("CONTAINER"),
+        image: z.strictObject({
+            reference: ContainerImageReferenceSchema,
+            id: Sha256DigestSchema,
+            os: z.literal("linux"),
+            architecture: z.string().min(1).max(64),
+        }),
+        runtime: z.strictObject({
+            clientVersion: z.string().min(1).max(128),
+            serverVersion: z.string().min(1).max(128),
+            serverOs: z.literal("linux"),
+            serverArchitecture: z.string().min(1).max(64),
+            cgroupVersion: z.string().max(16),
+            securityOptions: z.array(z.string().min(1).max(512)).max(64),
+        }),
+        controls: ContainerExecutionControlsSchema,
+    }),
+]);
+const EvidenceContextV2Schema = z.strictObject({
+    ...EvidenceContextSchema.shape,
+    execution: z.strictObject({
+        ...EvidenceContextSchema.shape.execution.shape,
+        backend: ExecutionBackendRecordSchema,
+    }),
+});
+export const EvidenceManifestV2Schema = z
+    .strictObject({
+    ...EvidenceManifestSchema.shape,
+    schemaVersion: z.literal(VERIFICATION_SCHEMA_VERSION_V2),
+    evidenceContext: EvidenceContextV2Schema,
+    isolation: z.discriminatedUnion("kind", [
+        z.strictObject({
+            kind: z.literal("trusted-local"),
+            level: z.literal("UNSANDBOXED"),
+            acknowledgedUnsafeExecution: z.literal(true),
+        }),
+        z.strictObject({
+            kind: z.literal("container"),
+            level: z.literal("CONTAINER"),
+            runtimeCommand: z.array(z.string().min(1).max(4_096)).min(1).max(16),
+        }),
+    ]),
+})
+    .meta({
+    id: "https://testforge.dev/schemas/evidence-manifest.v2.json",
+    title: "AssertLedger evidence manifest v2",
+    description: "The final auditable campaign artifact with a decision-bound record of the execution backend and its enforced controls.",
+});
 export const ReplayResultSchema = z
     .strictObject({
     valid: z.boolean(),
@@ -1304,6 +1408,297 @@ export const AgenticCorpusExperimentReplayResultSchema = z.strictObject({
     observationSemanticsValid: z.boolean(),
     resultSemanticsValid: z.boolean(),
 });
+const GitObjectIdSchema = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/);
+const EvidenceSourceRevisionSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        status: z.literal("RECORDED"),
+        commit: GitObjectIdSchema,
+        worktree: z.enum(["CLEAN", "DIRTY"]),
+    }),
+    z.strictObject({ status: z.literal("UNKNOWN") }),
+]);
+const EvidenceFormatSchema = z.strictObject({
+    schemaId: z.string().min(1).max(512),
+    schemaVersion: z.string().min(1).max(128),
+});
+export const EvidenceProviderManifestSchema = z
+    .strictObject({
+    schemaVersion: z.literal("1.0.0"),
+    provider: z.strictObject({
+        name: z.literal("assertledger"),
+        version: z.string().min(1).max(128),
+        sourceRevision: EvidenceSourceRevisionSchema,
+    }),
+    scope: z.string().min(1).max(2_048),
+    formats: z.strictObject({
+        accepts: z.array(EvidenceFormatSchema).max(100),
+        emits: z.array(EvidenceFormatSchema).max(100),
+    }),
+    capabilities: z
+        .array(z.strictObject({
+        id: ReasonCodeSchema,
+        status: z.enum(["SUPPORTED", "SUPPORTED_WHEN_RECORDED", "UNSUPPORTED"]),
+        modality: z.enum(["TEST_OBSERVED", "RECORDED_METADATA", "NONE"]),
+        description: z.string().min(1).max(2_048),
+    }))
+        .max(100),
+    adapters: z
+        .array(z.strictObject({
+        kind: z.enum(["node-test", "testforge-command"]),
+        profileId: z.string().min(1).max(128).nullable(),
+        profileVersion: z.string().min(1).max(128).nullable(),
+        official: z.boolean(),
+    }))
+        .max(100),
+    cost: z.strictObject({
+        unit: z.literal("PROCESS_EXECUTIONS"),
+        estimate: z.string().min(1).max(512),
+        assumptions: z.array(z.string().min(1).max(2_048)).max(100),
+    }),
+    limits: z.array(z.string().min(1).max(2_048)).max(100),
+    manifestDigest: Sha256DigestSchema,
+})
+    .meta({
+    id: "https://testforge.dev/schemas/evidence-provider-manifest.v1.json",
+    title: "AssertLedger evidence provider manifest",
+    description: "Announced provider identity, capabilities, formats, cost model, and limits. An announced capability never proves that a control ran.",
+});
+const EvidenceConsumerRequestSchema = z.strictObject({
+    reference: z.string().min(1).max(256).nullable(),
+    profileId: z.string().min(1).max(256).nullable(),
+    obligations: z
+        .array(z.strictObject({ id: IdentifierSchema, control: ReasonCodeSchema }))
+        .max(100),
+});
+export const EvidenceExportRequestSchema = z
+    .strictObject({
+    schemaVersion: z.literal("1.0.0"),
+    manifest: EmbeddedEvidenceManifestSchema,
+    consumerRequest: EvidenceConsumerRequestSchema.nullable(),
+})
+    .meta({
+    id: "https://testforge.dev/schemas/evidence-export-request.v1.json",
+    title: "AssertLedger evidence export request",
+    description: "A replay-valid evidence manifest and optional consumer references and requested controls.",
+});
+const EvidenceWorldKindSchema = z.enum(["REFERENCE", "TARGET", "NEUTRAL"]);
+export const EvidenceExportSchema = z
+    .strictObject({
+    schemaVersion: z.literal("1.0.0"),
+    sourceManifest: EmbeddedEvidenceManifestSchema,
+    sourceArtifactDigest: Sha256DigestSchema,
+    consumerRequest: EvidenceConsumerRequestSchema.nullable(),
+    result: z.strictObject({
+        detection: z.enum(["OBSERVED", "NOT_OBSERVED", "NOT_ESTABLISHED"]),
+        modality: z.enum(["TEST_OBSERVED", "NONE"]),
+        reasonCode: z.enum([
+            "REGRESSION_ASSERTION_OBSERVED",
+            "TARGET_PASSED_WITHOUT_DETECTION",
+            "ENGINE_ERROR",
+            "CONTROL_EVIDENCE_INVALID",
+            "CANDIDATE_EVIDENCE_INCONCLUSIVE",
+            "CANDIDATE_EVIDENCE_INVALID",
+            "TARGET_STRENGTH_INSUFFICIENT",
+            "OPERATIONAL_OUTCOME_NOT_DETECTION",
+        ]),
+        decision: z.strictObject({
+            status: z.enum(["VERIFIED", "REJECTED", "INCONCLUSIVE", "ENGINE_ERROR"]),
+            selectedCandidateIds: z.array(IdentifierSchema),
+            reasonCodes: z.array(ReasonCodeSchema),
+        }),
+        candidates: z.array(z.strictObject({
+            id: IdentifierSchema,
+            digest: Sha256DigestSchema,
+            status: z.enum(["ELIGIBLE", "UNSTABLE", "INCONCLUSIVE", "INVALID", "WEAK_ORACLE"]),
+            selected: z.boolean(),
+            reasonCodes: z.array(ReasonCodeSchema),
+            worlds: z.array(z.strictObject({
+                worldId: IdentifierSchema,
+                kind: EvidenceWorldKindSchema,
+                required: z.boolean(),
+                weight: z.int().min(0).max(1_000_000),
+                outcome: z.enum([
+                    "PASS",
+                    "ASSERTION_FAILURE",
+                    "COLLECTION_FAILURE",
+                    "COMPILE_FAILURE",
+                    "PROCESS_CRASH",
+                    "TIMEOUT",
+                    "INFRA_ERROR",
+                    "NO_TEST_DISCOVERED",
+                    "DIVERGENT",
+                    "MISSING",
+                ]),
+                attempts: z.int().min(0),
+                signal: z.enum(["RED", "GREEN", "NONE"]),
+                detection: z.enum(["OBSERVED", "NOT_OBSERVED", "NOT_ESTABLISHED", "NOT_APPLICABLE"]),
+            })),
+        })),
+    }),
+    integrity: z.strictObject({
+        sourceReplay: z.literal("VALID"),
+        verifiedRails: z.tuple([
+            z.literal("SCHEMA"),
+            z.literal("DECISION_DIGEST"),
+            z.literal("ARTIFACT_DIGEST"),
+            z.literal("DECISION_SEMANTICS"),
+        ]),
+        bindings: z.strictObject({
+            artifactDigest: Sha256DigestSchema,
+            decisionDigest: Sha256DigestSchema,
+            repositoryDigest: z.union([Sha256DigestSchema, z.literal("invalid")]),
+            policyDigest: Sha256DigestSchema,
+            worldDigests: z.array(z.strictObject({ worldId: IdentifierSchema, digest: Sha256DigestSchema })),
+        }),
+    }),
+    authenticity: z.strictObject({
+        status: z.literal("UNAUTHENTICATED"),
+        attestation: z.literal("NONE"),
+        declaredProducer: z.strictObject({
+            name: z.string().min(1).max(128),
+            version: z.string().min(1).max(128),
+        }),
+    }),
+    environment: z.strictObject({
+        isolation: z.strictObject({
+            kind: z.literal("trusted-local"),
+            level: z.literal("UNSANDBOXED"),
+        }),
+        environmentAllowlist: z.array(z.string().min(1).max(128)).max(100),
+        adapter: z.strictObject({
+            kind: z.enum(["node-test", "testforge-command"]),
+            name: z.string().min(1).max(128),
+            version: z.string().min(1).max(128),
+            framework: z.discriminatedUnion("status", [
+                z.strictObject({
+                    status: z.literal("RECORDED"),
+                    profileId: z.string().min(1).max(128),
+                    profileVersion: z.string().min(1).max(128),
+                    official: z.boolean(),
+                    nodeVersion: z.string().min(1).max(128).nullable(),
+                    executableDigest: Sha256DigestSchema.nullable(),
+                }),
+                z.strictObject({ status: z.literal("UNKNOWN") }),
+            ]),
+        }),
+    }),
+    confidence: z.strictObject({
+        level: z.literal("REPLAY_CONSISTENT_UNAUTHENTICATED"),
+        established: z.array(z.enum([
+            "SOURCE_SCHEMA_VALID",
+            "DECISION_DIGEST_RECOMPUTED",
+            "ARTIFACT_DIGEST_RECOMPUTED",
+            "DECISION_RECOMPUTED_FROM_RECORDED_OBSERVATIONS",
+        ])),
+        notEstablished: z.array(z.enum([
+            "PRODUCER_AUTHENTICITY",
+            "OBSERVATION_TRUTHFULNESS",
+            "EXECUTION_ISOLATION",
+            "EXECUTION_FRESHNESS",
+            "WORLD_SEMANTIC_RELEVANCE",
+        ])),
+    }),
+    scope: z.strictObject({
+        requiredAttempts: z.int().min(1).max(1_000),
+        candidates: z.int().min(0),
+        observations: z.int().min(0),
+        gitRevisions: z.enum(["RECORDED", "PARTIAL", "NOT_RECORDED"]),
+        worlds: z.array(z.strictObject({
+            id: IdentifierSchema,
+            kind: EvidenceWorldKindSchema,
+            required: z.boolean(),
+            weight: z.int().min(0).max(1_000_000),
+            digest: Sha256DigestSchema,
+            declaredProvenance: z.string().min(1).max(1_024),
+            git: z
+                .strictObject({
+                role: z.enum(["reference", "target", "neutral"]),
+                commit: GitObjectIdSchema,
+                tree: GitObjectIdSchema,
+                objectFormat: z.enum(["sha1", "sha256"]),
+            })
+                .nullable(),
+        })),
+    }),
+    controls: z.strictObject({
+        executed: z.array(z.strictObject({
+            control: z.enum([
+                "CONTROL_WITHOUT_CANDIDATE",
+                "REFERENCE_PASS",
+                "REGRESSION_DETECTION",
+                "NEUTRAL_PASS",
+                "STABILITY_REPETITION",
+            ]),
+            status: z.enum(["EXECUTED", "NOT_EXECUTED"]),
+            observations: z.int().min(0),
+        })),
+        requested: z.union([
+            z.strictObject({ status: z.literal("NOT_SUPPLIED") }),
+            z.strictObject({
+                status: z.enum(["NO_OBLIGATIONS", "COVERED", "PARTIAL", "NOT_COVERED"]),
+                obligations: z.array(z.strictObject({
+                    id: IdentifierSchema,
+                    control: ReasonCodeSchema,
+                    coverage: z.enum(["EXECUTED", "NOT_EXECUTED", "UNSUPPORTED"]),
+                })),
+            }),
+        ]),
+        omittedGates: z.array(z.strictObject({
+            candidateId: IdentifierSchema,
+            gate: GateResultSchema.shape.name,
+            reasonCodes: z.array(ReasonCodeSchema),
+        })),
+    }),
+    profile: z.union([
+        z.strictObject({ status: z.literal("NOT_REQUESTED") }),
+        z.strictObject({
+            status: z.literal("UNKNOWN_PROFILE"),
+            requestedProfileId: z.string().min(1).max(256),
+        }),
+    ]),
+    policy: z.strictObject({
+        policyVersion: z.string().min(1).max(128),
+        digest: Sha256DigestSchema,
+    }),
+    cost: z.strictObject({
+        estimated: z.strictObject({
+            unit: z.literal("PROCESS_EXECUTIONS"),
+            value: z.int().min(0),
+            basis: z.literal("RECORDED_CAMPAIGN_SHAPE"),
+            assumptions: z.array(z.string().min(1).max(2_048)),
+        }),
+        observed: z.strictObject({
+            unit: z.literal("PROCESS_EXECUTIONS"),
+            executions: z.int().min(0),
+            recordedWallTimeMs: z.number().finite().min(0).nullable(),
+            wallTimeCoverage: z.enum(["COMPLETE", "PARTIAL", "NOT_RECORDED"]),
+        }),
+        execution: z.strictObject({
+            freshness: z.literal("UNKNOWN"),
+            cache: z.literal("NOT_RECORDED"),
+        }),
+    }),
+    limitations: z.array(z.string().min(1).max(2_048)),
+    exportDigest: Sha256DigestSchema,
+})
+    .meta({
+    id: "https://testforge.dev/schemas/evidence-export.v1.json",
+    title: "AssertLedger evidence export",
+    description: "A self-contained, replayable projection of replay-valid evidence that separates result, integrity, authenticity, environment, confidence, controls, and cost.",
+});
+export const EvidenceExportReplayResultSchema = z
+    .strictObject({
+    valid: z.boolean(),
+    schemaValid: z.boolean(),
+    sourceManifestValid: z.boolean(),
+    exportDigestValid: z.boolean(),
+    semanticsValid: z.boolean(),
+})
+    .meta({
+    id: "https://testforge.dev/schemas/evidence-export-replay-result.v1.json",
+    title: "AssertLedger evidence export replay result",
+    description: "Independent schema, source, digest, and semantic replay verdicts for an export.",
+});
 export class ContractError extends Error {
     code;
     constructor(code, detail) {
@@ -1389,13 +1784,20 @@ function findReservedEnvironmentVariable(value) {
     if (typeof value !== "object" || value === null || !("isolation" in value))
         return undefined;
     const isolation = value.isolation;
-    if (typeof isolation !== "object" ||
-        isolation === null ||
-        !("environmentAllowlist" in isolation) ||
-        !Array.isArray(isolation.environmentAllowlist)) {
+    if (typeof isolation !== "object" || isolation === null)
         return undefined;
+    const names = [];
+    if ("environmentAllowlist" in isolation && Array.isArray(isolation.environmentAllowlist)) {
+        names.push(...isolation.environmentAllowlist);
+    }
+    if ("environment" in isolation && Array.isArray(isolation.environment)) {
+        for (const variable of isolation.environment) {
+            if (typeof variable === "object" && variable !== null && "name" in variable) {
+                names.push(variable.name);
+            }
+        }
     }
-    return isolation.environmentAllowlist.find((variable) => {
+    return names.find((variable) => {
         if (typeof variable !== "string")
             return false;
         const normalized = variable.toUpperCase();
@@ -1411,6 +1813,55 @@ export function parseVerificationRequest(value) {
         value.schemaVersion !== SCHEMA_VERSION) {
         throw new ContractError("SCHEMA_VERSION_UNSUPPORTED");
     }
+    assertVerificationRequestPreconditions(value);
+    const parsed = VerificationRequestSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("REQUEST_SCHEMA_INVALID", z.prettifyError(parsed.error));
+    }
+    const request = parsed.data;
+    assertUniqueIdentifiers(request.worlds, "DUPLICATE_WORLD_ID");
+    assertUniqueIdentifiers(request.candidates, "DUPLICATE_CANDIDATE_ID");
+    assertWorldKinds(request);
+    assertBudgets(request);
+    return request;
+}
+/** Parses either the frozen v1 request or the v2 request that adds container isolation. */
+export function parseVersionedVerificationRequest(value) {
+    if (typeof value === "object" &&
+        value !== null &&
+        "schemaVersion" in value &&
+        value.schemaVersion === VERIFICATION_SCHEMA_VERSION_V2) {
+        return parseVerificationRequestV2(value);
+    }
+    return parseVerificationRequest(value);
+}
+/** Parses only the v2 request, which adds container isolation to the frozen v1 request. */
+export function parseVerificationRequestV2(value) {
+    if (typeof value !== "object" ||
+        value === null ||
+        !("schemaVersion" in value) ||
+        value.schemaVersion !== VERIFICATION_SCHEMA_VERSION_V2) {
+        throw new ContractError("SCHEMA_VERSION_UNSUPPORTED");
+    }
+    assertVerificationRequestPreconditions(value);
+    const parsed = VerificationRequestV2Schema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("REQUEST_SCHEMA_INVALID", z.prettifyError(parsed.error));
+    }
+    const request = parsed.data;
+    assertUniqueIdentifiers(request.worlds, "DUPLICATE_WORLD_ID");
+    assertUniqueIdentifiers(request.candidates, "DUPLICATE_CANDIDATE_ID");
+    assertWorldKinds(request);
+    assertBudgets(request);
+    if (request.isolation.kind === "container") {
+        const names = request.isolation.environment.map((variable) => variable.name);
+        if (new Set(names).size !== names.length) {
+            throw new ContractError("DUPLICATE_CONTAINER_ENVIRONMENT_VARIABLE");
+        }
+    }
+    return request;
+}
+function assertVerificationRequestPreconditions(value) {
     const rawPolicy = "policy" in value ? value.policy : undefined;
     if (typeof rawPolicy === "object" &&
         rawPolicy !== null &&
@@ -1427,16 +1878,6 @@ export function parseVerificationRequest(value) {
     if (reservedEnvironmentVariable !== undefined) {
         throw new ContractError("RESERVED_ENVIRONMENT_VARIABLE", reservedEnvironmentVariable);
     }
-    const parsed = VerificationRequestSchema.safeParse(value);
-    if (!parsed.success) {
-        throw new ContractError("REQUEST_SCHEMA_INVALID", z.prettifyError(parsed.error));
-    }
-    const request = parsed.data;
-    assertUniqueIdentifiers(request.worlds, "DUPLICATE_WORLD_ID");
-    assertUniqueIdentifiers(request.candidates, "DUPLICATE_CANDIDATE_ID");
-    assertWorldKinds(request);
-    assertBudgets(request);
-    return request;
 }
 export function parseRepositoryAnalysis(value) {
     const parsed = RepositoryAnalysisSchema.safeParse(value);
@@ -1882,12 +2323,48 @@ export function parseEvidenceManifest(value) {
         throw new ContractError("EVIDENCE_MANIFEST_INVALID", z.prettifyError(parsed.error));
     }
     const manifest = parsed.data;
+    if (!manifestSummariesAreConsistent(manifest) || !manifestReferencesAreConsistent(manifest)) {
+        throw new ContractError("EVIDENCE_MANIFEST_INCONSISTENT");
+    }
+    return manifest;
+}
+export function parseEvidenceManifestV2(value) {
+    const parsed = EvidenceManifestV2Schema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("EVIDENCE_MANIFEST_INVALID", z.prettifyError(parsed.error));
+    }
+    const manifest = parsed.data;
+    if (!manifestSummariesAreConsistent(manifest) ||
+        !manifestReferencesAreConsistent(manifest) ||
+        !executionBackendIsConsistent(manifest)) {
+        throw new ContractError("EVIDENCE_MANIFEST_INCONSISTENT");
+    }
+    return manifest;
+}
+/** Parses either a frozen v1 manifest or a v2 manifest with an execution backend record. */
+export function parseVersionedEvidenceManifest(value) {
+    return isJsonObject(value) && value.schemaVersion === VERIFICATION_SCHEMA_VERSION_V2
+        ? parseEvidenceManifestV2(value)
+        : parseEvidenceManifest(value);
+}
+function executionBackendIsConsistent(manifest) {
+    const execution = manifest.evidenceContext.execution;
+    const backend = execution.backend;
+    if (backend.kind !== manifest.isolation.kind || backend.level !== manifest.isolation.level) {
+        return false;
+    }
+    if (backend.kind !== "container")
+        return true;
+    const names = backend.controls.environment.map((variable) => variable.name);
+    return (new Set(names).size === names.length &&
+        JSON.stringify([...names].sort()) === JSON.stringify(execution.environmentAllowlist));
+}
+function manifestReferencesAreConsistent(manifest) {
     const worldIds = new Set(manifest.worlds.map((world) => world.id));
     const candidateIds = new Set(manifest.candidates.map((candidate) => candidate.id));
     const runIds = new Set(manifest.observations.map((observation) => observation.runId));
     const contextWorldIds = new Set(manifest.evidenceContext.worlds.map((world) => world.id));
-    const inconsistent = !manifestSummariesAreConsistent(manifest) ||
-        worldIds.size !== manifest.worlds.length ||
+    const inconsistent = worldIds.size !== manifest.worlds.length ||
         candidateIds.size !== manifest.candidates.length ||
         runIds.size !== manifest.observations.length ||
         contextWorldIds.size !== manifest.evidenceContext.worlds.length ||
@@ -1899,10 +2376,7 @@ export function parseEvidenceManifest(value) {
             (observation.candidateId !== null && !candidateIds.has(observation.candidateId))) ||
         manifest.candidates.some((candidate) => candidate.killedTargetIds.some((id) => !worldIds.has(id)) ||
             candidate.gates.some((gate) => gate.evidenceRunIds.some((id) => !runIds.has(id))));
-    if (inconsistent) {
-        throw new ContractError("EVIDENCE_MANIFEST_INCONSISTENT");
-    }
-    return manifest;
+    return !inconsistent;
 }
 export function parseReplayResult(value) {
     const parsed = ReplayResultSchema.safeParse(value);
@@ -2453,6 +2927,54 @@ export function parseAgenticCorpusExperimentStructuredResult(value) {
     }
     return parsed.data;
 }
+export function parseEvidenceProviderManifest(value) {
+    const parsed = EvidenceProviderManifestSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("EVIDENCE_PROVIDER_MANIFEST_INVALID", z.prettifyError(parsed.error));
+    }
+    const capabilityIds = new Set(parsed.data.capabilities.map((capability) => capability.id));
+    if (capabilityIds.size !== parsed.data.capabilities.length) {
+        throw new ContractError("EVIDENCE_PROVIDER_MANIFEST_INCONSISTENT");
+    }
+    return parsed.data;
+}
+export function parseEvidenceExportRequest(value) {
+    const parsed = EvidenceExportRequestSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("EVIDENCE_EXPORT_REQUEST_INVALID", z.prettifyError(parsed.error));
+    }
+    const request = parsed.data;
+    parseEvidenceManifest(request.manifest);
+    assertUniqueIdentifiers(request.consumerRequest?.obligations ?? [], "EVIDENCE_EXPORT_REQUEST_INVALID");
+    return request;
+}
+export function parseEvidenceExport(value) {
+    const parsed = EvidenceExportSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("EVIDENCE_EXPORT_INVALID", z.prettifyError(parsed.error));
+    }
+    const evidenceExport = parsed.data;
+    parseEvidenceManifest(evidenceExport.sourceManifest);
+    assertUniqueIdentifiers(evidenceExport.result.candidates, "EVIDENCE_EXPORT_INCONSISTENT");
+    assertUniqueIdentifiers(evidenceExport.scope.worlds, "EVIDENCE_EXPORT_INCONSISTENT");
+    assertUniqueIdentifiers(evidenceExport.consumerRequest?.obligations ?? [], "EVIDENCE_EXPORT_INCONSISTENT");
+    return evidenceExport;
+}
+export function parseEvidenceExportReplayResult(value) {
+    const parsed = EvidenceExportReplayResultSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new ContractError("EVIDENCE_EXPORT_REPLAY_RESULT_INVALID", z.prettifyError(parsed.error));
+    }
+    const result = parsed.data;
+    if (result.valid !==
+        (result.schemaValid &&
+            result.sourceManifestValid &&
+            result.exportDigestValid &&
+            result.semanticsValid)) {
+        throw new ContractError("EVIDENCE_EXPORT_REPLAY_RESULT_INCONSISTENT");
+    }
+    return result;
+}
 function jsonSchemaFor(schema, id) {
     const generated = z.toJSONSchema(schema, {
         target: "draft-2020-12",
@@ -2485,6 +3007,12 @@ export function repositoryInitResultJsonSchema() {
 export function evidenceManifestJsonSchema() {
     return jsonSchemaFor(EvidenceManifestSchema, "https://testforge.dev/schemas/evidence-manifest.v1.json");
 }
+export function verificationRequestV2JsonSchema() {
+    return jsonSchemaFor(VerificationRequestV2Schema, "https://testforge.dev/schemas/verification-request.v2.json");
+}
+export function evidenceManifestV2JsonSchema() {
+    return jsonSchemaFor(EvidenceManifestV2Schema, "https://testforge.dev/schemas/evidence-manifest.v2.json");
+}
 export function replayResultJsonSchema() {
     return jsonSchemaFor(ReplayResultSchema, "https://testforge.dev/schemas/replay-result.v1.json");
 }
@@ -2566,4 +3094,16 @@ export function agenticCorpusExperimentReplayRequestJsonSchema() {
 export function agenticCorpusExperimentReplayResultJsonSchema() {
     return jsonSchemaFor(AgenticCorpusExperimentReplayResultSchema, "https://testforge.dev/schemas/agentic-corpus-experiment-replay-result.v1.json");
 }
+export function evidenceProviderManifestJsonSchema() {
+    return jsonSchemaFor(EvidenceProviderManifestSchema, "https://testforge.dev/schemas/evidence-provider-manifest.v1.json");
+}
+export function evidenceExportRequestJsonSchema() {
+    return jsonSchemaFor(EvidenceExportRequestSchema, "https://testforge.dev/schemas/evidence-export-request.v1.json");
+}
+export function evidenceExportJsonSchema() {
+    return jsonSchemaFor(EvidenceExportSchema, "https://testforge.dev/schemas/evidence-export.v1.json");
+}
+export function evidenceExportReplayResultJsonSchema() {
+    return jsonSchemaFor(EvidenceExportReplayResultSchema, "https://testforge.dev/schemas/evidence-export-replay-result.v1.json");
+}
 //# sourceMappingURL=index.js.map