project-tiny-context-harness 0.8.1 → 0.8.3

package/dist/commands/long-task-authoring.js

@@ -39,8 +39,10 @@ task:
       role: product
       runtime_family: process
       root_entrypoint: tests/replace-oracle.mjs
+      capabilities: [process-runtime, cold-start, production-root]
   source_paths: [plans/replace-me.md]
   context_refs: [project_context/areas/replace-me.md]
+  context_snapshot_mode: full
 source_claims:
   - key: replace-requirement
     source_ref: plans/replace-me.md#replace-requirement
@@ -48,6 +50,12 @@ source_claims:
     disposition:
       type: claim
       refs: [replace-outcome.requirement.replace-requirement]
+  - key: replace-architecture
+    source_ref: plans/replace-me.md#replace-architecture
+    statement: Preserve the declared owner, dependency direction, verifier boundary and architecture conformance.
+    disposition:
+      type: claim
+      refs: [replace-outcome.obligation.architecture]
 stages:
   - key: delivery
     title: Delivery
@@ -55,13 +63,22 @@ stages:
     gate_outcome: replace-outcome
 risk:
   facts: {}
-global: {}
+global:
+  applicability: []
 outcomes:
   - key: replace-outcome
     title: Replace outcome
     stage: delivery
+    applicability:
+      - key: root-success
+        target_ref: replace-runtime
+        journey_role: success
+        dimensions: [{key: delivery-state, value: ready}]
+        given_refs: [source-ready]
+        when_refs: [inspect-result]
     product:
       observable_result: Describe what a user or system can observe.
+      result_applicability_refs: [root-success]
       success_path_required: true
       degradation_path_required: false
       owner:
@@ -72,7 +89,17 @@ outcomes:
         - key: replace-requirement
           statement: Preserve one atomic source requirement.
           required_proof_surfaces: [runtime_behavior]
+          applicability_refs: [root-success]
+      control_relation_closure:
+        state: not_applicable
+        statement: This Outcome declares no user-visible Controls.
+        applicability_refs: [root-success]
     technical:
+      obligations:
+        - key: architecture
+          statement: Preserve the declared owner, dependency direction, verifier boundary and architecture conformance.
+          required_proof_surfaces: [runtime_behavior]
+          applicability_refs: [root-success]
       expected_change_paths: ["src/**"]
       bindings:
         - key: replace-carrier
@@ -97,21 +124,68 @@ outcomes:
           input_paths: [src/replace-me.ts]
           expected_output_paths: [src/replace-me.ts]
           positive_assertions:
-            - key: replace-success
-              criterion: The declared outcome and requirement are observable.
-              claims: [result, requirement.replace-requirement]
+            - key: replace-result
+              criterion: The declared outcome is observable.
+              claims: [result]
+              applicability_ref: root-success
               observation: result
               evidence_capabilities: [state_delta, target_runtime]
               operator: equals
               expected: true
+            - key: replace-requirement
+              criterion: The atomic Source requirement is observable.
+              claims: [requirement.replace-requirement]
+              applicability_ref: root-success
+              observation: requirement_result
+              evidence_capabilities: [state_delta, target_runtime]
+              operator: equals
+              expected: true
+            - key: replace-architecture
+              criterion: The declared architecture obligation remains conformant.
+              claims: [obligation.architecture]
+              applicability_ref: root-success
+              observation: architecture_result
+              evidence_capabilities: [state_delta, target_runtime]
+              operator: equals
+              expected: true
+            - key: replace-liveness
+              criterion: The declared target remains live under semantic mutation.
+              claims: []
+              observation: target_live
+              evidence_capabilities: [target_runtime]
+              operator: equals
+              expected: true
+          negative_assertions:
+            - key: replace-relations-na
+              criterion: Cross-Control relations remain inapplicable when no Controls are declared.
+              claims: [control_relation_closure]
+              applicability_ref: root-success
+              observation: relations_applicable
+              evidence_capabilities: [state_delta, target_runtime]
+              operator: equals
+              expected: false
       counterfactual_controls:
-        - key: remove-replace-carrier
+        - key: replace-semantic-carrier
+          binding_key: replace-carrier
+          claims: [result, requirement.replace-requirement, obligation.architecture]
+          check_key: replace-check
+          mutation:
+            type: replace_text
+            path: src/replace-me.ts
+            match: IMPLEMENTED_STATE
+            replacement: SEMANTIC_FAILURE_STATE
+          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture]
+          preserved_assertions: [replace-liveness]
+        - key: replace-relation-applicability
           binding_key: replace-carrier
-          claims: [result, requirement.replace-requirement]
+          claims: [control_relation_closure]
           check_key: replace-check
           mutation:
-            type: remove_paths
-            paths: [src/replace-me.ts]
-          expected_assertion_failures: [replace-success]
+            type: replace_text
+            path: src/replace-me.ts
+            match: NO_CROSS_CONTROL_RELATIONS
+            replacement: CROSS_CONTROL_RELATIONS_APPLY
+          expected_assertion_failures: [replace-relations-na]
+          preserved_assertions: [replace-liveness]
 `;
 }

package/dist/lib/context-graph-snapshot.js

@@ -15,6 +15,13 @@ export async function captureContextGraphSnapshot(repositoryRoot, contextRefs, m
     const explicitlySelected = new Set();
     if (mode === "full") {
         allFiles.forEach((file) => selected.add(file));
+        for (const contextRef of contextRefs) {
+            const normalized = normalizeRepoPath(contextRef);
+            if (!available.has(normalized)) {
+                throw new Error(`context_ref_invalid:${contextRef}`);
+            }
+            explicitlySelected.add(normalized);
+        }
     }
     else {
         for (const required of [

package/dist/lib/design-resource-fact-policy.d.ts

@@ -0,0 +1,25 @@
+import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+export declare const DESIGN_RESOURCE_FACT_INVARIANTS: Readonly<{
+    readonly complete_observable_design_fact_delivery: true;
+    readonly resource_fact_inventory_closure_required: true;
+    readonly exact_target_visual_pixel_required: true;
+    readonly exact_fact_set_conservation_required: true;
+    readonly design_fact_expression_boundary: true;
+    readonly unsupported_design_fact_blocks: true;
+    readonly control_granularity_is_not_design_fact_granularity: true;
+    readonly public_design_fact_guidance_required: true;
+    readonly design_fact_values_stay_in_canonical_resources: true;
+    readonly no_second_design_fact_authority: true;
+    readonly fact_inventory_required: true;
+    readonly contract_evidence_fact_binding_required: true;
+    readonly selected_design_fact_antidegradation_required: true;
+    readonly design_fact_distribution_context_cost: true;
+    readonly forbidden_design_fact_shortcuts_absent: true;
+    readonly preflight_is_not_production_conformance: true;
+    readonly unsupported_facts_block: true;
+    readonly control_relations_unchanged: true;
+}>;
+export declare const EXACT_TARGET_FULL_TARGET_METHODS: readonly ["layout_geometry", "visual_pixel"];
+export declare function assertDesignResourceFactPolicyEnabled(): void;
+export declare function designFactMethodIsCompatible(dimension: DesignResourceDimension, method: DesignResourceVerificationMethod): boolean;
+export declare function designFactEvidenceIsCompatible(dimension: DesignResourceDimension, kind: DesignResourceEvidenceKind): boolean;

package/dist/lib/design-resource-fact-policy.js

@@ -0,0 +1,35 @@
+import { DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION, DESIGN_RESOURCE_METHODS_BY_DIMENSION, } from "./design-resource-handoff-policy.js";
+export const DESIGN_RESOURCE_FACT_INVARIANTS = Object.freeze({
+    complete_observable_design_fact_delivery: true,
+    resource_fact_inventory_closure_required: true,
+    exact_target_visual_pixel_required: true,
+    exact_fact_set_conservation_required: true,
+    design_fact_expression_boundary: true,
+    unsupported_design_fact_blocks: true,
+    control_granularity_is_not_design_fact_granularity: true,
+    public_design_fact_guidance_required: true,
+    design_fact_values_stay_in_canonical_resources: true,
+    no_second_design_fact_authority: true,
+    fact_inventory_required: true,
+    contract_evidence_fact_binding_required: true,
+    selected_design_fact_antidegradation_required: true,
+    design_fact_distribution_context_cost: true,
+    forbidden_design_fact_shortcuts_absent: true,
+    preflight_is_not_production_conformance: true,
+    unsupported_facts_block: true,
+    control_relations_unchanged: true,
+});
+export const EXACT_TARGET_FULL_TARGET_METHODS = [
+    "layout_geometry",
+    "visual_pixel",
+];
+export function assertDesignResourceFactPolicyEnabled() {
+    if (Object.values(DESIGN_RESOURCE_FACT_INVARIANTS).some((enabled) => enabled !== true))
+        throw new Error("design_resource_fact_policy_disabled");
+}
+export function designFactMethodIsCompatible(dimension, method) {
+    return DESIGN_RESOURCE_METHODS_BY_DIMENSION[dimension].includes(method);
+}
+export function designFactEvidenceIsCompatible(dimension, kind) {
+    return DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION[dimension].includes(kind);
+}

package/dist/lib/design-resource-handoff-shape-evidence.d.ts

@@ -1,4 +1,6 @@
-import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffCoverageV1, DesignResourceHandoffEvidenceV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffCoverageV1, DesignResourceHandoffEvidenceV1, DesignResourceHandoffFactV1, DesignResourceHandoffResourceFactClosureV1 } from "./design-resource-handoff-types.js";
 export declare function parseDesignResourceHandoffEvidence(value: unknown): DesignResourceHandoffEvidenceV1[];
 export declare function parseDesignResourceHandoffCoverage(value: unknown): DesignResourceHandoffCoverageV1[];
+export declare function parseDesignResourceHandoffFacts(value: unknown): DesignResourceHandoffFactV1[];
+export declare function parseDesignResourceHandoffResourceFactClosure(value: unknown): DesignResourceHandoffResourceFactClosureV1[];
 export declare function parseDesignResourceHandoffBlockers(value: unknown): DesignResourceHandoffBlockerV1[];

package/dist/lib/design-resource-handoff-shape-evidence.js

@@ -1,6 +1,7 @@
 import { DESIGN_RESOURCE_DIMENSIONS, DESIGN_RESOURCE_EVIDENCE_KINDS, DESIGN_RESOURCE_LOCATOR_KINDS, } from "./design-resource-handoff-types.js";
 import { contractKey, contractKeys, sourceItemKeys, stableKey, stableKeys, verificationMethods, } from "./design-resource-handoff-shape-primitives.js";
 import { array, literal, object, string, } from "./long-task-shape-primitives.js";
+import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
 export function parseDesignResourceHandoffEvidence(value) {
     return array(value, "design_resource_handoff.evidence").map((item, index) => {
         const label = `design_resource_handoff.evidence[${index}]`;
@@ -35,6 +36,7 @@ export function parseDesignResourceHandoffCoverage(value) {
             "target_refs",
             "condition_refs",
             "evidence_refs",
+            "fact_refs",
             "source_item_refs",
             "verification_methods",
             "rationale",
@@ -53,12 +55,68 @@ export function parseDesignResourceHandoffCoverage(value) {
             target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
             condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
             evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
+            fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
             source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
             verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
             rationale: string(row.rationale, `${label}.rationale`),
         };
     });
 }
+export function parseDesignResourceHandoffFacts(value) {
+    return array(value, "design_resource_handoff.facts").map((item, index) => {
+        const label = `design_resource_handoff.facts[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "subject_ref",
+            "target_ref",
+            "condition_ref",
+            "dimension",
+            "observation_scope",
+            "evidence_refs",
+            "source_item_refs",
+            "verification_method",
+        ]);
+        return {
+            key: stableKey(row.key, `${label}.key`),
+            subject_ref: stableKey(row.subject_ref, `${label}.subject_ref`),
+            target_ref: contractKey(row.target_ref, `${label}.target_ref`),
+            condition_ref: contractKey(row.condition_ref, `${label}.condition_ref`),
+            dimension: literal(row.dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimension`),
+            observation_scope: literal(row.observation_scope, ["subject", "full_target"], `${label}.observation_scope`),
+            evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
+            source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+            verification_method: verificationMethods([row.verification_method], `${label}.verification_method`)[0],
+        };
+    });
+}
+export function parseDesignResourceHandoffResourceFactClosure(value) {
+    return array(value, "design_resource_handoff.resource_fact_closure").map((item, index) => {
+        const label = `design_resource_handoff.resource_fact_closure[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "resource_ref",
+            "disposition",
+            "fact_refs",
+            "inspection",
+            "rationale",
+        ]);
+        const inspection = object(row.inspection, `${label}.inspection`, [
+            "status",
+            "inspector",
+        ]);
+        return {
+            key: stableKey(row.key, `${label}.key`),
+            resource_ref: stableKey(row.resource_ref, `${label}.resource_ref`),
+            disposition: literal(row.disposition, ["material_with_facts", "supporting_only"], `${label}.disposition`),
+            fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
+            inspection: {
+                status: literal(inspection.status, ["complete"], `${label}.inspection.status`),
+                inspector: string(inspection.inspector, `${label}.inspection.inspector`),
+            },
+            rationale: string(row.rationale, `${label}.rationale`),
+        };
+    });
+}
 export function parseDesignResourceHandoffBlockers(value) {
     return array(value, "design_resource_handoff.acceptance_blockers").map((item, index) => {
         const label = `design_resource_handoff.acceptance_blockers[${index}]`;
@@ -69,6 +127,7 @@ export function parseDesignResourceHandoffBlockers(value) {
             "dimensions",
             "source_item_refs",
             "verification_methods",
+            "required_capabilities",
             "description",
         ]);
         return {
@@ -78,6 +137,7 @@ export function parseDesignResourceHandoffBlockers(value) {
             dimensions: array(row.dimensions, `${label}.dimensions`).map((dimension, itemIndex) => literal(dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimensions[${itemIndex}]`)),
             source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
             verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
+            required_capabilities: array(row.required_capabilities, `${label}.required_capabilities`).map((capability, capabilityIndex) => literal(capability, EXECUTION_TARGET_CAPABILITIES, `${label}.required_capabilities[${capabilityIndex}]`)),
             description: string(row.description, `${label}.description`),
         };
     });

package/dist/lib/design-resource-handoff-shape.js

@@ -1,4 +1,4 @@
-import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, } from "./design-resource-handoff-shape-evidence.js";
+import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, parseDesignResourceHandoffResourceFactClosure, } from "./design-resource-handoff-shape-evidence.js";
 import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
 import { parseDesignResourceHandoffConditions, parseDesignResourceHandoffResources, parseDesignResourceHandoffSubjects, parseDesignResourceHandoffTargets, } from "./design-resource-handoff-shape-structure.js";
 import { literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
@@ -13,6 +13,8 @@ export function parseDesignResourceHandoffShape(value) {
         "subjects",
         "targets",
         "evidence",
+        "facts",
+        "resource_fact_closure",
         "coverage",
         "acceptance_blockers",
         "proposal",
@@ -64,6 +66,8 @@ export function parseDesignResourceHandoffShape(value) {
         subjects: parseDesignResourceHandoffSubjects(root.subjects),
         targets: parseDesignResourceHandoffTargets(root.targets),
         evidence: parseDesignResourceHandoffEvidence(root.evidence),
+        facts: parseDesignResourceHandoffFacts(root.facts),
+        resource_fact_closure: parseDesignResourceHandoffResourceFactClosure(root.resource_fact_closure),
         coverage: parseDesignResourceHandoffCoverage(root.coverage),
         acceptance_blockers: parseDesignResourceHandoffBlockers(root.acceptance_blockers),
         proposal: {

package/dist/lib/design-resource-handoff-types.d.ts

@@ -1,3 +1,4 @@
+import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
 export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
 export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation"];
@@ -33,6 +34,8 @@ export interface DesignResourceHandoffV1 {
     subjects: DesignResourceHandoffSubjectV1[];
     targets: DesignResourceHandoffTargetV1[];
     evidence: DesignResourceHandoffEvidenceV1[];
+    facts: DesignResourceHandoffFactV1[];
+    resource_fact_closure: DesignResourceHandoffResourceFactClosureV1[];
     coverage: DesignResourceHandoffCoverageV1[];
     acceptance_blockers: DesignResourceHandoffBlockerV1[];
     proposal: {
@@ -96,6 +99,28 @@ export interface DesignResourceHandoffEvidenceV1 {
     };
     condition_refs: string[];
 }
+export interface DesignResourceHandoffFactV1 {
+    key: string;
+    subject_ref: string;
+    target_ref: string;
+    condition_ref: string;
+    dimension: DesignResourceDimension;
+    observation_scope: "subject" | "full_target";
+    evidence_refs: string[];
+    source_item_refs: string[];
+    verification_method: DesignResourceVerificationMethod;
+}
+export interface DesignResourceHandoffResourceFactClosureV1 {
+    key: string;
+    resource_ref: string;
+    disposition: "material_with_facts" | "supporting_only";
+    fact_refs: string[];
+    inspection: {
+        status: "complete";
+        inspector: string;
+    };
+    rationale: string;
+}
 export interface DesignResourceHandoffCoverageV1 {
     key: string;
     subject_refs: string[];
@@ -104,6 +129,7 @@ export interface DesignResourceHandoffCoverageV1 {
     target_refs: string[];
     condition_refs: string[];
     evidence_refs: string[];
+    fact_refs: string[];
     source_item_refs: string[];
     verification_methods: DesignResourceVerificationMethod[];
     rationale: string;
@@ -115,6 +141,7 @@ export interface DesignResourceHandoffBlockerV1 {
     dimensions: DesignResourceDimension[];
     source_item_refs: string[];
     verification_methods: DesignResourceVerificationMethod[];
+    required_capabilities: ExecutionTargetCapabilityV2[];
     description: string;
 }
 export interface ParsedDesignResourceHandoffV1 {
@@ -133,6 +160,8 @@ export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHa
         subjects: number;
         targets: number;
         evidence: number;
+        facts: number;
+        resource_fact_closure: number;
         coverage: number;
         acceptance_blockers: number;
     };

package/dist/lib/design-resource-handoff-validation-coverage.d.ts

@@ -1,4 +1,4 @@
 import { type DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function validateDesignResourceCoverage(handoff: DesignResourceHandoffV1, subjects: Map<string, unknown>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, conditions: Map<string, unknown>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>, sourceItems: Map<string, string>): void;
+export declare function validateDesignResourceCoverage(handoff: DesignResourceHandoffV1, subjects: Map<string, unknown>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, conditions: Map<string, unknown>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>, facts: Map<string, DesignResourceHandoffV1["facts"][number]>, sourceItems: Map<string, string>): void;
 export declare function validateDesignResourceBlockers(handoff: DesignResourceHandoffV1, subjects: Map<string, unknown>, targets: Map<string, unknown>, sourceItems: Map<string, string>): void;
 export declare function validateDesignResourceReachability(handoff: DesignResourceHandoffV1): void;

package/dist/lib/design-resource-handoff-validation-coverage.js

@@ -1,8 +1,9 @@
 import { DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION, DESIGN_RESOURCE_METHODS_BY_DIMENSION, } from "./design-resource-handoff-policy.js";
 import { DESIGN_RESOURCE_DIMENSIONS, } from "./design-resource-handoff-types.js";
 import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
-export function validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, sourceItems) {
+export function validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, facts, sourceItems) {
     const cells = new Set();
+    const referencedFacts = new Set();
     const unresolved = [];
     for (const row of handoff.coverage) {
         requireNonemptyDesignResourceValues(row.subject_refs, `coverage_subject_refs_required:${row.key}`);
@@ -12,6 +13,7 @@ export function validateDesignResourceCoverage(handoff, subjects, targets, condi
             ["target_ref", row.target_refs],
             ["condition_ref", row.condition_refs],
             ["evidence_ref", row.evidence_refs],
+            ["fact_ref", row.fact_refs],
             ["source_item_ref", row.source_item_refs],
             ["verification_method", row.verification_methods],
         ])
@@ -24,12 +26,12 @@ export function validateDesignResourceCoverage(handoff, subjects, targets, condi
         }
         validateCoverageApplicability(row, handoff, targets, conditions, cells);
         if (row.disposition === "covered")
-            validateCoveredRow(row, targets, conditions, evidence);
-        else
-            validateNoncoveredRow(row);
-        if (row.disposition === "decision_required" ||
+            validateCoveredRow(row, handoff, targets, conditions, evidence, facts, referencedFacts);
+        else if (row.disposition === "decision_required" ||
             row.disposition === "unavailable")
             unresolved.push(row.key);
+        else
+            validateNoncoveredRow(row);
     }
     for (const subject of handoff.subjects)
         for (const targetRef of subject.target_refs) {
@@ -43,6 +45,9 @@ export function validateDesignResourceCoverage(handoff, subjects, targets, condi
         }
     if (unresolved.length)
         invalidDesignResourceHandoff("unresolved_coverage", unresolved.sort().join(","));
+    for (const fact of handoff.facts)
+        if (!referencedFacts.has(fact.key))
+            invalidDesignResourceHandoff("design_resource_fact_unreferenced", fact.key);
 }
 function validateCoverageApplicability(row, handoff, targets, conditions, cells) {
     requireNonemptyDesignResourceValues(row.target_refs, `coverage_target_refs_required:${row.key}`);
@@ -80,6 +85,7 @@ export function validateDesignResourceBlockers(handoff, subjects, targets, sourc
             ["dimensions", blocker.dimensions],
             ["source_item_refs", blocker.source_item_refs],
             ["verification_methods", blocker.verification_methods],
+            ["required_capabilities", blocker.required_capabilities],
         ]) {
             requireNonemptyDesignResourceValues(values, `acceptance_blocker_${name}_required:${blocker.key}`);
             requireUniqueDesignResourceValues(values, `acceptance_blocker_${name}_duplicate:${blocker.key}`);
@@ -125,11 +131,12 @@ export function validateDesignResourceReachability(handoff) {
         if (!coverageEvidence.has(item.key))
             invalidDesignResourceHandoff("evidence_unreferenced", item.key);
 }
-function validateCoveredRow(row, targets, conditions, evidence) {
+function validateCoveredRow(row, handoff, targets, conditions, evidence, facts, referencedFacts) {
     for (const [name, values] of [
         ["target_refs", row.target_refs],
         ["condition_refs", row.condition_refs],
         ["evidence_refs", row.evidence_refs],
+        ["fact_refs", row.fact_refs],
         ["verification_methods", row.verification_methods],
     ])
         requireNonemptyDesignResourceValues(values, `coverage_${name}_required:${row.key}`);
@@ -139,6 +146,12 @@ function validateCoveredRow(row, targets, conditions, evidence) {
         requireKnownDesignResourceRef(conditions, ref, "condition");
     for (const ref of row.evidence_refs)
         requireKnownDesignResourceRef(evidence, ref, "evidence");
+    for (const ref of row.fact_refs) {
+        requireKnownDesignResourceRef(facts, ref, "fact");
+        if (referencedFacts.has(ref))
+            invalidDesignResourceHandoff("coverage_fact_ref_duplicate", `${row.key}:${ref}`);
+        referencedFacts.add(ref);
+    }
     const allowedEvidence = new Set(DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION[row.dimension]);
     const allowedMethods = new Set(DESIGN_RESOURCE_METHODS_BY_DIMENSION[row.dimension]);
     for (const ref of row.evidence_refs) {
@@ -149,20 +162,35 @@ function validateCoveredRow(row, targets, conditions, evidence) {
     for (const method of row.verification_methods)
         if (!allowedMethods.has(method))
             invalidDesignResourceHandoff("coverage_verification_method_incompatible", `${row.key}:${row.dimension}:${method}`);
-    for (const targetRef of row.target_refs)
-        for (const conditionRef of row.condition_refs)
-            if (!row.evidence_refs.some((evidenceRef) => {
-                const item = evidence.get(evidenceRef);
-                return (targets.get(targetRef).resource_refs.includes(item.resource_ref) &&
-                    item.condition_refs.includes(conditionRef));
-            }))
-                invalidDesignResourceHandoff("coverage_cell_without_evidence", `${row.key}:${targetRef}:${conditionRef}`);
+    const expectedFacts = handoff.facts.filter((fact) => fact.dimension === row.dimension &&
+        row.subject_refs.includes(fact.subject_ref) &&
+        row.target_refs.includes(fact.target_ref) &&
+        row.condition_refs.includes(fact.condition_ref));
+    assertSameSet(row.fact_refs, expectedFacts.map((fact) => fact.key), "coverage_fact_refs_mismatch", row.key);
+    assertSameSet(row.evidence_refs, expectedFacts.flatMap((fact) => fact.evidence_refs), "coverage_fact_evidence_refs_mismatch", row.key);
+    assertSameSet(row.source_item_refs, expectedFacts.flatMap((fact) => fact.source_item_refs), "coverage_fact_source_item_refs_mismatch", row.key);
+    assertSameSet(row.verification_methods, expectedFacts.map((fact) => fact.verification_method), "coverage_fact_verification_methods_mismatch", row.key);
+    for (const subjectRef of row.subject_refs)
+        for (const targetRef of row.target_refs)
+            for (const conditionRef of row.condition_refs)
+                if (!expectedFacts.some((fact) => fact.subject_ref === subjectRef &&
+                    fact.target_ref === targetRef &&
+                    fact.condition_ref === conditionRef))
+                    invalidDesignResourceHandoff("coverage_cell_without_fact", `${row.key}:${subjectRef}:${targetRef}:${conditionRef}`);
 }
 function validateNoncoveredRow(row) {
     for (const [name, values] of [
         ["evidence_refs", row.evidence_refs],
+        ["fact_refs", row.fact_refs],
         ["verification_methods", row.verification_methods],
     ])
         if (values.length)
             invalidDesignResourceHandoff("noncovered_binding_forbidden", `${row.key}:${row.disposition}:${name}`);
 }
+function assertSameSet(actual, expected, code, detail) {
+    const left = [...new Set(actual)].sort();
+    const right = [...new Set(expected)].sort();
+    if (left.length !== right.length ||
+        left.some((item, index) => item !== right[index]))
+        invalidDesignResourceHandoff(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+}

package/dist/lib/design-resource-handoff-validation-facts.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceFacts(handoff: DesignResourceHandoffV1, resources: Map<string, DesignResourceHandoffV1["resources"][number]>, conditions: Map<string, DesignResourceHandoffV1["conditions"][number]>, subjects: Map<string, DesignResourceHandoffV1["subjects"][number]>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>, sourceItems: Map<string, string>): void;

package/dist/lib/design-resource-handoff-validation-facts.js

@@ -0,0 +1,97 @@
+import { assertDesignResourceFactPolicyEnabled, designFactEvidenceIsCompatible, designFactMethodIsCompatible, EXACT_TARGET_FULL_TARGET_METHODS, } from "./design-resource-fact-policy.js";
+import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceFacts(handoff, resources, conditions, subjects, targets, evidence, sourceItems) {
+    assertDesignResourceFactPolicyEnabled();
+    for (const fact of handoff.facts) {
+        requireNonemptyDesignResourceValues(fact.evidence_refs, `fact_evidence_refs_required:${fact.key}`);
+        requireNonemptyDesignResourceValues(fact.source_item_refs, `fact_source_item_refs_required:${fact.key}`);
+        requireUniqueDesignResourceValues(fact.evidence_refs, `fact_evidence_ref_duplicate:${fact.key}`);
+        requireUniqueDesignResourceValues(fact.source_item_refs, `fact_source_item_ref_duplicate:${fact.key}`);
+        requireKnownDesignResourceRef(subjects, fact.subject_ref, "subject");
+        requireKnownDesignResourceRef(targets, fact.target_ref, "target");
+        requireKnownDesignResourceRef(conditions, fact.condition_ref, "condition");
+        const subject = subjects.get(fact.subject_ref);
+        const target = targets.get(fact.target_ref);
+        if (!subject.target_refs.includes(fact.target_ref))
+            invalidDesignResourceHandoff("fact_target_outside_subject", `${fact.key}:${fact.subject_ref}:${fact.target_ref}`);
+        if (!target.condition_refs.includes(fact.condition_ref))
+            invalidDesignResourceHandoff("fact_condition_outside_target", `${fact.key}:${fact.target_ref}:${fact.condition_ref}`);
+        if (fact.observation_scope === "full_target" &&
+            (subject.kind !== "surface" ||
+                !subject.stable_keys.some((key) => handoff.scope.surface_keys.includes(key))))
+            invalidDesignResourceHandoff("full_target_fact_surface_required", `${fact.key}:${fact.subject_ref}`);
+        if (!designFactMethodIsCompatible(fact.dimension, fact.verification_method))
+            invalidDesignResourceHandoff("fact_verification_method_incompatible", `${fact.key}:${fact.dimension}:${fact.verification_method}`);
+        for (const sourceItemRef of fact.source_item_refs) {
+            requireKnownDesignResourceRef(sourceItems, sourceItemRef, "source_item");
+            requireDesignSourceItemKind(sourceItems, sourceItemRef);
+        }
+        let exactResourceEvidence = false;
+        for (const evidenceRef of fact.evidence_refs) {
+            requireKnownDesignResourceRef(evidence, evidenceRef, "evidence");
+            const item = evidence.get(evidenceRef);
+            if (!target.resource_refs.includes(item.resource_ref))
+                invalidDesignResourceHandoff("fact_evidence_outside_target", `${fact.key}:${evidenceRef}:${fact.target_ref}`);
+            if (!item.condition_refs.includes(fact.condition_ref))
+                invalidDesignResourceHandoff("fact_evidence_condition_mismatch", `${fact.key}:${evidenceRef}:${fact.condition_ref}`);
+            if (!designFactEvidenceIsCompatible(fact.dimension, item.kind))
+                invalidDesignResourceHandoff("fact_evidence_kind_incompatible", `${fact.key}:${fact.dimension}:${evidenceRef}:${item.kind}`);
+            if (resources.get(item.resource_ref)?.role === "exact_target")
+                exactResourceEvidence = true;
+        }
+        if (fact.observation_scope === "full_target" && !exactResourceEvidence)
+            invalidDesignResourceHandoff("full_target_fact_exact_resource_required", fact.key);
+    }
+    validateExactTargetFacts(handoff);
+    validateResourceFactClosure(handoff, resources, evidence);
+}
+function validateExactTargetFacts(handoff) {
+    for (const target of handoff.targets) {
+        if (target.interpretation !== "exact_target")
+            continue;
+        for (const conditionRef of target.condition_refs)
+            for (const method of EXACT_TARGET_FULL_TARGET_METHODS)
+                if (!handoff.facts.some((fact) => fact.target_ref === target.key &&
+                    fact.condition_ref === conditionRef &&
+                    fact.observation_scope === "full_target" &&
+                    fact.verification_method === method))
+                    invalidDesignResourceHandoff("exact_target_full_target_fact_missing", `${target.key}:${conditionRef}:${method}`);
+    }
+}
+function validateResourceFactClosure(handoff, resources, evidence) {
+    const closuresByResource = new Map();
+    for (const closure of handoff.resource_fact_closure) {
+        requireKnownDesignResourceRef(resources, closure.resource_ref, "resource_fact_closure_resource");
+        if (closuresByResource.has(closure.resource_ref))
+            invalidDesignResourceHandoff("resource_fact_closure_duplicate", closure.resource_ref);
+        closuresByResource.set(closure.resource_ref, closure.key);
+        requireUniqueDesignResourceValues(closure.fact_refs, `resource_fact_closure_fact_ref_duplicate:${closure.key}`);
+        const expected = handoff.facts
+            .filter((fact) => fact.evidence_refs.some((evidenceRef) => evidence.get(evidenceRef)?.resource_ref === closure.resource_ref))
+            .map((fact) => fact.key);
+        for (const factRef of closure.fact_refs)
+            if (!handoff.facts.some((fact) => fact.key === factRef))
+                invalidDesignResourceHandoff("resource_fact_closure_fact_unknown", `${closure.key}:${factRef}`);
+        assertSameSet(closure.fact_refs, expected, "resource_fact_closure_mismatch", closure.resource_ref);
+        const resource = resources.get(closure.resource_ref);
+        if (closure.disposition === "material_with_facts" &&
+            closure.fact_refs.length === 0)
+            invalidDesignResourceHandoff("resource_fact_closure_facts_required", closure.key);
+        if (closure.disposition === "supporting_only" &&
+            closure.fact_refs.length > 0)
+            invalidDesignResourceHandoff("supporting_only_resource_fact_forbidden", closure.key);
+        if (resource.role !== "supporting" &&
+            closure.disposition !== "material_with_facts")
+            invalidDesignResourceHandoff("target_resource_fact_closure_required", `${closure.key}:${resource.role}`);
+    }
+    for (const resource of handoff.resources)
+        if (!closuresByResource.has(resource.key))
+            invalidDesignResourceHandoff("resource_fact_closure_missing", resource.key);
+}
+function assertSameSet(actual, expected, code, detail) {
+    const left = [...new Set(actual)].sort();
+    const right = [...new Set(expected)].sort();
+    if (left.length !== right.length ||
+        left.some((item, index) => item !== right[index]))
+        invalidDesignResourceHandoff(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+}