@memoarchitect/ontology 0.8.22 → 0.8.24

package/src/rules/closure/closure_rules.sysml

@@ -10,7 +10,7 @@ package memo_rules_closure {
     // ─── Risk Layer Rules ────────────────────────────────────────────────
 
     constraint def HazardMitigationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-001";
+        attribute :>> id = "CR-MED-001";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
@@ -20,7 +20,7 @@ package memo_rules_closure {
     }
 
     constraint def HazardSeverityRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-002";
+        attribute :>> id = "CR-MED-002";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
@@ -30,7 +30,7 @@ package memo_rules_closure {
     }
 
     constraint def RiskControlVerificationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-003";
+        attribute :>> id = "CR-MED-003";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "RiskControlMeasure";
         attribute severity = RuleSeverityKind::error;
@@ -40,7 +40,7 @@ package memo_rules_closure {
     }
 
     constraint def InitialRiskMatrixRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-004";
+        attribute :>> id = "CR-MED-004";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Risk";
         attribute severity = RuleSeverityKind::warning;
@@ -52,7 +52,7 @@ package memo_rules_closure {
     // ─── Requirements Layer Rules ────────────────────────────────────────
 
     constraint def SysReqTraceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-010";
+        attribute :>> id = "CR-MED-010";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::error;
@@ -62,7 +62,7 @@ package memo_rules_closure {
     }
 
     constraint def SwReqTraceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-011";
+        attribute :>> id = "CR-MED-011";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=software]";
         attribute severity = RuleSeverityKind::error;
@@ -80,7 +80,7 @@ package memo_rules_closure {
     // ─── Architecture Layer Rules ────────────────────────────────────────
 
     constraint def SwComponentSafetyClassRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-020";
+        attribute :>> id = "CR-MED-020";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
@@ -90,7 +90,7 @@ package memo_rules_closure {
     }
 
     constraint def SwComponentReqRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-021";
+        attribute :>> id = "CR-MED-021";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::warning;
@@ -100,7 +100,7 @@ package memo_rules_closure {
     }
 
     constraint def LogicalFunctionAllocationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-022";
+        attribute :>> id = "CR-MED-022";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SystemFunction";
         attribute severity = RuleSeverityKind::warning;
@@ -112,7 +112,7 @@ package memo_rules_closure {
     // ─── Verification Layer Rules ────────────────────────────────────────
 
     constraint def VerificationCaseMethodRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-030";
+        attribute :>> id = "CR-MED-030";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
@@ -122,7 +122,7 @@ package memo_rules_closure {
     }
 
     constraint def VerificationCaseTargetRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-031";
+        attribute :>> id = "CR-MED-031";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
@@ -132,7 +132,7 @@ package memo_rules_closure {
     }
 
     constraint def EvidenceProductionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-032";
+        attribute :>> id = "CR-MED-032";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::warning;
@@ -144,7 +144,7 @@ package memo_rules_closure {
     // ─── Cybersecurity Layer Rules ───────────────────────────────────────
 
     constraint def ThreatMitigationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-040";
+        attribute :>> id = "CR-MED-040";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Threat";
         attribute severity = RuleSeverityKind::error;
@@ -154,7 +154,7 @@ package memo_rules_closure {
     }
 
     constraint def AssetThreatLinkRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-041";
+        attribute :>> id = "CR-MED-041";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "CybersecurityAsset";
         attribute severity = RuleSeverityKind::warning;
@@ -166,7 +166,7 @@ package memo_rules_closure {
     // ─── Interface Rules ─────────────────────────────────────────────────
 
     constraint def LogicalInterfaceDirectionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-050";
+        attribute :>> id = "CR-MED-050";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Interface";
         attribute severity = RuleSeverityKind::error;
@@ -178,7 +178,7 @@ package memo_rules_closure {
     // ─── Conditional Rules ───────────────────────────────────────────────
 
     constraint def SafetyClassCVerificationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-101";
+        attribute :>> id = "CR-MED-101";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
@@ -203,7 +203,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";
+        attribute :>> id = "CR-MED-110";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::error;
@@ -217,7 +217,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";
+        attribute :>> id = "CR-MED-111";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
@@ -230,7 +230,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";
+        attribute :>> id = "CR-MED-112";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
@@ -242,7 +242,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";
+        attribute :>> id = "CR-MED-113";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "ScreenCapture";
         attribute severity = RuleSeverityKind::error;

package/src/rules/crosslayer/cross_layer_rules.sysml

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

package/src/rules/ontology/ontology_invariants.sysml

@@ -12,7 +12,7 @@ package memo_rules_ontology {
     // ─── Structure ───────────────────────────────────────────────────────
 
     constraint def ContainmentAcyclicRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-001";
+        attribute :>> id = "CR-ONT-001";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -21,7 +21,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def NestedPartConnectedRule :> MemoConsistencyRule {
-        attribute id = "AR-IBD-001";
+        attribute :>> id = "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 +44,7 @@ package memo_rules_ontology {
     // ─── Deployment and realization ──────────────────────────────────────
 
     constraint def RuntimeTracesToModuleRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-011";
+        attribute :>> id = "CR-ONT-011";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "SoftwareComponent";
         attribute severity = RuleSeverityKind::warning;
@@ -53,7 +53,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def PatientContactCharacterizedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-032";
+        attribute :>> id = "CR-ONT-032";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "PhysicalComponent";
         attribute severity = RuleSeverityKind::error;
@@ -65,7 +65,7 @@ package memo_rules_ontology {
     // ─── Assurance coverage ──────────────────────────────────────────────
 
     constraint def SafetyCriticalFunctionVerifiedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-040";
+        attribute :>> id = "CR-ONT-040";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "MemoFunction";
         attribute severity = RuleSeverityKind::error;
@@ -74,16 +74,16 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def CriticalTaskValidatedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-041";
+        attribute :>> id = "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";
+        attribute :>> id = "CR-ONT-042";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "UseError";
         attribute severity = RuleSeverityKind::warning;
@@ -113,9 +113,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 +127,7 @@ package memo_rules_ontology {
     // and the admissible types so the report is still actionable.
 
     constraint def SatisfiedBySourceKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-060";
+        attribute :>> id = "CR-ONT-060";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -136,16 +136,16 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def SatisfiedByTargetKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-061";
+        attribute :>> id = "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";
+        attribute :>> id = "CR-ONT-062";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -154,25 +154,25 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def AllocatedToSourceKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-063";
+        attribute :>> id = "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";
+        attribute :>> id = "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";
+        attribute :>> id = "CR-ONT-065";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -181,7 +181,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def ComposesChildKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-066";
+        attribute :>> id = "CR-ONT-066";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -190,16 +190,16 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def PrecedesEndKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-067";
+        attribute :>> id = "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";
+        attribute :>> id = "CR-ONT-068";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -208,7 +208,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def EnablesEnablerKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-069";
+        attribute :>> id = "CR-ONT-069";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -217,7 +217,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def BindsToInterfaceEndKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-070";
+        attribute :>> id = "CR-ONT-070";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -226,12 +226,12 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def CrossesTrustBoundaryEndKindRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-071";
+        attribute :>> id = "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 +241,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";
+        attribute :>> id = "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";
+        attribute :>> id = "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 +266,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";
+        attribute :>> id = "CR-ONT-074";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "ComponentFunction";
         attribute severity = RuleSeverityKind::error;
@@ -275,7 +275,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def FunctionDecomposesIntoFunctionsRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-075";
+        attribute :>> id = "CR-ONT-075";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "MemoFunction";
         attribute severity = RuleSeverityKind::error;
@@ -294,7 +294,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";
+        attribute :>> id = "CR-ONT-076";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "ComponentExchange";
         attribute severity = RuleSeverityKind::error;
@@ -304,9 +304,9 @@ package memo_rules_ontology {
     }
 
     constraint def AlternateScenarioHasBaseRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-043";
+        attribute :>> id = "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 != ''";

package/src/rules/quantitative/quantitative_rules.sysml

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