project-tiny-context-harness 0.8.4 → 0.8.6

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

@@ -69,6 +69,12 @@ export function key(value, label) {
         fail(label, "must match ^[a-z0-9][a-z0-9-]*$");
     return result;
 }
+export function semanticRef(value, label) {
+    const result = string(value, label);
+    if (!/^[a-z0-9][a-z0-9._:-]*$/u.test(result))
+        fail(label, "must be a stable lowercase semantic reference");
+    return result;
+}
 export function nullable(value, parser) {
     return value === null ? null : parser(value);
 }
@@ -100,6 +106,7 @@ export const EVIDENCE_CAPABILITIES = [
     "visual_render",
     "design_conformance",
     "design_method",
+    "semantic_fact",
     "target_runtime",
     "input_variation",
 ];

package/dist/lib/long-task-source-item-parser.js

@@ -1,7 +1,9 @@
 import { parseDesignResourceHandoffShape } from "./design-resource-handoff-shape.js";
+import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
 import { normalizeSourceItemText, parseSourceBackgroundMarker, parseSourceItemStartMarker, SOURCE_BACKGROUND_END, SOURCE_BACKGROUND_START, SOURCE_ITEM_END, SOURCE_ITEM_START, validateSourceBackgroundLine, } from "./long-task-source-markers.js";
 import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
 const DESIGN_RESOURCE_START = /^\s*```yaml[ \t]+design-resource-handoff-v1[ \t]*$/u;
+const SEMANTIC_FACT_START = /^\s*```yaml[ \t]+semantic-fact-manifest-v1[ \t]*$/u;
 const FORMAL_BLOCK_END = /^\s*```[ \t]*$/u;
 export function parseSourceItems(sourcePath, content) {
     const state = sourceParseState(sourcePath);
@@ -21,6 +23,7 @@ function sourceParseState(sourcePath) {
         background: null,
         formalBlock: null,
         designResourceBlocks: 0,
+        semanticFactBlocks: 0,
     };
 }
 function consumeSourceLine(state, line, lineNumber) {
@@ -42,7 +45,11 @@ function consumeOpenFormalBlock(state, line) {
         return true;
     }
     try {
-        parseDesignResourceHandoffShape(parseStrictYaml(state.formalBlock.lines.join("\n")));
+        const value = parseStrictYaml(state.formalBlock.lines.join("\n"));
+        if (state.formalBlock.owner === "design-resource-handoff-v1")
+            parseDesignResourceHandoffShape(value);
+        else
+            parseSemanticFactManifestShape(value);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -52,14 +59,26 @@ function consumeOpenFormalBlock(state, line) {
     return true;
 }
 function startFormalBlock(state, line, lineNumber) {
-    if (!DESIGN_RESOURCE_START.test(line))
+    const owner = DESIGN_RESOURCE_START.test(line)
+        ? "design-resource-handoff-v1"
+        : SEMANTIC_FACT_START.test(line)
+            ? "semantic-fact-manifest-v1"
+            : null;
+    if (!owner)
         return false;
     assertNoOpenOwnedSection(state, lineNumber);
-    state.designResourceBlocks += 1;
-    if (state.designResourceBlocks > 1)
-        throw new Error(`source_formal_block_duplicate:${state.sourcePath}:design-resource-handoff-v1`);
+    if (owner === "design-resource-handoff-v1") {
+        state.designResourceBlocks += 1;
+        if (state.designResourceBlocks > 1)
+            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:design-resource-handoff-v1`);
+    }
+    else {
+        state.semanticFactBlocks += 1;
+        if (state.semanticFactBlocks > 1)
+            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:semantic-fact-manifest-v1`);
+    }
     state.formalBlock = {
-        owner: "design-resource-handoff-v1",
+        owner,
         lines: [],
         line: lineNumber,
     };

package/dist/lib/long-task-source-target-continuity.js

@@ -32,7 +32,9 @@ function validateSourceClaimContinuity(claim, state, report) {
     }
     const ref = refs[0];
     const target = state.targets.get(ref);
-    if (!target || sourceKindForTarget(target) !== item.kind) {
+    if (!target ||
+        (target.kind !== "semantic_fact" &&
+            sourceKindForTarget(target) !== item.kind)) {
         issue(report, `source_target_kind_mismatch:${claim.key}:${item.kind}:${target ? sourceKindForTarget(target) : "unknown"}:${ref}`);
         return;
     }
@@ -63,6 +65,7 @@ function validateSourceClaimContinuity(claim, state, report) {
             "technical_obligation",
             "non_completing",
             "forbidden_shortcut",
+            "semantic_fact",
         ].includes(target.kind))
         state.sourceBackedOutcomeClaims.add(ref);
     if (!target.outcome_key &&

package/dist/lib/long-task-source-target-index.d.ts

@@ -1,7 +1,7 @@
 import type { DeliveryContractV2, SourceItemKind } from "./long-task-delivery-types.js";
 export interface CanonicalSourceTarget {
     ref: string;
-    kind: "outcome_result" | "requirement" | "control" | "technical_obligation" | "non_completing" | "global_constraint" | "non_goal" | "forbidden_shortcut" | "acceptance" | "risk_fact" | "external_confirmation";
+    kind: "outcome_result" | "requirement" | "control" | "technical_obligation" | "non_completing" | "global_constraint" | "non_goal" | "forbidden_shortcut" | "acceptance" | "semantic_fact" | "risk_fact" | "external_confirmation";
     normalized_text?: string;
     scope?: "global" | "outcome";
     outcome_key?: string;

package/dist/lib/long-task-source-target-index.js

@@ -6,6 +6,8 @@ export function buildCanonicalSourceTargetIndex(contract) {
         targets.push(target(`${outcome.key}.result`, "outcome_result", outcome.product.observable_result, outcome.key));
         for (const requirement of outcome.product.requirements)
             targets.push(target(`${outcome.key}.requirement.${requirement.key}`, "requirement", requirement.statement, outcome.key));
+        for (const binding of outcome.semantic_fact_bindings.facts)
+            targets.push(target(`${outcome.key}.${binding.claim_ref}`, "semantic_fact", undefined, outcome.key));
         for (const control of outcome.product.controls)
             for (const field of controlFieldFacts(control))
                 targets.push(target(`${outcome.key}.control.${control.key}.${field.claim_field}`, "control", field.statement, outcome.key));
@@ -64,5 +66,7 @@ function target(ref, kind, text, outcomeKey, scope) {
 export function sourceKindForTarget(target) {
     return target.kind === "global_constraint"
         ? "technical_obligation"
-        : target.kind;
+        : target.kind === "semantic_fact"
+            ? null
+            : target.kind;
 }

package/dist/lib/long-task-ui-design-policy.js

@@ -19,7 +19,7 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         if (!target.verification_method_bindings.length)
             issue(report, "ui_design_target_verification_methods_required", label);
         const methodArtifactPaths = new Set();
-        const methodFactRefs = new Set();
+        const methodFactObligations = new Set();
         for (const [name, values] of [
             ["source_paths", target.source_paths],
             ["condition_keys", target.condition_keys],
@@ -62,10 +62,14 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
                 issue(report, "ui_design_method_evidence_conditions_mismatch", `${label}:${methodBinding.method}`);
             for (const artifact of methodBinding.evidence_artifacts) {
                 unique(artifact.fact_refs, "ui_design_method_fact_ref_duplicate", `${label}:${methodBinding.method}:${artifact.condition_key}`, report);
+                unique(artifact.fact_expectations.map((item) => item.fact_ref), "ui_design_method_fact_expectation_duplicate", `${label}:${methodBinding.method}:${artifact.condition_key}`, report);
+                if (!sameSet(artifact.fact_expectations.map((item) => item.fact_ref), artifact.fact_refs))
+                    issue(report, "ui_design_method_fact_expectation_refs_mismatch", `${label}:${methodBinding.method}:${artifact.condition_key}`);
                 for (const factRef of artifact.fact_refs) {
-                    if (methodFactRefs.has(factRef))
-                        issue(report, "ui_design_method_fact_ref_reused", `${label}:${factRef}`);
-                    methodFactRefs.add(factRef);
+                    const obligationIdentity = `${methodBinding.method}\0${artifact.condition_key}\0${factRef}`;
+                    if (methodFactObligations.has(obligationIdentity))
+                        issue(report, "ui_design_method_fact_obligation_reused", `${label}:${methodBinding.method}:${artifact.condition_key}:${factRef}`);
+                    methodFactObligations.add(obligationIdentity);
                 }
                 for (const [kind, artifactPath] of [
                     ["record", artifact.path],

package/dist/lib/long-task-ui-surface-shape.js

@@ -1,6 +1,8 @@
 import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
+import { DESIGN_RESOURCE_COMPARATORS } from "./design-resource-fact-manifest-types.js";
+import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
 import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
-import { array, fail, key, literal, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
+import { array, fail, key, literal, nullable, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
 export function parseSurfaceBindings(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
@@ -100,17 +102,85 @@ function parseVerificationMethodBindings(value, label) {
                     "path",
                     "observation_path",
                     "fact_refs",
+                    "fact_expectations",
                 ]);
                 return {
                     condition_key: key(entry.condition_key, `${artifactLabel}.condition_key`),
                     path: repositoryFile(entry.path, `${artifactLabel}.path`),
                     observation_path: repositoryFile(entry.observation_path, `${artifactLabel}.observation_path`),
                     fact_refs: designFactRefs(entry.fact_refs, `${artifactLabel}.fact_refs`),
+                    fact_expectations: parseDesignFactExpectations(entry.fact_expectations, `${artifactLabel}.fact_expectations`),
                 };
             }),
         };
     });
 }
+function parseDesignFactExpectations(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "fact_ref",
+            "subject_ref",
+            "variation_ref",
+            "property_ref",
+            "observation_sensitivity",
+            "expected",
+            "comparison",
+            "oracle",
+            "environment",
+        ]);
+        const comparison = object(row.comparison, `${itemLabel}.comparison`, [
+            "comparator",
+            "mode",
+            "parameters",
+            "tolerance",
+            "mask",
+        ]);
+        const comparator = string(comparison.comparator, `${itemLabel}.comparison.comparator`);
+        if (!DESIGN_RESOURCE_COMPARATORS.includes(comparator) &&
+            !/^custom\.[a-z0-9][a-z0-9._-]*$/u.test(comparator))
+            fail(`${itemLabel}.comparison.comparator`, "must be a standard comparator or custom.*");
+        const oracle = object(row.oracle, `${itemLabel}.oracle`, [
+            "key",
+            "trust",
+            "identity",
+            "version",
+            "sha256",
+        ]);
+        const environment = object(row.environment, `${itemLabel}.environment`, [
+            "key",
+            "identity",
+            "definition",
+        ]);
+        return {
+            fact_ref: designFactRef(row.fact_ref, `${itemLabel}.fact_ref`),
+            subject_ref: designFactRef(row.subject_ref, `${itemLabel}.subject_ref`),
+            variation_ref: designFactRef(row.variation_ref, `${itemLabel}.variation_ref`),
+            property_ref: designFactRef(row.property_ref, `${itemLabel}.property_ref`),
+            observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${itemLabel}.observation_sensitivity`),
+            expected: parseDesignResourceLocatedDigest(row.expected, `${itemLabel}.expected`),
+            comparison: {
+                comparator,
+                mode: literal(comparison.mode, ["exact", "tolerance"], `${itemLabel}.comparison.mode`),
+                parameters: parseDesignResourceLocatedDigest(comparison.parameters, `${itemLabel}.comparison.parameters`),
+                tolerance: nullable(comparison.tolerance, (entry) => parseDesignResourceLocatedDigest(entry, `${itemLabel}.comparison.tolerance`)),
+                mask: nullable(comparison.mask, (entry) => parseDesignResourceLocatedDigest(entry, `${itemLabel}.comparison.mask`)),
+            },
+            oracle: {
+                key: designFactRef(oracle.key, `${itemLabel}.oracle.key`),
+                trust: literal(oracle.trust, ["frozen_executable", "named_external_tcb"], `${itemLabel}.oracle.trust`),
+                identity: string(oracle.identity, `${itemLabel}.oracle.identity`),
+                version: string(oracle.version, `${itemLabel}.oracle.version`),
+                sha256: nullable(oracle.sha256, (entry) => digest(entry, `${itemLabel}.oracle.sha256`)),
+            },
+            environment: {
+                key: designFactRef(environment.key, `${itemLabel}.environment.key`),
+                identity: string(environment.identity, `${itemLabel}.environment.identity`),
+                definition: parseDesignResourceLocatedDigest(environment.definition, `${itemLabel}.environment.definition`),
+            },
+        };
+    });
+}
 function keys(value, label) {
     return array(value, label).map((item, index) => key(item, `${label}[${index}]`));
 }
@@ -123,3 +193,15 @@ function designFactRefs(value, label) {
         return result;
     });
 }
+function designFactRef(value, label) {
+    const result = string(value, label);
+    if (!/^[a-z0-9][a-z0-9._-]*$/u.test(result))
+        fail(label, "must match ^[a-z0-9][a-z0-9._-]*$");
+    return result;
+}
+function digest(value, label) {
+    const result = string(value, label);
+    if (!/^[a-f0-9]{64}$/u.test(result))
+        fail(label, "must be a lowercase SHA-256");
+    return result;
+}

package/dist/lib/long-task-ui-surface-types.d.ts

@@ -1,6 +1,34 @@
 import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+import type { DesignResourceComparator, DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
 import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 export type DesignTargetInterpretationV2 = "exact_target" | "constraint";
+export interface DeliveryDesignFactExpectationV2 {
+    fact_ref: string;
+    subject_ref: string;
+    variation_ref: string;
+    property_ref: string;
+    observation_sensitivity: "plain" | "protected";
+    expected: DesignResourceLocatedDigestV1;
+    comparison: {
+        comparator: DesignResourceComparator | string;
+        mode: "exact" | "tolerance";
+        parameters: DesignResourceLocatedDigestV1;
+        tolerance: DesignResourceLocatedDigestV1 | null;
+        mask: DesignResourceLocatedDigestV1 | null;
+    };
+    oracle: {
+        key: string;
+        trust: "frozen_executable" | "named_external_tcb";
+        identity: string;
+        version: string;
+        sha256: string | null;
+    };
+    environment: {
+        key: string;
+        identity: string;
+        definition: DesignResourceLocatedDigestV1;
+    };
+}
 export interface DeliveryDesignVerificationBindingV2 {
     method: DesignResourceVerificationMethod;
     assertion_ref: string;
@@ -9,6 +37,7 @@ export interface DeliveryDesignVerificationBindingV2 {
         path: string;
         observation_path: string;
         fact_refs: string[];
+        fact_expectations: DeliveryDesignFactExpectationV2[];
     }>;
 }
 export interface DeliveryDesignTargetV2 {

package/dist/lib/modularity.js

@@ -57,7 +57,8 @@ export async function runModularityCheck(projectRoot, options) {
     }
     const files = [];
     for (const relativePath of [...candidates].sort()) {
-        if (!shouldIncludeCodeFile(relativePath)) {
+        if (isWorkflowAuthorityArtifact(relativePath) ||
+            !shouldIncludeCodeFile(relativePath)) {
             continue;
         }
         const absolutePath = path.join(projectRoot, ...relativePath.split("/"));
@@ -103,6 +104,11 @@ export async function runModularityCheck(projectRoot, options) {
         errors: [...configErrors, ...waiverErrors, ...waiverTargetErrors],
     };
 }
+function isWorkflowAuthorityArtifact(relativePath) {
+    const normalized = toPosix(relativePath);
+    return (normalized.startsWith(".work_products/") &&
+        normalized.endsWith("/delivery-contract.yaml"));
+}
 function analyzeFile(content, limit, relativePath) {
     const lines = countPhysicalLines(content);
     const metrics = analyzeModularity(content, relativePath);

package/dist/lib/semantic-fact-base-types.d.ts

@@ -0,0 +1,14 @@
+export type SemanticFactDisposition = "applicable" | "not_applicable" | "decision_required" | "unavailable";
+export type SemanticFactAuthorityKind = "direct" | "logically_derived" | "explicitly_delegated" | "evidence_backed_preservation";
+export type SemanticFactValueKind = "boolean" | "number" | "string" | "enum" | "set" | "ordered_list" | "object" | "schema" | "relation" | "decision_table" | "formula" | "range" | "duration" | "timestamp" | "rate" | "ratio" | "digest" | "trace" | "custom";
+export type SemanticFactLocatorKind = "source_item" | "manifest_pointer" | "json_pointer" | "yaml_pointer" | "whole_resource" | "schema_pointer" | "api_operation" | "code_symbol" | "custom";
+export interface SemanticFactLocatedValueV1 {
+    representation: "inline" | "located" | "digest_only";
+    locator: {
+        material_ref: string;
+        kind: SemanticFactLocatorKind;
+        value: string;
+    };
+    sha256: string;
+    value?: unknown;
+}

package/dist/lib/semantic-fact-base-types.js

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

package/dist/lib/semantic-fact-catalog.d.ts

@@ -0,0 +1,8 @@
+export declare const SEMANTIC_FACT_STANDARD_FAMILIES: readonly ["goal_scope_glossary", "actor_role_tenant_entitlement", "business_rule_calculation", "data_model", "operation_workflow", "state_machine", "temporal_scheduling", "input_validation", "output_error", "api_protocol", "event_message_job", "persistence_cache_search", "transaction_consistency_concurrency_idempotency", "fault_degradation_recovery", "backup_restore_disaster_recovery", "configuration_feature_flag_secret", "compatibility_migration_rollout", "performance_capacity_cost", "reliability_slo", "security", "privacy", "safety_compliance", "observability", "deployment_topology", "external_integration", "notification_file_media", "localization", "commercial_billing", "hardware_sensor", "ai_ml", "architecture_ownership"];
+export declare const SEMANTIC_FACT_STANDARD_CONDITION_AXES: readonly ["actor", "role", "tenant", "organization", "jurisdiction", "residency", "environment", "region", "zone", "platform", "device", "client_version", "api_version", "schema_version", "runtime_version", "feature", "cohort", "configuration", "entitlement", "permission", "consent", "session", "entity_state", "prior_state", "input_class", "boundary_case", "data_volume", "locale", "timezone", "clock", "concurrency", "repetition", "dependency_health", "connectivity", "failure_class", "retry_phase", "consistency", "freshness", "migration_phase", "rollout_phase", "topology", "threat", "operational_mode"];
+export declare const SEMANTIC_FACT_REQUIRED_INSPECTOR_CAPABILITIES: readonly ["source_inventory", "context_inventory", "input_classification", "standard_catalog", "custom_domain_discovery", "subject_inventory", "relation_inventory", "population_inventory", "condition_axis_inventory", "condition_combination_inventory", "property_inventory", "fact_cell_inventory", "proof_obligation_inventory"];
+export declare const SEMANTIC_FACT_PROOF_METHODS: readonly ["exact_value", "schema_contract", "decision_table", "formula_evaluation", "invariant", "transition_trace", "sequence_trace", "durable_roundtrip", "boundary_invocation", "external_side_effect", "population_set_equality", "concurrency_schedule", "idempotency_repetition", "fault_injection", "recovery_drill", "migration", "compatibility", "performance", "capacity", "security", "privacy", "audit", "observability", "deployment", "implementation_structure"];
+export declare const SEMANTIC_FACT_COMPARATORS: readonly ["exact_value", "semantic_equal", "set_equal", "ordered_equal", "schema_compatible", "decision_table_complete", "numeric_tolerance", "range_contains", "trace_equal", "invariant_holds", "population_set_equal", "latency_budget", "capacity_budget", "security_policy", "privacy_policy", "custom"];
+export declare const SEMANTIC_FACT_STANDARD_PROPERTIES: Readonly<Record<(typeof SEMANTIC_FACT_STANDARD_FAMILIES)[number], readonly string[]>>;
+export declare function isCustomSemanticFactName(value: string): boolean;
+export declare function isAtomicSemanticFactAtom(value: string): boolean;

package/dist/lib/semantic-fact-catalog.js

@@ -0,0 +1,191 @@
+export const SEMANTIC_FACT_STANDARD_FAMILIES = [
+    "goal_scope_glossary",
+    "actor_role_tenant_entitlement",
+    "business_rule_calculation",
+    "data_model",
+    "operation_workflow",
+    "state_machine",
+    "temporal_scheduling",
+    "input_validation",
+    "output_error",
+    "api_protocol",
+    "event_message_job",
+    "persistence_cache_search",
+    "transaction_consistency_concurrency_idempotency",
+    "fault_degradation_recovery",
+    "backup_restore_disaster_recovery",
+    "configuration_feature_flag_secret",
+    "compatibility_migration_rollout",
+    "performance_capacity_cost",
+    "reliability_slo",
+    "security",
+    "privacy",
+    "safety_compliance",
+    "observability",
+    "deployment_topology",
+    "external_integration",
+    "notification_file_media",
+    "localization",
+    "commercial_billing",
+    "hardware_sensor",
+    "ai_ml",
+    "architecture_ownership",
+];
+export const SEMANTIC_FACT_STANDARD_CONDITION_AXES = [
+    "actor",
+    "role",
+    "tenant",
+    "organization",
+    "jurisdiction",
+    "residency",
+    "environment",
+    "region",
+    "zone",
+    "platform",
+    "device",
+    "client_version",
+    "api_version",
+    "schema_version",
+    "runtime_version",
+    "feature",
+    "cohort",
+    "configuration",
+    "entitlement",
+    "permission",
+    "consent",
+    "session",
+    "entity_state",
+    "prior_state",
+    "input_class",
+    "boundary_case",
+    "data_volume",
+    "locale",
+    "timezone",
+    "clock",
+    "concurrency",
+    "repetition",
+    "dependency_health",
+    "connectivity",
+    "failure_class",
+    "retry_phase",
+    "consistency",
+    "freshness",
+    "migration_phase",
+    "rollout_phase",
+    "topology",
+    "threat",
+    "operational_mode",
+];
+export const SEMANTIC_FACT_REQUIRED_INSPECTOR_CAPABILITIES = [
+    "source_inventory",
+    "context_inventory",
+    "input_classification",
+    "standard_catalog",
+    "custom_domain_discovery",
+    "subject_inventory",
+    "relation_inventory",
+    "population_inventory",
+    "condition_axis_inventory",
+    "condition_combination_inventory",
+    "property_inventory",
+    "fact_cell_inventory",
+    "proof_obligation_inventory",
+];
+export const SEMANTIC_FACT_PROOF_METHODS = [
+    "exact_value",
+    "schema_contract",
+    "decision_table",
+    "formula_evaluation",
+    "invariant",
+    "transition_trace",
+    "sequence_trace",
+    "durable_roundtrip",
+    "boundary_invocation",
+    "external_side_effect",
+    "population_set_equality",
+    "concurrency_schedule",
+    "idempotency_repetition",
+    "fault_injection",
+    "recovery_drill",
+    "migration",
+    "compatibility",
+    "performance",
+    "capacity",
+    "security",
+    "privacy",
+    "audit",
+    "observability",
+    "deployment",
+    "implementation_structure",
+];
+export const SEMANTIC_FACT_COMPARATORS = [
+    "exact_value",
+    "semantic_equal",
+    "set_equal",
+    "ordered_equal",
+    "schema_compatible",
+    "decision_table_complete",
+    "numeric_tolerance",
+    "range_contains",
+    "trace_equal",
+    "invariant_holds",
+    "population_set_equal",
+    "latency_budget",
+    "capacity_budget",
+    "security_policy",
+    "privacy_policy",
+    "custom",
+];
+export const SEMANTIC_FACT_STANDARD_PROPERTIES = {
+    goal_scope_glossary: "goal observable_outcome scope non_goal term_definition unit_definition invariant assumption priority acceptance_meaning normative_status decision_owner conflict_resolution".split(" "),
+    actor_role_tenant_entitlement: "identity eligibility visibility allowed_operation forbidden_operation delegation impersonation isolation_boundary ownership approval_owner escalation lifecycle".split(" "),
+    business_rule_calculation: "predicate input precedence decision_branch overlap_handling gap_handling output formula formula_version unit precision rounding threshold boundary_inclusivity cap floor exception effective_period audit_rationale".split(" "),
+    data_model: "identity type schema nullability requiredness default absence_semantics enum_domain uniqueness cardinality ownership provenance lineage mutability lifecycle unit precision scale rounding format encoding normalization ordering comparison invariant validation_boundary sensitivity retention serialization".split(" "),
+    operation_workflow: "trigger initiator target precondition input guard ordered_step state_transition synchronous_effect asynchronous_effect output postcondition partial_success cancellation replacement compensation feedback audit_event forbidden_effect".split(" "),
+    state_machine: "state initial_state terminal_state transition trigger guard action emitted_effect illegal_transition compound_state concurrent_state precedence reentry interruption cancellation timeout stale_handling conflict_handling recovery restoration archive_delete".split(" "),
+    temporal_scheduling: "clock_source monotonicity timezone calendar dst_gap dst_fold clock_skew timestamp effective_boundary expiry_boundary interval_inclusivity schedule recurrence grace_period debounce throttle ordering lateness timeout lease retry_timing test_clock".split(" "),
+    input_validation: "source type requiredness default absence_semantics accepted_range grammar unit encoding normalization canonicalization cross_field_rule validation_order validation_location duplicate_handling replay_handling size_limit rate_limit malformed_case adversarial_case error_identity feedback lossless_recovery".split(" "),
+    output_error: "schema ordering format provenance freshness pagination streaming success_variant empty_variant partial_variant stale_variant degraded_variant error_variant error_code retryability feedback correlation_identity redaction reconciliation recovery".split(" "),
+    api_protocol: "operation_identity transport authentication authorization parameter header request_body serialization content_negotiation response_variant error_variant status_code pagination filtering sorting idempotency rate_limit quota timeout retry callback_webhook version_negotiation deprecation compatibility".split(" "),
+    event_message_job: "producer consumer schema version partition_routing_key correlation causation ordering delivery_guarantee acknowledgement deduplication idempotency retry_backoff timeout dead_letter replay retention backpressure poison_message cancellation schedule observable_completion".split(" "),
+    persistence_cache_search: "canonical_owner schema key index query ordering transaction_boundary persistence eviction freshness invalidation replication archive retention deletion tombstone import_export backup_participation tokenization ranking filter pagination rebuild reconciliation".split(" "),
+    transaction_consistency_concurrency_idempotency: "atomicity isolation consistency_model durability read_visibility write_visibility lock_lease optimistic_conflict pessimistic_conflict race_interleaving ordering causality duplicate_handling replay_handling idempotency_scope idempotency_key_lifetime retry_safety lost_update_prevention partial_commit compensation convergence".split(" "),
+    fault_degradation_recovery: "fault_class detection timeout_budget retry_eligibility retry_schedule jitter retry_exhaustion circuit_breaker bulkhead fallback degraded_result cancellation cleanup compensation feedback recovery_trigger restoration_point reconciliation data_loss_prevention duplicate_effect_prevention".split(" "),
+    backup_restore_disaster_recovery: "backup_scope frequency consistency_point encryption retention restore_procedure restore_verification rpo rto regional_disaster dependency_disaster failover failback replay reconciliation ownership drill_evidence".split(" "),
+    configuration_feature_flag_secret: "schema type requiredness safe_default scope environment_precedence tenant_precedence override_rule conflict_rule validation reload_restart rollout cohort_assignment kill_switch expiry cleanup audit protected_representation rotation failure_behavior".split(" "),
+    compatibility_migration_rollout: "supported_version backward_compatibility forward_compatibility mixed_version migration backfill validation dual_read dual_write cutover canary phased_rollout downgrade rollback irreversible_boundary cleanup deprecation data_reconciliation failure_recovery".split(" "),
+    performance_capacity_cost: "journey workload_model dataset_cardinality payload concurrency warm_cold_state latency_percentile deadline throughput queue_limit backpressure_limit resource_budget saturation scaling cost_boundary quota_boundary benchmark_environment measurement_window statistical_method tolerance".split(" "),
+    reliability_slo: "service_indicator measurement_point population exclusion target window availability correctness durability freshness continuity error_budget dependency_assumption degraded_expectation alert_relationship recovery_response".split(" "),
+    security: "asset threat trust_boundary authentication identity_proofing authorization least_privilege tenant_isolation session_lifecycle token_lifecycle mfa account_recovery secret_rotation key_rotation transport_encryption at_rest_encryption integrity input_defense output_defense audit rate_limit abuse_case supply_chain_integrity vulnerability_handling incident_response".split(" "),
+    privacy: "classification purpose lawful_authority consent preference minimization collection sharing lineage processor residency retention access_right correction_right portability_right deletion_right derived_data_effect redaction pseudonymization logging_restriction incident_handling policy_version".split(" "),
+    safety_compliance: "hazard prohibited_outcome jurisdiction policy_version risk_control safe_state human_approval four_eyes irreversibility confirmation cancellation emergency_stop audit accountability expert_authority incident_escalation residual_risk".split(" "),
+    observability: "log metric trace audit_event dimension unit correlation causation sampling aggregation redaction retention ownership health readiness liveness alert_condition alert_threshold alert_window alert_deduplication alert_routing alert_escalation dashboard runbook_diagnosis runbook_mitigation runbook_recovery".split(" "),
+    deployment_topology: "environment region zone topology replica dependency_direction configuration_injection secret_injection artifact_identity artifact_provenance startup readiness liveness shutdown migration_order rollout rollback drain maintenance autoscaling health_probe operational_owner post_deploy_verification".split(" "),
+    external_integration: "provider_protocol_identity capability version authentication region data_boundary quota rate_limit license commercial_constraint request_contract callback_contract timeout retry idempotency outage degradation side_effect_observation reconciliation sandbox_production_difference external_confirmation".split(" "),
+    notification_file_media: "audience channel template localization trigger priority quiet_hours cadence deduplication delivery_receipt retry unsubscribe file_type mime size dimensions duration codec metadata scan_quarantine upload_resume transformation storage signed_access fallback deletion accessibility_alternative".split(" "),
+    localization: "locale fallback language script unicode_normalization encoding collation case_sensitivity accent_sensitivity segmentation plural_rule grammar_rule timezone calendar date_format number_format currency exchange_rate_source measurement_unit conversion decimal_precision rounding locale_invariant_identifier".split(" "),
+    commercial_billing: "product_plan entitlement price effective_version meter_source aggregation currency tax jurisdiction precision rounding proration discount quota invoice payment_state retry refund dispute idempotency reconciliation audit processor_confirmation".split(" "),
+    hardware_sensor: "model firmware capability_discovery permission unit range resolution calibration sampling orientation coordinate_frame latency buffering connectivity power thermal storage_limit disconnect degradation actuator_safety simulation_limit physical_confirmation".split(" "),
+    ai_ml: "model version prompt_contract tool_contract input_schema output_schema context_source grounding_source stochastic_control confidence abstention safety_boundary policy_boundary bias_criterion quality_criterion explainability human_review intervention evaluation_population tolerance reproducibility drift_monitoring fallback privacy latency quota cost".split(" "),
+    architecture_ownership: "owner source_of_truth extension_point dependency_direction interface input_boundary output_boundary state_boundary persistence_boundary lifecycle_boundary failure_boundary recovery compatibility migration selected_design rejected_alternative future_change_challenge technical_debt forbidden_bypass conformance_check".split(" "),
+};
+export function isCustomSemanticFactName(value) {
+    return /^custom\.[a-z0-9][a-z0-9._-]*$/u.test(value);
+}
+export function isAtomicSemanticFactAtom(value) {
+    const normalized = value.trim().toLowerCase();
+    const aggregateLabel = /^(?:all|any|every|multiple|various)[._:-].*(?:catalog|states?|modes?|variants?|cases?|values?|conditions?)$/u.test(normalized) || /^(?:all|any|every|multiple|various)[._:-]\d+[._:-]/u.test(normalized);
+    return (/^[a-z0-9][a-z0-9._:-]*$/u.test(value) &&
+        !aggregateLabel &&
+        ![
+            "all",
+            "any",
+            "every",
+            "default",
+            "various",
+            "multiple",
+            "all-states",
+            "all_states",
+            "*",
+        ].includes(normalized));
+}

package/dist/lib/semantic-fact-condition-shape.d.ts

@@ -0,0 +1,48 @@
+export declare function parseSemanticFactAxisDispositions(value: unknown, label: string): {
+    key: string;
+    axis: string;
+    standard: boolean;
+    disposition: "applicable" | "decision_required" | "not_applicable" | "unavailable";
+    outcome_refs: string[];
+    values: {
+        key: string;
+        source_item_refs: string[];
+        basis_refs: string[];
+    }[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];
+export declare function parseSemanticFactConditionRules(value: unknown, label: string): {
+    key: string;
+    outcome_ref: string;
+    axis_refs: string[];
+    mode: "cross_product" | "explicit_meaningful" | "independent";
+    condition_refs: string[];
+    exclusion_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];
+export declare function parseSemanticFactConditions(value: unknown, label: string): {
+    key: string;
+    outcome_ref: string;
+    axis_values: {
+        axis_ref: string;
+        value_ref: string;
+    }[];
+    source_item_refs: string[];
+    basis_refs: string[];
+}[];
+export declare function parseSemanticFactConditionExclusions(value: unknown, label: string): {
+    key: string;
+    outcome_ref: string;
+    axis_values: {
+        axis_ref: string;
+        value_ref: string;
+    }[];
+    disposition: "decision_required" | "not_applicable" | "unavailable";
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];