project-tiny-context-harness 0.8.3 → 0.8.5

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/migrations.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { promises as fs } from "node:fs";
 import { CONTEXT_MANIFEST_PATH, contextManifestFromExistingAreas, } from "./context-manifest.js";
@@ -13,6 +14,8 @@ import { semanticDriftMigrationFields } from "./long-task-semantic-drift-migrati
 async function verifyNoop() {
     return;
 }
+const REMOVED_NORMAL_LONG_TASK_SKILL = "normal-long-task";
+const REMOVED_NORMAL_LONG_TASK_SKILL_SHA256 = "7a4f755da9a32e07f258d6c7fc5e5c70395257c72efb8a9ad4995cddcc4c73ba";
 export const migrations = [
     legacySdlcHarnessMigration,
     {
@@ -25,6 +28,17 @@ export const migrations = [
         detect: detectLongTaskSemanticDriftAuthority,
         verify: verifyNoop,
     },
+    {
+        id: "remove-normal-long-task-skill",
+        introducedIn: "0.8.4",
+        description: "Remove the obsolete normal-long-task compatibility Skill; long-task-workflow is the sole explicit Long-Task execution Skill.",
+        scope: "<harnessRoot>/skills/normal-long-task",
+        risk: "safe",
+        manualMessage: "The same-name directory differs from the former package-owned compatibility Skill. Preserve any user-authored content elsewhere, then remove the directory manually.",
+        detect: detectRemovedNormalLongTaskSkill,
+        apply: migrateRemovedNormalLongTaskSkill,
+        verify: verifyRemovedNormalLongTaskSkill,
+    },
     {
         id: "long-task-v1-retirement",
         introducedIn: "0.6.0",
@@ -131,6 +145,56 @@ async function detectLongTaskSemanticDriftAuthority(projectRoot, _root, migratio
         item(migration, "manual_required", ".long-task/delivery-contract.yaml", `The active/draft V2 Contract predates semantic-drift authority and is missing: ${fields.slice(0, 12).join(", ")}${fields.length > 12 ? `, +${fields.length - 12} more` : ""}. Re-author these meanings from Source; do not synthesize them from old passing evidence.`),
     ];
 }
+async function detectRemovedNormalLongTaskSkill(projectRoot, root, migration) {
+    const skill = removedNormalLongTaskSkillPath(projectRoot, root);
+    const state = await removedNormalLongTaskSkillState(skill);
+    if (state === "absent")
+        return [];
+    const relative = path.relative(projectRoot, skill).split(path.sep).join("/");
+    return [
+        item(migration, state === "package-owned" ? "safe_pending" : "manual_required", relative, state === "package-owned"
+            ? "Remove the exact obsolete package-owned compatibility Skill."
+            : "The obsolete Skill directory contains modified or additional content; preserve any user-authored material elsewhere and remove it manually."),
+    ];
+}
+async function migrateRemovedNormalLongTaskSkill(projectRoot, root, report) {
+    const skill = removedNormalLongTaskSkillPath(projectRoot, root);
+    const state = await removedNormalLongTaskSkillState(skill);
+    const relative = path.relative(projectRoot, skill).split(path.sep).join("/");
+    if (state === "absent") {
+        report.skipped.push("remove-normal-long-task-skill");
+        return;
+    }
+    if (state !== "package-owned") {
+        throw new Error(`${relative} changed after upgrade planning; rerun upgrade and resolve the manual_required item`);
+    }
+    await fs.rm(skill, { recursive: true, force: true });
+    report.changed.push(relative);
+}
+async function verifyRemovedNormalLongTaskSkill(projectRoot, root) {
+    if (await pathExists(removedNormalLongTaskSkillPath(projectRoot, root))) {
+        throw new Error("remove-normal-long-task-skill migration verification failed");
+    }
+}
+function removedNormalLongTaskSkillPath(projectRoot, root) {
+    return path.join(projectRoot, root, "skills", REMOVED_NORMAL_LONG_TASK_SKILL);
+}
+async function removedNormalLongTaskSkillState(skill) {
+    if (!(await pathExists(skill)))
+        return "absent";
+    const files = await listFiles(skill);
+    if (files.length === 0)
+        return "package-owned";
+    if (files.length !== 1 ||
+        path.relative(skill, files[0]).split(path.sep).join("/") !== "SKILL.md") {
+        return "modified";
+    }
+    const normalized = (await readText(files[0])).replace(/\r\n/g, "\n");
+    const digest = createHash("sha256").update(normalized).digest("hex");
+    return digest === REMOVED_NORMAL_LONG_TASK_SKILL_SHA256
+        ? "package-owned"
+        : "modified";
+}
 async function detectLongTaskV1Retirement(projectRoot, root, migration) {
     const items = [];
     const hook = path.join(projectRoot, root, "hooks", "long-task-hook.mjs");

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/profiles.js

@@ -58,8 +58,6 @@ export function enabledManagedSkillNames(config) {
         "design-system-authoring",
         "design-resource-authoring",
     ]);
-    if (isProfileEnabled(config, "workflow-default"))
-        names.add("normal-long-task");
     if (isProfileEnabled(config, "long-task")) {
         names.add("long-task-workflow");
         names.add("source-plan-authoring");

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;