onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/reconstruct/actionable-seed-validation.js

@@ -0,0 +1,1777 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { loadReconstructContractRegistry, } from "./contract-registry.js";
+function isoNow() {
+    return new Date().toISOString();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRecord(value, fieldPath, addViolation) {
+    if (!isRecord(value)) {
+        addViolation("schema_shape_invalid", `${fieldPath} must be an object`);
+        return null;
+    }
+    return value;
+}
+function readArray(value, fieldPath, addViolation) {
+    if (!Array.isArray(value)) {
+        addViolation("schema_shape_invalid", `${fieldPath} must be an array`);
+        return [];
+    }
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : null;
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
+const ACTIONABLE_ONTOLOGY_SEED_ID_KEYS = new Set([
+    "seed_id",
+    "concept_id",
+    "association_id",
+    "object_type_id",
+    "property_id",
+    "link_type_id",
+    "value_type_id",
+    "constraint_id",
+    "actor_type_id",
+    "role_id",
+    "action_type_id",
+    "parameter_id",
+    "precondition_id",
+    "postcondition_id",
+    "side_effect_id",
+    "function_id",
+    "workflow_id",
+    "policy_id",
+    "permission_policy_id",
+    "state_model_id",
+    "transition_id",
+    "rule_id",
+    "binding_id",
+    "read_model_id",
+    "writeback_id",
+    "provenance_id",
+    "limitation_id",
+    "candidate_id",
+]);
+export function collectActionableOntologySeedRefs(seed) {
+    const refs = new Set();
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (!isRecord(value))
+            return;
+        for (const [key, child] of Object.entries(value)) {
+            if (ACTIONABLE_ONTOLOGY_SEED_ID_KEYS.has(key) &&
+                typeof child === "string" &&
+                child.trim().length > 0) {
+                refs.add(child.trim());
+            }
+            visit(child);
+        }
+    };
+    visit(seed);
+    return refs;
+}
+function normalizeSourceRef(ref) {
+    return path.resolve(ref);
+}
+function evidenceObservationById(sourceObservations) {
+    return new Map(sourceObservations.observations.map((observation) => [
+        observation.observation_id,
+        observation,
+    ]));
+}
+function readEvidenceRefs(args) {
+    if (!Array.isArray(args.value)) {
+        args.addViolation({
+            code: args.required ? "evidence_ref_missing" : "evidence_ref_shape_invalid",
+            message: `${args.fieldPath} must be an evidence_refs array`,
+            subjectId: args.subjectId,
+        });
+        return [];
+    }
+    if (args.required && args.value.length === 0) {
+        args.addViolation({
+            code: "evidence_ref_missing",
+            message: `${args.fieldPath} must include at least one evidence ref`,
+            subjectId: args.subjectId,
+        });
+        return [];
+    }
+    const byObservationId = evidenceObservationById(args.sourceObservations);
+    const evidenceRefs = [];
+    for (const [index, item] of args.value.entries()) {
+        const itemPath = `${args.fieldPath}[${index}]`;
+        if (!isRecord(item)) {
+            args.addViolation({
+                code: "evidence_ref_shape_invalid",
+                message: `${itemPath} must be an object`,
+                subjectId: args.subjectId,
+            });
+            continue;
+        }
+        const observationId = optionalString(item.observation_id);
+        const targetMaterialKind = optionalString(item.target_material_kind);
+        const sourceRef = optionalString(item.source_ref);
+        const location = optionalString(item.location);
+        if (!observationId || !targetMaterialKind || !sourceRef || !location) {
+            args.addViolation({
+                code: "evidence_ref_shape_invalid",
+                message: `${itemPath} must include observation_id, target_material_kind, source_ref, and location`,
+                subjectId: args.subjectId,
+                observationId,
+            });
+            continue;
+        }
+        const observation = byObservationId.get(observationId);
+        if (!observation) {
+            args.addViolation({
+                code: "unknown_observation_ref",
+                message: `${itemPath} references unknown observation_id ${observationId}`,
+                subjectId: args.subjectId,
+                observationId,
+            });
+            continue;
+        }
+        if (targetMaterialKind !== observation.target_material_kind) {
+            args.addViolation({
+                code: "material_kind_mismatch",
+                message: `${itemPath}.target_material_kind does not match source observation`,
+                subjectId: args.subjectId,
+                observationId,
+            });
+        }
+        if (normalizeSourceRef(sourceRef) !== normalizeSourceRef(observation.source_ref)) {
+            args.addViolation({
+                code: "source_ref_mismatch",
+                message: `${itemPath}.source_ref does not match source observation`,
+                subjectId: args.subjectId,
+                observationId,
+            });
+        }
+        if (location !== observation.location) {
+            args.addViolation({
+                code: "location_mismatch",
+                message: `${itemPath}.location does not match source observation`,
+                subjectId: args.subjectId,
+                observationId,
+            });
+        }
+        evidenceRefs.push({
+            observation_id: observationId,
+            target_material_kind: observation.target_material_kind,
+            source_ref: sourceRef,
+            location,
+        });
+    }
+    return evidenceRefs;
+}
+function registryCandidateKindIds(registry) {
+    return new Set(registry.candidate_kind_registry.map((record) => record.candidate_kind_id));
+}
+function registryCandidateDispositionIds(registry) {
+    return new Set(registry.candidate_disposition_registry.map((record) => record.disposition_id));
+}
+function candidateValidationViolation(args) {
+    return {
+        code: args.code,
+        message: args.message,
+        candidate_id: args.candidateId ?? null,
+        observation_id: args.observationId ?? null,
+    };
+}
+export function validateCandidateDisposition(args) {
+    const violations = [];
+    const addShapeViolation = (_code, message) => {
+        violations.push(candidateValidationViolation({
+            code: "schema_shape_invalid",
+            message,
+        }));
+    };
+    const addEvidenceViolation = (violation) => {
+        violations.push(candidateValidationViolation({
+            code: violation.code,
+            message: violation.message,
+            candidateId: violation.subjectId ?? null,
+            observationId: violation.observationId ?? null,
+        }));
+    };
+    const inventory = readRecord(args.candidateInventory, "candidate_inventory", addShapeViolation);
+    const disposition = readRecord(args.candidateDisposition, "candidate_disposition", addShapeViolation);
+    const sessionId = optionalString(inventory?.session_id) ??
+        optionalString(disposition?.session_id) ??
+        args.sourceObservations.session_id;
+    if (optionalString(inventory?.session_id) &&
+        optionalString(disposition?.session_id) &&
+        optionalString(inventory?.session_id) !== optionalString(disposition?.session_id)) {
+        violations.push(candidateValidationViolation({
+            code: "session_id_mismatch",
+            message: "candidate inventory and disposition session_id values must match",
+        }));
+    }
+    const allowedKinds = registryCandidateKindIds(args.registry);
+    const allowedDispositions = registryCandidateDispositionIds(args.registry);
+    const candidateIds = new Set();
+    const candidateEvidenceObservationIds = new Set();
+    const candidateRows = readArray(inventory?.candidates, "candidate_inventory.candidates", addShapeViolation);
+    for (const [index, candidateValue] of candidateRows.entries()) {
+        if (!isRecord(candidateValue)) {
+            violations.push(candidateValidationViolation({
+                code: "schema_shape_invalid",
+                message: `candidate_inventory.candidates[${index}] must be an object`,
+            }));
+            continue;
+        }
+        const candidateId = optionalString(candidateValue.candidate_id);
+        if (!candidateId) {
+            violations.push(candidateValidationViolation({
+                code: "schema_shape_invalid",
+                message: `candidate_inventory.candidates[${index}].candidate_id is required`,
+            }));
+        }
+        else if (candidateIds.has(candidateId)) {
+            violations.push(candidateValidationViolation({
+                code: "duplicate_candidate_id",
+                message: `duplicate candidate_id ${candidateId}`,
+                candidateId,
+            }));
+        }
+        else {
+            candidateIds.add(candidateId);
+        }
+        const kind = optionalString(candidateValue.candidate_kind);
+        if (!kind || !allowedKinds.has(kind)) {
+            violations.push(candidateValidationViolation({
+                code: "invalid_candidate_kind",
+                message: `candidate ${candidateId ?? index} uses an unknown candidate_kind`,
+                candidateId,
+            }));
+        }
+        const candidateEvidenceRefs = readEvidenceRefs({
+            value: candidateValue.evidence_refs,
+            fieldPath: `candidate_inventory.candidates[${index}].evidence_refs`,
+            subjectId: candidateId,
+            required: true,
+            sourceObservations: args.sourceObservations,
+            addViolation: addEvidenceViolation,
+        });
+        for (const evidenceRef of candidateEvidenceRefs) {
+            candidateEvidenceObservationIds.add(evidenceRef.observation_id);
+        }
+    }
+    for (const observation of args.sourceObservations.observations) {
+        if (!candidateEvidenceObservationIds.has(observation.observation_id)) {
+            violations.push(candidateValidationViolation({
+                code: "source_observation_coverage_missing",
+                message: `source observation has no candidate inventory coverage: ${observation.observation_id}`,
+                observationId: observation.observation_id,
+            }));
+        }
+    }
+    const dispositionIds = new Set();
+    let promotedCandidateCount = 0;
+    const dispositionRows = readArray(disposition?.dispositions, "candidate_disposition.dispositions", addShapeViolation);
+    for (const [index, dispositionValue] of dispositionRows.entries()) {
+        if (!isRecord(dispositionValue)) {
+            violations.push(candidateValidationViolation({
+                code: "schema_shape_invalid",
+                message: `candidate_disposition.dispositions[${index}] must be an object`,
+            }));
+            continue;
+        }
+        const candidateId = optionalString(dispositionValue.candidate_id);
+        if (!candidateId) {
+            violations.push(candidateValidationViolation({
+                code: "schema_shape_invalid",
+                message: `candidate_disposition.dispositions[${index}].candidate_id is required`,
+            }));
+        }
+        else if (dispositionIds.has(candidateId)) {
+            violations.push(candidateValidationViolation({
+                code: "duplicate_disposition",
+                message: `duplicate disposition for candidate_id ${candidateId}`,
+                candidateId,
+            }));
+        }
+        else {
+            dispositionIds.add(candidateId);
+        }
+        if (candidateId && !candidateIds.has(candidateId)) {
+            violations.push(candidateValidationViolation({
+                code: "unknown_candidate_id",
+                message: `disposition references unknown candidate_id ${candidateId}`,
+                candidateId,
+            }));
+        }
+        const dispositionId = optionalString(dispositionValue.disposition_id);
+        if (!dispositionId || !allowedDispositions.has(dispositionId)) {
+            violations.push(candidateValidationViolation({
+                code: "invalid_disposition",
+                message: `candidate ${candidateId ?? index} uses an unknown disposition_id`,
+                candidateId,
+            }));
+        }
+        const targetSeedRefs = stringArray(dispositionValue.target_seed_refs);
+        const targetRefRequired = dispositionId === "promoted_to_seed_layer" ||
+            dispositionId?.startsWith("represented_as_") === true;
+        if (dispositionId === "promoted_to_seed_layer") {
+            promotedCandidateCount += 1;
+        }
+        if (targetRefRequired && targetSeedRefs.length === 0) {
+            violations.push(candidateValidationViolation({
+                code: dispositionId === "promoted_to_seed_layer"
+                    ? "promoted_target_missing"
+                    : "target_ref_missing",
+                message: `candidate ${candidateId ?? index} uses ${dispositionId} but has no target_seed_refs`,
+                candidateId,
+            }));
+        }
+        if (!optionalString(dispositionValue.rationale)) {
+            violations.push(candidateValidationViolation({
+                code: "rationale_missing",
+                message: `candidate ${candidateId ?? index} disposition rationale is required`,
+                candidateId,
+            }));
+        }
+        readEvidenceRefs({
+            value: dispositionValue.evidence_refs,
+            fieldPath: `candidate_disposition.dispositions[${index}].evidence_refs`,
+            subjectId: candidateId,
+            required: true,
+            sourceObservations: args.sourceObservations,
+            addViolation: addEvidenceViolation,
+        });
+    }
+    for (const candidateId of candidateIds) {
+        if (!dispositionIds.has(candidateId)) {
+            violations.push(candidateValidationViolation({
+                code: "missing_candidate_disposition",
+                message: `candidate ${candidateId} has no disposition row`,
+                candidateId,
+            }));
+        }
+    }
+    return {
+        schema_version: "1",
+        session_id: sessionId,
+        created_at: isoNow(),
+        candidate_inventory_ref: args.candidateInventoryRef ?? null,
+        candidate_disposition_ref: args.candidateDispositionRef ?? null,
+        source_observations_ref: args.sourceObservationsRef ?? null,
+        registry_ref: args.registryRef ?? null,
+        validation_status: violations.length === 0 ? "valid" : "invalid",
+        candidate_count: candidateIds.size,
+        disposition_count: dispositionIds.size,
+        promoted_candidate_count: promotedCandidateCount,
+        validation_results: violations.length === 0
+            ? ["candidate_disposition_valid"]
+            : ["candidate_disposition_invalid"],
+        violations,
+    };
+}
+function seedValidationViolation(args) {
+    return {
+        code: args.code,
+        message: args.message,
+        subject_id: args.subjectId ?? null,
+        observation_id: args.observationId ?? null,
+    };
+}
+const SEED_DECLARED_STATUS_VALUES = ["confirmed", "provisional", "deferred"];
+const INSTANCE_AVAILABILITY_STATUS_VALUES = [
+    "present",
+    "absent",
+    "unknown",
+    "not_applicable",
+];
+const READY_HANDOFF_MAPPING_KEYS = [
+    "classification_mapping",
+    "entity_identity_mapping",
+    "instance_assertion_mapping",
+    "terminology_mapping",
+    "relation_type_mapping",
+    "constraint_mapping",
+    "modularity_boundary",
+    "reasoning_or_formalism_profile",
+    "application_context_mapping",
+    "metadata_mapping",
+    "provenance_mapping",
+    "change_tracking_mapping",
+    "competency_scope_mapping",
+    "alignment_mapping",
+    "modeling_concern_applicability",
+    "reference_standard_mapping",
+    "pattern_catalog_mapping",
+    "graph_connectivity",
+];
+const NON_SUBSTANTIVE_HANDOFF_KEYS = new Set([
+    "limitation_refs",
+    "evidence_refs",
+    "rationale",
+]);
+const NON_SUBSTANTIVE_HANDOFF_STRING_VALUES = new Set([
+    "",
+    "unknown",
+    "none",
+    "not_applicable",
+]);
+function hasNestedLimitationRefs(value) {
+    if (Array.isArray(value))
+        return value.some((item) => hasNestedLimitationRefs(item));
+    if (!isRecord(value))
+        return false;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "limitation_refs" && stringArray(child).length > 0)
+            return true;
+        if (hasNestedLimitationRefs(child))
+            return true;
+    }
+    return false;
+}
+function hasSubstantiveHandoffContent(value) {
+    if (typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value === "string") {
+        return !NON_SUBSTANTIVE_HANDOFF_STRING_VALUES.has(value.trim());
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => hasSubstantiveHandoffContent(item));
+    }
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, child]) => !NON_SUBSTANTIVE_HANDOFF_KEYS.has(key) && hasSubstantiveHandoffContent(child));
+}
+function validateReadyHandoffMappings(args) {
+    for (const key of READY_HANDOFF_MAPPING_KEYS) {
+        const mapping = args.ontologyHandoff?.[key];
+        if (!isRecord(mapping)) {
+            args.violations.push(seedValidationViolation({
+                code: "missing_required_field",
+                message: `ontology_handoff.${key} must be an object when readiness_claim is ready`,
+                subjectId: key,
+            }));
+            continue;
+        }
+        if (!hasSubstantiveHandoffContent(mapping) &&
+            !hasNestedLimitationRefs(mapping)) {
+            args.violations.push(seedValidationViolation({
+                code: "missing_required_field",
+                message: `ontology_handoff.${key} must include substantive mapping content or limitation_refs when readiness_claim is ready`,
+                subjectId: key,
+            }));
+        }
+    }
+}
+function validateOptionalEnum(args) {
+    const value = optionalString(args.value);
+    if (!value) {
+        args.violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: `${args.fieldPath} must be a non-empty string`,
+            subjectId: args.subjectId ?? null,
+        }));
+        return null;
+    }
+    if (!args.allowed.includes(value)) {
+        args.violations.push(seedValidationViolation({
+            code: "invalid_enum",
+            message: `${args.fieldPath} has invalid value ${value}`,
+            subjectId: args.subjectId ?? value,
+        }));
+    }
+    return value;
+}
+function validateEnumArray(args) {
+    const values = readArray(args.value, args.fieldPath, (code, message) => args.violations.push(seedValidationViolation({ code, message }))).filter((item) => typeof item === "string" && item.trim().length > 0);
+    for (const value of values) {
+        if (!args.allowed.includes(value)) {
+            args.violations.push(seedValidationViolation({
+                code: "invalid_enum",
+                message: `${args.fieldPath} contains invalid value ${value}`,
+                subjectId: args.subjectId ?? value,
+            }));
+        }
+    }
+    return values;
+}
+function recordsFromSeed(args) {
+    const value = args.owner?.[args.key];
+    if (!Array.isArray(value)) {
+        args.violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: `${args.path}.${args.key} must be an array`,
+        }));
+        return [];
+    }
+    const records = [];
+    for (const [index, item] of value.entries()) {
+        if (!isRecord(item)) {
+            args.violations.push(seedValidationViolation({
+                code: "schema_shape_invalid",
+                message: `${args.path}.${args.key}[${index}] must be an object`,
+            }));
+            continue;
+        }
+        records.push(item);
+    }
+    return records;
+}
+function addSeedId(args) {
+    if (!args.id) {
+        args.violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: `${args.fieldPath} is required`,
+        }));
+        return;
+    }
+    if (args.seedRefs.has(args.id)) {
+        args.violations.push(seedValidationViolation({
+            code: "duplicate_id",
+            message: `duplicate seed ref id ${args.id}`,
+            subjectId: args.id,
+        }));
+        return;
+    }
+    args.seedRefs.add(args.id);
+}
+function addRequiredString(args) {
+    const value = optionalString(args.owner?.[args.key]);
+    if (!value) {
+        args.violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: `${args.fieldPath}.${args.key} is required`,
+        }));
+    }
+    return value;
+}
+function checkKnownRefs(args) {
+    for (const ref of args.refs) {
+        if (!args.knownRefs.has(ref)) {
+            args.violations.push(seedValidationViolation({
+                code: "unknown_ref",
+                message: `${args.fieldPath} references unknown seed ref ${ref}`,
+                subjectId: args.subjectId ?? ref,
+            }));
+        }
+    }
+}
+function addSeedRefFamily(families, familyId, ref) {
+    if (!ref)
+        return;
+    const family = families.get(familyId) ?? new Set();
+    family.add(ref);
+    families.set(familyId, family);
+}
+function seedRefsForFamilies(families, familyIds) {
+    const refs = new Set();
+    for (const familyId of familyIds) {
+        for (const ref of families.get(familyId) ?? [])
+            refs.add(ref);
+    }
+    return refs;
+}
+function allowedCandidateTargetFamilies(dispositionId) {
+    switch (dispositionId) {
+        case "promoted_to_seed_layer":
+            return [
+                "conceptual_frame.concepts",
+                "semantic_layer.object_types",
+                "semantic_layer.constraints",
+                "dynamic_layer.actor_types",
+                "dynamic_layer.permission_policies",
+                "kinetic_layer.action_types",
+                "kinetic_layer.workflows",
+                "data_binding_layer.source_bindings",
+                "data_binding_layer.read_models",
+                "data_binding_layer.writebacks",
+                "data_binding_layer.provenance_bindings",
+            ];
+        case "represented_as_property":
+            return ["semantic_layer.object_type_properties"];
+        case "represented_as_link":
+            return ["semantic_layer.link_types"];
+        case "represented_as_actor_role":
+            return ["dynamic_layer.actor_roles"];
+        case "represented_as_permission_rule":
+            return ["dynamic_layer.permission_policies"];
+        case "represented_as_data_binding":
+            return [
+                "data_binding_layer.source_bindings",
+                "data_binding_layer.read_models",
+                "data_binding_layer.writebacks",
+                "data_binding_layer.provenance_bindings",
+            ];
+        case "represented_as_validation_question":
+            return ["validation_layer.unsupported_question_candidates"];
+        default:
+            return [];
+    }
+}
+function collectNestedEvidenceRefs(args) {
+    let count = 0;
+    if (Array.isArray(args.value)) {
+        for (const [index, item] of args.value.entries()) {
+            count += collectNestedEvidenceRefs({
+                ...args,
+                value: item,
+                path: `${args.path}[${index}]`,
+            });
+        }
+        return count;
+    }
+    if (!isRecord(args.value))
+        return 0;
+    for (const [key, value] of Object.entries(args.value)) {
+        if (key === "evidence_refs") {
+            count += readEvidenceRefs({
+                value,
+                fieldPath: `${args.path}.evidence_refs`,
+                subjectId: optionalString(args.value[`${key.slice(0, -1)}_id`]),
+                required: false,
+                sourceObservations: args.sourceObservations,
+                addViolation: (violation) => {
+                    args.violations.push(seedValidationViolation({
+                        code: violation.code,
+                        message: violation.message,
+                        subjectId: violation.subjectId ?? null,
+                        observationId: violation.observationId ?? null,
+                    }));
+                },
+            }).length;
+            continue;
+        }
+        count += collectNestedEvidenceRefs({
+            ...args,
+            value,
+            path: `${args.path}.${key}`,
+        });
+    }
+    return count;
+}
+function collectNestedLimitationRefs(args) {
+    if (Array.isArray(args.value)) {
+        for (const [index, item] of args.value.entries()) {
+            collectNestedLimitationRefs({
+                ...args,
+                value: item,
+                path: `${args.path}[${index}]`,
+            });
+        }
+        return;
+    }
+    if (!isRecord(args.value))
+        return;
+    for (const [key, value] of Object.entries(args.value)) {
+        if (key === "limitation_refs") {
+            for (const ref of stringArray(value)) {
+                if (!args.limitationIds.has(ref)) {
+                    args.violations.push(seedValidationViolation({
+                        code: "limitation_ref_unknown",
+                        message: `${args.path}.limitation_refs references unknown limitation ${ref}`,
+                        subjectId: ref,
+                    }));
+                }
+            }
+            continue;
+        }
+        collectNestedLimitationRefs({
+            ...args,
+            value,
+            path: `${args.path}.${key}`,
+        });
+    }
+}
+function hasLimitationForRef(limitations, ref) {
+    return limitations.some((limitation) => stringArray(limitation.affected_refs).includes(ref));
+}
+function checkSourceRefs(args) {
+    for (const ref of args.refs) {
+        if (!args.observedSourceRefs.has(normalizeSourceRef(ref))) {
+            args.violations.push(seedValidationViolation({
+                code: "source_ref_unknown",
+                message: `${args.fieldPath} references unobserved source_ref ${ref}`,
+                subjectId: ref,
+            }));
+        }
+    }
+}
+export function validateActionableOntologySeed(args) {
+    const violations = [];
+    const addShapeViolation = (_code, message) => {
+        violations.push(seedValidationViolation({ code: "schema_shape_invalid", message }));
+    };
+    const seed = readRecord(args.ontologySeed, "ontology_seed", addShapeViolation);
+    const disposition = readRecord(args.candidateDisposition, "candidate_disposition", addShapeViolation);
+    const sessionId = optionalString(disposition?.session_id) ??
+        args.sourceObservations.session_id;
+    if (optionalString(disposition?.session_id) &&
+        optionalString(disposition?.session_id) !== args.sourceObservations.session_id) {
+        violations.push(seedValidationViolation({
+            code: "session_id_mismatch",
+            message: "candidate disposition and source observations session_id values must match",
+        }));
+    }
+    const rootObjects = [
+        "seed_identity",
+        "purpose",
+        "decision_context",
+        "conceptual_frame",
+        "semantic_layer",
+        "kinetic_layer",
+        "dynamic_layer",
+        "data_binding_layer",
+        "validation_layer",
+        "candidate_disposition_authority_ref",
+        "ontology_handoff",
+        "source_authority",
+    ];
+    const root = new Map();
+    for (const key of rootObjects) {
+        const record = readRecord(seed?.[key], `ontology_seed.${key}`, (code, message) => {
+            violations.push(seedValidationViolation({ code, message }));
+        });
+        root.set(key, record);
+    }
+    const limitations = recordsFromSeed({
+        owner: seed,
+        key: "handoff_limitations",
+        path: "ontology_seed",
+        violations,
+    });
+    const seedIdentity = root.get("seed_identity") ?? null;
+    const seedId = addRequiredString({
+        owner: seedIdentity,
+        key: "seed_id",
+        fieldPath: "ontology_seed.seed_identity",
+        violations,
+    });
+    addRequiredString({
+        owner: seedIdentity,
+        key: "schema_version",
+        fieldPath: "ontology_seed.seed_identity",
+        violations,
+    });
+    addRequiredString({
+        owner: seedIdentity,
+        key: "title",
+        fieldPath: "ontology_seed.seed_identity",
+        violations,
+    });
+    addRequiredString({
+        owner: seedIdentity,
+        key: "generated_at",
+        fieldPath: "ontology_seed.seed_identity",
+        violations,
+    });
+    addRequiredString({
+        owner: seedIdentity,
+        key: "authoring_profile",
+        fieldPath: "ontology_seed.seed_identity",
+        violations,
+    });
+    if (!Array.isArray(seedIdentity?.target_refs)) {
+        violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: "ontology_seed.seed_identity.target_refs must be an array",
+        }));
+    }
+    const purpose = root.get("purpose") ?? null;
+    addRequiredString({
+        owner: purpose,
+        key: "declared_purpose",
+        fieldPath: "ontology_seed.purpose",
+        violations,
+    });
+    for (const key of ["intended_decisions", "intended_actions", "non_goals"]) {
+        if (!Array.isArray(purpose?.[key])) {
+            violations.push(seedValidationViolation({
+                code: "missing_required_field",
+                message: `ontology_seed.purpose.${key} must be an array`,
+            }));
+        }
+    }
+    readEvidenceRefs({
+        value: purpose?.evidence_refs,
+        fieldPath: "ontology_seed.purpose.evidence_refs",
+        subjectId: seedId,
+        required: true,
+        sourceObservations: args.sourceObservations,
+        addViolation: (violation) => {
+            violations.push(seedValidationViolation({
+                code: violation.code,
+                message: violation.message,
+                subjectId: violation.subjectId ?? null,
+                observationId: violation.observationId ?? null,
+            }));
+        },
+    });
+    const seedRefs = new Set();
+    if (seedId)
+        seedRefs.add(seedId);
+    const seedRefFamilies = new Map();
+    const conceptIds = new Set();
+    const objectTypeIds = new Set();
+    const actorTypeIds = new Set();
+    const roleIds = new Set();
+    const actionTypeIds = new Set();
+    const valueTypeIds = new Set();
+    const conceptualFrame = root.get("conceptual_frame") ?? null;
+    const concepts = recordsFromSeed({
+        owner: conceptualFrame,
+        key: "concepts",
+        path: "ontology_seed.conceptual_frame",
+        violations,
+    });
+    for (const [index, concept] of concepts.entries()) {
+        const conceptId = optionalString(concept.concept_id);
+        addSeedId({
+            id: conceptId,
+            fieldPath: `ontology_seed.conceptual_frame.concepts[${index}].concept_id`,
+            seedRefs,
+            violations,
+        });
+        if (conceptId) {
+            conceptIds.add(conceptId);
+            addSeedRefFamily(seedRefFamilies, "conceptual_frame.concepts", conceptId);
+        }
+    }
+    const associations = recordsFromSeed({
+        owner: conceptualFrame,
+        key: "associations",
+        path: "ontology_seed.conceptual_frame",
+        violations,
+    });
+    for (const [index, association] of associations.entries()) {
+        const associationId = optionalString(association.association_id);
+        addSeedId({
+            id: associationId,
+            fieldPath: `ontology_seed.conceptual_frame.associations[${index}].association_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "conceptual_frame.associations", associationId);
+        checkKnownRefs({
+            refs: [
+                optionalString(association.source_concept_id),
+                optionalString(association.target_concept_id),
+            ].filter((ref) => ref !== null),
+            knownRefs: conceptIds,
+            fieldPath: `ontology_seed.conceptual_frame.associations[${index}]`,
+            violations,
+        });
+    }
+    const semanticLayer = root.get("semantic_layer") ?? null;
+    const objectTypes = recordsFromSeed({
+        owner: semanticLayer,
+        key: "object_types",
+        path: "ontology_seed.semantic_layer",
+        violations,
+    });
+    for (const [index, objectType] of objectTypes.entries()) {
+        const objectTypeId = optionalString(objectType.object_type_id);
+        addSeedId({
+            id: objectTypeId,
+            fieldPath: `ontology_seed.semantic_layer.object_types[${index}].object_type_id`,
+            seedRefs,
+            violations,
+        });
+        if (objectTypeId) {
+            objectTypeIds.add(objectTypeId);
+            addSeedRefFamily(seedRefFamilies, "semantic_layer.object_types", objectTypeId);
+        }
+        validateOptionalEnum({
+            value: objectType.status,
+            allowed: SEED_DECLARED_STATUS_VALUES,
+            fieldPath: `ontology_seed.semantic_layer.object_types[${index}].status`,
+            subjectId: objectTypeId,
+            violations,
+        });
+        const primaryKey = isRecord(objectType.primary_key) ? objectType.primary_key : null;
+        const primaryKeyId = optionalString(primaryKey?.property_id);
+        const propertyRows = recordsFromSeed({
+            owner: objectType,
+            key: "properties",
+            path: `ontology_seed.semantic_layer.object_types[${index}]`,
+            violations,
+        });
+        const propertyIds = new Set(propertyRows
+            .map((property) => optionalString(property.property_id))
+            .filter((propertyId) => propertyId !== null));
+        if (primaryKeyId && !propertyIds.has(primaryKeyId)) {
+            addSeedId({
+                id: primaryKeyId,
+                fieldPath: `ontology_seed.semantic_layer.object_types[${index}].primary_key.property_id`,
+                seedRefs,
+                violations,
+            });
+            addSeedRefFamily(seedRefFamilies, "semantic_layer.object_type_properties", primaryKeyId);
+        }
+        for (const [propertyIndex, property] of propertyRows.entries()) {
+            const propertyId = optionalString(property.property_id);
+            addSeedId({
+                id: propertyId,
+                fieldPath: `ontology_seed.semantic_layer.object_types[${index}].properties[${propertyIndex}].property_id`,
+                seedRefs,
+                violations,
+            });
+            addSeedRefFamily(seedRefFamilies, "semantic_layer.object_type_properties", propertyId);
+        }
+    }
+    const linkTypes = recordsFromSeed({
+        owner: semanticLayer,
+        key: "link_types",
+        path: "ontology_seed.semantic_layer",
+        violations,
+    });
+    for (const [index, linkType] of linkTypes.entries()) {
+        const linkTypeId = optionalString(linkType.link_type_id);
+        addSeedId({
+            id: linkTypeId,
+            fieldPath: `ontology_seed.semantic_layer.link_types[${index}].link_type_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "semantic_layer.link_types", linkTypeId);
+        checkKnownRefs({
+            refs: [
+                optionalString(linkType.source_object_type_id),
+                optionalString(linkType.target_object_type_id),
+            ].filter((ref) => ref !== null),
+            knownRefs: objectTypeIds,
+            fieldPath: `ontology_seed.semantic_layer.link_types[${index}]`,
+            violations,
+        });
+    }
+    for (const [index, valueType] of recordsFromSeed({
+        owner: semanticLayer,
+        key: "value_types",
+        path: "ontology_seed.semantic_layer",
+        violations,
+    }).entries()) {
+        const valueTypeId = optionalString(valueType.value_type_id);
+        addSeedId({
+            id: valueTypeId,
+            fieldPath: `ontology_seed.semantic_layer.value_types[${index}].value_type_id`,
+            seedRefs,
+            violations,
+        });
+        if (valueTypeId) {
+            valueTypeIds.add(valueTypeId);
+            addSeedRefFamily(seedRefFamilies, "semantic_layer.value_types", valueTypeId);
+        }
+    }
+    for (const [index, constraint] of recordsFromSeed({
+        owner: semanticLayer,
+        key: "constraints",
+        path: "ontology_seed.semantic_layer",
+        violations,
+    }).entries()) {
+        const constraintId = optionalString(constraint.constraint_id);
+        addSeedId({
+            id: constraintId,
+            fieldPath: `ontology_seed.semantic_layer.constraints[${index}].constraint_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "semantic_layer.constraints", constraintId);
+    }
+    const dynamicLayer = root.get("dynamic_layer") ?? null;
+    const actorTypes = recordsFromSeed({
+        owner: dynamicLayer,
+        key: "actor_types",
+        path: "ontology_seed.dynamic_layer",
+        violations,
+    });
+    for (const [index, actorType] of actorTypes.entries()) {
+        const actorTypeId = optionalString(actorType.actor_type_id);
+        addSeedId({
+            id: actorTypeId,
+            fieldPath: `ontology_seed.dynamic_layer.actor_types[${index}].actor_type_id`,
+            seedRefs,
+            violations,
+        });
+        if (actorTypeId) {
+            actorTypeIds.add(actorTypeId);
+            addSeedRefFamily(seedRefFamilies, "dynamic_layer.actor_types", actorTypeId);
+        }
+    }
+    const actorRoles = recordsFromSeed({
+        owner: dynamicLayer,
+        key: "actor_roles",
+        path: "ontology_seed.dynamic_layer",
+        violations,
+    });
+    for (const [index, actorRole] of actorRoles.entries()) {
+        const roleId = optionalString(actorRole.role_id);
+        addSeedId({
+            id: roleId,
+            fieldPath: `ontology_seed.dynamic_layer.actor_roles[${index}].role_id`,
+            seedRefs,
+            violations,
+        });
+        if (roleId) {
+            roleIds.add(roleId);
+            addSeedRefFamily(seedRefFamilies, "dynamic_layer.actor_roles", roleId);
+        }
+        checkKnownRefs({
+            refs: stringArray(actorRole.holder_actor_type_ids),
+            knownRefs: actorTypeIds,
+            fieldPath: `ontology_seed.dynamic_layer.actor_roles[${index}].holder_actor_type_ids`,
+            violations,
+        });
+    }
+    for (const [index, actorType] of actorTypes.entries()) {
+        checkKnownRefs({
+            refs: stringArray(actorType.role_refs),
+            knownRefs: roleIds,
+            fieldPath: `ontology_seed.dynamic_layer.actor_types[${index}].role_refs`,
+            violations,
+        });
+    }
+    const kineticLayer = root.get("kinetic_layer") ?? null;
+    const actionTypes = recordsFromSeed({
+        owner: kineticLayer,
+        key: "action_types",
+        path: "ontology_seed.kinetic_layer",
+        violations,
+    });
+    for (const [index, actionType] of actionTypes.entries()) {
+        const actionTypeId = optionalString(actionType.action_type_id);
+        addSeedId({
+            id: actionTypeId,
+            fieldPath: `ontology_seed.kinetic_layer.action_types[${index}].action_type_id`,
+            seedRefs,
+            violations,
+        });
+        if (actionTypeId) {
+            actionTypeIds.add(actionTypeId);
+            addSeedRefFamily(seedRefFamilies, "kinetic_layer.action_types", actionTypeId);
+        }
+        validateOptionalEnum({
+            value: actionType.status,
+            allowed: SEED_DECLARED_STATUS_VALUES,
+            fieldPath: `ontology_seed.kinetic_layer.action_types[${index}].status`,
+            subjectId: actionTypeId,
+            violations,
+        });
+        const actorRefs = stringArray(actionType.actor_type_ids);
+        const targetRefs = stringArray(actionType.target_object_type_ids);
+        const affectedRefs = stringArray(actionType.affected_object_type_ids);
+        checkKnownRefs({
+            refs: actorRefs,
+            knownRefs: actorTypeIds,
+            fieldPath: `ontology_seed.kinetic_layer.action_types[${index}].actor_type_ids`,
+            subjectId: actionTypeId,
+            violations,
+        });
+        checkKnownRefs({
+            refs: [...targetRefs, ...affectedRefs],
+            knownRefs: objectTypeIds,
+            fieldPath: `ontology_seed.kinetic_layer.action_types[${index}].object_type_ids`,
+            subjectId: actionTypeId,
+            violations,
+        });
+        if (actionTypeId && (actorRefs.length === 0 || targetRefs.length + affectedRefs.length === 0)) {
+            if (!hasLimitationForRef(limitations, actionTypeId)) {
+                violations.push(seedValidationViolation({
+                    code: "action_binding_missing",
+                    message: `action_type ${actionTypeId} needs actor and object bindings or a handoff limitation`,
+                    subjectId: actionTypeId,
+                }));
+            }
+        }
+        for (const [parameterIndex, parameter] of recordsFromSeed({
+            owner: actionType,
+            key: "parameters",
+            path: `ontology_seed.kinetic_layer.action_types[${index}]`,
+            violations,
+        }).entries()) {
+            addSeedId({
+                id: optionalString(parameter.parameter_id),
+                fieldPath: `ontology_seed.kinetic_layer.action_types[${index}].parameters[${parameterIndex}].parameter_id`,
+                seedRefs,
+                violations,
+            });
+        }
+        for (const key of ["preconditions", "postconditions", "side_effects"]) {
+            const idKey = key === "preconditions"
+                ? "precondition_id"
+                : key === "postconditions"
+                    ? "postcondition_id"
+                    : "side_effect_id";
+            for (const [nestedIndex, nested] of recordsFromSeed({
+                owner: actionType,
+                key,
+                path: `ontology_seed.kinetic_layer.action_types[${index}]`,
+                violations,
+            }).entries()) {
+                addSeedId({
+                    id: optionalString(nested[idKey]),
+                    fieldPath: `ontology_seed.kinetic_layer.action_types[${index}].${key}[${nestedIndex}].${idKey}`,
+                    seedRefs,
+                    violations,
+                });
+            }
+        }
+    }
+    for (const [index, fn] of recordsFromSeed({
+        owner: kineticLayer,
+        key: "functions",
+        path: "ontology_seed.kinetic_layer",
+        violations,
+    }).entries()) {
+        const functionId = optionalString(fn.function_id);
+        addSeedId({
+            id: functionId,
+            fieldPath: `ontology_seed.kinetic_layer.functions[${index}].function_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "kinetic_layer.functions", functionId);
+    }
+    for (const [index, workflow] of recordsFromSeed({
+        owner: kineticLayer,
+        key: "workflows",
+        path: "ontology_seed.kinetic_layer",
+        violations,
+    }).entries()) {
+        const workflowId = optionalString(workflow.workflow_id);
+        addSeedId({
+            id: workflowId,
+            fieldPath: `ontology_seed.kinetic_layer.workflows[${index}].workflow_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "kinetic_layer.workflows", workflowId);
+        checkKnownRefs({
+            refs: stringArray(workflow.ordered_action_type_ids),
+            knownRefs: actionTypeIds,
+            fieldPath: `ontology_seed.kinetic_layer.workflows[${index}].ordered_action_type_ids`,
+            violations,
+        });
+    }
+    const permissionPolicies = recordsFromSeed({
+        owner: dynamicLayer,
+        key: "permission_policies",
+        path: "ontology_seed.dynamic_layer",
+        violations,
+    });
+    const permissionPolicyActionIds = new Set();
+    for (const [index, policy] of permissionPolicies.entries()) {
+        const policyId = optionalString(policy.policy_id);
+        addSeedId({
+            id: policyId,
+            fieldPath: `ontology_seed.dynamic_layer.permission_policies[${index}].policy_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "dynamic_layer.permission_policies", policyId);
+        const actionTypeId = optionalString(policy.action_type_id);
+        if (actionTypeId)
+            permissionPolicyActionIds.add(actionTypeId);
+        checkKnownRefs({
+            refs: [
+                optionalString(policy.actor_type_id),
+            ].filter((ref) => ref !== null),
+            knownRefs: actorTypeIds,
+            fieldPath: `ontology_seed.dynamic_layer.permission_policies[${index}].actor_type_id`,
+            violations,
+        });
+        checkKnownRefs({
+            refs: [
+                actionTypeId,
+            ].filter((ref) => ref !== null),
+            knownRefs: actionTypeIds,
+            fieldPath: `ontology_seed.dynamic_layer.permission_policies[${index}].action_type_id`,
+            violations,
+        });
+        checkKnownRefs({
+            refs: [
+                optionalString(policy.object_type_id),
+            ].filter((ref) => ref !== null),
+            knownRefs: objectTypeIds,
+            fieldPath: `ontology_seed.dynamic_layer.permission_policies[${index}].object_type_id`,
+            violations,
+        });
+    }
+    for (const actionTypeId of actionTypeIds) {
+        if (!permissionPolicyActionIds.has(actionTypeId) && !hasLimitationForRef(limitations, actionTypeId)) {
+            violations.push(seedValidationViolation({
+                code: "permission_missing",
+                message: `action_type ${actionTypeId} needs permission policy coverage or a handoff limitation`,
+                subjectId: actionTypeId,
+            }));
+        }
+    }
+    for (const [index, stateModel] of recordsFromSeed({
+        owner: dynamicLayer,
+        key: "state_models",
+        path: "ontology_seed.dynamic_layer",
+        violations,
+    }).entries()) {
+        const stateModelId = optionalString(stateModel.state_model_id);
+        addSeedId({
+            id: stateModelId,
+            fieldPath: `ontology_seed.dynamic_layer.state_models[${index}].state_model_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "dynamic_layer.state_models", stateModelId);
+        checkKnownRefs({
+            refs: [optionalString(stateModel.object_type_id)]
+                .filter((ref) => ref !== null),
+            knownRefs: objectTypeIds,
+            fieldPath: `ontology_seed.dynamic_layer.state_models[${index}].object_type_id`,
+            violations,
+        });
+        for (const [transitionIndex, transition] of recordsFromSeed({
+            owner: stateModel,
+            key: "transitions",
+            path: `ontology_seed.dynamic_layer.state_models[${index}]`,
+            violations,
+        }).entries()) {
+            const transitionId = optionalString(transition.transition_id);
+            addSeedId({
+                id: transitionId,
+                fieldPath: `ontology_seed.dynamic_layer.state_models[${index}].transitions[${transitionIndex}].transition_id`,
+                seedRefs,
+                violations,
+            });
+            addSeedRefFamily(seedRefFamilies, "dynamic_layer.state_transitions", transitionId);
+            checkKnownRefs({
+                refs: [optionalString(transition.action_type_id)]
+                    .filter((ref) => ref !== null),
+                knownRefs: actionTypeIds,
+                fieldPath: `ontology_seed.dynamic_layer.state_models[${index}].transitions[${transitionIndex}].action_type_id`,
+                violations,
+            });
+        }
+    }
+    for (const [index, lifecycleRule] of recordsFromSeed({
+        owner: dynamicLayer,
+        key: "lifecycle_rules",
+        path: "ontology_seed.dynamic_layer",
+        violations,
+    }).entries()) {
+        const lifecycleRuleId = optionalString(lifecycleRule.rule_id);
+        addSeedId({
+            id: lifecycleRuleId,
+            fieldPath: `ontology_seed.dynamic_layer.lifecycle_rules[${index}].rule_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "dynamic_layer.lifecycle_rules", lifecycleRuleId);
+    }
+    const observedSourceRefs = new Set(args.sourceObservations.observations.map((observation) => normalizeSourceRef(observation.source_ref)));
+    const dataBindingLayer = root.get("data_binding_layer") ?? null;
+    const sourceBindings = recordsFromSeed({
+        owner: dataBindingLayer,
+        key: "source_bindings",
+        path: "ontology_seed.data_binding_layer",
+        violations,
+    });
+    const dataBoundSeedRefs = new Set();
+    for (const [index, binding] of sourceBindings.entries()) {
+        const bindingId = optionalString(binding.binding_id);
+        addSeedId({
+            id: bindingId,
+            fieldPath: `ontology_seed.data_binding_layer.source_bindings[${index}].binding_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "data_binding_layer.source_bindings", bindingId);
+        const seedRef = optionalString(binding.seed_ref);
+        if (seedRef)
+            dataBoundSeedRefs.add(seedRef);
+        checkSourceRefs({
+            refs: [optionalString(binding.source_ref)]
+                .filter((ref) => ref !== null),
+            observedSourceRefs,
+            fieldPath: `ontology_seed.data_binding_layer.source_bindings[${index}].source_ref`,
+            violations,
+        });
+    }
+    for (const [index, readModel] of recordsFromSeed({
+        owner: dataBindingLayer,
+        key: "read_models",
+        path: "ontology_seed.data_binding_layer",
+        violations,
+    }).entries()) {
+        const readModelId = optionalString(readModel.read_model_id);
+        addSeedId({
+            id: readModelId,
+            fieldPath: `ontology_seed.data_binding_layer.read_models[${index}].read_model_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "data_binding_layer.read_models", readModelId);
+        checkKnownRefs({
+            refs: stringArray(readModel.object_type_ids),
+            knownRefs: objectTypeIds,
+            fieldPath: `ontology_seed.data_binding_layer.read_models[${index}].object_type_ids`,
+            violations,
+        });
+        for (const objectTypeId of stringArray(readModel.object_type_ids)) {
+            dataBoundSeedRefs.add(objectTypeId);
+        }
+        checkSourceRefs({
+            refs: stringArray(readModel.source_refs),
+            observedSourceRefs,
+            fieldPath: `ontology_seed.data_binding_layer.read_models[${index}].source_refs`,
+            violations,
+        });
+    }
+    const writebackActionIds = new Set();
+    for (const [index, writeback] of recordsFromSeed({
+        owner: dataBindingLayer,
+        key: "writebacks",
+        path: "ontology_seed.data_binding_layer",
+        violations,
+    }).entries()) {
+        const writebackId = optionalString(writeback.writeback_id);
+        addSeedId({
+            id: writebackId,
+            fieldPath: `ontology_seed.data_binding_layer.writebacks[${index}].writeback_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "data_binding_layer.writebacks", writebackId);
+        const actionTypeId = optionalString(writeback.action_type_id);
+        if (actionTypeId)
+            writebackActionIds.add(actionTypeId);
+        checkKnownRefs({
+            refs: [actionTypeId].filter((ref) => ref !== null),
+            knownRefs: actionTypeIds,
+            fieldPath: `ontology_seed.data_binding_layer.writebacks[${index}].action_type_id`,
+            violations,
+        });
+        checkSourceRefs({
+            refs: stringArray(writeback.target_source_refs),
+            observedSourceRefs,
+            fieldPath: `ontology_seed.data_binding_layer.writebacks[${index}].target_source_refs`,
+            violations,
+        });
+    }
+    for (const [index, provenance] of recordsFromSeed({
+        owner: dataBindingLayer,
+        key: "provenance_bindings",
+        path: "ontology_seed.data_binding_layer",
+        violations,
+    }).entries()) {
+        const provenanceId = optionalString(provenance.provenance_id);
+        addSeedId({
+            id: provenanceId,
+            fieldPath: `ontology_seed.data_binding_layer.provenance_bindings[${index}].provenance_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "data_binding_layer.provenance_bindings", provenanceId);
+        const seedRef = optionalString(provenance.seed_ref);
+        if (seedRef)
+            dataBoundSeedRefs.add(seedRef);
+        checkSourceRefs({
+            refs: [optionalString(provenance.source_ref)]
+                .filter((ref) => ref !== null),
+            observedSourceRefs,
+            fieldPath: `ontology_seed.data_binding_layer.provenance_bindings[${index}].source_ref`,
+            violations,
+        });
+    }
+    for (const objectTypeId of objectTypeIds) {
+        if (!dataBoundSeedRefs.has(objectTypeId) && !hasLimitationForRef(limitations, objectTypeId)) {
+            violations.push(seedValidationViolation({
+                code: "data_binding_missing",
+                message: `object_type ${objectTypeId} needs data binding coverage or a handoff limitation`,
+                subjectId: objectTypeId,
+            }));
+        }
+    }
+    const limitationIds = new Set();
+    for (const [index, limitation] of limitations.entries()) {
+        const limitationId = optionalString(limitation.limitation_id);
+        addSeedId({
+            id: limitationId,
+            fieldPath: `ontology_seed.handoff_limitations[${index}].limitation_id`,
+            seedRefs,
+            violations,
+        });
+        if (limitationId)
+            limitationIds.add(limitationId);
+    }
+    collectNestedLimitationRefs({
+        value: seed,
+        path: "ontology_seed",
+        limitationIds,
+        violations,
+    });
+    const validationLayer = root.get("validation_layer") ?? null;
+    for (const [index, unsupportedQuestion] of recordsFromSeed({
+        owner: validationLayer,
+        key: "unsupported_question_candidates",
+        path: "ontology_seed.validation_layer",
+        violations,
+    }).entries()) {
+        const candidateId = optionalString(unsupportedQuestion.candidate_id);
+        addSeedId({
+            id: candidateId,
+            fieldPath: `ontology_seed.validation_layer.unsupported_question_candidates[${index}].candidate_id`,
+            seedRefs,
+            violations,
+        });
+        addSeedRefFamily(seedRefFamilies, "validation_layer.unsupported_question_candidates", candidateId);
+    }
+    const allowedCoverageAxes = new Set(args.registry.coverage_axis_registry.map((record) => record.axis_id));
+    for (const axis of stringArray(validationLayer?.coverage_axes)) {
+        if (!allowedCoverageAxes.has(axis)) {
+            violations.push(seedValidationViolation({
+                code: "invalid_enum",
+                message: `validation_layer.coverage_axes contains unknown axis ${axis}`,
+                subjectId: axis,
+            }));
+        }
+    }
+    const authorityRef = root.get("candidate_disposition_authority_ref") ?? null;
+    const expectedAuthorityRefs = {
+        authority_scope: "external_candidate_disposition",
+        projection_policy: "reference_only",
+    };
+    for (const [key, expected] of Object.entries(expectedAuthorityRefs)) {
+        if (optionalString(authorityRef?.[key]) !== expected) {
+            violations.push(seedValidationViolation({
+                code: "candidate_authority_ref_invalid",
+                message: `candidate_disposition_authority_ref.${key} must be ${expected}`,
+                subjectId: key,
+            }));
+        }
+    }
+    const ontologyHandoff = root.get("ontology_handoff") ?? null;
+    const readinessClaim = optionalString(ontologyHandoff?.readiness_claim);
+    if (!["ready", "limited", "not_ready", "blocked"].includes(readinessClaim ?? "")) {
+        violations.push(seedValidationViolation({
+            code: "invalid_enum",
+            message: "ontology_handoff.readiness_claim must be ready, limited, not_ready, or blocked",
+            subjectId: readinessClaim,
+        }));
+    }
+    else if (readinessClaim !== "ready" && limitationIds.size === 0) {
+        violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: "non-ready ontology handoff readiness must cite explicit handoff limitations",
+            subjectId: readinessClaim,
+        }));
+    }
+    else if (readinessClaim === "ready") {
+        validateReadyHandoffMappings({ ontologyHandoff, violations });
+    }
+    const reasoningProfile = isRecord(ontologyHandoff?.reasoning_or_formalism_profile)
+        ? ontologyHandoff?.reasoning_or_formalism_profile
+        : null;
+    const reasoningValues = args.registry.reasoning_or_formalism_profile_values;
+    if (reasoningProfile) {
+        validateOptionalEnum({
+            value: reasoningProfile.representation_formalism,
+            allowed: reasoningValues.representation_formalism_values,
+            fieldPath: "ontology_seed.ontology_handoff.reasoning_or_formalism_profile.representation_formalism",
+            violations,
+        });
+        validateEnumArray({
+            value: reasoningProfile.vocabulary_systems,
+            allowed: reasoningValues.vocabulary_system_values,
+            fieldPath: "ontology_seed.ontology_handoff.reasoning_or_formalism_profile.vocabulary_systems",
+            violations,
+        });
+        validateEnumArray({
+            value: reasoningProfile.validation_formalisms,
+            allowed: reasoningValues.validation_formalism_values,
+            fieldPath: "ontology_seed.ontology_handoff.reasoning_or_formalism_profile.validation_formalisms",
+            violations,
+        });
+        validateOptionalEnum({
+            value: reasoningProfile.ontology_type,
+            allowed: reasoningValues.ontology_type_values,
+            fieldPath: "ontology_seed.ontology_handoff.reasoning_or_formalism_profile.ontology_type",
+            violations,
+        });
+        validateOptionalEnum({
+            value: reasoningProfile.owl_profile,
+            allowed: reasoningValues.owl_profile_values,
+            fieldPath: "ontology_seed.ontology_handoff.reasoning_or_formalism_profile.owl_profile",
+            violations,
+        });
+        validateOptionalEnum({
+            value: reasoningProfile.alignment_posture,
+            allowed: reasoningValues.alignment_posture_values,
+            fieldPath: "ontology_seed.ontology_handoff.reasoning_or_formalism_profile.alignment_posture",
+            violations,
+        });
+    }
+    else {
+        violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: "ontology_handoff.reasoning_or_formalism_profile must be an object",
+            subjectId: "reasoning_or_formalism_profile",
+        }));
+    }
+    const instanceAssertionMapping = isRecord(ontologyHandoff?.instance_assertion_mapping)
+        ? ontologyHandoff?.instance_assertion_mapping
+        : null;
+    const instanceAvailabilityStatus = instanceAssertionMapping
+        ? validateOptionalEnum({
+            value: instanceAssertionMapping.instance_availability_status,
+            allowed: INSTANCE_AVAILABILITY_STATUS_VALUES,
+            fieldPath: "ontology_seed.ontology_handoff.instance_assertion_mapping.instance_availability_status",
+            violations,
+        })
+        : null;
+    if (!instanceAssertionMapping) {
+        violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: "ontology_handoff.instance_assertion_mapping must be an object",
+            subjectId: "instance_assertion_mapping",
+        }));
+    }
+    else if ((instanceAvailabilityStatus === "absent" || instanceAvailabilityStatus === "unknown") &&
+        stringArray(instanceAssertionMapping.limitation_refs).length === 0) {
+        violations.push(seedValidationViolation({
+            code: "missing_required_field",
+            message: "absent or unknown instance availability must cite instance_assertion_mapping.limitation_refs",
+            subjectId: "instance_assertion_mapping",
+        }));
+    }
+    for (const key of [
+        "query_access_contract",
+        "visualization_contract",
+        "graph_exploration_contract",
+    ]) {
+        const contract = isRecord(ontologyHandoff?.[key])
+            ? ontologyHandoff?.[key]
+            : null;
+        const applies = contract?.applies;
+        if (applies !== true &&
+            applies !== false &&
+            applies !== "unknown" &&
+            applies !== "not_applicable") {
+            violations.push(seedValidationViolation({
+                code: "invalid_enum",
+                message: `ontology_handoff.${key}.applies must be true, false, unknown, or not_applicable`,
+                subjectId: key,
+            }));
+            continue;
+        }
+        const limitationRefs = stringArray(contract?.limitation_refs);
+        if ((applies === true || applies === "unknown") && limitationRefs.length === 0) {
+            violations.push(seedValidationViolation({
+                code: "missing_required_field",
+                message: `ontology_handoff.${key} with applies=${String(applies)} must cite limitation_refs until runtime proof validation is active`,
+                subjectId: key,
+            }));
+        }
+        checkKnownRefs({
+            refs: limitationRefs,
+            knownRefs: limitationIds,
+            fieldPath: `ontology_seed.ontology_handoff.${key}.limitation_refs`,
+            subjectId: key,
+            violations,
+        });
+    }
+    const modelingConcerns = isRecord(ontologyHandoff?.modeling_concern_applicability)
+        ? ontologyHandoff?.modeling_concern_applicability
+        : null;
+    for (const [index, row] of readArray(modelingConcerns?.rows, "ontology_handoff.modeling_concern_applicability.rows", (code, message) => violations.push(seedValidationViolation({ code, message }))).entries()) {
+        if (!isRecord(row))
+            continue;
+        const applies = row.applies;
+        if (applies !== true &&
+            applies !== false &&
+            applies !== "unknown" &&
+            applies !== "not_applicable") {
+            violations.push(seedValidationViolation({
+                code: "invalid_enum",
+                message: `ontology_handoff.modeling_concern_applicability.rows[${index}].applies must be true, false, unknown, or not_applicable`,
+                subjectId: optionalString(row.concern_id),
+            }));
+            continue;
+        }
+        const limitationRefs = stringArray(row.limitation_refs);
+        if (applies === "unknown" && limitationRefs.length === 0) {
+            violations.push(seedValidationViolation({
+                code: "missing_required_field",
+                message: `ontology_handoff.modeling_concern_applicability.rows[${index}] with applies=unknown must cite limitation_refs`,
+                subjectId: optionalString(row.concern_id),
+            }));
+        }
+        checkKnownRefs({
+            refs: limitationRefs,
+            knownRefs: limitationIds,
+            fieldPath: `ontology_seed.ontology_handoff.modeling_concern_applicability.rows[${index}].limitation_refs`,
+            subjectId: optionalString(row.concern_id),
+            violations,
+        });
+    }
+    const dispositionRows = readArray(disposition?.dispositions, "candidate_disposition.dispositions", (code, message) => violations.push(seedValidationViolation({ code, message })));
+    for (const [index, dispositionValue] of dispositionRows.entries()) {
+        if (!isRecord(dispositionValue))
+            continue;
+        const dispositionId = optionalString(dispositionValue.disposition_id);
+        if (!dispositionId) {
+            continue;
+        }
+        const targetSeedRefs = stringArray(dispositionValue.target_seed_refs);
+        const allowedFamilies = allowedCandidateTargetFamilies(dispositionId);
+        const allowedRefs = seedRefsForFamilies(seedRefFamilies, allowedFamilies);
+        if (allowedFamilies.length > 0 && targetSeedRefs.length === 0) {
+            violations.push(seedValidationViolation({
+                code: "candidate_target_ref_invalid",
+                message: `candidate_disposition.dispositions[${index}].target_seed_refs is required for ${dispositionId}`,
+                subjectId: optionalString(dispositionValue.candidate_id),
+            }));
+        }
+        for (const targetSeedRef of targetSeedRefs) {
+            if (!seedRefs.has(targetSeedRef)) {
+                violations.push(seedValidationViolation({
+                    code: "promoted_candidate_ref_unknown",
+                    message: `candidate_disposition.dispositions[${index}].target_seed_refs references unknown seed ref ${targetSeedRef}`,
+                    subjectId: optionalString(dispositionValue.candidate_id),
+                }));
+            }
+            else if (allowedFamilies.length > 0 && !allowedRefs.has(targetSeedRef)) {
+                violations.push(seedValidationViolation({
+                    code: "candidate_target_ref_invalid",
+                    message: `candidate_disposition.dispositions[${index}].target_seed_refs ${targetSeedRef} is not valid for ${dispositionId}; expected one of ${allowedFamilies.join(", ")}`,
+                    subjectId: optionalString(dispositionValue.candidate_id),
+                }));
+            }
+        }
+    }
+    const evidenceRefCount = collectNestedEvidenceRefs({
+        value: seed,
+        path: "ontology_seed",
+        sourceObservations: args.sourceObservations,
+        violations,
+    });
+    const sourceAuthority = root.get("source_authority") ?? null;
+    for (const key of [
+        "evidence_scope",
+        "permission_scope",
+        "trust_boundary",
+        "instruction_authority",
+        "external_content_handling",
+        "rationale",
+    ]) {
+        addRequiredString({
+            owner: sourceAuthority,
+            key,
+            fieldPath: "ontology_seed.source_authority",
+            violations,
+        });
+    }
+    for (const key of [
+        "included_source_refs",
+        "excluded_source_refs",
+        "restricted_source_refs",
+        "source_gaps",
+    ]) {
+        if (!Array.isArray(sourceAuthority?.[key])) {
+            violations.push(seedValidationViolation({
+                code: "missing_required_field",
+                message: `ontology_seed.source_authority.${key} must be an array`,
+            }));
+        }
+    }
+    checkSourceRefs({
+        refs: stringArray(sourceAuthority?.included_source_refs),
+        observedSourceRefs,
+        fieldPath: "ontology_seed.source_authority.included_source_refs",
+        violations,
+    });
+    checkSourceRefs({
+        refs: stringArray(sourceAuthority?.excluded_source_refs),
+        observedSourceRefs,
+        fieldPath: "ontology_seed.source_authority.excluded_source_refs",
+        violations,
+    });
+    checkSourceRefs({
+        refs: stringArray(sourceAuthority?.restricted_source_refs),
+        observedSourceRefs,
+        fieldPath: "ontology_seed.source_authority.restricted_source_refs",
+        violations,
+    });
+    return {
+        schema_version: "1",
+        session_id: sessionId,
+        created_at: isoNow(),
+        ontology_seed_ref: args.ontologySeedRef ?? null,
+        candidate_disposition_ref: args.candidateDispositionRef ?? null,
+        source_observations_ref: args.sourceObservationsRef ?? null,
+        registry_ref: args.registryRef ?? null,
+        validation_status: violations.length === 0 ? "valid" : "invalid",
+        seed_ref_count: seedRefs.size,
+        evidence_ref_count: evidenceRefCount,
+        limitation_count: limitationIds.size,
+        validation_results: violations.length === 0
+            ? ["ontology_seed_valid"]
+            : ["ontology_seed_invalid"],
+        violations,
+    };
+}
+async function readYamlDocument(filePath) {
+    return parseYaml(await fs.readFile(filePath, "utf8"));
+}
+async function writeYamlDocument(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, stringifyYaml(value), "utf8");
+}
+export async function writeCandidateDispositionValidationArtifact(args) {
+    const [candidateInventory, candidateDisposition, sourceObservations, registry] = await Promise.all([
+        readYamlDocument(args.candidateInventoryPath),
+        readYamlDocument(args.candidateDispositionPath),
+        readYamlDocument(args.sourceObservationsPath),
+        loadReconstructContractRegistry({ registryPath: args.registryPath }),
+    ]);
+    const validation = validateCandidateDisposition({
+        candidateInventory,
+        candidateDisposition,
+        sourceObservations,
+        registry,
+        candidateInventoryRef: path.resolve(args.candidateInventoryPath),
+        candidateDispositionRef: path.resolve(args.candidateDispositionPath),
+        sourceObservationsRef: path.resolve(args.sourceObservationsPath),
+        registryRef: path.resolve(args.registryPath),
+    });
+    await writeYamlDocument(args.outputPath, validation);
+    return validation;
+}
+export async function writeActionableOntologySeedValidationArtifact(args) {
+    const [ontologySeed, candidateDisposition, sourceObservations, registry] = await Promise.all([
+        readYamlDocument(args.ontologySeedPath),
+        readYamlDocument(args.candidateDispositionPath),
+        readYamlDocument(args.sourceObservationsPath),
+        loadReconstructContractRegistry({ registryPath: args.registryPath }),
+    ]);
+    const validation = validateActionableOntologySeed({
+        ontologySeed,
+        candidateDisposition,
+        sourceObservations,
+        registry,
+        ontologySeedRef: path.resolve(args.ontologySeedPath),
+        candidateDispositionRef: path.resolve(args.candidateDispositionPath),
+        sourceObservationsRef: path.resolve(args.sourceObservationsPath),
+        registryRef: path.resolve(args.registryPath),
+    });
+    await writeYamlDocument(args.outputPath, validation);
+    return validation;
+}