project-tiny-context-harness 0.8.1 → 0.8.2

package/dist/lib/long-task-authoring-preflight.js

@@ -22,14 +22,18 @@ export async function preflightDeliveryContract(workdirInput, projectRootInput =
     }
     const contract = parsed.contract;
     addAuthoringDiagnostics(contract, parsed, diagnostics);
-    const validation = await validateContractForActivation({
-        repository,
-        workdir,
-        contract,
-        mode: "collect",
-        diagnostics,
-    });
-    const active = await loadAuthoringActiveAuthority(repository, workdir, diagnostics);
+    const activeDiagnostics = [];
+    const [validation, active] = await Promise.all([
+        validateContractForActivation({
+            repository,
+            workdir,
+            contract,
+            mode: "collect",
+            diagnostics,
+        }),
+        loadAuthoringActiveAuthority(repository, workdir, activeDiagnostics),
+    ]);
+    diagnostics.push(...activeDiagnostics);
     if (validation.workspace)
         try {
             const changedPaths = active?.workdir === workdir

package/dist/lib/long-task-authority-materials.js

@@ -31,12 +31,20 @@ export function projectProductSemantics(contract) {
         target_profile: contract.task.target_profile,
         execution_targets: [...contract.task.execution_targets].sort(keyOrder),
         stages: [...contract.stages].sort(keyOrder),
-        global_non_goals: keyedStatements(contract.global.product.non_goals),
+        global_non_goals: applicableStatements(contract.global.product.non_goals),
         outcomes: [...contract.outcomes].sort(keyOrder).map((outcome) => ({
             key: outcome.key,
             title: outcome.title,
             stage: outcome.stage,
+            applicability: [...outcome.applicability].sort(keyOrder).map((item) => ({
+                ...item,
+                given_refs: [...item.given_refs],
+                when_refs: [...item.when_refs],
+            })),
             observable_result: outcome.product.observable_result,
+            result_applicability_refs: [
+                ...outcome.product.result_applicability_refs,
+            ].sort(),
             success_path_required: outcome.product.success_path_required,
             degradation_path_required: outcome.product.degradation_path_required,
             owner: {
@@ -51,6 +59,7 @@ export function projectProductSemantics(contract) {
                 required_proof_surfaces: [
                     ...requirement.required_proof_surfaces,
                 ].sort(),
+                applicability_refs: [...requirement.applicability_refs].sort(),
             })),
             controls: [...outcome.product.controls].sort(keyOrder).map((control) => ({
                 key: control.key,
@@ -76,6 +85,20 @@ export function projectProductSemantics(contract) {
                 permission: control.permission,
                 feedback: control.feedback,
                 accessibility: control.accessibility,
+                field_coverage: [...control.field_coverage].map((entry) => ({
+                    ...entry,
+                    fields: [...entry.fields].sort(),
+                    applicability_refs: [...entry.applicability_refs].sort(),
+                })),
+            })),
+            control_relation_closure: outcome.product.control_relation_closure,
+            control_relations: [...outcome.product.control_relations]
+                .sort(keyOrder)
+                .map((relation) => ({
+                ...relation,
+                control_refs: [...relation.control_refs].sort(),
+                required_proof_surfaces: [...relation.required_proof_surfaces].sort(),
+                applicability_refs: [...relation.applicability_refs].sort(),
             })),
             surface_bindings: [...(outcome.product.surface_bindings ?? [])]
                 .sort(keyOrder)
@@ -96,16 +119,26 @@ export function projectProductSemantics(contract) {
                     .map((blocker) => ({
                     ...blocker,
                     refs: [...blocker.refs].sort(),
+                    source_item_refs: [...blocker.source_item_refs].sort(),
+                    verification_methods: [...blocker.verification_methods].sort(),
+                    required_capabilities: [...blocker.required_capabilities].sort(),
                 })),
             })),
-            non_completing_outcomes: keyedStatements(outcome.product.non_completing_outcomes),
+            non_completing_outcomes: applicableStatements(outcome.product.non_completing_outcomes),
         })),
     };
 }
 export function projectGlobalSemantics(contract) {
     return {
-        constraints: keyedStatements(contract.global.technical.constraints),
-        forbidden_shortcuts: keyedStatements(contract.global.technical.forbidden_shortcuts),
+        applicability: [...contract.global.applicability]
+            .sort(keyOrder)
+            .map((item) => ({
+            ...item,
+            given_refs: [...item.given_refs],
+            when_refs: [...item.when_refs],
+        })),
+        constraints: applicableStatements(contract.global.technical.constraints),
+        forbidden_shortcuts: applicableStatements(contract.global.technical.forbidden_shortcuts),
     };
 }
 function keyedStatements(values) {
@@ -113,6 +146,15 @@ function keyedStatements(values) {
         .sort(keyOrder)
         .map(({ key, statement }) => ({ key, statement }));
 }
+function applicableStatements(values) {
+    return [...values]
+        .sort(keyOrder)
+        .map(({ key, statement, applicability_refs }) => ({
+        key,
+        statement,
+        applicability_refs: [...applicability_refs].sort(),
+    }));
+}
 function keyOrder(left, right) {
     return left.key.localeCompare(right.key);
 }

package/dist/lib/long-task-authority-policy.d.ts

@@ -35,6 +35,12 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         requested_level: "semantic_user_review";
         facts: "semantic_user_review";
     };
+    readonly global: {
+        applicability: "semantic_user_review";
+        product: "semantic_user_review";
+        technical: "semantic_user_review";
+        acceptance: "proof_additive";
+    };
     readonly global_product: {
         non_goals: "semantic_user_review";
     };
@@ -53,18 +59,35 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         title: "descriptive_non_authoritative";
         stage: "semantic_user_review";
         depends_on: "readiness_only";
+        applicability: "semantic_user_review";
         product: "semantic_user_review";
         technical: "semantic_user_review";
         acceptance: "proof_additive";
     };
+    readonly claim_applicability: {
+        key: "identity";
+        target_ref: "semantic_user_review";
+        journey_role: "semantic_user_review";
+        dimensions: "semantic_user_review";
+        given_refs: "semantic_user_review";
+        when_refs: "semantic_user_review";
+    };
+    readonly applicable_statement: {
+        key: "identity";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+    };
     readonly outcome_product: {
         observable_result: "semantic_user_review";
+        result_applicability_refs: "semantic_user_review";
         success_path_required: "semantic_user_review";
         degradation_path_required: "semantic_user_review";
         owner: "semantic_user_review";
         requirements: "semantic_user_review";
         owner_surfaces: "semantic_user_review";
         controls: "semantic_user_review";
+        control_relation_closure: "semantic_user_review";
+        control_relations: "semantic_user_review";
         surface_bindings: "semantic_user_review";
         non_completing_outcomes: "semantic_user_review";
     };
@@ -72,6 +95,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         key: "identity";
         statement: "semantic_user_review";
         required_proof_surfaces: "proof_additive";
+        applicability_refs: "semantic_user_review";
     };
     readonly owner: {
         label: "identity";
@@ -102,6 +126,25 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         permission: "semantic_user_review";
         feedback: "semantic_user_review";
         accessibility: "semantic_user_review";
+        field_coverage: "semantic_user_review";
+    };
+    readonly control_field_coverage: {
+        fields: "semantic_user_review";
+        state: "semantic_user_review";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+    };
+    readonly control_relation_closure: {
+        state: "semantic_user_review";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+    };
+    readonly control_relation: {
+        key: "identity";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+        control_refs: "semantic_user_review";
+        required_proof_surfaces: "proof_additive";
     };
     readonly surface_binding: {
         key: "identity";
@@ -127,12 +170,18 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         actual_artifact_path: "output_requirement";
         comparison_artifact_path: "output_requirement";
     };
+    readonly design_verification_binding: {
+        method: "proof_additive";
+        assertion_ref: "proof_additive";
+        evidence_artifacts: "output_requirement";
+    };
     readonly design_blocker: {
         key: "identity";
         status: "semantic_user_review";
         refs: "semantic_user_review";
         source_item_refs: "semantic_user_review";
         verification_methods: "proof_additive";
+        required_capabilities: "semantic_user_review";
         rationale: "semantic_user_review";
     };
     readonly outcome_technical: {
@@ -148,6 +197,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         key: "identity";
         statement: "semantic_user_review";
         required_proof_surfaces: "proof_additive";
+        applicability_refs: "semantic_user_review";
     };
     readonly binding: {
         key: "identity";
@@ -186,6 +236,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         key: "identity";
         criterion: "semantic_user_review";
         claims: "proof_additive";
+        applicability_ref: "proof_additive";
         observation: "proof_additive";
         evidence_capabilities: "proof_additive";
         operator: "proof_additive";
@@ -203,6 +254,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly population: {
         check_key: "proof_additive";
+        universe_binding_key: "proof_additive";
         claims: "proof_additive";
         observations: "proof_additive";
         exclusion_rules: "proof_additive";
@@ -214,6 +266,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         check_key: "proof_additive";
         mutation: "proof_additive";
         expected_assertion_failures: "proof_additive";
+        preserved_assertions: "proof_additive";
     };
     readonly global_counterfactual: {
         key: "identity";
@@ -222,6 +275,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         check_key: "proof_additive";
         mutation: "proof_additive";
         expected_assertion_failures: "proof_additive";
+        preserved_assertions: "proof_additive";
     };
 };
 export declare function projectFieldsByPolicy<T extends object>(value: T, policy: Record<keyof T, AuthorityFieldPolicy>, included: ReadonlySet<AuthorityFieldPolicy>): Partial<T>;

package/dist/lib/long-task-authority-policy.js

@@ -18,6 +18,12 @@ const RISK_AUTHORITY_POLICY = {
     requested_level: "semantic_user_review",
     facts: "semantic_user_review",
 };
+const GLOBAL_AUTHORITY_POLICY = {
+    applicability: "semantic_user_review",
+    product: "semantic_user_review",
+    technical: "semantic_user_review",
+    acceptance: "proof_additive",
+};
 const GLOBAL_PRODUCT_AUTHORITY_POLICY = {
     non_goals: "semantic_user_review",
 };
@@ -36,18 +42,35 @@ const OUTCOME_AUTHORITY_POLICY = {
     title: "descriptive_non_authoritative",
     stage: "semantic_user_review",
     depends_on: "readiness_only",
+    applicability: "semantic_user_review",
     product: "semantic_user_review",
     technical: "semantic_user_review",
     acceptance: "proof_additive",
 };
+const CLAIM_APPLICABILITY_AUTHORITY_POLICY = {
+    key: "identity",
+    target_ref: "semantic_user_review",
+    journey_role: "semantic_user_review",
+    dimensions: "semantic_user_review",
+    given_refs: "semantic_user_review",
+    when_refs: "semantic_user_review",
+};
+const APPLICABLE_STATEMENT_AUTHORITY_POLICY = {
+    key: "identity",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+};
 const OUTCOME_PRODUCT_AUTHORITY_POLICY = {
     observable_result: "semantic_user_review",
+    result_applicability_refs: "semantic_user_review",
     success_path_required: "semantic_user_review",
     degradation_path_required: "semantic_user_review",
     owner: "semantic_user_review",
     requirements: "semantic_user_review",
     owner_surfaces: "semantic_user_review",
     controls: "semantic_user_review",
+    control_relation_closure: "semantic_user_review",
+    control_relations: "semantic_user_review",
     surface_bindings: "semantic_user_review",
     non_completing_outcomes: "semantic_user_review",
 };
@@ -55,6 +78,7 @@ const REQUIREMENT_AUTHORITY_POLICY = {
     key: "identity",
     statement: "semantic_user_review",
     required_proof_surfaces: "proof_additive",
+    applicability_refs: "semantic_user_review",
 };
 const OWNER_AUTHORITY_POLICY = {
     label: "identity",
@@ -85,6 +109,25 @@ const CONTROL_AUTHORITY_POLICY = {
     permission: "semantic_user_review",
     feedback: "semantic_user_review",
     accessibility: "semantic_user_review",
+    field_coverage: "semantic_user_review",
+};
+const CONTROL_FIELD_COVERAGE_AUTHORITY_POLICY = {
+    fields: "semantic_user_review",
+    state: "semantic_user_review",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+};
+const CONTROL_RELATION_CLOSURE_AUTHORITY_POLICY = {
+    state: "semantic_user_review",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+};
+const CONTROL_RELATION_AUTHORITY_POLICY = {
+    key: "identity",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+    control_refs: "semantic_user_review",
+    required_proof_surfaces: "proof_additive",
 };
 const SURFACE_BINDING_AUTHORITY_POLICY = {
     key: "identity",
@@ -110,12 +153,18 @@ const DESIGN_TARGET_AUTHORITY_POLICY = {
     actual_artifact_path: "output_requirement",
     comparison_artifact_path: "output_requirement",
 };
+const DESIGN_VERIFICATION_BINDING_AUTHORITY_POLICY = {
+    method: "proof_additive",
+    assertion_ref: "proof_additive",
+    evidence_artifacts: "output_requirement",
+};
 const DESIGN_BLOCKER_AUTHORITY_POLICY = {
     key: "identity",
     status: "semantic_user_review",
     refs: "semantic_user_review",
     source_item_refs: "semantic_user_review",
     verification_methods: "proof_additive",
+    required_capabilities: "semantic_user_review",
     rationale: "semantic_user_review",
 };
 const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
@@ -131,6 +180,7 @@ const OBLIGATION_AUTHORITY_POLICY = {
     key: "identity",
     statement: "semantic_user_review",
     required_proof_surfaces: "proof_additive",
+    applicability_refs: "semantic_user_review",
 };
 const BINDING_AUTHORITY_POLICY = {
     key: "identity",
@@ -169,6 +219,7 @@ const ASSERTION_AUTHORITY_POLICY = {
     key: "identity",
     criterion: "semantic_user_review",
     claims: "proof_additive",
+    applicability_ref: "proof_additive",
     observation: "proof_additive",
     evidence_capabilities: "proof_additive",
     operator: "proof_additive",
@@ -186,6 +237,7 @@ const RUNNER_AUTHORITY_POLICY = {
 };
 const POPULATION_AUTHORITY_POLICY = {
     check_key: "proof_additive",
+    universe_binding_key: "proof_additive",
     claims: "proof_additive",
     observations: "proof_additive",
     exclusion_rules: "proof_additive",
@@ -197,6 +249,7 @@ const COUNTERFACTUAL_AUTHORITY_POLICY = {
     check_key: "proof_additive",
     mutation: "proof_additive",
     expected_assertion_failures: "proof_additive",
+    preserved_assertions: "proof_additive",
 };
 const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
     key: "identity",
@@ -205,21 +258,29 @@ const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
     check_key: "proof_additive",
     mutation: "proof_additive",
     expected_assertion_failures: "proof_additive",
+    preserved_assertions: "proof_additive",
 };
 export const AUTHORITY_FIELD_POLICY_REGISTRIES = {
     task: TASK_AUTHORITY_POLICY,
     source_claim: SOURCE_CLAIM_AUTHORITY_POLICY,
     risk: RISK_AUTHORITY_POLICY,
+    global: GLOBAL_AUTHORITY_POLICY,
     global_product: GLOBAL_PRODUCT_AUTHORITY_POLICY,
     global_technical: GLOBAL_TECHNICAL_AUTHORITY_POLICY,
     global_acceptance: GLOBAL_ACCEPTANCE_AUTHORITY_POLICY,
     outcome: OUTCOME_AUTHORITY_POLICY,
+    claim_applicability: CLAIM_APPLICABILITY_AUTHORITY_POLICY,
+    applicable_statement: APPLICABLE_STATEMENT_AUTHORITY_POLICY,
     outcome_product: OUTCOME_PRODUCT_AUTHORITY_POLICY,
     requirement: REQUIREMENT_AUTHORITY_POLICY,
     owner: OWNER_AUTHORITY_POLICY,
     control: CONTROL_AUTHORITY_POLICY,
+    control_field_coverage: CONTROL_FIELD_COVERAGE_AUTHORITY_POLICY,
+    control_relation_closure: CONTROL_RELATION_CLOSURE_AUTHORITY_POLICY,
+    control_relation: CONTROL_RELATION_AUTHORITY_POLICY,
     surface_binding: SURFACE_BINDING_AUTHORITY_POLICY,
     design_target: DESIGN_TARGET_AUTHORITY_POLICY,
+    design_verification_binding: DESIGN_VERIFICATION_BINDING_AUTHORITY_POLICY,
     design_blocker: DESIGN_BLOCKER_AUTHORITY_POLICY,
     outcome_technical: OUTCOME_TECHNICAL_AUTHORITY_POLICY,
     obligation: OBLIGATION_AUTHORITY_POLICY,

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

@@ -1,5 +1,5 @@
-import type { ProofSurface } from "./long-task-contract-types.js";
-import type { DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
+import type { DeliveryControlV2, DeliveryOutcomeV2, ProofSurface } from "./long-task-contract-types.js";
+import type { ClaimApplicabilityV2, DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
@@ -18,12 +18,15 @@ export interface ProductSemanticProjectionV2 {
     global_non_goals: Array<{
         key: string;
         statement: string;
+        applicability_refs: string[];
     }>;
     outcomes: Array<{
         key: string;
         title: string;
         stage: string;
+        applicability: ClaimApplicabilityV2[];
         observable_result: string;
+        result_applicability_refs: string[];
         success_path_required: boolean;
         degradation_path_required: boolean;
         owner: {
@@ -34,6 +37,7 @@ export interface ProductSemanticProjectionV2 {
             key: string;
             statement: string;
             required_proof_surfaces: ProofSurface[];
+            applicability_refs: string[];
         }>;
         controls: Array<{
             key: string;
@@ -59,7 +63,10 @@ export interface ProductSemanticProjectionV2 {
             permission: string;
             feedback: string;
             accessibility: string;
+            field_coverage: DeliveryControlV2["field_coverage"];
         }>;
+        control_relation_closure: DeliveryOutcomeV2["product"]["control_relation_closure"];
+        control_relations: DeliveryOutcomeV2["product"]["control_relations"];
         surface_bindings: DeliverySurfaceBindingV2[];
         non_completing_outcomes: Array<{
             key: string;
@@ -68,13 +75,16 @@ export interface ProductSemanticProjectionV2 {
     }>;
 }
 export interface GlobalSemanticProjectionV2 {
+    applicability: ClaimApplicabilityV2[];
     constraints: Array<{
         key: string;
         statement: string;
+        applicability_refs: string[];
     }>;
     forbidden_shortcuts: Array<{
         key: string;
         statement: string;
+        applicability_refs: string[];
     }>;
 }
 export interface ContextAuthoritySnapshotV2 {

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

@@ -23,10 +23,14 @@ export function computeAuthorityHashes(contract) {
             target_profile: contract.task.target_profile,
             execution_targets: contract.task.execution_targets,
             stages: contract.stages,
-            global: contract.global.product,
+            global: {
+                applicability: contract.global.applicability,
+                product: contract.global.product,
+            },
             outcomes: contract.outcomes.map((outcome) => ({
                 key: outcome.key,
                 stage: outcome.stage,
+                applicability: outcome.applicability,
                 product: outcome.product,
             })),
         }),
@@ -56,6 +60,7 @@ export function computeAuthorityHashes(contract) {
 export function outcomeAuthorityHash(outcome) {
     return hash({
         stage: outcome.stage,
+        applicability: outcome.applicability,
         product: outcome.product,
         acceptance: {
             checks: outcome.acceptance.checks.map(acceptanceCheck),
@@ -146,6 +151,7 @@ function assertionsStrengthened(previous, next) {
         if (!nextAssertion ||
             previousAssertion.criterion !== nextAssertion.criterion ||
             !same(previousAssertion.claims, nextAssertion.claims) ||
+            previousAssertion.applicability_ref !== nextAssertion.applicability_ref ||
             previousAssertion.observation !== nextAssertion.observation ||
             previousAssertion.operator !== nextAssertion.operator ||
             !same(previousAssertion.expected, nextAssertion.expected) ||
@@ -160,7 +166,8 @@ function counterfactualsStrengthened(previous, next) {
         candidate.check_key === control.check_key &&
         same(candidate.mutation, control.mutation) &&
         subset(control.claims, candidate.claims) &&
-        subset(control.expected_assertion_failures, candidate.expected_assertion_failures)));
+        subset(control.expected_assertion_failures, candidate.expected_assertion_failures) &&
+        subset(control.preserved_assertions, candidate.preserved_assertions)));
 }
 function subset(previous, next) {
     const available = new Set(next.map((item) => canonicalValueJson(item)));

package/dist/lib/long-task-check-shape.js

@@ -89,7 +89,7 @@ function parseRunner(value, label) {
 function parseAssertions(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "expected"]);
+        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "applicability_ref", "expected"]);
         const operator = literal(row.operator, [
             "equals",
             "not_equals",
@@ -121,6 +121,11 @@ function parseAssertions(value, label) {
                 ? { criterion: string(row.criterion, `${itemLabel}.criterion`) }
                 : {}),
             claims: strings(row.claims, `${itemLabel}.claims`),
+            ...(Object.hasOwn(row, "applicability_ref")
+                ? {
+                    applicability_ref: key(row.applicability_ref, `${itemLabel}.applicability_ref`),
+                }
+                : {}),
             observation: string(row.observation, `${itemLabel}.observation`),
             evidence_capabilities: array(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
             operator,

package/dist/lib/long-task-claim-definitions.js

@@ -1,61 +1,43 @@
+import { controlFieldFacts } from "./long-task-control-fields.js";
 import { fail } from "./long-task-delivery-shape.js";
 export function generateClaims(outcome) {
-    const claims = [claim(outcome.key, "result", "result")];
+    const claims = [
+        claim(outcome.key, "result", "result", [], outcome.product.result_applicability_refs),
+    ];
     for (const requirement of outcome.product.requirements)
-        claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces));
+        claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces, requirement.applicability_refs));
     for (const control of outcome.product.controls) {
-        const fields = [
-            ["surface", control.surface],
-            ["region", control.region],
-            ["location", control.location],
-            ["control_type", control.control_type],
-            ["label_content", control.label_content],
-            ["user_task", control.user_task],
-            ["visibility", control.visibility],
-            ["availability", control.availability],
-            ["trigger", control.trigger],
-            ["input", control.input],
-            ["validation", control.validation],
-            ["default_value", control.default_value],
-            ["interaction", control.interaction],
-            ["navigation_result", control.navigation_result],
-            ["loading", control.loading_state],
-            ["empty", control.empty_state],
-            ["success", control.success_state],
-            ["failure", control.failure_state],
-            ["recovery", control.recovery],
-            ["permission", control.permission],
-            ["feedback", control.feedback],
-            ["accessibility", control.accessibility],
-        ];
-        for (const [field, value] of fields)
-            if (value.trim())
-                claims.push(claim(outcome.key, `control.${control.key}.${field}`, "control"));
+        for (const field of controlFieldFacts(control))
+            claims.push(claim(outcome.key, `control.${control.key}.${field.claim_field}`, "control", [], field.applicability_refs, field.state === "not_applicable" ? "negative" : "positive"));
     }
+    if (outcome.product.control_relation_closure.state !== "unresolved")
+        claims.push(claim(outcome.key, "control_relation_closure", "control_relation", [], outcome.product.control_relation_closure.applicability_refs, outcome.product.control_relation_closure.state === "not_applicable"
+            ? "negative"
+            : "positive"));
+    for (const relation of outcome.product.control_relations)
+        claims.push(claim(outcome.key, `control_relation.${relation.key}`, "control_relation", relation.required_proof_surfaces, relation.applicability_refs));
     for (const item of outcome.product.non_completing_outcomes)
-        claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing"));
+        claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing", [], item.applicability_refs, "negative"));
     for (const item of outcome.technical.obligations)
-        claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces));
+        claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces, item.applicability_refs));
     for (const item of outcome.technical.forbidden_shortcuts)
-        claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut"));
+        claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut", [], item.applicability_refs, "negative"));
     return claims;
 }
 export function generateGlobalClaims(global) {
     return [
-        ...global.product.non_goals.map((item) => globalClaim(`non_goal.${item.key}`, "global_non_goal", "negative")),
-        ...global.technical.constraints.map((item) => globalClaim(`constraint.${item.key}`, "global_constraint", "any")),
-        ...global.technical.forbidden_shortcuts.map((item) => globalClaim(`forbidden_shortcut.${item.key}`, "global_forbidden_shortcut", "negative")),
+        ...global.product.non_goals.map((item) => globalClaim(`non_goal.${item.key}`, "global_non_goal", "negative", item.applicability_refs)),
+        ...global.technical.constraints.map((item) => globalClaim(`constraint.${item.key}`, "global_constraint", "positive", item.applicability_refs)),
+        ...global.technical.forbidden_shortcuts.map((item) => globalClaim(`forbidden_shortcut.${item.key}`, "global_forbidden_shortcut", "negative", item.applicability_refs)),
     ].sort((left, right) => left.id.localeCompare(right.id));
 }
 export function validateGlobalProofPolarity(claim, proof) {
-    if (claim.required_polarity === "negative" && proof.polarity !== "negative")
+    if (proof.polarity !== claim.required_polarity)
         fail("global_negative_claim_proof_required", `${claim.local_key}:${proof.check_key}`);
 }
 export function validateProofSurface(claim, proof, outcomeKey) {
-    if ((claim.kind === "non_completing" || claim.kind === "forbidden_shortcut") &&
-        proof.polarity !== "negative" &&
-        proof.polarity !== "counterfactual")
-        fail("negative_or_counterfactual_claim_proof_required", `${outcomeKey}:${claim.local_key}`);
+    if (proof.polarity !== claim.required_polarity)
+        fail("claim_proof_polarity_mismatch", `${outcomeKey}:${claim.local_key}:${proof.polarity}:${claim.required_polarity}`);
     if ((claim.kind === "requirement" || claim.kind === "obligation") &&
         claim.required_proof_surfaces.length > 0 &&
         !claim.required_proof_surfaces.includes(proof.proof_surface))
@@ -69,20 +51,23 @@ export function assertAllGlobalClaimsCovered(uncovered) {
     if (uncovered.length)
         fail("global_claim_uncovered", uncovered.sort().join(","));
 }
-function claim(outcomeKey, localKey, kind, requiredProofSurfaces = []) {
+function claim(outcomeKey, localKey, kind, requiredProofSurfaces = [], applicabilityRefs = [], requiredPolarity = "positive") {
     return {
         id: `${outcomeKey}.${localKey}`,
         outcome_key: outcomeKey,
         local_key: localKey,
         kind,
         required_proof_surfaces: requiredProofSurfaces,
+        required_polarity: requiredPolarity,
+        applicability_refs: applicabilityRefs,
     };
 }
-function globalClaim(localKey, kind, requiredPolarity) {
+function globalClaim(localKey, kind, requiredPolarity, applicabilityRefs) {
     return {
         id: `GLOBAL.${localKey}`,
         local_key: localKey,
         kind,
         required_polarity: requiredPolarity,
+        applicability_refs: applicabilityRefs,
     };
 }