project-tiny-context-harness 0.8.0 → 0.8.2

package/dist/lib/long-task-claims.js

@@ -1,161 +1,29 @@
 import { assertAllClaimsCovered, assertAllGlobalClaimsCovered, generateClaims, generateGlobalClaims, validateGlobalProofPolarity, validateProofSurface, } from "./long-task-claim-definitions.js";
 import { fail } from "./long-task-delivery-shape.js";
 import { validateClaimAssertionOperator, validateGlobalAssertionOperator, } from "./long-task-claim-proof-policy.js";
+import { matchesRepoPattern } from "./long-task-paths.js";
 export function compileProductClaimCoverage(contract, options = {}) {
     const byGlobal = generateGlobalClaims(contract.global);
     const byOutcome = Object.fromEntries(contract.outcomes.map((outcome) => [outcome.key, generateClaims(outcome)]));
     for (const [outcomeKey, claims] of Object.entries(byOutcome))
         if (!claims.some((claim) => claim.kind !== "result"))
             fail("outcome_atomic_claim_required", outcomeKey);
-    const globalClaimMap = new Map(byGlobal.map((claim) => [claim.local_key, claim]));
-    const outcomeClaimIds = new Set(Object.values(byOutcome)
-        .flat()
-        .map((claim) => claim.id));
-    const globalProofs = new Map();
-    const addGlobalProof = (claimKey, proof) => {
-        const claim = globalClaimMap.get(claimKey);
-        if (!claim) {
-            if (outcomeClaimIds.has(claimKey))
-                fail("global_assertion_claim_cross_scope", claimKey);
-            fail("global_assertion_claim_unknown", claimKey);
-        }
-        validateGlobalProofPolarity(claim, proof);
-        const rows = globalProofs.get(claimKey) ?? [];
-        rows.push(proof);
-        globalProofs.set(claimKey, rows);
-    };
-    for (const check of contract.global.acceptance.checks) {
-        const assertionKeys = new Set();
-        for (const [polarity, assertions] of [
-            ["positive", check.positive_assertions],
-            ["negative", check.negative_assertions],
-        ])
-            for (const assertion of assertions) {
-                if (assertionKeys.has(assertion.key))
-                    fail("assertion_key_duplicate", `GLOBAL:${check.key}:${assertion.key}`);
-                assertionKeys.add(assertion.key);
-                validateGlobalAssertionOperator(assertion, check.key);
-                for (const claimKey of assertion.claims)
-                    addGlobalProof(claimKey, {
-                        check_key: check.key,
-                        assertion_key: assertion.key,
-                        polarity,
-                        proof_surface: check.proof_surface,
-                    });
-            }
-    }
-    const globalRows = {};
-    const uncoveredGlobal = [];
-    for (const claim of byGlobal) {
-        const proofs = globalProofs.get(claim.local_key) ?? [];
-        const covered = proofs.length > 0;
-        globalRows[claim.local_key] = { covered, proofs };
-        if (!covered)
-            uncoveredGlobal.push(claim.id);
-    }
+    const globalProfileMap = validateProfiles("GLOBAL", contract.global.applicability, contract.global.acceptance.checks, contract.task.execution_targets.map((target) => target.key));
+    const globalRows = compileGlobalScope(contract, byGlobal, globalProfileMap);
     const outcomeKeys = new Set(contract.outcomes.map((outcome) => outcome.key));
     const globalLocalKeys = new Set(byGlobal.map((claim) => claim.local_key));
-    const summaryRows = {};
-    const uncoveredOutcome = [];
+    const outcomeRows = {};
     for (const outcome of contract.outcomes) {
-        const claims = byOutcome[outcome.key];
-        const claimMap = new Map(claims.map((claim) => [claim.local_key, claim]));
-        const proofs = new Map();
-        const addProof = (claimKey, proof, observation, assertion) => {
-            const claim = claimMap.get(claimKey);
-            if (!claim) {
-                if (globalLocalKeys.has(claimKey))
-                    fail("assertion_claim_cross_scope", `${outcome.key}:${claimKey}`);
-                const first = claimKey.split(".")[0];
-                if (outcomeKeys.has(first) && first !== outcome.key)
-                    fail("assertion_claim_cross_outcome", `${outcome.key}:${claimKey}`);
-                fail("assertion_claim_unknown", `${outcome.key}:${claimKey}`);
-            }
-            if (observation === "playwright.passed" &&
-                (claim.kind === "requirement" || claim.kind === "control"))
-                fail("fine_grained_claim_requires_ac_observation", `${outcome.key}:${claim.local_key}`);
-            validateProofSurface(claim, proof, outcome.key);
-            if (assertion)
-                validateClaimAssertionOperator(claim, assertion, proof.proof_surface, outcome.key, proof.check_key);
-            const rows = proofs.get(claimKey) ?? [];
-            rows.push(proof);
-            proofs.set(claimKey, rows);
-        };
-        for (const check of outcome.acceptance.checks) {
-            const assertionKeys = new Set();
-            for (const [polarity, assertions] of [
-                ["positive", check.positive_assertions],
-                ["negative", check.negative_assertions],
-            ]) {
-                for (const assertion of assertions) {
-                    if (assertionKeys.has(assertion.key))
-                        fail("assertion_key_duplicate", `${outcome.key}:${check.key}:${assertion.key}`);
-                    assertionKeys.add(assertion.key);
-                    for (const claimKey of assertion.claims)
-                        addProof(claimKey, {
-                            check_key: check.key,
-                            assertion_key: assertion.key,
-                            polarity,
-                            proof_surface: check.proof_surface,
-                        }, assertion.observation, assertion);
-                }
-            }
-        }
-        if (outcome.acceptance.population) {
-            const population = outcome.acceptance.population;
-            const check = outcome.acceptance.checks.find((candidate) => candidate.key === population.check_key);
-            if (!check)
-                fail("outcome_check_reference_unknown", `${outcome.key}:${population.check_key}`);
-            for (const claimKey of population.claims)
-                addProof(claimKey, {
-                    check_key: check.key,
-                    assertion_key: null,
-                    polarity: "population",
-                    proof_surface: check.proof_surface,
-                });
-        }
-        for (const counterfactual of outcome.acceptance.counterfactual_controls) {
-            const check = outcome.acceptance.checks.find((candidate) => candidate.key === counterfactual.check_key);
-            if (!check)
-                fail("outcome_check_reference_unknown", `${outcome.key}:${counterfactual.check_key}`);
-            const assertionKeys = new Set([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key));
-            if (!counterfactual.expected_assertion_failures.length)
-                fail("counterfactual_expected_assertion_required", `${outcome.key}:${counterfactual.key}`);
-            for (const assertionKey of counterfactual.expected_assertion_failures)
-                if (!assertionKeys.has(assertionKey))
-                    fail("counterfactual_assertion_unknown", `${outcome.key}:${counterfactual.key}:${assertionKey}`);
-            for (const claimKey of counterfactual.claims)
-                addProof(claimKey, {
-                    check_key: check.key,
-                    assertion_key: counterfactual.expected_assertion_failures.join(","),
-                    polarity: "counterfactual",
-                    proof_surface: check.proof_surface,
-                });
-        }
-        const rows = {};
-        for (const claim of claims) {
-            const claimProofs = proofs.get(claim.local_key) ?? [];
-            const requiredSurfaces = [...claim.required_proof_surfaces].sort();
-            const coveredSurfaces = [
-                ...new Set(claimProofs.map((proof) => proof.proof_surface)),
-            ].sort();
-            const missingSurfaces = requiredSurfaces.filter((surface) => !coveredSurfaces.includes(surface));
-            const covered = claimProofs.length > 0 &&
-                (requiredSurfaces.length === 0 || missingSurfaces.length === 0);
-            rows[claim.local_key] = {
-                required_surfaces: requiredSurfaces,
-                covered_surfaces: coveredSurfaces,
-                missing_surfaces: missingSurfaces,
-                covered,
-                proofs: claimProofs,
-            };
-            if (claimProofs.length && missingSurfaces.length)
-                fail("product_claim_required_surfaces_missing", `${outcome.key}:${claim.local_key}:${missingSurfaces.join(",")}`);
-            if (!covered)
-                uncoveredOutcome.push(claim.id);
-        }
-        summaryRows[outcome.key] = rows;
+        const profiles = validateProfiles(outcome.key, outcome.applicability, outcome.acceptance.checks, contract.task.execution_targets.map((target) => target.key));
+        outcomeRows[outcome.key] = compileOutcomeScope(contract, outcome.key, byOutcome[outcome.key], profiles, outcomeKeys, globalLocalKeys);
     }
+    const uncoveredGlobal = byGlobal
+        .filter((claim) => !globalRows[claim.local_key]?.covered)
+        .map((claim) => claim.id);
+    const uncoveredOutcome = Object.values(byOutcome)
+        .flat()
+        .filter((claim) => !outcomeRows[claim.outcome_key]?.[claim.local_key]?.covered)
+        .map((claim) => claim.id);
     const uncovered = [...uncoveredGlobal, ...uncoveredOutcome].sort();
     const total = byGlobal.length +
         Object.values(byOutcome).reduce((sum, claims) => sum + claims.length, 0);
@@ -167,14 +35,264 @@ export function compileProductClaimCoverage(contract, options = {}) {
             claims_covered: total - uncovered.length,
             uncovered_claims: uncovered,
             claims_by_global: globalRows,
-            claims_by_outcome: summaryRows,
+            claims_by_outcome: outcomeRows,
         },
     };
     if (!options.allow_uncovered)
         assertCompiledClaimsCovered(compiled);
     return compiled;
 }
+function compileGlobalScope(contract, claims, profiles) {
+    const claimMap = new Map(claims.map((claim) => [claim.local_key, claim]));
+    const outcomeClaimIds = new Set(contract.outcomes.flatMap((outcome) => generateClaims(outcome).map((claim) => claim.id)));
+    const proofs = new Map();
+    for (const proof of scopeAssertions(contract.global.acceptance.checks)) {
+        validateAssertionArity(proof.assertion, "GLOBAL", proof.check.key);
+        if (!proof.assertion.claims.length)
+            continue;
+        const claimKey = proof.assertion.claims[0];
+        const claim = claimMap.get(claimKey);
+        if (!claim) {
+            if (outcomeClaimIds.has(claimKey))
+                fail("global_assertion_claim_cross_scope", claimKey);
+            fail("global_assertion_claim_unknown", claimKey);
+        }
+        const applicabilityRef = validateAssertionApplicability(claim.applicability_refs, proof, profiles, "GLOBAL");
+        const claimProof = {
+            check_key: proof.check.key,
+            assertion_key: proof.assertion.key,
+            polarity: proof.polarity,
+            proof_surface: proof.check.proof_surface,
+            applicability_ref: applicabilityRef,
+        };
+        validateGlobalProofPolarity(claim, claimProof);
+        validateGlobalAssertionOperator(proof.assertion, proof.check.key);
+        addProof(proofs, claimKey, claimProof);
+    }
+    validateProfileUse("GLOBAL", profiles, claims);
+    return Object.fromEntries(claims.map((claim) => {
+        const claimProofs = proofs.get(claim.local_key) ?? [];
+        const coverage = applicabilityCoverage(claim.applicability_refs, claimProofs, [], claim.required_polarity);
+        return [
+            claim.local_key,
+            {
+                covered: coverage.uncovered.length === 0,
+                applicability_refs: [...claim.applicability_refs].sort(),
+                uncovered_applicability_refs: coverage.uncovered,
+                proofs: claimProofs,
+            },
+        ];
+    }));
+}
+function compileOutcomeScope(contract, outcomeKey, claims, profiles, outcomeKeys, globalLocalKeys) {
+    const outcome = contract.outcomes.find((candidate) => candidate.key === outcomeKey);
+    const claimMap = new Map(claims.map((claim) => [claim.local_key, claim]));
+    const proofs = new Map();
+    for (const proof of scopeAssertions(outcome.acceptance.checks)) {
+        validateAssertionArity(proof.assertion, outcomeKey, proof.check.key);
+        if (!proof.assertion.claims.length)
+            continue;
+        const claimKey = proof.assertion.claims[0];
+        const claim = claimMap.get(claimKey);
+        if (!claim) {
+            if (globalLocalKeys.has(claimKey))
+                fail("assertion_claim_cross_scope", `${outcomeKey}:${claimKey}`);
+            const first = claimKey.split(".")[0];
+            if (outcomeKeys.has(first) && first !== outcomeKey)
+                fail("assertion_claim_cross_outcome", `${outcomeKey}:${claimKey}`);
+            fail("assertion_claim_unknown", `${outcomeKey}:${claimKey}`);
+        }
+        if (proof.assertion.observation === "playwright.passed" &&
+            (claim.kind === "requirement" ||
+                claim.kind === "control" ||
+                claim.kind === "control_relation"))
+            fail("fine_grained_claim_requires_ac_observation", `${outcomeKey}:${claim.local_key}`);
+        const applicabilityRef = validateAssertionApplicability(claim.applicability_refs, proof, profiles, outcomeKey);
+        const claimProof = {
+            check_key: proof.check.key,
+            assertion_key: proof.assertion.key,
+            polarity: proof.polarity,
+            proof_surface: proof.check.proof_surface,
+            applicability_ref: applicabilityRef,
+        };
+        validateProofSurface(claim, claimProof, outcomeKey);
+        validateClaimAssertionOperator(claim, proof.assertion, proof.check.proof_surface, outcomeKey, proof.check.key);
+        addProof(proofs, claimKey, claimProof);
+    }
+    validatePopulationReferences(outcome, claimMap);
+    validateCounterfactualReferences(outcome, claimMap);
+    validateProfileUse(outcomeKey, profiles, claims);
+    return Object.fromEntries(claims.map((claim) => {
+        const claimProofs = proofs.get(claim.local_key) ?? [];
+        const requiredSurfaces = [...claim.required_proof_surfaces].sort();
+        const coveredSurfaces = [
+            ...new Set(claimProofs.map((proof) => proof.proof_surface)),
+        ].sort();
+        const missingSurfaces = requiredSurfaces.filter((surface) => !coveredSurfaces.includes(surface));
+        const coverage = applicabilityCoverage(claim.applicability_refs, claimProofs, requiredSurfaces, claim.required_polarity);
+        return [
+            claim.local_key,
+            {
+                required_surfaces: requiredSurfaces,
+                covered_surfaces: coveredSurfaces,
+                missing_surfaces: missingSurfaces,
+                covered: coverage.uncovered.length === 0,
+                applicability_refs: [...claim.applicability_refs].sort(),
+                uncovered_applicability_refs: coverage.uncovered,
+                proofs: claimProofs,
+            },
+        ];
+    }));
+}
+function validateProfiles(scope, profiles, checks, targetRefs) {
+    const result = new Map();
+    const targets = new Set(targetRefs);
+    for (const profile of profiles) {
+        if (result.has(profile.key))
+            fail("claim_applicability_key_duplicate", `${scope}:${profile.key}`);
+        if (!targets.has(profile.target_ref))
+            fail("claim_applicability_target_unknown", `${scope}:${profile.key}:${profile.target_ref}`);
+        validateUniqueNonemptyRefs(profile.given_refs, "claim_applicability_given_refs", `${scope}:${profile.key}`);
+        validateUniqueNonemptyRefs(profile.when_refs, "claim_applicability_when_refs", `${scope}:${profile.key}`);
+        result.set(profile.key, profile);
+    }
+    validateScenarioStepSemantics(scope, checks);
+    return result;
+}
+function validateScenarioStepSemantics(scope, checks) {
+    for (const phase of ["given", "when"]) {
+        const semantics = new Map();
+        for (const check of checks) {
+            const seen = new Set();
+            for (const step of check.scenario[phase]) {
+                if (seen.has(step.key))
+                    fail("check_scenario_step_duplicate", `${scope}:${check.key}:${phase}:${step.key}`);
+                seen.add(step.key);
+                const previous = semantics.get(step.key);
+                if (previous !== undefined && previous !== step.statement)
+                    fail("check_scenario_step_semantics_conflict", `${scope}:${phase}:${step.key}`);
+                semantics.set(step.key, step.statement);
+            }
+        }
+    }
+}
+function validateAssertionArity(assertion, scope, checkKey) {
+    if (assertion.claims.length > 1)
+        fail("assertion_single_claim_required", `${scope}:${checkKey}:${assertion.key}`);
+    if (assertion.claims.length === 1 && !assertion.applicability_ref)
+        fail("assertion_applicability_ref_required", `${scope}:${checkKey}:${assertion.key}`);
+    if (!assertion.claims.length && assertion.applicability_ref)
+        fail("claimless_assertion_applicability_ref_forbidden", `${scope}:${checkKey}:${assertion.key}`);
+}
+function validateAssertionApplicability(claimRefs, proof, profiles, scope) {
+    validateUniqueNonemptyRefs(claimRefs, "claim_applicability_refs", `${scope}:${proof.assertion.claims[0]}`);
+    const reference = proof.assertion.applicability_ref;
+    if (!claimRefs.includes(reference))
+        fail("claim_assertion_applicability_not_declared", `${scope}:${proof.assertion.claims[0]}:${reference}`);
+    const profile = profiles.get(reference);
+    if (!profile)
+        fail("claim_applicability_ref_unknown", `${scope}:${proof.assertion.claims[0]}:${reference}`);
+    const label = `${scope}:${proof.check.key}:${proof.assertion.key}:${reference}`;
+    if (proof.check.execution_target.target_ref !== profile.target_ref)
+        fail("claim_applicability_target_mismatch", label);
+    if (!proof.check.journey_roles.includes(profile.journey_role))
+        fail("claim_applicability_journey_mismatch", label);
+    if (!sameSet(proof.check.scenario.given.map((step) => step.key), profile.given_refs))
+        fail("claim_applicability_given_mismatch", label);
+    if (proof.check.scenario.when.map((step) => step.key).join("\0") !==
+        profile.when_refs.join("\0"))
+        fail("claim_applicability_when_mismatch", label);
+    return reference;
+}
+function validatePopulationReferences(outcome, claims) {
+    const population = outcome.acceptance.population;
+    if (!population)
+        return;
+    const check = outcome.acceptance.checks.find((candidate) => candidate.key === population.check_key);
+    if (!check)
+        fail("outcome_check_reference_unknown", `${outcome.key}:${population.check_key}`);
+    const universeBinding = outcome.technical.bindings.find((binding) => binding.key === population.universe_binding_key);
+    if (!universeBinding)
+        fail("population_universe_binding_unknown", `${outcome.key}:${population.universe_binding_key}`);
+    const missingUniverseInputs = universeBinding.carrier_paths.filter((carrier) => !check.input_paths.some((pattern) => matchesRepoPattern(carrier, pattern)));
+    if (missingUniverseInputs.length)
+        fail("population_universe_carrier_input_missing", `${outcome.key}:${population.check_key}:${missingUniverseInputs.join(",")}`);
+    for (const claim of population.claims)
+        if (!claims.has(claim))
+            fail("assertion_claim_unknown", `${outcome.key}:${claim}`);
+}
+function validateCounterfactualReferences(outcome, claims) {
+    for (const control of outcome.acceptance.counterfactual_controls) {
+        const check = outcome.acceptance.checks.find((candidate) => candidate.key === control.check_key);
+        if (!check)
+            fail("outcome_check_reference_unknown", `${outcome.key}:${control.check_key}`);
+        const assertions = new Set([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key));
+        if (!control.expected_assertion_failures.length)
+            fail("counterfactual_expected_assertion_required", `${outcome.key}:${control.key}`);
+        for (const assertion of [
+            ...control.expected_assertion_failures,
+            ...control.preserved_assertions,
+        ])
+            if (!assertions.has(assertion))
+                fail("counterfactual_assertion_unknown", `${outcome.key}:${control.key}:${assertion}`);
+        for (const claim of control.claims)
+            if (!claims.has(claim))
+                fail("assertion_claim_unknown", `${outcome.key}:${claim}`);
+    }
+}
+function scopeAssertions(checks) {
+    return checks.flatMap((check) => [
+        ...check.positive_assertions.map((assertion) => ({
+            check,
+            assertion,
+            polarity: "positive",
+        })),
+        ...check.negative_assertions.map((assertion) => ({
+            check,
+            assertion,
+            polarity: "negative",
+        })),
+    ]);
+}
+function applicabilityCoverage(refs, proofs, requiredSurfaces, requiredPolarity) {
+    const uncovered = refs.filter((reference) => {
+        const matching = proofs.filter((proof) => proof.applicability_ref === reference &&
+            proof.polarity === requiredPolarity);
+        if (!matching.length)
+            return true;
+        return requiredSurfaces.some((surface) => !matching.some((proof) => proof.proof_surface === surface));
+    });
+    return { uncovered: [...uncovered].sort() };
+}
+function validateProfileUse(scope, profiles, claims) {
+    const used = new Set(claims.flatMap((claim) => claim.applicability_refs));
+    for (const reference of used)
+        if (!profiles.has(reference))
+            fail("claim_applicability_ref_unknown", `${scope}:${reference}`);
+    for (const reference of profiles.keys())
+        if (!used.has(reference))
+            fail("claim_applicability_profile_unused", `${scope}:${reference}`);
+}
+function validateUniqueNonemptyRefs(refs, code, detail) {
+    if (!refs.length)
+        fail(`${code}_required`, detail);
+    if (new Set(refs).size !== refs.length)
+        fail(`${code}_duplicate`, detail);
+}
+function addProof(proofs, claim, proof) {
+    const rows = proofs.get(claim) ?? [];
+    rows.push(proof);
+    proofs.set(claim, rows);
+}
+function sameSet(left, right) {
+    return (left.length === right.length &&
+        new Set(left).size === left.length &&
+        left.every((item) => right.includes(item)));
+}
 export function assertCompiledClaimsCovered(compiled) {
+    for (const [outcomeKey, claims] of Object.entries(compiled.by_outcome))
+        for (const claim of claims)
+            assertRequiredSurfacesForEveryApplicability(outcomeKey, claim, compiled.summary.claims_by_outcome[outcomeKey]?.[claim.local_key]);
     const uncoveredGlobal = compiled.by_global
         .filter((claim) => !compiled.summary.claims_by_global[claim.local_key]?.covered)
         .map((claim) => claim.id);
@@ -185,3 +303,14 @@ export function assertCompiledClaimsCovered(compiled) {
     assertAllGlobalClaimsCovered(uncoveredGlobal);
     assertAllClaimsCovered(uncoveredOutcome);
 }
+function assertRequiredSurfacesForEveryApplicability(scope, claim, summary) {
+    if (!summary || !claim.required_proof_surfaces.length)
+        return;
+    for (const applicabilityRef of claim.applicability_refs) {
+        const proofs = summary.proofs.filter((proof) => proof.applicability_ref === applicabilityRef &&
+            proof.polarity === claim.required_polarity);
+        const missing = claim.required_proof_surfaces.filter((surface) => !proofs.some((proof) => proof.proof_surface === surface));
+        if (missing.length)
+            fail("product_claim_required_surfaces_missing", `${scope}:${claim.local_key}:${applicabilityRef}:${missing.sort().join(",")}`);
+    }
+}

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

@@ -1,6 +1,7 @@
 import type { LongTaskRiskFacts, RequestedRiskLevel } from "./long-task-risk-types.js";
 import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./long-task-counterfactual-types.js";
-import type { CheckExecutionTargetV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
+import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
+import type { ApplicableKeyedStatementV2, CheckExecutionTargetV2, ClaimApplicabilityV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
@@ -51,6 +52,7 @@ interface DeliveryAssertionBaseV2 {
     key: string;
     criterion?: string;
     claims: string[];
+    applicability_ref?: string;
     observation: string;
     evidence_capabilities: EvidenceCapabilityV2[];
 }
@@ -125,8 +127,33 @@ export interface DeliveryControlV2 {
     permission: string;
     feedback: string;
     accessibility: string;
+    field_coverage: DeliveryControlFieldCoverageV2[];
 }
-interface DeliveryRequirementV2 extends KeyedStatementV2 {
+export type DeliveryControlFieldCoverageV2 = {
+    fields: DeliveryControlFieldNameV2[];
+    state: "specified";
+    applicability_refs: string[];
+} | {
+    fields: DeliveryControlFieldNameV2[];
+    state: "not_applicable";
+    statement: string;
+    applicability_refs: string[];
+} | {
+    fields: DeliveryControlFieldNameV2[];
+    state: "unresolved";
+    statement: string;
+    applicability_refs: string[];
+};
+export interface DeliveryControlRelationV2 extends ApplicableKeyedStatementV2 {
+    control_refs: string[];
+    required_proof_surfaces: ProofSurface[];
+}
+export interface DeliveryControlRelationClosureV2 {
+    state: "specified" | "not_applicable" | "unresolved";
+    statement: string;
+    applicability_refs: string[];
+}
+interface DeliveryRequirementV2 extends ApplicableKeyedStatementV2 {
     required_proof_surfaces: ProofSurface[];
 }
 export interface DeliveryOwnerV2 {
@@ -134,7 +161,7 @@ export interface DeliveryOwnerV2 {
     context_refs: string[];
     path_globs: string[];
 }
-export interface DeliveryObligationV2 extends KeyedStatementV2 {
+export interface DeliveryObligationV2 extends ApplicableKeyedStatementV2 {
     required_proof_surfaces: ProofSurface[];
 }
 export interface DeliveryBindingV2 {
@@ -152,8 +179,10 @@ export interface RollbackRecoveryV2 {
 }
 export interface PopulationRequirementV2 {
     check_key: string;
+    universe_binding_key: string;
     claims: string[];
     observations: {
+        universe_ids: string;
         eligible_ids: string;
         observed_ids: string;
         excluded_items: string;
@@ -165,16 +194,20 @@ export interface DeliveryOutcomeV2 {
     title: string;
     stage: string;
     depends_on: string[];
+    applicability: ClaimApplicabilityV2[];
     product: {
         observable_result: string;
+        result_applicability_refs: string[];
         success_path_required: boolean;
         degradation_path_required: boolean;
         owner: DeliveryOwnerV2;
         requirements: DeliveryRequirementV2[];
         owner_surfaces: string[];
         controls: DeliveryControlV2[];
+        control_relation_closure: DeliveryControlRelationClosureV2;
+        control_relations: DeliveryControlRelationV2[];
         surface_bindings: DeliverySurfaceBindingV2[];
-        non_completing_outcomes: KeyedStatementV2[];
+        non_completing_outcomes: ApplicableKeyedStatementV2[];
     };
     technical: {
         obligations: DeliveryObligationV2[];
@@ -182,7 +215,7 @@ export interface DeliveryOutcomeV2 {
         allowed_support_paths: string[];
         forbidden_paths: string[];
         bindings: DeliveryBindingV2[];
-        forbidden_shortcuts: KeyedStatementV2[];
+        forbidden_shortcuts: ApplicableKeyedStatementV2[];
         rollback_and_recovery: RollbackRecoveryV2 | null;
     };
     acceptance: {
@@ -210,13 +243,14 @@ export interface DeliveryContractV2 {
         facts: LongTaskRiskFacts;
     };
     global: {
+        applicability: ClaimApplicabilityV2[];
         product: {
-            non_goals: KeyedStatementV2[];
+            non_goals: ApplicableKeyedStatementV2[];
         };
         technical: {
-            constraints: KeyedStatementV2[];
+            constraints: ApplicableKeyedStatementV2[];
             forbidden_paths: KeyedPathV2[];
-            forbidden_shortcuts: KeyedStatementV2[];
+            forbidden_shortcuts: ApplicableKeyedStatementV2[];
         };
         acceptance: {
             checks: DeliveryCheckV2[];

package/dist/lib/long-task-control-fields.d.ts

@@ -0,0 +1,12 @@
+import type { DeliveryControlV2 } from "./long-task-contract-types.js";
+import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
+export declare const CONTROL_FIELD_NAMES: readonly ["surface", "region", "location", "control_type", "label_content", "user_task", "visibility", "availability", "trigger", "input", "validation", "default_value", "interaction", "navigation_result", "loading_state", "empty_state", "success_state", "failure_state", "recovery", "permission", "feedback", "accessibility"];
+export interface ControlFieldFactV2 {
+    contract_field: DeliveryControlFieldNameV2;
+    claim_field: string;
+    statement: string;
+    state: "specified" | "not_applicable" | "unresolved";
+    applicability_refs: string[];
+}
+export declare function controlFieldFacts(control: DeliveryControlV2): ControlFieldFactV2[];
+export declare function controlFieldState(control: DeliveryControlV2, field: DeliveryControlFieldNameV2): ControlFieldFactV2["state"];

package/dist/lib/long-task-control-fields.js

@@ -0,0 +1,66 @@
+export const CONTROL_FIELD_NAMES = [
+    "surface",
+    "region",
+    "location",
+    "control_type",
+    "label_content",
+    "user_task",
+    "visibility",
+    "availability",
+    "trigger",
+    "input",
+    "validation",
+    "default_value",
+    "interaction",
+    "navigation_result",
+    "loading_state",
+    "empty_state",
+    "success_state",
+    "failure_state",
+    "recovery",
+    "permission",
+    "feedback",
+    "accessibility",
+];
+const CLAIM_FIELD_BY_CONTRACT_FIELD = {
+    surface: "surface",
+    region: "region",
+    location: "location",
+    control_type: "control_type",
+    label_content: "label_content",
+    user_task: "user_task",
+    visibility: "visibility",
+    availability: "availability",
+    trigger: "trigger",
+    input: "input",
+    validation: "validation",
+    default_value: "default_value",
+    interaction: "interaction",
+    navigation_result: "navigation_result",
+    loading_state: "loading",
+    empty_state: "empty",
+    success_state: "success",
+    failure_state: "failure",
+    recovery: "recovery",
+    permission: "permission",
+    feedback: "feedback",
+    accessibility: "accessibility",
+};
+export function controlFieldFacts(control) {
+    const coverage = new Map(control.field_coverage.flatMap((entry) => entry.fields.map((field) => [field, entry])));
+    return CONTROL_FIELD_NAMES.map((field) => {
+        const entry = coverage.get(field);
+        if (!entry)
+            throw new Error(`control_field_coverage_missing:${control.key}:${field}`);
+        return {
+            contract_field: field,
+            claim_field: CLAIM_FIELD_BY_CONTRACT_FIELD[field],
+            statement: entry.state === "specified" ? control[field] : entry.statement,
+            state: entry.state,
+            applicability_refs: [...entry.applicability_refs],
+        };
+    });
+}
+export function controlFieldState(control, field) {
+    return controlFieldFacts(control).find((candidate) => candidate.contract_field === field).state;
+}

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

@@ -0,0 +1 @@
+export type DeliveryControlFieldNameV2 = "surface" | "region" | "location" | "control_type" | "label_content" | "user_task" | "visibility" | "availability" | "trigger" | "input" | "validation" | "default_value" | "interaction" | "navigation_result" | "loading_state" | "empty_state" | "success_state" | "failure_state" | "recovery" | "permission" | "feedback" | "accessibility";

package/dist/lib/long-task-control-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -54,4 +54,11 @@ function validateExpectedAssertions(control, check, unknownPrefix) {
     for (const key of control.expected_assertion_failures)
         if (!assertions.has(key))
             throw new Error(`${unknownPrefix}:${key}`);
+    const failures = new Set(control.expected_assertion_failures);
+    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}`);
+    }
 }