rea-agents 3.0.0 → 3.2.0

package/dist/domain/protocolCapture.js

@@ -59,7 +59,7 @@ export const protocolCaptureSchema = z.strictObject({
     /** Protocol family for this capture. */
     family: protocolFamilySchema,
     /** Captured messages in order. */
-    messages: z.array(protocolMessageSchema).min(0).max(10_000),
+    messages: z.array(protocolMessageSchema).min(0),
     /** Aggregated schema hypotheses across all messages. */
     inferred_schema: z.array(schemaHypothesisSchema).default([]),
     /** Whether any message was truncated. */
@@ -109,7 +109,7 @@ export function looksLikeCredential(path) {
 /** Decode a JSON-RPC message from raw payload bytes. */
 export function decodeJsonRpc(rawPayload) {
     const text = new TextDecoder().decode(rawPayload);
-    const parsed = JSON.parse(text);
+    const parsed = jsonValueSchema.parse(JSON.parse(text));
     const fields = [];
     if (typeof parsed === "object" && parsed !== null) {
         for (const [key, value] of Object.entries(parsed)) {
@@ -125,7 +125,7 @@ export function decodeJsonRpc(rawPayload) {
                 fields.push({
                     path: key,
                     wire_type: "json",
-                    value: value,
+                    value,
                     inferred: false,
                 });
             }
@@ -141,6 +141,8 @@ export function decodeMessagePack(rawPayload) {
         return { decoded_fields: [], truncated: false };
     }
     const tag = rawPayload[0];
+    if (tag === undefined)
+        return { decoded_fields: [], truncated: false };
     // Map type: 0x80-0x8f (fixmap), 0xde (map16), 0xdf (map32)
     if ((tag >= 0x80 && tag <= 0x8f) || tag === 0xde || tag === 0xdf) {
         fields.push({
@@ -169,7 +171,7 @@ export function decodeMessagePack(rawPayload) {
     }
     return {
         decoded_fields: fields,
-        truncated: rawPayload.length > 10_000,
+        truncated: false,
     };
 }
 /** Decode a gRPC frame (5-byte header + protobuf payload). */
@@ -189,10 +191,10 @@ export function decodeGrpcFrame(rawPayload) {
         };
     }
     const compressed = rawPayload[0] !== 0;
-    const length = (rawPayload[1] << 24) |
-        (rawPayload[2] << 16) |
-        (rawPayload[3] << 8) |
-        rawPayload[4];
+    const length = ((rawPayload[1] ?? 0) << 24) |
+        ((rawPayload[2] ?? 0) << 16) |
+        ((rawPayload[3] ?? 0) << 8) |
+        (rawPayload[4] ?? 0);
     return {
         decoded_fields: [
             {
@@ -208,7 +210,7 @@ export function decodeGrpcFrame(rawPayload) {
                 inferred: false,
             },
         ],
-        truncated: length > 10_000,
+        truncated: false,
     };
 }
 /** Infer schema hypotheses from a set of decoded messages. */

package/dist/domain/reconstructionCoverage.js

@@ -2,11 +2,11 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 import { evidenceBundleSchema, parseEvidenceBundle } from "./evidenceBundle.js";
-import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionWorkspaceRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.js";
+import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionCoverageRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
-const boundedTextSchema = z.string().trim().min(1).max(4_096);
+const boundedTextSchema = z.string().trim().min(1);
 const authoritySchema = z.enum([
     "observed",
     "derived",
@@ -17,24 +17,24 @@ const authoritySchema = z.enum([
 const artifactSchema = z.strictObject({
     artifact_id: stableIdSchema,
     artifact_sha256: digestSchema,
-    version: z.string().trim().min(1).max(500),
+    version: z.string().trim().min(1),
     environment_sha256: digestSchema,
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const surfaceSchema = z.strictObject({
     surface_id: stableIdSchema,
-    family: z.string().trim().min(1).max(100),
+    family: z.string().trim().min(1),
     artifact_id: stableIdSchema,
-    occurrence_id: z.string().trim().min(1).max(500).nullable(),
+    occurrence_id: z.string().trim().min(1).nullable(),
     location: boundedTextSchema,
     authority: authoritySchema,
-    dependency_surface_ids: z.array(stableIdSchema).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    dependency_surface_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const implementationOwnerSchema = z.strictObject({
     disposition: z.literal("implemented"),
     owner_path: boundedTextSchema,
-    owner_export: z.string().trim().min(1).max(500).nullable(),
+    owner_export: z.string().trim().min(1).nullable(),
     owner_sha256: digestSchema,
     path_state: z.enum(["present", "missing", "unknown"]),
     package_state: z.enum(["distributed", "missing", "unknown"]),
@@ -53,10 +53,10 @@ const ownerSchema = z.strictObject({
 });
 const claimSchema = z.strictObject({
     claim_id: stableIdSchema,
-    title: z.string().trim().min(1).max(500),
-    kind: z.string().trim().min(1).max(100),
-    surface_ids: z.array(stableIdSchema).min(1).max(1_000),
-    required_dimensions: z.array(stableIdSchema).min(1).max(100),
+    title: z.string().trim().min(1),
+    kind: z.string().trim().min(1),
+    surface_ids: z.array(stableIdSchema).min(1),
+    required_dimensions: z.array(stableIdSchema).min(1),
     required_authority: z.enum([
         "shipped-artifact",
         "controlled-replay",
@@ -66,16 +66,16 @@ const claimSchema = z.strictObject({
 });
 const verifierContractBaseSchema = z.strictObject({
     verifier_id: stableIdSchema,
-    claim_ids: z.array(stableIdSchema).min(1).max(1_000),
-    dimensions: z.array(stableIdSchema).min(1).max(100),
+    claim_ids: z.array(stableIdSchema).min(1),
+    dimensions: z.array(stableIdSchema).min(1),
     authority: z.enum([
         "shipped-artifact",
         "controlled-replay",
         "live-observation",
         "external",
     ]),
-    max_age_ms: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-    minimum_repeats: z.number().int().min(1).max(1_000),
+    max_age_ms: z.number().int().min(1),
+    minimum_repeats: z.number().int().min(1),
     normalization_sha256: digestSchema,
     normalization_removes_dimensions: z.literal(false),
 });
@@ -94,20 +94,20 @@ const verifierResultSchema = z.strictObject({
         "truncated",
         "skipped",
     ]),
-    covered_claim_ids: z.array(stableIdSchema).min(1).max(1_000),
-    covered_dimensions: z.array(stableIdSchema).min(1).max(100),
-    artifact_sha256s: z.array(digestSchema).min(1).max(1_000),
-    owner_sha256s: z.array(digestSchema).max(1_000),
+    covered_claim_ids: z.array(stableIdSchema).min(1),
+    covered_dimensions: z.array(stableIdSchema).min(1),
+    artifact_sha256s: z.array(digestSchema).min(1),
+    owner_sha256s: z.array(digestSchema),
     normalization_sha256: digestSchema,
-    repeats: z.number().int().min(1).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    repeats: z.number().int().min(1),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const contradictionSchema = z.strictObject({
     contradiction_id: stableIdSchema,
     status: z.enum(["active", "resolved"]),
-    surface_ids: z.array(stableIdSchema).max(1_000),
-    claim_ids: z.array(stableIdSchema).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(2).max(1_000),
+    surface_ids: z.array(stableIdSchema),
+    claim_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(2),
 });
 const packageProofSchema = z.strictObject({
     proof_id: stableIdSchema,
@@ -119,40 +119,37 @@ const packageProofSchema = z.strictObject({
         "authority-independence",
     ]),
     status: z.enum(["pass", "fail", "unknown", "unsupported", "skipped"]),
-    artifact_sha256s: z.array(digestSchema).min(1).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    artifact_sha256s: z.array(digestSchema).min(1),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const boundarySchema = z.strictObject({
     boundary_id: stableIdSchema,
-    title: z.string().trim().min(1).max(500),
-    required_surface_ids: z.array(stableIdSchema).min(1).max(10_000),
-    required_claim_ids: z.array(stableIdSchema).min(1).max(10_000),
-    required_package_proof_kinds: z
-        .array(packageProofSchema.shape.kind)
-        .min(1)
-        .max(5),
-    allowed_dispositions: z.array(z.enum(["external", "non-goal"])).max(2),
-    allowed_unknown_ids: z.array(stableIdSchema).max(1_000),
+    title: z.string().trim().min(1),
+    required_surface_ids: z.array(stableIdSchema).min(1),
+    required_claim_ids: z.array(stableIdSchema).min(1),
+    required_package_proof_kinds: z.array(packageProofSchema.shape.kind).min(1),
+    allowed_dispositions: z.array(z.enum(["external", "non-goal"])),
+    allowed_unknown_ids: z.array(stableIdSchema),
 });
-const workspaceSemanticSchema = z.strictObject({
-    schema_version: z.literal(1),
-    workspace_id: z.string().regex(/^rcw_[a-f0-9]{64}$/u),
-    name: z.string().trim().min(1).max(200),
-    revision: z.number().int().min(1),
-    previous_revision_sha256: digestSchema.nullable(),
+export const reconstructionCoverageDataSchema = z.strictObject({
     evidence_bundle: evidenceBundleSchema,
-    artifacts: z.array(artifactSchema).max(1_000),
-    surfaces: z.array(surfaceSchema).max(10_000),
-    owners: z.array(ownerSchema).max(10_000),
-    claims: z.array(claimSchema).max(10_000),
-    verifier_contracts: z.array(verifierContractSchema).max(10_000),
-    verifier_results: z.array(verifierResultSchema).max(100_000),
-    residual_unknown_ids: z.array(stableIdSchema).max(10_000),
-    contradictions: z.array(contradictionSchema).max(10_000),
-    package_proofs: z.array(packageProofSchema).max(10_000),
-    boundaries: z.array(boundarySchema).max(1_000),
+    artifacts: z.array(artifactSchema),
+    surfaces: z.array(surfaceSchema),
+    owners: z.array(ownerSchema),
+    claims: z.array(claimSchema),
+    verifier_contracts: z.array(verifierContractSchema),
+    verifier_results: z.array(verifierResultSchema),
+    residual_unknown_ids: z.array(stableIdSchema),
+    contradictions: z.array(contradictionSchema),
+    package_proofs: z.array(packageProofSchema),
+    boundaries: z.array(boundarySchema),
 });
-export const reconstructionCoverageWorkspaceSchema = workspaceSemanticSchema.extend({ revision_sha256: digestSchema });
+/** Parse inline coverage data and validate every evidence and authority link. */
+export const createReconstructionCoverageData = (input) => {
+    const coverage = reconstructionCoverageDataSchema.parse(input);
+    validateCoverageReferences(coverage);
+    return coverage;
+};
 const closureReasonSchema = z.strictObject({
     code: z.enum([
         "surface-missing",
@@ -186,21 +183,18 @@ const closureReasonSchema = z.strictObject({
 export const reconstructionClosureResultSchema = z.strictObject({
     boundary_id: stableIdSchema,
     status: z.enum(["partial", "failed", "unknown", "ready"]),
-    workspace_revision_sha256: digestSchema,
     summary: z.strictObject({
         required_surfaces: z.number().int().min(0),
         required_claims: z.number().int().min(0),
         reasons: z.number().int().min(0),
     }),
-    reasons: z.array(closureReasonSchema).max(100_000),
-    recommended_probes: z
-        .array(z.strictObject({
+    reasons: z.array(closureReasonSchema),
+    recommended_probes: z.array(z.strictObject({
         operation: stableIdSchema,
         subject_id: stableIdSchema,
         rationale: boundedTextSchema,
-    }))
-        .max(100_000),
-    evidence_ids: z.array(evidenceIdSchema).max(100_000),
+    })),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 /** Build a verifier contract whose digest prevents retrospective coverage edits. */
 export const createReconstructionVerifierContract = (input) => {
@@ -210,60 +204,14 @@ export const createReconstructionVerifierContract = (input) => {
         contract_sha256: digest(parsed),
     });
 };
-/** Build one canonical immutable coverage-workspace revision. */
-export const createReconstructionCoverageWorkspace = (input) => {
-    const semanticInput = {
-        schema_version: 1,
-        workspace_id: `rcw_${digest({ schema: "rea.reconstruction-coverage-workspace/v1", name: input.name })}`,
-        ...input,
-    };
-    const semantic = canonicalWorkspace(workspaceSemanticSchema.parse(semanticInput));
-    validateWorkspaceReferences(semantic);
-    return reconstructionCoverageWorkspaceSchema.parse({
-        ...semantic,
-        revision_sha256: digest(semantic),
-    });
-};
-/** Parse persisted coverage state and verify canonical order, references, and digests. */
-export const parseReconstructionCoverageWorkspace = (input) => {
-    const parsed = reconstructionCoverageWorkspaceSchema.parse(input);
-    const rebuilt = createReconstructionCoverageWorkspace({
-        name: parsed.name,
-        revision: parsed.revision,
-        previous_revision_sha256: parsed.previous_revision_sha256,
-        evidence_bundle: parsed.evidence_bundle,
-        artifacts: parsed.artifacts,
-        surfaces: parsed.surfaces,
-        owners: parsed.owners,
-        claims: parsed.claims,
-        verifier_contracts: parsed.verifier_contracts,
-        verifier_results: parsed.verifier_results,
-        residual_unknown_ids: parsed.residual_unknown_ids,
-        contradictions: parsed.contradictions,
-        package_proofs: parsed.package_proofs,
-        boundaries: parsed.boundaries,
-    });
-    if (parsed.workspace_id !== rebuilt.workspace_id ||
-        parsed.revision_sha256 !== rebuilt.revision_sha256 ||
-        JSON.stringify(parsed) !== JSON.stringify(rebuilt))
-        throw new TypeError("Reconstruction coverage workspace is not canonical");
-    return rebuilt;
-};
-/** Serialize one validated coverage revision as byte-stable canonical JSON. */
-export const serializeReconstructionCoverageWorkspace = (workspace) => {
-    const encoded = canonicalize(parseReconstructionCoverageWorkspace(workspace));
-    if (encoded === undefined)
-        throw new TypeError("Reconstruction coverage workspace is not canonical JSON");
-    return encoded;
-};
-/** Evaluate one named completion boundary without inferring undiscovered coverage. */
-export const evaluateReconstructionClosure = (workspaceInput, boundaryId, nowEpochMs) => {
-    const workspace = parseReconstructionCoverageWorkspace(workspaceInput);
-    const boundary = workspace.boundaries.find(({ boundary_id: id }) => id === boundaryId);
+/** Evaluate inline coverage data against one named fail-closed boundary. */
+export const evaluateReconstructionClosure = (coverageInput, boundaryId, nowEpochMs) => {
+    const coverage = createReconstructionCoverageData(coverageInput);
+    const boundary = coverage.boundaries.find(({ boundary_id: id }) => id === boundaryId);
     if (boundary === undefined)
         throw new TypeError(`Unknown reconstruction boundary: ${boundaryId}`);
     const context = {
-        workspace,
+        coverage,
         boundary,
         nowEpochMs,
         reasons: [],
@@ -271,13 +219,12 @@ export const evaluateReconstructionClosure = (workspaceInput, boundaryId, nowEpo
     };
     evaluateReconstructionSurfaces(context);
     evaluateReconstructionClaims(context);
-    evaluateReconstructionWorkspaceRisks(context);
+    evaluateReconstructionCoverageRisks(context);
     evaluateReconstructionPackageProofs(context);
     const reasons = [...context.reasons].sort(reasonOrder);
     return reconstructionClosureResultSchema.parse({
         boundary_id: boundary.boundary_id,
         status: closureStatus(reasons),
-        workspace_revision_sha256: workspace.revision_sha256,
         summary: {
             required_surfaces: boundary.required_surface_ids.length,
             required_claims: boundary.required_claim_ids.length,
@@ -288,7 +235,7 @@ export const evaluateReconstructionClosure = (workspaceInput, boundaryId, nowEpo
         evidence_ids: [...context.evidenceIds].sort(),
     });
 };
-const validateWorkspaceReferences = (workspace) => {
+const validateCoverageReferences = (workspace) => {
     const evidenceBundle = parseEvidenceBundle(workspace.evidence_bundle);
     const evidenceIds = new Set(evidenceBundle.records.map(({ evidence_id: id }) => id));
     const unknownIds = new Set(evidenceBundle.unknowns.map(({ unknown_id: id }) => id));
@@ -333,20 +280,6 @@ const validateWorkspaceReferences = (workspace) => {
     if (danglingUnknown !== undefined)
         throw new TypeError(`Coverage workspace residual unknown is missing: ${danglingUnknown}`);
 };
-const canonicalWorkspace = (workspace) => ({
-    ...workspace,
-    artifacts: sorted(workspace.artifacts, "artifact_id"),
-    surfaces: sorted(workspace.surfaces, "surface_id"),
-    owners: [...workspace.owners].sort((left, right) => left.surface_id.localeCompare(right.surface_id)),
-    claims: sorted(workspace.claims, "claim_id"),
-    verifier_contracts: sorted(workspace.verifier_contracts, "verifier_id"),
-    verifier_results: [...workspace.verifier_results].sort((left, right) => `${left.verifier_id}:${left.observed_at}`.localeCompare(`${right.verifier_id}:${right.observed_at}`)),
-    residual_unknown_ids: [...new Set(workspace.residual_unknown_ids)].sort(),
-    contradictions: sorted(workspace.contradictions, "contradiction_id"),
-    package_proofs: sorted(workspace.package_proofs, "proof_id"),
-    boundaries: sorted(workspace.boundaries, "boundary_id"),
-});
-const sorted = (items, key) => [...items].sort((left, right) => left[key].localeCompare(right[key]));
 const assertUnique = (items, key) => {
     const values = items.map((item) => item[key]);
     if (new Set(values).size !== values.length)

package/dist/domain/reconstructionCoverageEvaluation.js

@@ -1,4 +1,4 @@
-export const recommendedReconstructionProbes = (reasons) => reasons.slice(0, 100).map((reason) => ({
+export const recommendedReconstructionProbes = (reasons) => reasons.map((reason) => ({
     operation: probeOperation(reason.code),
     subject_id: reason.subject_id,
     rationale: reason.detail,
@@ -17,7 +17,7 @@ const probeOperation = (code) => {
     return "update_authoritative_inventory";
 };
 export const evaluateReconstructionSurfaces = (context) => {
-    const surfaces = indexUnique(context.workspace.surfaces, "surface_id");
+    const surfaces = indexUnique(context.coverage.surfaces, "surface_id");
     for (const surfaceId of context.boundary.required_surface_ids) {
         const surface = surfaces.get(surfaceId);
         if (surface === undefined) {
@@ -32,7 +32,7 @@ export const evaluateReconstructionSurfaces = (context) => {
     }
 };
 const evaluateOwner = (context, surfaceId) => {
-    const owners = context.workspace.owners.filter(({ surface_id: id }) => id === surfaceId);
+    const owners = context.coverage.owners.filter(({ surface_id: id }) => id === surfaceId);
     if (owners.length === 0) {
         addReason(context, "owner-missing", surfaceId, "Required surface has no reconstructed owner or explicit disposition.");
         return;
@@ -86,14 +86,14 @@ const evaluateOwner = (context, surfaceId) => {
             addReason(context, code, surfaceId, detail);
 };
 export const evaluateReconstructionClaims = (context) => {
-    const claims = indexUnique(context.workspace.claims, "claim_id");
+    const claims = indexUnique(context.coverage.claims, "claim_id");
     for (const claimId of context.boundary.required_claim_ids) {
         const claim = claims.get(claimId);
         if (claim === undefined) {
             addReason(context, "claim-missing", claimId, "Required finite claim is absent.");
             continue;
         }
-        const contracts = context.workspace.verifier_contracts.filter(({ claim_ids: ids }) => ids.includes(claimId));
+        const contracts = context.coverage.verifier_contracts.filter(({ claim_ids: ids }) => ids.includes(claimId));
         if (contracts.length === 0) {
             addReason(context, "verifier-missing", claimId, "No verifier contract covers this claim.");
             continue;
@@ -108,7 +108,7 @@ export const evaluateReconstructionClaims = (context) => {
     }
 };
 const evaluateVerifierResult = (context, claim, contract) => {
-    const results = context.workspace.verifier_results
+    const results = context.coverage.verifier_results
         .filter(({ verifier_id: id }) => id === contract.verifier_id)
         .sort((left, right) => Date.parse(right.observed_at) - Date.parse(left.observed_at));
     const result = results[0];
@@ -133,10 +133,10 @@ const evaluateVerifierResult = (context, claim, contract) => {
         addReason(context, "verifier-unknown", claim.claim_id, `Latest compatible verifier result is ${result.status}.`);
 };
 const verifierResultIsCompatible = (context, claim, contract, result) => {
-    const artifactDigests = new Set(context.workspace.artifacts.map(({ artifact_sha256: value }) => value));
-    const ownerDigests = new Set(context.workspace.owners.flatMap(({ ownership }) => ownership.disposition === "implemented" ? [ownership.owner_sha256] : []));
-    const surfaces = new Map(context.workspace.surfaces.map((surface) => [surface.surface_id, surface]));
-    const artifacts = new Map(context.workspace.artifacts.map((artifact) => [
+    const artifactDigests = new Set(context.coverage.artifacts.map(({ artifact_sha256: value }) => value));
+    const ownerDigests = new Set(context.coverage.owners.flatMap(({ ownership }) => ownership.disposition === "implemented" ? [ownership.owner_sha256] : []));
+    const surfaces = new Map(context.coverage.surfaces.map((surface) => [surface.surface_id, surface]));
+    const artifacts = new Map(context.coverage.artifacts.map((artifact) => [
         artifact.artifact_id,
         artifact,
     ]));
@@ -145,7 +145,7 @@ const verifierResultIsCompatible = (context, claim, contract, result) => {
         const artifact = surface === undefined ? undefined : artifacts.get(surface.artifact_id);
         return artifact === undefined ? [] : [artifact.artifact_sha256];
     });
-    const expectedOwnerDigests = context.workspace.owners.flatMap(({ surface_id: surfaceId, ownership }) => claim.surface_ids.includes(surfaceId) &&
+    const expectedOwnerDigests = context.coverage.owners.flatMap(({ surface_id: surfaceId, ownership }) => claim.surface_ids.includes(surfaceId) &&
         ownership.disposition === "implemented"
         ? [ownership.owner_sha256]
         : []);
@@ -163,11 +163,11 @@ const verifierResultIsCompatible = (context, claim, contract, result) => {
         result.repeats >= contract.minimum_repeats &&
         claim.required_authority === contract.authority);
 };
-export const evaluateReconstructionWorkspaceRisks = (context) => {
-    for (const unknownId of context.workspace.residual_unknown_ids)
+export const evaluateReconstructionCoverageRisks = (context) => {
+    for (const unknownId of context.coverage.residual_unknown_ids)
         if (!context.boundary.allowed_unknown_ids.includes(unknownId))
             addReason(context, "active-unknown", unknownId, "Active residual unknown is not permitted by the completion boundary.");
-    for (const contradiction of context.workspace.contradictions)
+    for (const contradiction of context.coverage.contradictions)
         if (contradiction.status === "active" &&
             (contradiction.surface_ids.some((id) => context.boundary.required_surface_ids.includes(id)) ||
                 contradiction.claim_ids.some((id) => context.boundary.required_claim_ids.includes(id)))) {
@@ -176,8 +176,8 @@ export const evaluateReconstructionWorkspaceRisks = (context) => {
         }
 };
 export const evaluateReconstructionPackageProofs = (context) => {
-    const surfaces = new Map(context.workspace.surfaces.map((surface) => [surface.surface_id, surface]));
-    const artifacts = new Map(context.workspace.artifacts.map((artifact) => [
+    const surfaces = new Map(context.coverage.surfaces.map((surface) => [surface.surface_id, surface]));
+    const artifacts = new Map(context.coverage.artifacts.map((artifact) => [
         artifact.artifact_id,
         artifact,
     ]));
@@ -187,7 +187,7 @@ export const evaluateReconstructionPackageProofs = (context) => {
         return artifact === undefined ? [] : [artifact.artifact_sha256];
     });
     for (const kind of context.boundary.required_package_proof_kinds) {
-        const proofs = context.workspace.package_proofs.filter((proof) => proof.kind === kind);
+        const proofs = context.coverage.package_proofs.filter((proof) => proof.kind === kind);
         const passing = proofs.find(({ artifact_sha256s: digests, status }) => status === "pass" &&
             requiredArtifactDigests.every((digest) => digests.includes(digest)));
         if (passing !== undefined) {