reverseport 0.0.0-stage → 1.2.0

package/dist/domain/reconstructionCoverage.js

@@ -0,0 +1,325 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { compareUnicodeCodePoints, compositeKey, } from "./unicodeCodePointOrder.js";
+import { evidenceBundleSchema, parseEvidenceBundle } from "./evidenceBundle.js";
+import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionCoverageRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.js";
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+import { offsetDateTimeSchema } from "./offsetDateTime.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const stableIdSchema = z
+    .string()
+    .regex(/^[A-Za-z][A-Za-z0-9._:\x2f\x2d]{0,199}$/u);
+const boundedTextSchema = z.string().trim().min(1);
+const authoritySchema = z.enum([
+    "observed",
+    "derived",
+    "inferred",
+    "historical",
+    "external",
+]);
+const artifactSchema = z.strictObject({
+    artifact_id: stableIdSchema,
+    artifact_sha256: digestSchema,
+    version: z.string().trim().min(1),
+    environment_sha256: digestSchema,
+    evidence_ids: z.array(evidenceIdSchema).min(1),
+});
+const surfaceSchema = z.strictObject({
+    surface_id: stableIdSchema,
+    family: z.string().trim().min(1),
+    artifact_id: stableIdSchema,
+    occurrence_id: z.string().trim().min(1).nullable(),
+    location: boundedTextSchema,
+    authority: authoritySchema,
+    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).nullable(),
+    owner_sha256: digestSchema,
+    path_state: z.enum(["present", "missing", "unknown"]),
+    package_state: z.enum(["distributed", "missing", "unknown"]),
+    authority_route: z.enum(["none", "detected", "unknown"]),
+});
+const externalOwnerSchema = z.strictObject({
+    disposition: z.enum(["external", "non-goal"]),
+    rationale: boundedTextSchema,
+});
+const ownerSchema = z.strictObject({
+    surface_id: stableIdSchema,
+    ownership: z.discriminatedUnion("disposition", [
+        implementationOwnerSchema,
+        externalOwnerSchema,
+    ]),
+});
+const claimSchema = z.strictObject({
+    claim_id: stableIdSchema,
+    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",
+        "live-observation",
+        "external",
+    ]),
+});
+const verifierContractBaseSchema = z.strictObject({
+    verifier_id: stableIdSchema,
+    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),
+    minimum_repeats: z.number().int().min(1),
+    normalization_sha256: digestSchema,
+    normalization_removes_dimensions: z.literal(false),
+});
+const verifierContractSchema = verifierContractBaseSchema.extend({
+    contract_sha256: digestSchema,
+});
+const verifierResultSchema = z.strictObject({
+    verifier_id: stableIdSchema,
+    contract_sha256: digestSchema,
+    observed_at: offsetDateTimeSchema,
+    status: z.enum([
+        "pass",
+        "fail",
+        "unknown",
+        "unsupported",
+        "truncated",
+        "skipped",
+    ]),
+    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),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
+});
+const contradictionSchema = z.strictObject({
+    contradiction_id: stableIdSchema,
+    status: z.enum(["active", "resolved"]),
+    surface_ids: z.array(stableIdSchema),
+    claim_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(2),
+});
+const packageProofSchema = z.strictObject({
+    proof_id: stableIdSchema,
+    kind: z.enum([
+        "build",
+        "clean-install",
+        "package-contents",
+        "runtime-routing",
+        "authority-independence",
+    ]),
+    status: z.enum(["pass", "fail", "unknown", "unsupported", "skipped"]),
+    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),
+    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),
+});
+export const reconstructionCoverageDataSchema = z.strictObject({
+    evidence_bundle: evidenceBundleSchema,
+    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),
+});
+/** 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",
+        "owner-missing",
+        "owner-duplicate",
+        "owner-path-missing",
+        "owner-path-unknown",
+        "owner-undistributed",
+        "owner-distribution-unknown",
+        "authority-routing-detected",
+        "authority-routing-unknown",
+        "disposition-not-allowed",
+        "dependency-surface-missing",
+        "claim-missing",
+        "verifier-missing",
+        "verifier-duplicate",
+        "verifier-result-missing",
+        "verifier-result-stale",
+        "verifier-result-incompatible",
+        "verifier-failed",
+        "verifier-unknown",
+        "active-unknown",
+        "active-contradiction",
+        "package-proof-missing",
+        "package-proof-failed",
+        "package-proof-unknown",
+    ]),
+    subject_id: stableIdSchema,
+    detail: boundedTextSchema,
+});
+export const reconstructionClosureResultSchema = z.strictObject({
+    boundary_id: stableIdSchema,
+    status: z.enum(["partial", "failed", "unknown", "ready"]),
+    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),
+    recommended_probes: z.array(z.strictObject({
+        operation: stableIdSchema,
+        subject_id: stableIdSchema,
+        rationale: boundedTextSchema,
+    })),
+    evidence_ids: z.array(evidenceIdSchema),
+});
+/** Build a verifier contract whose digest prevents retrospective coverage edits. */
+export const createReconstructionVerifierContract = (input) => {
+    const parsed = verifierContractBaseSchema.parse(input);
+    return verifierContractSchema.parse({
+        ...parsed,
+        contract_sha256: digest(parsed),
+    });
+};
+/** 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 = {
+        coverage,
+        boundary,
+        nowEpochMs,
+        reasons: [],
+        evidenceIds: new Set(),
+    };
+    evaluateReconstructionSurfaces(context);
+    evaluateReconstructionClaims(context);
+    evaluateReconstructionCoverageRisks(context);
+    evaluateReconstructionPackageProofs(context);
+    const reasons = [...context.reasons].sort(reasonOrder);
+    return reconstructionClosureResultSchema.parse({
+        boundary_id: boundary.boundary_id,
+        status: closureStatus(reasons),
+        summary: {
+            required_surfaces: boundary.required_surface_ids.length,
+            required_claims: boundary.required_claim_ids.length,
+            reasons: reasons.length,
+        },
+        reasons,
+        recommended_probes: recommendedReconstructionProbes(reasons),
+        evidence_ids: [...context.evidenceIds].sort(),
+    });
+};
+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));
+    const artifacts = assertUnique(workspace.artifacts, "artifact_id");
+    const surfaces = assertUnique(workspace.surfaces, "surface_id");
+    const claims = assertUnique(workspace.claims, "claim_id");
+    const contracts = assertUnique(workspace.verifier_contracts, "verifier_id");
+    assertUnique(workspace.contradictions, "contradiction_id");
+    assertUnique(workspace.package_proofs, "proof_id");
+    assertUnique(workspace.boundaries, "boundary_id");
+    for (const contract of workspace.verifier_contracts) {
+        const { contract_sha256: contractSha256, ...base } = contract;
+        if (contractSha256 !== digest(verifierContractBaseSchema.parse(base)))
+            throw new TypeError(`Verifier contract digest is invalid: ${contract.verifier_id}`);
+    }
+    for (const surface of workspace.surfaces)
+        if (!artifacts.has(surface.artifact_id))
+            throw new TypeError(`Surface artifact is missing: ${surface.surface_id}`);
+    for (const owner of workspace.owners)
+        if (!surfaces.has(owner.surface_id))
+            throw new TypeError(`Owner surface is missing: ${owner.surface_id}`);
+    for (const claim of workspace.claims)
+        if (claim.surface_ids.some((id) => !surfaces.has(id)))
+            throw new TypeError(`Claim surface is missing: ${claim.claim_id}`);
+    for (const contract of workspace.verifier_contracts)
+        if (contract.claim_ids.some((id) => !claims.has(id)))
+            throw new TypeError(`Verifier claim is missing: ${contract.verifier_id}`);
+    for (const result of workspace.verifier_results)
+        if (!contracts.has(result.verifier_id))
+            throw new TypeError(`Verifier result contract is missing: ${result.verifier_id}`);
+    const referencedEvidenceIds = [
+        ...workspace.artifacts.flatMap(({ evidence_ids: ids }) => ids),
+        ...workspace.surfaces.flatMap(({ evidence_ids: ids }) => ids),
+        ...workspace.verifier_results.flatMap(({ evidence_ids: ids }) => ids),
+        ...workspace.contradictions.flatMap(({ evidence_ids: ids }) => ids),
+        ...workspace.package_proofs.flatMap(({ evidence_ids: ids }) => ids),
+    ];
+    const danglingEvidence = referencedEvidenceIds.find((id) => !evidenceIds.has(id));
+    if (danglingEvidence !== undefined)
+        throw new TypeError(`Coverage workspace Evidence is missing: ${danglingEvidence}`);
+    const danglingUnknown = workspace.residual_unknown_ids.find((id) => !unknownIds.has(id));
+    if (danglingUnknown !== undefined)
+        throw new TypeError(`Coverage workspace residual unknown is missing: ${danglingUnknown}`);
+};
+const assertUnique = (items, key) => {
+    const values = items.map((item) => item[key]);
+    if (new Set(values).size !== values.length)
+        throw new TypeError(`Duplicate reconstruction coverage ${String(key)}`);
+    return new Set(values);
+};
+const closureStatus = (reasons) => {
+    if (reasons.length === 0)
+        return "ready";
+    if (reasons.some(({ code }) => [
+        "verifier-failed",
+        "active-contradiction",
+        "authority-routing-detected",
+        "owner-path-missing",
+        "owner-undistributed",
+        "package-proof-failed",
+    ].includes(code)))
+        return "failed";
+    if (reasons.some(({ code }) => [
+        "verifier-result-stale",
+        "verifier-result-incompatible",
+        "verifier-unknown",
+        "active-unknown",
+        "owner-path-unknown",
+        "owner-distribution-unknown",
+        "authority-routing-unknown",
+        "package-proof-unknown",
+    ].includes(code)))
+        return "unknown";
+    return "partial";
+};
+const reasonOrder = (left, right) => compareUnicodeCodePoints(compositeKey([left.code, left.subject_id]), compositeKey([right.code, right.subject_id]));
+const digest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Reconstruction coverage value is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};

package/dist/domain/reconstructionCoverageEvaluation.js

@@ -0,0 +1,234 @@
+export const recommendedReconstructionProbes = (reasons) => reasons.map((reason) => ({
+    operation: probeOperation(reason.code),
+    subject_id: reason.subject_id,
+    rationale: reason.detail,
+}));
+const probeOperation = (code) => {
+    if (code.startsWith("owner-") || code.startsWith("authority-routing"))
+        return "reconcile_reconstruction_owner";
+    if (code.startsWith("verifier-"))
+        return "run_reconstruction_verifier";
+    if (code.startsWith("package-proof"))
+        return "verify_reconstruction_package";
+    if (code === "active-contradiction")
+        return "resolve_contradiction";
+    if (code === "active-unknown")
+        return "probe_residual_unknown";
+    return "update_authoritative_inventory";
+};
+export const evaluateReconstructionSurfaces = (context) => {
+    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) {
+            addReason(context, "surface-missing", surfaceId, "Required surface is absent from the authoritative inventory.");
+            continue;
+        }
+        addEvidence(context, surface.evidence_ids);
+        for (const dependencyId of surface.dependency_surface_ids)
+            if (!surfaces.has(dependencyId))
+                addReason(context, "dependency-surface-missing", surfaceId, `Declared dependency surface is absent: ${dependencyId}`);
+        evaluateOwner(context, surfaceId);
+    }
+};
+const evaluateOwner = (context, 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;
+    }
+    if (owners.length > 1) {
+        addReason(context, "owner-duplicate", surfaceId, "Required surface has conflicting ownership declarations.");
+        return;
+    }
+    const owner = owners[0]?.ownership;
+    if (owner === undefined)
+        return;
+    if (owner.disposition !== "implemented") {
+        if (!context.boundary.allowed_dispositions.includes(owner.disposition))
+            addReason(context, "disposition-not-allowed", surfaceId, `${owner.disposition} is not allowed by this completion boundary.`);
+        return;
+    }
+    const ownerChecks = [
+        [
+            owner.path_state === "missing",
+            "owner-path-missing",
+            "Declared owner path is missing.",
+        ],
+        [
+            owner.path_state === "unknown",
+            "owner-path-unknown",
+            "Declared owner path has not been checked.",
+        ],
+        [
+            owner.package_state === "missing",
+            "owner-undistributed",
+            "Declared owner is absent from the distributable.",
+        ],
+        [
+            owner.package_state === "unknown",
+            "owner-distribution-unknown",
+            "Owner distribution state is unknown.",
+        ],
+        [
+            owner.authority_route === "detected",
+            "authority-routing-detected",
+            "Reconstructed owner routes into the authority.",
+        ],
+        [
+            owner.authority_route === "unknown",
+            "authority-routing-unknown",
+            "Authority independence has not been established.",
+        ],
+    ];
+    for (const [matches, code, detail] of ownerChecks)
+        if (matches)
+            addReason(context, code, surfaceId, detail);
+};
+export const evaluateReconstructionClaims = (context) => {
+    const claims = indexUnique(context.coverage.claims, "claim_id");
+    const indexes = createVerifierIndexes(context.coverage);
+    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 = indexes.contractsByClaim.get(claimId) ?? [];
+        if (contracts.length === 0) {
+            addReason(context, "verifier-missing", claimId, "No verifier contract covers this claim.");
+            continue;
+        }
+        if (contracts.length > 1) {
+            addReason(context, "verifier-duplicate", claimId, "Multiple verifier contracts claim primary coverage.");
+            continue;
+        }
+        const contract = contracts[0];
+        if (contract !== undefined)
+            evaluateVerifierResult(context, claim, contract, indexes);
+    }
+};
+const createVerifierIndexes = (coverage) => {
+    const contractsByClaim = new Map();
+    for (const contract of coverage.verifier_contracts)
+        for (const claimId of new Set(contract.claim_ids)) {
+            const contracts = contractsByClaim.get(claimId) ?? [];
+            contracts.push(contract);
+            contractsByClaim.set(claimId, contracts);
+        }
+    const latestResultsByVerifier = new Map();
+    for (const result of coverage.verifier_results) {
+        const latest = latestResultsByVerifier.get(result.verifier_id);
+        // Stable descending sort used to choose the first input record on ties.
+        if (latest === undefined ||
+            Date.parse(result.observed_at) > Date.parse(latest.observed_at))
+            latestResultsByVerifier.set(result.verifier_id, result);
+    }
+    const ownersBySurface = new Map();
+    for (const owner of coverage.owners) {
+        const owners = ownersBySurface.get(owner.surface_id) ?? [];
+        owners.push(owner);
+        ownersBySurface.set(owner.surface_id, owners);
+    }
+    return {
+        contractsByClaim,
+        latestResultsByVerifier,
+        artifactDigests: new Set(coverage.artifacts.map(({ artifact_sha256: value }) => value)),
+        ownerDigests: new Set(coverage.owners.flatMap(({ ownership }) => ownership.disposition === "implemented" ? [ownership.owner_sha256] : [])),
+        surfaces: indexUnique(coverage.surfaces, "surface_id"),
+        artifacts: indexUnique(coverage.artifacts, "artifact_id"),
+        ownersBySurface,
+    };
+};
+const evaluateVerifierResult = (context, claim, contract, indexes) => {
+    const result = indexes.latestResultsByVerifier.get(contract.verifier_id);
+    if (result === undefined) {
+        addReason(context, "verifier-result-missing", claim.claim_id, "Verifier has no recorded result.");
+        return;
+    }
+    addEvidence(context, result.evidence_ids);
+    if (!verifierResultIsCompatible(claim, contract, result, indexes)) {
+        addReason(context, "verifier-result-incompatible", claim.claim_id, "Latest verifier result does not match current artifacts, owners, dimensions, authority, normalization, repeats, or contract.");
+        return;
+    }
+    const observedAt = Date.parse(result.observed_at);
+    if (observedAt > context.nowEpochMs ||
+        context.nowEpochMs - observedAt > contract.max_age_ms) {
+        addReason(context, "verifier-result-stale", claim.claim_id, "Latest compatible verifier result is stale.");
+        return;
+    }
+    if (result.status === "fail")
+        addReason(context, "verifier-failed", claim.claim_id, "Latest compatible verifier result failed.");
+    else if (result.status !== "pass")
+        addReason(context, "verifier-unknown", claim.claim_id, `Latest compatible verifier result is ${result.status}.`);
+};
+const verifierResultIsCompatible = (claim, contract, result, indexes) => {
+    const expectedArtifactDigests = claim.surface_ids.flatMap((surfaceId) => {
+        const surface = indexes.surfaces.get(surfaceId);
+        const artifact = surface === undefined
+            ? undefined
+            : indexes.artifacts.get(surface.artifact_id);
+        return artifact === undefined ? [] : [artifact.artifact_sha256];
+    });
+    const expectedOwnerDigests = claim.surface_ids.flatMap((surfaceId) => (indexes.ownersBySurface.get(surfaceId) ?? []).flatMap(({ ownership }) => ownership.disposition === "implemented" ? [ownership.owner_sha256] : []));
+    return (result.contract_sha256 === contract.contract_sha256 &&
+        result.normalization_sha256 === contract.normalization_sha256 &&
+        result.covered_claim_ids.includes(claim.claim_id) &&
+        result.covered_claim_ids.every((item) => contract.claim_ids.includes(item)) &&
+        claim.required_dimensions.every((item) => contract.dimensions.includes(item)) &&
+        claim.required_dimensions.every((item) => result.covered_dimensions.includes(item)) &&
+        result.covered_dimensions.every((item) => contract.dimensions.includes(item)) &&
+        result.artifact_sha256s.every((item) => indexes.artifactDigests.has(item)) &&
+        expectedArtifactDigests.every((item) => result.artifact_sha256s.includes(item)) &&
+        result.owner_sha256s.every((item) => indexes.ownerDigests.has(item)) &&
+        expectedOwnerDigests.every((item) => result.owner_sha256s.includes(item)) &&
+        result.repeats >= contract.minimum_repeats &&
+        claim.required_authority === contract.authority);
+};
+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.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)))) {
+            addEvidence(context, contradiction.evidence_ids);
+            addReason(context, "active-contradiction", contradiction.contradiction_id, "Active contradiction affects the completion boundary.");
+        }
+};
+export const evaluateReconstructionPackageProofs = (context) => {
+    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,
+    ]));
+    const requiredArtifactDigests = context.boundary.required_surface_ids.flatMap((surfaceId) => {
+        const surface = surfaces.get(surfaceId);
+        const artifact = surface === undefined ? undefined : artifacts.get(surface.artifact_id);
+        return artifact === undefined ? [] : [artifact.artifact_sha256];
+    });
+    for (const kind of context.boundary.required_package_proof_kinds) {
+        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) {
+            addEvidence(context, passing.evidence_ids);
+            continue;
+        }
+        if (proofs.some(({ status }) => status === "fail"))
+            addReason(context, "package-proof-failed", kind, "Required package or integration proof failed.");
+        else if (proofs.length > 0)
+            addReason(context, "package-proof-unknown", kind, "Required package or integration proof is not passing.");
+        else
+            addReason(context, "package-proof-missing", kind, "Required package or integration proof is missing.");
+    }
+};
+const indexUnique = (items, key) => new Map(items.map((item) => [item[key], item]));
+const addReason = (context, code, subjectId, detail) => {
+    context.reasons.push({ code, subject_id: subjectId, detail });
+};
+const addEvidence = (context, evidenceIds) => {
+    for (const evidenceId of evidenceIds)
+        context.evidenceIds.add(evidenceId);
+};

package/dist/domain/reconstructionCoverageInput.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { reconstructionCoverageDataSchema } from "./reconstructionCoverage.js";
+/** Named-boundary input for inline reconstruction coverage evaluation. */
+export const reconstructionCoverageEvaluationInputSchema = z.strictObject({
+    coverage: reconstructionCoverageDataSchema,
+    boundary_id: z.string().min(1),
+});

package/dist/domain/reconstructionObligationLedgerIntegrity.js

@@ -0,0 +1,114 @@
+import { digestCanonicalValue } from "./canonicalDigest.js";
+import { canonicalJson } from "./comparisonSemantics.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
+/** Derive the ledger summary from the obligation facts. */
+export const summarizeReconstructionObligations = (obligations) => ({
+    total: obligations.length,
+    required: obligations.filter(({ required }) => required).length,
+    verified: obligations.filter(({ status }) => status === "verified").length,
+    required_open: obligations.filter(({ required, status }) => required && status !== "verified").length,
+    by_status: countBy(obligations, [
+        "unowned",
+        "characterized",
+        "implemented",
+        "verified",
+        "contradicted",
+        "blocked",
+        "out-of-scope",
+        "unknown",
+    ], ({ status }) => status),
+    by_application_layer: countBy(obligations, [
+        "cli",
+        "protocol",
+        "electron",
+        "persistence",
+        "process",
+        "runtime",
+        "packaging",
+        "native-abi",
+        "application",
+        "other",
+    ], ({ application_layer }) => application_layer),
+    by_evidence_authority: countBy(obligations, ["candidate", "observed", "reviewed", "unknown"], ({ source_state }) => source_state),
+});
+/** Derive closure status from required obligations and their diagnostic facts. */
+export const reconstructionObligationLedgerStatus = (obligations, limitations) => {
+    if (obligations.length === 0)
+        return "unknown";
+    const requiredOpen = obligations.filter(({ required, status }) => required && status !== "verified");
+    if (requiredOpen.some(({ status, diagnostics }) => status === "contradicted" ||
+        hasReconstructionObligationDiagnostic(diagnostics, "verifier-failed")))
+        return "failed";
+    if (limitations.length > 0)
+        return "unknown";
+    if (requiredOpen.some(({ status }) => status === "unknown"))
+        return "unknown";
+    return requiredOpen.length === 0 ? "ready" : "open";
+};
+export const reconstructionObligationCoverage = (limitations) => ({
+    status: limitations.length === 0 ? "complete" : "partial",
+});
+export const reconstructionObligationReports = (obligations) => ({
+    missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),
+    missing_verifier_obligation_ids: obligationIdsWith(obligations, "missing-verifier"),
+    contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),
+    residual_unknown_ids: [
+        ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),
+    ].sort(compareUnicodeCodePoints),
+});
+export const reconstructionObligationOwnershipGraph = (obligations) => obligations
+    .flatMap((obligation) => obligation.binding === null
+    ? []
+    : [
+        {
+            obligation_id: obligation.obligation_id,
+            module_path: obligation.binding.owner.module_path,
+            symbol: obligation.binding.owner.symbol,
+        },
+    ])
+    .sort(obligationEdgeOrder);
+export const reconstructionObligationDependencyGraph = (obligations) => obligations
+    .flatMap((obligation) => obligation.dependency_obligation_ids.map((dependencyId) => ({
+    obligation_id: obligation.obligation_id,
+    depends_on_obligation_id: dependencyId,
+})))
+    .sort(obligationEdgeOrder);
+/** Evidence attached to facts serialized on an obligation. */
+export const reconstructionObligationEvidenceIds = (obligations) => [
+    ...new Set(obligations.flatMap((obligation) => [
+        ...obligation.authority_references.map(({ evidence_id: id }) => id),
+        ...obligation.observed_cases.map(({ evidence_id: id }) => id),
+        ...(obligation.binding === null
+            ? []
+            : [
+                ...obligation.binding.original_cases.map(({ evidence_id: id }) => id),
+                ...obligation.binding.fixtures.flatMap(({ evidence_ids: ids }) => ids),
+                ...(obligation.binding.verifier === null
+                    ? []
+                    : [obligation.binding.verifier.result_evidence_id]),
+            ]),
+    ])),
+].sort(compareUnicodeCodePoints);
+const obligationEdgeOrder = (left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));
+const obligationIdsWith = (obligations, code) => obligations
+    .filter(({ diagnostics }) => hasReconstructionObligationDiagnostic(diagnostics, code))
+    .map(({ obligation_id: id }) => id)
+    .sort(compareUnicodeCodePoints);
+export const hasReconstructionObligationDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);
+/** Recompute the closure commitment from the fields carried by a ledger. */
+export const reconstructionObligationLedgerClosureDigest = (ledger) => digestCanonicalValue({
+    schema: "ReconstructionObligationClosure",
+    status: ledger.status,
+    coverage: ledger.coverage,
+    summary: ledger.summary,
+    reports: ledger.reports,
+    ownership_graph: ledger.ownership_graph,
+    dependency_graph: ledger.dependency_graph,
+    obligations: ledger.obligations,
+    evidence_links: ledger.evidence_links,
+    limitations: ledger.limitations,
+}, "Reconstruction obligation ledger");
+const countBy = (items, values, valueFor) => values.map((value) => ({
+    key: value,
+    count: items.filter((item) => valueFor(item) === value).length,
+}));