project-tiny-context-harness 0.8.17 → 0.11.0

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

@@ -3,7 +3,7 @@ export function validateSemanticFactProvenance(manifest, sourceItems) {
     const sourceRefs = new Set(sourceItems.map((item) => item.key));
     const inputByKey = new Map(manifest.inputs.map((item) => [item.key, item]));
     const materialInputRefs = new Set(manifest.inputs
-        .filter((item) => item.disposition === "non_ui_material")
+        .filter((item) => ["non_ui_material", "fact_bearing"].includes(item.disposition))
         .map((item) => item.key));
     const facts = new Map(manifest.facts.map((item) => [item.key, item]));
     const isMaterialAuthority = (ref) => sourceRefs.has(ref) || materialInputRefs.has(ref);

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

@@ -1,3 +1,4 @@
-import type { SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
+import type { SemanticFactGlobalBindingsV2, SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
 export declare function parseSemanticFactManifestRef(value: unknown, label: string): SemanticFactManifestRefV2;
 export declare function parseSemanticFactOutcomeBindings(value: unknown, label: string): SemanticFactOutcomeBindingsV2;
+export declare function parseSemanticFactGlobalBindings(value: unknown, label: string): SemanticFactGlobalBindingsV2;

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

@@ -13,7 +13,7 @@ export function parseSemanticFactOutcomeBindings(value, label) {
         manifest_ref: semanticRef(row.manifest_ref, `${label}.manifest_ref`),
         facts: array(row.facts, `${label}.facts`).map((item, index) => {
             const itemLabel = `${label}.facts[${index}]`;
-            const entry = object(item, itemLabel, ["fact_ref", "claim_ref", "applicability_ref"], ["fact_revision_digest"]);
+            const entry = object(item, itemLabel, ["fact_ref", "claim_ref", "applicability_ref"], ["fact_revision_digest", "required_polarity"]);
             return {
                 fact_ref: semanticRef(entry.fact_ref, `${itemLabel}.fact_ref`),
                 ...(Object.hasOwn(entry, "fact_revision_digest")
@@ -23,6 +23,11 @@ export function parseSemanticFactOutcomeBindings(value, label) {
                     : {}),
                 claim_ref: semanticRef(entry.claim_ref, `${itemLabel}.claim_ref`),
                 applicability_ref: semanticRef(entry.applicability_ref, `${itemLabel}.applicability_ref`),
+                ...(Object.hasOwn(entry, "required_polarity")
+                    ? {
+                        required_polarity: literal(entry.required_polarity, ["positive", "negative"], `${itemLabel}.required_polarity`),
+                    }
+                    : {}),
             };
         }),
         proofs: array(row.proofs, `${label}.proofs`).map((item, index) => {
@@ -76,6 +81,35 @@ export function parseSemanticFactOutcomeBindings(value, label) {
         }),
     };
 }
+export function parseSemanticFactGlobalBindings(value, label) {
+    const row = object(value, label, ["manifest_ref", "obligations"]);
+    return {
+        manifest_ref: semanticRef(row.manifest_ref, `${label}.manifest_ref`),
+        obligations: array(row.obligations, `${label}.obligations`).map((item, index) => {
+            const itemLabel = `${label}.obligations[${index}]`;
+            const entry = object(item, itemLabel, [
+                "claim_ref",
+                "applicability_ref",
+                "target_ref",
+                "outcome_ref",
+                "fact_ref",
+                "proof_ref",
+                "method",
+                "required_polarity",
+            ]);
+            return {
+                claim_ref: semanticRef(entry.claim_ref, `${itemLabel}.claim_ref`),
+                applicability_ref: semanticRef(entry.applicability_ref, `${itemLabel}.applicability_ref`),
+                target_ref: semanticRef(entry.target_ref, `${itemLabel}.target_ref`),
+                outcome_ref: semanticRef(entry.outcome_ref, `${itemLabel}.outcome_ref`),
+                fact_ref: semanticRef(entry.fact_ref, `${itemLabel}.fact_ref`),
+                proof_ref: semanticRef(entry.proof_ref, `${itemLabel}.proof_ref`),
+                method: semanticRef(entry.method, `${itemLabel}.method`),
+                required_polarity: literal(entry.required_polarity, ["positive", "negative"], `${itemLabel}.required_polarity`),
+            };
+        }),
+    };
+}
 function semanticRef(value, label) {
     const result = string(value, label);
     if (!/^[a-z0-9][a-z0-9._:-]*$/u.test(result))

package/dist/lib/long-task-semantic-proof-adequacy.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticFactManifestV1 } from "./long-task-delivery-types.js";
+export declare function validateSemanticFactProofFloors(manifest: SemanticFactManifestV1): void;

package/dist/lib/long-task-semantic-proof-adequacy.js

@@ -0,0 +1,19 @@
+import { semanticFactProofCapabilityFloor, validateSemanticFactProofProfileClosure, } from "./long-task-semantic-proof-profile.js";
+export function validateSemanticFactProofFloors(manifest) {
+    validateSemanticFactProofProfileClosure(manifest);
+    const facts = new Map(manifest.facts.map((fact) => [fact.key, fact]));
+    for (const proof of manifest.proof_obligations) {
+        const fact = facts.get(proof.fact_ref);
+        const required = semanticFactProofCapabilityFloor(manifest, fact, proof);
+        const missing = [...required].filter((capability) => !proof.evidence_capabilities.includes(capability));
+        if (missing.length)
+            fail("semantic_fact_proof_adequacy_capability_missing", `${proof.key}:${missing.sort().join(",")}`);
+        if (required.has("population_coverage") &&
+            proof.comparison.comparator !== "set_equality" &&
+            proof.method !== "population_set_equality")
+            fail("semantic_fact_population_set_equality_required", proof.key);
+    }
+}
+function fail(code, detail) {
+    throw new Error(`delivery_contract_invalid:${code}:${detail}`);
+}

package/dist/lib/long-task-semantic-proof-profile.d.ts

@@ -0,0 +1,5 @@
+import type { EvidenceCapabilityV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function semanticFactCustomPropertyHasClosedStandardProfile(property: SemanticFactManifestV1["property_dispositions"][number]): boolean;
+export declare function validateSemanticFactProofProfileClosure(manifest: SemanticFactManifestV1): void;
+export declare function semanticFactProofCapabilityFloor(manifest: SemanticFactManifestV1, fact: SemanticFactManifestV1["facts"][number], proof: SemanticFactManifestV1["proof_obligations"][number]): Set<EvidenceCapabilityV2>;

package/dist/lib/long-task-semantic-proof-profile.js

@@ -0,0 +1,187 @@
+import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
+import { isCustomSemanticFactName, SEMANTIC_FACT_PROOF_METHODS, SEMANTIC_FACT_STANDARD_PROPERTIES, } from "./semantic-fact-catalog.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const STANDARD_PROPERTY_CATALOG_SHA256 = "dd71ac2bb67144bd0e9df30c69a0231cc6ba71a72cd202a7e400cd59a3ab7d02";
+const METHOD_CAPABILITY_FLOORS = {
+    exact_value: ["semantic_fact"],
+    schema_contract: ["semantic_fact"],
+    decision_table: ["semantic_fact"],
+    formula_evaluation: ["semantic_fact"],
+    invariant: ["semantic_fact"],
+    transition_trace: ["semantic_fact", "interaction_trace", "state_delta"],
+    sequence_trace: ["semantic_fact", "interaction_trace"],
+    durable_roundtrip: ["semantic_fact", "data_state", "durable_readback"],
+    boundary_invocation: [
+        "semantic_fact",
+        "boundary_invocation",
+        "actual_provenance",
+    ],
+    external_side_effect: [
+        "semantic_fact",
+        "boundary_invocation",
+        "actual_provenance",
+        "external_side_effect",
+        "state_delta",
+    ],
+    population_set_equality: ["semantic_fact", "population_coverage"],
+    concurrency_schedule: ["semantic_fact", "input_variation", "state_delta"],
+    idempotency_repetition: ["semantic_fact", "input_variation", "state_delta"],
+    fault_injection: ["semantic_fact", "failure_injection"],
+    recovery_drill: ["semantic_fact", "failure_injection", "recovery"],
+    migration: ["semantic_fact", "data_state", "durable_readback"],
+    compatibility: ["semantic_fact", "input_variation"],
+    performance: ["semantic_fact", "target_runtime"],
+    capacity: ["semantic_fact", "target_runtime"],
+    security: ["semantic_fact", "target_runtime", "data_state"],
+    privacy: ["semantic_fact", "data_state"],
+    audit: ["semantic_fact", "data_state", "durable_readback"],
+    observability: ["semantic_fact", "target_runtime"],
+    deployment: ["semantic_fact", "presence", "target_runtime"],
+    implementation_structure: ["semantic_fact", "presence"],
+};
+const PROPERTY_CLASS_CAPABILITIES = {
+    durable: ["data_state", "durable_readback"],
+    boundary: ["boundary_invocation", "actual_provenance"],
+    identity: ["distinct_identity", "data_state", "target_runtime"],
+    transition: ["interaction_trace", "state_delta"],
+    recovery: ["failure_injection", "recovery"],
+    population: ["population_coverage"],
+    visual: ["visual_render", "design_conformance"],
+};
+const PROPERTY_CLASSES = {
+    durable: new Set([
+        "persistence_cache_search.persistence",
+        "persistence_cache_search.archive",
+        "persistence_cache_search.retention",
+        "persistence_cache_search.deletion",
+        "transaction_consistency_concurrency_idempotency.durability",
+        "reliability_slo.durability",
+        "event_message_job.retention",
+        "backup_restore_disaster_recovery.backup_scope",
+        "commercial_billing.audit",
+    ]),
+    boundary: new Set([
+        "api_protocol.operation_identity",
+        "api_protocol.request_body",
+        "api_protocol.callback_webhook",
+        "external_integration.provider_protocol_identity",
+        "external_integration.request_contract",
+        "external_integration.callback_contract",
+        "external_integration.side_effect_observation",
+        "commercial_billing.processor_confirmation",
+    ]),
+    identity: new Set([
+        "actor_role_tenant_entitlement.identity",
+        "actor_role_tenant_entitlement.impersonation",
+        "actor_role_tenant_entitlement.isolation_boundary",
+        "data_model.identity",
+        "security.authentication",
+        "security.identity_proofing",
+        "security.authorization",
+        "security.tenant_isolation",
+        "api_protocol.authentication",
+        "api_protocol.authorization",
+    ]),
+    transition: new Set([
+        "operation_workflow.trigger",
+        "operation_workflow.ordered_step",
+        "operation_workflow.state_transition",
+        "operation_workflow.synchronous_effect",
+        "operation_workflow.asynchronous_effect",
+        "state_machine.transition",
+        "state_machine.illegal_transition",
+        "state_machine.reentry",
+        "state_machine.interruption",
+        "commercial_billing.payment_state",
+    ]),
+    recovery: new Set([
+        "state_machine.recovery",
+        "state_machine.restoration",
+        "input_validation.lossless_recovery",
+        "output_error.recovery",
+        "fault_degradation_recovery.recovery_trigger",
+        "fault_degradation_recovery.restoration_point",
+        "fault_degradation_recovery.data_loss_prevention",
+        "backup_restore_disaster_recovery.restore_procedure",
+        "backup_restore_disaster_recovery.restore_verification",
+        "backup_restore_disaster_recovery.drill_evidence",
+        "compatibility_migration_rollout.failure_recovery",
+        "reliability_slo.recovery_response",
+        "architecture_ownership.recovery",
+    ]),
+    population: new Set([
+        "data_model.cardinality",
+        "performance_capacity_cost.dataset_cardinality",
+        "reliability_slo.population",
+        "ai_ml.evaluation_population",
+    ]),
+    visual: new Set([
+        "architecture_ownership.selected_design",
+        "notification_file_media.dimensions",
+        "notification_file_media.accessibility_alternative",
+    ]),
+};
+export function semanticFactCustomPropertyHasClosedStandardProfile(property) {
+    return (!property.standard &&
+        isCustomSemanticFactName(property.property) &&
+        property.required_methods.length > 0 &&
+        property.required_methods.every((method) => Object.hasOwn(METHOD_CAPABILITY_FLOORS, method)));
+}
+export function validateSemanticFactProofProfileClosure(manifest) {
+    const digest = sha256Hex(canonicalValueJson(SEMANTIC_FACT_STANDARD_PROPERTIES));
+    if (digest !== STANDARD_PROPERTY_CATALOG_SHA256)
+        semanticFactClosureInvalid("standard_property_profile_catalog_changed", `${digest}:${STANDARD_PROPERTY_CATALOG_SHA256}`);
+    if (Object.keys(METHOD_CAPABILITY_FLOORS).length !==
+        SEMANTIC_FACT_PROOF_METHODS.length ||
+        SEMANTIC_FACT_PROOF_METHODS.some((method) => !Object.hasOwn(METHOD_CAPABILITY_FLOORS, method)))
+        semanticFactClosureInvalid("standard_proof_method_profile_incomplete", SEMANTIC_FACT_PROOF_METHODS.join(","));
+    const families = new Map(manifest.family_dispositions.map((family) => [family.key, family.family]));
+    for (const property of manifest.property_dispositions) {
+        const family = families.get(property.family_ref);
+        if (!family)
+            semanticFactClosureInvalid("proof_profile_property_family_unknown", property.key);
+        const catalog = SEMANTIC_FACT_STANDARD_PROPERTIES[family];
+        const catalogStandard = Boolean(catalog?.includes(property.property));
+        if (property.standard !== catalogStandard)
+            semanticFactClosureInvalid("proof_profile_property_standard_mismatch", `${property.key}:${family}.${property.property}`);
+    }
+    const known = new Set(Object.entries(SEMANTIC_FACT_STANDARD_PROPERTIES).flatMap(([family, properties]) => properties.map((property) => `${family}.${property}`)));
+    for (const [className, members] of Object.entries(PROPERTY_CLASSES))
+        for (const member of members)
+            if (!known.has(member))
+                semanticFactClosureInvalid("proof_profile_property_member_unknown", `${className}:${member}`);
+}
+export function semanticFactProofCapabilityFloor(manifest, fact, proof) {
+    const property = manifest.property_dispositions.find((row) => row.key === fact.property_ref);
+    if (!property)
+        semanticFactClosureInvalid("proof_profile_fact_property_unknown", `${fact.key}:${fact.property_ref}`);
+    const standardMethod = Object.hasOwn(METHOD_CAPABILITY_FLOORS, proof.method);
+    if (proof.authority === "machine" &&
+        (!standardMethod ||
+            (!property.standard &&
+                !semanticFactCustomPropertyHasClosedStandardProfile(property))))
+        semanticFactClosureInvalid("semantic_fact_custom_machine_authority_forbidden", `${proof.key}:${property.property}:${proof.method}`);
+    const result = new Set(["semantic_fact"]);
+    if (standardMethod)
+        for (const capability of METHOD_CAPABILITY_FLOORS[proof.method])
+            result.add(capability);
+    for (const capability of property.required_evidence_capabilities)
+        result.add(capability);
+    const family = manifest.family_dispositions.find((row) => row.key === fact.family_ref)?.family;
+    const propertyIdentity = `${family}.${property.property}`;
+    for (const [className, members] of Object.entries(PROPERTY_CLASSES))
+        if (members.has(propertyIdentity))
+            for (const capability of PROPERTY_CLASS_CAPABILITIES[className])
+                result.add(capability);
+    if (fact.observation_scope === "implementation_structure")
+        result.add("presence");
+    if (fact.observation_scope === "data_boundary")
+        result.add("data_state");
+    if (fact.observation_scope === "external_boundary") {
+        result.add("boundary_invocation");
+        result.add("actual_provenance");
+    }
+    if (fact.quantifier.kind !== "one")
+        result.add("population_coverage");
+    return result;
+}

package/dist/lib/long-task-shape-primitives.d.ts

@@ -17,5 +17,5 @@ export declare function semanticRef(value: unknown, label: string): string;
 export declare function nullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
 export declare const PROOF_SURFACES: readonly ["ui_browser", "runtime_behavior", "api_contract", "data_state", "security_boundary", "population_coverage", "implementation_structure"];
 export declare const JOURNEY_ROLES: readonly ["success", "degradation", "recovery", "stage_gate", "conformance"];
-export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "external_side_effect", "failure_injection", "visual_render", "design_conformance", "design_method", "design_symbolic_certificate", "semantic_fact", "target_runtime", "input_variation"];
+export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "actual_provenance", "external_side_effect", "distinct_identity", "data_state", "population_coverage", "failure_injection", "recovery", "visual_render", "design_conformance", "design_method", "design_symbolic_certificate", "semantic_fact", "target_runtime", "input_variation"];
 export declare function fail(label: string, message: string): never;

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

@@ -101,8 +101,13 @@ export const EVIDENCE_CAPABILITIES = [
     "cross_surface_consistency",
     "durable_readback",
     "boundary_invocation",
+    "actual_provenance",
     "external_side_effect",
+    "distinct_identity",
+    "data_state",
+    "population_coverage",
     "failure_injection",
+    "recovery",
     "visual_render",
     "design_conformance",
     "design_method",

package/dist/lib/long-task-source-anchors.d.ts

@@ -0,0 +1,10 @@
+import type { MaterialSourceFragmentV2, SemanticSourceAnchorV2 } from "./long-task-source-authority-types.js";
+export type SemanticModalPolarity = "positive" | "negative";
+export interface SemanticModalOccurrenceV2 {
+    value: string;
+    polarity: SemanticModalPolarity;
+}
+export declare function semanticSourceAnchorRef(anchor: Pick<SemanticSourceAnchorV2, "fragment_ref" | "kind" | "value_sha256">): string;
+export declare function deriveSemanticSourceAnchors(fragment: MaterialSourceFragmentV2): SemanticSourceAnchorV2[];
+export declare function semanticModalOccurrences(text: string): SemanticModalOccurrenceV2[];
+export declare function semanticModalPolarity(value: string): SemanticModalPolarity | null;

package/dist/lib/long-task-source-anchors.js

@@ -0,0 +1,102 @@
+import { sha256Hex } from "./strict-codec.js";
+const POSITIVE_MODAL_TERMS = [
+    "must",
+    "shall",
+    "required",
+    "必须",
+    "应当",
+];
+const NEGATIVE_MODAL_TERMS = [
+    "must not",
+    "shall not",
+    "forbidden",
+    "never",
+    "不得",
+    "禁止",
+    "不可",
+    "只能",
+    "仅可",
+];
+export function semanticSourceAnchorRef(anchor) {
+    return `${anchor.fragment_ref}#anchor:${anchor.kind}:${anchor.value_sha256.slice(0, 16)}`;
+}
+export function deriveSemanticSourceAnchors(fragment) {
+    const found = [];
+    collectMatches(found, fragment.normalized_text, "code_mark", /`([^`\n]+)`/gu, 1);
+    collectMatches(found, fragment.normalized_text, "exact_quote", /["“”'‘’]([^"“”'‘’\n]{2,})["“”'‘’]/gu, 1);
+    collectMatches(found, fragment.normalized_text, "api_path", /(?:^|[\s`"'(])((?:\/[A-Za-z0-9._~!$&*+,;=:@%{}-]*[A-Za-z0-9_~!$&*+=@%{}-])+)(?=$|[\s`"'),.;:])/gu, 1);
+    collectMatches(found, fragment.normalized_text, "version", /\bv?\d+\.\d+(?:\.\d+)?(?:[-+][A-Za-z0-9.-]+)?\b/gu);
+    collectMatches(found, fragment.normalized_text, "symbol", /\b[A-Z][A-Z0-9_]{2,}\b/gu);
+    collectMatches(found, fragment.normalized_text, "frozen_identifier", /(?:\b(?:[Pp]rovider|[Pp]rotocol)\b|(?:提供商|供应商|协议))\s*(?:(?:[:：=]|is\b|named\b|called\b|为|是|采用|使用)\s*)?([A-Z][A-Za-z0-9]*(?:[-._][A-Za-z0-9]+)*)/gu, 1);
+    collectMatches(found, fragment.normalized_text, "file_or_schema_key", /\b[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+\b/gu);
+    collectMatches(found, fragment.normalized_text, "file_or_schema_key", /\b([A-Za-z_][\w.-]*)\s*(?=[:=])/gu, 1);
+    collectMatches(found, fragment.normalized_text, "number_or_unit", /\b\d+(?:\.\d+)?(?:\s*(?:-|–|—|\.\.)\s*\d+(?:\.\d+)?)?(?:\s*(?:ms|s|sec|seconds?|min|minutes?|h|hours?|bytes?|KB|MB|GB|%|px|rem|em|rps|qps))?\b/giu);
+    addModalAnchors(found, fragment.normalized_text);
+    return materializeAnchors(fragment, found);
+}
+function addModalAnchors(found, text) {
+    for (const occurrence of semanticModalOccurrences(text))
+        found.push({ kind: "modal_term", value: occurrence.value });
+}
+export function semanticModalOccurrences(text) {
+    const alternatives = [...NEGATIVE_MODAL_TERMS, ...POSITIVE_MODAL_TERMS].sort((left, right) => right.length - left.length);
+    const pattern = new RegExp(`(?:^|[^a-z])(${alternatives
+        .filter((term) => !/[\u3400-\u9fff]/u.test(term))
+        .map(escapeRegex)
+        .join("|")})(?=$|[^a-z])|(${alternatives
+        .filter((term) => /[\u3400-\u9fff]/u.test(term))
+        .map(escapeRegex)
+        .join("|")})`, "giu");
+    const negative = new Set(NEGATIVE_MODAL_TERMS);
+    return [...text.matchAll(pattern)].map((match) => {
+        const value = (match[1] ?? match[2]).toLocaleLowerCase("en-US");
+        return {
+            value,
+            polarity: negative.has(value) ? "negative" : "positive",
+        };
+    });
+}
+export function semanticModalPolarity(value) {
+    const normalized = value.toLocaleLowerCase("en-US");
+    if (NEGATIVE_MODAL_TERMS.includes(normalized))
+        return "negative";
+    if (POSITIVE_MODAL_TERMS.includes(normalized))
+        return "positive";
+    return null;
+}
+function materializeAnchors(fragment, found) {
+    const seen = new Set();
+    return found
+        .map(({ kind, value }) => ({ kind, value: value.trim() }))
+        .filter(({ kind, value }) => {
+        if (!value)
+            return false;
+        const identity = `${kind}\0${value}`;
+        if (seen.has(identity))
+            return false;
+        seen.add(identity);
+        return true;
+    })
+        .map(({ kind, value }) => {
+        const valueSha256 = sha256Hex(value);
+        const base = {
+            fragment_ref: fragment.key,
+            source_item_ref: fragment.source_item_ref,
+            authority_source_item_refs: [...fragment.authority_source_item_refs],
+            authority_domain: fragment.authority_domain,
+            kind,
+            value,
+            value_sha256: valueSha256,
+        };
+        return { ...base, key: semanticSourceAnchorRef(base) };
+    })
+        .sort((left, right) => left.key.localeCompare(right.key));
+}
+function collectMatches(result, value, kind, pattern, group = 0) {
+    for (const match of value.matchAll(pattern))
+        if (match[group])
+            result.push({ kind, value: match[group] });
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}

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

@@ -1,6 +1,52 @@
 import type { RiskFactName } from "./long-task-risk-types.js";
 export type SourceItemKind = "outcome_result" | "requirement" | "control" | "acceptance" | "technical_obligation" | "non_completing" | "non_goal" | "forbidden_shortcut" | "risk_fact" | "external_confirmation" | "decision";
 export type SourceItemAspect = "architecture";
+export type SourceAuthorityDomain = "product" | "technical" | "design" | "acceptance" | "external";
+export type MaterialSourceFragmentKind = "heading" | "paragraph" | "list_item" | "table_row" | "blockquote" | "given_when_then" | "fenced_code" | "structured_config_line" | "textual_html";
+export interface MaterialTextInputV2 {
+    input_key: string;
+    input_kind: "source_item" | "attachment" | "canonical_spec" | "repository_preservation" | "external_constraint" | "delegated_instruction" | "design_resource";
+    source_ref: string;
+    sha256: string;
+    authority_source_item_refs: string[];
+    authority_domain: SourceAuthorityDomain;
+    normalized_text: string;
+}
+export interface MaterialFragmentCoverageV2 {
+    material_nonblank_lines: number[];
+    covered_lines: number[];
+    excluded_separator_lines: number[];
+}
+export interface MaterialFragmentScanResultV2 {
+    fragments: MaterialSourceFragmentV2[];
+    coverage: MaterialFragmentCoverageV2;
+}
+export type SemanticAnchorKind = "code_mark" | "api_path" | "version" | "symbol" | "frozen_identifier" | "file_or_schema_key" | "number_or_unit" | "exact_quote" | "modal_term";
+export interface MaterialSourceFragmentV2 {
+    key: string;
+    input_key: string;
+    source_item_ref: string;
+    authority_source_item_refs: string[];
+    source_path: string;
+    authority_domain: SourceAuthorityDomain;
+    kind: MaterialSourceFragmentKind;
+    ordinal: number;
+    start_line: number;
+    end_line: number;
+    normalized_text: string;
+    text_sha256: string;
+}
+export interface SemanticSourceAnchorV2 {
+    key: string;
+    fragment_ref: string;
+    source_item_ref: string;
+    authority_source_item_refs: string[];
+    authority_domain: SourceAuthorityDomain;
+    kind: SemanticAnchorKind;
+    value: string;
+    value_sha256: string;
+}
+export type SemanticFactClassV2 = "delivery_semantic" | "source_integrity";
 export interface CompiledSourceItemV2 {
     key: string;
     kind: SourceItemKind;

package/dist/lib/long-task-source-claim-validation.js

@@ -7,6 +7,10 @@ export function validateSourceClaimMappings(contract, compiledClaims, report) {
     const productClaims = new Set(Object.values(compiledClaims.by_outcome)
         .flat()
         .map((claim) => claim.id));
+    const claimApplicability = new Map([
+        ...compiledClaims.by_global,
+        ...Object.values(compiledClaims.by_outcome).flat(),
+    ].map((claim) => [claim.id, new Set(claim.applicability_refs)]));
     const executionTargetClaims = new Set(contract.task.execution_targets.map((target) => executionTargetSourceTargetRef(target.key)));
     const globalClaims = new Map(compiledClaims.by_global.map((claim) => [claim.local_key, claim]));
     const coveredGlobalClaims = new Set(Object.entries(compiledClaims.summary.claims_by_global)
@@ -51,8 +55,40 @@ export function validateSourceClaimMappings(contract, compiledClaims, report) {
             validateGlobalRefs(claim.key, disposition.refs, forbiddenPaths, globalClaims, coveredGlobalClaims, report);
         if (disposition.type === "risk_fact")
             validateRiskRefs(contract, claim.key, disposition.refs, report);
+        validateJudgmentBasis(contract, claim, claimApplicability, report);
     }
 }
+function validateJudgmentBasis(contract, claim, claimApplicability, report) {
+    const basis = claim.judgment_basis;
+    if (!basis)
+        return;
+    if (!sourceClaimOwnsClaim(contract, claim, basis))
+        issue(report, "source_claim_judgment_basis_claim_not_owned", `${claim.key}:${basis.claim_ref}`);
+    const applicability = claimApplicability.get(basis.claim_ref);
+    if (!applicability)
+        issue(report, "source_claim_judgment_basis_claim_unknown", `${claim.key}:${basis.claim_ref}`);
+    if (!basis.applicability_refs.length ||
+        new Set(basis.applicability_refs).size !== basis.applicability_refs.length)
+        issue(report, "source_claim_judgment_basis_applicability_set_invalid", claim.key);
+    for (const applicabilityRef of basis.applicability_refs)
+        if (!applicability?.has(applicabilityRef))
+            issue(report, "source_claim_judgment_basis_applicability_unknown", `${claim.key}:${basis.claim_ref}:${applicabilityRef}`);
+}
+function sourceClaimOwnsClaim(contract, claim, basis) {
+    const disposition = claim.disposition;
+    if (disposition.type === "claim" || disposition.type === "global_constraint")
+        return disposition.refs.includes(basis.claim_ref);
+    if (disposition.type === "outcome_result")
+        return disposition.ref === basis.claim_ref;
+    if (disposition.type !== "external_confirmation")
+        return false;
+    return basis.applicability_refs.every((applicabilityRef) => contract.global.acceptance.external_confirmations.some((confirmation) => disposition.refs.includes(confirmation.key) &&
+        confirmation.obligations?.some((obligation) => obligation.claim_ref === basis.claim_ref &&
+            obligation.applicability_ref === applicabilityRef &&
+            obligation.result_kind === "judgment" &&
+            obligation.judgment_basis?.kind === basis.kind &&
+            obligation.judgment_basis.source_ref === claim.key)));
+}
 function validateSourcePresence(contract, report) {
     if (!contract.task.source_paths.length || !contract.source_claims.length)
         issue(report, "source_authority_required", "source_paths and source_claims must be non-empty");

package/dist/lib/long-task-source-conservation-facts.d.ts

@@ -0,0 +1,8 @@
+import type { SemanticFactClassV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import type { SourceConservationFactProjectionV2 } from "./long-task-source-conservation-types.js";
+export declare function addSourceConservationFact(facts: Map<string, SourceConservationFactProjectionV2>, fact: SourceConservationFactProjectionV2): void;
+export declare function semanticFactClass(fact: SemanticFactManifestV1["facts"][number]): SemanticFactClassV2;
+export declare function semanticFactAuthorityDomain(fact: SemanticFactManifestV1["facts"][number], sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>): SourceAuthorityDomain;
+export declare function semanticExpectedContains(fact: SourceConservationFactProjectionV2, value: string): boolean;
+export declare function semanticFactExpectedSearchText(fact: SemanticFactManifestV1["facts"][number]): string;

package/dist/lib/long-task-source-conservation-facts.js

@@ -0,0 +1,57 @@
+import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
+export function addSourceConservationFact(facts, fact) {
+    if (facts.has(fact.key))
+        semanticFactClosureInvalid("source_projection_fact_duplicate", fact.key);
+    facts.set(fact.key, fact);
+}
+export function semanticFactClass(fact) {
+    const structuralLocator = [
+        "source_item",
+        "whole_resource",
+        "code_symbol",
+    ].includes(fact.expected.locator.kind);
+    return fact.observation_scope === "implementation_structure" &&
+        (fact.value_kind === "digest" ||
+            fact.expected.representation === "digest_only" ||
+            structuralLocator)
+        ? "source_integrity"
+        : "delivery_semantic";
+}
+export function semanticFactAuthorityDomain(fact, sourceDomains) {
+    const available = new Set(fact.source_item_refs
+        .map((ref) => sourceDomains.get(ref))
+        .filter((value) => Boolean(value)));
+    if (available.size === 1)
+        return [...available][0];
+    const preferred = fact.observation_scope === "external_boundary"
+        ? "external"
+        : fact.observation_scope === "product_boundary"
+            ? "product"
+            : "technical";
+    if (available.has(preferred))
+        return preferred;
+    for (const candidate of [
+        "acceptance",
+        "product",
+        "technical",
+        "external",
+        "design",
+    ])
+        if (available.has(candidate))
+            return candidate;
+    semanticFactClosureInvalid("fact_authority_domain_missing", fact.key);
+}
+export function semanticExpectedContains(fact, value) {
+    return fact.expected_search_text.includes(value);
+}
+export function semanticFactExpectedSearchText(fact) {
+    return [
+        fact.expected.representation === "inline"
+            ? JSON.stringify(fact.expected.value)
+            : "",
+        fact.expected.locator.value,
+        fact.property_ref,
+        fact.unit_ref,
+        fact.owner_ref,
+    ].join("\n");
+}

package/dist/lib/long-task-source-conservation-types.d.ts

@@ -0,0 +1,34 @@
+import type { MaterialSourceFragmentV2, SemanticFactClassV2, SemanticSourceAnchorV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
+import type { SemanticFactSupportingRelationV1 } from "./semantic-fact-inventory-types.js";
+export type SourceProjectionDispositionV2 = "fact_bearing" | "supporting_basis" | "superseded" | "decision_required" | "scope_excluded";
+export interface ResolvedSourceProjectionV2 {
+    input_key: string;
+    disposition: SourceProjectionDispositionV2;
+    fact_refs: string[];
+    basis_refs: string[];
+    supporting_relation?: SemanticFactSupportingRelationV1;
+    explicit: boolean;
+    authority_derived: boolean;
+}
+export interface SourceConservationFactProjectionV2 {
+    key: string;
+    source_item_refs: string[];
+    basis_refs: string[];
+    semantic_class: SemanticFactClassV2;
+    authority_domain: SourceAuthorityDomain;
+    expected_search_text: string;
+    semantic_cell: {
+        outcome_ref: string;
+        unit_ref: string;
+        family_ref: string;
+        condition_ref: string;
+        property_ref: string;
+        value_kind: string;
+    } | null;
+}
+export interface SourceSemanticConservationV2 {
+    fragments: MaterialSourceFragmentV2[];
+    anchors: SemanticSourceAnchorV2[];
+    fact_classes: Record<string, SemanticFactClassV2>;
+    fact_domains: Record<string, SourceAuthorityDomain>;
+}

package/dist/lib/long-task-source-conservation-types.js

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