project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/long-task-semantic-drift-migration.js

@@ -22,8 +22,12 @@ export function semanticDriftMigrationFields(value) {
     collectApplicability(global?.applicability, "global.applicability", missing);
     const globalAcceptance = row(global?.acceptance);
     collectChecks(globalAcceptance?.checks, "global.acceptance.checks", missing);
-    for (const [index, confirmation] of rows(globalAcceptance?.external_confirmations).entries())
-        required(confirmation, `global.acceptance.external_confirmations[${index}]`, ["kind", "impact_claims", "blocks_target"], missing);
+    const externalConfirmations = rows(globalAcceptance?.external_confirmations);
+    for (const [index, confirmation] of externalConfirmations.entries())
+        collectExternalConfirmation(confirmation, `global.acceptance.external_confirmations[${index}]`, missing);
+    if (externalConfirmations.some((confirmation) => confirmation.blocks_target === true) &&
+        row(task?.target_profile)?.completion_authority !== "declared_authorities")
+        missing.push("task.target_profile.completion_authority=declared_authorities_or_remove_blocking_external");
     return [...new Set(missing)].sort();
 }
 export function semanticDriftOutcomeMigrationFields(value, label) {
@@ -87,6 +91,48 @@ function collectChecks(value, label, missing) {
                 required(assertion, `${checkLabel}.${polarity}[${assertionIndex}]`, ["evidence_capabilities"], missing);
     }
 }
+function collectExternalConfirmation(confirmation, label, missing) {
+    required(confirmation, label, ["kind", "impact_claims", "blocks_target"], missing);
+    if (confirmation.blocks_target !== true)
+        return;
+    required(confirmation, label, [
+        "actor",
+        "target_ref",
+        "environment_identity",
+        "scenario",
+        "evidence_requirements",
+        "obligations",
+    ], missing);
+    const actor = row(confirmation.actor);
+    if (actor) {
+        required(actor, `${label}.actor`, ["identity_assurance"], missing);
+        const assurance = row(actor.identity_assurance);
+        if (assurance) {
+            required(assurance, `${label}.actor.identity_assurance`, ["scheme"], missing);
+            if (assurance.scheme !== "ed25519")
+                missing.push(`${label}.actor.identity_assurance.scheme=ed25519`);
+            else
+                required(assurance, `${label}.actor.identity_assurance`, ["key_id", "public_key_ref"], missing);
+        }
+    }
+    for (const [index, obligation] of rows(confirmation.obligations).entries()) {
+        const obligationLabel = `${label}.obligations[${index}]`;
+        required(obligation, obligationLabel, [
+            "key",
+            "claim_ref",
+            "applicability_ref",
+            "fact_ref",
+            "proof_ref",
+            "method",
+            "proof_surface",
+            "evidence_capabilities",
+            "expected_authority_ref",
+            "result_kind",
+        ], missing);
+        if (obligation.result_kind === "judgment")
+            required(obligation, obligationLabel, ["judgment_basis"], missing);
+    }
+}
 function required(value, label, keys, missing) {
     for (const key of keys)
         if (!Object.hasOwn(value, key))

package/dist/lib/long-task-semantic-fact-binding-types.d.ts

@@ -11,6 +11,7 @@ export interface SemanticFactBindingV2 {
     fact_revision_digest?: string;
     claim_ref: string;
     applicability_ref: string;
+    required_polarity?: "positive" | "negative";
 }
 export type SemanticFactProofBindingV2 = {
     proof_ref: string;
@@ -37,6 +38,25 @@ export interface SemanticFactOutcomeBindingsV2 {
     facts: SemanticFactBindingV2[];
     proofs: SemanticFactProofBindingV2[];
 }
+export interface SemanticFactGlobalObligationBindingV2 {
+    claim_ref: string;
+    applicability_ref: string;
+    target_ref: string;
+    outcome_ref: string;
+    fact_ref: string;
+    proof_ref: string;
+    method: string;
+    required_polarity: "positive" | "negative";
+}
+/**
+ * Links Global Claims to exact obligations that remain owned by the existing
+ * Outcome-scoped Semantic Fact/proof bindings. This is a conservation
+ * projection, not a second Fact inventory or completion authority.
+ */
+export interface SemanticFactGlobalBindingsV2 {
+    manifest_ref: string;
+    obligations: SemanticFactGlobalObligationBindingV2[];
+}
 export interface SemanticFactExpectationV2 {
     manifest_ref: string;
     manifest_sha256: string;

package/dist/lib/long-task-semantic-fact-closure.d.ts

@@ -1,13 +1,17 @@
+import type { LongTaskDesignHandoffPreflight } from "./long-task-design-resource-handoff.js";
+import { type SourceSemanticConservationV2 } from "./long-task-source-conservation.js";
 import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
 import { semanticFactCollectionIdentity } from "./semantic-fact-policy.js";
 import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import type { CapturedContextGraphSnapshot } from "./context-graph-snapshot.js";
 export interface LongTaskSemanticFactClosureV2 {
     manifest: SemanticFactManifestV1;
     manifest_sha256: string;
     manifest_source_path: string;
     expectations_by_check: Map<string, SemanticFactExpectationV2[]>;
+    source_conservation: SourceSemanticConservationV2;
 }
-export declare function validateLongTaskSemanticFactClosure(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[], contextFiles: string[]): Promise<LongTaskSemanticFactClosureV2>;
+export declare function validateLongTaskSemanticFactClosure(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[], context: CapturedContextGraphSnapshot, designHandoffs?: LongTaskDesignHandoffPreflight[]): Promise<LongTaskSemanticFactClosureV2>;
 export declare const semantic_fact_manifest = "semantic-fact-manifest-v1";
 export declare const semantic_fact_contract_projection_enabled = true;
 export declare const expected_semantic_fact_universe: typeof semanticFactCollectionIdentity;

package/dist/lib/long-task-semantic-fact-closure.js

@@ -1,17 +1,24 @@
 import { validateSemanticFactContractProjection } from "./long-task-semantic-fact-contract-closure.js";
 import { assertSameSemanticFactClosureSet, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
-import { collectDesignOwnedSemanticFactSourceItems, validateSemanticFactInputInventory, } from "./long-task-semantic-fact-input-closure.js";
+import { collectDesignOwnedSemanticFactSourceItems, projectDesignOwnedSemanticFacts, validateSemanticFactInputInventory, } from "./long-task-semantic-fact-input-closure.js";
 import { validateSemanticFactBasisClosure } from "./long-task-semantic-fact-provenance-closure.js";
 import { validateSemanticFactLocatedValues } from "./long-task-semantic-fact-value-closure.js";
+import { validateSourceSemanticConservation, } from "./long-task-source-conservation.js";
 import { semanticFactCollectionIdentity, validateSemanticFactManifestPolicy, } from "./semantic-fact-policy.js";
 import { loadSemanticFactManifest } from "./semantic-fact-source-parser.js";
-export async function validateLongTaskSemanticFactClosure(contract, repository, sourceItems, contextFiles) {
+export async function validateLongTaskSemanticFactClosure(contract, repository, sourceItems, context, designHandoffs) {
     const parsed = await loadSemanticFactManifest(repository, contract.task.source_paths);
     const manifest = parsed.manifest;
-    const index = validateSemanticFactManifestPolicy(manifest);
     validateManifestReference(contract, parsed);
-    const designOwnedSourceItems = await collectDesignOwnedSemanticFactSourceItems(repository, contract.task.source_paths);
-    await validateSemanticFactInputInventory(repository, sourceItems, contextFiles, manifest, designOwnedSourceItems);
+    const designProjection = designHandoffs
+        ? projectDesignOwnedSemanticFacts(designHandoffs)
+        : {
+            source_items: await collectDesignOwnedSemanticFactSourceItems(repository, contract.task.source_paths),
+            facts: [],
+        };
+    const index = validateSemanticFactManifestPolicy(manifest, new Set(designProjection.facts.map((fact) => fact.key)));
+    const materialInputs = await validateSemanticFactInputInventory(repository, sourceItems, context, manifest, designProjection);
+    const sourceConservation = validateSourceSemanticConservation(sourceItems, manifest, designProjection, materialInputs, semanticFactClaimPolarities(contract));
     validateSemanticFactBasisClosure(manifest, sourceItems);
     await validateSemanticFactLocatedValues(repository, manifest, sourceItems);
     const expectations = validateSemanticFactContractProjection(contract, manifest, index, new Map(parsed.fact_revisions.map((item) => [item.key, item.revision_digest])), new Map(parsed.obligation_revisions.map((item) => [
@@ -23,8 +30,25 @@ export async function validateLongTaskSemanticFactClosure(contract, repository,
         manifest_sha256: parsed.sha256,
         manifest_source_path: parsed.source_path,
         expectations_by_check: expectations,
+        source_conservation: sourceConservation,
     };
 }
+function semanticFactClaimPolarities(contract) {
+    const result = new Map();
+    for (const outcome of contract.outcomes)
+        for (const binding of outcome.semantic_fact_bindings.facts) {
+            const values = result.get(binding.fact_ref) ?? new Set();
+            values.add(binding.required_polarity ?? "positive");
+            result.set(binding.fact_ref, values);
+        }
+    for (const binding of contract.global.semantic_fact_bindings?.obligations ??
+        []) {
+        const values = result.get(binding.fact_ref) ?? new Set();
+        values.add(binding.required_polarity);
+        result.set(binding.fact_ref, values);
+    }
+    return result;
+}
 function validateManifestReference(contract, parsed) {
     const declared = contract.semantic_fact_manifest;
     if (declared.key !== parsed.manifest.key ||
@@ -45,6 +69,10 @@ function validateManifestReference(contract, parsed) {
         if (outcome.semantic_fact_bindings.manifest_ref !==
             contract.semantic_fact_manifest.key)
             semanticFactClosureInvalid("outcome_manifest_ref_mismatch", `${outcome.key}:${outcome.semantic_fact_bindings.manifest_ref}`);
+    if (contract.global.semantic_fact_bindings &&
+        contract.global.semantic_fact_bindings.manifest_ref !==
+            contract.semantic_fact_manifest.key)
+        semanticFactClosureInvalid("global_manifest_ref_mismatch", contract.global.semantic_fact_bindings.manifest_ref);
 }
 export const semantic_fact_manifest = "semantic-fact-manifest-v1";
 export const semantic_fact_contract_projection_enabled = true;

package/dist/lib/long-task-semantic-fact-contract-closure.js

@@ -1,6 +1,7 @@
 import { validateSemanticFactOutcomeBindings } from "./long-task-semantic-fact-contract-facts.js";
 import { validateSemanticFactProofBindings } from "./long-task-semantic-fact-contract-proofs.js";
-import { assertSameSemanticFactClosureSet, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
+import { globalCompatibleOutcomeApplicabilityCoverage, outcomeApplicabilityPairIdentity, sameApplicabilityProfile, sameOutcomeApplicabilityCoverage, } from "./long-task-applicability-identity.js";
+import { assertSameSemanticFactClosureSet, semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
 export function validateSemanticFactContractProjection(contract, manifest, index, factRevisions, obligationRevisions, sourceRequiresRevisions) {
     const expectations = new Map();
     const allFactBindings = [];
@@ -25,10 +26,184 @@ export function validateSemanticFactContractProjection(contract, manifest, index
         validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired);
         validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired);
     }
+    validateSemanticFactGlobalBindings(contract, manifest, index);
     assertSameSemanticFactClosureSet(allFactBindings, manifest.facts.map((item) => item.key), "contract_all_fact_set");
     assertSameSemanticFactClosureSet(allProofBindings, manifest.proof_obligations.map((item) => item.key), "contract_all_proof_set");
     return expectations;
 }
+function validateSemanticFactGlobalBindings(contract, manifest, index) {
+    const claims = globalMaterialClaims(contract);
+    const bindings = contract.global.semantic_fact_bindings;
+    if (!claims.length) {
+        if (bindings?.obligations.length)
+            semanticFactClosureInvalid("global_semantic_fact_claim_unknown", bindings.obligations[0].claim_ref);
+        return;
+    }
+    if (!bindings)
+        semanticFactClosureInvalid("global_semantic_fact_bindings_required", claims
+            .map((claim) => claim.claim_ref)
+            .sort()
+            .join(","));
+    if (bindings.manifest_ref !== contract.semantic_fact_manifest.key)
+        semanticFactClosureInvalid("global_semantic_fact_manifest_ref_mismatch", `${bindings.manifest_ref}:${contract.semantic_fact_manifest.key}`);
+    const claimsByRef = new Map(claims.map((claim) => [claim.claim_ref, claim]));
+    const applicabilityByRef = new Map(contract.global.applicability.map((item) => [item.key, item]));
+    const validationContext = {
+        contract,
+        index,
+        claims_by_ref: claimsByRef,
+        applicability_by_ref: applicabilityByRef,
+    };
+    validateGlobalObligationRows(bindings.obligations, validationContext);
+    for (const claim of claims)
+        for (const applicabilityRef of claim.applicability_refs)
+            validateGlobalClaimApplicabilityCoverage(contract, manifest, bindings, claim, applicabilityRef, applicabilityByRef);
+}
+function validateGlobalObligationRows(obligations, context) {
+    const tupleKeys = new Set();
+    for (const binding of obligations) {
+        const tupleKey = globalObligationTupleKey(binding);
+        if (tupleKeys.has(tupleKey))
+            semanticFactClosureInvalid("global_semantic_fact_obligation_duplicate", tupleKey.replaceAll("\0", ":"));
+        tupleKeys.add(tupleKey);
+        validateGlobalObligation(binding, context);
+    }
+}
+function globalObligationTupleKey(binding) {
+    return [
+        binding.claim_ref,
+        binding.applicability_ref,
+        binding.target_ref,
+        binding.outcome_ref,
+        binding.fact_ref,
+        binding.proof_ref,
+        binding.method,
+    ].join("\0");
+}
+function validateGlobalObligation(binding, context) {
+    const { contract, index, claims_by_ref, applicability_by_ref } = context;
+    const claim = claims_by_ref.get(binding.claim_ref);
+    if (!claim)
+        semanticFactClosureInvalid("global_semantic_fact_claim_unknown", binding.claim_ref);
+    if (!claim.applicability_refs.includes(binding.applicability_ref))
+        semanticFactClosureInvalid("global_semantic_fact_applicability_not_owned", `${binding.claim_ref}:${binding.applicability_ref}`);
+    if (binding.required_polarity !== claim.required_polarity)
+        semanticFactClosureInvalid("global_semantic_fact_polarity_mismatch", `${binding.claim_ref}:${binding.required_polarity}:${claim.required_polarity}`);
+    const applicability = applicability_by_ref.get(binding.applicability_ref);
+    if (!applicability)
+        semanticFactClosureInvalid("global_semantic_fact_applicability_unknown", `${binding.claim_ref}:${binding.applicability_ref}`);
+    if (binding.target_ref !== applicability.target_ref)
+        semanticFactClosureInvalid("global_semantic_fact_target_mismatch", `${binding.claim_ref}:${binding.applicability_ref}:${binding.target_ref}:${applicability.target_ref}`);
+    const outcome = contract.outcomes.find((item) => item.key === binding.outcome_ref);
+    if (!outcome)
+        semanticFactClosureInvalid("global_semantic_fact_outcome_unknown", `${binding.claim_ref}:${binding.outcome_ref}`);
+    const fact = index.fact_by_ref.get(binding.fact_ref);
+    if (!fact)
+        semanticFactClosureInvalid("global_semantic_fact_unknown", `${binding.claim_ref}:${binding.fact_ref}`);
+    if (fact.outcome_ref !== binding.outcome_ref)
+        semanticFactClosureInvalid("global_semantic_fact_outcome_mismatch", `${binding.fact_ref}:${binding.outcome_ref}:${fact.outcome_ref}`);
+    const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === binding.fact_ref);
+    if (!factBinding)
+        semanticFactClosureInvalid("global_semantic_fact_outcome_binding_missing", `${binding.claim_ref}:${binding.outcome_ref}:${binding.fact_ref}`);
+    const factApplicability = outcome.applicability.find((item) => item.key === factBinding.applicability_ref);
+    if (!factApplicability || factApplicability.target_ref !== binding.target_ref)
+        semanticFactClosureInvalid("global_semantic_fact_outcome_target_mismatch", `${binding.claim_ref}:${binding.outcome_ref}:${binding.fact_ref}:${binding.target_ref}`);
+    if (!sameApplicabilityProfile(applicability, factApplicability))
+        semanticFactClosureInvalid("global_semantic_fact_applicability_profile_mismatch", `${binding.claim_ref}:${binding.applicability_ref}:${binding.outcome_ref}:${factBinding.applicability_ref}`);
+    const proof = index.proof_by_ref.get(binding.proof_ref);
+    if (!proof)
+        semanticFactClosureInvalid("global_semantic_fact_proof_unknown", `${binding.claim_ref}:${binding.proof_ref}`);
+    if (proof.fact_ref !== binding.fact_ref ||
+        proof.method !== binding.method ||
+        !outcome.semantic_fact_bindings.proofs.some((item) => item.proof_ref === binding.proof_ref &&
+            item.fact_ref === binding.fact_ref &&
+            item.method === binding.method))
+        semanticFactClosureInvalid("global_semantic_fact_proof_identity_mismatch", `${binding.claim_ref}:${binding.fact_ref}:${binding.proof_ref}:${binding.method}`);
+    if (!globalClaimSourceOwners(contract, binding.claim_ref).some((sourceRef) => fact.source_item_refs.includes(sourceRef)))
+        semanticFactClosureInvalid("global_semantic_fact_source_lineage_missing", `${binding.claim_ref}:${binding.fact_ref}`);
+}
+function validateGlobalClaimApplicabilityCoverage(contract, manifest, bindings, claim, applicabilityRef, applicabilityByRef) {
+    const applicability = applicabilityByRef.get(applicabilityRef);
+    if (!applicability)
+        semanticFactClosureInvalid("global_semantic_fact_applicability_unknown", `${claim.claim_ref}:${applicabilityRef}`);
+    const selected = bindings.obligations.filter((item) => item.claim_ref === claim.claim_ref &&
+        item.applicability_ref === applicabilityRef &&
+        item.target_ref === applicability.target_ref);
+    if (!selected.length)
+        semanticFactClosureInvalid("broad_claim_semantic_fact_required", `GLOBAL:${claim.claim_ref}:${applicabilityRef}`);
+    const localCoverage = globalCompatibleOutcomeApplicabilityCoverage(contract, applicability);
+    validateGlobalTargetOutcomeCoverage(claim.claim_ref, applicabilityRef, applicability.target_ref, localCoverage, selected);
+    validateGlobalLocalApplicabilityCoverage(contract, claim.claim_ref, applicabilityRef, localCoverage, selected);
+    validateGlobalFactMethodCoverage(manifest, claim.claim_ref, applicabilityRef, selected);
+}
+function validateGlobalTargetOutcomeCoverage(claimRef, applicabilityRef, targetRef, localCoverage, selected) {
+    const requiredOutcomes = localCoverage.target_outcome_refs;
+    if (!requiredOutcomes.length)
+        semanticFactClosureInvalid("global_semantic_fact_target_unowned", `${claimRef}:${applicabilityRef}:${targetRef}`);
+    if (localCoverage.missing_outcome_refs.length)
+        semanticFactClosureInvalid("global_semantic_fact_outcome_applicability_missing", `${claimRef}:${applicabilityRef}:${localCoverage.missing_outcome_refs.join(",")}`);
+    const coveredOutcomes = [
+        ...new Set(selected.map((item) => item.outcome_ref)),
+    ].sort();
+    if (requiredOutcomes.length !== coveredOutcomes.length ||
+        requiredOutcomes.some((outcomeRef, index) => outcomeRef !== coveredOutcomes[index]))
+        semanticFactClosureInvalid("global_semantic_fact_target_coverage_incomplete", `${claimRef}:${applicabilityRef}:required=${requiredOutcomes.join(",")}:actual=${coveredOutcomes.join(",")}`);
+}
+function validateGlobalLocalApplicabilityCoverage(contract, claimRef, applicabilityRef, localCoverage, selected) {
+    const covered = [
+        ...new Map(selected.map((item) => {
+            const outcome = contract.outcomes.find((candidate) => candidate.key === item.outcome_ref);
+            const factBinding = outcome.semantic_fact_bindings.facts.find((candidate) => candidate.fact_ref === item.fact_ref);
+            const pair = {
+                outcome_ref: item.outcome_ref,
+                applicability_ref: factBinding.applicability_ref,
+            };
+            return [outcomeApplicabilityPairIdentity(pair), pair];
+        })).values(),
+    ];
+    if (!sameOutcomeApplicabilityCoverage(localCoverage.required_pairs, covered))
+        semanticFactClosureInvalid("global_semantic_fact_local_applicability_coverage_incomplete", `${claimRef}:${applicabilityRef}:required=${localCoverage.required_pairs.map(outcomeApplicabilityPairIdentity).join(",")}:actual=${covered.map(outcomeApplicabilityPairIdentity).sort().join(",")}`);
+}
+function validateGlobalFactMethodCoverage(manifest, claimRef, applicabilityRef, selected) {
+    for (const factRef of new Set(selected.map((item) => item.fact_ref))) {
+        const requiredProofs = manifest.proof_obligations
+            .filter((proof) => proof.fact_ref === factRef)
+            .map((proof) => `${proof.key}\0${proof.method}`)
+            .sort();
+        const boundProofs = selected
+            .filter((item) => item.fact_ref === factRef)
+            .map((item) => `${item.proof_ref}\0${item.method}`)
+            .sort();
+        if (requiredProofs.length !== boundProofs.length ||
+            requiredProofs.some((proofIdentity, index) => proofIdentity !== boundProofs[index]))
+            semanticFactClosureInvalid("global_semantic_fact_method_coverage_incomplete", `${claimRef}:${applicabilityRef}:${factRef}`);
+    }
+}
+function globalMaterialClaims(contract) {
+    return [
+        ...contract.global.product.non_goals.map((item) => ({
+            claim_ref: `non_goal.${item.key}`,
+            applicability_refs: item.applicability_refs,
+            required_polarity: "negative",
+        })),
+        ...contract.global.technical.constraints.map((item) => ({
+            claim_ref: `constraint.${item.key}`,
+            applicability_refs: item.applicability_refs,
+            required_polarity: "positive",
+        })),
+        ...contract.global.technical.forbidden_shortcuts.map((item) => ({
+            claim_ref: `forbidden_shortcut.${item.key}`,
+            applicability_refs: item.applicability_refs,
+            required_polarity: "negative",
+        })),
+    ];
+}
+function globalClaimSourceOwners(contract, claimRef) {
+    return contract.source_claims
+        .filter((source) => source.disposition.type === "global_constraint" &&
+        source.disposition.refs.includes(claimRef))
+        .map((source) => source.key);
+}
 function revisionPair(key, digest, label) {
     if (!digest)
         throw new Error(`semantic_fact_closure_invalid:${label}:${key}:missing`);

package/dist/lib/long-task-semantic-fact-contract-proofs.js

@@ -59,7 +59,24 @@ function validateMachineProofProjection(contract, outcome, manifest, index, bind
         assertion.operator !== "equals" ||
         assertion.expected !== true ||
         !sameSemanticFactClosureSet(assertion.evidence_capabilities, binding.evidence_capabilities))
-        semanticFactClosureInvalid("semantic_fact_assertion_binding_mismatch", `${binding.check_ref}:${binding.assertion_ref}`);
+        semanticFactClosureInvalid("semantic_fact_assertion_binding_mismatch", {
+            check_ref: binding.check_ref,
+            assertion_ref: binding.assertion_ref,
+            expected: {
+                claims: [factBinding.claim_ref],
+                applicability_ref: factBinding.applicability_ref,
+                operator: "equals",
+                expected: true,
+                evidence_capabilities: [...binding.evidence_capabilities].sort(),
+            },
+            actual: {
+                claims: assertion.claims,
+                applicability_ref: assertion.applicability_ref ?? null,
+                operator: assertion.operator,
+                expected: "expected" in assertion ? assertion.expected : null,
+                evidence_capabilities: [...assertion.evidence_capabilities].sort(),
+            },
+        });
     validateSemanticFactCounterfactualProjection(outcome, proof, factBinding.claim_ref, binding.check_ref, binding.assertion_ref);
     const fact = index.fact_by_ref.get(binding.fact_ref);
     const rows = expectations.get(binding.check_ref) ?? [];

package/dist/lib/long-task-semantic-fact-input-closure.d.ts

@@ -1,4 +1,18 @@
-import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
+import type { CompiledSourceItemV2, MaterialTextInputV2 } from "./long-task-source-authority-types.js";
+import type { LongTaskDesignHandoffPreflight } from "./long-task-design-resource-handoff.js";
 import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import type { CapturedContextGraphSnapshot } from "./context-graph-snapshot.js";
+export interface DesignOwnedSemanticFactProjectionV1 {
+    key: string;
+    source_item_refs: string[];
+    basis_refs: string[];
+    expected_search_text: string;
+}
+export interface DesignOwnedSemanticProjectionV1 {
+    source_items: Set<string>;
+    facts: DesignOwnedSemanticFactProjectionV1[];
+}
+export declare function designOwnedSemanticFactProjectionKey(kind: "fact" | "fact_rule", handoffPath: string, factKey: string): string;
+export declare function projectDesignOwnedSemanticFacts(preflights: LongTaskDesignHandoffPreflight[]): DesignOwnedSemanticProjectionV1;
 export declare function collectDesignOwnedSemanticFactSourceItems(repository: string, sourcePaths: string[]): Promise<Set<string>>;
-export declare function validateSemanticFactInputInventory(repository: string, sourceItems: CompiledSourceItemV2[], contextFiles: string[], manifest: SemanticFactManifestV1, designOwnedSourceItems: Set<string>): Promise<void>;
+export declare function validateSemanticFactInputInventory(repository: string, sourceItems: CompiledSourceItemV2[], context: CapturedContextGraphSnapshot, manifest: SemanticFactManifestV1, designProjection: DesignOwnedSemanticProjectionV1): Promise<MaterialTextInputV2[]>;

package/dist/lib/long-task-semantic-fact-input-closure.js

@@ -3,8 +3,86 @@ import path from "node:path";
 import { containsDesignResourceHandoff, parseDesignResourceHandoffMarkdown, } from "./design-resource-handoff-parser.js";
 import { assertSameSemanticFactClosureSet, semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
 import { validateSemanticFactProvenance } from "./long-task-semantic-fact-provenance-closure.js";
+import { deriveMaterialTextInputs } from "./long-task-material-input-closure.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { sha256Hex } from "./strict-codec.js";
+export function designOwnedSemanticFactProjectionKey(kind, handoffPath, factKey) {
+    return `design.${kind}.${sha256Hex(`${kind}\0${handoffPath}\0${factKey}`)}`;
+}
+export function projectDesignOwnedSemanticFacts(preflights) {
+    const sourceItems = new Set();
+    const facts = new Map();
+    for (const preflight of preflights) {
+        for (const key of preflight.source_item_keys)
+            sourceItems.add(key);
+        if ("preflight_schema_version" in preflight)
+            for (const rule of preflight.manifest.fact_rules)
+                addDesignFactProjection(facts, {
+                    key: designOwnedSemanticFactProjectionKey("fact_rule", preflight.handoff_path, rule.key),
+                    source_item_refs: [...rule.source_item_refs],
+                    basis_refs: [...rule.semantic_obligation_refs],
+                    expected_search_text: [
+                        rule.key,
+                        rule.subject_or_relation_ref,
+                        rule.target_ref,
+                        rule.property_ref,
+                        rule.population_ref ?? "",
+                        rule.quantifier,
+                        rule.value_kind,
+                        rule.provenance_ref,
+                        rule.observation_scope,
+                        rule.expected.locator.resource_ref,
+                        rule.expected.locator.kind,
+                        rule.expected.locator.value,
+                        rule.expected.sha256,
+                        JSON.stringify(rule.region),
+                        ...rule.evidence_refs,
+                        ...rule.census_refs,
+                        ...rule.semantic_obligation_refs,
+                    ].join("\n"),
+                });
+        else
+            for (const fact of preflight.handoff.facts)
+                addDesignFactProjection(facts, {
+                    key: designOwnedSemanticFactProjectionKey("fact", preflight.handoff_path, fact.key),
+                    source_item_refs: [...fact.source_item_refs],
+                    basis_refs: [...fact.evidence_refs],
+                    expected_search_text: [
+                        fact.key,
+                        fact.cell_ref,
+                        fact.subject_ref,
+                        fact.target_ref,
+                        fact.condition_ref,
+                        fact.variation_ref,
+                        fact.property_ref,
+                        fact.dimension,
+                        fact.observation_scope,
+                        fact.value_kind,
+                        fact.value.locator.resource_ref,
+                        fact.value.locator.kind,
+                        fact.value.locator.value,
+                        fact.value.sha256,
+                        fact.lineage.design_system_ref ?? "",
+                        ...fact.lineage.token_chain_refs,
+                        ...fact.lineage.override_chain_refs,
+                        fact.lineage.resolved_value.locator.resource_ref,
+                        fact.lineage.resolved_value.locator.kind,
+                        fact.lineage.resolved_value.locator.value,
+                        fact.lineage.resolved_value.sha256,
+                        ...fact.evidence_refs,
+                    ].join("\n"),
+                });
+    }
+    return {
+        source_items: sourceItems,
+        facts: [...facts.values()].sort((left, right) => left.key.localeCompare(right.key)),
+    };
+}
+function addDesignFactProjection(facts, fact) {
+    if (facts.has(fact.key))
+        semanticFactClosureInvalid("design_fact_projection_duplicate", fact.key);
+    facts.set(fact.key, fact);
+}
 export async function collectDesignOwnedSemanticFactSourceItems(repository, sourcePaths) {
     const result = new Set();
     for (const sourcePath of sourcePaths) {
@@ -18,18 +96,20 @@ export async function collectDesignOwnedSemanticFactSourceItems(repository, sour
     }
     return result;
 }
-export async function validateSemanticFactInputInventory(repository, sourceItems, contextFiles, manifest, designOwnedSourceItems) {
+export async function validateSemanticFactInputInventory(repository, sourceItems, context, manifest, designProjection) {
+    const designOwnedSourceItems = designProjection.source_items;
     const sourceItemByKey = new Map(sourceItems.map((item) => [item.key, item]));
     const sourceInputs = manifest.inputs.filter((item) => item.kind === "source_item");
     assertSameSemanticFactClosureSet(manifest.scope.source_item_refs, sourceItems.map((item) => item.key), "manifest_source_item_universe");
     assertSameSemanticFactClosureSet(sourceInputs.map((item) => item.source_ref), sourceItems.map((item) => item.key), "input_source_item_universe");
     validateSourceInputDigests(sourceInputs, sourceItemByKey, designOwnedSourceItems);
     const contextInputs = manifest.inputs.filter((item) => item.kind === "context");
-    assertSameSemanticFactClosureSet(contextInputs.map((item) => item.source_ref), contextFiles, "input_context_universe");
+    assertSameSemanticFactClosureSet(contextInputs.map((item) => item.source_ref), context.snapshot.files, "input_context_universe");
     for (const input of manifest.inputs)
-        await validateInput(repository, manifest, input, designOwnedSourceItems);
-    validateInputFactLineage(manifest, sourceInputs);
+        await validateInput(repository, manifest, input, designOwnedSourceItems, context.physical_files);
+    validateInputFactLineage(manifest, sourceInputs, designProjection.facts);
     validateSemanticFactProvenance(manifest, sourceItems);
+    return deriveMaterialTextInputs(repository, sourceItems, manifest, designOwnedSourceItems);
 }
 function validateSourceInputDigests(sourceInputs, sourceItemByKey, designOwnedSourceItems) {
     for (const input of sourceInputs) {
@@ -43,14 +123,32 @@ function validateSourceInputDigests(sourceInputs, sourceItemByKey, designOwnedSo
             semanticFactClosureInvalid("material_source_item_disposition_mismatch", `${input.key}:${input.source_ref}:${input.disposition}:${designOwned ? "ui_design_or_non_ui_material" : "non_ui_material"}`);
     }
 }
-async function validateInput(repository, manifest, input, designOwnedSourceItems) {
+async function validateInput(repository, manifest, input, designOwnedSourceItems, contextPhysicalFiles) {
+    const projectionInput = input.kind === "source_fragment" || input.kind === "semantic_anchor";
+    const projectionDispositions = [
+        "fact_bearing",
+        "supporting_basis",
+        "superseded",
+        "decision_required",
+        "scope_excluded",
+    ];
+    const resourceDispositions = [
+        "non_ui_material",
+        "ui_design",
+        "supporting_only",
+        "excluded_by_scope",
+    ];
+    if (projectionInput
+        ? !projectionDispositions.includes(input.disposition)
+        : !resourceDispositions.includes(input.disposition))
+        semanticFactClosureInvalid("input_disposition_kind_mismatch", `${input.key}:${input.kind}:${input.disposition}`);
     uniqueSemanticFactClosureValues(input.fact_refs, `input_fact_refs:${input.key}`);
     uniqueSemanticFactClosureValues(input.basis_refs, `input_basis_refs:${input.key}`);
-    if (input.disposition === "non_ui_material"
-        ? !input.fact_refs.length
-        : input.fact_refs.length)
+    const factBearing = ["non_ui_material", "fact_bearing"].includes(input.disposition);
+    const requiresFactRefs = factBearing || input.disposition === "supporting_basis";
+    if (requiresFactRefs ? !input.fact_refs.length : input.fact_refs.length)
         semanticFactClosureInvalid("input_fact_disposition_mismatch", `${input.key}:${input.disposition}`);
-    if (input.disposition !== "non_ui_material" && !input.rationale.trim())
+    if (!factBearing && !input.rationale.trim())
         semanticFactClosureInvalid("input_disposition_rationale_required", input.key);
     if (["canonical_spec", "external_constraint", "delegated_instruction"].includes(input.kind) &&
         input.disposition !== "non_ui_material")
@@ -62,27 +160,46 @@ async function validateInput(repository, manifest, input, designOwnedSourceItems
         ? !["ui_design", "non_ui_material"].includes(input.disposition)
         : input.disposition === "ui_design")
         semanticFactClosureInvalid("ui_design_input_kind_mismatch", `${input.key}:${input.kind}:${input.disposition}`);
-    if (input.disposition === "excluded_by_scope" &&
+    if (["excluded_by_scope", "scope_excluded"].includes(input.disposition) &&
         !manifest.scope.exclusions.some((exclusion) => exclusion.affected_refs.includes(input.key)))
         semanticFactClosureInvalid("input_scope_exclusion_missing", input.key);
-    if (input.kind === "source_item")
+    if (input.kind === "source_item" || projectionInput)
         return;
-    const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...input.source_ref.split("/")), `semantic_fact_input:${input.key}`);
+    const inputPath = input.kind === "context"
+        ? contextPhysicalFiles.get(input.source_ref)
+        : path.resolve(repository, ...input.source_ref.split("/"));
+    if (!inputPath)
+        semanticFactClosureInvalid("input_context_physical_file_missing", `${input.key}:${input.source_ref}`);
+    const file = await assertProtectedRepositoryFile(repository, inputPath, `semantic_fact_input:${input.key}`);
     const digest = sha256Hex(await readFile(file));
     if (digest !== input.sha256)
         semanticFactClosureInvalid("input_resource_digest_mismatch", `${input.key}:${input.source_ref}`);
 }
-function validateInputFactLineage(manifest, sourceInputs) {
-    const facts = new Map(manifest.facts.map((item) => [item.key, item]));
+function validateInputFactLineage(manifest, sourceInputs, designFacts) {
+    const facts = new Map([
+        ...manifest.facts.map((item) => [
+            item.key,
+            {
+                key: item.key,
+                source_item_refs: item.source_item_refs,
+                basis_refs: item.provenance.basis_refs,
+            },
+        ]),
+        ...designFacts.map((item) => [item.key, item]),
+    ]);
+    const sourceItemRefs = new Set(sourceInputs.map((item) => item.source_ref));
     for (const input of manifest.inputs)
         for (const factRef of input.fact_refs)
             if (!facts.has(factRef))
                 semanticFactClosureInvalid("input_fact_unknown", `${input.key}:${factRef}`);
             else {
                 const fact = facts.get(factRef);
+                const projectedSourceRef = projectionSourceItemRef(input);
                 if (input.kind === "source_item"
                     ? !fact.source_item_refs.includes(input.source_ref)
-                    : !fact.provenance.basis_refs.includes(input.key))
+                    : projectedSourceRef && sourceItemRefs.has(projectedSourceRef)
+                        ? !fact.source_item_refs.includes(projectedSourceRef)
+                        : !fact.basis_refs.includes(input.key))
                     semanticFactClosureInvalid("input_fact_lineage_mismatch", `${input.key}:${factRef}`);
             }
     for (const fact of manifest.facts) {
@@ -99,3 +216,9 @@ function validateInputFactLineage(manifest, sourceInputs) {
             semanticFactClosureInvalid("fact_source_input_required", fact.key);
     }
 }
+function projectionSourceItemRef(input) {
+    if (input.kind !== "source_fragment" && input.kind !== "semantic_anchor")
+        return null;
+    const separator = input.source_ref.indexOf("#fragment:");
+    return separator > 0 ? input.source_ref.slice(0, separator) : null;
+}