@memoarchitect/ontology 0.4.6 → 0.6.1

package/examples/sysml-diagram-samples/model/samples/requirements_view.sysml

@@ -0,0 +1,63 @@
+// Requirements sample (general view kind, `req` diagram type). Stakeholder needs
+// on the left derive into system requirements; `DerivesFrom` edges render as the
+// requirements-diagram trace lines.
+package memo_examples_sysml_diagram_samples_model_samples_requirements_view {
+    private import ScalarValues::*;
+
+    private import memo_assurance_requirements_needs::*;
+    private import memo_assurance_requirements::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    requirement needSafeTherapy : Need {
+        attribute :>> needKind = NeedKind::stakeholder;
+        attribute :>> id = "NEED-001"; attribute :>> name = "SafeTherapy";
+        attribute :>> statement = "The device shall support safe patient-controlled infusion therapy.";
+    }
+    requirement needTimelyAlarms : Need {
+        attribute :>> needKind = NeedKind::stakeholder;
+        attribute :>> id = "NEED-002"; attribute :>> name = "TimelyAlarms";
+        attribute :>> statement = "Clinicians shall be notified promptly of any condition that endangers therapy.";
+    }
+
+    requirement reqDoseLimit : Requirement {
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> id = "REQ-001"; attribute :>> name = "DoseLimitEnforcement";
+        attribute :>> statement = "The pump shall not deliver more than the prescribed maximum dose in any one-hour window.";
+    }
+    requirement reqOcclusionAlarm : Requirement {
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> id = "REQ-002"; attribute :>> name = "OcclusionAlarm";
+        attribute :>> statement = "The pump shall raise an alarm within two seconds of detecting a downstream occlusion.";
+    }
+    requirement reqAlarmLoudness : Requirement {
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> id = "REQ-003"; attribute :>> name = "AlarmLoudness";
+        attribute :>> statement = "An active alarm shall be audible at 65 dBA at one metre.";
+    }
+
+    connection : DerivesFrom connect sourceDriver ::> needSafeTherapy to targetRequirement ::> reqDoseLimit;
+    connection : DerivesFrom connect sourceDriver ::> needSafeTherapy to targetRequirement ::> reqOcclusionAlarm;
+    connection : DerivesFrom connect sourceDriver ::> needTimelyAlarms to targetRequirement ::> reqOcclusionAlarm;
+    connection : DerivesFrom connect sourceDriver ::> needTimelyAlarms to targetRequirement ::> reqAlarmLoudness;
+
+    view sampleRequirementsView : MemoDiagramView {
+        expose needSafeTherapy::**;
+        expose needTimelyAlarms::**;
+        attribute depth = 1;
+        attribute :>> title = "Sample · Requirements";
+        attribute :>> shortDescription = "Stakeholder needs deriving into system requirements, wired by DerivesFrom trace edges.";
+        attribute :>> viewKind = DiagramViewKind::general;
+        attribute :>> diagramType = "req";
+        part :>> selectionQuery {
+            attribute :>> includeRelationshipKinds = ("DerivesFrom");
+        }
+    }
+
+    connection : IncludedIn connect sourceElement ::> needSafeTherapy to targetView ::> sampleRequirementsView;
+    connection : IncludedIn connect sourceElement ::> needTimelyAlarms to targetView ::> sampleRequirementsView;
+    connection : IncludedIn connect sourceElement ::> reqDoseLimit to targetView ::> sampleRequirementsView;
+    connection : IncludedIn connect sourceElement ::> reqOcclusionAlarm to targetView ::> sampleRequirementsView;
+    connection : IncludedIn connect sourceElement ::> reqAlarmLoudness to targetView ::> sampleRequirementsView;
+}

package/examples/sysml-diagram-samples/model/samples/state_transition_view.sysml

@@ -0,0 +1,109 @@
+// State transition sample (statetransition view kind, `stm` diagram type). A
+// behaviour machine owns its mode states; each Transition carries `sourceState`
+// / `targetState` naming the states it connects, and renders as a labelled edge.
+package memo_examples_sysml_diagram_samples_model_samples_state_transition_view {
+    private import ScalarValues::*;
+
+    private import memo_architecture_functional_behavior::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    state pumpModes : StateMachine { attribute :>> name = "Pump Operating Modes"; }
+
+    state idle : ModeState { attribute :>> name = "Idle"; }
+    state infusing : ModeState { attribute :>> name = "Infusing"; }
+    state paused : ModeState { attribute :>> name = "Paused"; }
+    state alarm : ModeState { attribute :>> name = "Alarm"; }
+
+    // Infusing is a composite state: its substates show what the pump is doing
+    // while it is infusing, and the machine renders them nested inside it.
+    state priming : ModeState { attribute :>> name = "Priming"; }
+    state delivering : ModeState { attribute :>> name = "Delivering"; }
+    state holding : ModeState { attribute :>> name = "Holding (KVO)"; }
+
+    part tStart : Transition {
+        attribute :>> name = "start";
+        attribute :>> trigger = "startInfusion";
+        attribute :>> sourceState = "Idle"; attribute :>> targetState = "Infusing";
+    }
+    part tPause : Transition {
+        attribute :>> name = "pause";
+        attribute :>> trigger = "pauseRequested";
+        attribute :>> sourceState = "Infusing"; attribute :>> targetState = "Paused";
+    }
+    part tResume : Transition {
+        attribute :>> name = "resume";
+        attribute :>> trigger = "resumeRequested";
+        attribute :>> sourceState = "Paused"; attribute :>> targetState = "Infusing";
+    }
+    part tFault : Transition {
+        attribute :>> name = "fault";
+        attribute :>> trigger = "occlusionDetected";
+        attribute :>> sourceState = "Infusing"; attribute :>> targetState = "Alarm";
+    }
+    part tRecover : Transition {
+        attribute :>> name = "acknowledge";
+        attribute :>> trigger = "alarmCleared";
+        attribute :>> sourceState = "Alarm"; attribute :>> targetState = "Idle";
+    }
+    part tStop : Transition {
+        attribute :>> name = "stop";
+        attribute :>> trigger = "stopInfusion";
+        attribute :>> sourceState = "Infusing"; attribute :>> targetState = "Idle";
+    }
+
+    part tPrimed : Transition {
+        attribute :>> name = "primed";
+        attribute :>> trigger = "primeComplete";
+        attribute :>> sourceState = "Priming"; attribute :>> targetState = "Delivering";
+    }
+    part tKvo : Transition {
+        attribute :>> name = "keepVeinOpen";
+        attribute :>> trigger = "doseComplete";
+        attribute :>> sourceState = "Delivering"; attribute :>> targetState = "Holding (KVO)";
+    }
+    part tResumeDose : Transition {
+        attribute :>> name = "resumeDose";
+        attribute :>> trigger = "doseScheduled";
+        attribute :>> sourceState = "Holding (KVO)"; attribute :>> targetState = "Delivering";
+    }
+
+    connection : Composes connect parent ::> pumpModes to child ::> idle;
+    connection : Composes connect parent ::> pumpModes to child ::> infusing;
+    connection : Composes connect parent ::> pumpModes to child ::> paused;
+    connection : Composes connect parent ::> pumpModes to child ::> alarm;
+    connection : Composes connect parent ::> infusing to child ::> priming;
+    connection : Composes connect parent ::> infusing to child ::> delivering;
+    connection : Composes connect parent ::> infusing to child ::> holding;
+
+    view sampleStateTransitionView : MemoDiagramView {
+        expose pumpModes::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · State Transition";
+        attribute :>> shortDescription = "A pump-mode state machine — Idle, Infusing, Paused, Alarm — where Infusing is a composite state nesting Priming, Delivering and Holding.";
+        attribute :>> viewKind = DiagramViewKind::statetransition;
+        attribute :>> diagramType = "stm";
+        part :>> selectionQuery {
+            attribute :>> includeElementKinds = ("StateMachine", "ModeState", "Transition");
+        }
+    }
+
+    connection : IncludedIn connect sourceElement ::> pumpModes to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> idle to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> infusing to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> paused to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> alarm to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tStart to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tPause to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tResume to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tFault to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tRecover to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tStop to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> priming to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> delivering to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> holding to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tPrimed to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tKvo to targetView ::> sampleStateTransitionView;
+    connection : IncludedIn connect sourceElement ::> tResumeDose to targetView ::> sampleStateTransitionView;
+}

package/examples/{gpca-pump → sysml-diagram-samples}/model/samples/tree_view.sysml

@@ -1,8 +1,8 @@
-package memo_examples_gpca_pump_model_samples_tree_view {
+package memo_examples_sysml_diagram_samples_model_samples_tree_view {
     private import ScalarValues::*;
-    private import memo_architecture_hardware_structure::*;
+    private import memo_architecture_implementation_hardware_structure::*;
 
-    private import memo_architecture_physical::*;
+    private import memo_architecture_realization_physical::*;
     private import memo_core_relationships::*;
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;

package/examples/sysml-diagram-samples/model/samples/use_case_view.sysml

@@ -0,0 +1,81 @@
+package memo_examples_sysml_diagram_samples_model_samples_use_case_view {
+    private import ScalarValues::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_architecture_operational_use_cases::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    // Product-neutral fixture for the UML-style use-case presentation.
+    part patient : User {
+        attribute :>> actorKind = ActorKind::patient;
+        attribute :>> name = "Patient";
+    }
+    part clinician : User {
+        attribute :>> actorKind = ActorKind::clinician;
+        attribute :>> name = "Clinician";
+    }
+    part serviceTechnician : User {
+        attribute :>> actorKind = ActorKind::technician;
+        attribute :>> name = "Service Technician";
+    }
+
+    use case reviewStatus : UseCase {
+        attribute :>> id = "UC-SAMPLE-001";
+        attribute :>> name = "Review Device Status";
+        attribute :>> useCaseKind = UseCaseKind::clinical;
+    }
+    use case configureTherapy : UseCase {
+        attribute :>> id = "UC-SAMPLE-002";
+        attribute :>> name = "Configure Therapy";
+        attribute :>> useCaseKind = UseCaseKind::clinical;
+    }
+    use case maintainDevice : UseCase {
+        attribute :>> id = "UC-SAMPLE-003";
+        attribute :>> name = "Maintain Device";
+        attribute :>> useCaseKind = UseCaseKind::service;
+    }
+
+    use case documentTreatment : UseCase {
+        attribute :>> id = "UC-SAMPLE-004";
+        attribute :>> name = "Document Treatment";
+        attribute :>> useCaseKind = UseCaseKind::clinical;
+    }
+
+    // L2 child of Review Device Status: makes L0 → L1 → L2 selectable.
+    use case validateTherapySettings : UseCase {
+        attribute :>> id = "UC-SAMPLE-005";
+        attribute :>> name = "Validate Therapy Settings";
+        attribute :>> useCaseKind = UseCaseKind::clinical;
+    }
+
+    connection : Initiates connect initiatingUser ::> clinician to initiatedUseCase ::> configureTherapy;
+    connection : ParticipatesIn connect participant ::> patient to useCase ::> reviewStatus;
+    connection : ParticipatesIn connect participant ::> patient to useCase ::> configureTherapy;
+    connection : ParticipatesIn connect participant ::> serviceTechnician to useCase ::> maintainDevice;
+    connection : ParticipatesIn connect participant ::> clinician to useCase ::> validateTherapySettings;
+    connection : Includes connect includingUseCase ::> configureTherapy to includedUseCase ::> reviewStatus;
+    connection : Includes connect includingUseCase ::> reviewStatus to includedUseCase ::> validateTherapySettings;
+    connection : Extends connect extendingUseCase ::> documentTreatment to extendedUseCase ::> reviewStatus;
+
+    view sampleUseCaseView : MemoDiagramView {
+        expose patient;
+        expose clinician;
+        expose serviceTechnician;
+        expose reviewStatus;
+        expose configureTherapy;
+        expose maintainDevice;
+        expose documentTreatment;
+        expose validateTherapySettings;
+        attribute :>> title = "Sample · Device Use Cases";
+        attribute :>> shortDescription = "Actors outside a device boundary with include, extend, hierarchy-level, and orthogonal-routing presentation.";
+        attribute :>> viewKind = DiagramViewKind::general;
+        attribute :>> diagramType = "ucd";
+        part :>> selectionQuery {
+            attribute :>> includeElementKinds = ("User", "UseCase");
+            attribute :>> includeRelationshipKinds = ("Initiates", "ParticipatesIn", "Includes", "Extends");
+        }
+        // Presentation is owned by the model view, rather than a canvas control.
+        attribute :>> layoutHint = "usecase:level=all;edge=rounded";
+    }
+}

package/examples/temperature-alarm/README.md

@@ -0,0 +1,7 @@
+# Temperature alarm
+
+A focused MEMO example for patient-temperature monitoring and alarming.
+
+- `model/temperature_alarm.sysml` is the public parent package.
+- `model/catalog/` holds the canonical model elements.
+- `model/viewpoints/` holds diagram views of that catalog.

package/examples/temperature-alarm/model/catalog/temperature_alarm.sysml

@@ -0,0 +1,140 @@
+// Focused example: patient-temperature monitoring with an alarm — the
+// assurance chain end to end. Use case → function → logical channel → UI
+// alarm element → use error → hazard → risk control (implemented by the UI)
+// → verification + usability validation → evidence. Demonstrates Phase 4
+// integration: one element participates in several disciplines at once
+// without duplication.
+package memo_examples_temperature_alarm {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_dimensions::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_assurance_requirements_needs::*;
+    private import memo_architecture_operational_use_cases::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_operational_scenarios::*;
+    private import memo_architecture_functional_functions::*;
+    private import memo_architecture_logical_structure::*;
+    private import memo_assurance_safety_risk::*;
+    private import memo_assurance_verification_validation::*;
+    private import memo_assurance_human_factors::*;
+    private import memo_architecture_implementation_ui::*;
+    private import memo_core_relationships::*;
+
+    // ── Operational intent ──────────────────────────────────────
+    part icuNurse : User {
+        attribute :>> actorKind = ActorKind::clinician;
+        attribute :>> id = "TA-USR-001"; attribute :>> name = "ICUNurse";
+    }
+    use case ucMonitorTemp : UseCase {
+        attribute :>> useCaseKind = UseCaseKind::clinical;
+        attribute :>> id = "TA-UC-001";
+        attribute :>> name = "MonitorPatientTemperature";
+        attribute :>> goalStatement = "Continuously monitor core temperature and be alerted when it leaves the safe range.";
+    }
+    action actAcknowledgeAlarm : OperationalActivity {
+        attribute :>> id = "TA-ACT-001"; attribute :>> name = "ReviewAndAcknowledgeAlarm";
+        attribute :>> criticality = CriticalityKind::high;
+    }
+    action taskAckAlarm : UserTask {
+        attribute :>> criticality = CriticalityKind::high;
+        attribute :>> id = "TA-TASK-001"; attribute :>> name = "AcknowledgeTemperatureAlarm";
+        attribute :>> taskGoal = "recognize, assess, and acknowledge the alarm";
+        attribute :>> potentialHarm = "delayed intervention for hypo-/hyperthermia";
+        attribute :>> severityIfFailed = SeverityKind::serious;
+    }
+    connection : Initiates connect initiatingUser ::> icuNurse to initiatedUseCase ::> ucMonitorTemp;
+    connection : Composes connect parent ::> actAcknowledgeAlarm to child ::> taskAckAlarm;
+
+    // ── Functional and logical slices ───────────────────────────
+    part fnDetectDeviation : SystemFunction {
+        attribute :>> id = "TA-FN-001"; attribute :>> name = "DetectTemperatureDeviation";
+        attribute :>> criticality = CriticalityKind::high;
+        // This function is owned by the functional architecture layer (its
+        // package). Its safety and verification character are typed
+        // relationships to assurance-owned elements, not tags on the function.
+    }
+    part chMonitor : LogicalComponent {
+        attribute :>> id = "TA-LC-001"; attribute :>> name = "TemperatureMonitorChannel";
+        attribute :>> channelRole = ChannelRoleKind::monitor;
+    }
+    part chPrimary : LogicalComponent {
+        attribute :>> id = "TA-LC-002"; attribute :>> name = "MeasurementChannel";
+        attribute :>> channelRole = ChannelRoleKind::primary;
+    }
+    connection : IndependentOf connect channel ::> chMonitor to otherChannel ::> chPrimary {
+        attribute :>> independenceBasis = "separate sensing element and power rail";
+    }
+    connection : AllocatedTo connect function ::> fnDetectDeviation to allocatedElement ::> chMonitor;
+
+    // ── UI: alarm element and acknowledgement action ────────────
+    part uiBedside : UserInterface {
+        attribute :>> id = "TA-UI-001"; attribute :>> name = "BedsideDisplay";
+        attribute :>> modality = "visual + audible";
+    }
+    part elAlarmBanner : UIElement {
+        attribute :>> id = "TA-EL-001"; attribute :>> name = "TempAlarmBanner";
+        attribute :>> alarmPriority = NotificationPriorityKind::high;
+        attribute :>> annunciationModality = "flashing banner + tone";
+        attribute :>> silenceable = true;
+    }
+    action uiaAcknowledge : UIAction {
+        attribute :>> id = "TA-UIA-001"; attribute :>> name = "AcknowledgeAlarm";
+        attribute :>> intent = InteractionIntentKind::acknowledgement;
+        attribute :>> confirmationRequired = true;
+    }
+    connection : ElementTriggersAction connect element ::> elAlarmBanner to triggeredAction ::> uiaAcknowledge;
+    connection : ActionInvokesFunction connect uiAction ::> uiaAcknowledge to systemFunction ::> fnDetectDeviation;
+    connection : Supports { attribute :>> supportKind = SupportKind::task; connect supporter ::> uiBedside to supported ::> taskAckAlarm; }
+
+    // ── Risk chain with use error ───────────────────────────────
+    part ueSilenceAndForget : UseError {
+        attribute :>> id = "TA-UE-001"; attribute :>> name = "SilenceWithoutAssessment";
+        attribute :>> errorCategory = UseErrorCategoryKind::memoryRecall;
+        attribute :>> severity = SeverityKind::serious;
+    }
+    item hzUndetectedDeviation : Hazard {
+        attribute :>> id = "TA-HZ-001"; attribute :>> name = "UndetectedTemperatureDeviation";
+        attribute :>> hazardType = HazardTypeKind::informationError;
+        attribute :>> severity = SeverityKind::serious;
+        attribute :>> foreseeable = true;
+    }
+    item rcReAnnunciate : RiskControlMeasure {
+        attribute :>> id = "TA-RC-001"; attribute :>> name = "AutoReAnnunciationAfterSilence";
+        attribute :>> controlKind = RiskControlKind::alarm;
+        attribute :>> implementationKind = RiskControlImplementationKind::softwareDesign;
+    }
+    connection : CommitsUseError connect task ::> taskAckAlarm to useError ::> ueSilenceAndForget;
+    connection : Causes { attribute :>> causeKind = CauseKind::useErrorLeadsToHazard; connect cause ::> ueSilenceAndForget to effect ::> hzUndetectedDeviation; }
+    connection : Mitigates { attribute :>> mitigationKind = MitigationKind::hazard; connect control ::> rcReAnnunciate to mitigatedElement ::> hzUndetectedDeviation; }
+    connection : ControlImplementedBy connect riskControl ::> rcReAnnunciate to implementingElement ::> elAlarmBanner;
+
+    // ── Verification, validation, evidence ──────────────────────
+    part vsAlarmLatency : VerificationScenario {
+        attribute :>> id = "TA-VS-001"; attribute :>> name = "AlarmLatencyScenario";
+        attribute :>> variantKind = ScenarioVariantKind::nominal;
+        attribute :>> operationalCondition = OperationalConditionKind::normal;
+        attribute :>> scenarioPurpose = ScenarioPurposeKind::memoVerification;
+        attribute :>> pathSummary = "Induce out-of-range temperature; measure detection-to-annunciation latency.";
+    }
+    verification vcAlarmLatency : VerificationCase {
+        attribute :>> id = "TA-VC-001"; attribute :>> name = "VerifyAlarmLatency";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "annunciation within 2 s of sustained deviation";
+    }
+    part uvAckTask : UsabilityValidation {
+        attribute :>> id = "TA-UV-001"; attribute :>> name = "SummativeAlarmAcknowledgement";
+        attribute :>> participantProfile = "15 ICU nurses, representative shift conditions";
+        attribute :>> participantCount = 15;
+        attribute :>> acceptanceCriteria = "no critical-task failures; all alarms assessed before silencing";
+    }
+    part evLatencyReport : Evidence {
+        attribute :>> id = "TA-EV-001"; attribute :>> name = "AlarmLatencyTestReport";
+        attribute :>> evidenceType = "test report";
+    }
+    connection : ExecutesScenario connect verificationCase ::> vcAlarmLatency to scenario ::> vsAlarmLatency;
+    connection : VerifiedBy connect verificationCase ::> vcAlarmLatency to verificationTarget ::> fnDetectDeviation;
+    connection : Validates connect validationCase ::> uvAckTask to validationTarget ::> taskAckAlarm;
+    connection : ProducesEvidence connect producer ::> vcAlarmLatency to producedEvidence ::> evLatencyReport;
+}

package/examples/temperature-alarm/model/temperature_alarm.sysml

@@ -0,0 +1,4 @@
+// Public entry point for this example. Keep model content in catalog/ and views in viewpoints/.
+package memo_examples_temperature_alarm_parent {
+    public import memo_examples_temperature_alarm::*;
+}

package/examples/temperature-alarm/model/viewpoints/temperature_alarm_overview.sysml

@@ -0,0 +1,13 @@
+package memo_examples_temperature_alarm_viewpoints {
+    private import memo_examples_temperature_alarm::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    view temperatureAlarmOverview : MemoDiagramView {
+        expose memo_examples_temperature_alarm::*;
+        attribute depth = 2;
+        attribute :>> title = "Temperature Alarm Overview";
+        attribute :>> viewKind = DiagramViewKind::general;
+        attribute :>> diagramType = "bdd";
+    }
+}

package/memo.manifest.yaml

@@ -5,9 +5,17 @@ packages:
   "@memoarchitect/methodology-default": ./methodologies/default
   "@memoarchitect/methodology-gpca": ./methodologies/gpca
 init:
-  defaultExtends: "@memoarchitect/medical-modeling-profile"
-  rootImport: "memo_medical_device_library"
-  template: ./template
-  archetypes: ./profile/archetypes.yaml
+  defaultExtends: "@memoarchitect/methodology-default"
+  rootImport: "memo"
+  defaultTemplate: default
+templates:
+  default: ./templates/default
+  samd: ./templates/samd
+  connected-device: ./templates/connected-device
+  monitoring-device: ./templates/monitoring-device
+  infusion-pump: ./templates/infusion-pump
 examples:
   gpca: ./examples/gpca-pump
+  standard-sysml-diagrams: ./examples/sysml-diagram-samples
+  extension-template: ./examples/extensions/template
+  clinical-extension: ./examples/extensions/clinical

package/methodologies/default/memo.package.yaml

@@ -1,5 +1,5 @@
 name: "@memoarchitect/methodology-default"
-version: "0.4.6"
+version: "0.6.1"
 type: methodology
 extends: "@memoarchitect/ontology"
 sysmlDir: "../../src/methodology"

package/methodologies/gpca/memo.package.yaml

@@ -1,9 +1,9 @@
-name: "@memo/methodology-gpca"
-version: "0.4.6"
+name: "@memoarchitect/methodology-gpca"
+version: "0.6.1"
 type: methodology
-extends: "@memo/methodology-default"
+extends: "@memoarchitect/methodology-default"
 sysmlDir: "../../examples/gpca-pump/methodology"
-description: "GPCA infusion pump methodology — subtraction-based tailoring of @memo/methodology-default for the non-networked prototype variant. Excludes cybersecurity and SOUP."
+description: "GPCA infusion pump methodology — subtraction-based tailoring of @memoarchitect/methodology-default for the non-networked prototype variant. Excludes cybersecurity and SOUP."
 license: "MIT"
 tags: ["methodology", "medical-device", "gpca", "tailoring"]
 usage: ["viewpoints", "views", "rules", "gates", "patterns", "profiles", "workflow", "dhf"]

package/ontology/memo.package.yaml

@@ -1,5 +1,5 @@
 name: "@memoarchitect/ontology"
-version: "0.4.6"
+version: "0.6.1"
 type: ontology
 description: "MEMO — the single canonical medical-device ontology: core semantics, the Arcadia-inspired architecture layers (context, requirements, behavior, structure, interfaces, risk, cybersecurity, assurance, …), compliance, viewpoints, views, and invariant rules. One namespace (memo::), one src/ tree."
 license: "MIT"

package/ontology/memo.rendering.yaml

@@ -45,3 +45,40 @@ layers:
   - id: verification
     label: Verification
     color: "#2ECC71"
+
+# Model Explorer taxonomy. This is ontology metadata: Architect receives these
+# values from memo-tools and does not infer MEMO's V-model from source paths.
+explorer:
+  classifications:
+    - { source: activities, domain: architecture, group: operational }
+    - { source: context, domain: architecture, group: operational }
+    # Context has concrete namespaces such as actors and use_context; retain
+    # them when the Explorer receives ontology-derived kinds directly.
+    - { source: actors, domain: architecture, group: operational }
+    - { source: use_context, domain: architecture, group: operational }
+    - { source: workflows, domain: architecture, group: operational }
+    - { source: scenarios, domain: architecture, group: operational }
+    - { source: use_cases, domain: architecture, group: operational }
+    - { source: interaction, domain: architecture, group: operational }
+    - { source: operational, domain: architecture, group: operational }
+    - { source: functions, domain: architecture, group: functional }
+    - { source: behavior, domain: architecture, group: functional }
+    - { source: constraints, domain: architecture, group: functional }
+    - { source: logical_structure, domain: architecture, group: logical }
+    - { source: interfaces, domain: architecture, group: logical }
+    - { source: hardware_structure, domain: architecture, group: implementation }
+    # HardwareAssembly is declared in architecture/implementation/hardware.
+    - { source: implementation, domain: architecture, group: implementation }
+    - { source: software_structure, domain: architecture, group: implementation }
+    - { source: software_runtime, domain: architecture, group: implementation }
+    - { source: physical, domain: architecture, group: realization }
+    - { source: deployment, domain: architecture, group: realization }
+    - { source: needs, domain: assurance, group: requirements }
+    - { source: requirements, domain: assurance, group: requirements }
+    - { source: safety, domain: assurance, group: safety-risk }
+    - { source: safety_analysis, domain: assurance, group: safety-risk }
+    - { source: cybersecurity, domain: assurance, group: cybersecurity }
+    - { source: human_factors, domain: assurance, group: human-factors }
+    - { source: verification, domain: assurance, group: verification-validation }
+    - { source: core, domain: assurance, group: evidence }
+    - { source: methodology, domain: methodology, group: methodology }

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "@memoarchitect/ontology",
-  "version": "0.4.6",
+  "version": "0.6.1",
   "packageManager": "pnpm@9.15.0",
-  "description": "MEMO — Medical Engineering Modelling Ontology. Pure SysML v2 medical-device ontology with native constraints, portable to any conformant SysML v2 tool (SysIDE, SysON, sysand).",
+  "description": "MEMO \u2014 Medical Engineering Modelling Ontology. Pure SysML v2 medical-device ontology with native constraints, portable to any conformant SysML v2 tool (SysIDE, SysON, sysand).",
   "scripts": {
     "build": "bash scripts/build-kpar.sh",
     "check": "bash scripts/build-kpar.sh",
     "test": "node --test test/package.test.mjs",
-    "docs:serve": "python3 -m mkdocs serve",
-    "docs:build": "python3 -m mkdocs build --strict"
+    "docs:api": "node scripts/generate-sysml-api.mjs",
+    "docs:diagrams": "node scripts/generate-reference-diagrams.mjs",
+    "docs:serve": "node scripts/generate-reference-diagrams.mjs && node scripts/generate-sysml-api.mjs && node scripts/check-reference-coverage.mjs && python3 -m mkdocs serve",
+    "docs:build": "node scripts/generate-reference-diagrams.mjs && node scripts/generate-sysml-api.mjs && node scripts/check-reference-coverage.mjs && python3 -m mkdocs build --strict",
+    "docs:check-reference": "node scripts/check-reference-coverage.mjs"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=26.0.0"
   },
   "keywords": [
     "sysml-v2",
@@ -36,7 +39,7 @@
     "./src/*": "./src/*",
     "./profile/*": "./profile/*",
     "./methodologies/*": "./methodologies/*",
-    "./templates/*": "./template/*",
+    "./templates/*": "./templates/*",
     "./examples/*": "./examples/*"
   },
   "files": [
@@ -46,21 +49,26 @@
     "ontology/memo.package.yaml",
     "ontology/memo.rendering.yaml",
     "profile/memo.package.yaml",
-    "profile/archetypes.yaml",
-    "profile/templates/",
     "methodologies/default/memo.package.yaml",
     "methodologies/gpca/memo.package.yaml",
+    "src/assurance/",
     "src/architecture/",
     "src/artifacts/",
     "src/compliance/",
     "src/core/",
-    "src/methodology/*.sysml",
+    "src/methodology/archetypes/",
+    "src/methodology/core/",
+    "src/methodology/gates/",
+    "src/methodology/patterns/",
+    "src/methodology/profiles/",
+    "src/methodology/rules/",
+    "src/methodology/viewpoints/",
+    "src/methodology/workflow/",
     "src/methodology/LICENSES/",
     "src/rules/",
     "src/viewpoints/",
-    "src/medical_device_library.sysml",
     "src/memo_namespaces.sysml",
-    "template/",
+    "templates/",
     "examples/"
   ]
 }

package/profile/memo.package.yaml

@@ -1,9 +1,9 @@
 name: "@memoarchitect/medical-modeling-profile"
-version: "0.4.6"
+version: "0.6.1"
 type: profile
 extends:
   - "@memoarchitect/ontology"
-description: "Closure rules, viewpoints, and starter templates for medical device modeling"
+description: "Closure rules and viewpoints for medical device modeling"
 license: "MIT"
 tags: ["medical-device", "iso-14971", "iec-62304", "iso-13485", "modeling-profile"]
-usage: ["rules", "viewpoints", "templates"]
+usage: ["rules", "viewpoints"]

package/src/architecture/decisions/memo_decisions.sysml

@@ -3,7 +3,7 @@ package memo_architecture_decisions {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def DesignDecision specializes TraceableElement {
+    part def DesignDecision specializes MemoPart {
         attribute decisionKind : String;
         attribute alternatives : String;
         attribute selectedOption : String;