project-tiny-context-harness 0.8.2 → 0.8.3

package/dist/commands/design-resource.js

@@ -26,7 +26,7 @@ export async function designResource(args) {
     console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
 }
 function help() {
-    console.log(`ty-context design-resource commands:
-  preflight <handoff.md> [--json]
+    console.log(`ty-context design-resource commands:
+  preflight <handoff.md> [--json]
                        Validate one selected implementation handoff`);
 }

package/dist/commands/index.js

@@ -36,32 +36,32 @@ export const commands = {
     package: packageSource,
 };
 export function help() {
-    console.log(`ty-context commands:
-  init [--adopt] [--harness-folder <path>]
-                       Initialize/adopt a project; without --harness-folder, choose target agent first
-  enable long-task     Install Long-Task Skill, Source Plan pointer, Stop Hook and templates
-  disable long-task    Remove only package-owned long-task profile assets
-  sync                 Refresh managed assets; does not run migrations
-  upgrade [--check] [--json]
-                       Run safe migrations, sync managed assets and doctor
-  doctor               Diagnose project configuration and drift
-  check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
-                       Warn when selected handwritten source files exceed a line-count limit
-  export-context --full|--code|--all|--source-pack|--code-index|--task-context
-                       Export temporary Context, code snapshot or bounded Source Pack artifacts
-  validate <gate>      Run a Harness validation gate
-  validate-context     Validate Minimal Context fact-source recoverability
-  validate-code-modularity
-                       Enforce touched handwritten source file modularity
-  validate-harness     Run validate-context and validate-code-modularity
-  design-resource <subcommand>
-                       Validate a selected design-resource implementation handoff
-  long-task <subcommand>
-                       Manage one Canonical Delivery Contract in the current workspace
-  delivery-set <subcommand>
-                       Retired; use one complete Contract with semantic Outcomes
-  composite-long-task Retired command; use ty-context long-task
-  composite-campaign  Retired command; use ty-context long-task
+    console.log(`ty-context commands:
+  init [--adopt] [--harness-folder <path>]
+                       Initialize/adopt a project; without --harness-folder, choose target agent first
+  enable long-task     Install Long-Task Skill, Source Plan pointer, Stop Hook and templates
+  disable long-task    Remove only package-owned long-task profile assets
+  sync                 Refresh managed assets; does not run migrations
+  upgrade [--check] [--json]
+                       Run safe migrations, sync managed assets and doctor
+  doctor               Diagnose project configuration and drift
+  check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
+                       Warn when selected handwritten source files exceed a line-count limit
+  export-context --full|--code|--all|--source-pack|--code-index|--task-context
+                       Export temporary Context, code snapshot or bounded Source Pack artifacts
+  validate <gate>      Run a Harness validation gate
+  validate-context     Validate Minimal Context fact-source recoverability
+  validate-code-modularity
+                       Enforce touched handwritten source file modularity
+  validate-harness     Run validate-context and validate-code-modularity
+  design-resource <subcommand>
+                       Validate a selected design-resource implementation handoff
+  long-task <subcommand>
+                       Manage one Canonical Delivery Contract in the current workspace
+  delivery-set <subcommand>
+                       Retired; use one complete Contract with semantic Outcomes
+  composite-long-task Retired command; use ty-context long-task
+  composite-campaign  Retired command; use ty-context long-task
   package <subcommand> Maintain package canonical source`);
 }
 async function withLongTaskProfile(args, handler) {

package/dist/commands/long-task.js

@@ -124,20 +124,20 @@ async function finalGate(workdir, args) {
         process.exitCode = 1;
 }
 function help() {
-    console.log(`ty-context long-task commands:
-  init <workdir>
-  preflight <workdir>
-  compile <workdir>
-  compile <workdir> --revise
-  diagnose-revision <workdir> [--outcome <key>] [--check <key>]
-  approve-authority-revision <workdir> --revision <sha>
-  explain <workdir>
-  verify <workdir> [--outcome <key>] [--check <key>] [--explain]
-  status <workdir>
-  resume <workdir>
-  doctor <workdir>
-  final-gate <workdir>
-  stop-check <workdir> [--message <text>]
-  close <workdir>
+    console.log(`ty-context long-task commands:
+  init <workdir>
+  preflight <workdir>
+  compile <workdir>
+  compile <workdir> --revise
+  diagnose-revision <workdir> [--outcome <key>] [--check <key>]
+  approve-authority-revision <workdir> --revision <sha>
+  explain <workdir>
+  verify <workdir> [--outcome <key>] [--check <key>] [--explain]
+  status <workdir>
+  resume <workdir>
+  doctor <workdir>
+  final-gate <workdir>
+  stop-check <workdir> [--message <text>]
+  close <workdir>
   abandon <workdir> [--force-corrupt-state]`);
 }

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

@@ -36,6 +36,7 @@ export function parseDesignResourceHandoffCoverage(value) {
             "target_refs",
             "condition_refs",
             "evidence_refs",
+            "fact_refs",
             "source_item_refs",
             "verification_methods",
             "rationale",
@@ -54,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}]`;

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

@@ -34,6 +34,8 @@ export interface DesignResourceHandoffV1 {
     subjects: DesignResourceHandoffSubjectV1[];
     targets: DesignResourceHandoffTargetV1[];
     evidence: DesignResourceHandoffEvidenceV1[];
+    facts: DesignResourceHandoffFactV1[];
+    resource_fact_closure: DesignResourceHandoffResourceFactClosureV1[];
     coverage: DesignResourceHandoffCoverageV1[];
     acceptance_blockers: DesignResourceHandoffBlockerV1[];
     proposal: {
@@ -97,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[];
@@ -105,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;
@@ -135,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}`);
@@ -126,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}`);
@@ -140,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) {
@@ -150,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(",")}`);
+}

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

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
 import { validateDesignResourceFiles } from "./design-resource-handoff-file-validation.js";
+import { validateDesignResourceFacts } from "./design-resource-handoff-validation-facts.js";
 import { validateDesignResourceBlockers, validateDesignResourceCoverage, validateDesignResourceReachability, } from "./design-resource-handoff-validation-coverage.js";
 import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonemptyDesignResourceValues, requireUniqueDesignResourceObjects, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
 import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
@@ -25,6 +26,8 @@ export async function preflightDesignResourceHandoff(repository, handoffPath) {
             subjects: handoff.subjects.length,
             targets: handoff.targets.length,
             evidence: handoff.evidence.length,
+            facts: handoff.facts.length,
+            resource_fact_closure: handoff.resource_fact_closure.length,
             coverage: handoff.coverage.length,
             acceptance_blockers: handoff.acceptance_blockers.length,
         },
@@ -38,6 +41,8 @@ export function validateDesignResourceHandoffSemantics(parsed) {
     requireNonemptyDesignResourceValues(handoff.subjects, "subjects_required");
     requireNonemptyDesignResourceValues(handoff.targets, "targets_required");
     requireNonemptyDesignResourceValues(handoff.evidence, "evidence_required");
+    requireNonemptyDesignResourceValues(handoff.facts, "facts_required");
+    requireNonemptyDesignResourceValues(handoff.resource_fact_closure, "resource_fact_closure_required");
     requireNonemptyDesignResourceValues(handoff.coverage, "coverage_required");
     requireUniqueDesignResourceValues(handoff.scope.surface_keys, "scope_surface_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.resources, "resource_key_duplicate");
@@ -46,6 +51,8 @@ export function validateDesignResourceHandoffSemantics(parsed) {
     requireUniqueDesignResourceObjects(handoff.subjects, "subject_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.targets, "target_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.evidence, "evidence_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.facts, "fact_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.resource_fact_closure, "resource_fact_closure_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.coverage, "coverage_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.acceptance_blockers, "acceptance_blocker_key_duplicate");
     const resources = indexDesignResourceItems(handoff.resources);
@@ -53,13 +60,15 @@ export function validateDesignResourceHandoffSemantics(parsed) {
     const subjects = indexDesignResourceItems(handoff.subjects);
     const targets = indexDesignResourceItems(handoff.targets);
     const evidence = indexDesignResourceItems(handoff.evidence);
+    const facts = indexDesignResourceItems(handoff.facts);
     const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
     validateDesignResourceScope(handoff);
     validateDesignResourceConditions(handoff);
     validateDesignResourceSubjects(handoff, targets);
     validateDesignResourceTargets(handoff, resources, conditions);
     validateDesignResourceEvidence(handoff, resources, conditions);
-    validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, sourceItems);
+    validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, facts, sourceItems);
+    validateDesignResourceFacts(handoff, resources, conditions, subjects, targets, evidence, sourceItems);
     validateDesignResourceBlockers(handoff, subjects, targets, sourceItems);
     validateDesignResourceReachability(handoff);
 }