@memoarchitect/ontology 0.8.22 → 0.8.24

package/src/architecture/operational/scenarios/memo_scenarios.sysml

@@ -16,59 +16,15 @@ package memo_architecture_operational_scenarios {
     private import memo_architecture_operational_workflows::*;
     private import memo_architecture_operational_use_cases::*;
 
-    enum def ScenarioVariantKind {
+    // A scenario is a nominal path or an alternate (exception/recovery) path.
+    // Defaults to nominal.
+    enum def ScenarioKind {
         enum nominal;
         enum alternate;
-        enum exception;
-        enum recovery;
-    }
-
-    enum def OperationalConditionKind {
-        enum normal;
-        enum degraded;
-        enum emergency;
-        enum maintenance;
-        enum startup;
-        enum shutdown;
-        enum timeout;
-        enum misuse;
-        enum foreseeableMisuse;
-    }
-
-    // `memoAnalysis` and `memoVerification` keep the regulated terms `analysis`
-    // and `verification` intact but prefixed, because both are SysML v2 reserved
-    // words and cannot be bare enum names. `validation` is not reserved.
-    enum def ScenarioPurposeKind {
-        enum memoAnalysis;
-        enum design;
-        enum memoVerification;
-        enum validation;
-        enum risk;
-        enum cybersecurity;
-    }
-
-    // The architecture/assurance role a scenario plays. These values preserve
-    // the former named scenario specializations without turning a taxonomy into
-    // six action definitions.
-    enum def ScenarioKind {
-        enum functional;
-        enum operative;
-        enum ui;
-        enum threat;
-        // `verification` is a SysML v2 reserved word; retain the regulated
-        // term with the same `memo` prefix used by ScenarioPurposeKind.
-        enum memoVerification;
-        enum hazardRelatedUse;
     }
 
-    // Shared scenario foundation. Fields that apply only to one scenario kind
-    // remain optional here; this keeps the taxonomy queryable without six
-    // otherwise redundant action definitions.
-    action def MemoScenario specializes MemoAction {
-        attribute scenarioKind : ScenarioKind;
-        attribute variantKind : ScenarioVariantKind;
-        attribute operationalCondition : OperationalConditionKind;
-        attribute scenarioPurpose : ScenarioPurposeKind[0..*];
+    action def OperativeScenario specializes MemoAction {
+        attribute scenarioKind : ScenarioKind default ScenarioKind::nominal;
         attribute initialState : String;
         attribute trigger : String;
         attribute preCondition : String;
@@ -76,21 +32,11 @@ package memo_architecture_operational_scenarios {
         attribute postCondition : String;
         attribute pathSummary : String;
 
-        ref involvedActors : OperationalParticipant[0..*];
+        // The workflow this scenario belongs to is expressed by the workflow
+        // (HasScenario); a nominal/alternate pair are scenarios of the same
+        // workflow, distinguished by scenarioKind — no baseScenario back-ref.
+        // Actors are derived from `perform` on the nested steps, not listed.
         ref useContext : UseContext[0..1];
-        // Alternate/exception/recovery scenarios reference their base and the
-        // point at which behavior diverges — never a copied workflow.
-        ref baseScenario : MemoScenario[0..1];
-        attribute variationPoint : String;
-
-        // functional scenario
-        ref selectedFlow : MemoAction[0..1];
-        // operative scenario
-        ref parentWorkflow : OperationalWorkflow[0..1];
-        ref parentUseCase : UseCase[0..1];
-        ref activities : OperationalActivity[0..*];
-        // UI scenario
-        ref parentFlow : MemoAction[0..1];
         // threat scenario
         attribute actorDescription : String;
         attribute assumptionSummary : String;
@@ -106,45 +52,17 @@ package memo_architecture_operational_scenarios {
         attribute selectionRationale : String;
     }
 
-    // An actual or hypothetical execution of a scenario (usability test run,
-    // postmarket incident reconstruction, simulated-use session).
-    part def ScenarioOccurrence specializes MemoPart {
-        attribute occurredAt : String;
-        attribute hypothetical : Boolean;
-        attribute outcomeSummary : String;
-        ref executedScenario : MemoScenario[1];
-    }
-
-    // Ordered selection of a workflow step into a scenario path.
-    // Selects unifies SelectsStep / SelectsFlow (a scenario selects its path
-    // element), keyed by selectsKind.
-    enum def SelectsKind {
-        enum step;
-        enum 'flow';
-    }
-    connection def Selects :> MemoRelationship {
-        attribute selectsKind : SelectsKind;
-        attribute pathOrder : Integer[0..1];
-        attribute decisionTaken : String[0..1];
-        end scenario : MemoScenario :>> source;
-        // A selected path element may be a WorkflowStep action or a flow
-        // element. Those constructs do not share a MEMO base metaclass.
-        end selected :>> target;
-    }
-    abstract connection selectsLinks : Selects[*];
-    metadata def <selects> SelectsMetadata :> SemanticMetadata {
-        :> annotatedElement : SysML::ConnectionDefinition;
-        :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = selectsLinks meta SysML::Usage;
-    }
-    connection def OccursDuring :> MemoRelationship {
-        end occurrence : ScenarioOccurrence :>> source;
-        end context : UseContext :>> target;
+    // A workflow is composed of one or more scenarios (nominal + alternate
+    // paths). ScenarioOccurrence/Executes were removed: an actual execution is
+    // a native SysML *usage* of the scenario, not a separate def + relation.
+    connection def HasScenario :> MemoRelationship {
+        end owningWorkflow : OperationalWorkflow :>> source;
+        end pathScenario : OperativeScenario :>> target;
     }
-    abstract connection occursDuringLinks : OccursDuring[*];
-    metadata def <occursDuring> OccursDuringMetadata :> SemanticMetadata {
+    abstract connection hasScenarioLinks : HasScenario[*];
+    metadata def <hasScenario> HasScenarioMetadata :> SemanticMetadata {
         :> annotatedElement : SysML::ConnectionDefinition;
         :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = occursDuringLinks meta SysML::Usage;
+        :>> baseType = hasScenarioLinks meta SysML::Usage;
     }
 }

package/src/architecture/operational/structure/memo_operational.sysml

@@ -1,31 +1,60 @@
 package memo_architecture_operational_structure {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
-    private import memo_architecture_operational_activities::*;
-    // OperationalActivity now lives in memo_architecture_operational_activities (action def) and
-    // Operational scenarios are defined in memo_architecture_operational_scenarios.
-    part def Mission specializes DocumentedElement {
-        attribute missionKind : String;
-        attribute successCriteria : String;
-        attribute operationalContext : String;
+    private import memo_architecture_operational_use_cases::*;
+
+    // IEC 62366-1 / ISO 14971 intended use: the medical device's declared
+    // purpose and the root of the operational spine. A MemoMission, because
+    // "mission" has no medical-device meaning — intended use is what a device
+    // exists to do. Was in memo_assurance_requirements; moved here as the
+    // operational-world root.
+    part def IntendedUse specializes MemoMission {
+        attribute indication : String;
+        attribute contraindication : String;
+        attribute patientPopulation : String;
+        attribute clinicalBenefit : String;
+        attribute regulatoryClassification : String;
     }
-    part def OperationalEntity specializes ArchitectureElement {
+    part def OperationalEntity specializes MemoPart {
         attribute entityKind : OperationalEntityKind;
         attribute operationalDomain : String;
         attribute responsibility : String;
     }
-    part def OperationalCapability specializes ArchitectureElement {
+    part def OperationalCapability specializes MemoPart {
         attribute capabilityLevel : String;
         attribute preCondition : String;
         attribute postCondition : String;
     }
-    part def OperationalInteraction specializes ArchitectureElement {
-        attribute exchangeKind : FlowKind;
-        attribute direction : DirectionKind;
-        attribute latencyConstraint : String;
+
+    // The intended use requires these operational capabilities (ARCADIA:
+    // Mission Requires Capability).
+    connection def RequiresCapability :> MemoRelationship {
+        end requiringIntendedUse : IntendedUse :>> source;
+        end requiredCapability : OperationalCapability :>> target;
+    }
+    abstract connection requiresCapabilityLinks : RequiresCapability[*];
+    metadata def <requiresCapability> RequiresCapabilityMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = requiresCapabilityLinks meta SysML::Usage;
+    }
+
+    // An operational capability enables a use case (the ability the actor draws
+    // on to accomplish the goal). Capability is tied to the use case, not to
+    // individual activities.
+    connection def EnablesUseCase :> MemoRelationship {
+        end enablingCapability : OperationalCapability :>> source;
+        end enabledUseCase : UseCase :>> target;
+    }
+    abstract connection enablesUseCaseLinks : EnablesUseCase[*];
+    metadata def <enablesUseCase> EnablesUseCaseMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = enablesUseCaseLinks meta SysML::Usage;
     }
 
 }

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

@@ -40,7 +40,6 @@ package memo_architecture_operational_use_cases {
         ref primaryUser : User[0..1];
         ref supportingActors : OperationalParticipant[0..*];
         ref useContext : UseContext[0..1];
-        ref originatingNeeds : Need[0..*];
     }
 
     connection def Motivates :> MemoRelationship {

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

@@ -37,20 +37,24 @@ package memo_architecture_operational_workflows {
         attribute completionCondition : String;
         attribute recoveryPathSummary : String;
         attribute timingConstraints : String;
-        ref involvedActors : OperationalParticipant[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 entryCondition : String;
-        attribute exitCondition : String;
-        ref performedActivity : OperationalActivity[0..1];
-        ref performedTask : UserTask[0..1];
-        ref responsibleRole : OperationalParticipant[0..1];
+    // The use case a workflow realizes. Many workflows may trace to one use
+    // case; the use case does not own its workflows (the trace points upward,
+    // workflow → use case).
+    connection def RealizesUseCase :> MemoRelationship {
+        end realizingWorkflow : OperationalWorkflow :>> source;
+        end realizedUseCase : UseCase :>> target;
+    }
+    abstract connection realizesUseCaseLinks : RealizesUseCase[*];
+    metadata def <realizesUseCase> RealizesUseCaseMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = realizesUseCaseLinks meta SysML::Usage;
     }
 
+
     // decision / fork / join / handoff.
     enum def ControlNodeKind {
         enum decision;
@@ -69,8 +73,6 @@ package memo_architecture_operational_workflows {
         attribute parallelismRationale : String[0..1];
         attribute joinCondition : String[0..1];
         attribute informationTransferred : String[0..1];
-        ref fromRole : OperationalParticipant[0..1];
-        ref toRole : OperationalParticipant[0..1];
     }
 
     // Resources a workflow requires: information, materials, or equipment by
@@ -82,18 +84,14 @@ package memo_architecture_operational_workflows {
     }
 
     // ── 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;
-    }
+    // An element supports (affords, enables) an action — e.g. a UI element
+    // that affords a user task. Use-case and capability tracing are direct
+    // refs now (OperationalWorkflow.useCase,
+    // OperativeAction.contributesToCapabilities), so the former
+    // SupportKind discriminator is gone: what used to be three enum values
+    // that each implied a different target type are now two typed refs plus
+    // this one plain relation.
     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 :>> source;
         end supported : MemoAction :>> target;
     }

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

@@ -1,10 +1,10 @@
-// Deployment (allocation) view: SoftwareModule buildsInto DeploymentUnit;
-// DeploymentUnit deploysTo ProcessingNode. Software deploys only to capable
+// Deployment (allocation) view: SoftwareModule buildsInto SoftwareDeploymentUnit;
+// SoftwareDeploymentUnit deploysTo ProcessingNode. Software deploys only to capable
 // execution nodes (rules/crosslayer).
 //
 // `HostedBy` is NOT part of that chain, and this comment used to claim it was
 // ("SoftwareComponent hostedBy ProcessingNode"). It is
-// `processingNode : ArchitectureElement -> hostAssembly : ArchitectureElement`:
+// `processingNode : ProcessingNode -> hostAssembly : PhysicalAssembly`:
 // physical hosting of a node by the assembly it is mounted in, running the
 // other way and between different things. Software reaches a node through
 // DeploysTo.
@@ -26,14 +26,14 @@ package memo_architecture_realization_deployment {
     private import memo_architecture_logical_structure::*;
     private import memo_architecture_logical_interfaces::*;                   // ComponentExchange
 
-    part def DeploymentUnit specializes ArchitectureElement {
+    part def SoftwareDeploymentUnit specializes MemoPart {
         attribute unitKind : String;
         attribute version : String;
         attribute integrityProtection : String;
         attribute installationMechanism : String;
     }
 
-    part def RuntimeEnvironment specializes ArchitectureElement {
+    part def RuntimeEnvironment specializes MemoPart {
         attribute environmentKind : String;
         attribute osOrRtos : String;
         attribute providedServices : String;
@@ -42,7 +42,7 @@ package memo_architecture_realization_deployment {
 
     connection def BuildsInto :> MemoRelationship {
         end module : SoftwareModule :>> source;
-        end deploymentUnit : DeploymentUnit :>> target;
+        end deploymentUnit : SoftwareDeploymentUnit :>> target;
     }
     abstract connection buildsIntoLinks : BuildsInto[*];
     metadata def <buildsInto> BuildsIntoMetadata :> SemanticMetadata {
@@ -52,7 +52,7 @@ package memo_architecture_realization_deployment {
     }
     connection def DeploysTo :> MemoRelationship {
         attribute deploymentKind : DeploymentKind;
-        end deploymentUnit : DeploymentUnit :>> source;
+        end deploymentUnit : SoftwareDeploymentUnit :>> source;
         end node : ProcessingNode :>> target;
     }
     abstract connection deploysToLinks : DeploysTo[*];
@@ -140,7 +140,7 @@ package memo_architecture_realization_deployment {
         enum path;
     }
     // A flow declared at a logical component boundary (in-port → out-port).
-    part def FlowSpecification specializes ArchitectureElement {
+    part def FlowSpecification specializes MemoPart {
         attribute flowKind : FlowSpecKind;
         ref inPort : LogicalPort[0..1];
         ref outPort : LogicalPort[0..1];
@@ -148,7 +148,7 @@ package memo_architecture_realization_deployment {
     // 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 {
+    part def EndToEndFlow specializes MemoPart {
         attribute latencyBudgetMs : Real;
         attribute analysisPurpose : String;
         ref sourceFunction : MemoFunction[0..1];
@@ -174,7 +174,7 @@ package memo_architecture_realization_deployment {
     // The flow traverses a software→hardware binding; latency accrues here.
     connection def FlowTraversesBinding :> MemoRelationship {
         end endToEndFlow : EndToEndFlow :>> source;
-        end deploymentUnit : DeploymentUnit :>> target;
+        end deploymentUnit : SoftwareDeploymentUnit :>> target;
     }
     abstract connection flowTraversesBindingLinks : FlowTraversesBinding[*];
     metadata def <flowTraversesBinding> FlowTraversesBindingMetadata :> SemanticMetadata {

package/src/architecture/realization/physical/memo_physical_architecture.sysml

@@ -6,7 +6,7 @@ package memo_architecture_realization_physical {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def ProcessingNode specializes ArchitectureElement {
+    part def ProcessingNode specializes MemoPart {
         attribute nodeKind : ProcessingNodeKind;
         attribute processorArchitecture : String;
         attribute memoryMB : String;
@@ -17,7 +17,7 @@ package memo_architecture_realization_physical {
         attribute supportsContainerization : Boolean;
         attribute realTimeCapable : Boolean;
     }
-    part def MemoryDevice specializes ArchitectureElement {
+    part def MemoryDevice specializes MemoPart {
         attribute memoryKind : String;
         attribute capacityMB : String;
         attribute nonVolatile : Boolean;

package/src/artifacts/templates/dhf/system/sad.md

@@ -75,7 +75,7 @@ Runtime behaviour: the components executing in the system and the connectors thr
 #### 3.2.1 Runtime Environments
 
 ```memo-query
-kind: [RuntimeEnvironment, DeploymentUnit]
+kind: [RuntimeEnvironment, SoftwareDeploymentUnit]
 display: table
 columns: name, layer, doc
 sort: name
@@ -101,12 +101,12 @@ Software elements mapped to their execution environments.
 #### 3.3.1 Deployment Units
 
 ```memo-query
-kind: DeploymentUnit
+kind: SoftwareDeploymentUnit
 traverse: outgoing deploysTo
 display: table
 columns: name, kind, layer, doc
 sort: name
-empty: "No deployments defined. Add DeploysTo links from DeploymentUnit to the processing node."
+empty: "No deployments defined. Add DeploysTo links from SoftwareDeploymentUnit to the processing node."
 ```
 
 ---

package/src/assurance/cybersecurity/memo_cybersecurity.sysml

@@ -10,7 +10,7 @@ package memo_assurance_cybersecurity {
     private import memo_assurance_verification_validation::*;
     private import memo_architecture_operational_scenarios::*;
 
-    part def CybersecurityAsset specializes ArchitectureElement {
+    part def CybersecurityAsset specializes MemoPart {
         attribute assetKind : AssetKind;
         attribute confidentialityNeed : String;
         attribute integrityNeed : String;
@@ -99,7 +99,7 @@ package memo_assurance_cybersecurity {
     }
     connection def RealizedByScenario :> MemoRelationship {
         end realizedThreat : RequirementDriver :>> source;
-        end scenario : MemoScenario :>> target;
+        end scenario : OperativeScenario :>> target;
     }
     abstract connection realizedByScenarioLinks : RealizedByScenario[*];
     metadata def <realizedByScenario> RealizedByScenarioMetadata :> SemanticMetadata {

package/src/assurance/human_factors/memo_human_factors.sysml

@@ -21,7 +21,7 @@ package memo_assurance_human_factors {
     }
 
     connection def CommitsUseError :> MemoRelationship {
-        end task : UserTask :>> source;
+        end task : OperativeAction :>> source;
         end useError : UseError :>> target;
     }
     abstract connection commitsUseErrorLinks : CommitsUseError[*];
@@ -32,7 +32,7 @@ package memo_assurance_human_factors {
     }
     connection def EvaluatesTask :> MemoRelationship {
         end evaluation : MemoEvidence :>> source;
-        end task : UserTask :>> target;
+        end task : OperativeAction :>> target;
     }
     abstract connection evaluatesTaskLinks : EvaluatesTask[*];
     metadata def <evaluatesTask> EvaluatesTaskMetadata :> SemanticMetadata {

package/src/assurance/requirements/memo_requirements.sysml

@@ -7,22 +7,6 @@ package memo_assurance_requirements {
     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- /
@@ -42,14 +26,14 @@ package memo_assurance_requirements {
 
     requirement def Requirement specializes MemoRequirement {
         attribute requirementKind : RequirementKind;
-        attribute statement : String;
+        attribute :>> statement : String;
         attribute sourceKind : RequirementSourceKind;
         attribute concernKind : ConcernKind;
         // Editorial state is the inherited `status : ElementStatusKind` — the
         // one status vocabulary in MEMO. Whether a requirement is implemented,
         // verified, or validated is read from its Realizes / VerifiedBy /
         // Validates links, not restated here.
-        attribute acceptanceCriteria : String;
+        attribute :>> acceptanceCriteria : String;
         attribute subjectDescription : String;
         attribute actorDescription : String;
         attribute assumptionSummary : String;

package/src/assurance/safety_risk/analysis/memo_fmea.sysml

@@ -184,7 +184,7 @@ package memo_assurance_safety_risk_analysis {
         :>> baseType = identifiesHazardLinks meta SysML::Usage;
     }
     connection def HasFailureMode :> MemoRelationship {
-        end element : ArchitectureElement :>> source;
+        end element : MemoPart :>> source;
         end failureMode : FailureMode :>> target;
     }
     abstract connection hasFailureModeLinks : HasFailureMode[*];

package/src/assurance/safety_risk/memo_risk.sysml

@@ -6,6 +6,18 @@ package memo_assurance_safety_risk {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
     private import memo_assurance_requirements::*;
+
+    // ISO 14971 / IEC 62366-1 risk-analysis input. A model element so hazards,
+    // scenarios, requirements, and DHF records can trace to the foreseeable
+    // misuse that motivated them. Its counterpart, IntendedUse, is now the
+    // operational-world root (memo_architecture_operational_structure::IntendedUse,
+    // a MemoMission).
+    part def ReasonablyForeseeableMisuse specializes MemoPart {
+        attribute misuseContext : String;
+        attribute foreseeableBasis : String;
+        attribute affectedUseContext : String;
+    }
+
     part def Risk specializes RiskDriver {
         attribute probabilityEstimate : ProbabilityKind;
         attribute severityEstimate : SeverityKind;

package/src/assurance/verification_validation/memo_assurance.sysml

@@ -34,7 +34,7 @@ package memo_assurance_verification_validation {
     // Safety-critical functions must trace to verification (rules/coverage).
     connection def ExecutesScenario :> MemoRelationship {
         end verificationCase : VerificationCase :>> source;
-        end scenario : MemoScenario :>> target;
+        end scenario : OperativeScenario :>> target;
     }
     abstract connection executesScenarioLinks : ExecutesScenario[*];
     metadata def <executesScenario> ExecutesScenarioMetadata :> SemanticMetadata {

package/src/core/common/memo_common.sysml

@@ -78,7 +78,6 @@ package memo_core_common {
     //     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;
     enum def EvidenceKind { enum testArtifact; enum evidence; enum formativeEvaluation; enum usabilityValidation; enum securityClaim; }
     part def MemoEvidence specializes MemoPart {
@@ -108,10 +107,15 @@ package memo_core_common {
     // description registers every MemoPart now carries: a title and its place
     // in a document. The former `shortDescription`/`longDescription` pair is
     // gone — short is inherited, and `description` IS the long form.
-    part def DocumentedElement specializes MemoPart {
-        attribute title : String;
-        attribute documentUsage : String[*];
-        attribute sectionIdentifier : String;
+    // Top-level goal a system or operation exists to fulfil, with its success
+    // criteria and context. Domain layers specialize it; the medical-device
+    // intended use (memo_architecture_operational_structure::IntendedUse) is a
+    // MemoMission. Specializes MemoPart directly — name/description/rationale
+    // already live there, so no DocumentedElement layer is needed.
+    abstract part def MemoMission specializes MemoPart {
+        attribute missionKind : String;
+        attribute successCriteria : String;
+        attribute operationalContext : String;
     }
 
     // ─── Construct-specific foundations (non-part metaclasses) ───────

package/src/core/relationships/memo_relationships.sysml

@@ -79,12 +79,12 @@ package memo_core_relationships {
     // SystemFunction a part def with its behaviour stapled on through a
     // separate action def, and what makes `allocate <function> to <actor>` —
     // ARCADIA's own System Analysis mechanism — illegal, since Actor is a
-    // MemoPart but not an ArchitectureElement.
+    // MemoPart but not a narrower part subtype.
     //
     // Several of the relaxed ends were ALREADY being violated by real content
-    // before they were relaxed: `composes` links parts to WorkflowStep and
-    // OperationalActivity (action defs) and to SoftwarePort/PhysicalPort;
-    // `precedes` links OperationalActivity to OperationalActivity; `allocatedTo`
+    // before they were relaxed: `composes` links parts to OperativeAction
+    // (an action def) and to SoftwarePort/PhysicalPort;
+    // `precedes` links OperativeAction to OperativeAction; `allocatedTo`
     // has ActionUsage sources; `bindsToInterface` targets an `interface def`,
     // which an InterfaceElement-typed end cannot hold. The types were not
     // buying the strictness they appeared to buy.
@@ -160,7 +160,7 @@ package memo_core_relationships {
 
     connection def ThreatenedBy :> MemoRelationship {
         attribute threatRole : String;
-        end protectedAsset : ArchitectureElement :>> source;
+        end protectedAsset : MemoPart :>> source;
         end realizedThreat : RequirementDriver :>> target;
     }
     abstract connection threatenedByLinks : ThreatenedBy[*];
@@ -218,8 +218,8 @@ package memo_core_relationships {
     }
 
     connection def HostedBy :> MemoRelationship {
-        end processingNode : ArchitectureElement :>> source;
-        end hostAssembly : ArchitectureElement :>> target;
+        end processingNode : MemoPart :>> source;
+        end hostAssembly : MemoPart :>> target;
     }
     abstract connection hostedByLinks : HostedBy[*];
     metadata def <hostedBy> HostedByMetadata :> SemanticMetadata {
@@ -248,7 +248,7 @@ package memo_core_relationships {
     }
 
     connection def AnalyzedBy :> MemoRelationship {
-        end element : ArchitectureElement :>> source;
+        end element : MemoPart :>> source;
         end analysisArtifact : AnalysisArtifact :>> target;
     }
     abstract connection analyzedByLinks : AnalyzedBy[*];

package/src/methodology/workflow/memo_workflow.sysml

@@ -5,11 +5,11 @@ package memo_methodology_workflow {
     private import memo_core_enumerations::*;
 
     // Named for its axis: this is a step in a METHODOLOGY workflow (a lifecycle
-    // stage with entry/exit criteria), distinct from
-    // memo_architecture_operational_workflows::WorkflowStep, which is a step in
-    // an OPERATIONAL workflow performed by users. The two carry different
-    // attributes and must not share a short name — an overloaded name resolves
-    // by load order and silently validates a usage against the wrong type.
+    // stage with entry/exit criteria), distinct from an OPERATIONAL workflow's
+    // steps, which are OperativeActions performed by users or the system. The
+    // two carry different attributes and must not share a short name — an
+    // overloaded name resolves by load order and silently validates a usage
+    // against the wrong type.
     action def MethodologyWorkflowStep :> MemoAction {
         attribute stage : WorkflowStageKind;
         attribute objectiveDescription : String;