@memoarchitect/ontology 0.7.0 → 0.8.24

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

@@ -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,46 @@ 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;
     }
 }

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

@@ -5,6 +5,7 @@
 // scenario. Workflows are action defs: steps, decisions, forks/joins, and
 // successions use native SysML v2 action semantics where portable.
 package memo_architecture_operational_workflows {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -36,20 +37,24 @@ package memo_architecture_operational_workflows {
         attribute completionCondition : String;
         attribute recoveryPathSummary : String;
         attribute timingConstraints : String;
-        ref involvedActors : Actor[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 : Actor[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;
@@ -68,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 : Actor[0..1];
-        ref toRole : Actor[0..1];
     }
 
     // Resources a workflow requires: information, materials, or equipment by
@@ -81,24 +84,32 @@ 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;
-        end supported;
+        end supporter :>> source;
+        end supported : MemoAction :>> target;
+    }
+    abstract connection supportsLinks : Supports[*];
+    metadata def <supports> SupportsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = supportsLinks meta SysML::Usage;
     }
     connection def RequiresResource :> MemoRelationship {
-        end workflow : OperationalWorkflow;
-        end resource : WorkflowResource;
+        end workflow : OperationalWorkflow :>> source;
+        end resource : WorkflowResource :>> target;
+    }
+    abstract connection requiresResourceLinks : RequiresResource[*];
+    metadata def <requiresResource> RequiresResourceMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = requiresResourceLinks meta SysML::Usage;
     }
 
     // ── Workflow transformation (as-is → to-be) ──────────────────
@@ -113,8 +124,14 @@ package memo_architecture_operational_workflows {
         attribute transformKind : TransformKind;
         attribute transformation : StepTransformationKind[0..1];
         attribute transformationRationale : String[0..1];
-        end source : MemoPart;
-        end target : MemoPart;
+        end source : MemoAction;
+        end target : MemoAction;
+    }
+    abstract connection transformsLinks : Transforms[*];
+    metadata def <transforms> TransformsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = transformsLinks meta SysML::Usage;
     }
     // The device or system whose introduction enables a workflow.
 }

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

@@ -1,27 +1,39 @@
-// Deployment (allocation) view: SoftwareModule buildsInto
-// DeploymentUnit; DeploymentUnit deploysTo ProcessingNode; SoftwareComponent
-// hostedBy ProcessingNode. Software deploys only to capable execution nodes
-// (rules/crosslayer).
+// 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 : 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.
 package memo_architecture_realization_deployment {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
+    // The standard's allocation base, which the two AADL bindings below root
+    // on alongside MemoRelationship.
+    private import Allocations::Allocation;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
     private import memo_architecture_implementation_software_structure::*;
     private import memo_architecture_implementation_software_runtime::*;
+    private import memo_architecture_implementation_hardware_electrical::*;   // NetworkMedium
     private import memo_architecture_realization_physical::*;
     private import memo_architecture_functional_functions::*;
     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;
@@ -29,17 +41,88 @@ package memo_architecture_realization_deployment {
     }
 
     connection def BuildsInto :> MemoRelationship {
-        end module : SoftwareModule;
-        end deploymentUnit : DeploymentUnit;
+        end module : SoftwareModule :>> source;
+        end deploymentUnit : SoftwareDeploymentUnit :>> target;
+    }
+    abstract connection buildsIntoLinks : BuildsInto[*];
+    metadata def <buildsInto> BuildsIntoMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = buildsIntoLinks meta SysML::Usage;
     }
     connection def DeploysTo :> MemoRelationship {
         attribute deploymentKind : DeploymentKind;
-        end deploymentUnit : DeploymentUnit;
-        end node : ProcessingNode;
+        end deploymentUnit : SoftwareDeploymentUnit :>> source;
+        end node : ProcessingNode :>> target;
+    }
+    abstract connection deploysToLinks : DeploysTo[*];
+    metadata def <deploysTo> DeploysToMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = deploysToLinks meta SysML::Usage;
     }
     connection def ProvidesEnvironment :> MemoRelationship {
-        end node : ProcessingNode;
-        end environment : RuntimeEnvironment;
+        end node : ProcessingNode :>> source;
+        end environment : RuntimeEnvironment :>> target;
+    }
+    abstract connection providesEnvironmentLinks : ProvidesEnvironment[*];
+    metadata def <providesEnvironment> ProvidesEnvironmentMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = providesEnvironmentLinks meta SysML::Usage;
+    }
+
+    // ─── AADL bindings (SAE AS5506) — plan C1 ────────────────────────────
+    //
+    // AADL's analytic power is that EVERYTHING is bound to something, and the
+    // binding is where latency, bandwidth and fault propagation accrue. MEMO
+    // had one binding of three: `DeploysTo` is `actual_processor_binding`.
+    // Without the other two, `SoftwareComponent.memoryBudget` is unanalysable
+    // and `EndToEndFlow.latencyBudgetMs` cannot be checked against the media
+    // the flow traverses — the analysis the flow comment below describes and
+    // the model could not perform.
+    //
+    // Both are `allocation def`s rooted on the standard's
+    // `Allocations::Allocation`, because a binding IS an allocation and the
+    // language says so. The double specialization keeps MEMO's identification
+    // core from `MemoRelationship` while adding the standard's allocation
+    // semantics; both root on `Connections::BinaryConnection`, so this is a
+    // diamond and not a conflict. Verified under `syside check` against a
+    // negative control (a non-existent supertype is reported), so the clean
+    // result is the checker agreeing rather than the checker skipping.
+
+    // AADL `actual_memory_binding`. Which memory a software component's code
+    // and data occupy — what makes a memory budget a claim about a device
+    // rather than a string.
+    allocation def MemoryBinding :> MemoRelationship, Allocations::Allocation {
+        attribute bindingKind : String;
+        end boundComponent : SoftwareComponent :>> source;
+        end memory : MemoryDevice :>> target;
+    }
+    abstract connection memoryBindingLinks : MemoryBinding[*];
+    metadata def <memoryBinding> MemoryBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = memoryBindingLinks meta SysML::Usage;
+    }
+
+    // AADL `actual_connection_binding`. Which physical medium carries a
+    // component exchange. The source is the ComponentExchange rather than the
+    // `ComponentConnects` link, because the exchange is the ELEMENT that owns
+    // the budget (§19.3) and a link instance is not something the graph can
+    // bind to; it is also exactly where the latency the medium contributes has
+    // to be accounted.
+    allocation def ConnectionBinding :> MemoRelationship, Allocations::Allocation {
+        attribute allocatedBandwidth : String;
+        attribute mediumLatencyMs : Real;
+        end boundExchange : ComponentExchange :>> source;
+        end medium : NetworkMedium :>> target;
+    }
+    abstract connection connectionBindingLinks : ConnectionBinding[*];
+    metadata def <connectionBinding> ConnectionBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = connectionBindingLinks meta SysML::Usage;
     }
 
     // ─── AADL-style flow modeling (SAE AS5506) ───────────────────────────
@@ -57,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];
@@ -65,11 +148,11 @@ 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 : SystemFunction[0..1];
-        ref sinkFunction : SystemFunction[0..1];
+        ref sourceFunction : MemoFunction[0..1];
+        ref sinkFunction : MemoFunction[0..1];
         ref logicalSegments : LogicalComponent[0..*];
         // Runtime C&C components (SEI) — the elements actually bound to hardware.
         ref softwareSegments : SoftwareComponent[0..*];
@@ -79,12 +162,24 @@ package memo_architecture_realization_deployment {
     // segment per traversed component boundary (AADL flow-spec → end-to-end).
     connection def FlowComprisesSpec :> MemoRelationship {
         attribute segmentOrder : Integer;
-        end endToEndFlow : EndToEndFlow;
-        end spec : FlowSpecification;
+        end endToEndFlow : EndToEndFlow :>> source;
+        end spec : FlowSpecification :>> target;
+    }
+    abstract connection flowComprisesSpecLinks : FlowComprisesSpec[*];
+    metadata def <flowComprisesSpec> FlowComprisesSpecMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = flowComprisesSpecLinks meta SysML::Usage;
     }
     // The flow traverses a software→hardware binding; latency accrues here.
     connection def FlowTraversesBinding :> MemoRelationship {
-        end endToEndFlow : EndToEndFlow;
-        end deploymentUnit : DeploymentUnit;
+        end endToEndFlow : EndToEndFlow :>> source;
+        end deploymentUnit : SoftwareDeploymentUnit :>> target;
+    }
+    abstract connection flowTraversesBindingLinks : FlowTraversesBinding[*];
+    metadata def <flowTraversesBinding> FlowTraversesBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = flowTraversesBindingLinks meta SysML::Usage;
     }
 }

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,14 +17,39 @@ 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;
     }
-    part def PhysicalPort specializes InterfaceElement {
+    // A physical boundary feature: the connector the outside world plugs into.
+    //
+    // A `port def` (Track A1), not a part. It was `part def PhysicalPort
+    // specializes InterfaceElement` for one reason — the exchange endpoints
+    // were `MemoPart`-typed, so anything that terminated an exchange had to be
+    // a part (CR-ONT-002, since rewritten). Track A0 made those ends
+    // metaclass-neutral, and KerML forbids a port from specializing a
+    // part-based type, so the specialization moves to `MemoPort`.
+    //
+    // `direction` is gone: the port usage carries `in` / `out` / `inout`
+    // natively (Track A2). `DirectionKind` survives for the non-port
+    // constructs that still need it — see memo_core_enumerations.
+    //
+    // `portKind` is declared here AND on SoftwarePort rather than on a shared
+    // base. `MemoPort` is the identification core and nothing else — the block
+    // comment in memo_core_common makes that a stated invariant across all
+    // five bases — and pushing `portKind` down onto DataPort, SensorPort,
+    // CommandPort, and LogicalPort would give them a second classifier beside
+    // the ones they already carry (`interfaceType`, `sensorDomain`,
+    // `commandDomain`, `contentKind`). An intermediate `abstract port def`
+    // holding one attribute is a class standing in for an attribute, which is
+    // what the lean direction removes. One attribute, two sites, no new type.
+    port def PhysicalPort specializes MemoPort {
         attribute portKind : InterfaceKind;
+        // AADL port category (plan C2) — see SoftwarePort. A physical port
+        // carries it for the same reason: a sampled sensor line and a queued
+        // interrupt line fail differently under overload.
+        attribute portCategory : PortCategoryKind;
         attribute connectorType : String;
-        attribute direction : DirectionKind;
     }
 }

package/src/artifacts/configuration_management/memo_configuration_management.sysml

@@ -1,5 +1,7 @@
 package memo_artifacts_configuration_management {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
+    private import memo_core_relationships::*;   // MemoRelationship
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
@@ -16,4 +18,18 @@ package memo_artifacts_configuration_management {
         attribute baseline : String;
         attribute controlLevel : String;
     }
+
+    // ── Relations owned by this package ─────────────────────────────
+    // 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 Changes :> MemoRelationship {
+        end changeRequest : ChangeRequest :>> source;
+        end changedElement : MemoPart :>> target;
+    }
+    abstract connection changesLinks : Changes[*];
+    metadata def <changes> ChangesMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = changesLinks meta SysML::Usage;
+    }
 }

package/src/artifacts/core/memo_controlled_artifacts.sysml

@@ -4,7 +4,9 @@ package memo_artifacts_core {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    item def ControlledArtifact :> MemoPart {
+    abstract item def MemoArtifactItem :> MemoItem;
+
+    item def ControlledArtifact :> MemoArtifactItem {
         attribute version : String;
         attribute artifactKind : ArtifactKind;
         attribute owner : String;