project-tiny-context-harness 0.8.12 → 0.8.13

package/dist/lib/long-task-counterfactual-claim-policy.js

@@ -1,3 +1,4 @@
+import { scopeDeliveryBindings, } from "./long-task-scoped-binding.js";
 export function validateCounterfactualBindingClaims(outcome, control, binding) {
     if (binding.verification_check_key &&
         binding.verification_check_key !== control.check_key)
@@ -21,10 +22,10 @@ export function resolveGlobalCounterfactualBinding(contract, control) {
     const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
     if (!outcome)
         throw new Error(`global_counterfactual_binding_ref_invalid:${control.key}:${control.binding_ref}`);
-    const binding = outcome.technical.bindings.find((item) => item.key === bindingKey);
-    if (!binding)
+    const scoped = scopeDeliveryBindings(outcome.key, outcome.technical.bindings).find((item) => item.binding_ref === control.binding_ref && item.local_key === bindingKey);
+    if (!scoped)
         throw new Error(`global_counterfactual_binding_unknown:${control.key}:${control.binding_ref}`);
-    return { outcome, binding };
+    return { outcome, ...scoped };
 }
 export function validateGlobalCounterfactualBindingClaims(contract, control) {
     const resolved = resolveGlobalCounterfactualBinding(contract, control);
@@ -55,10 +56,17 @@ function validateExpectedAssertions(control, check, unknownPrefix) {
         if (!assertions.has(key))
             throw new Error(`${unknownPrefix}:${key}`);
     const failures = new Set(control.expected_assertion_failures);
+    const preserved = new Set(control.preserved_assertions);
     for (const key of control.preserved_assertions) {
         if (!assertions.has(key))
             throw new Error(`${unknownPrefix}:${key}`);
         if (failures.has(key))
             throw new Error(`counterfactual_preserved_assertion_conflict:${unknownPrefix}:${key}`);
     }
+    for (const key of control.allowed_fanout_assertions) {
+        if (!assertions.has(key))
+            throw new Error(`${unknownPrefix}:${key}`);
+        if (failures.has(key) || preserved.has(key))
+            throw new Error(`counterfactual_fanout_assertion_conflict:${unknownPrefix}:${key}`);
+    }
 }

package/dist/lib/long-task-counterfactual-sandbox.js

@@ -24,6 +24,7 @@ export async function createCounterfactualSandbox(snapshotRoot, check, control,
     const exactPaths = new Set([
         ...Object.keys(check.runner.frozen_files),
         ...Object.keys(check.verification_input_hashes),
+        ...(check.process_runtime_closure?.allowed_runtime_files ?? []),
         check.runner.resolved_target,
         ...(control.mutation.type === "replace_file"
             ? [control.mutation.fixture_path]

package/dist/lib/long-task-counterfactual-types.d.ts

@@ -24,6 +24,7 @@ export interface CounterfactualControlV2 {
     mutation: CounterfactualMutationV2;
     expected_assertion_failures: string[];
     preserved_assertions: string[];
+    allowed_fanout_assertions: string[];
 }
 export interface GlobalCounterfactualControlV2 {
     key: string;
@@ -33,4 +34,5 @@ export interface GlobalCounterfactualControlV2 {
     mutation: CounterfactualMutationV2;
     expected_assertion_failures: string[];
     preserved_assertions: string[];
+    allowed_fanout_assertions: string[];
 }

package/dist/lib/long-task-delivery-compiler.js

@@ -86,6 +86,8 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
             verification_inputs: check.verification_input_hashes,
             raw_execution_identity: check.raw_execution_identity,
             evidence_adapter: check.evidence_adapter,
+            observation_authorities: check.observation_authorities,
+            process_runtime_closure: check.process_runtime_closure,
         })),
     }));
     let authorityRevision = options.authority_revision ?? previous?.authority_revision ?? 1;

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]));
@@ -100,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 = [];
@@ -129,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;
@@ -149,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);
@@ -159,8 +183,90 @@ 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();

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;

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

@@ -1,8 +1,14 @@
+import { evaluateExactDigestComparison, exactComparisonResultIdentity, } from "./long-task-exact-comparison.js";
+import { admittedObservationAuthorityKey, isJsonPointerExactOracle, resolveObservationAuthority, } from "./long-task-admitted-observation.js";
 import { validateSemanticFactEvidence } from "./long-task-semantic-fact-evidence.js";
-export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
+export { evaluateExactDigestComparison, exactComparisonResultIdentity };
+export function validateRuntimeEvidenceRecord(check, record, artifactHashes, admittedObservations, hostAttestation = null) {
+    const admittedObservationIssue = validateAdmittedObservationRecord(check, record, admittedObservations);
+    if (admittedObservationIssue)
+        return admittedObservationIssue;
     switch (record.capability) {
         case "interaction_trace":
-            return validateInteractionTrace(check, record);
+            return validateInteractionTrace(check, record, hostAttestation);
         case "state_delta":
             if (record.before_sha256 === record.after_sha256)
                 return "state_unchanged";
@@ -35,11 +41,81 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
         case "semantic_fact":
             return validateSemanticFactEvidence(check, record, artifactHashes);
         case "target_runtime":
-            return validateTargetRuntime(check, record);
+            return validateTargetRuntime(check, record, hostAttestation);
         case "input_variation":
             return validateInputVariation(record);
     }
 }
+function validateAdmittedObservationRecord(check, record, admitted) {
+    if (record.capability === "semantic_fact" &&
+        record.observer_results.length > 0)
+        return "semantic_fact_machine_observer_not_admitted";
+    const candidates = runtimeAdmittedObservationCandidates(record);
+    for (const candidate of candidates) {
+        if (!isJsonPointerExactOracle(candidate.oracle))
+            return "custom_oracle_machine_completion_forbidden";
+        const authorityResolution = resolveObservationAuthority(check, {
+            assertion_key: record.assertion_key,
+            identity_ref: candidate.identity_ref,
+            method: record.capability === "semantic_fact" ||
+                record.capability === "design_method"
+                ? record.method
+                : "exact_value",
+        });
+        if (!authorityResolution.authority)
+            return authorityResolution.reason;
+        if (authorityResolution.authority.authority === "external_confirmation")
+            return "unsupported_observer_requires_external_confirmation";
+        if (!admitted)
+            return "admitted_observation_runtime_required";
+        const key = admittedObservationAuthorityKey(authorityResolution.authority);
+        const prepared = admitted.by_authority_key.get(key);
+        if (!prepared ||
+            prepared.obligation_ref !== authorityResolution.authority.obligation_ref)
+            return "admitted_observation_missing";
+        if (prepared.reason)
+            return prepared.reason;
+        if (!prepared.observation)
+            return "admitted_observation_missing";
+        if (authorityResolution.authority.authority === "package_static_json_exact" &&
+            (prepared.observation.artifact_path !==
+                candidate.actual_observation.artifact_path ||
+                prepared.observation.artifact_sha256 !==
+                    candidate.actual_observation.artifact_sha256))
+            return "admitted_observation_artifact_mismatch";
+        if (candidate.actual_observation.locator.kind !== "json_pointer" ||
+            candidate.actual_observation.locator.value !==
+                authorityResolution.authority.locator_policy.value)
+            return "observation_locator_identity_mismatch";
+        if (prepared.observation.value_sha256 !==
+            candidate.actual_observation.value_sha256)
+            return "admitted_observation_value_mismatch";
+    }
+    return null;
+}
+function runtimeAdmittedObservationCandidates(record) {
+    if (record.capability === "semantic_fact")
+        return [
+            {
+                identity_ref: record.fact_ref,
+                actual_observation: record.actual_observation,
+                oracle: record.oracle,
+            },
+        ];
+    if (record.capability !== "design_method")
+        return [];
+    return "fact_model" in record
+        ? record.rule_results.map((result) => ({
+            identity_ref: result.obligation_ref,
+            actual_observation: result.actual_observation,
+            oracle: result.oracle,
+        }))
+        : record.cells.flatMap((cell) => cell.fact_results.map((result) => ({
+            identity_ref: result.fact_ref,
+            actual_observation: result.actual_observation,
+            oracle: result.oracle,
+        })));
+}
 function validateDesignMethod(check, record, artifactHashes) {
     return "fact_model" in record
         ? validateSymbolicDesignMethod(check, record, artifactHashes)
@@ -111,6 +187,9 @@ function validateGroundCellResults(cell, expectedCell, artifactHashes) {
         const artifactIssue = validateGroundFactArtifacts(result, expectation, cell, artifactHashes);
         if (artifactIssue)
             return artifactIssue;
+        const exactIssue = validateGroundExactComparison(result);
+        if (exactIssue)
+            return exactIssue;
         const actualIdentity = `${result.actual_observation.artifact_path}\0${canonicalJson(result.actual_observation.locator)}`;
         if (actualIdentities.has(actualIdentity))
             return "design_method_actual_observation_reused";
@@ -124,6 +203,28 @@ function validateGroundCellResults(cell, expectedCell, artifactHashes) {
     }
     return null;
 }
+function validateGroundExactComparison(result) {
+    if (result.comparison.comparator !== "exact_value" ||
+        result.comparison.mode !== "exact")
+        return null;
+    if (result.comparison.tolerance !== null || result.comparison.mask !== null)
+        return "design_method_comparison_authority_mismatch";
+    const recomputed = evaluateExactDigestComparison({
+        identity: {
+            kind: "selected_design_ground_v1",
+            fact_ref: result.fact_ref,
+            subject_ref: result.subject_ref,
+            variation_ref: result.variation_ref,
+            property_ref: result.property_ref,
+        },
+        ...exactComparisonMaterial(result),
+    });
+    if (!recomputed.passed)
+        return "design_method_exact_value_mismatch";
+    return result.comparison.result_sha256 === recomputed.result_sha256
+        ? null
+        : "design_method_comparison_result_identity_mismatch";
+}
 function validateGroundFactIdentity(result, expectation) {
     if (result.subject_ref !== expectation.subject_ref ||
         result.variation_ref !== expectation.variation_ref ||
@@ -220,6 +321,9 @@ function validateSymbolicRuleResults(binding, record, artifactHashes) {
         const artifactIssue = validateSymbolicResultArtifacts(result, expectation, record, artifactHashes);
         if (artifactIssue)
             return artifactIssue;
+        const exactIssue = validateSymbolicExactComparison(result);
+        if (exactIssue)
+            return exactIssue;
         const actualIdentity = `${result.actual_observation.artifact_path}\0${canonicalJson(result.actual_observation.locator)}`;
         if (actualIdentities.has(actualIdentity))
             return "design_symbolic_method_actual_observation_reused";
@@ -233,6 +337,42 @@ function validateSymbolicRuleResults(binding, record, artifactHashes) {
     }
     return null;
 }
+function validateSymbolicExactComparison(result) {
+    if (result.comparison.comparator !== "exact_value" ||
+        result.comparison.mode !== "exact")
+        return null;
+    if (result.comparison.tolerance !== null || result.comparison.mask !== null)
+        return "design_symbolic_method_comparison_authority_mismatch";
+    const recomputed = evaluateExactDigestComparison({
+        identity: {
+            kind: "selected_design_symbolic_v2",
+            obligation_ref: result.obligation_ref,
+            fact_rule_ref: result.fact_rule_ref,
+            region_sha256: result.region_sha256,
+            subject_or_relation_ref: result.subject_or_relation_ref,
+            property_ref: result.property_ref,
+            population_ref: result.population_ref,
+            quantifier: result.quantifier,
+        },
+        ...exactComparisonMaterial(result),
+    });
+    if (!recomputed.passed)
+        return "design_symbolic_method_exact_value_mismatch";
+    return result.comparison.result_sha256 === recomputed.result_sha256
+        ? null
+        : "design_symbolic_method_comparison_result_identity_mismatch";
+}
+function exactComparisonMaterial(result) {
+    return {
+        actual_value_sha256: result.actual_observation.value_sha256,
+        expected_value_sha256: result.expected.sha256,
+        comparator: result.comparison.comparator,
+        mode: result.comparison.mode,
+        parameters_sha256: result.comparison.parameters.sha256,
+        tolerance_sha256: result.comparison.tolerance?.sha256 ?? null,
+        mask_sha256: result.comparison.mask?.sha256 ?? null,
+    };
+}
 function validateSymbolicResultIdentity(result, expectation) {
     if (result.fact_rule_ref !== expectation.fact_rule_ref ||
         result.region_sha256 !== expectation.region_sha256 ||
@@ -381,7 +521,9 @@ function designTargetUsesAssertion(target, assertionKey) {
         target.verification_method_bindings.some((item) => item.assertion_ref === assertionKey) ||
         (target.symbolic_method_bindings ?? []).some((item) => item.assertion_ref === assertionKey));
 }
-function validateInteractionTrace(check, record) {
+function validateInteractionTrace(check, record, hostAttestation) {
+    if (!hostAttestation?.direct_root_match)
+        return "legacy_interaction_trace_non_authoritative";
     if (record.target_ref !== check.execution_target.target_ref)
         return "target_mismatch";
     if (!same(record.given_keys, check.scenario.given.map((step) => step.key)))
@@ -410,7 +552,9 @@ function validateObserverEvidence(check, observerTargetRef) {
         return "check_must_execute_on_observer";
     return null;
 }
-function validateTargetRuntime(check, record) {
+function validateTargetRuntime(check, record, hostAttestation) {
+    if (!hostAttestation?.direct_root_match)
+        return "legacy_target_runtime_non_authoritative";
     if (record.target_ref !== check.execution_target.target_ref)
         return "target_mismatch";
     if (record.root_entrypoint !== check.execution_target_definition.root_entrypoint)

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

@@ -1,4 +1,13 @@
 import type { CompiledCheckV2, CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+export declare function validateCounterfactualObservationImpact(input: {
+    baseline_by_fact: Record<string, string>;
+    mutated_by_fact: Record<string, string>;
+    expected_affected_fact_refs: string[];
+    preserved_fact_refs: string[];
+    allowed_fanout_fact_refs?: string[];
+    target_live: boolean;
+    carrier_role: "product" | "evidence";
+}): string | null;
 export declare function validateClaimEvidenceSensitivity(contract: DeliveryContractV2, globalChecks: CompiledCheckV2[], outcomes: CompiledOutcomeV2[], report?: ValidationReporter): void;
 type ValidationReporter = (message: string) => void;
 export {};

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

@@ -6,6 +6,37 @@ const NON_RESULT_SENSITIVITY_PREFIXES = [
     "non_completing.",
     "forbidden_shortcut.",
 ];
+export function validateCounterfactualObservationImpact(input) {
+    if (input.carrier_role === "evidence")
+        return "counterfactual_mutates_generated_evidence";
+    if (!input.target_live)
+        return "counterfactual_target_not_live";
+    const expected = new Set(input.expected_affected_fact_refs);
+    const preserved = new Set(input.preserved_fact_refs);
+    const allowedFanout = new Set(input.allowed_fanout_fact_refs ?? []);
+    for (const factRef of expected) {
+        if (!Object.hasOwn(input.baseline_by_fact, factRef) ||
+            !Object.hasOwn(input.mutated_by_fact, factRef))
+            return "counterfactual_expected_fact_observation_missing";
+        if (input.baseline_by_fact[factRef] === input.mutated_by_fact[factRef])
+            return "counterfactual_expected_fact_unchanged";
+    }
+    for (const factRef of new Set([
+        ...Object.keys(input.baseline_by_fact),
+        ...Object.keys(input.mutated_by_fact),
+    ])) {
+        if (expected.has(factRef) || allowedFanout.has(factRef))
+            continue;
+        const baseline = input.baseline_by_fact[factRef];
+        const mutated = input.mutated_by_fact[factRef];
+        if (preserved.has(factRef) &&
+            (baseline === undefined || mutated === undefined || baseline !== mutated))
+            return "counterfactual_unexpected_fact_impact";
+        if (!preserved.has(factRef) && baseline !== mutated)
+            return "counterfactual_unexpected_fact_impact";
+    }
+    return null;
+}
 export function validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, report) {
     validateGlobalStructuredSensitivity(contract, globalChecks, report);
     validateGlobalSemanticWitnesses(contract, globalChecks, report);
@@ -62,7 +93,6 @@ function isNarrowSemanticMutation(type) {
 }
 function isBehavioralAssertion(check, assertion) {
     return !(check.proof_surface === "implementation_structure" &&
-        assertion.operator === "exists" &&
         assertion.evidence_capabilities.every((capability) => capability === "presence"));
 }
 function isLivenessAssertion(check, reference) {

package/dist/lib/long-task-evidence-v2.d.ts

@@ -1,5 +1,5 @@
 import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function evaluateCheckEvidence(check: CompiledCheckV2, raw: RawCommandExecutionV2, snapshotRoot: string, outcome?: CompiledOutcomeV2): Promise<CheckExecutionResultV2>;
-export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[]): Promise<LongTaskFindingV2[]>;
-export declare function evaluateGlobalCounterfactuals(compiled: CompiledDeliveryContractV2, snapshotRoot: string, selectedCheckKeys?: ReadonlySet<string>, manifest?: WorkspaceManifestV2): Promise<LongTaskFindingV2[]>;
-export declare function isValidCounterfactualCheckResult(result: CheckExecutionResultV2, expectedAssertionFailures: string[]): boolean;
+export declare function evaluateCheckEvidence(check: CompiledCheckV2, raw: RawCommandExecutionV2, snapshotRoot: string, outcome?: CompiledOutcomeV2, observationAuthorityPaths?: readonly string[]): Promise<CheckExecutionResultV2>;
+export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[], baselineResults?: readonly CheckExecutionResultV2[], baselineExecutions?: ReadonlyMap<string, RawCommandExecutionV2>, executionUniverse?: readonly CompiledCheckV2[]): Promise<LongTaskFindingV2[]>;
+export declare function evaluateGlobalCounterfactuals(compiled: CompiledDeliveryContractV2, snapshotRoot: string, selectedCheckKeys?: ReadonlySet<string>, manifest?: WorkspaceManifestV2, baselineResults?: readonly CheckExecutionResultV2[], baselineExecutions?: ReadonlyMap<string, RawCommandExecutionV2>, executionUniverse?: readonly CompiledCheckV2[]): Promise<LongTaskFindingV2[]>;
+export declare function isValidCounterfactualCheckResult(result: CheckExecutionResultV2, expectedAssertionFailures: string[], allowedFanoutAssertions?: string[]): boolean;