@memoarchitect/ontology 0.6.5 → 0.8.22

package/src/memo_namespaces.sysml

@@ -6,6 +6,7 @@ package memo {
     public import memo_core_terminology::*;
     public import memo_core_common::*;
     public import memo_core_relationships::*;
+    public import memo_core_annotations::*;
 
     public import memo_architecture_operational_context_actors::*;
     public import memo_architecture_operational_context_stakeholders::*;
@@ -31,44 +32,60 @@ package memo {
     public import memo_assurance_safety_risk::*;
     public import memo_assurance_cybersecurity::*;
     public import memo_assurance_verification_validation::*;
+    public import memo_assurance_verification_validation_clinical_evaluation::*;
     public import memo_architecture_realization_physical::*;
     public import memo_assurance_safety_risk_analysis::*;
+    public import memo_assurance_safety_risk_postmarket_surveillance::*;
     public import memo_architecture_decisions::*;
 
     public import memo_viewpoints_definitions::*;
     public import memo_viewpoints_catalog::*;
     public import memo_viewpoints_context_context_viewpoint::*;
-    public import memo_viewpoints_context_system_context_view::*;
+    public import memo_viewpoints_context_views_system_context_view::*;
     public import memo_viewpoints_operational_operational_viewpoint::*;
-    public import memo_viewpoints_operational_use_case_view::*;
+    public import memo_viewpoints_operational_views_use_case_view::*;
     public import memo_viewpoints_requirements_requirements_viewpoint::*;
-    public import memo_viewpoints_requirements_requirements_traceability_view::*;
+    public import memo_viewpoints_requirements_views_requirements_traceability_view::*;
     public import memo_viewpoints_functional_functional_viewpoint::*;
-    public import memo_viewpoints_functional_system_functional_tree_view::*;
-    public import memo_viewpoints_functional_function_allocation_view::*;
+    public import memo_viewpoints_functional_views_system_functional_tree_view::*;
+    public import memo_viewpoints_functional_views_function_allocation_view::*;
     public import memo_viewpoints_logical_logical_viewpoint::*;
-    public import memo_viewpoints_logical_logical_architecture_view::*;
+    public import memo_viewpoints_logical_views_logical_architecture_view::*;
     public import memo_viewpoints_software_software_viewpoint::*;
-    public import memo_viewpoints_software_software_architecture_view::*;
+    public import memo_viewpoints_software_views_software_architecture_view::*;
     public import memo_viewpoints_physical_physical_viewpoint::*;
-    public import memo_viewpoints_physical_physical_bom_view::*;
-    public import memo_viewpoints_physical_network_topology_view::*;
+    public import memo_viewpoints_physical_views_physical_bom_view::*;
+    public import memo_viewpoints_physical_views_network_topology_view::*;
     public import memo_viewpoints_risk_risk_viewpoint::*;
-    public import memo_viewpoints_risk_risk_chain_view::*;
+    public import memo_viewpoints_risk_views_risk_chain_view::*;
     public import memo_viewpoints_verification_verification_viewpoint::*;
-    public import memo_viewpoints_verification_verification_coverage_view::*;
+    public import memo_viewpoints_verification_views_verification_coverage_view::*;
     public import memo_viewpoints_cybersecurity_cybersecurity_viewpoint::*;
-    public import memo_viewpoints_cybersecurity_threat_model_view::*;
-    public import memo_viewpoints_cybersecurity_cybersecurity_assessment_view::*;
+    public import memo_viewpoints_cybersecurity_views_threat_model_view::*;
+    public import memo_viewpoints_cybersecurity_views_cybersecurity_assessment_view::*;
     public import memo_viewpoints_clinical_clinical_viewpoint::*;
-    public import memo_viewpoints_clinical_clinical_evidence_view::*;
+    public import memo_viewpoints_clinical_views_clinical_evidence_view::*;
     public import memo_viewpoints_usability_usability_viewpoint::*;
-    public import memo_viewpoints_usability_usability_engineering_view::*;
+    public import memo_viewpoints_usability_views_usability_engineering_view::*;
+    public import memo_viewpoints_ui_layout_ui_layout_viewpoint::*;
+    public import memo_viewpoints_ui_layout_views_screen_layout_view::*;
 
     public import memo_artifacts_definitions::*;
-    public import memo_compliance_artifacts::*;
-    public import memo_compliance_change::*;
-    public import memo_compliance_postmarket::*;
+    public import memo_artifacts_core::*;
+    public import memo_artifacts_configuration_management::*;
+    public import memo_artifacts_documents_risk_management::*;
+    public import memo_artifacts_standards_traceability::*;
+    public import memo_artifacts_standards_cfr_21_820::*;
+    public import memo_artifacts_standards_fda_cybersecurity_2023::*;
+    public import memo_artifacts_standards_iec_60601_1::*;
+    public import memo_artifacts_standards_iec_60601_1_2::*;
+    public import memo_artifacts_standards_iec_60812::*;
+    public import memo_artifacts_standards_iec_62304::*;
+    public import memo_artifacts_standards_iec_62366_1::*;
+    public import memo_artifacts_standards_iec_81001_5_1::*;
+    public import memo_artifacts_standards_iso_13485::*;
+    public import memo_artifacts_standards_iso_14971::*;
+    public import memo_artifacts_standards_iso_iec_ieee_42010::*;
 
     public import memo_methodology_core::*;
     public import memo_methodology_rules::*;
@@ -80,7 +97,6 @@ package memo {
     alias architecture for memo_namespace_architecture;
     alias assurance for memo_namespace_assurance;
     alias artifacts for memo_namespace_artifacts;
-    alias compliance for memo_namespace_compliance;
     alias core for memo_namespace_core;
     alias methodology for memo_namespace_methodology;
     alias rules for memo_namespace_rules;
@@ -103,6 +119,7 @@ package memo_namespace_assurance {
         public import memo_assurance_safety_risk::*;
         public import memo_assurance_safety_risk_arch_risk::*;
         alias 'analysis' for memo_namespace_assurance_safety_risk_analysis;
+        alias postmarket_surveillance for memo_namespace_assurance_safety_risk_postmarket_surveillance;
     }
     alias cybersecurity for memo_namespace_assurance_cybersecurity;
     alias human_factors for memo_namespace_assurance_human_factors;
@@ -235,17 +252,14 @@ package memo_namespace_architecture {
 
 package memo_namespace_artifacts {
     alias definitions for memo_namespace_artifacts_definitions;
-}
-
-package memo_namespace_compliance {
-    alias artifacts for memo_namespace_compliance_artifacts;
-    alias change for memo_namespace_compliance_change;
-    alias document_views for memo_namespace_compliance_document_views;
-    alias iso14971 for memo_namespace_compliance_iso14971;
-    alias postmarket for memo_namespace_compliance_postmarket;
+    alias core for memo_namespace_artifacts_core;
+    alias configuration_management for memo_namespace_artifacts_configuration_management;
+    alias documents for memo_namespace_artifacts_documents;
+    alias standards for memo_namespace_artifacts_standards;
 }
 
 package memo_namespace_core {
+    alias annotations for memo_namespace_core_annotations;
     alias common for memo_namespace_core_common;
     alias consistency_rules for memo_namespace_core_consistency_rules;
     alias dimensions for memo_namespace_core_dimensions;
@@ -290,6 +304,7 @@ package memo_namespace_viewpoints {
     alias requirements for memo_namespace_viewpoints_requirements;
     alias risk for memo_namespace_viewpoints_risk;
     alias software for memo_namespace_viewpoints_software;
+    alias ui_layout for memo_namespace_viewpoints_ui_layout;
     alias usability for memo_namespace_viewpoints_usability;
     alias 'verification' for memo_namespace_viewpoints_verification;
 }
@@ -300,6 +315,7 @@ package memo_namespace_assurance_safety_risk_analysis {
 
 package memo_namespace_assurance_verification_validation {
     public import memo_assurance_verification_validation::*;
+    alias clinical_evaluation for memo_namespace_assurance_verification_validation_clinical_evaluation;
 }
 
 package memo_namespace_architecture_behavior {
@@ -350,24 +366,49 @@ package memo_namespace_artifacts_definitions {
     public import memo_artifacts_definitions::*;
 }
 
-package memo_namespace_compliance_artifacts {
-    public import memo_compliance_artifacts::*;
+package memo_namespace_artifacts_core {
+    public import memo_artifacts_core::*;
 }
 
-package memo_namespace_compliance_change {
-    public import memo_compliance_change::*;
+package memo_namespace_artifacts_configuration_management {
+    public import memo_artifacts_configuration_management::*;
 }
 
-package memo_namespace_compliance_document_views {
-    public import memo_compliance_document_views::*;
+package memo_namespace_artifacts_documents {
+    alias risk_management for memo_namespace_artifacts_documents_risk_management;
 }
 
-package memo_namespace_compliance_iso14971 {
-    public import memo_compliance_iso14971::*;
+package memo_namespace_artifacts_documents_risk_management {
+    public import memo_artifacts_documents_risk_management::*;
 }
 
-package memo_namespace_compliance_postmarket {
-    public import memo_compliance_postmarket::*;
+package memo_namespace_artifacts_standards {
+    public import memo_artifacts_standards_traceability::*;
+    // The library itself: one package per standard, concrete clause instances.
+    // Adding a standard is one file next to these and no change anywhere else.
+    public import memo_artifacts_standards_cfr_21_820::*;
+    public import memo_artifacts_standards_fda_cybersecurity_2023::*;
+    public import memo_artifacts_standards_iec_60601_1::*;
+    public import memo_artifacts_standards_iec_60601_1_2::*;
+    public import memo_artifacts_standards_iec_60812::*;
+    public import memo_artifacts_standards_iec_62304::*;
+    public import memo_artifacts_standards_iec_62366_1::*;
+    public import memo_artifacts_standards_iec_81001_5_1::*;
+    public import memo_artifacts_standards_iso_13485::*;
+    public import memo_artifacts_standards_iso_14971::*;
+    public import memo_artifacts_standards_iso_iec_ieee_42010::*;
+}
+
+package memo_namespace_assurance_verification_validation_clinical_evaluation {
+    public import memo_assurance_verification_validation_clinical_evaluation::*;
+}
+
+package memo_namespace_assurance_safety_risk_postmarket_surveillance {
+    public import memo_assurance_safety_risk_postmarket_surveillance::*;
+}
+
+package memo_namespace_core_annotations {
+    public import memo_core_annotations::*;
 }
 
 package memo_namespace_core_common {
@@ -470,19 +511,21 @@ package memo_namespace_viewpoints_catalog {
 }
 
 package memo_namespace_viewpoints_clinical {
-    alias clinical_evidence_view for memo_namespace_viewpoints_clinical_clinical_evidence_view;
     public import memo_viewpoints_clinical_clinical_viewpoint::*;
+    package views { alias clinical_evidence_view for memo_namespace_viewpoints_clinical_clinical_evidence_view; }
 }
 
 package memo_namespace_viewpoints_context {
-    alias system_context_view for memo_namespace_viewpoints_context_system_context_view;
     public import memo_viewpoints_context_context_viewpoint::*;
+    package views { alias system_context_view for memo_namespace_viewpoints_context_system_context_view; }
 }
 
 package memo_namespace_viewpoints_cybersecurity {
-    alias cybersecurity_assessment_view for memo_namespace_viewpoints_cybersecurity_cybersecurity_assessment_view;
-    alias threat_model_view for memo_namespace_viewpoints_cybersecurity_threat_model_view;
     public import memo_viewpoints_cybersecurity_cybersecurity_viewpoint::*;
+    package views {
+        alias cybersecurity_assessment_view for memo_namespace_viewpoints_cybersecurity_cybersecurity_assessment_view;
+        alias threat_model_view for memo_namespace_viewpoints_cybersecurity_threat_model_view;
+    }
 }
 
 package memo_namespace_viewpoints_definitions {
@@ -490,50 +533,59 @@ package memo_namespace_viewpoints_definitions {
 }
 
 package memo_namespace_viewpoints_functional {
-    alias function_allocation_view for memo_namespace_viewpoints_functional_function_allocation_view;
-    alias system_functional_tree_view for memo_namespace_viewpoints_functional_system_functional_tree_view;
     public import memo_viewpoints_functional_functional_viewpoint::*;
+    package views {
+        alias function_allocation_view for memo_namespace_viewpoints_functional_function_allocation_view;
+        alias system_functional_tree_view for memo_namespace_viewpoints_functional_system_functional_tree_view;
+    }
 }
 
 package memo_namespace_viewpoints_logical {
-    alias logical_architecture_view for memo_namespace_viewpoints_logical_logical_architecture_view;
     public import memo_viewpoints_logical_logical_viewpoint::*;
+    package views { alias logical_architecture_view for memo_namespace_viewpoints_logical_logical_architecture_view; }
 }
 
 package memo_namespace_viewpoints_operational {
-    alias use_case_view for memo_namespace_viewpoints_operational_use_case_view;
     public import memo_viewpoints_operational_operational_viewpoint::*;
+    package views { alias use_case_view for memo_namespace_viewpoints_operational_use_case_view; }
 }
 
 package memo_namespace_viewpoints_physical {
-    alias network_topology_view for memo_namespace_viewpoints_physical_network_topology_view;
-    alias physical_bom_view for memo_namespace_viewpoints_physical_physical_bom_view;
     public import memo_viewpoints_physical_physical_viewpoint::*;
+    package views {
+        alias network_topology_view for memo_namespace_viewpoints_physical_network_topology_view;
+        alias physical_bom_view for memo_namespace_viewpoints_physical_physical_bom_view;
+    }
 }
 
 package memo_namespace_viewpoints_requirements {
-    alias requirements_traceability_view for memo_namespace_viewpoints_requirements_requirements_traceability_view;
     public import memo_viewpoints_requirements_requirements_viewpoint::*;
+    package views { alias requirements_traceability_view for memo_namespace_viewpoints_requirements_requirements_traceability_view; }
 }
 
 package memo_namespace_viewpoints_risk {
-    alias risk_chain_view for memo_namespace_viewpoints_risk_risk_chain_view;
     public import memo_viewpoints_risk_risk_viewpoint::*;
+    package views { alias risk_chain_view for memo_namespace_viewpoints_risk_risk_chain_view; }
 }
 
 package memo_namespace_viewpoints_software {
-    alias software_architecture_view for memo_namespace_viewpoints_software_software_architecture_view;
     public import memo_viewpoints_software_software_viewpoint::*;
+    package views { alias software_architecture_view for memo_namespace_viewpoints_software_software_architecture_view; }
 }
 
 package memo_namespace_viewpoints_usability {
-    alias usability_engineering_view for memo_namespace_viewpoints_usability_usability_engineering_view;
     public import memo_viewpoints_usability_usability_viewpoint::*;
+    package views { alias usability_engineering_view for memo_namespace_viewpoints_usability_usability_engineering_view; }
+}
+
+package memo_namespace_viewpoints_ui_layout {
+    public import memo_viewpoints_ui_layout_ui_layout_viewpoint::*;
+    package views { alias screen_layout_view for memo_namespace_viewpoints_ui_layout_screen_layout_view; }
 }
 
 package memo_namespace_viewpoints_verification {
-    alias verification_coverage_view for memo_namespace_viewpoints_verification_verification_coverage_view;
     public import memo_viewpoints_verification_verification_viewpoint::*;
+    package views { alias verification_coverage_view for memo_namespace_viewpoints_verification_verification_coverage_view; }
 }
 
 package memo_namespace_core_stdlib_collections {
@@ -553,61 +605,69 @@ package memo_namespace_core_stdlib_time {
 }
 
 package memo_namespace_viewpoints_clinical_clinical_evidence_view {
-    public import memo_viewpoints_clinical_clinical_evidence_view::*;
+    public import memo_viewpoints_clinical_views_clinical_evidence_view::*;
 }
 
 package memo_namespace_viewpoints_context_system_context_view {
-    public import memo_viewpoints_context_system_context_view::*;
+    public import memo_viewpoints_context_views_system_context_view::*;
 }
 
 package memo_namespace_viewpoints_cybersecurity_cybersecurity_assessment_view {
-    public import memo_viewpoints_cybersecurity_cybersecurity_assessment_view::*;
+    public import memo_viewpoints_cybersecurity_views_cybersecurity_assessment_view::*;
 }
 
 package memo_namespace_viewpoints_cybersecurity_threat_model_view {
-    public import memo_viewpoints_cybersecurity_threat_model_view::*;
+    public import memo_viewpoints_cybersecurity_views_threat_model_view::*;
 }
 
 package memo_namespace_viewpoints_functional_function_allocation_view {
-    public import memo_viewpoints_functional_function_allocation_view::*;
+    public import memo_viewpoints_functional_views_function_allocation_view::*;
 }
 
 package memo_namespace_viewpoints_functional_system_functional_tree_view {
-    public import memo_viewpoints_functional_system_functional_tree_view::*;
+    public import memo_viewpoints_functional_views_system_functional_tree_view::*;
 }
 
 package memo_namespace_viewpoints_logical_logical_architecture_view {
-    public import memo_viewpoints_logical_logical_architecture_view::*;
+    public import memo_viewpoints_logical_views_logical_architecture_view::*;
 }
 
 package memo_namespace_viewpoints_operational_use_case_view {
-    public import memo_viewpoints_operational_use_case_view::*;
+    public import memo_viewpoints_operational_views_use_case_view::*;
 }
 
 package memo_namespace_viewpoints_physical_network_topology_view {
-    public import memo_viewpoints_physical_network_topology_view::*;
+    public import memo_viewpoints_physical_views_network_topology_view::*;
 }
 
 package memo_namespace_viewpoints_physical_physical_bom_view {
-    public import memo_viewpoints_physical_physical_bom_view::*;
+    public import memo_viewpoints_physical_views_physical_bom_view::*;
 }
 
 package memo_namespace_viewpoints_requirements_requirements_traceability_view {
-    public import memo_viewpoints_requirements_requirements_traceability_view::*;
+    public import memo_viewpoints_requirements_views_requirements_traceability_view::*;
 }
 
 package memo_namespace_viewpoints_risk_risk_chain_view {
-    public import memo_viewpoints_risk_risk_chain_view::*;
+    public import memo_viewpoints_risk_views_risk_chain_view::*;
 }
 
 package memo_namespace_viewpoints_software_software_architecture_view {
-    public import memo_viewpoints_software_software_architecture_view::*;
+    public import memo_viewpoints_software_views_software_architecture_view::*;
 }
 
 package memo_namespace_viewpoints_usability_usability_engineering_view {
-    public import memo_viewpoints_usability_usability_engineering_view::*;
+    public import memo_viewpoints_usability_views_usability_engineering_view::*;
+}
+
+package memo_namespace_viewpoints_ui_layout_ui_layout_viewpoint {
+    public import memo_viewpoints_ui_layout_ui_layout_viewpoint::*;
+}
+
+package memo_namespace_viewpoints_ui_layout_screen_layout_view {
+    public import memo_viewpoints_ui_layout_views_screen_layout_view::*;
 }
 
 package memo_namespace_viewpoints_verification_verification_coverage_view {
-    public import memo_viewpoints_verification_verification_coverage_view::*;
+    public import memo_viewpoints_verification_views_verification_coverage_view::*;
 }

package/src/methodology/core/memo_core.sysml

@@ -1,8 +1,11 @@
 package memo_methodology_core {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
+    private import memo_core_relationships::*;   // MemoRelationship
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
+    private import memo_core_consistency_rules::*;
 
     part def MethodologyLibrary :> MemoPart {
         attribute version : String;
@@ -10,18 +13,56 @@ package memo_methodology_core {
         attribute :>> description : String;
     }
 
+    // A rule's disposition under one methodology or project binding.
+    //
+    // `targetRule` and `replacementRule` are typed references to the rule's own
+    // `constraint def`, narrowed at the usage with `ref :>> targetRule : <Rule>`.
+    // There is deliberately no `targetRuleId : String`: a qualified SysML
+    // reference already identifies the rule, and a parallel string namespace
+    // would be a MEMO-specific identifier where the language has one. The
+    // stable rule ID survives on the rule itself, for audit records and
+    // diagnostics — a different job from being the reference mechanism.
+    part def RulePolicy :> MemoPart {
+        ref targetRule : MemoConsistencyRule;
+        // A replacement must be another native constraint. A methodology
+        // cannot replace a predicate with a string expression stored here.
+        ref replacementRule : MemoConsistencyRule[0..1];
+        attribute disposition : RuleDispositionKind;
+        attribute severityOverride : RuleSeverityKind[0..1];
+        attribute rationaleText : String;
+        attribute authority : String;
+        attribute approvalReference : String[0..1];
+        attribute approvedBy : String[0..1];
+        attribute approvedOn : String[0..1];
+    }
+
     part def MethodologyDefinition :> MemoPart {
         attribute version : String;
         attribute domain : String;
         attribute :>> description : String;
-        attribute baseMethodName : String;
+        // Exactly one base methodology at most. Multiple inheritance is not a
+        // multiplicity the resolver has conflict semantics for, so the model
+        // does not permit expressing it.
+        ref baseMethodology : MethodologyDefinition[0..1];
+        // Whether the inclusion lists below are the whole story. Under
+        // `explicit`, an empty list selects nothing.
+        attribute scopeMode : ScopeModeKind;
         // A methodology is an inclusion set. Layer entries normally name a
         // public MEMO layer namespace; module entries may name any qualified
         // package available to the project, including packages outside MEMO.
         attribute includedLayer : String[0..*];
         attribute includedModule : String[0..*];
+        attribute includedStandard : String[0..*];
+        attribute includedArtifactKind : String[0..*];
+        attribute includedViewpoint : String[0..*];
+        part rulePolicy : RulePolicy[0..*];
     }
 
+    // Derived, never authored. The resolver projects this from a binding and
+    // its methodology chain. If it is serialized for review it is generated
+    // output that records its input hashes; it does not compete with the
+    // authored methodology and binding, and ontology source declares no
+    // instances of it.
     part def ResolvedMethodology :> MemoPart {
         attribute version : String;
         // The effective inclusion set after the project binding has added any
@@ -32,10 +73,22 @@ package memo_methodology_core {
 
     part def ProjectMethodBinding :> MemoPart {
         attribute projectName : String;
-        attribute methodologyName : String;
+        ref selectedMethodology : MethodologyDefinition;
+        // Additive: what the project adds on top of the selected methodology.
+        // An empty list under `explicit` means no project additions.
+        attribute scopeMode : ScopeModeKind;
         // Project bindings may add project or supplier modules to the selected
         // methodology without requiring those packages to live under memo::.
         attribute includedModule : String[0..*];
+        // The submission regimes this project targets, declared once here.
+        // Everything downstream that needs to know which standards apply —
+        // `memo standards check`, the standards checklist, the Architect gap
+        // badges — reads this, so the regime axis is a project fact stated in
+        // SysML rather than a per-document array maintained in 44 places.
+        // Empty means the project has not declared its regimes; a report that
+        // needs them says so rather than assuming a default market.
+        attribute regulatoryRegime : RegulatoryRegimeKind[0..*];
+        part rulePolicy : RulePolicy[0..*];
     }
 
     part def DhfDocumentBinding :> MemoPart {
@@ -56,4 +109,18 @@ package memo_methodology_core {
         attribute includedStandard : String;
         attribute templateDir : String;
     }
+
+    // ── Relations owned by this package ─────────────────────────────
+    // Moved out of memo_core_relationships: their ends are typed against
+    // types declared here, and core must not depend on a domain package.
+    connection def ResolvesToMethodology :> MemoRelationship {
+        end boundModelElement : MemoPart :>> source;
+        end resolvedMethodology : MethodologyDefinition :>> target;
+    }
+    abstract connection resolvesToMethodologyLinks : ResolvesToMethodology[*];
+    metadata def <resolvesToMethodology> ResolvesToMethodologyMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = resolvesToMethodologyLinks meta SysML::Usage;
+    }
 }

package/src/methodology/profiles/memo_profiles.sysml

@@ -17,23 +17,26 @@ package memo_methodology_profiles {
         attribute :>> description = "Methodology layer for selecting, restricting, sequencing, tailoring, and lightly extending use of the medical-device ontology.";
     }
 
-    part mdLightDefaultDefinition : MethodologyDefinition {
-        attribute :>> id = "METH-001";
-        attribute :>> name = "MedicalDeviceLightDefault";
-        attribute :>> version = "0.1";
+    // The default methodology deliberately selects everything the project's
+    // resolved reusable packages provide. That is what `scopeMode` exists to
+    // say: `allAvailable` is an authored decision, not an empty list that the
+    // resolver silently reads as "allow everything". Under `allAvailable` the
+    // inclusion lists must stay empty — authoring both would leave two
+    // competing answers to the same question.
+    //
+    // Before the flip this methodology carried a narrower `includedLayer` /
+    // `includedModule` pair that nothing consumed: effective scope came from
+    // the separate `mdCoverageScope : MethodologyScope` part, whose lists said
+    // "all five architecture layers, all five assurance disciplines". Folding
+    // that into `allAvailable` preserves the effective result and removes the
+    // second scope authority.
+    part mdDefaultDefinition : MethodologyDefinition {
+        attribute :>> id = "METH-MD-DEFAULT";
+        attribute :>> name = "MedicalDeviceDefault";
+        attribute :>> version = "0.6.5";
         attribute :>> domain = "medical device modeling";
-        attribute :>> description = "Light default methodology around the ontology for smaller or early project use.";
-        attribute :>> baseMethodName = "";
-        attribute :>> includedLayer = ("memo::architecture::operational", "memo::architecture::functional", "memo::architecture::logical");
-        attribute :>> includedModule = ("memo::assurance::requirements", "memo::assurance::safety_risk", "memo::assurance::verification_validation");
-    }
-
-    part mdLightDefaultResolved : ResolvedMethodology {
-        attribute :>> id = "RMETH-001";
-        attribute :>> name = "MedicalDeviceLightDefaultResolved";
-        attribute :>> version = "0.1";
-        attribute :>> includedLayer = ("memo::architecture::operational", "memo::architecture::functional", "memo::architecture::logical");
-        attribute :>> includedModule = ("memo::assurance::requirements", "memo::assurance::safety_risk", "memo::assurance::verification_validation");
+        attribute :>> description = "MEMO default medical-device methodology. Selects every layer, discipline, standard, artifact kind, and viewpoint the resolved ontology and extension packages provide.";
+        attribute :>> scopeMode = ScopeModeKind::allAvailable;
     }
 
     part useRiskAndResidualRule : ElementUsageRule {
@@ -47,7 +50,7 @@ package memo_methodology_profiles {
     part requireVerifiedByRule : RelationUsageRule {
         attribute :>> id = "RULE-002";
         attribute :>> name = "VerifiedBysRequired";
-        attribute :>> relationTypeName = "VerifiedBy";
+        attribute :>> relationTypeName = "verify";
         attribute :>> strength = RuleStrengthKind::required;
         attribute :>> rationaleText = "Safety-relevant requirements and controls shall trace to verification.";
     }
@@ -68,45 +71,44 @@ package memo_methodology_profiles {
         attribute :>> strength = RuleStrengthKind::required;
     }
 
-    part stepRequirements : WorkflowStep {
+    action stepRequirements : MethodologyWorkflowStep {
         attribute :>> id = "STEP-001";
         attribute :>> name = "CaptureRequirements";
-        attribute :>> stepOrder = 1;
         attribute :>> stage = WorkflowStageKind::requirements;
         attribute :>> objectiveDescription = "Capture stakeholder needs and derive requirements.";
         attribute :>> entryCriteria = "Intended use and actors understood.";
         attribute :>> exitCriteria = "Initial requirement set exists.";
     }
 
-    part stepArchitecture : WorkflowStep {
+    action stepArchitecture : MethodologyWorkflowStep {
         attribute :>> id = "STEP-002";
         attribute :>> name = "DefineArchitecture";
-        attribute :>> stepOrder = 2;
         attribute :>> stage = WorkflowStageKind::architecture;
         attribute :>> objectiveDescription = "Define key software and hardware architecture elements and interfaces.";
         attribute :>> entryCriteria = "Initial requirements exist.";
         attribute :>> exitCriteria = "Core architecture and interfaces exist.";
     }
 
-    part stepRisk : WorkflowStep {
+    action stepRisk : MethodologyWorkflowStep {
         attribute :>> id = "STEP-003";
         attribute :>> name = "PerformRiskAnalysis";
-        attribute :>> stepOrder = 3;
         attribute :>> stage = WorkflowStageKind::risk;
         attribute :>> objectiveDescription = "Create core risk chain and controls.";
         attribute :>> entryCriteria = "Initial requirements and key behavior exist.";
         attribute :>> exitCriteria = "Risk and control model exists.";
     }
 
-    part stepVerification : WorkflowStep {
+    action stepVerification : MethodologyWorkflowStep {
         attribute :>> id = "STEP-004";
         attribute :>> name = "PlanVerification";
-        attribute :>> stepOrder = 4;
         attribute :>> stage = WorkflowStageKind::verificationStage;
         attribute :>> objectiveDescription = "Define verification and evidence expectations.";
         attribute :>> entryCriteria = "Requirements and controls exist.";
         attribute :>> exitCriteria = "Verification cases and evidence targets exist.";
     }
+    first stepRequirements then stepArchitecture;
+    first stepArchitecture then stepRisk;
+    first stepRisk then stepVerification;
 
     part gateLightComplete : QualityGate {
         attribute :>> id = "GATE-001";
@@ -115,22 +117,10 @@ package memo_methodology_profiles {
         attribute :>> passCriteria = "Core traceability, risk, verification, and RMF view support are present.";
     }
 
-    part mdCoverageScope : MethodologyScope {
-        attribute :>> id = "SCOPE-COV-001";
-        attribute :>> name = "MedicalDeviceCoverageScope";
-        attribute :>> scopeName = "coverage";
-
-        attribute :>> includedArchLayer = ("memo::architecture::operational", "memo::architecture::functional", "memo::architecture::logical", "memo::architecture::implementation", "memo::architecture::realization");
-        attribute :>> includedModule = ("memo::assurance::requirements", "memo::assurance::safety_risk", "memo::assurance::cybersecurity", "memo::assurance::human_factors", "memo::assurance::verification_validation");
-        attribute :>> description = "Comprehensive default MEMO layer and module selection.";
-    }
-
-    part gpcaProjectBinding : ProjectMethodBinding {
-        attribute :>> id = "PMB-001";
-        attribute :>> name = "GPCAProjectMethodBinding";
-        attribute :>> projectName = "GPCA";
-        attribute :>> methodologyName = "MedicalDeviceLightDefault";
-    }
+    // The GPCA binding used to live here, in the reusable default methodology,
+    // naming its methodology by string. A project binding is project content:
+    // it now lives in the GPCA project's own `model/catalog/project.sysml` and
+    // references its methodology with a typed SysML reference.
 
     part rmpDoc : DhfDocumentBinding {
         attribute :>> id = "DHF-001";

package/src/methodology/workflow/memo_workflow.sysml

@@ -4,8 +4,13 @@ package memo_methodology_workflow {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def WorkflowStep :> MemoPart {
-        attribute stepOrder : Integer;
+    // Named for its axis: this is a step in a METHODOLOGY workflow (a lifecycle
+    // stage with entry/exit criteria), distinct from
+    // memo_architecture_operational_workflows::WorkflowStep, which is a step in
+    // an OPERATIONAL workflow performed by users. The two carry different
+    // attributes and must not share a short name — an overloaded name resolves
+    // by load order and silently validates a usage against the wrong type.
+    action def MethodologyWorkflowStep :> MemoAction {
         attribute stage : WorkflowStageKind;
         attribute objectiveDescription : String;
         attribute entryCriteria : String;