project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/long-task-evidence-capability-codec.js

@@ -183,39 +183,11 @@ function decodeRecord(value, index) {
                 cold_start: row.cold_start,
             };
         case "design_method":
-            exact(row, label, [
-                "assertion_key",
-                "capability",
-                "design_target_ref",
-                "target_ref",
-                "method",
-                "cells",
-            ]);
-            return {
-                ...base,
-                capability,
-                design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
-                target_ref: key(row.target_ref, `${label}.target_ref`),
-                method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
-                cells: array(row.cells, `${label}.cells`).map((item, cellIndex) => {
-                    const cellLabel = `${label}.cells[${cellIndex}]`;
-                    const cell = record(item, cellLabel);
-                    exact(cell, cellLabel, [
-                        "condition_key",
-                        "artifact_path",
-                        "observation_artifact_path",
-                        "fact_refs",
-                        "fact_results",
-                    ]);
-                    return {
-                        condition_key: key(cell.condition_key, `${cellLabel}.condition_key`),
-                        artifact_path: nonEmpty(cell.artifact_path, `${cellLabel}.artifact_path`),
-                        observation_artifact_path: nonEmpty(cell.observation_artifact_path, `${cellLabel}.observation_artifact_path`),
-                        fact_refs: designFactRefs(cell.fact_refs, `${cellLabel}.fact_refs`),
-                        fact_results: array(cell.fact_results, `${cellLabel}.fact_results`).map((result, resultIndex) => decodeDesignFactResult(result, `${cellLabel}.fact_results[${resultIndex}]`)),
-                    };
-                }),
-            };
+            return Object.hasOwn(row, "fact_model")
+                ? decodeSymbolicDesignMethodEvidence(row, label, base)
+                : decodeGroundDesignMethodEvidence(row, label, base);
+        case "design_symbolic_certificate":
+            return decodeDesignSymbolicCertificateEvidence(row, label, base);
         case "semantic_fact":
             return decodeSemanticFactEvidence(row, label, base);
         case "input_variation":
@@ -224,6 +196,217 @@ function decodeRecord(value, index) {
             throw invalidRecord(`${label}.capability_unsupported:${capability}`);
     }
 }
+function decodeGroundDesignMethodEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "design_target_ref",
+        "target_ref",
+        "method",
+        "cells",
+    ]);
+    return {
+        ...base,
+        capability: "design_method",
+        design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+        target_ref: key(row.target_ref, `${label}.target_ref`),
+        method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
+        cells: array(row.cells, `${label}.cells`).map((item, cellIndex) => {
+            const cellLabel = `${label}.cells[${cellIndex}]`;
+            const cell = record(item, cellLabel);
+            exact(cell, cellLabel, [
+                "condition_key",
+                "artifact_path",
+                "observation_artifact_path",
+                "fact_refs",
+                "fact_results",
+            ]);
+            return {
+                condition_key: key(cell.condition_key, `${cellLabel}.condition_key`),
+                artifact_path: nonEmpty(cell.artifact_path, `${cellLabel}.artifact_path`),
+                observation_artifact_path: nonEmpty(cell.observation_artifact_path, `${cellLabel}.observation_artifact_path`),
+                fact_refs: designFactRefs(cell.fact_refs, `${cellLabel}.fact_refs`),
+                fact_results: array(cell.fact_results, `${cellLabel}.fact_results`).map((result, resultIndex) => decodeDesignFactResult(result, `${cellLabel}.fact_results[${resultIndex}]`)),
+            };
+        }),
+    };
+}
+function decodeSymbolicDesignMethodEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "fact_model",
+        "design_target_ref",
+        "target_ref",
+        "method",
+        "artifact_path",
+        "observation_artifact_path",
+        "rule_results",
+    ]);
+    return {
+        ...base,
+        capability: "design_method",
+        fact_model: literal(row.fact_model, ["symbolic_rules_v2"], `${label}.fact_model`),
+        design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+        target_ref: key(row.target_ref, `${label}.target_ref`),
+        method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
+        artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
+        observation_artifact_path: nonEmpty(row.observation_artifact_path, `${label}.observation_artifact_path`),
+        rule_results: array(row.rule_results, `${label}.rule_results`).map((item, index) => decodeDesignSymbolicRuleResult(item, `${label}.rule_results[${index}]`)),
+    };
+}
+function decodeDesignSymbolicRuleResult(value, label) {
+    const row = record(value, label);
+    exact(row, label, [
+        "obligation_ref",
+        "fact_rule_ref",
+        "region_sha256",
+        "subject_or_relation_ref",
+        "property_ref",
+        "population_ref",
+        "quantifier",
+        "actual_observation",
+        "actual_environment",
+        "observation_sensitivity",
+        "expected",
+        "proof_surface",
+        "observation_boundary",
+        "comparison",
+        "verdict",
+        "oracle",
+        "environment",
+        "protected_value_policy",
+        "completion_effect",
+    ]);
+    const decoded = decodeDesignFactResult({
+        fact_ref: row.fact_rule_ref,
+        subject_ref: row.subject_or_relation_ref,
+        variation_ref: "symbolic",
+        property_ref: row.property_ref,
+        actual_observation: row.actual_observation,
+        actual_environment: row.actual_environment,
+        expected: row.expected,
+        comparison: row.comparison,
+        verdict: row.verdict,
+        oracle: row.oracle,
+        environment: row.environment,
+    }, label);
+    const quantifier = record(row.quantifier, `${label}.quantifier`);
+    exact(quantifier, `${label}.quantifier`, ["kind", "minimum", "maximum"]);
+    return {
+        obligation_ref: designFactRef(row.obligation_ref, `${label}.obligation_ref`),
+        fact_rule_ref: decoded.fact_ref,
+        region_sha256: sha(row.region_sha256, `${label}.region_sha256`),
+        subject_or_relation_ref: decoded.subject_ref,
+        property_ref: decoded.property_ref,
+        population_ref: nullable(row.population_ref, (item) => designFactRef(item, `${label}.population_ref`)),
+        quantifier: {
+            kind: literal(quantifier.kind, [
+                "one",
+                "all",
+                "any",
+                "none",
+                "exactly",
+                "at_least",
+                "at_most",
+                "range",
+            ], `${label}.quantifier.kind`),
+            minimum: nullable(quantifier.minimum, (item) => nonnegativeInteger(item, `${label}.quantifier.minimum`)),
+            maximum: nullable(quantifier.maximum, (item) => nonnegativeInteger(item, `${label}.quantifier.maximum`)),
+        },
+        actual_observation: decoded.actual_observation,
+        actual_environment: decoded.actual_environment,
+        observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${label}.observation_sensitivity`),
+        expected: decoded.expected,
+        proof_surface: nonEmpty(row.proof_surface, `${label}.proof_surface`),
+        observation_boundary: nonEmpty(row.observation_boundary, `${label}.observation_boundary`),
+        comparison: decoded.comparison,
+        verdict: decoded.verdict,
+        oracle: decoded.oracle,
+        environment: decoded.environment,
+        protected_value_policy: nonEmpty(row.protected_value_policy, `${label}.protected_value_policy`),
+        completion_effect: nonEmpty(row.completion_effect, `${label}.completion_effect`),
+    };
+}
+function decodeDesignSymbolicCertificateEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "design_target_ref",
+        "target_ref",
+        "artifact_path",
+        "artifact_sha256",
+        "metrics",
+        "certificate_results",
+    ]);
+    const metrics = record(row.metrics, `${label}.metrics`);
+    exact(metrics, `${label}.metrics`, [
+        "semantic_obligations",
+        "certificate_obligations",
+        "certificate_covered_omitted_axes",
+        "certificate_covered_dependency_edges",
+        "canonical_dag_nodes",
+        "canonical_partition_edges",
+        "canonical_bytes",
+        "theoretical_ground_cardinality",
+    ]);
+    return {
+        ...base,
+        capability: "design_symbolic_certificate",
+        design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+        target_ref: key(row.target_ref, `${label}.target_ref`),
+        artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
+        artifact_sha256: sha(row.artifact_sha256, `${label}.artifact_sha256`),
+        metrics: {
+            semantic_obligations: nonnegativeInteger(metrics.semantic_obligations, `${label}.metrics.semantic_obligations`),
+            certificate_obligations: nonnegativeInteger(metrics.certificate_obligations, `${label}.metrics.certificate_obligations`),
+            certificate_covered_omitted_axes: nonnegativeInteger(metrics.certificate_covered_omitted_axes, `${label}.metrics.certificate_covered_omitted_axes`),
+            certificate_covered_dependency_edges: nonnegativeInteger(metrics.certificate_covered_dependency_edges, `${label}.metrics.certificate_covered_dependency_edges`),
+            canonical_dag_nodes: nonnegativeInteger(metrics.canonical_dag_nodes, `${label}.metrics.canonical_dag_nodes`),
+            canonical_partition_edges: nonnegativeInteger(metrics.canonical_partition_edges, `${label}.metrics.canonical_partition_edges`),
+            canonical_bytes: nonnegativeInteger(metrics.canonical_bytes, `${label}.metrics.canonical_bytes`),
+            theoretical_ground_cardinality: decimalCardinality(metrics.theoretical_ground_cardinality, `${label}.metrics.theoretical_ground_cardinality`),
+        },
+        certificate_results: array(row.certificate_results, `${label}.certificate_results`).map((item, index) => {
+            const itemLabel = `${label}.certificate_results[${index}]`;
+            const result = record(item, itemLabel);
+            exact(result, itemLabel, [
+                "certificate_ref",
+                "fact_rule_refs",
+                "omitted_axis_refs",
+                "dependency_edge_refs",
+                "canonical_rule_dag_sha256",
+                "recomputed",
+                "verdict",
+                ...[
+                    "source_noninterference_proof_sha256",
+                    "production_noninterference_proof_sha256",
+                ].filter((field) => Object.hasOwn(result, field)),
+            ]);
+            if (result.recomputed !== true)
+                throw invalidRecord(`${itemLabel}.recomputed`);
+            return {
+                certificate_ref: designFactRef(result.certificate_ref, `${itemLabel}.certificate_ref`),
+                fact_rule_refs: designFactRefs(result.fact_rule_refs, `${itemLabel}.fact_rule_refs`),
+                omitted_axis_refs: designFactRefs(result.omitted_axis_refs, `${itemLabel}.omitted_axis_refs`),
+                dependency_edge_refs: designFactRefs(result.dependency_edge_refs, `${itemLabel}.dependency_edge_refs`),
+                canonical_rule_dag_sha256: sha(result.canonical_rule_dag_sha256, `${itemLabel}.canonical_rule_dag_sha256`),
+                ...(result.source_noninterference_proof_sha256 === undefined
+                    ? {}
+                    : {
+                        source_noninterference_proof_sha256: sha(result.source_noninterference_proof_sha256, `${itemLabel}.source_noninterference_proof_sha256`),
+                    }),
+                ...(result.production_noninterference_proof_sha256 === undefined
+                    ? {}
+                    : {
+                        production_noninterference_proof_sha256: sha(result.production_noninterference_proof_sha256, `${itemLabel}.production_noninterference_proof_sha256`),
+                    }),
+                recomputed: true,
+                verdict: literal(result.verdict, ["passed", "failed"], `${itemLabel}.verdict`),
+            };
+        }),
+    };
+}
 function decodeInputVariationEvidence(row, label, base) {
     exact(row, label, [
         "assertion_key",
@@ -249,7 +432,7 @@ function decodeInputVariationEvidence(row, label, base) {
     };
 }
 function decodeSemanticFactEvidence(row, label, base) {
-    exact(row, label, [
+    exactOptional(row, label, [
         "assertion_key",
         "capability",
         "manifest_ref",
@@ -270,7 +453,21 @@ function decodeSemanticFactEvidence(row, label, base) {
         "oracle",
         "environment",
         "observer_results",
+    ], [
+        "fact_key",
+        "fact_revision_digest",
+        "obligation_key",
+        "obligation_revision_digest",
     ]);
+    const revisionFields = [
+        "fact_key",
+        "fact_revision_digest",
+        "obligation_key",
+        "obligation_revision_digest",
+    ];
+    const revisionFieldCount = revisionFields.filter((field) => Object.hasOwn(row, field)).length;
+    if (revisionFieldCount !== 0 && revisionFieldCount !== revisionFields.length)
+        throw invalidRecord(`${label}.revision_identity.shape`);
     const actual = record(row.actual_observation, `${label}.actual_observation`);
     exact(actual, `${label}.actual_observation`, [
         "artifact_path",
@@ -320,6 +517,14 @@ function decodeSemanticFactEvidence(row, label, base) {
         manifest_sha256: sha(row.manifest_sha256, `${label}.manifest_sha256`),
         outcome_ref: semanticFactRef(row.outcome_ref, `${label}.outcome_ref`),
         target_ref: key(row.target_ref, `${label}.target_ref`),
+        ...(revisionFieldCount
+            ? {
+                fact_key: semanticFactRef(row.fact_key, `${label}.fact_key`),
+                fact_revision_digest: sha(row.fact_revision_digest, `${label}.fact_revision_digest`),
+                obligation_key: semanticFactRef(row.obligation_key, `${label}.obligation_key`),
+                obligation_revision_digest: sha(row.obligation_revision_digest, `${label}.obligation_revision_digest`),
+            }
+            : {}),
         fact_ref: semanticFactRef(row.fact_ref, `${label}.fact_ref`),
         proof_ref: semanticFactRef(row.proof_ref, `${label}.proof_ref`),
         method: semanticFactRef(row.method, `${label}.method`),
@@ -611,6 +816,12 @@ function exact(row, label, fields) {
         Object.keys(row).some((field) => !allowed.has(field)))
         throw invalidRecord(`${label}.shape`);
 }
+function exactOptional(row, label, required, optional) {
+    const allowed = new Set([...required, ...optional]);
+    if (required.some((field) => !Object.hasOwn(row, field)) ||
+        Object.keys(row).some((field) => !allowed.has(field)))
+        throw invalidRecord(`${label}.shape`);
+}
 function array(value, label) {
     if (!Array.isArray(value))
         throw invalidRecord(label);
@@ -621,6 +832,17 @@ function nonEmpty(value, label) {
         throw invalidRecord(label);
     return value;
 }
+function nonnegativeInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw invalidRecord(label);
+    return value;
+}
+function decimalCardinality(value, label) {
+    const result = nonEmpty(value, label);
+    if (!/^(0|[1-9][0-9]*)$/u.test(result))
+        throw invalidRecord(label);
+    return result;
+}
 function key(value, label) {
     const result = nonEmpty(value, label);
     if (!/^[a-z0-9][a-z0-9-]*$/u.test(result))

package/dist/lib/long-task-evidence-capability-policy.d.ts

@@ -1,8 +1,9 @@
-import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityRecordV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
+import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityRecordV2, LongTaskFindingV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
+import { type PreparedAdmittedObservationSet } from "./long-task-admitted-observation.js";
 export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-codec.js";
 type Reporter = (message: string) => void;
 export declare function validateEvidenceCapabilityDeclarations(contract: DeliveryContractV2, report?: Reporter): void;
-export declare function evaluateEvidenceCapabilities(check: CompiledCheckV2, records: EvidenceCapabilityRecordV2[], artifactHashes: Record<string, string>): {
+export declare function evaluateEvidenceCapabilities(check: CompiledCheckV2, records: EvidenceCapabilityRecordV2[], artifactHashes: Record<string, string>, admittedObservations?: PreparedAdmittedObservationSet, rawExecution?: RawCommandExecutionV2): {
     complete: Record<string, boolean>;
     findings: LongTaskFindingV2[];
 };

package/dist/lib/long-task-evidence-capability-policy.js

@@ -1,6 +1,7 @@
 import { validateRuntimeEvidenceRecord } from "./long-task-evidence-capability-runtime.js";
 import { validateDistinctSemanticFactEvidence } from "./long-task-semantic-fact-evidence.js";
 import { checkFinding } from "./long-task-evidence-findings.js";
+import { admittedObservationAuthorityKey, } from "./long-task-admitted-observation.js";
 export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-codec.js";
 export function validateEvidenceCapabilityDeclarations(contract, report) {
     const targets = new Map(contract.task.execution_targets.map((target) => [target.key, target]));
@@ -45,6 +46,9 @@ function validateArtifactCapabilityDeclarations(assertion, check, label, report)
     if (assertion.evidence_capabilities.includes("design_method") &&
         !check.artifact_globs.length)
         issue(report, "design_method_artifact_required", label);
+    if (assertion.evidence_capabilities.includes("design_symbolic_certificate") &&
+        !check.artifact_globs.length)
+        issue(report, "design_symbolic_certificate_artifact_required", label);
     if (assertion.evidence_capabilities.includes("semantic_fact") &&
         !check.artifact_globs.length)
         issue(report, "semantic_fact_artifact_required", label);
@@ -58,6 +62,7 @@ function validateRunnerCapabilityDeclarations(assertion, check, targets, label,
             capability !== "interaction_trace" &&
             capability !== "design_conformance" &&
             capability !== "design_method" &&
+            capability !== "design_symbolic_certificate" &&
             capability !== "semantic_fact" &&
             capability !== "target_runtime"))
         issue(report, "playwright_evidence_capability_unsupported", label);
@@ -96,7 +101,7 @@ function validateJourneySeparation(contract, report) {
         }
     }
 }
-export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
+export function evaluateEvidenceCapabilities(check, records, artifactHashes, admittedObservations, rawExecution) {
     const runtimeRecords = records ?? [];
     const complete = {};
     const findings = [];
@@ -125,15 +130,22 @@ export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
     for (const assertion of assertions) {
         let assertionComplete = true;
         for (const capability of assertion.evidence_capabilities) {
-            if (capability === "presence")
-                continue;
             const matches = runtimeRecords.filter((record) => record.assertion_key === assertion.key &&
                 record.capability === capability);
-            const reason = matches.length === 1
-                ? validateRuntimeEvidenceRecord(check, matches[0], artifactHashes)
-                : matches.length === 0
-                    ? "record_missing"
-                    : "record_duplicate";
+            const derived = packageDerivedCapability(check, assertion.key, capability, admittedObservations, rawExecution);
+            const submittedReason = matches.length === 1
+                ? validateRuntimeEvidenceRecord(check, matches[0], artifactHashes, admittedObservations, rawExecution?.host_execution_attestation ?? null)
+                : matches.length > 1
+                    ? "record_duplicate"
+                    : null;
+            const reason = submittedReason ??
+                (derived.supported
+                    ? derived.reason
+                    : capability === "presence"
+                        ? null
+                        : matches.length === 0
+                            ? "record_missing"
+                            : null);
             if (!reason)
                 continue;
             assertionComplete = false;
@@ -145,6 +157,22 @@ export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
                 actual: reason,
             });
         }
+        const authorityIssues = assertionObservationAuthorityIssues(check, assertion.key, assertion.claims.length > 0, admittedObservations);
+        if (authorityIssues.length) {
+            assertionComplete = false;
+            for (const authorityIssue of authorityIssues) {
+                findings.push({
+                    ...checkFinding(check, "evidence_capability_invalid", `Assertion ${assertion.key} has no complete package-admitted current-Actual chain for ${authorityIssue.obligation_ref ?? "an unplanned machine obligation"}: ${authorityIssue.reason}.`, "Bind every machine-closing or liveness-preserving obligation to its compiled package observation authority, or move unsupported observation to an explicit blocking External Confirmation."),
+                    assertion_key: assertion.key,
+                    claim_keys: assertion.claims,
+                    expected: {
+                        authority: authorityIssue.authority,
+                        obligation_ref: authorityIssue.obligation_ref,
+                    },
+                    actual: authorityIssue.reason,
+                });
+            }
+        }
         complete[assertion.key] = assertionComplete;
     }
     validateDistinctDesignMethodArtifacts(check, runtimeRecords, artifactHashes, findings);
@@ -155,14 +183,105 @@ export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
             expected: "unique_fact_proof_and_artifact_locator_identity",
             actual: semanticDistinctness,
         });
+    for (const entry of admittedObservations?.entries ?? [])
+        if (!entry.authority_key && entry.reason)
+            findings.push({
+                ...checkFinding(check, "evidence_capability_invalid", `A package observation was not bound to the compiled observation plan: ${entry.identity_ref}:${entry.reason}.`, "Emit only the exact identity set selected by the Harness-owned compiled observation plan."),
+                expected: "compiled_observation_identity",
+                actual: entry.identity_ref,
+            });
     return { complete, findings };
 }
+function packageDerivedCapability(check, assertionKey, capability, admitted, raw) {
+    const authorities = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === assertionKey);
+    const supported = capability === "presence" ||
+        capability === "semantic_fact" ||
+        capability === "design_method" ||
+        capability === "target_runtime";
+    if (!supported || !authorities.length)
+        return { supported: false, reason: null };
+    for (const authority of authorities) {
+        if (authority.authority === "external_confirmation")
+            return {
+                supported: true,
+                reason: "unsupported_observer_requires_external_confirmation",
+            };
+        const prepared = admitted?.by_authority_key.get(admittedObservationAuthorityKey(authority));
+        if (!prepared)
+            return { supported: true, reason: "admitted_observation_missing" };
+        if (prepared.reason)
+            return { supported: true, reason: prepared.reason };
+        if (!prepared.observation || !prepared.comparison)
+            return { supported: true, reason: "admitted_observation_missing" };
+    }
+    const processRequired = capability === "target_runtime" ||
+        authorities.some((authority) => authority.authority === "package_process_json_exact");
+    if (processRequired) {
+        const attestation = raw?.host_execution_attestation;
+        if (!attestation)
+            return { supported: true, reason: "host_attestation_required" };
+        if (!attestation.direct_root_match ||
+            attestation.raw_execution_identity !== check.raw_execution_identity ||
+            !attestation.snapshot_sha256 ||
+            !check.process_runtime_closure ||
+            attestation.process_runtime_closure_identity !==
+                check.process_runtime_closure.closure_identity ||
+            attestation.exit_code !== 0 ||
+            attestation.exit_code !== raw?.exit_code)
+            return { supported: true, reason: "host_attestation_mismatch" };
+    }
+    return { supported: true, reason: null };
+}
+function assertionObservationAuthorityIssues(check, assertionKey, machineClosing, admitted) {
+    const authorities = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === assertionKey);
+    if (!authorities.length)
+        return machineClosing
+            ? [
+                {
+                    obligation_ref: null,
+                    authority: null,
+                    reason: "machine_observer_not_admitted",
+                },
+            ]
+            : [];
+    const issues = [];
+    for (const authority of authorities) {
+        let reason = null;
+        if (authority.authority === "external_confirmation")
+            reason = "unsupported_observer_requires_external_confirmation";
+        else if (!admitted)
+            reason = "admitted_observation_runtime_required";
+        else {
+            const authorityKey = admittedObservationAuthorityKey(authority);
+            const prepared = admitted.by_authority_key.get(authorityKey);
+            reason =
+                prepared?.reason ??
+                    (prepared?.observation ? null : "admitted_observation_missing");
+        }
+        if (reason)
+            issues.push({
+                obligation_ref: authority.obligation_ref,
+                authority: authority.authority,
+                reason,
+            });
+    }
+    return issues;
+}
 function validateDistinctDesignMethodArtifacts(check, records, artifactHashes, findings) {
     const pathOwners = new Map();
     const digestOwners = new Map();
     for (const record of records) {
+        if (record.capability === "design_symbolic_certificate") {
+            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-certificate:${record.design_target_ref}`, record.artifact_path, artifactHashes);
+            continue;
+        }
         if (record.capability !== "design_method")
             continue;
+        if ("fact_model" in record) {
+            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-method:${record.design_target_ref}:${record.method}:observation`, record.observation_artifact_path, artifactHashes);
+            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-method:${record.design_target_ref}:${record.method}:comparison`, record.artifact_path, artifactHashes);
+            continue;
+        }
         for (const cell of record.cells) {
             const currentOwner = `${record.method}:${cell.condition_key}`;
             const pathOwner = pathOwners.get(cell.observation_artifact_path);
@@ -181,6 +300,21 @@ function validateDistinctDesignMethodArtifacts(check, records, artifactHashes, f
         }
     }
 }
+function addDistinctArtifact(check, findings, pathOwners, digestOwners, assertionKey, currentOwner, path, artifactHashes) {
+    const pathOwner = pathOwners.get(path);
+    if (pathOwner)
+        findings.push(reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, pathOwner, "path", path));
+    else
+        pathOwners.set(path, currentOwner);
+    const digest = artifactHashes[path];
+    if (!digest)
+        return;
+    const digestOwner = digestOwners.get(digest);
+    if (digestOwner)
+        findings.push(reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, digestOwner, "sha256", digest));
+    else
+        digestOwners.set(digest, currentOwner);
+}
 function reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, previousOwner, identityKind, identity) {
     return {
         ...checkFinding(check, "design_method_evidence_reused", `Design-method evidence ${identityKind} ${identity} is reused by ${previousOwner} and ${currentOwner}.`, "Emit method-and-condition evidence whose path and current content digest are both distinct for every verification-method cell."),

package/dist/lib/long-task-evidence-capability-runtime.d.ts

@@ -1,2 +1,5 @@
-import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
-export declare function validateRuntimeEvidenceRecord(check: CompiledCheckV2, record: EvidenceCapabilityRecordV2, artifactHashes: Record<string, string>): string | null;
+import type { CompiledCheckV2, EvidenceCapabilityRecordV2, HostExecutionAttestationV2 } from "./long-task-delivery-types.js";
+import { evaluateExactDigestComparison, exactComparisonResultIdentity } from "./long-task-exact-comparison.js";
+import { type PreparedAdmittedObservationSet } from "./long-task-admitted-observation.js";
+export { evaluateExactDigestComparison, exactComparisonResultIdentity };
+export declare function validateRuntimeEvidenceRecord(check: CompiledCheckV2, record: EvidenceCapabilityRecordV2, artifactHashes: Record<string, string>, admittedObservations?: PreparedAdmittedObservationSet, hostAttestation?: HostExecutionAttestationV2 | null): string | null;