@memoarchitect/ontology 0.4.4

package/src/methodology/memo_archetypes.sysml

@@ -0,0 +1,93 @@
+package memo_methodology_archetypes {
+    private import ScalarValues::*;
+
+    private import memo_methodology_core::*;
+
+    part minimal : Archetype {
+        attribute :>> id = "ARCH-MINIMAL";
+        attribute :>> name = "Minimal";
+        attribute :>> label = "Minimal";
+        attribute :>> description = "Core ontology only — requirements, hazards, basic architecture (~53 kinds)";
+        attribute :>> category = "profile";
+        attribute :>> includedLayer = "context; requirements; risk";
+        attribute :>> includedStandard = "ISO 14971";
+        attribute :>> templateDir = "";
+    }
+
+    part standardArchetype : Archetype {
+        attribute :>> id = "ARCH-STANDARD";
+        attribute :>> name = "Standard";
+        attribute :>> label = "Standard";
+        attribute :>> description = "Core + risk + software + DHF — covers most Class II devices (~120 kinds)";
+        attribute :>> category = "profile";
+        attribute :>> includedLayer = "context; requirements; functions; logical_structure; software_structure; risk; assurance";
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820";
+        attribute :>> templateDir = "";
+    }
+
+    part full : Archetype {
+        attribute :>> id = "ARCH-FULL";
+        attribute :>> name = "Full";
+        attribute :>> label = "Full";
+        attribute :>> description = "All architecture layers, standards, and extensions (~200+ kinds)";
+        attribute :>> category = "profile";
+        attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; behavior; risk; arch_risk; assurance; cybersecurity; constraints";
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820; ISO 13485; IEC 62366; IEC 60601-1; IEC 82304-1; FDA Cybersecurity Guidance";
+        attribute :>> templateDir = "";
+    }
+
+    part samd : Archetype {
+        attribute :>> id = "ARCH-SAMD";
+        attribute :>> name = "SaMD";
+        attribute :>> label = "Software as Medical Device (SaMD)";
+        attribute :>> description = "Clinical decision support, diagnostic algorithm, AI/ML tool, mobile medical app";
+        attribute :>> category = "device-class";
+        attribute :>> includedLayer = "context; requirements; functions; logical_structure; software_structure; risk; assurance; cybersecurity";
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; IEC 82304-1; FDA Cybersecurity Guidance";
+        attribute :>> templateDir = "samd";
+    }
+
+    part connected : Archetype {
+        attribute :>> id = "ARCH-CONNECTED";
+        attribute :>> name = "Connected";
+        attribute :>> label = "Connected / IoT Device";
+        attribute :>> description = "Remote monitoring, wearable, smart device with cloud connectivity and cybersecurity requirements";
+        attribute :>> category = "device-class";
+        attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; risk; assurance; cybersecurity";
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820; FDA Cybersecurity Guidance";
+        attribute :>> templateDir = "connected-device";
+    }
+
+    part monitoring : Archetype {
+        attribute :>> id = "ARCH-MONITORING";
+        attribute :>> name = "Monitoring";
+        attribute :>> label = "Monitoring / Diagnostic Device";
+        attribute :>> description = "Patient monitor, ECG, SpO2, vital signs, bedside diagnostic equipment";
+        attribute :>> category = "device-class";
+        attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; risk; assurance";
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; IEC 60601-1; 21 CFR 820";
+        attribute :>> templateDir = "monitoring-device";
+    }
+
+    part infusion_pump : Archetype {
+        attribute :>> id = "ARCH-INFUSION";
+        attribute :>> name = "InfusionPump";
+        attribute :>> label = "Infusion / Drug Delivery Device";
+        attribute :>> description = "Infusion pump, syringe driver, implantable drug delivery, dosing device";
+        attribute :>> category = "device-class";
+        attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; behavior; risk; arch_risk; assurance; cybersecurity";
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; IEC 60601-1; 21 CFR 820; ISO 13485";
+        attribute :>> templateDir = "infusion-pump";
+    }
+
+    part blank : Archetype {
+        attribute :>> id = "ARCH-BLANK";
+        attribute :>> name = "Blank";
+        attribute :>> label = "Blank Project";
+        attribute :>> description = "Start from scratch with a minimal SysML shell";
+        attribute :>> category = "device-class";
+        attribute :>> includedLayer = "";
+        attribute :>> includedStandard = "";
+        attribute :>> templateDir = "";
+    }
+}

package/src/methodology/memo_core.sysml

@@ -0,0 +1,53 @@
+package memo_methodology_core {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def MethodologyLibrary :> TraceableElement {
+        attribute version : String;
+        attribute domain : String;
+        attribute :>> description : String;
+    }
+
+    part def MethodologyDefinition :> TraceableElement {
+        attribute version : String;
+        attribute domain : String;
+        attribute :>> description : String;
+        attribute baseMethodName : String;
+    }
+
+    part def ResolvedMethodology :> TraceableElement {
+        attribute version : String;
+        // Risk-proportionate scope keyed to the device's software safety
+        // classification (IEC 62304 A/B/C) and lifecycle stage — not a
+        // "rigor dial". The class + stage determine which layers, links,
+        // viewpoints, and gates a release must clear.
+        attribute safetyClassification : SafetyClassKind;
+        attribute lifecycleStage : LifecycleStateKind;
+        attribute resolutionSummary : String;
+    }
+
+    part def ProjectMethodBinding :> TraceableElement {
+        attribute projectName : String;
+    }
+
+    part def DhfDocumentBinding :> TraceableElement {
+        attribute documentTitle : String;
+        attribute groupLabel : String;
+        attribute templateId : String;
+        attribute viewKind : String;
+        attribute regulatoryReference : String;
+        attribute lifecycleStage : WorkflowStageKind;
+        attribute required : Boolean;
+    }
+
+    part def Archetype :> TraceableElement {
+        attribute label : String;
+        attribute :>> description : String;
+        attribute category : String;
+        attribute includedLayer : String;
+        attribute includedStandard : String;
+        attribute templateDir : String;
+    }
+}

package/src/methodology/memo_gates.sysml

@@ -0,0 +1,11 @@
+package memo_methodology_gates {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def QualityGate :> TraceableElement {
+        attribute gateStage : WorkflowStageKind;
+        attribute passCriteria : String;
+    }
+}

package/src/methodology/memo_patterns.sysml

@@ -0,0 +1,12 @@
+package memo_methodology_patterns {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def ModelingPattern :> TraceableElement {
+        attribute intent : String;
+        attribute stage : WorkflowStageKind;
+        attribute strength : RuleStrengthKind;
+    }
+}

package/src/methodology/memo_profiles.sysml

@@ -0,0 +1,218 @@
+package memo_methodology_profiles {
+    private import ScalarValues::*;
+
+    private import memo_methodology_core::*;
+    private import memo_methodology_viewpoints::*;
+    private import memo_methodology_rules::*;
+    private import memo_methodology_patterns::*;
+    private import memo_methodology_workflow::*;
+    private import memo_methodology_gates::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_methodology_scope::*;
+
+    part mdCoreLibrary : MethodologyLibrary {
+        attribute :>> id = "METHLIB-001";
+        attribute :>> name = "MedicalDeviceMethodologyLibrary";
+        attribute :>> version = "0.1";
+        attribute :>> domain = "medical device modeling";
+        attribute :>> description = "Methodology layer for selecting, restricting, sequencing, tailoring, and lightly extending use of the medical-device ontology.";
+    }
+
+    part mdLightDefaultDefinition : MethodologyDefinition {
+        attribute :>> id = "METH-001";
+        attribute :>> name = "MedicalDeviceLightDefault";
+        attribute :>> version = "0.1";
+        attribute :>> domain = "medical device modeling";
+        attribute :>> description = "Light default methodology around the ontology for smaller or early project use.";
+        attribute :>> baseMethodName = "";
+    }
+
+    part mdLightDefaultResolved : ResolvedMethodology {
+        attribute :>> id = "RMETH-001";
+        attribute :>> name = "MedicalDeviceLightDefaultResolved";
+        attribute :>> version = "0.1";
+        attribute :>> safetyClassification = SafetyClassKind::A;
+        attribute :>> lifecycleStage = LifecycleStateKind::development;
+        attribute :>> resolutionSummary = "Class A development-stage scope: core requirements, architecture, risk, verification, and RMF support required; cybersecurity and SOUP out of scope.";
+    }
+
+    part riskView : Viewpoint {
+        attribute :>> id = "VP-001";
+        attribute :>> name = "RiskManagementView";
+        attribute :>> purpose = "Focus on risk chain, controls, verification, and residual risk.";
+        attribute :>> audience = AudienceKind::safetyEngineer;
+        attribute :>> stage = WorkflowStageKind::risk;
+        attribute :>> abstractionLevel = "safety management";
+    }
+
+    part swArchView : Viewpoint {
+        attribute :>> id = "VP-002";
+        attribute :>> name = "SoftwareArchitectureView";
+        attribute :>> purpose = "Focus on software decomposition, interfaces, timing, and contracts.";
+        attribute :>> audience = AudienceKind::softwareArchitect;
+        attribute :>> stage = WorkflowStageKind::architecture;
+        attribute :>> abstractionLevel = "software design";
+    }
+
+    part useRiskBeforeRule : ElementUsageRule {
+        attribute :>> id = "RULE-001";
+        attribute :>> name = "UseRiskBeforeAfter";
+        attribute :>> elementTypeName = "RiskBeforeMitigation,RiskAfterMitigation,RiskMatrix";
+        attribute :>> strength = RuleStrengthKind::recommended;
+        attribute :>> rationaleText = "Even a light methodology should distinguish pre- and post-mitigation risk and assess against a matrix.";
+    }
+
+    part requireVerifiedByRule : RelationUsageRule {
+        attribute :>> id = "RULE-002";
+        attribute :>> name = "VerifiedBysRequired";
+        attribute :>> relationTypeName = "VerifiedBy";
+        attribute :>> strength = RuleStrengthKind::required;
+        attribute :>> rationaleText = "Safety-relevant requirements and controls shall trace to verification.";
+    }
+
+    part lightRiskPattern : ModelingPattern {
+        attribute :>> id = "PAT-001";
+        attribute :>> name = "LightRiskBeforeAfterPattern";
+        attribute :>> intent = "Model hazard chain, before/after mitigation risk, controls, and residual evaluation in a lightweight way.";
+        attribute :>> stage = WorkflowStageKind::risk;
+        attribute :>> strength = RuleStrengthKind::recommended;
+    }
+
+    part lightTracePattern : ModelingPattern {
+        attribute :>> id = "PAT-002";
+        attribute :>> name = "CoreTracePattern";
+        attribute :>> intent = "Need or risk to requirement, requirement to architecture, requirement/control to verification.";
+        attribute :>> stage = WorkflowStageKind::requirements;
+        attribute :>> strength = RuleStrengthKind::required;
+    }
+
+    part stepRequirements : WorkflowStep {
+        attribute :>> id = "STEP-001";
+        attribute :>> name = "CaptureRequirements";
+        attribute :>> stepOrder = 1;
+        attribute :>> stage = WorkflowStageKind::requirements;
+        attribute :>> objectiveDescription = "Capture stakeholder needs and derive requirements.";
+        attribute :>> entryCriteria = "Intended use and actors understood.";
+        attribute :>> exitCriteria = "Initial requirement set exists.";
+    }
+
+    part stepArchitecture : WorkflowStep {
+        attribute :>> id = "STEP-002";
+        attribute :>> name = "DefineArchitecture";
+        attribute :>> stepOrder = 2;
+        attribute :>> stage = WorkflowStageKind::architecture;
+        attribute :>> objectiveDescription = "Define key software and hardware architecture elements and interfaces.";
+        attribute :>> entryCriteria = "Initial requirements exist.";
+        attribute :>> exitCriteria = "Core architecture and interfaces exist.";
+    }
+
+    part stepRisk : WorkflowStep {
+        attribute :>> id = "STEP-003";
+        attribute :>> name = "PerformRiskAnalysis";
+        attribute :>> stepOrder = 3;
+        attribute :>> stage = WorkflowStageKind::risk;
+        attribute :>> objectiveDescription = "Create core risk chain and controls.";
+        attribute :>> entryCriteria = "Initial requirements and key behavior exist.";
+        attribute :>> exitCriteria = "Risk and control model exists.";
+    }
+
+    part stepVerification : WorkflowStep {
+        attribute :>> id = "STEP-004";
+        attribute :>> name = "PlanVerification";
+        attribute :>> stepOrder = 4;
+        attribute :>> stage = WorkflowStageKind::verificationStage;
+        attribute :>> objectiveDescription = "Define verification and evidence expectations.";
+        attribute :>> entryCriteria = "Requirements and controls exist.";
+        attribute :>> exitCriteria = "Verification cases and evidence targets exist.";
+    }
+
+    part gateLightComplete : QualityGate {
+        attribute :>> id = "GATE-001";
+        attribute :>> name = "LightMethodReady";
+        attribute :>> gateStage = WorkflowStageKind::verificationStage;
+        attribute :>> passCriteria = "Core traceability, risk, verification, and RMF view support are present.";
+    }
+
+    part mdCoverageScope : MethodologyScope {
+        attribute :>> id = "SCOPE-COV-001";
+        attribute :>> name = "MedicalDeviceCoverageScope";
+        attribute :>> scopeName = "coverage";
+
+        attribute :>> includedArchLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; behavior; risk; arch_risk; assurance; cybersecurity; constraints";
+
+        attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820; ISO 13485; ISO 14155; IEC 62366; IEC 60601-1; IEC 82304-1; FDA Cybersecurity Guidance";
+
+        attribute :>> includedArtifactKind = "RiskManagementPlan; RequirementsSpecification; SystemArchitectureDescription; SoftwareDesignDescription; HazardAnalysisReport; RequirementsTraceabilityMatrix; CybersecurityAssessmentReport; ThreatModelReport; UsabilityEngineeringReport; ClinicalSafetyReport; FailureModeEffectsAnalysisReport; SoupList; DesignInputPlan; DesignOutputPlan; SoftwareDevelopmentPlan; LabelingSpecification; DesignHistoryFileIndex; DesignChangeLog";
+
+        attribute :>> includedViewpointType = "VP-CTX; VP-OPS; VP-REQ; VP-FUNC; VP-LOG; VP-SW; VP-PHY; VP-RISK; VP-VER; VP-CYB; VP-USE; VP-CLIN";
+
+        attribute :>> excludedKind = "";
+        attribute :>> description = "Comprehensive default methodology — includes all architecture layers, supported standards, artifact kinds, and viewpoint types. No GPCA-specific subtraction.";
+    }
+
+    part gpcaProjectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-001";
+        attribute :>> name = "GPCAProjectMethodBinding";
+        attribute :>> projectName = "GPCA";
+    }
+
+    part rmpDoc : DhfDocumentBinding {
+        attribute :>> id = "DHF-001";
+        attribute :>> name = "RiskManagementPlan";
+        attribute :>> documentTitle = "Risk Management Plan";
+        attribute :>> groupLabel = "Risk Management";
+        attribute :>> templateId = "iso-14971/rmp";
+        attribute :>> viewKind = "RMF";
+        attribute :>> regulatoryReference = "ISO 14971";
+        attribute :>> lifecycleStage = WorkflowStageKind::risk;
+        attribute :>> required = true;
+    }
+
+    part harDoc : DhfDocumentBinding {
+        attribute :>> id = "DHF-002";
+        attribute :>> name = "HazardAnalysisReport";
+        attribute :>> documentTitle = "Hazard Analysis Report";
+        attribute :>> groupLabel = "Risk Management";
+        attribute :>> templateId = "iso-14971/har";
+        attribute :>> viewKind = "RMF";
+        attribute :>> regulatoryReference = "ISO 14971";
+        attribute :>> lifecycleStage = WorkflowStageKind::risk;
+        attribute :>> required = true;
+    }
+
+    part sadDoc : DhfDocumentBinding {
+        attribute :>> id = "DHF-003";
+        attribute :>> name = "SoftwareArchitectureDescription";
+        attribute :>> documentTitle = "Software Architecture Description";
+        attribute :>> groupLabel = "Software";
+        attribute :>> templateId = "iec-62304/sad";
+        attribute :>> viewKind = "ArchitectureDescription";
+        attribute :>> regulatoryReference = "IEC 62304";
+        attribute :>> lifecycleStage = WorkflowStageKind::architecture;
+        attribute :>> required = true;
+    }
+
+    part threatModelDoc : DhfDocumentBinding {
+        attribute :>> id = "DHF-004";
+        attribute :>> name = "CybersecurityThreatModel";
+        attribute :>> documentTitle = "Threat Model";
+        attribute :>> groupLabel = "Cybersecurity";
+        attribute :>> templateId = "fda-cybersecurity/threat-model";
+        attribute :>> viewKind = "ThreatModel";
+        attribute :>> regulatoryReference = "FDA Cybersecurity Guidance";
+        attribute :>> lifecycleStage = WorkflowStageKind::risk;
+        attribute :>> required = true;
+    }
+
+    part vvPlanDoc : DhfDocumentBinding {
+        attribute :>> id = "DHF-005";
+        attribute :>> name = "VerificationValidationPlan";
+        attribute :>> documentTitle = "V&V Plan";
+        attribute :>> groupLabel = "Verification & Validation";
+        attribute :>> templateId = "21cfr820/vv-plan";
+        attribute :>> viewKind = "VV";
+        attribute :>> regulatoryReference = "21 CFR 820.30";
+        attribute :>> lifecycleStage = WorkflowStageKind::verificationStage;
+        attribute :>> required = true;
+    }
+}

package/src/methodology/memo_rules.sysml

@@ -0,0 +1,15 @@
+package memo_methodology_rules {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_consistency_rules::*;
+
+    part def ElementUsageRule :> ConsistencyRule {
+        attribute elementTypeName : String;
+    }
+
+    part def RelationUsageRule :> ConsistencyRule {
+        attribute relationTypeName : String;
+    }
+}

package/src/methodology/memo_viewpoints.sysml

@@ -0,0 +1,5 @@
+package memo_methodology_viewpoints {
+    private import ScalarValues::*;
+
+    public import memo_viewpoints_definitions::*;
+}

package/src/methodology/memo_workflow.sysml

@@ -0,0 +1,14 @@
+package memo_methodology_workflow {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def WorkflowStep :> TraceableElement {
+        attribute stepOrder : Integer;
+        attribute stage : WorkflowStageKind;
+        attribute objectiveDescription : String;
+        attribute entryCriteria : String;
+        attribute exitCriteria : String;
+    }
+}

package/src/rules/closure/closure_rules.sysml

@@ -0,0 +1,180 @@
+// Closure consistency rules — native KerML constraints (Epic EE-3).
+// Migrated from the proprietary ConsistencyRule predicate-attribute parts to
+// native `constraint def` bodies whose `constraint { … }` expression is
+// evaluated directly by the KerML constraint evaluator (validator/constraint-eval.ts).
+//
+// Rule metadata (id, appliesTo subject kind, severity, rationale) travels as plain
+// attribute members; the boolean body is the rule. Per the EE-3 mapping the native
+// surface drops the legacy `direction`/`relatedKinds` qualifiers — navigation counts
+// related elements in either direction. Cross-element `uniqueAttribute` (CR-MED-012)
+// has no single-subject expression and stays an engine-level exception (see note).
+package memo_rules_closure {
+    private import ScalarValues::*;
+
+    private import memo_core_consistency_rules::*;
+    private import memo_core_enumerations::*;
+
+    // ─── Risk Layer Rules ────────────────────────────────────────────────
+
+    constraint def hazardMitigationRule {
+        attribute id = "CR-MED-001";
+        attribute appliesTo = "Hazard";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "ISO 14971 requires each identified hazard to have risk control measures.";
+        attribute predicateExpression = "mitigatesHazard->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def hazardSeverityRule {
+        attribute id = "CR-MED-002";
+        attribute appliesTo = "Hazard";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Hazard severity is required for risk estimation per ISO 14971.";
+        attribute predicateExpression = "attributes.severity != \"\"";
+        constraint { true }
+    }
+
+    constraint def riskControlVerificationRule {
+        attribute id = "CR-MED-003";
+        attribute appliesTo = "RiskControl";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Risk controls shall be verified per ISO 14971 clause 7.4.";
+        attribute predicateExpression = "verifiedBy->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def riskBeforeMatrixRule {
+        attribute id = "CR-MED-004";
+        attribute appliesTo = "RiskBeforeMitigation";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Pre-mitigation risk must be assessed against a risk acceptability matrix.";
+        attribute predicateExpression = "assessedAgainst->size() >= 1";
+        constraint { true }
+    }
+
+    // ─── Requirements Layer Rules ────────────────────────────────────────
+
+    constraint def sysReqTraceRule {
+        attribute id = "CR-MED-010";
+        attribute appliesTo = "SystemRequirement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Requirements shall be traceable to stakeholder needs per ISO 13485.";
+        attribute predicateExpression = "derivesFrom->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def swReqTraceRule {
+        attribute id = "CR-MED-011";
+        attribute appliesTo = "SoftwareRequirement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Software requirements derive from system requirements per IEC 62304.";
+        attribute predicateExpression = "derivesFrom->size() >= 1";
+        constraint { true }
+    }
+
+    // CR-MED-012 (RequirementIdMustBeUnique) is intentionally omitted from the native
+    // constraint set: cross-element uniqueness is not a single-subject predicate and
+    // cannot be expressed as a `constraint { … }` body over one Requirement.
+    // It remains an engine-level check (future model-level constraint support).
+    // Do not reintroduce the `predicate="uniqueAttribute"` part.
+
+    // ─── Architecture Layer Rules ────────────────────────────────────────
+
+    constraint def swComponentSafetyClassRule {
+        attribute id = "CR-MED-020";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "IEC 62304 requires safety classification for all software items.";
+        attribute predicateExpression = "attributes.safetyClass != \"\"";
+        constraint { true }
+    }
+
+    constraint def swComponentReqRule {
+        attribute id = "CR-MED-021";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Software items shall be linked to their requirements per IEC 62304.";
+        attribute predicateExpression = "satisfiedBy->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def logicalFunctionAllocationRule {
+        attribute id = "CR-MED-022";
+        attribute appliesTo = "LogicalFunction";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Functions should be allocated to implementation elements.";
+        attribute predicateExpression = "allocatedTo->size() >= 1";
+        constraint { true }
+    }
+
+    // ─── Verification Layer Rules ────────────────────────────────────────
+
+    constraint def verificationCaseMethodRule {
+        attribute id = "CR-MED-030";
+        attribute appliesTo = "VerificationCase";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Verification method (test, analysis, inspection, demonstration) required per IEC 62304.";
+        attribute predicateExpression = "attributes.methodKind != \"\"";
+        constraint { true }
+    }
+
+    constraint def verificationCaseTargetRule {
+        attribute id = "CR-MED-031";
+        attribute appliesTo = "VerificationCase";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Verification cases must be linked to verifiable items.";
+        attribute predicateExpression = "verifiedBy->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def evidenceProductionRule {
+        attribute id = "CR-MED-032";
+        attribute appliesTo = "VerificationCase";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Verification results should be documented as evidence records.";
+        attribute predicateExpression = "producesEvidence->size() >= 1";
+        constraint { true }
+    }
+
+    // ─── Cybersecurity Layer Rules ───────────────────────────────────────
+
+    constraint def threatMitigationRule {
+        attribute id = "CR-MED-040";
+        attribute appliesTo = "Threat";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires threat mitigation.";
+        attribute predicateExpression = "derivesCyberRequirement->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def assetThreatLinkRule {
+        attribute id = "CR-MED-041";
+        attribute appliesTo = "CybersecurityAsset";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Assets should have threat analysis per FDA cybersecurity guidance.";
+        attribute predicateExpression = "threatenedBy->size() >= 1";
+        constraint { true }
+    }
+
+    // ─── Interface Rules ─────────────────────────────────────────────────
+
+    constraint def logicalInterfaceDirectionRule {
+        attribute id = "CR-MED-050";
+        attribute appliesTo = "Interface";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Interface direction required for integration analysis.";
+        attribute predicateExpression = "attributes.direction != \"\"";
+        constraint { true }
+    }
+
+    // ─── Conditional Rules ───────────────────────────────────────────────
+
+    constraint def safetyClassCVerificationRule {
+        attribute id = "CR-MED-101";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "IEC 62304 requires rigorous verification for Class C software.";
+        attribute predicateExpression = "not(attributes.safetyClass == \"C\") or verifiedBy->size() >= 1";
+        constraint { true }
+    }
+}