@memoarchitect/ontology 0.4.6 → 0.6.0

package/src/methodology/{memo_core.sysml → core/memo_core.sysml}

@@ -4,35 +4,41 @@ package memo_methodology_core {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def MethodologyLibrary :> TraceableElement {
+    part def MethodologyLibrary :> MemoPart {
         attribute version : String;
         attribute domain : String;
         attribute :>> description : String;
     }
 
-    part def MethodologyDefinition :> TraceableElement {
+    part def MethodologyDefinition :> MemoPart {
         attribute version : String;
         attribute domain : String;
         attribute :>> description : String;
         attribute baseMethodName : String;
+        // A methodology is an inclusion set. Layer entries normally name a
+        // public MEMO layer namespace; module entries may name any qualified
+        // package available to the project, including packages outside MEMO.
+        attribute includedLayer : String[0..*];
+        attribute includedModule : String[0..*];
     }
 
-    part def ResolvedMethodology :> TraceableElement {
+    part def ResolvedMethodology :> MemoPart {
         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;
+        // The effective inclusion set after the project binding has added any
+        // project- or supplier-specific modules.
+        attribute includedLayer : String[0..*];
+        attribute includedModule : String[0..*];
     }
 
-    part def ProjectMethodBinding :> TraceableElement {
+    part def ProjectMethodBinding :> MemoPart {
         attribute projectName : String;
+        attribute methodologyName : String;
+        // Project bindings may add project or supplier modules to the selected
+        // methodology without requiring those packages to live under memo::.
+        attribute includedModule : String[0..*];
     }
 
-    part def DhfDocumentBinding :> TraceableElement {
+    part def DhfDocumentBinding :> MemoPart {
         attribute documentTitle : String;
         attribute groupLabel : String;
         attribute templateId : String;
@@ -42,7 +48,7 @@ package memo_methodology_core {
         attribute required : Boolean;
     }
 
-    part def Archetype :> TraceableElement {
+    part def Archetype :> MemoPart {
         attribute label : String;
         attribute :>> description : String;
         attribute category : String;

package/src/methodology/{memo_gates.sysml → gates/memo_gates.sysml}

@@ -4,7 +4,7 @@ package memo_methodology_gates {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def QualityGate :> TraceableElement {
+    part def QualityGate :> MemoPart {
         attribute gateStage : WorkflowStageKind;
         attribute passCriteria : String;
     }

package/src/methodology/{memo_patterns.sysml → patterns/memo_patterns.sysml}

@@ -4,7 +4,7 @@ package memo_methodology_patterns {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def ModelingPattern :> TraceableElement {
+    part def ModelingPattern :> MemoPart {
         attribute intent : String;
         attribute stage : WorkflowStageKind;
         attribute strength : RuleStrengthKind;

package/src/methodology/{memo_profiles.sysml → profiles/memo_profiles.sysml}

@@ -2,7 +2,6 @@ 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::*;
@@ -25,39 +24,30 @@ package memo_methodology_profiles {
         attribute :>> domain = "medical device modeling";
         attribute :>> description = "Light default methodology around the ontology for smaller or early project use.";
         attribute :>> baseMethodName = "";
+        attribute :>> includedLayer = "memo::architecture::operational";
+        attribute :>> includedLayer = "memo::architecture::functional";
+        attribute :>> includedLayer = "memo::architecture::logical";
+        attribute :>> includedModule = "memo::assurance::requirements";
+        attribute :>> includedModule = "memo::assurance::safety_risk";
+        attribute :>> includedModule = "memo::assurance::verification_validation";
     }
 
     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.";
+        attribute :>> includedLayer = "memo::architecture::operational";
+        attribute :>> includedLayer = "memo::architecture::functional";
+        attribute :>> includedLayer = "memo::architecture::logical";
+        attribute :>> includedModule = "memo::assurance::requirements";
+        attribute :>> includedModule = "memo::assurance::safety_risk";
+        attribute :>> includedModule = "memo::assurance::verification_validation";
     }
 
-    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 {
+    part useRiskAndResidualRule : ElementUsageRule {
         attribute :>> id = "RULE-001";
-        attribute :>> name = "UseRiskBeforeAfter";
-        attribute :>> elementTypeName = "RiskBeforeMitigation,RiskAfterMitigation,RiskMatrix";
+        attribute :>> name = "UseRiskAndResidualRisk";
+        attribute :>> elementTypeName = "Risk,ResidualRisk,RiskMatrix";
         attribute :>> strength = RuleStrengthKind::recommended;
         attribute :>> rationaleText = "Even a light methodology should distinguish pre- and post-mitigation risk and assess against a matrix.";
     }
@@ -138,22 +128,24 @@ package memo_methodology_profiles {
         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.";
+        attribute :>> includedArchLayer = "memo::architecture::operational";
+        attribute :>> includedArchLayer = "memo::architecture::functional";
+        attribute :>> includedArchLayer = "memo::architecture::logical";
+        attribute :>> includedArchLayer = "memo::architecture::implementation";
+        attribute :>> includedArchLayer = "memo::architecture::realization";
+        attribute :>> includedModule = "memo::assurance::requirements";
+        attribute :>> includedModule = "memo::assurance::safety_risk";
+        attribute :>> includedModule = "memo::assurance::cybersecurity";
+        attribute :>> includedModule = "memo::assurance::human_factors";
+        attribute :>> includedModule = "memo::assurance::verification_validation";
+        attribute :>> description = "Comprehensive default MEMO layer and module selection.";
     }
 
     part gpcaProjectBinding : ProjectMethodBinding {
         attribute :>> id = "PMB-001";
         attribute :>> name = "GPCAProjectMethodBinding";
         attribute :>> projectName = "GPCA";
+        attribute :>> methodologyName = "MedicalDeviceLightDefault";
     }
 
     part rmpDoc : DhfDocumentBinding {

package/src/methodology/{memo_workflow.sysml → workflow/memo_workflow.sysml}

@@ -4,7 +4,7 @@ package memo_methodology_workflow {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def WorkflowStep :> TraceableElement {
+    part def WorkflowStep :> MemoPart {
         attribute stepOrder : Integer;
         attribute stage : WorkflowStageKind;
         attribute objectiveDescription : String;

package/src/rules/closure/closure_rules.sysml

@@ -21,7 +21,7 @@ package memo_rules_closure {
         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";
+        attribute predicateExpression = "mitigates->size() >= 1";
         constraint { true }
     }
 
@@ -36,16 +36,16 @@ package memo_rules_closure {
 
     constraint def riskControlVerificationRule {
         attribute id = "CR-MED-003";
-        attribute appliesTo = "RiskControl";
+        attribute appliesTo = "RiskControlMeasure";
         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 {
+    constraint def initialRiskMatrixRule {
         attribute id = "CR-MED-004";
-        attribute appliesTo = "RiskBeforeMitigation";
+        attribute appliesTo = "Risk";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Pre-mitigation risk must be assessed against a risk acceptability matrix.";
         attribute predicateExpression = "assessedAgainst->size() >= 1";
@@ -56,7 +56,7 @@ package memo_rules_closure {
 
     constraint def sysReqTraceRule {
         attribute id = "CR-MED-010";
-        attribute appliesTo = "SystemRequirement";
+        attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Requirements shall be traceable to stakeholder needs per ISO 13485.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
@@ -65,7 +65,7 @@ package memo_rules_closure {
 
     constraint def swReqTraceRule {
         attribute id = "CR-MED-011";
-        attribute appliesTo = "SoftwareRequirement";
+        attribute appliesTo = "Requirement[requirementKind=software]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Software requirements derive from system requirements per IEC 62304.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
@@ -75,14 +75,14 @@ package memo_rules_closure {
     // 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).
+    // It remains an engine-level check.
     // Do not reintroduce the `predicate="uniqueAttribute"` part.
 
     // ─── Architecture Layer Rules ────────────────────────────────────────
 
     constraint def swComponentSafetyClassRule {
         attribute id = "CR-MED-020";
-        attribute appliesTo = "SoftwareComponent";
+        attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "IEC 62304 requires safety classification for all software items.";
         attribute predicateExpression = "attributes.safetyClass != \"\"";
@@ -91,7 +91,7 @@ package memo_rules_closure {
 
     constraint def swComponentReqRule {
         attribute id = "CR-MED-021";
-        attribute appliesTo = "SoftwareComponent";
+        attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Software items shall be linked to their requirements per IEC 62304.";
         attribute predicateExpression = "satisfiedBy->size() >= 1";
@@ -100,7 +100,7 @@ package memo_rules_closure {
 
     constraint def logicalFunctionAllocationRule {
         attribute id = "CR-MED-022";
-        attribute appliesTo = "LogicalFunction";
+        attribute appliesTo = "SystemFunction";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Functions should be allocated to implementation elements.";
         attribute predicateExpression = "allocatedTo->size() >= 1";
@@ -171,7 +171,7 @@ package memo_rules_closure {
 
     constraint def safetyClassCVerificationRule {
         attribute id = "CR-MED-101";
-        attribute appliesTo = "SoftwareComponent";
+        attribute appliesTo = "SoftwareModule";
         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";

package/src/rules/coverage/coverage_rules.sysml

@@ -54,34 +54,34 @@ package memo_rules_coverage {
 
     constraint def iec62304SwArchCoverage {
         attribute id = "COV-62304-001";
-        attribute appliesTo = "SoftwareComponent";
+        attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "IEC 62304 clause 5.3 requires software architecture.";
         attribute standardReference = "IEC 62304";
         attribute clause = "5.3";
-        attribute coverageTarget = "SoftwareComponent";
+        attribute coverageTarget = "SoftwareModule";
     }
 
     constraint def iec62304SwReqCoverage {
         attribute id = "COV-62304-002";
-        attribute appliesTo = "SoftwareRequirement";
+        attribute appliesTo = "Requirement[requirementKind=software]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "IEC 62304 clause 5.2 requires software requirements specification.";
         attribute standardReference = "IEC 62304";
         attribute clause = "5.2";
-        attribute coverageTarget = "SoftwareRequirement";
+        attribute coverageTarget = "Requirement[requirementKind=software]";
     }
 
     // ─── FDA 21 CFR 820: Quality System ──────────────────────────────────
 
     constraint def fda820DesignInputCoverage {
         attribute id = "COV-820-001";
-        attribute appliesTo = "SystemRequirement";
+        attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "21 CFR 820.30(c) requires design inputs including requirements.";
         attribute standardReference = "FDA 21 CFR 820";
         attribute clause = "820.30(c)";
-        attribute coverageTarget = "SystemRequirement";
+        attribute coverageTarget = "Requirement[requirementKind=system]";
     }
 
     constraint def fda820DesignVerificationCoverage {
@@ -98,12 +98,12 @@ package memo_rules_coverage {
 
     constraint def iso13485StakeholderNeedCoverage {
         attribute id = "COV-13485-001";
-        attribute appliesTo = "StakeholderNeed";
+        attribute appliesTo = "Need[needKind=stakeholder]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "ISO 13485 clause 7.2 requires determination of customer requirements.";
         attribute standardReference = "ISO 13485";
         attribute clause = "7.2";
-        attribute coverageTarget = "StakeholderNeed";
+        attribute coverageTarget = "Need[needKind=stakeholder]";
     }
 
     // ─── ISO 14155: Clinical Investigations ──────────────────────────────

package/src/rules/crosslayer/cross_layer_rules.sysml

@@ -1,4 +1,4 @@
-// C4 cross-layer rule pack — native KerML constraints (Epic EE-3).
+// Cross-layer rule pack — native KerML constraints.
 // Traceability between architecture layers, migrated from ConsistencyRule
 // predicate-attribute parts to native `constraint def` bodies.
 package memo_rules_crosslayer {
@@ -18,7 +18,7 @@ package memo_rules_crosslayer {
 
     constraint def reqToArchTraceRule {
         attribute id = "XL-002";
-        attribute appliesTo = "SystemRequirement";
+        attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Requirements-to-architecture traceability per IEC 62304.";
         attribute predicateExpression = "satisfiedBy->size() >= 1";

package/src/rules/lifecycle/lifecycle_rules.sysml

@@ -17,7 +17,7 @@ package memo_rules_lifecycle {
 
     constraint def reqBeforeArchRule {
         attribute id = "LC-001";
-        attribute appliesTo = "SoftwareComponent";
+        attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "IEC 62304 requires requirements to precede architecture decomposition.";
         // Lifecycle ordering — model-level, no single-subject predicate.

package/src/rules/ontology/ontology_invariants.sysml

@@ -0,0 +1,133 @@
+// Ontology conformance invariants (§25, 0.5 rework). Same native pattern as
+// memo_rules_closure: `constraint def` bodies with declarative rule metadata
+// (`predicateExpression`) evaluated by the external constraint engine.
+// Structural invariants (endpoint existence, cycle freedom) are expressed over
+// the typed relations introduced in 0.5 — typed references make them checkable.
+package memo_rules_ontology {
+    private import ScalarValues::*;
+
+    private import memo_core_consistency_rules::*;
+    private import memo_core_enumerations::*;
+
+    // ─── Structure ───────────────────────────────────────────────────────
+
+    constraint def containmentAcyclicRule {
+        attribute id = "CR-ONT-001";
+        attribute appliesTo = "MemoPart";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Containment/composition relations (Composes) must form no cycles.";
+        attribute predicateExpression = "acyclic(composes)";
+        constraint { true }
+    }
+    constraint def connectorEndpointsExistRule {
+        attribute id = "CR-ONT-002";
+        attribute appliesTo = "ComponentExchange";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Connector endpoints must resolve to model elements via the typed refs sourceEndpoint/targetEndpoint; port-path strings are descriptive labels only.";
+        attribute predicateExpression = "sourceEndpoint->size() = 1 and targetEndpoint->size() = 1";
+        constraint { true }
+    }
+    constraint def portCompatibilityRule {
+        attribute id = "CR-ONT-003";
+        attribute appliesTo = "LogicalConnector";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Connected ports must agree on content kind; a fluid port cannot connect to an information port.";
+        attribute predicateExpression = "sourceComponent.ports.contentKind->intersect(targetComponent.ports.contentKind)->size() >= 1";
+        constraint { true }
+    }
+    constraint def directionAgreesWithFlowRule {
+        attribute id = "CR-ONT-004";
+        attribute appliesTo = "LogicalExchange";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Exchange direction must agree with the direction of its source and target ports.";
+        attribute predicateExpression = "sourcePort.direction != DirectionKind::input and targetPort.direction != DirectionKind::output";
+        constraint { true }
+    }
+    constraint def exchangedItemTypeRule {
+        attribute id = "CR-ONT-005";
+        attribute appliesTo = "LogicalExchange";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Exchanged items must be type-compatible with the exchange content kind.";
+        attribute predicateExpression = "exchangedItem->isEmpty() or exchangedItem.contentKind = contentKind";
+        constraint { true }
+    }
+
+    // ─── Deployment and realization ──────────────────────────────────────
+
+    constraint def deployToCapableNodeRule {
+        attribute id = "CR-ONT-010";
+        attribute appliesTo = "DeploysTo";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Software deploys only to capable execution nodes (e.g. containerized units require supportsContainerization).";
+        attribute predicateExpression = "deploymentKind != DeploymentKind::containerized or node.supportsContainerization = true";
+        constraint { true }
+    }
+    constraint def runtimeTracesToModuleRule {
+        attribute id = "CR-ONT-011";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Every runtime component must trace to a module-view definition (Realizes).";
+        attribute predicateExpression = "realizes->size() >= 1";
+        constraint { true }
+    }
+    constraint def logicalRealizationTypedRule {
+        attribute id = "CR-ONT-012";
+        attribute appliesTo = "Realizes";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Realization relations must resolve both ends to model elements, not name strings.";
+        attribute predicateExpression = "realizing->size() = 1 and realized->size() = 1";
+        constraint { true }
+    }
+
+    constraint def patientContactCharacterizedRule {
+        attribute id = "CR-ONT-032";
+        attribute appliesTo = "PhysicalComponent";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Patient-contact components must identify contact nature and duration (ISO 10993-1).";
+        attribute predicateExpression = "patientContact = false or (contactNature != '' and contactDuration != '')";
+        constraint { true }
+    }
+
+    // ─── Assurance coverage ──────────────────────────────────────────────
+
+    constraint def safetyCriticalFunctionVerifiedRule {
+        attribute id = "CR-ONT-040";
+        attribute appliesTo = "SystemFunction";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Safety-critical functions (criticality high or catastrophic) must trace to at least one verification case.";
+        attribute predicateExpression = "criticality < CriticalityKind::high or verifiedBy->size() >= 1";
+        constraint { true }
+    }
+    constraint def criticalTaskValidatedRule {
+        attribute id = "CR-ONT-041";
+        attribute appliesTo = "UserTask[criticality=high]";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Critical tasks (criticality high or catastrophic) must trace to usability validation (FDA HF guidance; IEC 62366-1 summative evaluation).";
+        attribute predicateExpression = "criticality < CriticalityKind::high or validates->size() >= 1";
+        constraint { true }
+    }
+    constraint def useErrorTracesToHazardRule {
+        attribute id = "CR-ONT-042";
+        attribute appliesTo = "UseError";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Safety-relevant use errors (severity serious or worse) must trace to a hazard.";
+        attribute predicateExpression = "severity < SeverityKind::serious or causes->size() >= 1";
+        constraint { true }
+    }
+    constraint def alternateScenarioHasBaseRule {
+        attribute id = "CR-ONT-043";
+        attribute appliesTo = "MemoScenario";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Alternate, exception, and recovery scenarios must identify their base scenario or variation point — never duplicate the workflow.";
+        attribute predicateExpression = "variantKind = ScenarioVariantKind::nominal or baseScenario->size() = 1 or variationPoint != ''";
+        constraint { true }
+    }
+    constraint def singleAxisOwnershipRule {
+        attribute id = "CR-ONT-045";
+        attribute appliesTo = "MemoPart";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Every element is owned by exactly one axis, encoded by its owning package: a horizontal architecture layer (memo_architecture_*) XOR a vertical assurance discipline (memo_assurance_*) — never both. Cross-axis participation is expressed by typed relationships, not by dual membership.";
+        attribute predicateExpression = "owningPackage.startsWith('memo_architecture_') xor owningPackage.startsWith('memo_assurance_')";
+        constraint { true }
+    }
+}

package/src/rules/quantitative/quantitative_rules.sysml

@@ -13,13 +13,13 @@ package memo_rules_quantitative {
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::info;
         attribute rationaleText = "Excessive controls per hazard suggests the hazard is too broad and should be decomposed.";
-        attribute predicateExpression = "mitigatesHazard->size() >= 0 and mitigatesHazard->size() <= 10";
+        attribute predicateExpression = "mitigates->size() >= 0 and mitigates->size() <= 10";
         constraint { true }
     }
 
     constraint def swComponentMaxInterfacesRule {
         attribute id = "QT-002";
-        attribute appliesTo = "SoftwareComponent";
+        attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::info;
         attribute rationaleText = "High interface count indicates excessive coupling; consider decomposition.";
         attribute predicateExpression = "threatenedBy->size() >= 0 and threatenedBy->size() <= 8";