@memoarchitect/ontology 0.8.22 → 0.10.9

package/src/rules/closure/closure_rules.sysml

@@ -7,10 +7,12 @@ package memo_rules_closure {
     private import memo_core_consistency_rules::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     // ─── Risk Layer Rules ────────────────────────────────────────────────
 
     constraint def HazardMitigationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-001";
+        @MemoIdentity { :>> providedId = "CR-MED-001"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
@@ -20,7 +22,7 @@ package memo_rules_closure {
     }
 
     constraint def HazardSeverityRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-002";
+        @MemoIdentity { :>> providedId = "CR-MED-002"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
@@ -30,7 +32,7 @@ package memo_rules_closure {
     }
 
     constraint def RiskControlVerificationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-003";
+        @MemoIdentity { :>> providedId = "CR-MED-003"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "RiskControlMeasure";
         attribute severity = RuleSeverityKind::error;
@@ -40,7 +42,7 @@ package memo_rules_closure {
     }
 
     constraint def InitialRiskMatrixRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-004";
+        @MemoIdentity { :>> providedId = "CR-MED-004"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Risk";
         attribute severity = RuleSeverityKind::warning;
@@ -52,7 +54,7 @@ package memo_rules_closure {
     // ─── Requirements Layer Rules ────────────────────────────────────────
 
     constraint def SysReqTraceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-010";
+        @MemoIdentity { :>> providedId = "CR-MED-010"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::error;
@@ -62,7 +64,7 @@ package memo_rules_closure {
     }
 
     constraint def SwReqTraceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-011";
+        @MemoIdentity { :>> providedId = "CR-MED-011"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=software]";
         attribute severity = RuleSeverityKind::error;
@@ -80,7 +82,7 @@ package memo_rules_closure {
     // ─── Architecture Layer Rules ────────────────────────────────────────
 
     constraint def SwComponentSafetyClassRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-020";
+        @MemoIdentity { :>> providedId = "CR-MED-020"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
@@ -90,7 +92,7 @@ package memo_rules_closure {
     }
 
     constraint def SwComponentReqRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-021";
+        @MemoIdentity { :>> providedId = "CR-MED-021"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::warning;
@@ -100,7 +102,7 @@ package memo_rules_closure {
     }
 
     constraint def LogicalFunctionAllocationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-022";
+        @MemoIdentity { :>> providedId = "CR-MED-022"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SystemFunction";
         attribute severity = RuleSeverityKind::warning;
@@ -112,7 +114,7 @@ package memo_rules_closure {
     // ─── Verification Layer Rules ────────────────────────────────────────
 
     constraint def VerificationCaseMethodRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-030";
+        @MemoIdentity { :>> providedId = "CR-MED-030"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
@@ -122,7 +124,7 @@ package memo_rules_closure {
     }
 
     constraint def VerificationCaseTargetRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-031";
+        @MemoIdentity { :>> providedId = "CR-MED-031"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
@@ -132,7 +134,7 @@ package memo_rules_closure {
     }
 
     constraint def EvidenceProductionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-032";
+        @MemoIdentity { :>> providedId = "CR-MED-032"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::warning;
@@ -144,7 +146,7 @@ package memo_rules_closure {
     // ─── Cybersecurity Layer Rules ───────────────────────────────────────
 
     constraint def ThreatMitigationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-040";
+        @MemoIdentity { :>> providedId = "CR-MED-040"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Threat";
         attribute severity = RuleSeverityKind::error;
@@ -154,7 +156,7 @@ package memo_rules_closure {
     }
 
     constraint def AssetThreatLinkRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-041";
+        @MemoIdentity { :>> providedId = "CR-MED-041"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "CybersecurityAsset";
         attribute severity = RuleSeverityKind::warning;
@@ -166,7 +168,7 @@ package memo_rules_closure {
     // ─── Interface Rules ─────────────────────────────────────────────────
 
     constraint def LogicalInterfaceDirectionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-050";
+        @MemoIdentity { :>> providedId = "CR-MED-050"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Interface";
         attribute severity = RuleSeverityKind::error;
@@ -178,7 +180,7 @@ package memo_rules_closure {
     // ─── Conditional Rules ───────────────────────────────────────────────
 
     constraint def SafetyClassCVerificationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-101";
+        @MemoIdentity { :>> providedId = "CR-MED-101"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
@@ -203,7 +205,7 @@ package memo_rules_closure {
     // triggers. Chrome must be DECLARED `decoration`; an element left
     // unclassified fails rather than passing as scenery.
     constraint def UiElementDesignRecordRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-110";
+        @MemoIdentity { :>> providedId = "CR-MED-110"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::error;
@@ -217,7 +219,7 @@ package memo_rules_closure {
     // The interactive-form restriction lives in the predicate because it spans
     // several enum values.
     constraint def ControlInvokesFunctionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-111";
+        @MemoIdentity { :>> providedId = "CR-MED-111"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
@@ -230,7 +232,7 @@ package memo_rules_closure {
     // unconfirmed machine guess must never reach a design review looking like
     // an engineering decision.
     constraint def BoundsDetectionConfirmedRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-112";
+        @MemoIdentity { :>> providedId = "CR-MED-112"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
@@ -242,7 +244,7 @@ package memo_rules_closure {
     // A screenshot with no build behind it is undated design intent, not
     // evidence of what the device does.
     constraint def ScreenCaptureProvenanceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-113";
+        @MemoIdentity { :>> providedId = "CR-MED-113"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "ScreenCapture";
         attribute severity = RuleSeverityKind::error;

package/src/rules/crosslayer/cross_layer_rules.sysml

@@ -6,8 +6,10 @@ package memo_rules_crosslayer {
     private import memo_core_consistency_rules::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     constraint def RiskToReqTraceRule :> MemoConsistencyRule {
-        attribute id = "XL-001";
+        @MemoIdentity { :>> providedId = "XL-001"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::warning;
@@ -17,7 +19,7 @@ package memo_rules_crosslayer {
     }
 
     constraint def ReqToArchTraceRule :> MemoConsistencyRule {
-        attribute id = "XL-002";
+        @MemoIdentity { :>> providedId = "XL-002"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::warning;

package/src/rules/ontology/ontology_invariants.sysml

@@ -9,10 +9,12 @@ package memo_rules_ontology {
     private import memo_core_consistency_rules::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     // ─── Structure ───────────────────────────────────────────────────────
 
     constraint def ContainmentAcyclicRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-001";
+        @MemoIdentity { :>> providedId = "CR-ONT-001"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -21,7 +23,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def NestedPartConnectedRule :> MemoConsistencyRule {
-        attribute id = "AR-IBD-001";
+        @MemoIdentity { :>> providedId = "AR-IBD-001"; }
         attribute tailoring = RuleTailoringKind::invariant;
         // Internal-block connectivity is a structural-architecture concern, so
         // the subject is the structural component — not every MemoPart. UI
@@ -44,7 +46,7 @@ package memo_rules_ontology {
     // ─── Deployment and realization ──────────────────────────────────────
 
     constraint def RuntimeTracesToModuleRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-011";
+        @MemoIdentity { :>> providedId = "CR-ONT-011"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "SoftwareComponent";
         attribute severity = RuleSeverityKind::warning;
@@ -53,7 +55,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def PatientContactCharacterizedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-032";
+        @MemoIdentity { :>> providedId = "CR-ONT-032"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "PhysicalComponent";
         attribute severity = RuleSeverityKind::error;
@@ -65,7 +67,7 @@ package memo_rules_ontology {
     // ─── Assurance coverage ──────────────────────────────────────────────
 
     constraint def SafetyCriticalFunctionVerifiedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-040";
+        @MemoIdentity { :>> providedId = "CR-ONT-040"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "MemoFunction";
         attribute severity = RuleSeverityKind::error;
@@ -74,16 +76,16 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def CriticalTaskValidatedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-041";
+        @MemoIdentity { :>> providedId = "CR-ONT-041"; }
         attribute tailoring = RuleTailoringKind::invariant;
-        attribute appliesTo = "UserTask[criticality=high]";
+        attribute appliesTo = "OperativeAction[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 = "not(criticality == 'high' or criticality == 'catastrophic') or validates->size() >= 1";
         constraint { true }
     }
     constraint def UseErrorTracesToHazardRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-042";
+        @MemoIdentity { :>> providedId = "CR-ONT-042"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "UseError";
         attribute severity = RuleSeverityKind::warning;
@@ -113,9 +115,9 @@ package memo_rules_ontology {
     // Several of these are WIDER than the end they replace, and deliberately so:
     // the ends were being violated by content that already shipped. `composes`
     // was typed MemoPart/MemoPart and links StateMachine (a state def) to
-    // WorkflowStep (an action def); `verifiedBy`'s source was typed MemoPart and
+    // OperativeAction (an action def); `verifiedBy`'s source was typed MemoPart and
     // most of its sources are requirement defs; `precedes` was typed
-    // ArchitectureElement and joins OperationalActivity to OperationalActivity.
+    // a part-only type and joins OperativeAction to OperativeAction.
     // A rule that reproduced the old type exactly would have failed on the
     // flagship example on the day it landed. What each rule asserts is the
     // constraint the end MEANT, stated so it can be checked.
@@ -127,7 +129,7 @@ package memo_rules_ontology {
     // and the admissible types so the report is still actionable.
 
     constraint def SatisfiedBySourceKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-060";
+        @MemoIdentity { :>> providedId = "CR-ONT-060"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -136,16 +138,16 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def SatisfiedByTargetKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-061";
+        @MemoIdentity { :>> providedId = "CR-ONT-061"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "A requirement is satisfied by a designed thing: an architecture element, an actor, a behaviour, or a port. Never by another requirement or by a document.";
-        attribute predicateExpression = "targetsOf(satisfiedBy)->forAll(conformsTo(ArchitectureElement) or conformsTo(Actor) or construct == 'action' or construct == 'port')";
+        attribute rationaleText = "A requirement is satisfied by a designed part, a behaviour, or a port. Never by another requirement or by a document.";
+        attribute predicateExpression = "targetsOf(satisfiedBy)->forAll(conformsTo(MemoPart) or construct == 'action' or construct == 'port')";
         constraint { true }
     }
     constraint def VerifiedByTargetKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-062";
+        @MemoIdentity { :>> providedId = "CR-ONT-062"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -154,25 +156,25 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def AllocatedToSourceKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-063";
+        @MemoIdentity { :>> providedId = "CR-ONT-063"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "Allocation runs from a function or a behaviour to where it runs. The source end of AllocatedTo is an architecture element or an action.";
-        attribute predicateExpression = "sourcesOf(allocatedTo)->forAll(conformsTo(ArchitectureElement) or construct == 'action')";
+        attribute rationaleText = "Allocation runs from a function or a behaviour to where it runs. The source end of AllocatedTo is a part or an action.";
+        attribute predicateExpression = "sourcesOf(allocatedTo)->forAll(conformsTo(MemoPart) or construct == 'action')";
         constraint { true }
     }
     constraint def AllocatedToTargetKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-064";
+        @MemoIdentity { :>> providedId = "CR-ONT-064"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "A function is allocated to an architecture element or to an actor — ARCADIA System Analysis allocates to the system OR to an actor, which the former ArchitectureElement-typed end made impossible.";
-        attribute predicateExpression = "targetsOf(allocatedTo)->forAll(conformsTo(ArchitectureElement) or conformsTo(Actor))";
+        attribute rationaleText = "A function is allocated to a part — including a system or actor — as ARCADIA System Analysis requires.";
+        attribute predicateExpression = "targetsOf(allocatedTo)->forAll(conformsTo(MemoPart))";
         constraint { true }
     }
     constraint def ComposesParentKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-065";
+        @MemoIdentity { :>> providedId = "CR-ONT-065"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -181,7 +183,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def ComposesChildKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-066";
+        @MemoIdentity { :>> providedId = "CR-ONT-066"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -190,16 +192,16 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def PrecedesEndKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-067";
+        @MemoIdentity { :>> providedId = "CR-ONT-067"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "Precedence orders things that happen: architecture elements or behaviours, at both ends.";
-        attribute predicateExpression = "sourcesOf(precedes)->forAll(conformsTo(ArchitectureElement) or construct == 'action') and targetsOf(precedes)->forAll(conformsTo(ArchitectureElement) or construct == 'action')";
+        attribute rationaleText = "Precedence orders things that happen: parts or behaviours, at both ends.";
+        attribute predicateExpression = "sourcesOf(precedes)->forAll(conformsTo(MemoPart) or construct == 'action') and targetsOf(precedes)->forAll(conformsTo(MemoPart) or construct == 'action')";
         constraint { true }
     }
     constraint def PerformsPerformerKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-068";
+        @MemoIdentity { :>> providedId = "CR-ONT-068"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -207,17 +209,8 @@ package memo_rules_ontology {
         attribute predicateExpression = "sourcesOf(performs)->forAll(conformsTo(MemoPart) or construct == 'action')";
         constraint { true }
     }
-    constraint def EnablesEnablerKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-069";
-        attribute tailoring = RuleTailoringKind::invariant;
-        attribute appliesTo = "Model";
-        attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "An enabling system or function enables a workflow: the enabling end is a part or a behaviour.";
-        attribute predicateExpression = "sourcesOf(enables)->forAll(conformsTo(MemoPart) or construct == 'action')";
-        constraint { true }
-    }
     constraint def BindsToInterfaceEndKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-070";
+        @MemoIdentity { :>> providedId = "CR-ONT-070"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -226,12 +219,12 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def CrossesTrustBoundaryEndKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-071";
+        @MemoIdentity { :>> providedId = "CR-ONT-071"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "A boundary is a boundary element or a port; what crosses it is an asset or an exchange item.";
-        attribute predicateExpression = "sourcesOf(crossesTrustBoundary)->forAll(conformsTo(InterfaceElement) or construct == 'port') and targetsOf(crossesTrustBoundary)->forAll(conformsTo(ArchitectureElement) or construct == 'item')";
+        attribute predicateExpression = "sourcesOf(crossesTrustBoundary)->forAll(conformsTo(InterfaceElement) or construct == 'port') and targetsOf(crossesTrustBoundary)->forAll(conformsTo(MemoPart) or construct == 'item')";
         constraint { true }
     }
 
@@ -241,21 +234,21 @@ package memo_rules_ontology {
     // reached with sourcesOf/targetsOf. They are resolved here by looking the id
     // up in the kind extent, which is the same statement made the long way.
     constraint def ComponentExchangeSourceEndpointKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-072";
+        @MemoIdentity { :>> providedId = "CR-ONT-072"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "ComponentExchange";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "An exchange starts at a component or at a boundary port. Stating it as a rule is what let the endpoint refs stop being MemoPart-typed, which is what lets PhysicalPort and SoftwarePort become port defs.";
-        attribute predicateExpression = "attributes.sourceEndpoint == '' or allOfKind('ArchitectureElement')->exists(id == subject.attributes.sourceEndpoint) or allOfKind('InterfaceElement')->exists(id == subject.attributes.sourceEndpoint) or allOfKind('MemoPort')->exists(id == subject.attributes.sourceEndpoint)";
+        attribute predicateExpression = "attributes.sourceEndpoint == '' or allOfKind('MemoPart')->exists(id == subject.attributes.sourceEndpoint) or allOfKind('InterfaceElement')->exists(id == subject.attributes.sourceEndpoint) or allOfKind('MemoPort')->exists(id == subject.attributes.sourceEndpoint)";
         constraint { true }
     }
     constraint def ComponentExchangeTargetEndpointKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-073";
+        @MemoIdentity { :>> providedId = "CR-ONT-073"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "ComponentExchange";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "An exchange ends at a component or at a boundary port, on the same grounds as CR-ONT-072.";
-        attribute predicateExpression = "attributes.targetEndpoint == '' or allOfKind('ArchitectureElement')->exists(id == subject.attributes.targetEndpoint) or allOfKind('InterfaceElement')->exists(id == subject.attributes.targetEndpoint) or allOfKind('MemoPort')->exists(id == subject.attributes.targetEndpoint)";
+        attribute predicateExpression = "attributes.targetEndpoint == '' or allOfKind('MemoPart')->exists(id == subject.attributes.targetEndpoint) or allOfKind('InterfaceElement')->exists(id == subject.attributes.targetEndpoint) or allOfKind('MemoPort')->exists(id == subject.attributes.targetEndpoint)";
         constraint { true }
     }
 
@@ -266,7 +259,7 @@ package memo_rules_ontology {
     // "answerable to exactly one component" is the whole content of the concept.
 
     constraint def ComponentFunctionAllocatedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-074";
+        @MemoIdentity { :>> providedId = "CR-ONT-074"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "ComponentFunction";
         attribute severity = RuleSeverityKind::error;
@@ -275,7 +268,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def FunctionDecomposesIntoFunctionsRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-075";
+        @MemoIdentity { :>> providedId = "CR-ONT-075"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "MemoFunction";
         attribute severity = RuleSeverityKind::error;
@@ -284,6 +277,59 @@ package memo_rules_ontology {
         constraint { true }
     }
 
+    // ── Containment stays inside one family ─────────────────────────────
+    //
+    // CR-ONT-075 above is this rule for functions; these are the same shape for
+    // the other families. The invariant is FAMILY homogeneity, not type
+    // homogeneity: a System containing a Subsystem containing a LogicalComponent
+    // is correct decomposition even though all three types differ, and measured
+    // 2026-08-18 only 1 of 68 containment edges had identical types at both
+    // ends — a same-type rule would have rejected 98.5% of the corpus, the
+    // ontology's own templates included.
+    //
+    // What they catch is containment CROSSING a family: a logical component
+    // "containing" a software module is realization, and a hardware assembly
+    // "containing" a function is allocation. Both have their own relation, and
+    // writing them as containment loses the distinction.
+    //
+    // They read the `composes` edge, which the builder synthesizes from native
+    // nesting, so they cover the nesting spelling and the retired connection
+    // form identically.
+    //
+    // Ports are exempt. A port is a boundary FEATURE of its owner, not a member
+    // of its owner's family, and any element may carry one whatever family it
+    // is in — CR-ONT-065/066 already govern what may sit at a containment end.
+    // Without the exemption these rules reject `SoftwareModule composes
+    // PhysicalPort`, which those rules accept, and the ontology contradicts
+    // itself about a single edge.
+    constraint def SoftwareContainsSoftwareRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-ONT-077"; }
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "SoftwareElement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Software contains software. A software element containing a logical or physical one is realization, not containment — that is a refinement dependency.";
+        attribute predicateExpression = "composes->forAll(construct == 'port' or construct == 'package' or conformsTo(SoftwareElement))";
+        constraint { true }
+    }
+    constraint def LogicalContainsLogicalRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-ONT-078"; }
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "LogicalComponent";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "The logical hierarchy decomposes into logical components. A logical component containing a software module or a physical part is realization — the implementation element refines the logical one, it is not part of it.";
+        attribute predicateExpression = "composes->forAll(construct == 'port' or construct == 'package' or conformsTo(LogicalComponent))";
+        constraint { true }
+    }
+    constraint def PhysicalContainsPhysicalRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-ONT-079"; }
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "PhysicalElement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "An assembly contains physical things. PhysicalElement is the shared root the family gained for this rule — PhysicalAssembly and PhysicalComponent previously specialized MemoPart separately, which left no type meaning 'a physical thing' to name here.";
+        attribute predicateExpression = "composes->forAll(construct == 'port' or construct == 'package' or conformsTo(PhysicalElement))";
+        constraint { true }
+    }
+
     // Track A3. The flow is the edge; the exchange part carries the budget and
     // assurance attributes. The two halves are bound by a SHARED NAME — the flow
     // usage is named with its exchange — and this is what makes that binding a
@@ -294,7 +340,7 @@ package memo_rules_ontology {
     // the ends and can never answer it. Naming the flow is what the grammar's
     // restored FlowDeclaration name makes possible at all.
     constraint def ExchangeHasFlowRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-076";
+        @MemoIdentity { :>> providedId = "CR-ONT-076"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "ComponentExchange";
         attribute severity = RuleSeverityKind::error;
@@ -304,12 +350,39 @@ package memo_rules_ontology {
     }
 
     constraint def AlternateScenarioHasBaseRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-043";
+        @MemoIdentity { :>> providedId = "CR-ONT-043"; }
         attribute tailoring = RuleTailoringKind::invariant;
-        attribute appliesTo = "MemoScenario";
+        attribute appliesTo = "OperativeScenario";
         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 = "not(variantKind == 'alternate' or variantKind == 'exception' or variantKind == 'recovery') or baseScenario->size() == 1 or variationPoint != ''";
         constraint { true }
     }
+
+    // ─── Assurance-trace warnings ────────────────────────────────────────
+    // Both are WARNINGS, not errors: each describes a trace graph that is
+    // suspicious rather than invalid, and a regulated model has legitimate
+    // exceptions to both. They needed `upstream` / `downstream` — the bare
+    // relation name is bidirectional, so before those existed no rule could
+    // ask which way a derivation ran.
+
+    constraint def DerivationGapRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-ONT-080"; }
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "MemoRequirementElement";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A requirement that others derive from should itself be justified. If nothing is upstream of it and it is not a stakeholder need, the derivation chain dead-ends at an unexplained requirement — the gap an assessor asks about first. Needs are the legitimate roots, so they are exempt by type rather than by convention.";
+        attribute predicateExpression = "downstream(derivesFrom)->isEmpty() or upstream(derivesFrom)->notEmpty() or conformsTo(MemoNeed)";
+        constraint { true }
+    }
+
+    constraint def RedundantAncestorTraceRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-ONT-081"; }
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "MemoRequirementElement";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "When one element satisfies both a requirement and something derived from that requirement, the trace to the ancestor is already implied by the derivation and adds no coverage. Two elements satisfying the two ends is ordinary decomposition and is not reported.";
+        attribute predicateExpression = "not satisfiedBy->intersects(downstream(derivesFrom).satisfiedBy)";
+        constraint { true }
+    }
 }

package/src/rules/quantitative/quantitative_rules.sysml

@@ -6,8 +6,10 @@ package memo_rules_quantitative {
     private import memo_core_consistency_rules::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     constraint def HazardMaxControlsRule :> MemoConsistencyRule {
-        attribute id = "QT-001";
+        @MemoIdentity { :>> providedId = "QT-001"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::info;
@@ -17,7 +19,7 @@ package memo_rules_quantitative {
     }
 
     constraint def SwComponentMaxInterfacesRule :> MemoConsistencyRule {
-        attribute id = "QT-002";
+        @MemoIdentity { :>> providedId = "QT-002"; }
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::info;