@memoarchitect/ontology 0.4.6 → 0.6.0

package/src/architecture/operational/use_cases/memo_use_cases.sysml

@@ -0,0 +1,67 @@
+// Use cases (§5). A UseCase is a goal a person or organization wants to
+// achieve with system support — there is no separate Goal class. Clinical,
+// service, manufacturing, and development use cases specialize the same base.
+package memo_architecture_operational_use_cases {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_architecture_operational_context_use_context::*;
+    private import memo_assurance_requirements_needs::*;
+
+    enum def UseCaseKind {
+        enum clinical;
+        enum service;
+        enum manufacturing;
+        enum development;
+    }
+
+    use case def UseCase {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+        // Text of this use case's goal; this is not a separate Goal element.
+        attribute goalStatement : String;
+        attribute trigger : String;
+        attribute preCondition : String;
+        attribute successOutcome : String;
+        attribute failureOutcome : String;
+        attribute postCondition : String;
+        // clinical / service / manufacturing / development
+        attribute useCaseKind : UseCaseKind;
+
+        // The device or system under consideration supports the goal.
+        ref supportingSystem : MemoPart[0..1];
+        ref primaryUser : User[0..1];
+        ref supportingActors : Actor[0..*];
+        ref useContext : UseContext[0..1];
+        ref originatingNeeds : Need[0..*];
+    }
+
+    connection def Motivates :> MemoRelationship {
+        end motivatingNeed : Need;
+        end motivatedUseCase : UseCase;
+    }
+    connection def Initiates :> MemoRelationship {
+        end initiatingUser : User;
+        end initiatedUseCase : UseCase;
+    }
+    connection def ParticipatesIn :> MemoRelationship {
+        end participant : Actor;
+        end useCase : UseCase;
+    }
+    // UML use-case relationships. Includes establishes a decomposition level;
+    // extends remains a cross-cutting relationship and is always presented.
+    connection def Includes :> MemoRelationship {
+        end includingUseCase : UseCase;
+        end includedUseCase : UseCase;
+    }
+    connection def Extends :> MemoRelationship {
+        end extendingUseCase : UseCase;
+        end extendedUseCase : UseCase;
+    }
+}

package/src/architecture/operational/workflows/memo_workflows.sysml

@@ -0,0 +1,126 @@
+// First-class operational workflows. An OperationalWorkflow is
+// a reusable definition of how clinical or service work is performed — it may
+// exist before any device is selected. A scenario (memo_architecture_operational_scenarios) is a
+// selected path through a workflow; an occurrence is an execution of a
+// scenario. Workflows are action defs: steps, decisions, forks/joins, and
+// successions use native SysML v2 action semantics where portable.
+package memo_architecture_operational_workflows {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_operational_use_cases::*;
+
+    // As-is vs. to-be vs. contingency is a typed dimension of the workflow,
+    // not a name suffix.
+    enum def WorkflowStateKind {
+        enum asIs;
+        enum toBe;
+        enum contingency;
+        enum deprecated;
+    }
+
+    enum def StepTransformationKind {
+        enum preserves;
+        enum automates;
+        enum augments;
+        enum eliminates;
+    }
+
+    action def OperationalWorkflow specializes MemoAction {
+        attribute workflowState : WorkflowStateKind;
+        attribute entryCondition : String;
+        attribute completionCondition : String;
+        attribute recoveryPathSummary : String;
+        attribute timingConstraints : String;
+        ref involvedActors : Actor[0..*];
+        attribute environmentSummary : String;
+    }
+
+    // A step in a workflow wraps an operational activity or user task by
+    // reference — the same activity may appear in several workflows.
+    action def WorkflowStep specializes MemoAction {
+        attribute stepOrder : Integer;
+        attribute entryCondition : String;
+        attribute exitCondition : String;
+        ref performedActivity : OperationalActivity[0..1];
+        ref performedTask : UserTask[0..1];
+        ref responsibleRole : Actor[0..1];
+    }
+
+    // decision / fork / join / handoff.
+    enum def ControlNodeKind {
+        enum decision;
+        enum fork;
+        enum join;
+        enum handoff;
+    }
+
+    // A workflow control node. The role is given by controlKind; the
+    // kind-specific fields below are set only for the relevant controlKind.
+    // handoff = transfer of responsibility between roles (shift change, room-to-lab).
+    action def WorkflowControlNode specializes MemoAction {
+        attribute controlKind : ControlNodeKind;
+        attribute decisionQuestion : String[0..1];
+        attribute decisionCriteria : String[0..1];
+        attribute parallelismRationale : String[0..1];
+        attribute joinCondition : String[0..1];
+        attribute informationTransferred : String[0..1];
+        ref fromRole : Actor[0..1];
+        ref toRole : Actor[0..1];
+    }
+
+    // Resources a workflow requires: information, materials, or equipment by
+    // reference.
+    part def WorkflowResource specializes MemoPart {
+        attribute resourceKind : String;
+        attribute quantity : String;
+        ref resolvedProduct : MemoPart[0..1];
+    }
+
+    // ── Workflow-level relationships ─────────────────────────────
+    // Supports unifies SupportsUseCase / SupportsTask / ContributesToCapability
+    // (an element supports a goal/task/capability), keyed by supportKind.
+    enum def SupportKind {
+        enum useCase;
+        enum task;
+        enum capability;
+    }
+    connection def Supports :> MemoRelationship {
+        attribute supportKind : SupportKind;
+        // The accepted endpoints span SysML metaclasses: an operational
+        // workflow or other action may support a use case, task, or
+        // capability. They therefore have no single MEMO base type.
+        end supporter;
+        end supported;
+    }
+    connection def StepPrecedes :> MemoRelationship {
+        attribute guardCondition : String;
+        end predecessor : WorkflowStep;
+        end successor : WorkflowStep;
+    }
+    connection def RequiresResource :> MemoRelationship {
+        end workflow : OperationalWorkflow;
+        end resource : WorkflowResource;
+    }
+
+    // ── Workflow transformation (as-is → to-be) ──────────────────
+    // Transforms unifies TransformsStep / TransformsWorkflow / ReplacesWorkflow
+    // (tailoring of workflow structure: as-is → to-be), keyed by transformKind.
+    enum def TransformKind {
+        enum step;
+        enum workflow;
+        enum replacesWorkflow;
+    }
+    connection def Transforms :> MemoRelationship {
+        attribute transformKind : TransformKind;
+        attribute transformation : StepTransformationKind[0..1];
+        attribute transformationRationale : String[0..1];
+        end source : MemoPart;
+        end target : MemoPart;
+    }
+    // The device or system whose introduction enables a workflow.
+}

package/src/architecture/realization/deployment/memo_deployment.sysml

@@ -0,0 +1,90 @@
+// Deployment (allocation) view: SoftwareModule buildsInto
+// DeploymentUnit; DeploymentUnit deploysTo ProcessingNode; SoftwareComponent
+// hostedBy ProcessingNode. Software deploys only to capable execution nodes
+// (rules/crosslayer).
+package memo_architecture_realization_deployment {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_implementation_software_structure::*;
+    private import memo_architecture_implementation_software_runtime::*;
+    private import memo_architecture_realization_physical::*;
+    private import memo_architecture_functional_functions::*;
+    private import memo_architecture_logical_structure::*;
+
+    part def DeploymentUnit specializes ArchitectureElement {
+        attribute unitKind : String;
+        attribute version : String;
+        attribute integrityProtection : String;
+        attribute installationMechanism : String;
+    }
+
+    part def RuntimeEnvironment specializes ArchitectureElement {
+        attribute environmentKind : String;
+        attribute osOrRtos : String;
+        attribute providedServices : String;
+        attribute certificationEvidence : String;
+    }
+
+    connection def BuildsInto :> MemoRelationship {
+        end module : SoftwareModule;
+        end deploymentUnit : DeploymentUnit;
+    }
+    connection def DeploysTo :> MemoRelationship {
+        attribute deploymentKind : DeploymentKind;
+        end deploymentUnit : DeploymentUnit;
+        end node : ProcessingNode;
+    }
+    connection def ProvidesEnvironment :> MemoRelationship {
+        end node : ProcessingNode;
+        end environment : RuntimeEnvironment;
+    }
+
+    // ─── AADL-style flow modeling (SAE AS5506) ───────────────────────────
+    // AADL separates a flow *specification* (declared at a component boundary
+    // as source / sink / path through ports) from a flow *implementation*
+    // (its routing through subcomponents and connectors), and traces a
+    // complete source→sink flow as an *end-to-end flow* across the assembly.
+    // MEMO keeps software and hardware as distinct families (SoftwareModule
+    // vs ProcessingNode) and analyses the flow across their binding — the same
+    // way AADL end-to-end flows account for processor/bus bindings — enabling
+    // latency and fault-propagation analysis.
+    enum def FlowSpecKind {
+        enum source;
+        enum sink;
+        enum path;
+    }
+    // A flow declared at a logical component boundary (in-port → out-port).
+    part def FlowSpecification specializes ArchitectureElement {
+        attribute flowKind : FlowSpecKind;
+        ref inPort : LogicalPort[0..1];
+        ref outPort : LogicalPort[0..1];
+    }
+    // A complete source→sink flow traced across the layers and the software→
+    // hardware binding it traverses. `latencyBudgetMs` and `analysisPurpose`
+    // (latency | fault-propagation | security) drive the AADL-style analysis.
+    part def EndToEndFlow specializes ArchitectureElement {
+        attribute latencyBudgetMs : Real;
+        attribute analysisPurpose : String;
+        ref sourceFunction : SystemFunction[0..1];
+        ref sinkFunction : SystemFunction[0..1];
+        ref logicalSegments : LogicalComponent[0..*];
+        // Runtime C&C components (SEI) — the elements actually bound to hardware.
+        ref softwareSegments : SoftwareComponent[0..*];
+        ref hostNodes : ProcessingNode[0..*];
+    }
+    // The end-to-end flow is realized by an ordered flow specification, one
+    // segment per traversed component boundary (AADL flow-spec → end-to-end).
+    connection def FlowComprisesSpec :> MemoRelationship {
+        attribute segmentOrder : Integer;
+        end flow : EndToEndFlow;
+        end spec : FlowSpecification;
+    }
+    // The flow traverses a software→hardware binding; latency accrues here.
+    connection def FlowTraversesBinding :> MemoRelationship {
+        end flow : EndToEndFlow;
+        end deploymentUnit : DeploymentUnit;
+    }
+}

package/src/architecture/{physical → realization/physical}/memo_physical_architecture.sysml

@@ -1,4 +1,7 @@
-package memo_architecture_physical {
+// Execution-platform elements of the physical architecture (§12): the nodes
+// software runs on and the ports the outside world plugs into. The broader
+// physical taxonomy lives in memo_architecture_implementation_hardware_structure.
+package memo_architecture_realization_physical {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -10,6 +13,14 @@ package memo_architecture_physical {
         attribute operatingSystem : String;
         attribute safetyPartition : Boolean;
         attribute redundancyKind : String;
+        // Capabilities relevant to deployment feasibility checks.
+        attribute supportsContainerization : Boolean;
+        attribute realTimeCapable : Boolean;
+    }
+    part def MemoryDevice specializes ArchitectureElement {
+        attribute memoryKind : String;
+        attribute capacityMB : String;
+        attribute nonVolatile : Boolean;
     }
     part def PhysicalPort specializes InterfaceElement {
         attribute portKind : InterfaceKind;

package/src/artifacts/definitions/memo_artifact_definitions.sysml

@@ -4,7 +4,7 @@ package memo_artifacts_definitions {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def ArtifactKindDef specializes TraceableElement {
+    part def ArtifactKindDef specializes MemoPart {
         attribute documentTitle : String;
         attribute regulatoryRef : String;
         attribute artifactKind : ArtifactKind;

package/src/{architecture → assurance}/cybersecurity/memo_cybersecurity.sysml

@@ -1,11 +1,12 @@
-package memo_architecture_cybersecurity {
+package memo_assurance_cybersecurity {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    private import memo_architecture_requirements::*;
-    private import memo_architecture_risk_risk::*;
-    private import memo_architecture_assurance::*;
+    private import memo_assurance_requirements::*;
+    private import memo_assurance_safety_risk::*;
+    private import memo_assurance_verification_validation::*;
+    private import memo_architecture_operational_scenarios::*;
 
     part def CybersecurityAsset specializes ArchitectureElement {
         attribute assetKind : AssetKind;
@@ -19,7 +20,7 @@ package memo_architecture_cybersecurity {
         attribute classification : String;
     }
 
-    part def AttackSurface specializes TraceableElement {
+    part def AttackSurface specializes MemoPart {
         attribute entryPointKind : InterfaceKind;
         attribute exposureLevel : String;
         attribute reachableFrom : String;
@@ -36,7 +37,7 @@ package memo_architecture_cybersecurity {
         attribute strideCategory : ThreatCategoryKind;
     }
 
-    item def Vulnerability specializes TraceableElement {
+    item def Vulnerability specializes MemoPart {
         attribute weakness : String;
         attribute exploitability : String;
         attribute discoveryMethod : String;
@@ -45,7 +46,10 @@ package memo_architecture_cybersecurity {
         attribute remediable : Boolean;
     }
 
-    item def ThreatScenario specializes TraceableElement {
+    // A scenario specialization: an attack path through the
+    // system, classified by the shared scenario dimensions with purpose
+    // `cybersecurity`.
+    part def ThreatScenario specializes MemoScenario {
         attribute actorDescription : String;
         attribute assumptionSummary : String;
         attribute guaranteeSummary : String;
@@ -62,7 +66,7 @@ package memo_architecture_cybersecurity {
         attribute linkedSafetyHazardId : String;
     }
 
-    item def CyberRisk specializes RiskBeforeMitigation {
+    item def CyberRisk specializes Risk {
         attribute exploitabilityEstimate : String;
         attribute attackComplexity : String;
         attribute detectability : DetectionKind;
@@ -70,7 +74,7 @@ package memo_architecture_cybersecurity {
         attribute patientSafetyContribution : String;
     }
 
-    part def CyberMitigation specializes RiskControl {
+    part def CyberMitigation specializes RiskControlMeasure {
         attribute cyberControlKind : CyberControlKind;
         attribute securityMechanism : String;
         attribute verificationExpectation : String;
@@ -91,7 +95,7 @@ package memo_architecture_cybersecurity {
         attribute trustAssumption : String;
     }
 
-    part def SecurityClaim specializes EvidenceElement {
+    part def SecurityClaim specializes MemoEvidence {
         attribute claimText : String;
         attribute claimScope : String;
         attribute supportedByEvidence : String;

package/src/assurance/human_factors/memo_human_factors.sysml

@@ -0,0 +1,50 @@
+// Human-factors assurance (IEC 62366-1; FDA HF guidance 2016). UseError
+// relocated here from the former memo_architecture_context; hazard-related
+// use scenarios and formative/summative evaluations complete the usability
+// engineering chain: user → task → use error → hazard → risk control →
+// usability validation.
+package memo_assurance_human_factors {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_operational_scenarios::*;
+
+    part def UseError specializes MemoPart {
+        attribute errorCategory : UseErrorCategoryKind;
+        attribute taskReference : String;
+        attribute severity : SeverityKind;
+        attribute rootCauseType : String;
+    }
+
+    // A use scenario whose performance could lead to a hazardous situation
+    // (IEC 62366-1 3.9); selected for summative evaluation.
+    part def HazardRelatedUseScenario specializes MemoScenario {
+        attribute hazardReference : String;
+        attribute selectionRationale : String;
+    }
+
+    part def FormativeEvaluation specializes MemoEvidence {
+        attribute evaluationMethod : String;
+        attribute findingsSummary : String;
+        attribute designChangesTriggered : String;
+    }
+
+    part def UsabilityValidation specializes MemoEvidence {
+        attribute participantProfile : String;
+        attribute participantCount : Integer;
+        attribute acceptanceCriteria : String;
+        attribute resultSummary : String;
+    }
+
+    connection def CommitsUseError :> MemoRelationship {
+        end task : UserTask;
+        end useError : UseError;
+    }
+    connection def EvaluatesTask :> MemoRelationship {
+        end evaluation : MemoEvidence;
+        end task : UserTask;
+    }
+}

package/src/{architecture → assurance}/requirements/memo_requirements.sysml

@@ -1,14 +1,47 @@
-package memo_architecture_requirements {
+package memo_assurance_requirements {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    requirement def StakeholderNeed specializes RequirementDriver {
-        attribute statement : String;
-        attribute priority : String;
-    }
+    // StakeholderNeed and the needs hierarchy now live in memo_assurance_requirements_needs.
+    private import memo_assurance_requirements_needs::*;
     part def RiskDriver specializes RequirementDriver { attribute driverKind : String; }
+
+    // ISO 14971 risk-analysis inputs. These are model elements so hazards,
+    // scenarios, requirements, and DHF records can trace to the exact use
+    // definition or foreseeable misuse that motivated them.
+    part def IntendedUse specializes DocumentedElement {
+        attribute indication : String;
+        attribute contraindication : String;
+        attribute patientPopulation : String;
+        attribute clinicalBenefit : String;
+        attribute regulatoryClassification : String;
+    }
+    part def ReasonablyForeseeableMisuse specializes DocumentedElement {
+        attribute misuseContext : String;
+        attribute foreseeableBasis : String;
+        attribute affectedUseContext : String;
+    }
+
+    // The kind of requirement. Was a subclass branch (SystemRequirement /
+    // SoftwareRequirement / HardwareRequirement) plus a parallel design-control
+    // specification hierarchy (DesignControlSpecification / System- / Software- /
+    // HardwareSpecification); now one attribute. The role-specific attributes
+    // below are all optional so a requirement carries only the ones its kind
+    // needs. IEC 62304 / design-control classification is preserved as the
+    // enum value, not lost.
+    enum def RequirementKind {
+        enum system;
+        enum software;
+        enum hardware;
+        enum systemSpecification;
+        enum softwareSpecification;
+        enum hardwareSpecification;
+        enum designControl;
+    }
+
     requirement def Requirement specializes VerifiableElement {
+        attribute requirementKind : RequirementKind;
         attribute statement : String;
         attribute sourceKind : RequirementSourceKind;
         attribute concernKind : ConcernKind;
@@ -26,29 +59,20 @@ package memo_architecture_requirements {
         attribute obligation : ObligationKind;      // shall/should/will (RFC 2119, SOPHIST legal-obligation)
         attribute conditionClause : String;         // EARS When/While/If/Where or SOPHIST condition clause
         attribute systemResponse : String;          // the "shall <system response>" predicate
-    }
-    requirement def SystemRequirement specializes Requirement;
-    requirement def SoftwareRequirement specializes Requirement { attribute safetyClass : SafetyClassKind; }
-    requirement def HardwareRequirement specializes Requirement { attribute electricalSafetyRelevant : Boolean; }
-    requirement def DesignControlNeed specializes StakeholderNeed {
-        attribute sourceFolder : String;
-        attribute linkedDesignControls : String;
-    }
-    requirement def DesignControlSpecification specializes Requirement {
+        // software requirement / specification (IEC 62304)
+        attribute safetyClass : SafetyClassKind[0..1];
+        // hardware requirement
+        attribute electricalSafetyRelevant : Boolean;
+        // design-control specification (ISO 13485 design output)
         attribute specificationDomain : String;
         attribute sourceFolder : String;
         attribute linkedUserNeeds : String;
         attribute linkedRisks : String;
         attribute linkedTests : String;
     }
-    requirement def HardwareSpecification specializes DesignControlSpecification;
-    requirement def SoftwareSpecification specializes DesignControlSpecification {
-        attribute softwareSafetyClass : SafetyClassKind;
-    }
-    requirement def SystemSpecification specializes DesignControlSpecification;
     // Named constant defined by a source requirements document (e.g. CriSys
     // GPCA App. A.4) and referenced from requirement statements.
-    part def SystemConstant specializes TraceableElement {
+    part def SystemConstant specializes MemoPart {
         attribute symbol : String;          // identifier as written in the source, e.g. "Tolerance_Max const"
         attribute unit : String;
         attribute valueType : String;
@@ -57,7 +81,7 @@ package memo_architecture_requirements {
     }
     // One row of a notification/alarm action table (e.g. CriSys GPCA REQ 59):
     // a named notification, its priority, and the actions the system must take.
-    part def NotificationSpec specializes TraceableElement {
+    part def NotificationSpec specializes MemoPart {
         attribute priority : NotificationPriorityKind;
         attribute visualNotification : Boolean;
         attribute audioNotification : Boolean;

package/src/assurance/requirements/needs/memo_needs.sysml

@@ -0,0 +1,43 @@
+// Needs (§4). A Need is a problem-space expectation stated in stakeholder
+// language; requirements (memo_assurance_requirements) are the solution-space
+// obligations derived from needs. Need specializes the part-based
+// RequirementDriver so it can serve as a typed end of trace relations
+// (DerivesFrom, Motivates).
+package memo_assurance_requirements_needs {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    // The kind of need. Was a subclass branch (StakeholderNeed / UserNeed /
+    // ClinicalUserNeed / PatientUserNeed / BusinessNeed / ServiceNeed /
+    // RegulatoryNeed / OperationalNeed / DesignControlNeed); now one attribute.
+    // The exact terms survive as enum values, so design-input classification
+    // (ISO 13485 §7.3.3, IEC 62366-1 user needs) is unchanged — it is simply
+    // an attribute of the one Need type rather than a class the modeler picks.
+    enum def NeedKind {
+        enum stakeholder;
+        enum user;
+        enum clinicalUser;
+        enum patientUser;
+        enum business;
+        enum service;
+        enum regulatory;
+        enum operational;
+        enum designControl;
+    }
+
+    requirement def Need specializes MemoNeed, RequirementDriver {
+        attribute needKind : NeedKind;
+        // user need (IEC 62366-1)
+        attribute userPopulationReference : String;
+        // regulatory need
+        attribute jurisdiction : String;
+        attribute regulationReference : String;
+        // operational need
+        attribute operationalContextReference : String;
+        // design-control need (ISO 13485 design input)
+        attribute sourceFolder : String;
+        attribute linkedDesignControls : String;
+    }
+}