@memoarchitect/ontology 0.4.4

package/examples/gpca-pump/model/views/verification_verification_coverage_view.sysml

@@ -0,0 +1,42 @@
+package memo_examples_gpca_pump_model_views_verification_verification_coverage_view {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_context_context_viewpoint::*;
+    private import memo_viewpoints_operational_operational_viewpoint::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
+    private import memo_viewpoints_logical_logical_viewpoint::*;
+    private import memo_viewpoints_software_software_viewpoint::*;
+    private import memo_viewpoints_physical_physical_viewpoint::*;
+    private import memo_viewpoints_requirements_requirements_viewpoint::*;
+    private import memo_viewpoints_risk_risk_viewpoint::*;
+    private import memo_viewpoints_verification_verification_viewpoint::*;
+    private import memo_core_enumerations::*;
+
+    view gpcaVerificationCoverageView : MemoDiagramView {
+        expose memo_examples_gpca_pump_model_views_verification_verification_coverage_view::*;
+        attribute depth = 2;
+        attribute :>> id = "VIEW-VER-101";
+        attribute :>> name = "GPCA_VerificationCoverageView";
+        attribute :>> title = "GPCA Verification and Validation Coverage View";
+        attribute :>> shortDescription = "Requirements and risk controls against verification cases, validation cases, and evidence.";
+        attribute :>> outputKind = (ViewOutputKind::matrix);
+        attribute :>> presentationKind = (PresentationKind::traceMatrix);
+        attribute :>> viewKind = DiagramViewKind::grid;
+        attribute :>> diagramType = "req";
+        attribute :>> dataSourceDescription = "VerifiedBy, Validates, and ProducesEvidence links in the GPCA model";
+        attribute :>> autoPopulate = true;
+        attribute :>> queryDescription = "Include every requirement and risk control with its verification/validation status and produced evidence.";
+        attribute :>> documentUsage = ("VV", "DHF", "QMSR");
+        part :>> selectionQuery {
+            attribute :>> id = "QRY-VER-101";
+            attribute :>> name = "GPCA_VerificationCoverageQuery";
+            attribute :>> includeElementKinds = ("Requirement", "RiskControl", "VerificationCase", "ValidationCase", "TestArtifact", "Evidence");
+            attribute :>> includeRelationshipKinds = ("VerifiedBy", "Validates", "ProducesEvidence");
+            attribute :>> includeLayers = ("requirements", "risk", "assurance");
+            attribute :>> selectionExpression = "product == 'GPCA'";
+            attribute :>> rationaleText = "Coverage gaps surface as requirements or controls without linked cases or evidence.";
+        }
+        part :>> viewpointDefinition = verificationViewpoint;
+    }
+}

package/memo.manifest.yaml

@@ -0,0 +1,13 @@
+manifest: 1
+packages:
+  "@memoarchitect/ontology": ./ontology
+  "@memoarchitect/medical-modeling-profile": ./profile
+  "@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
+examples:
+  gpca: ./examples/gpca-pump

package/methodologies/default/memo.package.yaml

@@ -0,0 +1,9 @@
+name: "@memoarchitect/methodology-default"
+version: "0.4.3"
+type: methodology
+extends: "@memoarchitect/ontology"
+sysmlDir: "../../src/methodology"
+description: "MEMO default medical-device methodology — selects viewpoints/views/DHF documents from @memoarchitect/ontology and adds rules, gates, patterns, profiles, and workflow."
+license: "MIT"
+tags: ["methodology", "medical-device", "iso-14971", "iec-62304", "memo"]
+usage: ["viewpoints", "views", "rules", "gates", "patterns", "profiles", "workflow", "dhf"]

package/methodologies/gpca/memo.package.yaml

@@ -0,0 +1,9 @@
+name: "@memo/methodology-gpca"
+version: "0.4.3"
+type: methodology
+extends: "@memo/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."
+license: "MIT"
+tags: ["methodology", "medical-device", "gpca", "tailoring"]
+usage: ["viewpoints", "views", "rules", "gates", "patterns", "profiles", "workflow", "dhf"]

package/ontology/memo.package.yaml

@@ -0,0 +1,8 @@
+name: "@memoarchitect/ontology"
+version: "0.4.3"
+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"
+tags: ["mbse", "sysml-v2", "arcadia", "iso-42010", "medical-device", "ontology", "iso-14971", "iec-62304"]
+usage: ["kinds", "relationships"]
+sysmlDir: "../src"

package/ontology/memo.rendering.yaml

@@ -0,0 +1,47 @@
+# @memoarchitect/ontology rendering configuration
+# Architecture layer colors — v12 Visual Map palette
+
+layers:
+  - id: operational
+    label: Operational
+    color: "#C0392B"
+
+  - id: behavioral
+    label: Behavioral
+    color: "#E74C3C"
+
+  - id: functional
+    label: Functional
+    color: "#E67E22"
+
+  - id: logical
+    label: Logical
+    color: "#7B68EE"
+
+  - id: software
+    label: Software
+    color: "#F39C12"
+
+  - id: software-extension
+    label: Software Extension (ROS)
+    color: "#D4AC0D"
+
+  - id: hardware
+    label: Hardware
+    color: "#95A5A6"
+
+  - id: safety
+    label: Safety
+    color: "#E74C3C"
+
+  - id: security
+    label: Security
+    color: "#2C3E50"
+
+  - id: privacy
+    label: Privacy
+    color: "#8E44AD"
+
+  - id: verification
+    label: Verification
+    color: "#2ECC71"

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@memoarchitect/ontology",
+  "version": "0.4.4",
+  "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).",
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "sysml-v2",
+    "kerml",
+    "medical-device",
+    "iso-14971",
+    "iec-62304",
+    "ontology",
+    "mbse"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memoarchitect/memo.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./manifest": "./memo.manifest.yaml",
+    "./src/*": "./src/*",
+    "./profile/*": "./profile/*",
+    "./methodologies/*": "./methodologies/*",
+    "./templates/*": "./template/*",
+    "./examples/*": "./examples/*"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "memo.manifest.yaml",
+    "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/architecture/",
+    "src/artifacts/",
+    "src/compliance/",
+    "src/core/",
+    "src/methodology/*.sysml",
+    "src/methodology/LICENSES/",
+    "src/rules/",
+    "src/viewpoints/",
+    "src/medical_device_library.sysml",
+    "src/memo_namespaces.sysml",
+    "template/",
+    "examples/"
+  ],
+  "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"
+  }
+}

package/profile/archetypes.yaml

@@ -0,0 +1,36 @@
+archetypes:
+  - id: samd
+    label: Software as Medical Device (SaMD)
+    description: Clinical decision support, diagnostic algorithm, AI/ML tool, mobile medical app
+    category: device-class
+    templateDir: samd
+    includedLayers: [context, requirements, functions, logical_structure, software_structure, risk, assurance, cybersecurity]
+    includedStandards: [ISO 14971, IEC 62304, IEC 82304-1, FDA Cybersecurity Guidance]
+  - id: connected
+    label: Connected / IoT Device
+    description: Remote monitoring, wearable, smart device with cloud connectivity and cybersecurity requirements
+    category: device-class
+    templateDir: connected-device
+    includedLayers: [context, requirements, functions, logical_structure, logical_interfaces, software_structure, hardware_structure, risk, assurance, cybersecurity]
+    includedStandards: [ISO 14971, IEC 62304, 21 CFR 820, FDA Cybersecurity Guidance]
+  - id: monitoring
+    label: Monitoring / Diagnostic Device
+    description: Patient monitor, ECG, SpO2, vital signs, bedside diagnostic equipment
+    category: device-class
+    templateDir: monitoring-device
+    includedLayers: [context, requirements, functions, logical_structure, logical_interfaces, physical_interfaces, software_structure, hardware_structure, risk, assurance]
+    includedStandards: [ISO 14971, IEC 62304, IEC 60601-1, 21 CFR 820]
+  - id: infusion_pump
+    label: Infusion / Drug Delivery Device
+    description: Infusion pump, syringe driver, implantable drug delivery, dosing device
+    category: device-class
+    templateDir: infusion-pump
+    includedLayers: [context, requirements, functions, logical_structure, logical_interfaces, physical_interfaces, software_structure, hardware_structure, behavior, risk, arch_risk, assurance, cybersecurity]
+    includedStandards: [ISO 14971, IEC 62304, IEC 60601-1, 21 CFR 820, ISO 13485]
+  - id: blank
+    label: Blank Project
+    description: Start from scratch with a minimal SysML shell
+    category: device-class
+    templateDir: ""
+    includedLayers: []
+    includedStandards: []

package/profile/memo.package.yaml

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

package/profile/templates/connected-device/starter.sysml

@@ -0,0 +1,8 @@
+package memo_connected_device_starter {
+    import memo_medical_device_library::*;
+
+    part connectedDeviceSystem : System;
+    requirement connectivityRequirement : Requirement {
+        attribute redefines title = "Define connectivity and cybersecurity boundaries";
+    }
+}

package/profile/templates/infusion-pump/starter.sysml

@@ -0,0 +1,8 @@
+package memo_infusion_pump_starter {
+    import memo_medical_device_library::*;
+
+    part infusionPumpSystem : System;
+    requirement deliveryRequirement : Requirement {
+        attribute redefines title = "Define safe therapy delivery behavior";
+    }
+}

package/profile/templates/monitoring-device/starter.sysml

@@ -0,0 +1,8 @@
+package memo_monitoring_device_starter {
+    import memo_medical_device_library::*;
+
+    part monitoringDeviceSystem : System;
+    requirement monitoringRequirement : Requirement {
+        attribute redefines title = "Define the monitored physiological parameter";
+    }
+}

package/profile/templates/samd/starter.sysml

@@ -0,0 +1,8 @@
+package memo_samd_starter {
+    import memo_medical_device_library::*;
+
+    part samdSystem : System;
+    requirement clinicalPurpose : Requirement {
+        attribute redefines title = "Define the clinical purpose and intended user";
+    }
+}

package/src/architecture/analysis/memo_fmea.sysml

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

package/src/architecture/assurance/memo_assurance.sysml

@@ -0,0 +1,29 @@
+package memo_architecture_assurance {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def VerificationCase specializes VerifiableElement {
+        attribute methodKind : VerificationMethodKind;
+        attribute acceptanceCriteria : String;
+        attribute status : String;
+    }
+    part def ValidationCase specializes VerifiableElement {
+        attribute validationMethod : ValidationMethodKind;
+        attribute userParticipation : String;
+        attribute acceptanceCriteria : String;
+        attribute clinicalContext : String;
+    }
+    part def TestArtifact specializes EvidenceElement {
+        attribute version : String;
+        attribute lifecycleState : LifecycleStateKind;
+        attribute artifactKind : ArtifactKind;
+        attribute resultSummary : String;
+    }
+    part def Evidence specializes EvidenceElement {
+        attribute version : String;
+        attribute lifecycleState : LifecycleStateKind;
+        attribute evidenceType : String;
+        attribute integrityStatus : String;
+    }
+}

package/src/architecture/behavior/memo_behavior.sysml

@@ -0,0 +1,65 @@
+package memo_architecture_behavior {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def BehaviorMachine specializes ArchitectureElement {
+        attribute machineKind : String;
+        attribute executionSemantics : String;
+    }
+    part def ModeState specializes ArchitectureElement {
+        attribute modeKind : String;
+        attribute entryCondition : String;
+        attribute exitCondition : String;
+    }
+    part def Transition specializes ArchitectureElement {
+        attribute trigger : String;
+        attribute guardSummary : String;
+        attribute effectSummary : String;
+        attribute priority : Integer;
+        attribute sameStepCritical : Boolean;
+        attribute sourceState : String;
+        attribute targetState : String;
+    }
+    part def BehaviorProperty specializes VerifiableElement {
+        attribute propertyKind : BehaviorPropertyKind;
+        attribute languageKind : PropertyLanguageKind;
+        attribute formalExpression : String;
+    }
+    part def AssumeProperty specializes BehaviorProperty;
+    part def GuaranteeProperty specializes BehaviorProperty;
+    part def Contract specializes VerifiableElement { attribute contractScope : String; }
+    part def PropertySet specializes VerifiableElement { attribute propertySetScope : String; }
+    part def ActivityAction specializes ArchitectureElement {
+        attribute actionKind : ActionKind;
+        attribute inputSummary : String;
+        attribute outputSummary : String;
+        attribute wcetMs : String;
+        attribute safetyRelevant : Boolean;
+    }
+    part def ActivityFlow specializes ArchitectureElement {
+        attribute flowKind : ActivityFlowKind;
+        attribute guardCondition : String;
+        attribute weight : String;
+    }
+    part def InteractionScenario specializes TraceableElement {
+        attribute scenarioKind : ScenarioKind;
+        attribute relatedCapability : String;
+        attribute diagramReference : String;
+    }
+    part def InteractionMessage specializes TraceableElement {
+        attribute messageKind : MessageKind;
+        attribute sequenceOrder : Integer;
+        attribute senderComponent : String;
+        attribute receiverComponent : String;
+        attribute exchangeItem : String;
+        attribute timingConstraintMs : String;
+    }
+    part def TimingConstraint specializes VerifiableElement {
+        attribute constraintKind : TimingConstraintKind;
+        attribute minMs : String;
+        attribute maxMs : String;
+        attribute referenceElement : String;
+        attribute verificationMethod : VerificationMethodKind;
+    }
+}

package/src/architecture/constraints/memo_constraints.sysml

@@ -0,0 +1,14 @@
+package memo_architecture_constraints {
+    private import ScalarValues::*;
+
+    doc /* archLayer: constraints */
+
+    constraint def MaxResponseTimeConstraint {
+        attribute responseTimeMs : Real;
+        attribute maxAllowedMs : Real;
+    }
+    constraint def LockoutIntervalConstraint {
+        attribute elapsedMs : Real;
+        attribute lockoutMs : Real;
+    }
+}

package/src/architecture/context/memo_context.sysml

@@ -0,0 +1,58 @@
+package memo_architecture_context {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    part def IntendedUse specializes DocumentedElement {
+        attribute indication : String;
+        attribute contraindication : String;
+        attribute patientPopulation : String;
+        attribute clinicalBenefit : String;
+        attribute regulatoryClassification : String;
+    }
+    part def Actor specializes TraceableElement {
+        attribute actorKind : ActorKind;
+        attribute trainingLevel : String;
+    }
+    part def UseContext specializes TraceableElement {
+        attribute careSetting : String;
+        attribute environment : String;
+        attribute jurisdiction : String;
+        attribute connectedUse : Boolean;
+        attribute intendedUseReference : String;
+    }
+    part def UseError specializes TraceableElement {
+        attribute errorCategory : UseErrorCategoryKind;
+        attribute taskReference : String;
+        attribute severity : SeverityKind;
+        attribute rootCauseType : String;
+    }
+
+    connection def InteractsWith :> SemanticLink {
+        end contextParticipant : Actor;
+        end target : TraceableElement;
+    }
+    // Directional context-level data flow between boundary entities
+    // (Fig 2.1-style "Data Flow" edges).
+    connection def ExchangesWith :> SemanticLink {
+        end source : TraceableElement;
+        end target : TraceableElement;
+    }
+    // Physical connection between boundary entities (fluid path,
+    // mechanical mounting) as opposed to a data flow.
+    connection def ConnectsPhysically :> SemanticLink {
+        end source : TraceableElement;
+        end target : TraceableElement;
+    }
+    // Anchors an intended use to the system it governs.
+    connection def GovernsUse :> SemanticLink {
+        end intendedUse : IntendedUse;
+        end governedElement : TraceableElement;
+    }
+    // Binds a use context to the system or environment it applies to.
+    connection def AppliesInContext :> SemanticLink {
+        end useContext : UseContext;
+        end subjectElement : TraceableElement;
+    }
+}

package/src/architecture/cybersecurity/memo_cybersecurity.sysml

@@ -0,0 +1,99 @@
+package memo_architecture_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::*;
+
+    part def CybersecurityAsset specializes ArchitectureElement {
+        attribute assetKind : AssetKind;
+        attribute confidentialityNeed : String;
+        attribute integrityNeed : String;
+        attribute availabilityNeed : String;
+        attribute privacyRelevant : Boolean;
+        attribute safetyRelevant : Boolean;
+        attribute owningLayer : String;
+        attribute assetOwner : String;
+        attribute classification : String;
+    }
+
+    part def AttackSurface specializes TraceableElement {
+        attribute entryPointKind : InterfaceKind;
+        attribute exposureLevel : String;
+        attribute reachableFrom : String;
+        attribute authenticationExpected : Boolean;
+    }
+
+    item def Threat specializes RiskDriver {
+        attribute threatCategory : ThreatCategoryKind;
+        attribute attackVector : String;
+        attribute threatSource : String;
+        attribute precondition : String;
+        attribute affectedConcern : ConcernKind;
+        attribute defaultTechnique : String;
+        attribute strideCategory : ThreatCategoryKind;
+    }
+
+    item def Vulnerability specializes TraceableElement {
+        attribute weakness : String;
+        attribute exploitability : String;
+        attribute discoveryMethod : String;
+        attribute affectedLayer : String;
+        attribute cweReference : String;
+        attribute remediable : Boolean;
+    }
+
+    item def ThreatScenario specializes TraceableElement {
+        attribute actorDescription : String;
+        attribute assumptionSummary : String;
+        attribute guaranteeSummary : String;
+        attribute securityObjective : String;
+        attribute abuseCaseReference : String;
+        attribute defaultCategory : ThreatCategoryKind;
+    }
+
+    item def CyberHazard specializes Hazard {
+        attribute securityImpact : String;
+        attribute safetyImpact : String;
+        attribute privacyImpact : String;
+        attribute operationalImpact : String;
+        attribute linkedSafetyHazardId : String;
+    }
+
+    item def CyberRisk specializes RiskBeforeMitigation {
+        attribute exploitabilityEstimate : String;
+        attribute attackComplexity : String;
+        attribute detectability : DetectionKind;
+        attribute essentialPerformanceImpact : String;
+        attribute patientSafetyContribution : String;
+    }
+
+    part def CyberMitigation specializes RiskControl {
+        attribute cyberControlKind : CyberControlKind;
+        attribute securityMechanism : String;
+        attribute verificationExpectation : String;
+        attribute hardeningScope : String;
+    }
+
+    requirement def SecurityRequirement :> Requirement {
+        attribute securityObjective : String;
+        attribute derivedFromThreat : String;
+        attribute derivedFromRisk : String;
+        attribute defaultConcern : ConcernKind;
+        attribute safetyClass : SafetyClassKind;
+    }
+
+    item def TrustBoundary specializes InterfaceElement {
+        attribute boundaryType : String;
+        attribute crossingConstraint : String;
+        attribute trustAssumption : String;
+    }
+
+    part def SecurityClaim specializes EvidenceElement {
+        attribute claimText : String;
+        attribute claimScope : String;
+        attribute supportedByEvidence : String;
+    }
+}

package/src/architecture/decisions/memo_decisions.sysml

@@ -0,0 +1,12 @@
+package memo_architecture_decisions {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def DesignDecision specializes TraceableElement {
+        attribute decisionKind : String;
+        attribute alternatives : String;
+        attribute selectedOption : String;
+        attribute decisionStatus : DesignDecisionStatusKind;
+    }
+}