@memoarchitect/ontology 0.6.4 → 0.7.0

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

@@ -67,8 +67,7 @@ package memo_architecture_logical_interfaces {
         attribute interfaceKind : InterfaceKind;
         attribute protocolSemantics : String;
     }
-    port def DataPort {
-        attribute direction : DirectionKind;
+    port def DataPort specializes MemoPort {
         attribute interfaceType : String;
     }
     port def SensorPort specializes DataPort { attribute sensorDomain : String; }

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

@@ -37,13 +37,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 +54,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,9 +137,7 @@ 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;

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

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

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

@@ -51,7 +51,7 @@ package memo_architecture_operational_scenarios {
     // 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 {
+    abstract action def MemoScenario specializes MemoAction {
         attribute variantKind : ScenarioVariantKind;
         attribute operationalCondition : OperationalConditionKind;
         attribute scenarioPurpose : ScenarioPurposeKind[0..*];
@@ -76,7 +76,7 @@ package memo_architecture_operational_scenarios {
     // 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 {
+    action def OperativeScenario specializes MemoScenario {
         ref parentWorkflow : OperationalWorkflow[0..1];
         ref parentUseCase : UseCase[0..1];
         // Each scenario owns the operational activity/action flow for its

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

@@ -43,7 +43,6 @@ package memo_architecture_operational_workflows {
     // 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 stepOrder : Integer;
         attribute entryCondition : String;
         attribute exitCondition : String;
         ref performedActivity : OperationalActivity[0..1];
@@ -97,11 +96,6 @@ package memo_architecture_operational_workflows {
         end supporter;
         end supported;
     }
-    connection def StepPrecedes :> MemoRelationship {
-        attribute guardCondition : String;
-        end predecessor : WorkflowStep;
-        end successor : WorkflowStep;
-    }
     connection def RequiresResource :> MemoRelationship {
         end workflow : OperationalWorkflow;
         end resource : WorkflowResource;

package/src/{compliance/change/memo_change.sysml → artifacts/configuration_management/memo_configuration_management.sysml}

@@ -1,15 +1,17 @@
-package memo_compliance_change {
+package memo_artifacts_configuration_management {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def ChangeRequest specializes MemoPart {
+
+    part def ChangeRequest :> MemoPart {
         attribute changeType : ChangeTypeKind;
         attribute impactAssessment : String;
         attribute approvalStatus : String;
         attribute affectedBaseline : String;
     }
-    part def ConfigurationItem specializes MemoPart {
+
+    part def ConfigurationItem :> MemoPart {
         attribute version : String;
         attribute baseline : String;
         attribute controlLevel : String;

package/src/artifacts/core/memo_controlled_artifacts.sysml

@@ -0,0 +1,33 @@
+package memo_artifacts_core {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    item def ControlledArtifact :> MemoPart {
+        attribute version : String;
+        attribute artifactKind : ArtifactKind;
+        attribute owner : String;
+        attribute approvalStatus : String;
+    }
+
+    part def ModelOwnedArtifact :> ControlledArtifact {
+        attribute uri : String;
+        attribute mediaType : String;
+        attribute contentHash : String;
+        attribute artifactVersion : String[0..1];
+        attribute authoredLanguage : String[0..1];
+        attribute executionEnvironment : String[0..1];
+        attribute generated : Boolean;
+    }
+
+    part def ADRArtifact :> ModelOwnedArtifact {
+        attribute decisionId : String;
+    }
+
+    part def MarkdownDocumentSource :> ModelOwnedArtifact {}
+    part def ModelQueryScript :> ModelOwnedArtifact {}
+    part def AnalysisNotebook :> ModelOwnedArtifact {}
+    part def ModelDataset :> ModelOwnedArtifact {}
+    part def GeneratedReport :> ModelOwnedArtifact {}
+}

package/src/artifacts/documents/risk_management/memo_risk_management.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_documents_risk_management {
+    private import ScalarValues::*;
+
+    private import memo_artifacts_core::*;
+
+    part def RiskManagementFile :> ModelOwnedArtifact {
+        attribute standardReference : String;
+        attribute clause : String;
+        attribute edition : String;
+        attribute completenessStatus : String;
+    }
+}

package/src/assurance/cybersecurity/memo_cybersecurity.sysml

@@ -49,7 +49,7 @@ package memo_assurance_cybersecurity {
     // A scenario specialization: an attack path through the
     // system, classified by the shared scenario dimensions with purpose
     // `cybersecurity`.
-    part def ThreatScenario specializes MemoScenario {
+    action def ThreatScenario specializes MemoScenario {
         attribute actorDescription : String;
         attribute assumptionSummary : String;
         attribute guaranteeSummary : String;

package/src/assurance/human_factors/memo_human_factors.sysml

@@ -21,7 +21,7 @@ package memo_assurance_human_factors {
 
     // A use scenario whose performance could lead to a hazardous situation
     // (IEC 62366-1 3.9); selected for summative evaluation.
-    part def HazardRelatedUseScenario specializes MemoScenario {
+    action def HazardRelatedUseScenario specializes MemoScenario {
         attribute hazardReference : String;
         attribute selectionRationale : String;
     }

package/src/assurance/safety_risk/postmarket_surveillance/memo_postmarket_surveillance.sysml

@@ -0,0 +1,11 @@
+package memo_assurance_safety_risk_postmarket_surveillance {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+
+    part def PostMarketSurveillance :> MemoPart {
+        attribute surveillanceKind : String;
+        attribute dataSource : String;
+        attribute reportingObligation : String;
+    }
+}

package/src/assurance/verification_validation/clinical_evaluation/memo_clinical_evaluation.sysml

@@ -0,0 +1,11 @@
+package memo_assurance_verification_validation_clinical_evaluation {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+
+    part def ClinicalEvaluation :> MemoPart {
+        attribute evaluationStage : String;
+        attribute clinicalDataSource : String;
+        attribute conclusion : String;
+    }
+}

package/src/assurance/verification_validation/memo_assurance.sysml

@@ -34,7 +34,7 @@ package memo_assurance_verification_validation {
 
     // A scenario executed to verify — selected path with purpose
     // 'verification'.
-    part def VerificationScenario specializes MemoScenario {
+    action def VerificationScenario specializes MemoScenario {
         attribute verificationEnvironment : String;
         attribute stimulusSummary : String;
     }

package/src/core/annotations/memo_annotations.sysml

@@ -0,0 +1,77 @@
+// Universal model annotations carried as model content rather than source-text
+// `doc` / `comment` annotations. Comments capture review conversation, notes
+// preserve useful context, and rationales explain why an engineering choice was
+// made. Each is independently traceable, queryable, and exportable.
+//
+// The distinction is deliberate and load-bearing: `description` is what an
+// element IS, a ModelComment is what someone SAID ABOUT IT. A design review
+// needs an author, a timestamp, a thread, and a resolution state, and none of
+// those survive inside a documentation string. Merging the two would put
+// unresolved review chatter into a generated DHF section, so they never merge.
+//
+// Annotations attach to every metaclass — parts, actions, requirements, views,
+// connections, and MEMO specializations — so CommentsOn, RationaleFor, and
+// NotesOn leave their subject ends untyped, following the MemoLink precedent in
+// memo_core_relationships.
+package memo_core_annotations {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+
+    abstract part def ModelAnnotation specializes MemoPart {
+        // `body` is the annotation content; `shortDescription` is the one-line
+        // form shown in badges, tables, and generated indexes.
+        attribute body : String;
+        attribute author : String;
+        // ISO 8601. Strings, not a date type: MEMO stays portable content and
+        // does not depend on a tool's date library.
+        attribute createdAt : String;
+        // Optional pinpoint inside the annotated element: an attribute name,
+        // requirement clause, diagram node, or other stable local reference.
+        attribute anchor : String;
+    }
+
+    part def ModelComment specializes ModelAnnotation {
+        attribute commentStatus : CommentStatusKind;
+        // Why the comment closed. Required in practice for `resolved` and
+        // `rejected` — a closed review point with no stated disposition is an
+        // audit gap.
+        attribute resolution : String;
+        attribute resolvedBy : String;
+        attribute resolvedAt : String;
+    }
+
+    part def ModelRationale specializes ModelAnnotation {
+        // Decision, trade-off, standard clause, or evidence that the rationale
+        // rests on. The body explains the reasoning in full.
+        attribute basis : String;
+    }
+
+    part def ModelNote specializes ModelAnnotation {
+        // A lightweight category for filtering notes without constraining their
+        // content (for example assumption, usage, implementation, or warning).
+        attribute noteKind : String;
+    }
+
+    // Replies form a thread through the ordinary Composes relation (parent
+    // comment → reply), so CR-ONT-001's acyclicity invariant already covers
+    // comment threads and no thread-specific relation is needed.
+    // The end is `remark`, not `comment`: `comment` is a reserved KerML
+    // keyword and cannot name a feature.
+    connection def CommentsOn :> MemoRelationship {
+        end remark : ModelComment;
+        end annotatedElement;
+    }
+
+    connection def RationaleFor :> MemoRelationship {
+        end rationaleRecord : ModelRationale;
+        end justifiedElement;
+    }
+
+    connection def NotesOn :> MemoRelationship {
+        end noteRecord : ModelNote;
+        end notedElement;
+    }
+}

package/src/core/common/memo_common.sysml

@@ -27,6 +27,14 @@ package memo_core_common {
         // identity
         attribute id : String;
         attribute name : String;
+        // Two description registers on every MEMO element, because views have
+        // two densities. `shortDescription` is the one-line form a table cell,
+        // matrix header, chip, or diagram node can show whole; `description` is
+        // the full prose a properties panel or a generated document section
+        // renders. A view picks the register that fits — it never truncates
+        // the long one, because a silently clipped sentence in a DHF table is
+        // a defect, not a layout choice.
+        attribute shortDescription : String;
         attribute description : String;
         // traceability
         attribute rationale : String;
@@ -51,10 +59,12 @@ package memo_core_common {
     part def MemoEvidence specializes MemoPart;
     abstract part def AnalysisArtifact specializes MemoPart;
 
+    // Document-bound elements add only what a document needs beyond the two
+    // description registers every MemoPart now carries: a title and its place
+    // in a document. The former `shortDescription`/`longDescription` pair is
+    // gone — short is inherited, and `description` IS the long form.
     part def DocumentedElement specializes MemoPart {
         attribute title : String;
-        attribute shortDescription : String;
-        attribute longDescription : String;
         attribute documentUsage : String[*];
         attribute sectionIdentifier : String;
     }
@@ -66,6 +76,7 @@ package memo_core_common {
     action def MemoAction {
         attribute id : String;
         attribute name : String;
+        attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
@@ -76,8 +87,8 @@ package memo_core_common {
     port def MemoPort {
         attribute id : String;
         attribute name : String;
+        attribute shortDescription : String;
         attribute description : String;
-        attribute direction : DirectionKind;
     }
 
     // Interaction-contract foundation for interface definitions between ports.
@@ -86,6 +97,7 @@ package memo_core_common {
         end target;
         attribute id : String;
         attribute name : String;
+        attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
@@ -96,6 +108,7 @@ package memo_core_common {
     item def MemoExchangeItem {
         attribute id : String;
         attribute name : String;
+        attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
@@ -113,6 +126,7 @@ package memo_core_common {
     // solution-space obligation.
     requirement def MemoNeed {
         attribute needId : String;
+        attribute shortDescription : String;
         attribute statement : String;
         attribute needRationale : String;
         attribute needSource : String;
@@ -122,6 +136,7 @@ package memo_core_common {
 
     requirement def MemoRequirement {
         attribute requirementId : String;
+        attribute shortDescription : String;
         attribute statement : String;
         attribute acceptanceCriteria : String;
         attribute requirementStatus : ElementStatusKind;
@@ -134,6 +149,7 @@ package memo_core_common {
     verification def MemoVerificationCase {
         attribute id : String;
         attribute name : String;
+        attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
@@ -147,6 +163,7 @@ package memo_core_common {
     abstract state def MemoState {
         attribute id : String;
         attribute name : String;
+        attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;

package/src/core/consistency_rules/consistency_rules.sysml

@@ -6,6 +6,13 @@ package memo_core_consistency_rules {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
+    // Common supertype of every executable MEMO rule. It carries no members of
+    // its own: a rule's metadata is declared on the rule, and a shared member
+    // here would be shadowed by every rule that sets it. Its job is to give
+    // RulePolicy a type to reference, so a policy names a rule the way SysML
+    // names anything else rather than through a parallel string-ID namespace.
+    abstract constraint def MemoConsistencyRule;
+
     part def ConsistencyRule specializes MemoPart {
         attribute appliesTo : String;
         attribute predicate : RulePredicateKind;

package/src/core/dimensions/dimensions.sysml

@@ -10,9 +10,13 @@ package memo_core_dimensions {
     private import ScalarValues::*;
 
     // Realization stages of one element identity across the product
-    // lifecycle (specification through retirement). Orthogonal to the axis:
+    // lifecycle (proposal through retirement). Orthogonal to the axis:
     // a single identity progresses through stages without changing its owner.
     enum def RealizationStageKind {
+        // Put forward but not yet specified — a candidate under consideration,
+        // so a design alternative can be modelled and traced without implying
+        // it has been accepted into the specification.
+        enum proposed;
         enum specified;
         enum designed;
         enum built;

package/src/core/enumerations/memo_enumerations.sysml

@@ -83,7 +83,6 @@ package memo_core_enumerations {
         enum input;
         enum output;
         enum inputOutput;
-        enum bidirectional;
     }
     enum def CriticalityKind {
         enum low;
@@ -192,11 +191,11 @@ package memo_core_enumerations {
         enum SDD;
         enum RMF;
         enum VV;
-        enum ArchitectureDescription;
-        enum CybersecurityAssessment;
-        enum ThreatModel;
-        enum Clinical;
-        enum Usability;
+        enum architectureDescription;
+        enum cybersecurityAssessment;
+        enum threatModel;
+        enum clinical;
+        enum usability;
     }
     enum def SchedulingPolicyKind {
         enum nonRealTime;
@@ -264,6 +263,29 @@ package memo_core_enumerations {
         enum crossLayer;
         enum quantitative;
     }
+    // How far a methodology may tailor a rule. `invariant` rules hold the
+    // ontology's own consistency and may only change in an ontology release;
+    // `assurance` and `methodology` rules may be disabled or replaced through
+    // an explicit RulePolicy carrying rationale and authority.
+    enum def RuleTailoringKind {
+        enum invariant;
+        enum assurance;
+        enum methodology;
+    }
+    enum def RuleDispositionKind {
+        enum enabled;
+        enum disabled;
+        enum replaced;
+    }
+    // Whether a methodology's inclusion lists are the whole selection or a
+    // deliberate subset. An empty list under `explicit` selects nothing; it
+    // never means "everything". `allAvailable` is the only way to say "all",
+    // and it is always deliberate. (SysML v2 reserves `all`, so the literal is
+    // spelled `allAvailable`.)
+    enum def ScopeModeKind {
+        enum allAvailable;
+        enum explicit;
+    }
     enum def WorkflowStageKind {
         enum context;
         enum requirements;
@@ -337,6 +359,9 @@ package memo_core_enumerations {
         enum riskTable;
         enum traceMatrix;
         enum narrativeSection;
+        // A captured screen with its regions drawn over it — the presentation
+        // of the geometry view kind.
+        enum screenLayout;
         enum custom;
     }
     enum def DeploymentKind {
@@ -570,4 +595,14 @@ package memo_core_enumerations {
         enum actionCategory;
         enum memoryRecall;
     }
+    // Lifecycle of a review remark on a model element. `rejected` is a closed
+    // state with a stated reason, not a deletion: a design review that
+    // considered a point and declined it is a record the DHF wants to keep.
+    enum def CommentStatusKind {
+        enum open;
+        enum acknowledged;
+        enum addressed;
+        enum resolved;
+        enum rejected;
+    }
 }

package/src/core/methodology_scope/methodology_scope.sysml

@@ -1,25 +1,17 @@
 // Methodology scope helpers.
-// Instances use repeated scalar attribute usages to enumerate set entries, for
-// example: `attribute :>> includedArchLayer = "operational";`.
+//
+// `MethodologyScope` and `MethodologyLayerSet` were removed when the semantic
+// contract flipped. A methodology's effective selection is declared on
+// `MethodologyDefinition` itself — `scopeMode` plus the `included*` lists — so
+// that one element answers "what is in scope". A second scope part sitting
+// beside the methodology meant two authorities for the same question, and the
+// tools read the one the methodology definition did not declare.
 package memo_core_methodology_scope {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_dimensions::*;
 
-    part def MethodologyLayerSet specializes MemoPart {
-        attribute setName : String;
-        attribute layer : String;
-    }
-
-    part def MethodologyScope specializes MemoPart {
-        attribute scopeName : String;
-        attribute includedArchLayer : String[0..*];
-        // Qualified package names may resolve to MEMO, project, supplier, or
-        // other externally provided ontology modules.
-        attribute includedModule : String[0..*];
-    }
-
     part def ElementKindAlias specializes MemoPart {
         attribute methodTerm : String;
         attribute concreteKind : String;

package/src/core/relationships/memo_relationships.sysml

@@ -85,8 +85,10 @@ package memo_core_relationships {
     // Implements{Component,Procedure}, UIRealizesFunctional,
     // FunctionalRealizesOper{ative,ational} and ScenarioRealizesUseCase.
     connection def Realizes :> MemoRelationship {
-        end realizing : MemoPart;
-        end realized : MemoPart;
+        // Realization crosses structural and behavioral metaclasses (for
+        // example a FunctionalFlow route realizing a FunctionalScenario).
+        end realizing;
+        end realized;
     }
     connection def VerifiedBy :> MemoRelationship {
         // Requirements, risk controls, and architecture components are