@memoarchitect/ontology 0.13.2 → 0.15.1

package/src/core/relationships/memo_workspace_membership.sysml

@@ -0,0 +1,284 @@
+// Which workspace a relation's far end belongs to.
+//
+// A workspace (the system of systems, or one system) is not declared; it is
+// the closure of what is linked to the system (plans/memo-model-product-project-structure.md,
+// T2). That closure needs one fact per relation: when one end is in a workspace,
+// does the relation draw the other end in? This file states it, for every
+// relation the registry holds and for the edges the builder synthesizes from
+// SysML keywords (`flow`, `interface`, `succession`, `bind`, `variant`).
+//
+// It is a table, not an attribute on each relation def, because the relations
+// the closure needs most are SysML keywords with no def to annotate (`allocate`,
+// `satisfy`, `verify`, `subject`, nesting). One mechanism for all of them.
+//
+//   sourceFollowsTarget  the source is in whichever workspace the target is in
+//                        (a function is in the workspace of the component it is
+//                        allocated to)
+//   targetFollowsSource  the target is in whichever workspace the source is in
+//                        (a verification case follows the requirement it verifies)
+//   neither              the relation joins elements without placing either
+//
+// Every row is a decision and says why. A test requires a row for every
+// relation, so adding a relation forces the decision. The rule of thumb: the
+// dependent end follows the anchor end (a function follows the component it is
+// allocated to, a comment follows the element it annotates). `neither` is for
+// peers, for shared catalogue entries, and for the elements that sit above the
+// systems: a clinical use case that includes three system use cases, or a chain
+// that performs functions of three systems, belongs to the system of systems and
+// must not be pulled into each system it touches (`includesStep`, `performs`,
+// `interface`, `flow`).
+package memo_core_relationships_workspace_membership {
+    private import ScalarValues::*;
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def WorkspaceMembershipEntry specializes MemoPart {
+        doc /* One relation and the direction it places elements in a workspace. */
+        attribute relation : String;
+        attribute direction : WorkspaceMembershipKind;
+    }
+
+    // An ADR follows the decision it records.
+    part membershipDecisionRecordedInADR : WorkspaceMembershipEntry { attribute :>> relation = "decisionRecordedInADR"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A design decision follows the element it affects.
+    part membershipDecides : WorkspaceMembershipEntry { attribute :>> relation = "decides"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A SOUP item follows the component that depends on it.
+    part membershipDependsOnSoup : WorkspaceMembershipEntry { attribute :>> relation = "dependsOnSoup"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A screen capture follows its screen.
+    part membershipCapturesScreen : WorkspaceMembershipEntry { attribute :>> relation = "capturesScreen"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A UI action follows the element that triggers it.
+    part membershipElementTriggersAction : WorkspaceMembershipEntry { attribute :>> relation = "elementTriggersAction"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // An interaction flow follows the use case it serves.
+    part membershipFlowServesUseCase : WorkspaceMembershipEntry { attribute :>> relation = "flowServesUseCase"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A use error follows the element it occurs at.
+    part membershipErrorAtElement : WorkspaceMembershipEntry { attribute :>> relation = "errorAtElement"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A risk control follows the element that implements it.
+    part membershipControlImplementedBy : WorkspaceMembershipEntry { attribute :>> relation = "controlImplementedBy"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a connector joins peer components.
+    part membershipLogicalConnector : WorkspaceMembershipEntry { attribute :>> relation = "logicalConnector"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: independence is a claim about two channels, not a placement.
+    part membershipIndependentOf : WorkspaceMembershipEntry { attribute :>> relation = "independentOf"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A difficulty assessment follows its task.
+    part membershipAssessesDifficulty : WorkspaceMembershipEntry { attribute :>> relation = "assessesDifficulty"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a governing rule or standard applies to many elements and is placed by none.
+    part membershipGoverns : WorkspaceMembershipEntry { attribute :>> relation = "governs"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A context participant follows the system of interest.
+    part membershipInteractsInContext : WorkspaceMembershipEntry { attribute :>> relation = "interactsInContext"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A use context follows its subject element.
+    part membershipAppliesInContext : WorkspaceMembershipEntry { attribute :>> relation = "appliesInContext"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: an environment is shared by the contexts situated in it.
+    part membershipSituatedIn : WorkspaceMembershipEntry { attribute :>> relation = "situatedIn"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: an intended use and its capability are operational, not any system.
+    part membershipRequiresCapability : WorkspaceMembershipEntry { attribute :>> relation = "requiresCapability"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A capability follows the use case it enables.
+    part membershipEnablesUseCase : WorkspaceMembershipEntry { attribute :>> relation = "enablesUseCase"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A need follows the use case it motivates.
+    part membershipMotivates : WorkspaceMembershipEntry { attribute :>> relation = "motivates"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A workflow follows the use case it realizes.
+    part membershipRealizesUseCase : WorkspaceMembershipEntry { attribute :>> relation = "realizesUseCase"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a transformation joins two actions.
+    part membershipTransforms : WorkspaceMembershipEntry { attribute :>> relation = "transforms"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A module follows the deployment unit it is built into.
+    part membershipBuildsInto : WorkspaceMembershipEntry { attribute :>> relation = "buildsInto"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // The hardware or software follows the logical component it realizes: the logical component is
+    // what a System contains, and what implements it belongs to the same System (logical and
+    // implementation are separate structures joined by this allocation, never nested).
+    part membershipRealizedBy : WorkspaceMembershipEntry { attribute :>> relation = "realizedBy"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A deployment unit follows the node it runs on.
+    part membershipDeploysTo : WorkspaceMembershipEntry { attribute :>> relation = "deploysTo"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A runtime environment follows the node that provides it.
+    part membershipProvidesEnvironment : WorkspaceMembershipEntry { attribute :>> relation = "providesEnvironment"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A memory device follows the component bound to it.
+    part membershipMemoryBinding : WorkspaceMembershipEntry { attribute :>> relation = "memoryBinding"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A physical medium follows the exchange bound to it.
+    part membershipConnectionBinding : WorkspaceMembershipEntry { attribute :>> relation = "connectionBinding"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A flow specification follows the end-to-end flow it belongs to.
+    part membershipFlowComprisesSpec : WorkspaceMembershipEntry { attribute :>> relation = "flowComprisesSpec"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: an end-to-end flow crosses deployment units; it is not part of any one.
+    part membershipFlowTraversesBinding : WorkspaceMembershipEntry { attribute :>> relation = "flowTraversesBinding"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A change request follows the element it changes.
+    part membershipChanges : WorkspaceMembershipEntry { attribute :>> relation = "changes"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a clause belongs to the standards library, not to any workspace.
+    part membershipConformsTo : WorkspaceMembershipEntry { attribute :>> relation = "conformsTo"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A controlled document follows the elements that trace to it.
+    part membershipTracesToDocument : WorkspaceMembershipEntry { attribute :>> relation = "tracesToDocument"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A threat follows the asset it threatens.
+    part membershipThreatenedBy : WorkspaceMembershipEntry { attribute :>> relation = "threatenedBy"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A vulnerability follows the threat that exploits it.
+    part membershipExploits : WorkspaceMembershipEntry { attribute :>> relation = "exploits"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // An attack scenario follows the threat it realizes.
+    part membershipRealizedByScenario : WorkspaceMembershipEntry { attribute :>> relation = "realizedByScenario"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a cyber element and a safety item are each placed on their own.
+    part membershipImpactsSafety : WorkspaceMembershipEntry { attribute :>> relation = "impactsSafety"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A security property follows its asset.
+    part membershipHasSecurityProperty : WorkspaceMembershipEntry { attribute :>> relation = "hasSecurityProperty"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // An attack surface follows the asset it exposes.
+    part membershipExposesAsset : WorkspaceMembershipEntry { attribute :>> relation = "exposesAsset"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a threat actor is shared by every threat attributed to it.
+    part membershipAttributedToThreatActor : WorkspaceMembershipEntry { attribute :>> relation = "attributedToThreatActor"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: an attack technique is a shared catalogue entry.
+    part membershipUsesAttackTechnique : WorkspaceMembershipEntry { attribute :>> relation = "usesAttackTechnique"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: an attack technique is a shared catalogue entry.
+    part membershipIncludesAttackTechnique : WorkspaceMembershipEntry { attribute :>> relation = "includesAttackTechnique"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A cyber hazard follows the threat that realizes it.
+    part membershipRealizesCyberHazard : WorkspaceMembershipEntry { attribute :>> relation = "realizesCyberHazard"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A cyber risk assessment follows the risk it assesses.
+    part membershipAssessesCyberRisk : WorkspaceMembershipEntry { attribute :>> relation = "assessesCyberRisk"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A security finding follows the vulnerability it identifies.
+    part membershipIdentifiesVulnerability : WorkspaceMembershipEntry { attribute :>> relation = "identifiesVulnerability"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A vulnerability follows the SBOM entry it affects.
+    part membershipAffectsSBOMEntry : WorkspaceMembershipEntry { attribute :>> relation = "affectsSBOMEntry"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A security finding follows the attack path it demonstrates.
+    part membershipDemonstratesAttackPath : WorkspaceMembershipEntry { attribute :>> relation = "demonstratesAttackPath"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Evidence follows the mitigation it supports.
+    part membershipSupportsMitigationEffectiveness : WorkspaceMembershipEntry { attribute :>> relation = "supportsMitigationEffectiveness"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // An assumption follows the cyber element it conditions.
+    part membershipConditionsCyberElement : WorkspaceMembershipEntry { attribute :>> relation = "conditionsCyberElement"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A postmarket process follows the SBOM entry it monitors.
+    part membershipMonitorsSBOMEntry : WorkspaceMembershipEntry { attribute :>> relation = "monitorsSBOMEntry"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A use error follows the task that commits it.
+    part membershipCommitsUseError : WorkspaceMembershipEntry { attribute :>> relation = "commitsUseError"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // An evaluation follows the task it evaluates.
+    part membershipEvaluatesTask : WorkspaceMembershipEntry { attribute :>> relation = "evaluatesTask"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A usability test follows the element or task it tests.
+    part membershipTestedByUsability : WorkspaceMembershipEntry { attribute :>> relation = "testedByUsability"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a need and its holder are each placed on their own.
+    part membershipHeldBy : WorkspaceMembershipEntry { attribute :>> relation = "heldBy"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // An effect follows its cause.
+    part membershipCauses : WorkspaceMembershipEntry { attribute :>> relation = "causes"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A detection method follows the failure mode it detects.
+    part membershipDetectedBy : WorkspaceMembershipEntry { attribute :>> relation = "detectedBy"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: fault-tree nodes are joined, not placed, by their gates.
+    part membershipInputToGate : WorkspaceMembershipEntry { attribute :>> relation = "inputToGate"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: fault-tree nodes are joined, not placed, by their gates.
+    part membershipProducesEvent : WorkspaceMembershipEntry { attribute :>> relation = "producesEvent"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a cut set names events that are placed on their own.
+    part membershipContainsEvent : WorkspaceMembershipEntry { attribute :>> relation = "containsEvent"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A hazard follows the HAZOP deviation that identifies it.
+    part membershipIdentifiesHazard : WorkspaceMembershipEntry { attribute :>> relation = "identifiesHazard"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A failure mode follows its element.
+    part membershipHasFailureMode : WorkspaceMembershipEntry { attribute :>> relation = "hasFailureMode"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a trace between risk elements places neither. Both ends are risk items (`TracesRisk` joins
+    // RiskItem to RiskItem), so the relation names no design element to anchor to; a risk item belongs to the
+    // system through the relation that ties it to one (a failure mode, a control measure's allocation).
+    // Decided 2026-10-14: a risk chain with no such tie is Unassigned, which is the finding, not a gap here.
+    part membershipTracesRisk : WorkspaceMembershipEntry { attribute :>> relation = "tracesRisk"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A harm follows the hazardous situation that leads to it.
+    part membershipLeadsToHarm : WorkspaceMembershipEntry { attribute :>> relation = "leadsToHarm"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a scenario illustrates a hazard without being part of it.
+    part membershipHazardRelatedScenario : WorkspaceMembershipEntry { attribute :>> relation = "hazardRelatedScenario"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a risk matrix is shared by every risk assessed against it.
+    part membershipAssessedAgainst : WorkspaceMembershipEntry { attribute :>> relation = "assessedAgainst"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A risk estimate follows the risk element it is for.
+    part membershipEstimatedFor : WorkspaceMembershipEntry { attribute :>> relation = "estimatedFor"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a residual risk and its control are each placed already.
+    part membershipReducedBy : WorkspaceMembershipEntry { attribute :>> relation = "reducedBy"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: an overall residual-risk evaluation spans the whole device.
+    part membershipEvaluatedIn : WorkspaceMembershipEntry { attribute :>> relation = "evaluatedIn"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A risk control follows the risk it mitigates.
+    part membershipMitigates : WorkspaceMembershipEntry { attribute :>> relation = "mitigates"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A surveillance finding follows the design element it feeds back to.
+    part membershipFeedsBackTo : WorkspaceMembershipEntry { attribute :>> relation = "feedsBackTo"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A test step follows its verification case.
+    part membershipPerformsStep : WorkspaceMembershipEntry { attribute :>> relation = "performsStep"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A comment follows the element it annotates.
+    part membershipCommentsOn : WorkspaceMembershipEntry { attribute :>> relation = "commentsOn"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A rationale follows the element it justifies.
+    part membershipRationaleFor : WorkspaceMembershipEntry { attribute :>> relation = "rationaleFor"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A note follows the element it annotates.
+    part membershipNotesOn : WorkspaceMembershipEntry { attribute :>> relation = "notesOn"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A need or driver follows the requirement derived from it.
+    part membershipDerivesFrom : WorkspaceMembershipEntry { attribute :>> relation = "derivesFrom"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Evidence follows the case that produced it.
+    part membershipProducesEvidence : WorkspaceMembershipEntry { attribute :>> relation = "producesEvidence"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A threat or risk follows the requirement derived from it.
+    part membershipDerivesCyberRequirement : WorkspaceMembershipEntry { attribute :>> relation = "derivesCyberRequirement"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a crossing joins a boundary and an item that are each placed on their own.
+    part membershipCrossesTrustBoundary : WorkspaceMembershipEntry { attribute :>> relation = "crossesTrustBoundary"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A validation case follows what it validates.
+    part membershipValidates : WorkspaceMembershipEntry { attribute :>> relation = "validates"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A processing node follows the assembly that hosts it.
+    part membershipHostedBy : WorkspaceMembershipEntry { attribute :>> relation = "hostedBy"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: an interface definition is owned by the system of systems.
+    part membershipBindsToInterface : WorkspaceMembershipEntry { attribute :>> relation = "bindsToInterface"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A requirement follows what satisfies it.
+    part membershipSatisfiedBy : WorkspaceMembershipEntry { attribute :>> relation = "satisfiedBy"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A verification case follows what it verifies.
+    part membershipVerifiedBy : WorkspaceMembershipEntry { attribute :>> relation = "verifiedBy"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A function follows the element it runs on.
+    part membershipAllocatedTo : WorkspaceMembershipEntry { attribute :>> relation = "allocatedTo"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a chain that performs functions of three systems belongs to none of them. Decided 2026-10-14:
+    // a chain step is the system of systems' own, so `performs` places nothing in a system.
+    part membershipPerforms : WorkspaceMembershipEntry { attribute :>> relation = "performs"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a use case that includes others belongs to the system of systems; pulling it would put it in every system it includes.
+    part membershipIncludesStep : WorkspaceMembershipEntry { attribute :>> relation = "includesStep"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a bare dependency says nothing about placement.
+    part membershipDependency : WorkspaceMembershipEntry { attribute :>> relation = "dependency"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // An actor follows the use cases it takes part in.
+    part membershipParticipatesIn : WorkspaceMembershipEntry { attribute :>> relation = "participatesIn"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A mode follows the component that exhibits it.
+    part membershipExhibitsMode : WorkspaceMembershipEntry { attribute :>> relation = "exhibitsMode"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a viewpoint frames concerns that no one workspace owns.
+    part membershipFramesConcern : WorkspaceMembershipEntry { attribute :>> relation = "framesConcern"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A use case follows its subject.
+    part membershipHasSubject : WorkspaceMembershipEntry { attribute :>> relation = "hasSubject"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // An assumption follows the contract that makes it.
+    part membershipAssumes : WorkspaceMembershipEntry { attribute :>> relation = "assumes"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A guarantee follows the contract that makes it.
+    part membershipRequires : WorkspaceMembershipEntry { attribute :>> relation = "requires"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // A child follows its parent.
+    part membershipComposes : WorkspaceMembershipEntry { attribute :>> relation = "composes"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a refinement dependency says nothing about placement.
+    part membershipRealizes : WorkspaceMembershipEntry { attribute :>> relation = "realizes"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a binding equates two features; neither is placed by it.
+    part membershipBind : WorkspaceMembershipEntry { attribute :>> relation = "bind"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a flow joins peers; the chain it belongs to is not drawn into each system it touches.
+    part membershipFlow : WorkspaceMembershipEntry { attribute :>> relation = "flow"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: an interface joins two systems and belongs to the system of systems.
+    part membershipInterface : WorkspaceMembershipEntry { attribute :>> relation = "interface"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: ordering between steps places neither.
+    part membershipSuccession : WorkspaceMembershipEntry { attribute :>> relation = "succession"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A variant follows its variation point.
+    part membershipVariant : WorkspaceMembershipEntry { attribute :>> relation = "variant"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+
+    // A feature follows the variants that realize it: realized by variants of two systems it is
+    // shared, realized by none it is Unassigned (a feature nothing builds).
+    part membershipRealizesFeature : WorkspaceMembershipEntry { attribute :>> relation = "realizesFeature"; attribute :>> direction = WorkspaceMembershipKind::targetFollowsSource; }
+    // Neither: a release is a family-level record, and a feature it selects is placed by its variants.
+    part membershipSelectsFeature : WorkspaceMembershipEntry { attribute :>> relation = "selectsFeature"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A feature lists the views that demonstrate it; listing one places it in no workspace.
+    part membershipShowsView : WorkspaceMembershipEntry { attribute :>> relation = "showsView"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: two features that need each other are peers, and neither is placed by the other.
+    part membershipRequiresFeature : WorkspaceMembershipEntry { attribute :>> relation = "requiresFeature"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: two features that exclude each other are peers.
+    part membershipExcludesFeature : WorkspaceMembershipEntry { attribute :>> relation = "excludesFeature"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // A design decision follows the option it weighs, as it follows the element it decides.
+    part membershipAlternative : WorkspaceMembershipEntry { attribute :>> relation = "alternative"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // A design decision follows the option it chose.
+    part membershipSelected : WorkspaceMembershipEntry { attribute :>> relation = "selected"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+
+    // A release record follows the item it releases: a release of a system is in that system's
+    // workspace. With `neither` every record is Unassigned, which is a finding.
+    part membershipReleaseOf : WorkspaceMembershipEntry { attribute :>> relation = "releaseOf"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a system of systems version contains system releases that belong to their systems.
+    part membershipContains : WorkspaceMembershipEntry { attribute :>> relation = "contains"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: an interface revision belongs to the system of systems, and the systems that implement it are peers.
+    part membershipImplements : WorkspaceMembershipEntry { attribute :>> relation = "implements"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a verification case is placed by what it verifies, not by the release that cites it.
+    part membershipVerifiedByCase : WorkspaceMembershipEntry { attribute :>> relation = "verifiedByCase"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+    // Neither: a change request is not placed by the release it is raised against.
+    part membershipAffectsRelease : WorkspaceMembershipEntry { attribute :>> relation = "affectsRelease"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+
+    // A device follows the releases it covers, and they follow their items: a device that covers releases of
+    // two systems is shared, and one that covers none is Unassigned (an approval for nothing).
+    part membershipCovers : WorkspaceMembershipEntry { attribute :>> relation = "covers"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+
+    // Neither: a step is not placed by the rule that says when it is done.
+    part membershipDoneWhen : WorkspaceMembershipEntry { attribute :>> relation = "doneWhen"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+
+    // A project follows the releases it feeds, as a device follows what it covers: a project that feeds releases
+    // of two systems is shared, and one that feeds none is Unassigned (work that reached nothing).
+    part membershipFeeds : WorkspaceMembershipEntry { attribute :>> relation = "feeds"; attribute :>> direction = WorkspaceMembershipKind::sourceFollowsTarget; }
+    // Neither: a variant is placed by its variation point; the project that introduced it is not drawn into it.
+    part membershipIntroducedBy : WorkspaceMembershipEntry { attribute :>> relation = "introducedBy"; attribute :>> direction = WorkspaceMembershipKind::neither; }
+}

package/src/core/semantics/semantics.sysml

@@ -4,6 +4,7 @@
 // applying these metadata defs with `@Name` — never by adding new grammar.
 package memo_core_semantics {
     private import ScalarValues::*;
+    private import memo_core_terminology::ExternalReference;
 
     // Tags an element with the regulatory standard it derives from
     // (e.g. ISO 14971, IEC 62304, ISO/IEC/IEEE 42010).
@@ -12,6 +13,63 @@ package memo_core_semantics {
         attribute clause : String;
     }
 
+    // An element imported from another system (a requirements tool, a PLM, a
+    // quality system, a test-result export). It annotates an element of ANY
+    // metaclass, because imported records span them: a requirement def is not a
+    // MemoPart. The source id is `externalReference.identifier`, NOT MemoIdentity's
+    // `providedId`: `providedId` is the id an external system knows an
+    // authored element by, whereas this records the external record an
+    // element was made from, with its revision.
+    //
+    //   @ExternalSource {
+    //       :>> externalReference { :>> sourceSystem = "..."; :>> identifier = "..."; :>> revision = "B"; }
+    //       :>> sourceMastered = true;
+    //   }
+    //
+    // `sourceMastered` is true when the source system owns the element, so a
+    // re-import overwrites it and a MEMO edit would be lost. `sourceWithdrawn`
+    // is set by a re-import when the record is gone from the source: the
+    // element is kept, so the links to it still compile and can be reviewed.
+    metadata def ExternalSource {
+        attribute externalReference : ExternalReference[0..1];
+        attribute sourceMastered : Boolean[0..1];
+        attribute sourceWithdrawn : Boolean[0..1];
+    }
+
+    // What an import wrote a package from, on the package itself. A source's
+    // records live in one package that the import owns and regenerates, so this
+    // is the record of where it came from and when it was last imported. A
+    // metadata usage is a package member (PackageBodyElement, SysML-textual-bnf.kebnf:124 →
+    // PackageMember :133 → DefinitionElement :184 → AnnotatingElement :74 → MetadataFeature).
+    metadata def ImportSource {
+        attribute sourceSystem : String;
+        attribute importFormat : String;
+        attribute importFile : String[0..1];
+        attribute importedAt : String;
+    }
+
+    // The revision of an imported element a MEMO-authored link was made against.
+    // A link is suspect when that revision is no longer the element's current
+    // `externalReference.revision`, or when the element is withdrawn. The status
+    // is derived, never stored; reviewing the link rewrites this baseline to the
+    // current revision. Only MEMO-authored links carry it: a link imported
+    // from the source is mastered there and is re-imported instead.
+    //
+    // Both are written in a body, because a prefix `#Name` cannot carry a value
+    // (PrefixMetadataUsage, SysML-textual-bnf.kebnf:1667). The nested
+    // `externalReference { … }` is MetadataBodyUsage (kebnf:1694), and the baseline sits in
+    // the link's own body: a `satisfy`'s RequirementBody (kebnf:1408), a
+    // connection's or a `dependency`'s DefinitionBody (kebnf:238).
+    //
+    // `sourceIdentifier` names the imported element the revision belongs to. A
+    // link between two imported elements needs it: one revision cannot be
+    // compared with two ends, so without it the link could never be cleared by
+    // review. Absent, every imported end is compared.
+    metadata def TraceBaseline {
+        attribute sourceRevision : String;
+        attribute sourceIdentifier : String[0..1];
+    }
+
     // Marks an element as the rationale/provenance carrier for a decision.
     metadata def Provenance {
         attribute source : String;

package/src/core/terminology/terminology.sysml

@@ -26,10 +26,17 @@ package memo_core_terminology {
 
     // A reference into an external registry or document (regulatory listing,
     // standard clause, catalog page) with enough context to resolve it.
+    //
+    // For an element imported from another system (see ExternalSource) it is the
+    // record in that system: `sourceSystem` names the system, `identifier` is
+    // the id the system knows the record by, and `revision` is the revision of
+    // the record as last imported.
     attribute def ExternalReference {
         attribute referenceKind : String;
         attribute identifier : String;
         attribute uri : String;
         attribute section : String;
+        attribute sourceSystem : String[0..1];
+        attribute revision : String[0..1];
     }
 }

package/src/memo_namespaces.sysml

@@ -37,6 +37,7 @@ package memo {
     public import memo_assurance_safety_risk_analysis::*;
     public import memo_assurance_safety_risk_postmarket_surveillance::*;
     public import memo_architecture_decisions::*;
+    public import memo_architecture_variability::*;
 
     public import memo_viewpoints_definitions::*;
     public import memo_viewpoints_stakeholders_concerns::*;
@@ -211,6 +212,7 @@ package memo_assurance_safety_compatibility {
 // the Diagram workspace, never as architecture layers.
 package memo_namespace_architecture {
     alias decisions for memo_namespace_architecture_decisions;
+    alias variability for memo_namespace_architecture_variability;
 
     package operational {
         alias structure for memo_namespace_architecture_operational;
@@ -335,6 +337,10 @@ package memo_namespace_architecture_decisions {
     public import memo_architecture_decisions::*;
 }
 
+package memo_namespace_architecture_variability {
+    public import memo_architecture_variability::*;
+}
+
 package memo_namespace_architecture_functions {
     public import memo_architecture_functional_functions::*;
 }

package/src/methodology/archetypes/memo_archetypes.sysml

@@ -7,9 +7,8 @@ package memo_methodology_archetypes {
     private import memo_core_common::MemoIdentity;
     part minimal : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-MINIMAL"; }
-        attribute :>> name = "Minimal";
         attribute :>> label = "Minimal";
-        attribute :>> description = "Core ontology only — requirements, hazards, basic architecture (~53 kinds)";
+        doc /* Core ontology only — requirements, hazards, basic architecture (~53 kinds) */
         attribute :>> category = "profile";
         attribute :>> includedLayer = "context; requirements; risk";
         attribute :>> includedStandard = "ISO 14971";
@@ -18,9 +17,8 @@ package memo_methodology_archetypes {
 
     part standardArchetype : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-STANDARD"; }
-        attribute :>> name = "Standard";
         attribute :>> label = "Standard";
-        attribute :>> description = "Core + risk + software + DHF — covers most Class II devices (~120 kinds)";
+        doc /* Core + risk + software + DHF — covers most Class II devices (~120 kinds) */
         attribute :>> category = "profile";
         attribute :>> includedLayer = "context; requirements; functions; logical_structure; software_structure; risk; assurance";
         attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820";
@@ -29,9 +27,8 @@ package memo_methodology_archetypes {
 
     part full : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-FULL"; }
-        attribute :>> name = "Full";
         attribute :>> label = "Full";
-        attribute :>> description = "All architecture layers, standards, and extensions (~200+ kinds)";
+        doc /* All architecture layers, standards, and extensions (~200+ kinds) */
         attribute :>> category = "profile";
         attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; behavior; risk; arch_risk; assurance; cybersecurity; constraints";
         attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820; ISO 13485; IEC 62366; IEC 60601-1; IEC 82304-1; FDA Cybersecurity Guidance";
@@ -40,9 +37,8 @@ package memo_methodology_archetypes {
 
     part samd : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-SAMD"; }
-        attribute :>> name = "SaMD";
         attribute :>> label = "Software as Medical Device (SaMD)";
-        attribute :>> description = "Clinical decision support, diagnostic algorithm, AI/ML tool, mobile medical app";
+        doc /* Clinical decision support, diagnostic algorithm, AI/ML tool, mobile medical app */
         attribute :>> category = "device-class";
         attribute :>> includedLayer = "context; requirements; functions; logical_structure; software_structure; risk; assurance; cybersecurity";
         attribute :>> includedStandard = "ISO 14971; IEC 62304; IEC 82304-1; FDA Cybersecurity Guidance";
@@ -51,9 +47,8 @@ package memo_methodology_archetypes {
 
     part connected : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-CONNECTED"; }
-        attribute :>> name = "Connected";
         attribute :>> label = "Connected / IoT Device";
-        attribute :>> description = "Remote monitoring, wearable, smart device with cloud connectivity and cybersecurity requirements";
+        doc /* Remote monitoring, wearable, smart device with cloud connectivity and cybersecurity requirements */
         attribute :>> category = "device-class";
         attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; risk; assurance; cybersecurity";
         attribute :>> includedStandard = "ISO 14971; IEC 62304; 21 CFR 820; FDA Cybersecurity Guidance";
@@ -62,9 +57,8 @@ package memo_methodology_archetypes {
 
     part monitoring : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-MONITORING"; }
-        attribute :>> name = "Monitoring";
         attribute :>> label = "Monitoring / Diagnostic Device";
-        attribute :>> description = "Patient monitor, ECG, SpO2, vital signs, bedside diagnostic equipment";
+        doc /* Patient monitor, ECG, SpO2, vital signs, bedside diagnostic equipment */
         attribute :>> category = "device-class";
         attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; risk; assurance";
         attribute :>> includedStandard = "ISO 14971; IEC 62304; IEC 60601-1; 21 CFR 820";
@@ -73,9 +67,8 @@ package memo_methodology_archetypes {
 
     part infusion_pump : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-INFUSION"; }
-        attribute :>> name = "InfusionPump";
         attribute :>> label = "Infusion / Drug Delivery Device";
-        attribute :>> description = "Infusion pump, syringe driver, implantable drug delivery, dosing device";
+        doc /* Infusion pump, syringe driver, implantable drug delivery, dosing device */
         attribute :>> category = "device-class";
         attribute :>> includedLayer = "context; requirements; functions; logical_structure; interfaces; software_structure; hardware_structure; behavior; risk; arch_risk; assurance; cybersecurity";
         attribute :>> includedStandard = "ISO 14971; IEC 62304; IEC 60601-1; 21 CFR 820; ISO 13485";
@@ -84,9 +77,8 @@ package memo_methodology_archetypes {
 
     part blank : Archetype {
         @MemoIdentity { :>> providedId = "ARCH-BLANK"; }
-        attribute :>> name = "Blank";
         attribute :>> label = "Blank Project";
-        attribute :>> description = "Start from scratch with a minimal SysML shell";
+        doc /* Start from scratch with a minimal SysML shell */
         attribute :>> category = "device-class";
         attribute :>> includedLayer = "";
         attribute :>> includedStandard = "";