@memoarchitect/ontology 0.6.5 → 0.8.22

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

@@ -4,6 +4,7 @@
 // plus independence constraints — never by duplicating identically named
 // components.
 package memo_architecture_logical_structure {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -37,13 +38,15 @@ package memo_architecture_logical_structure {
     }
 
     // The role a logical component plays. Was a subclass branch
-    // (LogicalSystem / LogicalSubsystem / LogicalChannel / LogicalDataStore /
-    // LogicalControlElement / LogicalUserInterface / LogicalExternalSystem);
-    // now one attribute, because all of them share the same relationships and
-    // differed only by a couple of descriptive attributes.
+    // (LogicalChannel / LogicalDataStore / LogicalControlElement /
+    // LogicalUserInterface / LogicalExternalSystem); now one attribute, because
+    // those all share the same relationships and differed only by a couple of
+    // descriptive attributes.
+    //
+    // System / Subsystem / SystemOfSystems are types below, not values here:
+    // each admits a different set of children, and a value on an attribute
+    // cannot carry containment legality.
     enum def ComponentRoleKind {
-        enum system;
-        enum subsystem;
         enum channel;
         enum dataStore;
         enum controlElement;
@@ -52,17 +55,73 @@ package memo_architecture_logical_structure {
         enum generic;
     }
 
-    // One logical component. `componentRole` selects what it is; the role-
-    // specific attributes below are all 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.
+    // The discipline a logical block is realized in. Orthogonal to
+    // `componentRole`: a subsystem may be software, a system may be hardware,
+    // and a block whose realization is not yet decided stays `logical`.
+    //
+    // This does NOT relocate the element. The block remains logical-layer —
+    // MEMO encodes layer by owning package, and this one is
+    // memo_architecture_logical_structure. `systemType` records what the block
+    // WILL BE realized in, which is a logical-architecture decision made
+    // before any software or hardware element exists. Once those elements do
+    // exist, AllocatedTo carries the actual allocation and this attribute
+    // stays as the stated intent.
+    enum def SystemTypeKind {
+        enum logical;
+        enum software;
+        enum hardware;
+    }
+
+    // ─── System hierarchy ────────────────────────────────────────
+    // Three types rather than three role values, because they differ in what
+    // they may CONTAIN — and containment legality cannot live on an attribute.
+    //
+    // The allowed children are declared as typed part features, which is how
+    // SysML v2 already states "what may be contained". No new relationship is
+    // introduced: `Composes` remains the single containment relation for
+    // instances, exactly as everywhere else in MEMO. The features below say
+    // which types are admissible; Composes records the actual links.
+
+    part def SystemOfSystems specializes LogicalComponent {
+        // Constituent systems are independently operated and independently
+        // managed, collaborating for a capability none delivers alone
+        // (ISO/IEC/IEEE 21841). A connected pump talking to a hospital
+        // infusion-management server is one; a pump and its own pole-mounted
+        // battery are not — which is why ownership is recorded here and is the
+        // attribute that distinguishes an SoS from a merely large system.
+        attribute systemBoundaryDescription : String;
+        attribute constituentOwnership : String;
+        // A constituent may itself coordinate systems-of-systems, or it may be
+        // an independently operated system. Subsystems and components remain
+        // inside one of those constituent systems.
+        part constituentSystemOfSystems : SystemOfSystems[0..*];
+        part constituentSystem : System[0..*];
+    }
+
+    part def System specializes LogicalComponent {
+        attribute systemBoundaryDescription : String;
+        part system : System[0..*];
+        part subsystem : Subsystem[0..*];
+        part component : LogicalComponent[0..*];
+    }
+
+    part def Subsystem specializes LogicalComponent {
+        attribute systemBoundaryDescription : String;
+        part subsystem : Subsystem[0..*];
+        part component : LogicalComponent[0..*];
+    }
+
+    // One logical component. `componentRole` selects what it is, `systemType`
+    // what it is realized in; the role-specific attributes below are all
+    // 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 {
         attribute componentRole : ComponentRoleKind;
+        attribute systemType : SystemTypeKind[0..1];
         attribute responsibility : String;
         attribute decompositionLevel : String;
         attribute safetyPartition : String;
-        // system / subsystem
-        attribute systemBoundaryDescription : String;
         // channel (safety role + diversity)
         attribute channelRole : ChannelRoleKind[0..1];
         attribute diversityBasis : String;
@@ -79,16 +138,14 @@ package memo_architecture_logical_structure {
     }
 
     // Boundary features and contracts.
-    port def LogicalPort specializes MemoPort {
-        attribute contentKind : FlowContentKind;
-    }
+    port def LogicalPort specializes MemoPort;
     interface def LogicalInterface specializes MemoInterface {
         attribute contentKind : FlowContentKind;
         attribute interactionPattern : String;
         end providerPort : LogicalPort;
         end consumerPort : ~LogicalPort;
     }
-    item def LogicalExchangeItem specializes MemoExchangeItem {
+    item def LogicalExchangeItem specializes MemoItem {
         attribute contentKind : FlowContentKind;
     }
 
@@ -96,8 +153,14 @@ package memo_architecture_logical_structure {
     connection def LogicalConnector :> MemoRelationship {
         attribute contentKind : FlowContentKind;
         attribute direction : DirectionKind;
-        end sourceComponent : LogicalComponent;
-        end targetComponent : LogicalComponent;
+        end sourceComponent : LogicalComponent :>> source;
+        end targetComponent : LogicalComponent :>> target;
+    }
+    abstract connection logicalConnectorLinks : LogicalConnector[*];
+    metadata def <logicalConnector> LogicalConnectorMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = logicalConnectorLinks meta SysML::Usage;
     }
     // A transfer of a typed item across a connector.
     part def LogicalExchange specializes ArchitectureElement {
@@ -111,14 +174,7 @@ package memo_architecture_logical_structure {
 
     // States and modes of the logical solution (kept distinct from UI state
     // and from physical device configuration).
-    part def LogicalState specializes ArchitectureElement {
-        attribute stateInvariant : String;
-    }
-    part def LogicalMode specializes ArchitectureElement {
-        attribute modePurpose : String;
-        attribute entryCondition : String;
-        attribute exitCondition : String;
-    }
+
     part def LogicalBehavior specializes ArchitectureElement {
         attribute behaviorSummary : String;
         attribute executionSemantics : String;
@@ -136,15 +192,16 @@ package memo_architecture_logical_structure {
     // Claimed independence between channels (common-cause defense).
     connection def IndependentOf :> MemoRelationship {
         attribute independenceBasis : String;
-        end channel : LogicalComponent;
-        end otherChannel : LogicalComponent;
+        end channel : LogicalComponent :>> source;
+        end otherChannel : LogicalComponent :>> target;
     }
-    connection def MonitorsChannel :> MemoRelationship {
-        end monitorChannel : LogicalComponent;
-        end monitoredComponent : LogicalComponent;
-    }
-    connection def ExhibitsMode :> MemoRelationship {
-        end component : LogicalComponent;
-        end mode : LogicalMode;
+    abstract connection independentOfLinks : IndependentOf[*];
+    metadata def <independentOf> IndependentOfMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = independentOfLinks meta SysML::Usage;
     }
+    // `MonitorsChannel` is native `dependency` (R10-S6): write
+    // `dependency <monitorChannel> to <monitoredComponent>;` instead.
+
 }

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

@@ -7,6 +7,7 @@
 // Task difficulty belongs to a task performed in a context — never to an
 // instrument (TaskDifficultyAssessment).
 package memo_architecture_operational_activities {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -28,7 +29,7 @@ package memo_architecture_operational_activities {
         attribute preCondition : String;
         attribute postCondition : String;
         attribute criticality : CriticalityKind;
-        ref performedBy : Actor[0..*];
+        ref performedBy : OperationalParticipant[0..*];
     }
 
     // A human task. A critical task (IEC 62366-1 / FDA HF guidance §3) is a
@@ -50,7 +51,6 @@ package memo_architecture_operational_activities {
     // 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 stepOrder : Integer;
         attribute perceptualCue : String;
         attribute feedbackExpected : String;
     }
@@ -80,7 +80,13 @@ package memo_architecture_operational_activities {
     }
 
     connection def AssessesDifficulty :> MemoRelationship {
-        end assessment : TaskDifficultyAssessment;
-        end task : UserTask;
+        end assessment : TaskDifficultyAssessment :>> source;
+        end task : UserTask :>> target;
+    }
+    abstract connection assessesDifficultyLinks : AssessesDifficulty[*];
+    metadata def <assessesDifficulty> AssessesDifficultyMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = assessesDifficultyLinks meta SysML::Usage;
     }
 }

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

@@ -1,5 +1,5 @@
-// Actor hierarchy (§4). An Actor interacts with the system; it is distinct
-// from a Stakeholder (memo_architecture_operational_context_stakeholders), who has concerns about the
+// 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.
 package memo_architecture_operational_context_actors {
@@ -7,8 +7,7 @@ package memo_architecture_operational_context_actors {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-
-    abstract part def Actor specializes MemoPart {
+    abstract part def OperationalParticipant specializes MemoPart {
         attribute actorKind : ActorKind;
         attribute trainingLevel : String;
         attribute responsibility : String;
@@ -19,7 +18,7 @@ package memo_architecture_operational_context_actors {
     // The human actor. The specific role is given by actorKind
     // (patient / clinician / caregiver / technician / administrator); the
     // role-specific fields below are set only for the relevant actorKind.
-    part def User specializes Actor {
+    part def User specializes OperationalParticipant {
         attribute userPopulation : String;
         attribute impairmentConsiderations : String;
         attribute intendedTraining : String;
@@ -32,7 +31,5 @@ package memo_architecture_operational_context_actors {
 
     // A non-human actor (external system, external device, or environmental
     // agent). The specific kind is described by externalKind.
-    part def NonHumanActor specializes Actor {
-        attribute externalKind : String[0..1];
-    }
+
 }

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

@@ -1,27 +1,17 @@
-// ISO/IEC/IEEE 42010 architecture-description core (§4). A Stakeholder has
-// interests (Concerns) in the system; a Viewpoint frames concerns; a View
+// 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 the Actor role — expressed by ActsAsActor, never by merging
-// the types.
+// Stakeholder and operational-participant concerns stay distinct from the
+// architecture-description types below.
 package memo_architecture_operational_context_stakeholders {
+    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_context_actors::*;
-
-    part def Stakeholder specializes MemoPart {
-        attribute stakeholderCategory : String;
-        attribute influence : String;
-    }
-
-    part def Concern specializes MemoPart {
-        attribute concernKind : ConcernKind;
-        attribute question : String;
-    }
-
     part def ArchitectureDescription specializes DocumentedElement {
         attribute systemOfInterest : String;
         attribute version : String;
@@ -38,19 +28,6 @@ package memo_architecture_operational_context_stakeholders {
         attribute ruleExpression : String;
     }
 
-    connection def HasConcern :> MemoRelationship {
-        end interestedStakeholder : Stakeholder;
-        end stakeholderConcern : Concern;
-    }
-    connection def FramesConcern :> MemoRelationship {
-        end framingViewpoint : MemoPart;
-        end framedConcern : Concern;
-    }
-    // Links the stakeholder to the actor role the same entity plays, if any.
-    connection def ActsAsActor :> MemoRelationship {
-        end interestedStakeholder : Stakeholder;
-        end actorRole : Actor;
-    }
     // Governs unifies GovernsCorrespondence / GovernsUse, keyed by governKind.
     enum def GovernKind {
         enum correspondence;
@@ -58,7 +35,13 @@ package memo_architecture_operational_context_stakeholders {
     }
     connection def Governs :> MemoRelationship {
         attribute governKind : GovernKind;
-        end governor : MemoPart;
-        end governedElement : MemoPart;
+        end governor : MemoPart :>> source;
+        end governedElement : MemoPart :>> target;
+    }
+    abstract connection governsLinks : Governs[*];
+    metadata def <governs> GovernsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = governsLinks meta SysML::Usage;
     }
 }

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

@@ -1,7 +1,16 @@
 // Operational use context (IEC 62366-1 use specification). Intended use and
 // reasonably foreseeable misuse are assurance requirements/risk inputs and
 // live in memo_assurance_requirements.
+//
+// This package once defined `ExchangesWith` for directional context-level data
+// flow between boundary entities. It is deleted: SysML v2's own `flow` covers
+// every case and is strictly stronger, because `of <ItemDef>` says WHAT moves
+// and two untyped connection ends cannot. Delegation between a boundary port
+// and the interior it stands for is `bind` — identity, not transport. SysML v2
+// keeps the two apart the same way: training ch. 13 wires components with
+// `flow`, ch. 12 delegates across a boundary with `bind`.
 package memo_architecture_operational_context_use_context {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -47,32 +56,49 @@ 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 : MemoPart;
+        end contextParticipant : ArchitectureElement :>> source;
         // Untyped: the system of interest may be a part or an operational activity.
-        end systemOfInterest;
+        end systemOfInterest : ArchitectureElement :>> target;
+    }
+    abstract connection interactsInContextLinks : InteractsInContext[*];
+    metadata def <interactsInContext> InteractsInContextMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = interactsInContextLinks meta SysML::Usage;
     }
 
     connection def InteractsWith :> MemoRelationship {
-        end contextParticipant : Actor;
+        end contextParticipant : OperationalParticipant :>> source;
         // Untyped so operational activities (action def) can be targets as well as parts.
         end target;
     }
-    // Directional context-level data flow between boundary entities.
-    connection def ExchangesWith :> MemoRelationship {
-        end source : MemoPart;
-        end target : MemoPart;
-    }
-    // Physical connection between boundary entities (fluid path, mounting).
-    connection def ConnectsPhysically :> MemoRelationship {
-        end source : MemoPart;
-        end target : MemoPart;
+    abstract connection interactsWithLinks : InteractsWith[*];
+    metadata def <interactsWith> InteractsWithMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = interactsWithLinks meta SysML::Usage;
     }
+    // `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.
     connection def AppliesInContext :> MemoRelationship {
-        end useContext : UseContext;
-        end subjectElement : MemoPart;
+        end useContext : UseContext :>> source;
+        end subjectElement : MemoPart :>> target;
+    }
+    abstract connection appliesInContextLinks : AppliesInContext[*];
+    metadata def <appliesInContext> AppliesInContextMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = appliesInContextLinks meta SysML::Usage;
     }
     connection def SituatedIn :> MemoRelationship {
-        end useContext : UseContext;
-        end environment : UseEnvironment;
+        end useContext : UseContext :>> source;
+        end environment : UseEnvironment :>> target;
+    }
+    abstract connection situatedInLinks : SituatedIn[*];
+    metadata def <situatedIn> SituatedInMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = situatedInLinks meta SysML::Usage;
     }
 }

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

@@ -1,10 +1,10 @@
 // Scenario foundation. A scenario is a selected path through a
-// workflow (or functional flow), classified by three independent typed
-// dimensions — variant, operational condition, purpose — replacing the former
-// single ScenarioKind. An occurrence is an actual or hypothetical execution
+// workflow (or functional flow), classified by its kind plus three independent
+// dimensions — variant, operational condition, and purpose. An occurrence is an actual or hypothetical execution
 // of a scenario. Alternate scenarios reference their base scenario and
 // variation point instead of duplicating the workflow.
 package memo_architecture_operational_scenarios {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -47,11 +47,25 @@ package memo_architecture_operational_scenarios {
         enum cybersecurity;
     }
 
-    // Shared scenario foundation. Specializations exist only where structure
-    // or invariants differ (OperativeScenario here; FunctionalScenario in
-    // memo_functions; UIScenario in memo_architecture_implementation_ui;
-    // VerificationScenario / ThreatScenario in assurance packages).
-    abstract part def MemoScenario specializes MemoPart {
+    // 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..*];
@@ -62,26 +76,34 @@ package memo_architecture_operational_scenarios {
         attribute postCondition : String;
         attribute pathSummary : String;
 
-        ref involvedActors : Actor[0..*];
+        ref involvedActors : OperationalParticipant[0..*];
         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;
-    }
 
-    // The operational-layer scenario: a path through an OperationalWorkflow in
-    // a use context. It is realized down the V by a FunctionalScenario (the
-    // function sequence) and a UIScenario (the interaction sequence), each owned
-    // by its own architecture layer and linked by typed realization
-    // relationships — never by copying the path. Workflow stays operational;
-    // only the scenario is layered.
-    part def OperativeScenario specializes MemoScenario {
+        // functional scenario
+        ref selectedFlow : MemoAction[0..1];
+        // operative scenario
         ref parentWorkflow : OperationalWorkflow[0..1];
         ref parentUseCase : UseCase[0..1];
-        // Each scenario owns the operational activity/action flow for its
-        // selected path. Do not reuse one generic activity for every scenario.
         ref activities : OperationalActivity[0..*];
+        // UI scenario
+        ref parentFlow : MemoAction[0..1];
+        // threat scenario
+        attribute actorDescription : String;
+        attribute assumptionSummary : String;
+        attribute guaranteeSummary : String;
+        attribute securityObjective : String;
+        attribute abuseCaseReference : String;
+        attribute defaultCategory : ThreatCategoryKind[0..1];
+        // verification scenario
+        attribute verificationEnvironment : String;
+        attribute stimulusSummary : String;
+        // hazard-related use scenario (IEC 62366-1 3.9)
+        attribute hazardReference : String;
+        attribute selectionRationale : String;
     }
 
     // An actual or hypothetical execution of a scenario (usability test run,
@@ -104,13 +126,25 @@ package memo_architecture_operational_scenarios {
         attribute selectsKind : SelectsKind;
         attribute pathOrder : Integer[0..1];
         attribute decisionTaken : String[0..1];
-        end scenario : MemoScenario;
+        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;
+        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;
-        end context : UseContext;
+        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;
     }
 }

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

@@ -2,6 +2,7 @@
 // achieve with system support — there is no separate Goal class. Clinical,
 // service, manufacturing, and development use cases specialize the same base.
 package memo_architecture_operational_use_cases {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -18,12 +19,7 @@ package memo_architecture_operational_use_cases {
         enum development;
     }
 
-    use case def UseCase {
-        attribute id : String;
-        attribute name : String;
-        attribute description : String;
-        attribute rationale : String;
-        attribute sourceReference : String;
+    use case def UseCase :> MemoUseCase {
         // Text of this use case's goal; this is not a separate Goal element.
         attribute goalStatement : String;
         attribute trigger : String;
@@ -34,34 +30,47 @@ package memo_architecture_operational_use_cases {
         // clinical / service / manufacturing / development
         attribute useCaseKind : UseCaseKind;
 
-        // The device or system under consideration supports the goal.
-        ref supportingSystem : MemoPart[0..1];
+        // The device or system under consideration supports the goal. Native
+        // `subject`, not `ref` (R10-S6): SysIDE requires an explicit subject
+        // before a use case can declare `actor` — `case-usage-subject-
+        // parameter-position` — and "the device/system under consideration"
+        // is exactly what a case's subject means, so this was a duplicate
+        // waiting to surface once `actor` needed a subject to attach to.
+        subject supportingSystem : MemoPart[0..1];
         ref primaryUser : User[0..1];
-        ref supportingActors : Actor[0..*];
+        ref supportingActors : OperationalParticipant[0..*];
         ref useContext : UseContext[0..1];
         ref originatingNeeds : Need[0..*];
     }
 
     connection def Motivates :> MemoRelationship {
-        end motivatingNeed : Need;
-        end motivatedUseCase : UseCase;
+        end motivatingNeed : Need :>> source;
+        end motivatedUseCase : UseCase :>> target;
     }
-    connection def Initiates :> MemoRelationship {
-        end initiatingUser : User;
-        end initiatedUseCase : UseCase;
-    }
-    connection def ParticipatesIn :> MemoRelationship {
-        end participatingActor : Actor;
-        end useCase : UseCase;
-    }
-    // UML use-case relationships. Includes establishes a decomposition level;
-    // extends remains a cross-cutting relationship and is always presented.
-    connection def Includes :> MemoRelationship {
-        end includingUseCase : UseCase;
-        end includedUseCase : UseCase;
+    abstract connection motivatesLinks : Motivates[*];
+    metadata def <motivates> MotivatesMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = motivatesLinks meta SysML::Usage;
     }
+    // `Initiates` and `ParticipatesIn` are native `actor` (R10-S6): both were
+    // a bare typed edge onto UseCase with no attributes of their own, and
+    // native `actor` does not distinguish an initiating actor from a
+    // participating one — that distinction now lives in how the actor is
+    // named on the use case, not in a relationship type. Write
+    // `actor <role> = <existingElement>;` inside the use case instead.
+    // UML use-case decomposition (`Includes`) is native `include use case` /
+    // `include` (R10-S6); write that instead of a connection here. `extends`
+    // has 0 hits in the corpus for a use-case `extend` production, so it stays
+    // a MEMO construct: a cross-cutting relationship that is always presented.
     connection def Extends :> MemoRelationship {
-        end extendingUseCase : UseCase;
-        end extendedUseCase : UseCase;
+        end extendingUseCase : UseCase :>> source;
+        end extendedUseCase : UseCase :>> target;
+    }
+    abstract connection extendsLinks : Extends[*];
+    metadata def <extends> ExtendsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = extendsLinks meta SysML::Usage;
     }
 }