project-tiny-context-harness 0.8.11 → 0.8.13

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): 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;

package/dist/lib/long-task-evidence-v2.js

@@ -1,22 +1,41 @@
 import { copyFile, rm, stat } from "node:fs/promises";
 import { evaluatePopulation } from "./long-task-assertions-v2.js";
-import { collectCheckArtifacts } from "./long-task-artifacts.js";
+import { collectCheckArtifacts, prepareAdmittedObservations, } from "./long-task-artifacts.js";
 import { executeCheckRunner } from "./long-task-check-runner.js";
+import { prepareExecutionObservationGroup } from "./long-task-execution-observation.js";
 import { createCounterfactualSandbox } from "./long-task-counterfactual-sandbox.js";
 import { assertionFinding, checkFinding, classifyCheckStatus, evaluateAssertionResults, } from "./long-task-evidence-findings.js";
 import { classifyPlaywrightCounterfactual } from "./long-task-playwright-counterfactual-policy.js";
+import { admittedObservationAuthorityKey, classifyMachineObservationCarrierRoleConflict, } from "./long-task-admitted-observation.js";
 import { applyNarrowSemanticMutation } from "./long-task-semantic-mutation.js";
 import { evaluateEvidenceCapabilities } from "./long-task-evidence-capability-policy.js";
+import { validateCounterfactualObservationImpact } from "./long-task-evidence-sensitivity-policy.js";
+import { matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
 import { resolveInsideRepository } from "./long-task-workspace.js";
-export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
+import { canonicalValueJson } from "./strict-codec.js";
+export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome, observationAuthorityPaths = []) {
     const artifacts = await collectCheckArtifacts(check, snapshotRoot);
-    const assertionResults = evaluateAssertionResults(check, raw.observations);
+    const admittedObservations = await prepareAdmittedObservations({
+        check,
+        records: raw.evidence_records ?? [],
+        snapshot_root: snapshotRoot,
+        authority_paths: observationAuthorityPaths,
+        package_observations: (raw.package_observations ?? []).filter((candidate) => (check.observation_authorities ?? []).some((authority) => authority.authority === candidate.authority &&
+            authority.observation_identity === candidate.observation_identity &&
+            authority.assertion_ref === candidate.assertion_ref &&
+            authority.obligation_ref === candidate.obligation_ref &&
+            authority.method === candidate.method)),
+    });
+    const derived = packageDerivedAssertionObservations(check, raw.observations, admittedObservations);
+    const authoritativeRaw = { ...raw, observations: derived.observations };
+    const assertionResults = evaluateAssertionResults(check, authoritativeRaw.observations);
     const executionCompleted = raw.execution_status === "completed";
-    const findings = collectExecutionFindings(check, raw, outcome, artifacts, assertionResults);
+    const findings = collectExecutionFindings(check, authoritativeRaw, outcome, artifacts, assertionResults, admittedObservations);
+    findings.push(...derived.findings);
     const population = outcome?.acceptance.population;
     let populationPassed = true;
     if (executionCompleted && population?.check_key === check.key) {
-        const result = evaluatePopulation(population, raw.observations);
+        const result = evaluatePopulation(population, authoritativeRaw.observations);
         populationPassed = result.passed;
         if (!result.passed)
             findings.push({
@@ -57,7 +76,7 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
         evidence_adapter: check.evidence_adapter,
         execution_identity: raw.raw_execution_identity,
         assertion_results: assertionResults,
-        observations: raw.observations,
+        observations: authoritativeRaw.observations,
         evidence_records: raw.evidence_records ?? [],
         artifact_hashes: artifacts.hashes,
         claim_proofs: claimProofs,
@@ -66,7 +85,40 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
         duration_ms: raw.duration_ms,
     };
 }
-function collectExecutionFindings(check, raw, outcome, artifacts, assertionResults) {
+function packageDerivedAssertionObservations(check, submitted, admitted) {
+    const observations = { ...submitted };
+    const findings = [];
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ]) {
+        const authorities = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === assertion.key);
+        if (!authorities.length)
+            continue;
+        const entries = authorities.map((authority) => admitted.by_authority_key.get(admittedObservationAuthorityKey(authority)));
+        if (entries.some((entry) => !entry || entry.reason || !entry.observation || !entry.comparison))
+            continue;
+        const factBound = authorities.some((authority) => authority.fact_ref !== null);
+        const derivedValue = factBound
+            ? entries.every((entry) => entry.comparison.passed)
+            : entries.length === 1
+                ? entries[0].raw_value
+                : entries.every((entry) => entry.comparison.passed);
+        if (Object.hasOwn(submitted, assertion.observation) &&
+            canonicalValueJson(submitted[assertion.observation]) !==
+                canonicalValueJson(derivedValue))
+            findings.push({
+                ...checkFinding(check, "project_submitted_verdict_disagrees_with_harness", `Project-submitted observation ${assertion.observation} disagrees with the package-derived current Actual.`, "Remove the compatibility copy or make it agree with the Harness-derived observation; it cannot act as Authority."),
+                assertion_key: assertion.key,
+                claim_keys: assertion.claims,
+                expected: derivedValue,
+                actual: submitted[assertion.observation],
+            });
+        observations[assertion.observation] = derivedValue;
+    }
+    return { observations, findings };
+}
+function collectExecutionFindings(check, raw, outcome, artifacts, assertionResults, admittedObservations) {
     const findings = [];
     if (raw.execution_status !== "completed") {
         findings.push(checkFinding(check, raw.execution_status, raw.error ?? raw.execution_status, raw.execution_status === "blocked_external"
@@ -83,17 +135,24 @@ function collectExecutionFindings(check, raw, outcome, artifacts, assertionResul
     for (const result of assertionResults)
         if (!result.passed)
             findings.push(assertionFinding(check, result, raw.observations, outcome));
-    const capabilityEvaluation = evaluateEvidenceCapabilities(check, raw.evidence_records, artifacts.hashes);
+    const capabilityEvaluation = evaluateEvidenceCapabilities(check, raw.evidence_records, artifacts.hashes, admittedObservations, raw);
     const passedAssertions = new Set(assertionResults
         .filter((result) => result.passed)
         .map((result) => result.key));
-    findings.push(...capabilityEvaluation.findings.filter((finding) => !finding.assertion_key || passedAssertions.has(finding.assertion_key)));
+    findings.push(...capabilityEvaluation.findings.filter((finding) => !finding.assertion_key ||
+        passedAssertions.has(finding.assertion_key) ||
+        isObservationAuthorityFailureFinding(finding)));
     for (const result of assertionResults)
         result.evidence_complete =
             result.passed && capabilityEvaluation.complete[result.key] === true;
     return findings;
 }
-export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, manifest) {
+function isObservationAuthorityFailureFinding(finding) {
+    if (typeof finding.actual !== "string")
+        return false;
+    return /^(?:admitted_observation_|counterfactual_admitted_observation_|host_attestation_|machine_observer_|observation_|process_observation_|process_observer_|project_submitted_|static_observation_|unsupported_observer_)/u.test(finding.actual);
+}
+export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, manifest, protectedAuthorityPaths = [], baselineResults = [], baselineExecutions = new Map(), executionUniverse = outcome.acceptance.checks) {
     return evaluateCounterfactualSet(outcome.acceptance.counterfactual_controls.map((control) => ({
         control,
         check: outcome.acceptance.checks.find((item) => item.key === control.check_key),
@@ -101,9 +160,12 @@ export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, mani
         findingOutcomeKey: outcome.key,
         owningOutcome: outcome,
         bindingRef: `${outcome.key}.${control.binding_key}`,
-    })), snapshotRoot, manifest);
+    })), snapshotRoot, manifest, protectedAuthorityPaths, baselineResults, baselineExecutions, executionUniverse);
 }
-export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, selectedCheckKeys, manifest) {
+export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, selectedCheckKeys, manifest, baselineResults = [], baselineExecutions = new Map(), executionUniverse = [
+    ...compiled.global.acceptance.checks,
+    ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
+]) {
     return evaluateCounterfactualSet((compiled.global.acceptance.counterfactual_controls ?? [])
         .filter((control) => !selectedCheckKeys || selectedCheckKeys.has(control.check_key))
         .map((control) => {
@@ -115,23 +177,18 @@ export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, sele
             owningOutcome: compiled.outcomes.find((outcome) => outcome.key === outcomeKey),
             bindingRef: control.binding_ref,
         };
-    }), snapshotRoot, manifest);
+    }), snapshotRoot, manifest, compiledAuthorityPaths(compiled), baselineResults, baselineExecutions, executionUniverse);
 }
-async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
+async function evaluateCounterfactualSet(entries, snapshotRoot, manifest, protectedAuthorityPaths = [], baselineResults = [], baselineExecutions = new Map(), executionUniverse = []) {
     const findings = [];
     for (const entry of entries) {
         const { control, check } = entry;
         const owningBinding = entry.owningOutcome.technical.bindings.find((binding) => `${entry.owningOutcome.key}.${binding.key}` === entry.bindingRef);
-        const sandbox = await createCounterfactualSandbox(snapshotRoot, check, control, owningBinding?.carrier_paths ?? [], manifest);
+        const sandbox = await createCounterfactualSandbox(snapshotRoot, check, control, owningBinding?.carrier_paths ?? [], manifest, protectedAuthorityPaths);
         const root = sandbox.root;
         try {
-            const mutationTargets = control.mutation.type === "remove_paths"
-                ? control.mutation.paths
-                : [control.mutation.path];
-            const missingTargets = [];
-            for (const target of mutationTargets)
-                if (!(await stat(resolveInsideRepository(root, target, "counterfactual.target")).catch(() => null)))
-                    missingTargets.push(target);
+            const mutationTargets = counterfactualMutationTargets(control);
+            const missingTargets = await missingCounterfactualMutationTargets(root, mutationTargets);
             if (missingTargets.length) {
                 findings.push(counterfactualIntegrityFinding(entry, {
                     execution_status: "not_run",
@@ -140,18 +197,10 @@ async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
                 }));
                 continue;
             }
-            if (control.mutation.type === "remove_paths") {
-                for (const target of control.mutation.paths)
-                    await rm(resolveInsideRepository(root, target, "counterfactual.remove_paths"), { recursive: true, force: true });
-            }
-            else if (control.mutation.type === "replace_file") {
-                await copyFile(resolveInsideRepository(root, control.mutation.fixture_path, "counterfactual.fixture"), resolveInsideRepository(root, control.mutation.path, "counterfactual.path"));
-            }
-            else {
-                await applyNarrowSemanticMutation(root, control.mutation);
-            }
-            const raw = await executeCheckRunner(check, root);
-            const result = await evaluateCheckEvidence(check, raw, root, entry.evidenceOutcome);
+            await applyCounterfactualMutation(root, control);
+            const raw = await executeCounterfactualCheck(check, root, manifest, protectedAuthorityPaths, executionUniverse);
+            const result = await evaluateCheckEvidence(check, raw, root, entry.evidenceOutcome, protectedAuthorityPaths);
+            const observationImpactIssue = await counterfactualObservationImpactIssue(entry, baselineResults, baselineExecutions.get(check.raw_execution_identity), result, raw, snapshotRoot, root, mutationTargets, owningBinding?.carrier_paths ?? [], protectedAuthorityPaths, executionUniverse);
             const playwrightClassification = result.evidence_adapter === "playwright_json_v1"
                 ? classifyPlaywrightCounterfactual(raw, result, control)
                 : null;
@@ -161,21 +210,27 @@ async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
                 .map((assertion) => assertion.key)
                 .sort();
             const expected = [...control.expected_assertion_failures].sort();
+            const allowedFanout = [
+                ...(control.allowed_fanout_assertions ?? []),
+            ].sort();
             const acceptedExit = playwrightClassification
                 ? playwrightClassification.accepted_test_failure_exit
                 : raw.exit_code === 0;
             const valid = raw.execution_status === "completed" &&
                 acceptedExit &&
-                isValidCounterfactualCheckResult(sensitivityResult, expected);
+                observationImpactIssue === null &&
+                isValidCounterfactualCheckResult(sensitivityResult, expected, allowedFanout);
             if (!valid)
                 findings.push(counterfactualIntegrityFinding(entry, playwrightClassification
                     ? playwrightCounterfactualDiagnostic(raw, result, expected, playwrightClassification.rejection_reasons)
                     : {
                         execution_status: raw.execution_status,
                         exit_code: raw.exit_code,
+                        execution_error: raw.error,
                         result_status: result.status,
                         failed_assertions: failedAssertions,
                         finding_codes: result.findings.map((finding) => finding.code),
+                        observation_impact_issue: observationImpactIssue,
                     }));
         }
         finally {
@@ -184,6 +239,232 @@ async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
     }
     return findings;
 }
+async function executeCounterfactualCheck(check, root, manifest, protectedAuthorityPaths, executionUniverse) {
+    const packageAuthorities = (check.observation_authorities ?? []).filter((authority) => authority.authority !== "external_confirmation");
+    if (!packageAuthorities.length)
+        return executeCheckRunner(check, root);
+    if (!manifest)
+        return {
+            raw_execution_identity: check.raw_execution_identity,
+            execution_identity: check.raw_execution_identity,
+            execution_status: "invalid_evidence",
+            exit_code: -1,
+            observations: {},
+            evidence_records: [],
+            stdout_sha256: "",
+            stderr_sha256: "",
+            attempts: 0,
+            duration_ms: 0,
+            error: "counterfactual_admitted_observation_required",
+            package_observations: [],
+            host_execution_attestation: null,
+        };
+    const group = executionUniverse.filter((candidate) => candidate.raw_execution_identity === check.raw_execution_identity);
+    const prepared = await prepareExecutionObservationGroup({
+        checks: group.length ? group : [check],
+        snapshot_root: root,
+        workspace_manifest: manifest,
+        protected_authority_paths: protectedAuthorityPaths,
+    });
+    try {
+        return await prepared.finalize(await executeCheckRunner(check, prepared.execution_root, prepared.runner_context));
+    }
+    finally {
+        await prepared.dispose();
+    }
+}
+function counterfactualMutationTargets(control) {
+    return control.mutation.type === "remove_paths"
+        ? control.mutation.paths
+        : [control.mutation.path];
+}
+async function missingCounterfactualMutationTargets(root, targets) {
+    const missing = [];
+    for (const target of targets)
+        if (!(await stat(resolveInsideRepository(root, target, "counterfactual.target")).catch(() => null)))
+            missing.push(target);
+    return missing;
+}
+async function applyCounterfactualMutation(root, control) {
+    if (control.mutation.type === "remove_paths") {
+        for (const target of control.mutation.paths)
+            await rm(resolveInsideRepository(root, target, "counterfactual.remove_paths"), { recursive: true, force: true });
+        return;
+    }
+    if (control.mutation.type === "replace_file") {
+        await copyFile(resolveInsideRepository(root, control.mutation.fixture_path, "counterfactual.fixture"), resolveInsideRepository(root, control.mutation.path, "counterfactual.path"));
+        return;
+    }
+    await applyNarrowSemanticMutation(root, control.mutation);
+}
+async function counterfactualObservationImpactIssue(entry, baselineResults, baselineRaw, mutatedResult, mutatedRaw, baselineRoot, mutatedRoot, mutationTargets, bindingCarrierPaths, protectedAuthorityPaths, executionUniverse) {
+    const baselineResult = baselineResults.find((candidate) => candidate.internal_id === entry.check.internal_id);
+    const machineClosing = [
+        ...entry.check.positive_assertions,
+        ...entry.check.negative_assertions,
+    ].some((assertion) => assertion.claims.length > 0);
+    if (!baselineResult || !baselineRaw)
+        return machineClosing
+            ? "counterfactual_admitted_observation_required"
+            : null;
+    const processObserved = (entry.check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact");
+    const processClosure = processObserved
+        ? entry.check.process_runtime_closure
+        : null;
+    if (processObserved) {
+        if (!processClosure)
+            return "process_runtime_closure_identity_mismatch";
+        const normalizedMutationTargets = mutationTargets.map((target, index) => normalizeRepositoryFile(target, `counterfactual.mutation_targets[${index}]`));
+        if (normalizedMutationTargets.some((target) => !processClosure.production_carrier_files.includes(target)))
+            return "counterfactual_runtime_reachability_unproven";
+    }
+    const observationChecks = counterfactualObservationChecks(entry.check, executionUniverse, processObserved);
+    const observationSets = await Promise.all(observationChecks.map(async (check) => {
+        const baselineCheckResult = baselineResults.find((candidate) => candidate.internal_id === check.internal_id);
+        const [baseline, mutated] = await Promise.all([
+            prepareAdmittedObservations({
+                check,
+                records: baselineCheckResult?.evidence_records ?? [],
+                snapshot_root: baselineRoot,
+                authority_paths: protectedAuthorityPaths,
+                package_observations: packageObservationsForCheck(check, baselineRaw.package_observations ?? []),
+            }),
+            prepareAdmittedObservations({
+                check,
+                records: check.internal_id === entry.check.internal_id
+                    ? mutatedResult.evidence_records
+                    : [],
+                snapshot_root: mutatedRoot,
+                authority_paths: protectedAuthorityPaths,
+                package_observations: packageObservationsForCheck(check, mutatedRaw.package_observations ?? []),
+            }),
+        ]);
+        return { check, baseline, mutated };
+    }));
+    const baselineEntries = observationSets.flatMap(({ check, baseline }) => baseline.entries.map((candidate) => ({
+        candidate,
+        check,
+        identity: scopedObservationImpactIdentity(check, candidate),
+    })));
+    const mutatedEntries = observationSets.flatMap(({ check, mutated }) => mutated.entries.map((candidate) => ({
+        candidate,
+        check,
+        identity: scopedObservationImpactIdentity(check, candidate),
+    })));
+    if (!baselineEntries.length || !mutatedEntries.length)
+        return machineClosing
+            ? "counterfactual_admitted_observation_required"
+            : null;
+    const baselineIssue = baselineEntries.find(({ candidate }) => candidate.reason || !candidate.observation);
+    if (baselineIssue)
+        return `counterfactual_baseline_observation_invalid:${baselineIssue.candidate.reason ?? "missing"}`;
+    const mutatedIssue = mutatedEntries.find(({ candidate }) => candidate.reason || !candidate.observation);
+    if (mutatedIssue)
+        return `counterfactual_mutated_observation_invalid:${mutatedIssue.candidate.reason ?? "missing"}`;
+    if (processClosure) {
+        const baselineClosureIdentity = baselineRaw.host_execution_attestation
+            ?.process_runtime_closure_identity ?? null;
+        const mutatedClosureIdentity = mutatedRaw.host_execution_attestation?.process_runtime_closure_identity ??
+            null;
+        if (baselineClosureIdentity !== processClosure.closure_identity ||
+            mutatedClosureIdentity !== processClosure.closure_identity ||
+            baselineClosureIdentity !== mutatedClosureIdentity)
+            return "process_runtime_closure_identity_mismatch";
+    }
+    const baselineKeys = baselineEntries.map(({ identity }) => identity).sort();
+    const mutatedKeys = mutatedEntries.map(({ identity }) => identity).sort();
+    if (canonicalValueJson(baselineKeys) !== canonicalValueJson(mutatedKeys))
+        return "counterfactual_obligation_universe_changed";
+    const baselineByFact = Object.fromEntries(baselineEntries.map(({ candidate, identity }) => [
+        identity,
+        candidate.observation.value_sha256,
+    ]));
+    const mutatedByFact = Object.fromEntries(mutatedEntries.map(({ candidate, identity }) => [
+        identity,
+        candidate.observation.value_sha256,
+    ]));
+    const expectedAssertions = new Set(entry.control.expected_assertion_failures);
+    const preservedAssertions = new Set(entry.control.preserved_assertions);
+    const allowedFanoutAssertions = new Set(entry.control.allowed_fanout_assertions ?? []);
+    const expectedFactRefs = baselineEntries
+        .filter(({ candidate, check }) => check.internal_id === entry.check.internal_id &&
+        expectedAssertions.has(candidate.assertion_key))
+        .map(({ identity }) => identity);
+    if (!expectedFactRefs.length)
+        return "counterfactual_expected_fact_observation_missing";
+    const preservedFactRefs = baselineEntries
+        .filter(({ candidate, check }) => check.internal_id === entry.check.internal_id &&
+        preservedAssertions.has(candidate.assertion_key))
+        .map(({ identity }) => identity);
+    const allowedFanoutFactRefs = baselineEntries
+        .filter(({ candidate, check }) => check.internal_id === entry.check.internal_id &&
+        allowedFanoutAssertions.has(candidate.assertion_key))
+        .map(({ identity }) => identity);
+    const targetLive = entry.control.preserved_assertions.every((key) => mutatedResult.assertion_results.some((assertion) => assertion.key === key && assertion.passed));
+    let carrierRole = "product";
+    if (!processObserved) {
+        const carrierRoleConflict = mutationTargets
+            .map((target) => classifyMachineObservationCarrierRoleConflict({
+            carrier_pattern: target,
+            expected_authority_patterns: [
+                ...entry.check.verification_inputs,
+                ...protectedAuthorityPaths,
+            ],
+            evidence_role_patterns: [
+                ...entry.check.expected_output_paths,
+                ...entry.check.artifact_globs,
+            ],
+        }))
+            .find((candidate) => candidate !== null);
+        if (carrierRoleConflict)
+            return `counterfactual_static_carrier_${carrierRoleConflict}_forbidden`;
+        carrierRole = mutationTargets.every((target) => bindingCarrierPaths.some((pattern) => matchesRepoPattern(target, pattern)) &&
+            entry.check.input_paths.some((pattern) => matchesRepoPattern(target, pattern)))
+            ? "product"
+            : "evidence";
+    }
+    return validateCounterfactualObservationImpact({
+        baseline_by_fact: baselineByFact,
+        mutated_by_fact: mutatedByFact,
+        expected_affected_fact_refs: expectedFactRefs,
+        preserved_fact_refs: preservedFactRefs,
+        allowed_fanout_fact_refs: allowedFanoutFactRefs,
+        target_live: targetLive,
+        carrier_role: carrierRole,
+    });
+}
+function counterfactualObservationChecks(check, executionUniverse, processObserved) {
+    if (!processObserved)
+        return [check];
+    const checks = new Map([[check.internal_id, check]]);
+    for (const candidate of executionUniverse)
+        if (candidate.raw_execution_identity === check.raw_execution_identity &&
+            (candidate.observation_authorities ?? []).some((authority) => authority.authority !== "external_confirmation"))
+            checks.set(candidate.internal_id, candidate);
+    return [...checks.values()].sort((left, right) => left.internal_id.localeCompare(right.internal_id));
+}
+function packageObservationsForCheck(check, observations) {
+    return observations.filter((candidate) => (check.observation_authorities ?? []).some((authority) => authority.authority === candidate.authority &&
+        authority.observation_identity === candidate.observation_identity &&
+        authority.assertion_ref === candidate.assertion_ref &&
+        authority.obligation_ref === candidate.obligation_ref &&
+        authority.method === candidate.method));
+}
+function observationImpactIdentity(candidate) {
+    return (candidate.authority_key ??
+        `${candidate.assertion_key}\0${candidate.obligation_ref ?? candidate.identity_ref}\0${candidate.method}`);
+}
+function scopedObservationImpactIdentity(check, candidate) {
+    return `${check.internal_id}\0${observationImpactIdentity(candidate)}`;
+}
+function compiledAuthorityPaths(compiled) {
+    return [
+        compiled.contract_file,
+        ...Object.keys(compiled.contract_files),
+        ...Object.keys(compiled.source_hashes),
+        ...compiled.context_snapshot.files,
+    ];
+}
 function playwrightCounterfactualDiagnostic(raw, result, expectedAssertions, rejectionReasons) {
     const caseIds = result.assertion_results
         .map((assertion) => /^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(assertion.observation)?.[1])
@@ -225,23 +506,20 @@ function counterfactualIntegrityFinding(entry, actual) {
         next_action: "Repair the referenced implementation carrier or proof so only the designated Assertion value mismatches demonstrate sensitivity.",
     };
 }
-export function isValidCounterfactualCheckResult(result, expectedAssertionFailures) {
+export function isValidCounterfactualCheckResult(result, expectedAssertionFailures, allowedFanoutAssertions = []) {
     const expected = [...expectedAssertionFailures].sort();
+    const allowed = new Set([...expected, ...allowedFanoutAssertions]);
     const failedAssertions = result.assertion_results
         .filter((assertion) => !assertion.passed)
         .map((assertion) => assertion.key)
         .sort();
     return (result.status === "assertion_failed" &&
-        result.findings.length === expected.length &&
-        result.findings.filter((finding) => finding.assertion_key).length ===
-            expected.length &&
-        result.findings
-            .filter((finding) => finding.assertion_key)
-            .every((finding) => expected.some((key) => finding.assertion_key === key)) &&
+        result.findings.length === failedAssertions.length &&
+        result.findings.every((finding) => Boolean(finding.assertion_key) && allowed.has(finding.assertion_key)) &&
         result.findings.every((finding) => finding.code === "assertion_value_mismatch") &&
         result.assertion_results
             .filter((assertion) => !assertion.passed)
             .every((assertion) => assertion.status === "assertion_value_mismatch") &&
-        failedAssertions.length === expected.length &&
-        failedAssertions.every((item, index) => item === expected[index]));
+        expected.every((item) => failedAssertions.includes(item)) &&
+        failedAssertions.every((item) => allowed.has(item)));
 }

package/dist/lib/long-task-exact-comparison.d.ts

@@ -0,0 +1,16 @@
+export interface ExactDigestComparisonInput {
+    identity: Readonly<Record<string, unknown>>;
+    actual_value_sha256: string;
+    expected_value_sha256: string;
+    comparator: string;
+    mode: "exact" | "tolerance";
+    parameters_sha256: string;
+    tolerance_sha256: string | null;
+    mask_sha256: string | null;
+}
+export interface ExactDigestComparisonResult {
+    passed: boolean;
+    result_sha256: string;
+}
+export declare function evaluateExactDigestComparison(input: ExactDigestComparisonInput): ExactDigestComparisonResult;
+export declare function exactComparisonResultIdentity(material: Readonly<Record<string, unknown>>): string;

package/dist/lib/long-task-exact-comparison.js

@@ -0,0 +1,28 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function evaluateExactDigestComparison(input) {
+    if (input.comparator !== "exact_value" ||
+        input.mode !== "exact" ||
+        input.tolerance_sha256 !== null ||
+        input.mask_sha256 !== null)
+        throw new Error("exact_digest_comparison_authority_invalid");
+    const { actual_value_sha256, expected_value_sha256 } = input;
+    const passed = actual_value_sha256 === expected_value_sha256;
+    const material = {
+        identity: input.identity,
+        actual_value_sha256: input.actual_value_sha256,
+        expected_value_sha256: input.expected_value_sha256,
+        comparator: input.comparator,
+        mode: input.mode,
+        parameters_sha256: input.parameters_sha256,
+        tolerance_sha256: input.tolerance_sha256,
+        mask_sha256: input.mask_sha256,
+        passed,
+    };
+    return {
+        passed,
+        result_sha256: exactComparisonResultIdentity(material),
+    };
+}
+export function exactComparisonResultIdentity(material) {
+    return sha256Hex(canonicalValueJson(material));
+}

package/dist/lib/long-task-execution-observation.d.ts

@@ -0,0 +1,24 @@
+import type { CheckRunnerExecutionContextV2, CompiledCheckV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export interface PreparedExecutionObservationGroupV2 {
+    readonly execution_root: string;
+    readonly runner_context: CheckRunnerExecutionContextV2;
+    finalize(raw: RawCommandExecutionV2): Promise<RawCommandExecutionV2>;
+    dispose(): Promise<void>;
+}
+/**
+ * Freezes every selected Raw Execution group's observation inputs before the
+ * caller is allowed to start any runner. Keeping this as one owner prevents a
+ * prior execution from priming a later group's supposedly pre-run carrier.
+ */
+export declare function prepareExecutionObservationUniverse(input: {
+    groups: readonly (readonly CompiledCheckV2[])[];
+    snapshot_root: string;
+    workspace_manifest: WorkspaceManifestV2;
+    protected_authority_paths?: readonly string[];
+}): Promise<PreparedExecutionObservationGroupV2[]>;
+export declare function prepareExecutionObservationGroup(input: {
+    checks: readonly CompiledCheckV2[];
+    snapshot_root: string;
+    workspace_manifest: WorkspaceManifestV2;
+    protected_authority_paths?: readonly string[];
+}): Promise<PreparedExecutionObservationGroupV2>;