@memoarchitect/ontology 0.4.6 → 0.6.0

package/src/{architecture → assurance/safety_risk}/analysis/memo_fmea.sysml

@@ -1,16 +1,16 @@
-package memo_architecture_analysis {
+package memo_assurance_safety_risk_analysis {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    item def FMEAWorksheet specializes TraceableElement {
+    item def FMEAWorksheet specializes AnalysisArtifact {
         attribute analysisScope : String;
         attribute standardReference : String;
         attribute analysisBasis : String;
         attribute revisionDate : String;
         attribute reviewer : String;
     }
-    item def FailureMode specializes TraceableElement {
+    item def FailureMode specializes MemoPart {
         attribute failureModeKind : FailureModeKind;
         attribute severityRating : Integer;
         attribute occurrenceRating : Integer;
@@ -18,20 +18,20 @@ package memo_architecture_analysis {
         attribute rpn : Integer;
         attribute criticality : CriticalityKind;
     }
-    item def FailureEffect specializes TraceableElement {
+    item def FailureEffect specializes MemoPart {
         attribute effectLevel : FailureEffectLevelKind;
         attribute effectOnPatient : String;
         attribute effectOnOperator : String;
         attribute effectOnSystem : String;
         attribute severity : SeverityKind;
     }
-    item def FailureCause specializes TraceableElement {
+    item def FailureCause specializes MemoPart {
         attribute causeCategory : FailureCauseCategoryKind;
         attribute causeDescription : String;
         attribute occurrenceRating : ProbabilityKind;
         attribute preventionMethod : String;
     }
-    item def DetectionMethod specializes TraceableElement {
+    item def DetectionMethod specializes MemoPart {
         attribute methodKind : DetectionMethodKind;
         attribute detectionPoint : String;
         attribute confidence : DetectionKind;
@@ -42,43 +42,43 @@ package memo_architecture_analysis {
         attribute targetCompletionDate : String;
         attribute revisedRpn : Integer;
     }
-    item def FaultTree specializes TraceableElement {
+    item def FaultTree specializes AnalysisArtifact {
         attribute standardReference : String;
         attribute analysisScope : String;
         attribute topEventDescription : String;
         attribute cutSetSummary : String;
         attribute revisionDate : String;
     }
-    item def FaultTreeEvent specializes TraceableElement {
+    item def FaultTreeEvent specializes MemoPart {
         attribute eventKind : FaultTreeEventKind;
         attribute probability : Real;
         attribute failureRate : Real;
         attribute exposureTime : Real;
         attribute :>> description : String;
     }
-    item def FaultTreeGate specializes TraceableElement {
+    item def FaultTreeGate specializes MemoPart {
         attribute gateKind : FaultTreeGateKind;
         attribute kValue : Integer;
         attribute nValue : Integer;
     }
-    item def MinimalCutSet specializes TraceableElement {
+    item def MinimalCutSet specializes MemoPart {
         attribute cutSetOrder : Integer;
         attribute probability : Real;
         attribute involvedEvents : String;
         attribute significance : String;
     }
-    item def HAZOPStudy specializes TraceableElement {
+    item def HAZOPStudy specializes AnalysisArtifact {
         attribute standardReference : String;
         attribute processDescription : String;
         attribute studyScope : String;
         attribute teamComposition : String;
     }
-    item def HAZOPNode specializes TraceableElement {
+    item def HAZOPNode specializes MemoPart {
         attribute nodeDescription : String;
         attribute designIntent : String;
         attribute operatingConditions : String;
     }
-    item def HAZOPDeviation specializes TraceableElement {
+    item def HAZOPDeviation specializes MemoPart {
         attribute guideWord : HAZOPGuideWordKind;
         attribute parameter : String;
         attribute cause : String;

package/src/{architecture/risk → assurance/safety_risk}/memo_arch_risk.sysml

@@ -1,7 +1,7 @@
-package memo_architecture_risk_arch_risk {
+package memo_assurance_safety_risk_arch_risk {
     private import ScalarValues::*;
 
     doc /* Configuration Item (CI) aggregator for MEMO architecture risk domain.
          * Re-exports all risk-related packages for Sysand build. */
-    public import memo_architecture_risk_risk::*;
+    public import memo_assurance_safety_risk::*;
 }

package/src/{architecture/risk → assurance/safety_risk}/memo_risk.sysml

@@ -1,27 +1,22 @@
-package memo_architecture_risk_risk {
+package memo_assurance_safety_risk {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    private import memo_architecture_requirements::*;
+    private import memo_assurance_requirements::*;
     part def Risk specializes RiskDriver {
         attribute probabilityEstimate : ProbabilityKind;
         attribute severityEstimate : SeverityKind;
         attribute riskLevel : CriticalityKind;
         attribute acceptability : RiskAcceptabilityKind;
-    }
-    part def RiskBeforeMitigation specializes Risk {
         attribute estimationBasis : String;
         attribute analysisContext : String;
         attribute foreseeableMisuseIncluded : Boolean;
     }
-    part def RiskAfterMitigation specializes Risk {
-        attribute residualProbability : ProbabilityKind;
-        attribute residualSeverity : SeverityKind;
-        attribute residualAcceptability : RiskAcceptabilityKind;
+    part def ResidualRisk specializes Risk {
         attribute benefitRiskRequired : Boolean;
     }
-    part def RiskMatrix specializes TraceableElement {
+    part def RiskMatrix specializes MemoPart {
         attribute probabilityScaleDefinition : String;
         attribute severityScaleDefinition : String;
         attribute riskLevelMapping : String;
@@ -43,37 +38,51 @@ package memo_architecture_risk_risk {
         attribute cannotReduceFurther : Boolean;
         attribute linkSummary : String;
     }
-    item def Hazard specializes TraceableElement {
+    // A device characteristic whose implementation, failure, or misuse can
+    // affect safety. This is the modelable output of ISO 14971 §5.3.
+    part def SafetyRelatedCharacteristic specializes MemoPart {
+        attribute characteristic : String;
+        attribute safetyImpact : String;
+        attribute normalUseRelevant : Boolean;
+        attribute faultConditionRelevant : Boolean;
+    }
+    item def Hazard specializes MemoPart {
         attribute hazardType : HazardTypeKind;
         attribute severity : SeverityKind;
         attribute foreseeable : Boolean;
     }
-    item def SequenceOfEvents specializes TraceableElement {
+    item def SequenceOfEvents specializes MemoPart {
         attribute initiatingEvent : String;
         attribute contributingFactors : String;
     }
     // A categorized root cause in a hazard causal tree (FDA GIIP
     // taxonomy pattern: cause -> hazard -> hazardous situation -> harm;
     // several HazardCause elements may converge on one Hazard).
-    item def HazardCause specializes TraceableElement {
+    item def HazardCause specializes MemoPart {
         attribute causeSource : CauseSourceKind;
         attribute contributingFactors : String;
     }
-    item def HazardousSituation specializes TraceableElement {
+    item def HazardousSituation specializes MemoPart {
         attribute exposedPersons : String;
         attribute operatingCondition : String;
     }
-    item def Harm specializes TraceableElement {
+    item def Harm specializes MemoPart {
         attribute clinicalImpact : String;
         attribute reversibility : String;
         attribute severity : SeverityKind;
     }
-    item def RiskControl specializes VerifiableElement {
+    item def RiskControlMeasure specializes VerifiableElement {
         attribute controlKind : RiskControlKind;
         attribute implementationKind : RiskControlImplementationKind;
         attribute verificationStatus : String;
     }
-    item def OverallResidualRiskEvaluation specializes TraceableElement {
+    part def Benefit specializes MemoPart {
+        attribute beneficialOutcome : String;
+        attribute beneficiary : String;
+        attribute clinicalSignificance : String;
+        attribute supportingEvidence : String;
+    }
+    item def OverallResidualRiskEvaluation specializes MemoPart {
         attribute conclusion : String;
         attribute reviewer : String;
     }

package/src/assurance/verification_validation/memo_assurance.sysml

@@ -0,0 +1,49 @@
+package memo_assurance_verification_validation {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_scenarios::*;
+    private import memo_architecture_operational_use_cases::*;
+    private import memo_architecture_functional_functions::*;
+    // Verification and validation cases are SysML v2 verification cases
+    // (behaviours that check requirements), not verifiable structures — they
+    // derive from the MemoVerificationCase foundation, not MemoPart.
+    verification def VerificationCase :> MemoVerificationCase {
+        attribute methodKind : VerificationMethodKind;
+        attribute acceptanceCriteria : String;
+        attribute status : String;
+    }
+    verification def ValidationCase :> MemoVerificationCase {
+        attribute validationMethod : ValidationMethodKind;
+        attribute userParticipation : String;
+        attribute acceptanceCriteria : String;
+        attribute clinicalContext : String;
+    }
+    part def TestArtifact specializes MemoEvidence {
+        attribute version : String;
+        attribute artifactKind : ArtifactKind;
+        attribute resultSummary : String;
+    }
+    part def Evidence specializes MemoEvidence {
+        attribute version : String;
+        attribute evidenceType : String;
+        attribute integrityStatus : String;
+    }
+
+    // A scenario executed to verify — selected path with purpose
+    // 'verification'.
+    part def VerificationScenario specializes MemoScenario {
+        attribute verificationEnvironment : String;
+        attribute stimulusSummary : String;
+    }
+
+    // Operational validation confirms the user's goal is achieved in the
+    // use environment (§5): ValidationCase validates a UseCase.
+    // Safety-critical functions must trace to verification (rules/coverage).
+    connection def ExecutesScenario :> MemoRelationship {
+        end verificationCase : VerificationCase;
+        end scenario : MemoScenario;
+    }
+}

package/src/compliance/artifacts/memo_artifacts.sysml

@@ -3,7 +3,7 @@ package memo_compliance_artifacts {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    item def ControlledArtifact specializes TraceableElement {
+    item def ControlledArtifact specializes MemoPart {
         attribute version : String;
         attribute lifecycleState : LifecycleStateKind;
         attribute artifactKind : ArtifactKind;

package/src/compliance/change/memo_change.sysml

@@ -3,13 +3,13 @@ package memo_compliance_change {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def ChangeRequest specializes TraceableElement {
+    part def ChangeRequest specializes MemoPart {
         attribute changeType : ChangeTypeKind;
         attribute impactAssessment : String;
         attribute approvalStatus : String;
         attribute affectedBaseline : String;
     }
-    part def ConfigurationItem specializes TraceableElement {
+    part def ConfigurationItem specializes MemoPart {
         attribute version : String;
         attribute baseline : String;
         attribute controlLevel : String;

package/src/compliance/dhf-templates/21cfr820/design-input.md

@@ -33,7 +33,7 @@ empty: "No system requirements defined."
 ### 2.2 Design Inputs from User Needs
 
 ```memo-query
-kind: [DesignInput, StakeholderNeed]
+kind: [DesignInput, Need]
 display: table
 columns: name, layer, doc
 sort: name

package/src/compliance/dhf-templates/21cfr820/design-validation.md

@@ -43,7 +43,7 @@ empty: "No validation activities defined."
 Coverage of user needs by validation activities, computed live from the model:
 
 ```memo-query
-kind: [StakeholderNeed, Requirement]
+kind: [Need, Requirement]
 display: table
 columns: name, layer, doc
 empty: "No user needs defined."

package/src/compliance/dhf-templates/21cfr820/user-needs.md

@@ -31,11 +31,11 @@ _[TODO: Describe all intended user groups with their roles, training levels, and
 User needs captured for **{{project.product}}** are listed below from the model. Each user need should trace forward to at least one design input:
 
 ```memo-query
-kind: [StakeholderNeed, Requirement]
+kind: [Need, Requirement]
 display: table
 columns: name, layer, doc
 sort: name
-empty: "No user need elements defined. Add StakeholderNeed or Requirement elements."
+empty: "No user need elements defined. Add Need or Requirement elements."
 ```
 
 ---

package/src/compliance/dhf-templates/iec-62366/urra.md

@@ -60,7 +60,7 @@ _[TODO: Identify the critical tasks whose failure could cause a hazardous situat
 This section is generated from the system model. The table below lists the **Mitigation Measures** elements currently defined:
 
 ```memo-query
-kind: [RiskControl, UsabilityRequirement]
+kind: [RiskControlMeasure, UsabilityRequirement]
 display: table
 columns: name, layer, doc
 sort: name

package/src/compliance/dhf-templates/iso-14971/fmea.md

@@ -71,7 +71,7 @@ empty: "No interfaces defined."
 This section is generated from the system model. The table below lists the **Risk Controls for FMEA Items** elements currently defined:
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: table
 columns: name, layer, doc
 sort: name

package/src/compliance/dhf-templates/iso-14971/har.md

@@ -35,7 +35,7 @@ label: Hazardous situations
 ```
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: count
 label: Risk control measures
 ```
@@ -113,7 +113,7 @@ empty: "No harm elements defined. Add Harm elements linked to HazardousSituation
 ### 6.1 Inherent Safety by Design
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 where: doc contains "design"
 display: table
 columns: name, doc, layer
@@ -123,11 +123,11 @@ empty: "No inherent safety controls."
 ### 6.2 Protective Measures
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: table
 columns: name, doc, layer
 sort: name
-empty: "No risk controls defined. Add RiskControl elements."
+empty: "No risk controls defined. Add RiskControlMeasure elements."
 ```
 
 ### 6.3 Information for Safety

package/src/compliance/dhf-templates/iso-14971/risk-matrix.md

@@ -39,7 +39,7 @@ empty: "No risk elements defined."
 This section is generated from the system model. The table below lists the **Risk Control Coverage** elements currently defined:
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: table
 columns: name, layer, doc
 sort: name

package/src/compliance/dhf-templates/iso-14971/rmp.md

@@ -119,7 +119,7 @@ empty: "No hazardous situations defined."
 ### 5.3 Risk Control Measures
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: table
 columns: name, layer, doc
 sort: name

package/src/compliance/dhf-templates/iso-14971/rmr.md

@@ -29,7 +29,7 @@ label: Total hazards identified
 ```
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: count
 label: Risk controls implemented
 ```

package/src/compliance/iso14971/risk_management_file.sysml

@@ -7,7 +7,7 @@ package memo_compliance_iso14971 {
     doc /* ISO 14971 Risk Management File — the top-level deliverable
            that aggregates all risk management artifacts required by
            ISO 14971:2019 clause 4.5. */
-    part def RiskManagementFile specializes TraceableElement {
+    part def RiskManagementFile specializes MemoPart {
         attribute standardReference : String;
         attribute clause : String;
         attribute edition : String;

package/src/compliance/postmarket/memo_postmarket.sysml

@@ -3,12 +3,12 @@ package memo_compliance_postmarket {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def ClinicalEvaluation specializes TraceableElement {
+    part def ClinicalEvaluation specializes MemoPart {
         attribute evaluationStage : String;
         attribute clinicalDataSource : String;
         attribute conclusion : String;
     }
-    part def PostMarketSurveillance specializes TraceableElement {
+    part def PostMarketSurveillance specializes MemoPart {
         attribute surveillanceKind : String;
         attribute dataSource : String;
         attribute reportingObligation : String;

package/src/core/common/memo_common.sysml

@@ -1,20 +1,57 @@
+// MEMO base hierarchy. Construct-specific foundations: one base per
+// SysML v2 metaclass family (part, action, port, interface, item, requirement,
+// connection), each carrying the shared MEMO semantics. Common inheritance
+// across metaclasses is not portable, so non-part bases re-declare the small
+// identification core and share classification through the metadata defs in
+// memo_core_dimensions.
 package memo_core_common {
     private import ScalarValues::*;
 
+    private import memo_core_dimensions::*;
+    private import memo_core_terminology::*;
     private import memo_core_enumerations::*;
 
-    part def IdentifiedElement {
+    // ─── Single abstract part root ──────────────────────────────────
+    // Every structural MEMO concept specializes MemoPart. Identity and
+    // traceability are attributes of this one root — MEMO has no separate
+    // IdentifiedElement/TraceableElement classes, because *everything* is
+    // identifiable and traceable by definition; that is not a type a modeler
+    // picks. MemoPart is abstract: never instantiated, only specialized.
+    //
+    // Axis ownership (horizontal architecture layer vs. vertical assurance
+    // discipline) is NOT an attribute — it is the element's owning package
+    // (memo_architecture_* xor memo_assurance_*), enforced by CR-ONT-045.
+    // The remaining dimensions are orthogonal to the axis: realization stage,
+    // cross-cutting concern, and editorial status.
+    abstract part def MemoPart {
+        // identity
         attribute id : String;
         attribute name : String;
         attribute description : String;
-    }
-
-    part def TraceableElement specializes IdentifiedElement {
+        // traceability
         attribute rationale : String;
         attribute sourceReference : String;
+        // editorial status and lifecycle
+        attribute status : ElementStatusKind;
+        attribute lifecycleState : LifecycleStateKind;
+        // orthogonal dimensions
+        attribute realizationStage : RealizationStageKind[0..1];
+        attribute crossCuttingConcerns : CrossCuttingConcernKind[0..*];
+        attribute concerns : ConcernKind[0..*];
+        attribute applicableStandards : ExternalReference[0..*];
+        attribute codes : TerminologyCode[0..*];
     }
 
-    part def DocumentedElement specializes TraceableElement {
+    // ─── Role bases retained from the original kernel, re-founded on
+    //     MemoPart so all existing content inherits the dimensions. ───
+    part def RequirementDriver specializes MemoPart;
+    abstract part def VerifiableElement specializes MemoPart;
+    abstract part def ArchitectureElement specializes MemoPart;
+    part def InterfaceElement specializes MemoPart;
+    part def MemoEvidence specializes MemoPart;
+    abstract part def AnalysisArtifact specializes MemoPart;
+
+    part def DocumentedElement specializes MemoPart {
         attribute title : String;
         attribute shortDescription : String;
         attribute longDescription : String;
@@ -22,26 +59,98 @@ package memo_core_common {
         attribute sectionIdentifier : String;
     }
 
-    part def RequirementDriver specializes TraceableElement;
-    part def VerifiableElement specializes TraceableElement;
-    part def ArchitectureElement specializes TraceableElement;
-    part def InterfaceElement specializes TraceableElement;
-    part def EvidenceElement specializes TraceableElement;
+    // ─── Construct-specific foundations (non-part metaclasses) ───────
+
+    // Behavioral foundation: operational activities, tasks, system actions,
+    // and interaction steps specialize MemoAction.
+    action def MemoAction {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+        attribute status : ElementStatusKind;
+    }
+
+    // Boundary feature foundation for typed ports.
+    port def MemoPort {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute direction : DirectionKind;
+    }
+
+    // Interaction-contract foundation for interface definitions between ports.
+    interface def MemoInterface {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+    }
 
-    part def ExchangeItem specializes TraceableElement {
+    // Exchange-content foundation: everything that flows — information,
+    // command, material, energy — is an item, not a part.
+    item def MemoExchangeItem {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
         attribute semantics : String;
         attribute unit : String;
         attribute minValue : String;
         attribute maxValue : String;
         attribute encoding : String;
         attribute timestampRequired : Boolean;
+        attribute codes : TerminologyCode[0..*];
     }
 
-    part def LayerElement specializes TraceableElement {
-        attribute layerName : String;
+    // Requirement-family foundations. MemoNeed captures a problem-space
+    // expectation in stakeholder language; MemoRequirement a testable
+    // solution-space obligation.
+    requirement def MemoNeed {
+        attribute needId : String;
+        attribute statement : String;
+        attribute needRationale : String;
+        attribute needSource : String;
+        attribute priority : String;
+        attribute needStatus : ElementStatusKind;
+    }
+
+    requirement def MemoRequirement {
+        attribute requirementId : String;
+        attribute statement : String;
+        attribute acceptanceCriteria : String;
+        attribute requirementStatus : ElementStatusKind;
+    }
+
+    // Verification-case foundation. A SysML v2 verification case is a behaviour
+    // (it checks requirements), and KerML forbids a behaviour from specializing
+    // the part-based MemoPart — so, like MemoAction, it re-declares the small
+    // identification core rather than inheriting it.
+    verification def MemoVerificationCase {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+    }
+
+    // State foundation. SysML v2 states (state machines and their mode states)
+    // are behaviours, so — like MemoAction and MemoVerificationCase — they
+    // re-declare the identification core instead of specializing MemoPart
+    // Transitions stay part-based to keep their traceable safety
+    // attributes (id, sourceReference, priority, sameStepCritical).
+    abstract state def MemoState {
+        attribute id : String;
+        attribute name : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
     }
 
-    part def Citation specializes IdentifiedElement {
+    part def Citation specializes MemoPart {
         attribute source : String;
         attribute section : String;
         attribute uri : String;

package/src/core/consistency_rules/consistency_rules.sysml

@@ -1,12 +1,12 @@
 // Consistency rule base types per Epic N.
-// Bare imports (no `private`) per ADR-1-16 fallback.
+// Bare imports are required by the current compatibility surface.
 package memo_core_consistency_rules {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    part def ConsistencyRule specializes TraceableElement {
+    part def ConsistencyRule specializes MemoPart {
         attribute appliesTo : String;
         attribute predicate : RulePredicateKind;
         attribute strength : RuleStrengthKind;