@memoarchitect/ontology 0.8.24 → 0.11.0

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,7 +76,7 @@ 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 = "OperativeAction[criticality=high]";
         attribute severity = RuleSeverityKind::error;
@@ -83,7 +85,7 @@ package memo_rules_ontology {
         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;
@@ -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,7 +138,7 @@ 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;
@@ -145,7 +147,7 @@ package memo_rules_ontology {
         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,7 +156,7 @@ 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;
@@ -163,7 +165,7 @@ package memo_rules_ontology {
         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;
@@ -172,7 +174,7 @@ package memo_rules_ontology {
         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,7 +192,7 @@ 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;
@@ -199,7 +201,7 @@ package memo_rules_ontology {
         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,7 +219,7 @@ 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;
@@ -241,7 +234,7 @@ 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;
@@ -250,7 +243,7 @@ package memo_rules_ontology {
         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;
@@ -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;
@@ -303,13 +349,51 @@ package memo_rules_ontology {
         constraint { true }
     }
 
+    // The predicate here named three features that do not exist — `variantKind`,
+    // `baseScenario`, `variationPoint` — so it could never fail, and a rule that
+    // cannot fail is coverage on paper only. `baseScenario` is the one the
+    // scenario def deliberately refused: "a nominal/alternate pair are scenarios
+    // of the same workflow, distinguished by scenarioKind — no baseScenario
+    // back-ref". The base of an alternate IS the nominal scenario of its
+    // workflow, so the rule asks the containment that already expresses it.
     constraint def AlternateScenarioHasBaseRule :> MemoConsistencyRule {
-        attribute :>> id = "CR-ONT-043";
+        @MemoIdentity { :>> providedId = "CR-ONT-043"; }
         attribute tailoring = RuleTailoringKind::invariant;
         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 != ''";
+        attribute rationaleText = "An alternate scenario is a variation of a nominal path, so it belongs to a workflow that has one. An alternate with no nominal sibling is either a workflow with no happy path or a scenario filed under the wrong parent.";
+        // A nominal scenario usually says nothing: `nominal` is the default on
+        // the definition, and a default is not written onto every usage. So the
+        // sibling test is "not alternate", and `conformsTo` keeps it from being
+        // satisfied by an ordinary step of the same workflow.
+        attribute predicateExpression = "not(scenarioKind == 'alternate') or composes.composes->exists(conformsTo(OperativeScenario) and scenarioKind != 'alternate')";
+        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;

package/src/viewpoints/catalog/memo_viewpoint_catalog.sysml

@@ -9,143 +9,144 @@ package memo_viewpoints_catalog {
     private import memo_core_enumerations::*;
     private import memo_viewpoints_definitions::*;
 
+    private import memo_core_common::MemoIdentity;
     // A cataloged viewpoint: the Viewpoint descriptor plus its default
     // resolution to a standard SysML v2 view kind.
 
     // ── Content and context ─────────────────────────────────────
     viewpoint vpModelContent : MemoViewpoint {
-        attribute :>> id = "VP-CAT-001"; attribute :>> name = "ModelContentViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-001"; } attribute :>> name = "ModelContentViewpoint";
         attribute :>> purpose = "Browse the model tree and package structure.";
         attribute :>> defaultViewKind = DiagramViewKind::browser;
     }
     viewpoint vpSystemContext : MemoViewpoint {
-        attribute :>> id = "VP-CAT-002"; attribute :>> name = "SystemContextViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-002"; } attribute :>> name = "SystemContextViewpoint";
         attribute :>> purpose = "System of interest, actors, external systems, and context exchanges.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     // ── Operational world ───────────────────────────────────────
     viewpoint vpUseCase : MemoViewpoint {
-        attribute :>> id = "VP-CAT-003"; attribute :>> name = "UseCaseViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-003"; } attribute :>> name = "UseCaseViewpoint";
         attribute :>> purpose = "Use cases, initiating users, supporting actors, and motivating needs.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpClinicalWorkflow : MemoViewpoint {
-        attribute :>> id = "VP-CAT-004"; attribute :>> name = "ClinicalWorkflowViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-004"; } attribute :>> name = "ClinicalWorkflowViewpoint";
         attribute :>> purpose = "Workflow steps, decisions, parallel work, handoffs, and roles.";
         attribute :>> defaultViewKind = DiagramViewKind::actionflow;
     }
     viewpoint vpScenario : MemoViewpoint {
-        attribute :>> id = "VP-CAT-005"; attribute :>> name = "ScenarioViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-005"; } attribute :>> name = "ScenarioViewpoint";
         attribute :>> purpose = "Selected paths through workflows: variants, conditions, variation points.";
         attribute :>> defaultViewKind = DiagramViewKind::actionflow;
     }
     // ── Functional ──────────────────────────────────────────────
     viewpoint vpFunctionalArchitecture : MemoViewpoint {
-        attribute :>> id = "VP-CAT-006"; attribute :>> name = "FunctionalArchitectureViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-006"; } attribute :>> name = "FunctionalArchitectureViewpoint";
         attribute :>> purpose = "System functions, capabilities, and functional exchanges.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpFunctionalFlow : MemoViewpoint {
-        attribute :>> id = "VP-CAT-007"; attribute :>> name = "FunctionalFlowViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-007"; } attribute :>> name = "FunctionalFlowViewpoint";
         attribute :>> purpose = "Ordered functional flows and their steps.";
         attribute :>> defaultViewKind = DiagramViewKind::actionflow;
     }
     // ── Logical ─────────────────────────────────────────────────
     viewpoint vpLogicalArchitecture : MemoViewpoint {
-        attribute :>> id = "VP-CAT-008"; attribute :>> name = "LogicalArchitectureViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-008"; } attribute :>> name = "LogicalArchitectureViewpoint";
         attribute :>> purpose = "Logical components, channels, and allocations.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpSystemDecomposition : MemoViewpoint {
-        attribute :>> id = "VP-CAT-009"; attribute :>> name = "SystemDecompositionViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-009"; } attribute :>> name = "SystemDecompositionViewpoint";
         attribute :>> purpose = "Composition hierarchy of the system of interest.";
         attribute :>> defaultViewKind = DiagramViewKind::browser;
     }
     viewpoint vpInternalInterconnection : MemoViewpoint {
-        attribute :>> id = "VP-CAT-010"; attribute :>> name = "InternalInterconnectionViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-010"; } attribute :>> name = "InternalInterconnectionViewpoint";
         attribute :>> purpose = "Ports, connectors, and exchanges inside a component boundary.";
         attribute :>> defaultViewKind = DiagramViewKind::interconnection;
     }
     // ── Implementation ──────────────────────────────────────────
     viewpoint vpSoftwareModule : MemoViewpoint {
-        attribute :>> id = "VP-CAT-011"; attribute :>> name = "SoftwareModuleViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-011"; } attribute :>> name = "SoftwareModuleViewpoint";
         attribute :>> purpose = "IEC 62304 module structure: systems, items, units, SOUP.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpSoftwareComponents : MemoViewpoint {
-        attribute :>> id = "VP-CAT-012"; attribute :>> name = "SoftwareComponentViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-012"; } attribute :>> name = "SoftwareComponentViewpoint";
         attribute :>> purpose = "Runtime component-and-connector structure with concurrency and scheduling.";
         attribute :>> defaultViewKind = DiagramViewKind::interconnection;
     }
     viewpoint vpHardwareArchitecture : MemoViewpoint {
-        attribute :>> id = "VP-CAT-013"; attribute :>> name = "HardwareArchitectureViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-013"; } attribute :>> name = "HardwareArchitectureViewpoint";
         attribute :>> purpose = "Electronic/electrical structure and processing platform.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpPhysicalArchitecture : MemoViewpoint {
-        attribute :>> id = "VP-CAT-014"; attribute :>> name = "PhysicalArchitectureViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-014"; } attribute :>> name = "PhysicalArchitectureViewpoint";
         attribute :>> purpose = "Mechanical, fluidic, optical, and other physical realization.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpDeviceComposition : MemoViewpoint {
-        attribute :>> id = "VP-CAT-015"; attribute :>> name = "DeviceCompositionViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-015"; } attribute :>> name = "DeviceCompositionViewpoint";
         attribute :>> purpose = "Device definitions, instances, accessories, and consumables.";
         attribute :>> defaultViewKind = DiagramViewKind::browser;
     }
     viewpoint vpNetworkDeployment : MemoViewpoint {
-        attribute :>> id = "VP-CAT-016"; attribute :>> name = "NetworkDeploymentViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-016"; } attribute :>> name = "NetworkDeploymentViewpoint";
         attribute :>> purpose = "Deployment units on processing nodes and network topology.";
         attribute :>> defaultViewKind = DiagramViewKind::interconnection;
     }
     // ── Interaction and behavior ────────────────────────────────
     viewpoint vpUiFlow : MemoViewpoint {
-        attribute :>> id = "VP-CAT-017"; attribute :>> name = "UiFlowViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-017"; } attribute :>> name = "UiFlowViewpoint";
         attribute :>> purpose = "Interaction flows, UI states, and transitions.";
         attribute :>> defaultViewKind = DiagramViewKind::statetransition;
     }
     viewpoint vpStateMode : MemoViewpoint {
-        attribute :>> id = "VP-CAT-018"; attribute :>> name = "StateModeViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-018"; } attribute :>> name = "StateModeViewpoint";
         attribute :>> purpose = "System states, device modes, and transitions.";
         attribute :>> defaultViewKind = DiagramViewKind::statetransition;
     }
     viewpoint vpSequenceInteraction : MemoViewpoint {
-        attribute :>> id = "VP-CAT-019"; attribute :>> name = "SequenceInteractionViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-019"; } attribute :>> name = "SequenceInteractionViewpoint";
         attribute :>> purpose = "Ordered message exchanges between participants in a scenario.";
         attribute :>> defaultViewKind = DiagramViewKind::sequence;
     }
     // ── Assurance ───────────────────────────────────────────────
     viewpoint vpRequirementsTraceability : MemoViewpoint {
-        attribute :>> id = "VP-CAT-020"; attribute :>> name = "RequirementsTraceabilityViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-020"; } attribute :>> name = "RequirementsTraceabilityViewpoint";
         attribute :>> purpose = "Needs → requirements → architecture → verification trace matrix.";
         attribute :>> defaultViewKind = DiagramViewKind::grid;
     }
     viewpoint vpRiskChain : MemoViewpoint {
-        attribute :>> id = "VP-CAT-021"; attribute :>> name = "RiskChainViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-021"; } attribute :>> name = "RiskChainViewpoint";
         attribute :>> purpose = "ISO 14971 chain: hazard → hazardous situation → harm with controls.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpCybersecurity : MemoViewpoint {
-        attribute :>> id = "VP-CAT-022"; attribute :>> name = "CybersecurityViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-022"; } attribute :>> name = "CybersecurityViewpoint";
         attribute :>> purpose = "Assets, threats, trust boundaries, and security controls.";
         attribute :>> defaultViewKind = DiagramViewKind::general;
     }
     viewpoint vpHumanFactors : MemoViewpoint {
-        attribute :>> id = "VP-CAT-023"; attribute :>> name = "HumanFactorsViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-023"; } attribute :>> name = "HumanFactorsViewpoint";
         attribute :>> purpose = "Users, tasks, use errors, and hazard-related use scenarios.";
         attribute :>> defaultViewKind = DiagramViewKind::grid;
     }
     viewpoint vpVerificationCoverage : MemoViewpoint {
-        attribute :>> id = "VP-CAT-024"; attribute :>> name = "VerificationCoverageViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-024"; } attribute :>> name = "VerificationCoverageViewpoint";
         attribute :>> purpose = "Verification cases against requirements and functions.";
         attribute :>> defaultViewKind = DiagramViewKind::grid;
     }
     viewpoint vpValidationCoverage : MemoViewpoint {
-        attribute :>> id = "VP-CAT-025"; attribute :>> name = "ValidationCoverageViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-025"; } attribute :>> name = "ValidationCoverageViewpoint";
         attribute :>> purpose = "Validation cases against use cases and critical tasks.";
         attribute :>> defaultViewKind = DiagramViewKind::grid;
     }
     viewpoint vpEvidenceTraceability : MemoViewpoint {
-        attribute :>> id = "VP-CAT-026"; attribute :>> name = "EvidenceTraceabilityViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-026"; } attribute :>> name = "EvidenceTraceabilityViewpoint";
         attribute :>> purpose = "Evidence records back to the cases and elements they support.";
         attribute :>> defaultViewKind = DiagramViewKind::grid;
     }
@@ -154,14 +155,14 @@ package memo_viewpoints_catalog {
     // SoftwareComponents realizing a functional OperativeScenario. The viewpoint is the
     // reusable spec; the diagram of a specific model is the view.
     viewpoint vpSoftwareSequence : MemoViewpoint {
-        attribute :>> id = "VP-CAT-027"; attribute :>> name = "SoftwareSequenceViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-027"; } attribute :>> name = "SoftwareSequenceViewpoint";
         attribute :>> purpose = "Runtime message ordering between software components along a functional scenario.";
         attribute :>> defaultViewKind = DiagramViewKind::sequence;
     }
     // The first cataloged viewpoint to resolve to `geometry`: screen regions
     // carry authored RegionBounds, so a geometry view draws modelled facts.
     viewpoint vpUILayout : MemoViewpoint {
-        attribute :>> id = "VP-CAT-028"; attribute :>> name = "UILayoutViewpoint";
+        @MemoIdentity { :>> providedId = "VP-CAT-028"; } attribute :>> name = "UILayoutViewpoint";
         attribute :>> purpose = "Captured screens with their marked regions and the UI elements those regions present.";
         attribute :>> defaultViewKind = DiagramViewKind::geometry;
     }

package/src/viewpoints/clinical/clinical_viewpoint.sysml

@@ -4,10 +4,12 @@ package memo_viewpoints_clinical_clinical_viewpoint {
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     viewpoint clinicalViewpoint : MemoViewpoint {
-        attribute :>> id = "VP-CLIN";
+        @MemoIdentity { :>> providedId = "VP-CLIN"; }
         attribute :>> name = "ClinicalViewpoint";
-        attribute :>> shortDescription = "Shows clinical context, users, use environment, and clinical evidence.";
+        @MemoIdentity { :>> shortDescription = "Shows clinical context, users, use environment, and clinical evidence."; }
         attribute :>> description = "Default viewpoint derived from the context and assurance layers for clinical stakeholders — intended use, patient/clinician interaction, clinical evidence, and clinical safety claims.";
         attribute :>> purpose = "Communicate clinical use context and clinical evidence for the device.";
         attribute :>> audience = (AudienceKind::clinicalEngineer, AudienceKind::regulatoryEngineer);

package/src/viewpoints/context/context_viewpoint.sysml

@@ -4,10 +4,12 @@ package memo_viewpoints_context_context_viewpoint {
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     viewpoint contextViewpoint : MemoViewpoint {
-        attribute :>> id = "VP-CTX";
+        @MemoIdentity { :>> providedId = "VP-CTX"; }
         attribute :>> name = "ContextViewpoint";
-        attribute :>> shortDescription = "Shows actors, use context, and system boundary.";
+        @MemoIdentity { :>> shortDescription = "Shows actors, use context, and system boundary."; }
         attribute :>> description = "Default viewpoint derived from the context layer to communicate who interacts with the device, under which use conditions, and where trust or safety boundaries exist.";
         attribute :>> purpose = "Communicate operational context and boundaries.";
         attribute :>> audience = (AudienceKind::systemArchitect);
@@ -28,7 +30,7 @@ package memo_viewpoints_context_context_viewpoint {
         // boundary picture. Projects derive their own verbs from it and are
         // picked up through the specialization closure. The three older
         // relations remain for models authored before it existed.
-        attribute :>> allowedRelationshipKinds = ("InteractsInContext", "InteractsWith", "flow", "bind", "connect");
+        attribute :>> allowedRelationshipKinds = ("InteractsInContext", "connect", "flow", "bind");
         attribute :>> userExtensible = true;
     }
 }

package/src/viewpoints/context/views/system_context_view/system_context_view.sysml

@@ -5,19 +5,21 @@ package memo_viewpoints_context_views_system_context_view {
                 private import memo_core_enumerations::*;
     private import memo_viewpoints_context_context_viewpoint::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
                 view systemContextView : MemoDiagramView {
                     expose memo_viewpoints_context_views_system_context_view::*;
                     attribute depth = 2;
-    attribute :>> id = "VIEW-CTX-001";
+    @MemoIdentity { :>> providedId = "VIEW-CTX-001"; }
     attribute :>> name = "SystemContextView";
-    attribute :>> shortDescription = "Actors, use context, and system boundary.";
+    @MemoIdentity { :>> shortDescription = "Actors, use context, and system boundary."; }
     attribute :>> outputKind = (ViewOutputKind::diagram);
     attribute :>> presentationKind = (PresentationKind::blockDiagram);
     attribute :>> diagramType = "bdd";
     attribute :>> autoPopulate = true;
     attribute :>> queryDescription = "Include actors, use contexts, and trust boundaries at the system boundary.";
     part :>> selectionQuery {
-        attribute :>> id = "QRY-CTX-001";
+        @MemoIdentity { :>> providedId = "QRY-CTX-001"; }
         attribute :>> name = "SystemContextQuery";
         attribute :>> includeElementKinds = ("Actor", "UseContext", "TrustBoundary");
         attribute :>> includeLayers = ("context");

package/src/viewpoints/cybersecurity/cybersecurity_viewpoint.sysml

@@ -4,10 +4,12 @@ package memo_viewpoints_cybersecurity_cybersecurity_viewpoint {
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;
 
+    private import memo_core_common::*;
+    private import memo_core_common::MemoIdentity;
     viewpoint cybersecurityViewpoint : MemoViewpoint {
-        attribute :>> id = "VP-CYB";
+        @MemoIdentity { :>> providedId = "VP-CYB"; }
         attribute :>> name = "CybersecurityViewpoint";
-        attribute :>> shortDescription = "Shows assets, trust boundaries, threats, vulnerabilities, cyber hazards, cyber risks, and mitigations.";
+        @MemoIdentity { :>> shortDescription = "Shows assets, trust boundaries, threats, vulnerabilities, cyber hazards, cyber risks, and mitigations."; }
         attribute :>> description = "Default viewpoint derived from the cybersecurity layer, using STRIDE-style threat categories by default while allowing safety and privacy impacts to be traced into the broader model.";
         attribute :>> purpose = "Communicate cybersecurity design, threat analysis, and cyber risk posture.";
         attribute :>> audience = (AudienceKind::securityEngineer);