@memoarchitect/ontology 0.8.22 → 0.10.9

package/src/architecture/functional/functions/memo_functions.sysml

@@ -8,14 +8,14 @@
 // ─── A function is a behaviour ───────────────────────────────────────────
 //
 // `MemoFunction` and both its specializations are `action def`s. They were
-// `part def SystemFunction specializes ArchitectureElement` until Track A0
-// removed the reason: relation ends were typed on MemoPart/ArchitectureElement,
+// `part def SystemFunction specializes MemoPart` until Track A0
+// removed the reason: relation ends were typed on part-based types,
 // KerML forbids a behaviour from specializing a part-based type, and a function
 // has to be satisfiable, verifiable, and allocatable. So a function was declared
-// a part, and a separate `action def SystemAction` carried the behaviour with a
+// a part, and a separate `action def OperativeAction` carried the behaviour with a
 // `ref performedFunction` stapling the two back together — a reference used in
 // ZERO example files. The ends are metaclass-neutral now (CR-ONT-060..073), so
-// the split has no cause and is gone: SystemAction is merged into the function
+// the split has no cause and is gone: OperativeAction is merged into the function
 // family, and its `actionKind` moved onto MemoFunction where it was always
 // describing the function anyway.
 //
@@ -97,7 +97,7 @@ package memo_architecture_functional_functions {
     // So this part def is a workaround for a MEMO gap, not a design MEMO is
     // entitled to. Restoring the two dropped clauses is what would let it
     // collapse into the flow it stands in for.
-    part def FunctionalExchange specializes ArchitectureElement {
+    part def FunctionalExchange specializes MemoPart {
         attribute flowKind : FlowKind;
         attribute latencyBudgetMs : Real;
         attribute staleAfterMs : Real;
@@ -112,7 +112,7 @@ package memo_architecture_functional_functions {
 
     // A reusable functional route through system responsibilities. Functional
     // flows are part of functional architecture, never logical structure.
-    part def FunctionalFlow specializes ArchitectureElement {
+    part def FunctionalFlow specializes MemoPart {
         attribute flowCategory : FunctionalFlowKind;
         attribute endToEndLatencyBudgetMs : String;
         attribute safetyRelevant : Boolean;

package/src/architecture/implementation/hardware/common/memo_hardware_common.sysml

@@ -13,7 +13,17 @@ package memo_architecture_implementation_hardware_common {
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
 
-    part def PhysicalAssembly specializes ArchitectureElement {
+    // The shared root of the physical family.
+    //
+    // `PhysicalAssembly` and `PhysicalComponent` each specialized `MemoPart`
+    // directly, so the family had two roots and no single type that means
+    // "a physical thing". A containment rule has to name one type, and
+    // `conformsTo(MemoPart)` is far too wide — it admits a requirement or a
+    // hazard. This is that type, and it carries nothing of its own: the split
+    // between an assembly and a component is what the two subtypes are for.
+    abstract part def PhysicalElement specializes MemoPart { }
+
+    part def PhysicalAssembly specializes PhysicalElement {
         attribute responsibility : String;
         attribute safetyRole : String;
         attribute partNumber : String;
@@ -25,7 +35,7 @@ package memo_architecture_implementation_hardware_common {
     // Retained name from 0.4; an electronics-centred assembly.
     part def HardwareAssembly specializes PhysicalAssembly;
 
-    part def PhysicalComponent specializes ArchitectureElement {
+    part def PhysicalComponent specializes PhysicalElement {
         attribute partNumber : String;
         attribute materialSummary : String;
         // ISO 10993-1 contact characterization; required when true.

package/src/architecture/implementation/software/runtime/memo_software_runtime.sysml

@@ -78,15 +78,4 @@ package memo_architecture_implementation_software_runtime {
         // a component belongs to without claiming to describe it.
     }
 
-    connection def ComponentConnects :> MemoRelationship {
-        attribute protocolSummary : String;
-        end sourceComponent : SoftwareComponent :>> source;
-        end targetComponent : SoftwareComponent :>> target;
-    }
-    abstract connection componentConnectsLinks : ComponentConnects[*];
-    metadata def <componentConnects> ComponentConnectsMetadata :> SemanticMetadata {
-        :> annotatedElement : SysML::ConnectionDefinition;
-        :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = componentConnectsLinks meta SysML::Usage;
-    }
 }

package/src/architecture/implementation/software/structure/memo_software_structure.sysml

@@ -28,7 +28,7 @@ package memo_architecture_implementation_software_structure {
     // the term "software item" for this concept, but reserving SoftwareItem
     // for the native SysML item family keeps structural parts and exchanged
     // values unambiguous in the model.
-    abstract part def SoftwareElement specializes ArchitectureElement {
+    abstract part def SoftwareElement specializes MemoPart {
         attribute safetyClass : SafetyClassKind;
         attribute complexity : ComplexityKind;
     }
@@ -70,17 +70,17 @@ package memo_architecture_implementation_software_structure {
         attribute soupClassification : SOUPClassificationKind[0..1];
     }
 
-    part def Algorithm specializes ArchitectureElement {
+    part def Algorithm specializes MemoPart {
         attribute algorithmKind : String;
         attribute inputSummary : String;
         attribute outputSummary : String;
         attribute clinicalPerformanceClaim : String;
     }
-    part def DataModel specializes ArchitectureElement {
+    part def DataModel specializes MemoPart {
         attribute schemaReference : String;
         attribute persistenceScope : String;
     }
-    part def ConfigurationArtifact specializes ArchitectureElement {
+    part def ConfigurationArtifact specializes MemoPart {
         attribute configurationScope : String;
         attribute version : String;
     }
@@ -89,8 +89,8 @@ package memo_architecture_implementation_software_structure {
     abstract item def SoftwareItem specializes MemoItem {
         attribute schemaIdentifier : String;
         attribute schemaVersion : String;
-        attribute encoding : String;
-        attribute timestampRequired : Boolean;
+        attribute :>> encoding : String;
+        attribute :>> timestampRequired : Boolean;
     }
 
     item def SBOMEntry specializes SoftwareItem {
@@ -108,7 +108,7 @@ package memo_architecture_implementation_software_structure {
     // Moved out of memo_core_relationships: their ends are typed against
     // types declared here, and core must not depend on a domain package.
     connection def DependsOnSoup :> MemoRelationship {
-        end component : ArchitectureElement :>> source;
+        end component : MemoPart :>> source;
         end soupItem : SoftwareElement :>> target;
     }
     abstract connection dependsOnSoupLinks : DependsOnSoup[*];

package/src/architecture/implementation/ui/memo_ui.sysml

@@ -110,7 +110,7 @@ package memo_architecture_implementation_ui {
         enum recovery;
     }
 
-    part def UserInterface specializes ArchitectureElement {
+    part def UserInterface specializes MemoPart {
         attribute modality : String;
         attribute uiTechnology : String;
     }
@@ -121,7 +121,7 @@ package memo_architecture_implementation_ui {
     // "something the user interacts with" rather than against software
     // specifically. Without it a use error on a knob would be unmodellable,
     // because ErrorAtElement would only accept a UIElement.
-    abstract part def InteractionElement specializes ArchitectureElement {
+    abstract part def InteractionElement specializes MemoPart {
         attribute labelText : String;
         attribute accessibilitySummary : String;
         // alarm annunciation (optional; IEC 60601-1-8)
@@ -235,7 +235,7 @@ package memo_architecture_implementation_ui {
     }
 
     // ─── Captured evidence ───────────────────────────────────────
-    // One image of one screen. MemoEvidence, not ArchitectureElement: it
+    // One image of one screen. MemoEvidence, not a design element: it
     // records what a specific build actually displayed at a specific time,
     // which is the provenance a design review or a usability engineering file
     // needs before it can rely on the picture. The screen it depicts is an
@@ -258,11 +258,11 @@ package memo_architecture_implementation_ui {
     }
 
     // UI state is presentation state — distinct from system/device state.
-    part def UIState specializes ArchitectureElement {
+    part def UIState specializes MemoPart {
         attribute displayedInformation : String;
         attribute availableActions : String;
     }
-    part def UIEvent specializes ArchitectureElement {
+    part def UIEvent specializes MemoPart {
         attribute eventSource : String;
         attribute intent : InteractionIntentKind;
     }
@@ -274,24 +274,12 @@ package memo_architecture_implementation_ui {
     }
 
     // A reusable dialogue structure through the UI; a selected path through
-    // it is a MemoScenario with scenarioKind `ui`.
+    // it is a OperativeScenario with scenarioKind `ui`.
     action def InteractionFlow specializes MemoAction {
         attribute entryPoint : String;
         attribute exitPoint : String;
     }
 
-    connection def DataBinding :> MemoRelationship {
-        attribute bindingExpression : String;
-        attribute refreshPolicy : String;
-        end boundElement : InteractionElement :>> source;
-        end dataSource : MemoItem :>> target;
-    }
-    abstract connection dataBindingLinks : DataBinding[*];
-    metadata def <dataBinding> DataBindingMetadata :> SemanticMetadata {
-        :> annotatedElement : SysML::ConnectionDefinition;
-        :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = dataBindingLinks meta SysML::Usage;
-    }
     // `PresentsState` had zero usages anywhere in the tree (R10-S6). Its
     // audited native form, `exhibit state`, does not actually fit: `UIState`
     // is a `part def` with plain string attributes, not a `state def`, and
@@ -320,17 +308,6 @@ package memo_architecture_implementation_ui {
     // Conflating the two was the mistake that made "clicking takes you to a
     // child view" look like spatial nesting; it is a separate frame reached
     // from here, and only this relation says so.
-    connection def NavigatesTo :> MemoRelationship {
-        attribute triggerGesture : String;
-        end sourceElement : UIElement :>> source;
-        end targetScreen : UIElement :>> target;
-    }
-    abstract connection navigatesToLinks : NavigatesTo[*];
-    metadata def <navigatesTo> NavigatesToMetadata :> SemanticMetadata {
-        :> annotatedElement : SysML::ConnectionDefinition;
-        :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = navigatesToLinks meta SysML::Usage;
-    }
 
     // ── §18 traceability ─────────────────────────────────────────
     connection def ElementTriggersAction :> MemoRelationship {
@@ -356,7 +333,7 @@ package memo_architecture_implementation_ui {
         :>> baseType = flowServesUseCaseLinks meta SysML::Usage;
     }
     // A UI scenario realizes a functional scenario one layer up: each is a
-    // MemoScenario selected by scenarioKind rather than a separate definition.
+    // OperativeScenario selected by scenarioKind rather than a separate definition.
     connection def ErrorAtElement :> MemoRelationship {
         end useError : UseError :>> source;
         end element : InteractionElement :>> target;
@@ -371,7 +348,7 @@ package memo_architecture_implementation_ui {
     // (confirmation dialog, lockout, guarded control).
     connection def ControlImplementedBy :> MemoRelationship {
         end riskControl : RiskControlMeasure :>> source;
-        end implementingElement : ArchitectureElement :>> target;
+        end implementingElement :>> target;
     }
     abstract connection controlImplementedByLinks : ControlImplementedBy[*];
     metadata def <controlImplementedBy> ControlImplementedByMetadata :> SemanticMetadata {

package/src/architecture/logical/interfaces/memo_interfaces.sysml

@@ -15,7 +15,9 @@ package memo_architecture_logical_interfaces {
     // DigitalInterface / SPIInterface / RestInterface … hierarchy: those were
     // 20+ classes that differed only in the value of `protocol`.
 
-    interface def Interface specializes MemoInterface {
+    // Specializes the standard library interface as well as MEMO's base,
+    // rather than shadowing it — see the note on UseCase.
+    interface def Interface specializes MemoInterface, Interfaces::Interface {
         attribute interfaceKind : InterfaceKind;   // semantic + signaling family
         attribute direction : DirectionKind;
         attribute protocol : String;               // "SPI", "CAN", "Ethernet", "REST", "4-20mA"
@@ -85,7 +87,7 @@ package memo_architecture_logical_interfaces {
     port def SensorPort specializes DataPort { attribute sensorDomain : String; }
     port def CommandPort specializes DataPort { attribute commandDomain : String; }
 
-    part def ComponentExchange specializes ArchitectureElement {
+    part def ComponentExchange specializes MemoPart {
         attribute exchangeKind : FlowKind;
         // Metaclass-neutral endpoints. CR-ONT-002 used to read: "Typed
         // endpoints. A component or a boundary port may terminate an exchange,

package/src/architecture/logical/structure/memo_logical_structure.sysml

@@ -116,7 +116,7 @@ package memo_architecture_logical_structure {
     // optional so a component carries only the ones its role needs. A channel
     // claiming independence must still be linked by IndependentOf with its
     // basis stated.
-    part def LogicalComponent specializes ArchitectureElement {
+    part def LogicalComponent specializes MemoPart {
         attribute componentRole : ComponentRoleKind;
         attribute systemType : SystemTypeKind[0..1];
         attribute responsibility : String;
@@ -163,7 +163,7 @@ package memo_architecture_logical_structure {
         :>> baseType = logicalConnectorLinks meta SysML::Usage;
     }
     // A transfer of a typed item across a connector.
-    part def LogicalExchange specializes ArchitectureElement {
+    part def LogicalExchange specializes MemoPart {
         attribute contentKind : FlowContentKind;
         attribute direction : DirectionKind;
         attribute latencyRequirement : String;
@@ -175,17 +175,17 @@ package memo_architecture_logical_structure {
     // States and modes of the logical solution (kept distinct from UI state
     // and from physical device configuration).
 
-    part def LogicalBehavior specializes ArchitectureElement {
+    part def LogicalBehavior specializes MemoPart {
         attribute behaviorSummary : String;
         attribute executionSemantics : String;
     }
 
     // Isolation, fault containment, and trust boundaries (§10).
-    part def IsolationBoundary specializes ArchitectureElement {
+    part def IsolationBoundary specializes MemoPart {
         attribute boundaryKind : String;
         attribute isolationMechanism : String;
     }
-    part def FaultContainmentRegion specializes ArchitectureElement {
+    part def FaultContainmentRegion specializes MemoPart {
         attribute containmentRationale : String;
     }
 

package/src/architecture/operational/activities/memo_activities.sysml

@@ -1,11 +1,11 @@
-// Operational activities and user tasks (§7, §17). Activities are behavioral
-// concepts (action defs on MemoAction). An OperationalActivity is work
-// performed in the operational world; a UserTask is a unit of user work within
-// an activity (IEC 62366-1); a critical task is a UserTask whose criticality is
-// high/catastrophic — its failure could cause serious harm (FDA HF guidance) and
-// it must trace to usability validation.
-// Task difficulty belongs to a task performed in a context — never to an
-// instrument (TaskDifficultyAssessment).
+// Operational actions (§7, §17). One `OperativeAction` (action def on
+// MemoAction) is a unit of operational work; whether a User or the system
+// performs it is a native `perform` relationship, not a subtype.
+// A critical task is an OperativeAction with high/catastrophic criticality that
+// a User performs — its failure could cause serious harm (IEC 62366-1 / FDA HF
+// guidance) and it must trace to usability validation. Task difficulty belongs
+// to an action performed in a context (TaskDifficultyAssessment), never to an
+// instrument.
 package memo_architecture_operational_activities {
     private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
@@ -24,33 +24,25 @@ package memo_architecture_operational_activities {
         enum extreme;
     }
 
-    action def OperationalActivity specializes MemoAction {
+    // One operational action / step. Who performs it — a human actor or the
+    // system — is a relationship (native `perform`), not a subtype, so an
+    // action can migrate from user- to system-performed (automation, as-is →
+    // to-be) without changing type. This one type merges the former
+    // OperationalActivity, UserTask, SystemAction and TaskStep: a "user task"
+    // is simply an OperativeAction a User performs; finer steps are nested
+    // OperativeActions. Human-factors fields (potentialHarm, severityIfFailed,
+    // perceptualCue …) are optional, meaningful when a User is the performer.
+    action def OperativeAction specializes MemoAction {
         attribute trigger : String;
         attribute preCondition : String;
         attribute postCondition : String;
         attribute criticality : CriticalityKind;
-        ref performedBy : OperationalParticipant[0..*];
-    }
-
-    // A human task. A critical task (IEC 62366-1 / FDA HF guidance §3) is a
-    // UserTask whose criticality is high or catastrophic — a use error could
-    // cause serious harm. potentialHarm/severityIfFailed are set only for such
-    // tasks. Modeled as an attribute, like SystemFunction.criticality.
-    action def UserTask specializes MemoAction {
         attribute taskGoal : String;
-        attribute preCondition : String;
-        attribute postCondition : String;
         attribute expectedDuration : String;
         attribute frequencyOfUse : String;
-        attribute criticality : CriticalityKind;
         attribute potentialHarm : String[0..1];
         attribute severityIfFailed : SeverityKind[0..1];
-        ref performingUser : User[0..1];
-    }
-
-    // An elementary perceptual/cognitive/motor step within a user task
-    // (task analysis granularity: grasp needle, drive needle, tie knot …).
-    action def TaskStep specializes MemoAction {
+        attribute automated : Boolean;
         attribute perceptualCue : String;
         attribute feedbackExpected : String;
     }
@@ -72,7 +64,6 @@ package memo_architecture_operational_activities {
         attribute assessor : String;
         attribute assessmentMethod : String;
 
-        ref assessedTask : UserTask[0..1];
         ref userPopulation : User[0..1];
         ref useEnvironment : UseEnvironment[0..1];
         ref instrument : MemoPart[0..1];
@@ -81,7 +72,7 @@ package memo_architecture_operational_activities {
 
     connection def AssessesDifficulty :> MemoRelationship {
         end assessment : TaskDifficultyAssessment :>> source;
-        end task : UserTask :>> target;
+        end task : OperativeAction :>> target;
     }
     abstract connection assessesDifficultyLinks : AssessesDifficulty[*];
     metadata def <assessesDifficulty> AssessesDifficultyMetadata :> SemanticMetadata {

package/src/architecture/operational/context/actors/memo_actors.sysml

@@ -1,7 +1,8 @@
-// Operational participants (§4) interact with the system; they are distinct
-// from stakeholders (memo_architecture_operational_context_stakeholders), who have concerns about the
-// system but need not interact with it. "User" is reserved for a human who
-// interacts with the medical device.
+// Operational participants (§4) interact with the system. A stakeholder —
+// someone with a concern about the system who need not interact with it — is
+// a native SysML notion (a Part in a stakeholder membership on a concern or
+// viewpoint), not a separate MEMO type; the same Part may fill both roles.
+// "User" is reserved for a human who interacts with the medical device.
 package memo_architecture_operational_context_actors {
     private import ScalarValues::*;
 

package/src/architecture/operational/context/stakeholders/memo_stakeholders.sysml

@@ -1,9 +1,9 @@
-// ISO/IEC/IEEE 42010 architecture-description core (§4). A stakeholder has
-// interests in the system; a Viewpoint frames concerns; a View
-// (memo_viewpoints_definitions::MemoView) is governed by a viewpoint within an
-// ArchitectureDescription. The same real-world entity may play both the
-// Stakeholder and operational-participant concerns stay distinct from the
-// architecture-description types below.
+// ISO/IEC/IEEE 42010 architecture-description core (§4): ArchitectureDescription,
+// ModelKind, and CorrespondenceRule below. Stakeholders and concerns — 42010's
+// other cornerstones — are native SysML v2 constructs (stakeholder memberships
+// and `concern def`), used directly rather than reinvented as MEMO types. A
+// View (memo_viewpoints_definitions::MemoView) conforms to a Viewpoint within
+// an ArchitectureDescription.
 package memo_architecture_operational_context_stakeholders {
     private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
@@ -12,7 +12,7 @@ package memo_architecture_operational_context_stakeholders {
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
     private import memo_architecture_operational_context_actors::*;
-    part def ArchitectureDescription specializes DocumentedElement {
+    part def ArchitectureDescription specializes MemoPart {
         attribute systemOfInterest : String;
         attribute version : String;
     }

package/src/architecture/operational/context/use_context/memo_use_context.sysml

@@ -23,7 +23,6 @@ package memo_architecture_operational_context_use_context {
         attribute environment : String;
         attribute jurisdiction : String;
         attribute connectedUse : Boolean;
-        attribute intendedUseReference : String;
     }
 
     // The physical/organizational environment of use (IEC 62366-1 3.20),
@@ -56,9 +55,9 @@ package memo_architecture_operational_context_use_context {
         attribute contextSide : ContextSideKind;
         // The verb, as it should read on the edge ("Directs procedure").
         attribute interactionLabel : String[0..1];
-        end contextParticipant : ArchitectureElement :>> source;
+        end contextParticipant : MemoPart :>> source;
         // Untyped: the system of interest may be a part or an operational activity.
-        end systemOfInterest : ArchitectureElement :>> target;
+        end systemOfInterest :>> target;
     }
     abstract connection interactsInContextLinks : InteractsInContext[*];
     metadata def <interactsInContext> InteractsInContextMetadata :> SemanticMetadata {
@@ -67,17 +66,9 @@ package memo_architecture_operational_context_use_context {
         :>> baseType = interactsInContextLinks meta SysML::Usage;
     }
 
-    connection def InteractsWith :> MemoRelationship {
-        end contextParticipant : OperationalParticipant :>> source;
-        // Untyped so operational activities (action def) can be targets as well as parts.
-        end target;
-    }
-    abstract connection interactsWithLinks : InteractsWith[*];
-    metadata def <interactsWith> InteractsWithMetadata :> SemanticMetadata {
-        :> annotatedElement : SysML::ConnectionDefinition;
-        :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = interactsWithLinks meta SysML::Usage;
-    }
+    // `InteractsWith` is native `connect` (2026-08-18): write
+    // `connection connect <participant> to <target>;`. It carried no
+    // attributes, and the operational-context package already scopes the ends.
     // `ConnectsPhysically` is native `connect` (R10-S6): write
     // `connection connect source ::> <a> to target ::> <b>;` — the ordinary
     // untyped binary connection — instead of a connection def for it.

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,7 @@ 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;
-    }
-    abstract connection occursDuringLinks : OccursDuring[*];
-    metadata def <occursDuring> OccursDuringMetadata :> SemanticMetadata {
-        :> annotatedElement : SysML::ConnectionDefinition;
-        :> annotatedElement : SysML::ConnectionUsage;
-        :>> baseType = occursDuringLinks meta SysML::Usage;
-    }
+    // 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.
 }