@memoarchitect/ontology 0.4.4

package/src/viewpoints/functional/functional_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_functional_functional_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part functionalViewpoint : Viewpoint {
+        attribute :>> id = "VP-FUNC";
+        attribute :>> name = "FunctionalViewpoint";
+        attribute :>> title = "Functional Viewpoint";
+        attribute :>> shortDescription = "Shows system functions, their decomposition, and allocation.";
+        attribute :>> longDescription = "Default viewpoint derived from the functions layer for what the system does, independent of how it is structured — function trees, function allocation, and behavior triggers.";
+        attribute :>> purpose = "Describe the system's functional decomposition and behavior.";
+        attribute :>> audience = (AudienceKind::systemArchitect);
+        attribute :>> stage = WorkflowStageKind::architecture;
+        attribute :>> abstractionLevel = "functional";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::activityDiagram);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::performance);
+        attribute :>> includedLayers = ("functions", "behavior");
+        attribute :>> allowedElementKinds = ("LogicalFunction", "LogicalFlow", "ModeState");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/functional/system_functional_tree_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_functional_system_functional_tree_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
+
+                view systemFunctionalTreeView : MemoDiagramView {
+                    expose memo_viewpoints_functional_system_functional_tree_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-FUNC-001";
+    attribute :>> name = "SystemFunctionalTreeView";
+    attribute :>> title = "System Functional Tree";
+    attribute :>> shortDescription = "Hierarchical decomposition of system functions.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::activityDiagram);
+    attribute :>> diagramType = "act";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include functions and their decomposition into subfunctions.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-FUNC-001";
+        attribute :>> name = "SystemFunctionalTreeQuery";
+        attribute :>> includeElementKinds = ("LogicalFunction");
+        attribute :>> includeLayers = ("functions");
+        attribute :>> rationaleText = "Auto-populate the functional tree from the functions layer.";
+    }
+    part :>> viewpointDefinition = functionalViewpoint;
+                }
+}

package/src/viewpoints/logical/logical_architecture_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_logical_logical_architecture_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_logical_logical_viewpoint::*;
+
+                view logicalArchitectureView : MemoDiagramView {
+                    expose memo_viewpoints_logical_logical_architecture_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-LOG-001";
+    attribute :>> name = "LogicalArchitectureView";
+    attribute :>> title = "Logical Architecture View";
+    attribute :>> shortDescription = "Logical components and their interfaces.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::blockDiagram);
+    attribute :>> diagramType = "bdd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include logical components and the interfaces that connect them.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-LOG-001";
+        attribute :>> name = "LogicalArchitectureQuery";
+        attribute :>> includeElementKinds = ("LogicalComponent", "Interface");
+        attribute :>> includeLayers = ("logical_structure", "interfaces");
+        attribute :>> rationaleText = "Auto-populate the logical architecture view from the logical structure and interfaces layers.";
+    }
+    part :>> viewpointDefinition = logicalArchitectureViewpoint;
+                }
+}

package/src/viewpoints/logical/logical_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_logical_logical_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part logicalArchitectureViewpoint : Viewpoint {
+        attribute :>> id = "VP-LOG";
+        attribute :>> name = "LogicalArchitectureViewpoint";
+        attribute :>> title = "Logical Viewpoint";
+        attribute :>> shortDescription = "Shows logical decomposition and interfaces.";
+        attribute :>> longDescription = "Default viewpoint derived from the logical architecture layer for subsystem structure, responsibilities, and major interactions, independent of physical realization.";
+        attribute :>> purpose = "Describe the system's logical decomposition.";
+        attribute :>> audience = (AudienceKind::systemArchitect);
+        attribute :>> stage = WorkflowStageKind::architecture;
+        attribute :>> abstractionLevel = "logical";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::blockDiagram);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::performance);
+        attribute :>> includedLayers = ("logical_structure", "interfaces");
+        attribute :>> allowedElementKinds = ("LogicalComponent", "Interface");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/operational/operational_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_operational_operational_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part operationalViewpoint : Viewpoint {
+        attribute :>> id = "VP-OPS";
+        attribute :>> name = "OperationalViewpoint";
+        attribute :>> title = "Operational & Use-Case Viewpoint";
+        attribute :>> shortDescription = "Shows actors, use contexts, operational scenarios, and system capabilities.";
+        attribute :>> longDescription = "Default viewpoint derived from the context, operational, and system layers for how actors use the device — operational scenarios, capabilities, and the functional chains that realize them.";
+        attribute :>> purpose = "Communicate how actors interact with the system and which capabilities they invoke.";
+        attribute :>> audience = (AudienceKind::projectLead, AudienceKind::systemArchitect);
+        attribute :>> stage = WorkflowStageKind::context;
+        attribute :>> abstractionLevel = "operational";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::custom);
+        attribute :>> concernKinds = (ConcernKind::performance, ConcernKind::interoperability);
+        attribute :>> includedLayers = ("context", "operational", "system");
+        attribute :>> allowedElementKinds = ("Actor", "UseContext", "OperationalActivity", "OperationalScenario", "SystemCapability", "FunctionalChain");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/operational/use_case_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_operational_use_case_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_operational_operational_viewpoint::*;
+
+                view useCaseView : MemoDiagramView {
+                    expose memo_viewpoints_operational_use_case_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-OPS-001";
+    attribute :>> name = "UseCaseView";
+    attribute :>> title = "Use Case Overview";
+    attribute :>> shortDescription = "Actors connected to the operational scenarios and capabilities they invoke.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::custom);
+    attribute :>> diagramType = "ucd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include actors, use contexts, and the operational scenarios they participate in.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-OPS-001";
+        attribute :>> name = "UseCaseQuery";
+        attribute :>> includeElementKinds = ("Actor", "UseContext", "OperationalScenario");
+        attribute :>> includeLayers = ("context", "operational");
+        attribute :>> rationaleText = "Auto-populate the use case view from the context and operational layers.";
+    }
+    part :>> viewpointDefinition = operationalViewpoint;
+                }
+}

package/src/viewpoints/physical/network_topology_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_physical_network_topology_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_physical_physical_viewpoint::*;
+
+                view networkTopologyView : MemoDiagramView {
+                    expose memo_viewpoints_physical_network_topology_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-PHY-002";
+    attribute :>> name = "NetworkTopologyView";
+    attribute :>> title = "Network Topology View";
+    attribute :>> shortDescription = "Physical interconnections and network ports between components.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::internalDiagram);
+    attribute :>> diagramType = "ibd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include physical ports and connections that make up the device's network topology.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-PHY-002";
+        attribute :>> name = "NetworkTopologyQuery";
+        attribute :>> includeElementKinds = ("PhysicalPort", "ProcessingNode");
+        attribute :>> includeLayers = ("physical");
+        attribute :>> rationaleText = "Auto-populate the network topology view from the physical interfaces layer.";
+    }
+    part :>> viewpointDefinition = physicalViewpoint;
+                }
+}

package/src/viewpoints/physical/physical_bom_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_physical_physical_bom_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_physical_physical_viewpoint::*;
+
+                view physicalBOMView : MemoDiagramView {
+                    expose memo_viewpoints_physical_physical_bom_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-PHY-001";
+    attribute :>> name = "PhysicalBOMView";
+    attribute :>> title = "Physical Bill of Materials View";
+    attribute :>> shortDescription = "Physical and hardware components with their decomposition.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::blockDiagram);
+    attribute :>> diagramType = "bdd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include physical and hardware components and their assembly structure.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-PHY-001";
+        attribute :>> name = "PhysicalBOMQuery";
+        attribute :>> includeElementKinds = ("ProcessingNode", "HardwareAssembly");
+        attribute :>> includeLayers = ("hardware_structure", "physical");
+        attribute :>> rationaleText = "Auto-populate the physical BOM view from the hardware and physical layers.";
+    }
+    part :>> viewpointDefinition = physicalViewpoint;
+                }
+}

package/src/viewpoints/physical/physical_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_physical_physical_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part physicalViewpoint : Viewpoint {
+        attribute :>> id = "VP-PHY";
+        attribute :>> name = "PhysicalViewpoint";
+        attribute :>> title = "Physical Viewpoint";
+        attribute :>> shortDescription = "Shows physical components, hardware structure, and their interconnections.";
+        attribute :>> longDescription = "Default viewpoint derived from the physical and hardware structure layers for bill-of-materials, hardware decomposition, physical interfaces, and network/connectivity topology.";
+        attribute :>> purpose = "Describe the system's physical realization and interconnections.";
+        attribute :>> audience = (AudienceKind::hardwareEngineer);
+        attribute :>> stage = WorkflowStageKind::architecture;
+        attribute :>> abstractionLevel = "physical";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::blockDiagram);
+        attribute :>> concernKinds = (ConcernKind::reliability, ConcernKind::interoperability);
+        attribute :>> includedLayers = ("hardware_structure", "physical");
+        attribute :>> allowedElementKinds = ("ProcessingNode", "HardwareAssembly", "PhysicalPort");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/requirements/requirements_traceability_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_requirements_requirements_traceability_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_requirements_requirements_viewpoint::*;
+
+                view requirementsTraceabilityView : MemoDiagramView {
+                    expose memo_viewpoints_requirements_requirements_traceability_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-REQ-001";
+    attribute :>> name = "RequirementsTraceabilityView";
+    attribute :>> title = "Requirements Traceability View";
+    attribute :>> shortDescription = "Stakeholder needs traced through system, software, and hardware requirements.";
+    attribute :>> outputKind = (ViewOutputKind::matrix);
+    attribute :>> presentationKind = (PresentationKind::traceMatrix);
+    attribute :>> diagramType = "req";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include stakeholder needs and requirements with their derivation chain.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-REQ-001";
+        attribute :>> name = "RequirementsTraceabilityQuery";
+        attribute :>> includeElementKinds = ("StakeholderNeed", "Requirement", "SystemRequirement", "SoftwareRequirement", "HardwareRequirement");
+        attribute :>> includeLayers = ("requirements");
+        attribute :>> rationaleText = "Auto-populate requirements traceability from the requirements layer.";
+    }
+    part :>> viewpointDefinition = requirementsViewpoint;
+                }
+}

package/src/viewpoints/requirements/requirements_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_requirements_requirements_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part requirementsViewpoint : Viewpoint {
+        attribute :>> id = "VP-REQ";
+        attribute :>> name = "RequirementsViewpoint";
+        attribute :>> title = "Requirements Viewpoint";
+        attribute :>> shortDescription = "Shows stakeholder needs and their decomposition into system, software, and hardware requirements.";
+        attribute :>> longDescription = "Default viewpoint derived from the requirements layer for requirements traceability — the chain from stakeholder need through system, software, and hardware requirements, supporting IEC 62304 §5.1.1 and ISO 13485 §7.3.3.";
+        attribute :>> purpose = "Communicate requirements decomposition and traceability.";
+        attribute :>> audience = (AudienceKind::regulatoryEngineer, AudienceKind::systemArchitect);
+        attribute :>> stage = WorkflowStageKind::requirements;
+        attribute :>> abstractionLevel = "requirements";
+        attribute :>> outputKind = (ViewOutputKind::diagram, ViewOutputKind::matrix);
+        attribute :>> presentationKind = (PresentationKind::traceMatrix);
+        attribute :>> concernKinds = (ConcernKind::regulatory, ConcernKind::safety);
+        attribute :>> includedLayers = ("requirements");
+        attribute :>> allowedElementKinds = ("StakeholderNeed", "Requirement", "SystemRequirement", "SoftwareRequirement", "HardwareRequirement");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/risk/risk_chain_view.sysml

@@ -0,0 +1,30 @@
+package memo_viewpoints_risk_risk_chain_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_risk_risk_viewpoint::*;
+
+                view riskChainView : MemoDiagramView {
+                    expose memo_viewpoints_risk_risk_chain_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-RISK-001";
+    attribute :>> name = "RiskChainView";
+    attribute :>> title = "Risk Mitigation Chain View";
+    attribute :>> shortDescription = "Hazards through harms with controls and verification.";
+    attribute :>> outputKind = (ViewOutputKind::table);
+    attribute :>> presentationKind = (PresentationKind::riskTable);
+    attribute :>> diagramType = "risk";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include hazards, hazardous situations, harms, controls, and verification evidence.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-RISK-001";
+        attribute :>> name = "RiskChainQuery";
+        attribute :>> includeElementKinds = ("Hazard", "HazardousSituation", "Harm", "RiskControl", "VerificationCase");
+        attribute :>> includeLayers = ("risk", "assurance");
+        attribute :>> includeConcerns = (ConcernKind::safety);
+        attribute :>> rationaleText = "Auto-populate the risk chain view from the risk and assurance layers.";
+    }
+    part :>> viewpointDefinition = riskViewpoint;
+                }
+}

package/src/viewpoints/risk/risk_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_risk_risk_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part riskViewpoint : Viewpoint {
+        attribute :>> id = "VP-RISK";
+        attribute :>> name = "RiskViewpoint";
+        attribute :>> title = "Risk and Control Viewpoint";
+        attribute :>> shortDescription = "Shows hazards, risks, controls, and assurance links.";
+        attribute :>> longDescription = "Default viewpoint derived from the risk layer for ISO 14971-style reasoning across hazard, hazardous situation, harm, control, and verification evidence.";
+        attribute :>> purpose = "Communicate safety risk chains and controls.";
+        attribute :>> audience = (AudienceKind::safetyEngineer);
+        attribute :>> stage = WorkflowStageKind::risk;
+        attribute :>> abstractionLevel = "analysis";
+        attribute :>> outputKind = (ViewOutputKind::table);
+        attribute :>> presentationKind = (PresentationKind::riskTable);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::regulatory);
+        attribute :>> includedLayers = ("risk", "assurance");
+        attribute :>> allowedElementKinds = ("Hazard", "HazardousSituation", "Harm", "Risk", "RiskControl", "VerificationCase");
+        attribute :>> methodologyReference = ("iso14971-default");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/software/software_architecture_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_software_software_architecture_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_software_software_viewpoint::*;
+
+                view softwareArchitectureView : MemoDiagramView {
+                    expose memo_viewpoints_software_software_architecture_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-SW-001";
+    attribute :>> name = "SoftwareArchitectureView";
+    attribute :>> title = "Software Architecture View";
+    attribute :>> shortDescription = "Software systems, components, and SOUP with their decomposition.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::blockDiagram);
+    attribute :>> diagramType = "bdd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include software systems, components, and SOUP components with their decomposition.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-SW-001";
+        attribute :>> name = "SoftwareArchitectureQuery";
+        attribute :>> includeElementKinds = ("SoftwareSystem", "SoftwareComponent", "SOUPComponent");
+        attribute :>> includeLayers = ("software_structure");
+        attribute :>> rationaleText = "Auto-populate the software architecture view from the software structure layer.";
+    }
+    part :>> viewpointDefinition = softwareViewpoint;
+                }
+}

package/src/viewpoints/software/software_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_software_software_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part softwareViewpoint : Viewpoint {
+        attribute :>> id = "VP-SW";
+        attribute :>> name = "SoftwareViewpoint";
+        attribute :>> title = "Software Viewpoint";
+        attribute :>> shortDescription = "Shows software systems, components, SOUP, and software interfaces.";
+        attribute :>> longDescription = "Default viewpoint derived from the software structure layer for IEC 62304 software architecture description — software item decomposition, SOUP inventory, and software-to-software interfaces, distinct from system-level logical decomposition.";
+        attribute :>> purpose = "Describe the software architecture for IEC 62304 design documentation.";
+        attribute :>> audience = (AudienceKind::softwareArchitect);
+        attribute :>> stage = WorkflowStageKind::architecture;
+        attribute :>> abstractionLevel = "software";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::blockDiagram);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::reliability);
+        attribute :>> includedLayers = ("software_structure", "interfaces");
+        attribute :>> allowedElementKinds = ("SoftwareSystem", "SoftwareComponent", "SOUPComponent", "SoftwareInterface");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/usability/usability_engineering_view.sysml

@@ -0,0 +1,13 @@
+package memo_viewpoints_usability_usability_engineering_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+
+                view def MemoUsabilityEngineeringView :> MemoDocumentView {
+    attribute :>> viewKind = DocumentViewKind::Usability;
+    attribute :>> generationRule = "Include actors, use contexts, use errors, and requirements tagged with the usability concern to support the Usability Engineering Report.";
+    attribute :>> outputKind = (ViewOutputKind::documentSection);
+    attribute :>> presentationKind = (PresentationKind::narrativeSection);
+                }
+}

package/src/viewpoints/usability/usability_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_usability_usability_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part usabilityViewpoint : Viewpoint {
+        attribute :>> id = "VP-USE";
+        attribute :>> name = "UsabilityViewpoint";
+        attribute :>> title = "Usability Viewpoint";
+        attribute :>> shortDescription = "Shows use contexts, actors, use errors, and usability requirements.";
+        attribute :>> longDescription = "Default viewpoint derived from the context and requirements layers for IEC 62366-1 usability engineering — actors, use contexts, identified use errors, and requirements tagged with the usability concern. Reuses existing context-layer elements (Actor, UseContext, UseError) rather than a separate usability layer.";
+        attribute :>> purpose = "Communicate use-related hazards and usability requirements for the device.";
+        attribute :>> audience = (AudienceKind::usabilityEngineer, AudienceKind::safetyEngineer);
+        attribute :>> stage = WorkflowStageKind::requirements;
+        attribute :>> abstractionLevel = "usability";
+        attribute :>> outputKind = (ViewOutputKind::documentSection);
+        attribute :>> presentationKind = (PresentationKind::narrativeSection);
+        attribute :>> concernKinds = (ConcernKind::usability, ConcernKind::safety);
+        attribute :>> includedLayers = ("context", "requirements");
+        attribute :>> allowedElementKinds = ("Actor", "UseContext", "UseError", "Requirement");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/verification/verification_coverage_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_verification_verification_coverage_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_verification_verification_viewpoint::*;
+
+                view verificationCoverageView : MemoDiagramView {
+                    expose memo_viewpoints_verification_verification_coverage_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-VER-001";
+    attribute :>> name = "VerificationCoverageView";
+    attribute :>> title = "Verification & Validation Coverage View";
+    attribute :>> shortDescription = "Requirements with their verification cases, validation cases, and evidence.";
+    attribute :>> outputKind = (ViewOutputKind::matrix);
+    attribute :>> presentationKind = (PresentationKind::traceMatrix);
+    attribute :>> diagramType = "req";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include requirements and their linked verification/validation cases and evidence.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-VER-001";
+        attribute :>> name = "VerificationCoverageQuery";
+        attribute :>> includeElementKinds = ("Requirement", "VerificationCase", "ValidationCase", "Evidence");
+        attribute :>> includeLayers = ("requirements", "assurance");
+        attribute :>> rationaleText = "Auto-populate V&V coverage from the requirements and assurance layers.";
+    }
+    part :>> viewpointDefinition = verificationViewpoint;
+                }
+}

package/src/viewpoints/verification/verification_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_verification_verification_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part verificationViewpoint : Viewpoint {
+        attribute :>> id = "VP-VER";
+        attribute :>> name = "VerificationViewpoint";
+        attribute :>> title = "Verification & Validation Viewpoint";
+        attribute :>> shortDescription = "Shows verification cases, validation cases, and the evidence they produce, traced to requirements.";
+        attribute :>> longDescription = "Default viewpoint derived from the requirements and assurance layers for V&V coverage — which requirements are verified/validated, by which case, and what evidence was produced, supporting ISO 13485 §7.3.6/§7.3.7 and IEC 62304 §5.7/§5.8.";
+        attribute :>> purpose = "Communicate verification and validation coverage against requirements.";
+        attribute :>> audience = (AudienceKind::verificationEngineer);
+        attribute :>> stage = WorkflowStageKind::verificationStage;
+        attribute :>> abstractionLevel = "verification";
+        attribute :>> outputKind = (ViewOutputKind::matrix);
+        attribute :>> presentationKind = (PresentationKind::traceMatrix);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::regulatory);
+        attribute :>> includedLayers = ("requirements", "assurance");
+        attribute :>> allowedElementKinds = ("Requirement", "VerificationCase", "ValidationCase", "Evidence", "TestArtifact");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/template/memo.package.yaml

@@ -0,0 +1,5 @@
+name: "{{name}}"
+version: "0.1.0"
+type: device
+extends: "@memo/medical-modeling-profile"
+description: "MEMO medical device model project"

package/template/src/catalog/starter.sysml

@@ -0,0 +1,12 @@
+package memo_starter_catalog {
+    import memo_medical_device_library::*;
+
+    part starterSystem : System {
+        attribute redefines name = "{{name}}";
+    }
+
+    requirement mainRequirement : Requirement {
+        attribute redefines title = "Main system requirement";
+        doc /* TODO: define the first system requirement. */
+    }
+}

package/template/src/documents/.gitkeep

@@ -0,0 +1 @@
+

package/template/src/views/.gitkeep

@@ -0,0 +1 @@
+