@memoarchitect/ontology 0.12.1 → 0.15.0

package/src/rules/closure/closure_rules.sysml

@@ -9,69 +9,96 @@ package memo_rules_closure {
 
     private import memo_core_common::*;
     private import memo_core_common::MemoIdentity;
+    private import memo_artifacts_standards_traceability::EnforcesClause;
+    private import memo_artifacts_standards_fda_cybersecurity_2023::*;
+    private import memo_artifacts_standards_iec_62304::*;
+    private import memo_artifacts_standards_iec_62366_1::*;
+    private import memo_artifacts_standards_iso_13485::*;
+    private import memo_artifacts_standards_iso_14971::*;
     // ─── Risk Layer Rules ────────────────────────────────────────────────
 
     constraint def HazardMitigationRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-001"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "ISO 14971 requires each identified hazard to have risk control measures.";
         attribute predicateExpression = "mitigates->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from HazardMitigationRule to iso14971::iso14971Clause7::iso14971Clause7_1;
 
     constraint def HazardSeverityRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-002"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
         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 }
     }
+    #EnforcesClause dependency from HazardSeverityRule to iso14971::iso14971Clause5::iso14971Clause5_5;
 
     constraint def RiskControlVerificationRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-003"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // Note: ISO 14971:2019 puts verification of the implementation and effectiveness of a risk control measure in 7.2; the rule text used to say 7.4, which is benefit-risk analysis.
         attribute appliesTo = "RiskControlMeasure";
         attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "Risk controls shall be verified per ISO 14971 clause 7.4.";
+        attribute rationaleText = "Risk controls shall be verified per ISO 14971 clause 7.2.";
         attribute predicateExpression = "verifiedBy->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from RiskControlVerificationRule to iso14971::iso14971Clause7::iso14971Clause7_2;
 
     constraint def InitialRiskMatrixRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-004"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // To confirm: inferred from the clause scope, the rule text names no clause; confirm.
         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";
         constraint { true }
     }
+    #EnforcesClause dependency from InitialRiskMatrixRule to iso14971::iso14971Clause6;
 
     // ─── Requirements Layer Rules ────────────────────────────────────────
 
     constraint def SysReqTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-010"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // To confirm: inferred from the clause scope; confirm.
         attribute appliesTo = "Requirement[requirementType=system]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Requirements shall be traceable to stakeholder needs per ISO 13485.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from SysReqTraceRule to iso13485::iso13485Clause7::iso13485Clause7_3::iso13485Clause7_3_3;
 
     constraint def SwReqTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-011"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
         attribute appliesTo = "Requirement[requirementType=software]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Software requirements derive from system requirements per IEC 62304.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from SwReqTraceRule to iec62304::iec62304Clause5::iec62304Clause5_2::iec62304Clause5_2_1;
 
     // CR-MED-012 (RequirementIdMustBeUnique) is intentionally omitted from the native
     // constraint set: cross-element uniqueness is not a single-subject predicate and
@@ -84,16 +111,21 @@ package memo_rules_closure {
     constraint def SwComponentSafetyClassRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-020"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "IEC 62304 requires safety classification for all software items.";
         attribute predicateExpression = "attributes.safetyClass != ''";
         constraint { true }
     }
+    #EnforcesClause dependency from SwComponentSafetyClassRule to iec62304::iec62304Clause4::iec62304Clause4_3;
 
     constraint def SwComponentReqRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-021"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Software items shall be linked to their requirements per IEC 62304.";
@@ -104,6 +136,8 @@ package memo_rules_closure {
     constraint def LogicalFunctionAllocationRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-022"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "SystemFunction";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Functions should be allocated to implementation elements.";
@@ -120,14 +154,22 @@ package memo_rules_closure {
     constraint def FunctionInChainRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-023"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "MemoFunction";
         attribute severity = RuleSeverityKind::warning;
-        attribute rationaleText = "A function participates in the functional chain through a flow or a succession, or through the functions it decomposes into. One that participates in none of them is unreachable behaviour: nothing triggers it and nothing consumes what it produces.";
+        attribute rationaleText = "A function participates in the functional chain through a flow or a succession, through the functions it decomposes into, or by being performed — by a functional chain, or by the action that triggers it. One that participates in none of them is unreachable behaviour: nothing triggers it and nothing consumes what it produces.";
         // `downstream` and not a bare `composes`: the relation navigates both
         // ways, so a bare name would exempt every child on the strength of
         // having a parent. A decomposed function participates through its
         // parts; a leaf has to be reached by an edge of its own.
-        attribute predicateExpression = "flow->size() >= 1 or succession->size() >= 1 or downstream(composes)->size() >= 1";
+        //
+        // `upstream(performs)`: a `perform` IS participation. A functional
+        // chain names its steps that way, and a UI action performing a
+        // function is what triggers it. Without it the rule reported gpca-pump's
+        // startup chain's own two steps, and ui-screen-regions' two functions
+        // that a control invokes, as reached by nothing.
+        attribute predicateExpression = "flow->size() >= 1 or succession->size() >= 1 or downstream(composes)->size() >= 1 or upstream(performs)->size() >= 1";
         constraint { true }
     }
 
@@ -138,18 +180,23 @@ package memo_rules_closure {
     constraint def UserNeedIdentifiesUserRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-024"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
         attribute appliesTo = "Need";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "A user need is a need someone has. Which users a device serves, and what they can be assumed to see, know and do, is the input a usability engineering file is built from (IEC 62366-1 5.1); a need that names no user leaves that input to prose.";
         attribute predicateExpression = "not(needKind == 'user' or needKind == 'clinicalUser' or needKind == 'patientUser') or heldBy->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from UserNeedIdentifiesUserRule to iec62366_1::iec62366_1Clause5::iec62366_1Clause5_1;
 
     // ─── Verification Layer Rules ────────────────────────────────────────
 
     constraint def VerificationCaseMethodRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-030"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Verification method (test, analysis, inspection, demonstration) required per IEC 62304.";
@@ -160,6 +207,8 @@ package memo_rules_closure {
     constraint def VerificationCaseTargetRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-031"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Verification cases must be linked to verifiable items.";
@@ -170,6 +219,8 @@ package memo_rules_closure {
     constraint def EvidenceProductionRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-032"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Verification results should be documented as evidence records.";
@@ -182,32 +233,42 @@ package memo_rules_closure {
     constraint def ThreatMitigationRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-040"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // To confirm: inferred from the section scope; confirm.
         attribute appliesTo = "Threat";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "FDA cybersecurity guidance requires threat mitigation.";
         attribute predicateExpression = "derivesCyberRequirement->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from ThreatMitigationRule to fdaCybersecurity2023::fdaCyberSection5::fdaCyberSection5A;
 
     constraint def AssetThreatLinkRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-041"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // To confirm: inferred from the section scope; confirm.
         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 }
     }
+    #EnforcesClause dependency from AssetThreatLinkRule to fdaCybersecurity2023::fdaCyberSection5::fdaCyberSection5A;
 
     // ─── Interface Rules ─────────────────────────────────────────────────
 
     constraint def LogicalInterfaceDirectionRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-050"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "Interface";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Interface direction required for integration analysis.";
-        attribute predicateExpression = "attributes.direction != '' or attributes.directionality != ''";
+        attribute predicateExpression = "attributes.direction != ''";
         constraint { true }
     }
 
@@ -216,12 +277,16 @@ package memo_rules_closure {
     constraint def SafetyClassCVerificationRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-101"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
         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";
+        // To confirm: inferred: 5.5.4 and 5.5.5 are the unit verification clauses that Class C adds to; confirm.
         constraint { true }
     }
+    #EnforcesClause dependency from SafetyClassCVerificationRule to iec62304::iec62304Clause5::iec62304Clause5_5::iec62304Clause5_5_4, iec62304::iec62304Clause5::iec62304Clause5_5::iec62304Clause5_5_5;
 
     // ─── UI Layout Rules ─────────────────────────────────────────────────
     //
@@ -241,6 +306,8 @@ package memo_rules_closure {
     constraint def UiElementDesignRecordRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-110"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Every functional UI element must have a design record — a requirement it satisfies or an action it triggers. Elements with formKind `decoration` are chrome and are exempt.";
@@ -255,6 +322,8 @@ package memo_rules_closure {
     constraint def ControlInvokesFunctionRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-111"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "An interactive UI element (button, selector, slider, field) should trigger a UIAction that invokes a system function; otherwise the control's purpose is not in the model. Physical controls are OperatorInterfaceElement and are covered separately.";
@@ -268,6 +337,8 @@ package memo_rules_closure {
     constraint def BoundsDetectionConfirmedRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-112"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Automatically detected bounds are a proposal until a reviewer confirms them; released UI documentation should contain no unconfirmed automatic bounds.";
@@ -280,10 +351,185 @@ package memo_rules_closure {
     constraint def ScreenCaptureProvenanceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-113"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::modelling;
+        attribute obligation = RuleObligationKind::recommended;
         attribute appliesTo = "ScreenCapture";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "A screen capture used as design or usability evidence must identify the build it was taken from and hash the image bytes, or it cannot be relied on in the DHF.";
         attribute predicateExpression = "attributes.capturedBuild != '' and attributes.imageHash != ''";
         constraint { true }
     }
+
+    // ─── Risk analysis and software lifecycle rules (clause by clause) ─────
+    // Written from the classification in plans/memo-rules-domain-trace-and-editor.md
+    // (Step 5): each checks a property the model carries, and each traces to the clause it enforces.
+
+    constraint def HazardHasSituationRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-005"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "Hazard";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A hazard is analysed through the hazardous situations it can lead to: a hazard that reaches no hazardous situation has not been analysed far enough to estimate a risk.";
+        attribute predicateExpression = "downstream(tracesRisk)->exists(conformsTo(HazardousSituation))";
+        constraint { true }
+    }
+    #EnforcesClause dependency from HazardHasSituationRule to iso14971::iso14971Clause5::iso14971Clause5_4;
+
+    constraint def SituationLeadsToHarmRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-006"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "HazardousSituation";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A hazardous situation is described by the harm it can cause; one that reaches no harm leaves the severity of the risk unestimated.";
+        attribute predicateExpression = "downstream(tracesRisk)->exists(conformsTo(Harm))";
+        constraint { true }
+    }
+    #EnforcesClause dependency from SituationLeadsToHarmRule to iso14971::iso14971Clause5::iso14971Clause5_4;
+
+    constraint def RiskEstimateRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-007"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "Risk";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A risk is estimated from the probability of occurrence and the severity of the harm; a risk missing either has no estimate.";
+        attribute predicateExpression = "attributes.probabilityEstimate != '' and attributes.severityEstimate != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from RiskEstimateRule to iso14971::iso14971Clause5::iso14971Clause5_5;
+
+    constraint def RiskAcceptabilityRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-008"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "Risk";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Each estimated risk is evaluated against the acceptability criteria, so a risk states whether it is acceptable.";
+        attribute predicateExpression = "attributes.acceptability != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from RiskAcceptabilityRule to iso14971::iso14971Clause6;
+
+    constraint def ResidualRiskAcceptabilityRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-009"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "ResidualRisk";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "After risk control the residual risk is evaluated: it follows a control and states whether it is acceptable.";
+        attribute predicateExpression = "reducedBy->size() >= 1 and attributes.acceptability != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from ResidualRiskAcceptabilityRule to iso14971::iso14971Clause7::iso14971Clause7_3;
+
+    constraint def ResidualRiskEvaluatedRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-014"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "ResidualRisk";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "The overall residual risk is evaluated from the individual residual risks, so each residual risk is an input to that evaluation.";
+        attribute predicateExpression = "evaluatedIn->size() >= 1";
+        constraint { true }
+    }
+    #EnforcesClause dependency from ResidualRiskEvaluatedRule to iso14971::iso14971Clause8;
+
+    constraint def SoupAnomaliesRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-015"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "SOUPSoftwareModule";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "The published anomaly list of a SOUP item is evaluated for anomalies that could lead to a hazardous situation, and the result is recorded on the item.";
+        attribute predicateExpression = "attributes.knownAnomalies != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from SoupAnomaliesRule to iec62304::iec62304Clause7::iec62304Clause7_1::iec62304Clause7_1_3;
+
+    constraint def SoupIdentifiedRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-016"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "SOUPSoftwareModule";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A SOUP item is identified under configuration management by its title, manufacturer and version, so a SOUP item states a vendor and a version.";
+        attribute predicateExpression = "attributes.version != '' and attributes.supplier != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from SoupIdentifiedRule to iec62304::iec62304Clause8::iec62304Clause8_1::iec62304Clause8_1_2;
+
+    constraint def SoupRequirementRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-017"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "SOUPSoftwareModule";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "The functional and performance a software item needs from a SOUP item are stated as requirements, so a SOUP item is the subject of at least one requirement.";
+        attribute predicateExpression = "satisfiedBy->size() >= 1";
+        constraint { true }
+    }
+    #EnforcesClause dependency from SoupRequirementRule to iec62304::iec62304Clause5::iec62304Clause5_3::iec62304Clause5_3_3;
+
+    constraint def UnitDecompositionRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-018"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "SoftwareModule";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A software item of safety class B or C is subdivided into software units, so such an item contains at least one module of kind unit.";
+        attribute predicateExpression = "not(attributes.moduleKind == 'item' and (attributes.safetyClass == 'B' or attributes.safetyClass == 'C')) or downstream(composes)->exists(attributes.moduleKind == 'unit')";
+        constraint { true }
+    }
+    #EnforcesClause dependency from UnitDecompositionRule to iec62304::iec62304Clause5::iec62304Clause5_4::iec62304Clause5_4_1;
+
+    constraint def ChangeImpactRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-019"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "ChangeRequest";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A change request is analysed for its effect on the organisation, the released software and the systems that interface with it, and the analysis is recorded on the request.";
+        attribute predicateExpression = "attributes.impactAssessment != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from ChangeImpactRule to iec62304::iec62304Clause6::iec62304Clause6_2::iec62304Clause6_2_3;
+
+    constraint def ChangeApprovalRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-025"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "ChangeRequest";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A change request records whether it was approved before the change is made.";
+        attribute predicateExpression = "attributes.approvalStatus != ''";
+        constraint { true }
+    }
+    #EnforcesClause dependency from ChangeApprovalRule to iec62304::iec62304Clause6::iec62304Clause6_2::iec62304Clause6_2_4, iec62304::iec62304Clause8::iec62304Clause8_2::iec62304Clause8_2_1;
+
+    constraint def ChangeTraceRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-026"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        attribute appliesTo = "ChangeRequest";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A change request is traceable to the items it changes, so it has a changes relation to at least one element.";
+        attribute predicateExpression = "changes->size() >= 1";
+        constraint { true }
+    }
+    #EnforcesClause dependency from ChangeTraceRule to iec62304::iec62304Clause8::iec62304Clause8_2::iec62304Clause8_2_4;
 }

package/src/rules/crosslayer/cross_layer_rules.sysml

@@ -8,24 +8,35 @@ package memo_rules_crosslayer {
 
     private import memo_core_common::*;
     private import memo_core_common::MemoIdentity;
+    private import memo_artifacts_standards_traceability::EnforcesClause;
+    private import memo_artifacts_standards_iec_62304::*;
+    private import memo_artifacts_standards_iso_14971::*;
     constraint def RiskToReqTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "XL-001"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // To confirm: inferred from the clause scopes; confirm.
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Risk-requirement traceability required for regulatory submissions.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from RiskToReqTraceRule to iso14971::iso14971Clause7::iso14971Clause7_2, iec62304::iec62304Clause5::iec62304Clause5_2::iec62304Clause5_2_3;
 
     constraint def ReqToArchTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "XL-002"; }
         attribute tailoring = RuleTailoringKind::assurance;
+        attribute domain = RuleDomainKind::medicalDevice;
+        attribute obligation = RuleObligationKind::required;
+        // To confirm: inferred from the clause scope; confirm.
         attribute appliesTo = "Requirement[requirementType=system]";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Requirements-to-architecture traceability per IEC 62304.";
         attribute predicateExpression = "satisfiedBy->size() >= 1";
         constraint { true }
     }
+    #EnforcesClause dependency from ReqToArchTraceRule to iec62304::iec62304Clause5::iec62304Clause5_3::iec62304Clause5_3_1;
 
 }