@memoarchitect/ontology 0.7.0 → 0.8.24

package/src/core/common/memo_common.sysml

@@ -1,9 +1,32 @@
 // MEMO base hierarchy. Construct-specific foundations: one base per
-// SysML v2 metaclass family (part, action, port, interface, item, requirement,
-// connection), each carrying the shared MEMO semantics. Common inheritance
+// SysML v2 metaclass family (part, action, port, interface, item, use case,
+// requirement, constraint, verification, state, connection), each carrying
+// the shared MEMO semantics. Common inheritance
 // across metaclasses is not portable, so non-part bases re-declare the small
 // identification core and share classification through the metadata defs in
 // memo_core_dimensions.
+//
+// ─── The identification core ────────────────────────────────────────────
+// Every MEMO base below declares the SAME attributes, in the same order,
+// with no exceptions:
+//
+//     id, uuid, name, shortDescription, description,
+//     rationale, sourceReference, status
+//
+// They are re-declared per metaclass only because KerML will not let an
+// action, port, item, requirement, or connection inherit from a part def.
+// The duplication is a language constraint, not a design choice — so treat
+// the block as one unit: anything added or removed here is added or removed
+// in all of them. The drift this replaces was real (MemoPort carried no
+// sourceReference and no status; MemoRequirement and MemoNeed each invented
+// their own status attribute), and drift here shows up as an element whose
+// properties panel is missing fields its neighbours have.
+//
+// `uuid` is the stable technical identity: never displayed, never used as a
+// label, never reused. Authors normally leave it unset and let the compiler
+// derive it (memo-tools assigns a v5 UUID over file+kind+id); set it
+// explicitly on an element whose file or id must be free to change without
+// breaking external references to it, and the authored value wins.
 package memo_core_common {
     private import ScalarValues::*;
 
@@ -26,6 +49,7 @@ package memo_core_common {
     abstract part def MemoPart {
         // identity
         attribute id : String;
+        attribute uuid : 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,
@@ -54,19 +78,44 @@ package memo_core_common {
     //     MemoPart so all existing content inherits the dimensions. ───
     part def RequirementDriver specializes MemoPart;
     abstract part def VerifiableElement specializes MemoPart;
-    abstract part def ArchitectureElement specializes MemoPart;
     part def InterfaceElement specializes MemoPart;
-    part def MemoEvidence specializes MemoPart;
+    enum def EvidenceKind { enum testArtifact; enum evidence; enum formativeEvaluation; enum usabilityValidation; enum securityClaim; }
+    part def MemoEvidence specializes MemoPart {
+        attribute evidenceKind : EvidenceKind;
+        attribute version : String;
+        attribute artifactKind : ArtifactKind[0..1];
+        attribute resultSummary : String;
+        attribute evidenceType : String;
+        attribute integrityStatus : String;
+        // Promoted from the retired `UsabilityValidation` and
+        // `FormativeEvaluation` specializations. The collapse in `02083c5`
+        // deleted both subclasses without carrying their fields up, so an
+        // IEC 62366-1 evaluation record lost what it actually reports.
+        // Promoted on the standard's terms, not on in-tree usage: MEMO is a
+        // library, so what its own examples happen to set says nothing about
+        // what an adopter's usability file needs.
+        attribute participantProfile : String;
+        attribute participantCount : Integer;
+        attribute acceptanceCriteria : String;
+        attribute evaluationMethod : String;
+        attribute findingsSummary : String;
+        attribute designChangesTriggered : String;
+    }
     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 documentUsage : String[*];
-        attribute sectionIdentifier : String;
+    // Top-level goal a system or operation exists to fulfil, with its success
+    // criteria and context. Domain layers specialize it; the medical-device
+    // intended use (memo_architecture_operational_structure::IntendedUse) is a
+    // MemoMission. Specializes MemoPart directly — name/description/rationale
+    // already live there, so no DocumentedElement layer is needed.
+    abstract part def MemoMission specializes MemoPart {
+        attribute missionKind : String;
+        attribute successCriteria : String;
+        attribute operationalContext : String;
     }
 
     // ─── Construct-specific foundations (non-part metaclasses) ───────
@@ -75,6 +124,7 @@ package memo_core_common {
     // and interaction steps specialize MemoAction.
     action def MemoAction {
         attribute id : String;
+        attribute uuid : String;
         attribute name : String;
         attribute shortDescription : String;
         attribute description : String;
@@ -86,9 +136,13 @@ package memo_core_common {
     // Boundary feature foundation for typed ports.
     port def MemoPort {
         attribute id : String;
+        attribute uuid : String;
         attribute name : String;
         attribute shortDescription : String;
         attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+        attribute status : ElementStatusKind;
     }
 
     // Interaction-contract foundation for interface definitions between ports.
@@ -96,6 +150,7 @@ package memo_core_common {
         end source;
         end target;
         attribute id : String;
+        attribute uuid : String;
         attribute name : String;
         attribute shortDescription : String;
         attribute description : String;
@@ -103,15 +158,25 @@ package memo_core_common {
         attribute sourceReference : String;
     }
 
-    // Exchange-content foundation: everything that flows — information,
-    // command, material, energy — is an item, not a part.
-    item def MemoExchangeItem {
+    // Single item foundation. Standards, hazards, stored software data, and
+    // message payloads are all item-native concepts. Whether an item is
+    // exchanged is expressed by its use in a port or flow, not by a second
+    // ontology root.
+    abstract item def MemoItem {
         attribute id : String;
+        attribute uuid : String;
         attribute name : String;
         attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
+        attribute status : ElementStatusKind;
+        // What the item CARRIES, as distinct from what it is called. Removed
+        // by `595bfac` while modelling native wrappers; nothing replaced them,
+        // and every exchange item in the examples went on setting them. A
+        // measured value without its unit, its range, or its terminology code
+        // is not a regulated data item — an IVD result is "5.5 mg/dL, LOINC
+        // 2345-7", not "5.5".
         attribute semantics : String;
         attribute unit : String;
         attribute minValue : String;
@@ -121,25 +186,58 @@ package memo_core_common {
         attribute codes : TerminologyCode[0..*];
     }
 
+    // Use-case foundation. The domain UseCase adds its goal and actor
+    // references; identity is carried here so use cases do not maintain a
+    // partial hand-written copy of the MEMO identification core.
+    abstract use case def MemoUseCase {
+        attribute id : String;
+        attribute uuid : String;
+        attribute name : String;
+        attribute shortDescription : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+        attribute status : ElementStatusKind;
+    }
+
+    // General constraint foundation. Executable consistency rules and
+    // reusable quantitative constraints are both native constraint defs.
+    abstract constraint def MemoConstraint {
+        attribute id : String;
+        attribute uuid : String;
+        attribute name : String;
+        attribute shortDescription : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+        attribute status : ElementStatusKind;
+    }
+
     // Requirement-family foundations. MemoNeed captures a problem-space
     // expectation in stakeholder language; MemoRequirement a testable
     // solution-space obligation.
-    requirement def MemoNeed {
-        attribute needId : String;
+    // Shared base of the requirement family. It exists so a relation end can
+    // say "a need or a requirement" with one type name — before it, every end
+    // that had to accept both was left untyped.
+    abstract requirement def MemoRequirementElement {
+        attribute id : String;
+        attribute uuid : String;
+        attribute name : String;
         attribute shortDescription : String;
+        attribute description : String;
+        attribute rationale : String;
+        attribute sourceReference : String;
+        attribute status : ElementStatusKind;
         attribute statement : String;
-        attribute needRationale : String;
+    }
+
+    requirement def MemoNeed :> MemoRequirementElement {
         attribute needSource : String;
         attribute priority : String;
-        attribute needStatus : ElementStatusKind;
     }
 
-    requirement def MemoRequirement {
-        attribute requirementId : String;
-        attribute shortDescription : String;
-        attribute statement : String;
+    requirement def MemoRequirement :> MemoRequirementElement {
         attribute acceptanceCriteria : String;
-        attribute requirementStatus : ElementStatusKind;
     }
 
     // Verification-case foundation. A SysML v2 verification case is a behaviour
@@ -148,11 +246,13 @@ package memo_core_common {
     // identification core rather than inheriting it.
     verification def MemoVerificationCase {
         attribute id : String;
+        attribute uuid : String;
         attribute name : String;
         attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
+        attribute status : ElementStatusKind;
     }
 
     // State foundation. SysML v2 states (state machines and their mode states)
@@ -160,13 +260,22 @@ package memo_core_common {
     // re-declare the identification core instead of specializing MemoPart
     // Transitions stay part-based to keep their traceable safety
     // attributes (id, sourceReference, priority, sameStepCritical).
-    abstract state def MemoState {
+    enum def StateKind { enum mode; enum logical; }
+
+    state def MemoState {
+        attribute stateKind : StateKind;
         attribute id : String;
+        attribute uuid : String;
         attribute name : String;
         attribute shortDescription : String;
         attribute description : String;
         attribute rationale : String;
         attribute sourceReference : String;
+        attribute status : ElementStatusKind;
+        attribute modeKind : String;
+        attribute entryCondition : String;
+        attribute exitCondition : String;
+        attribute modePurpose : String;
     }
 
     part def Citation specializes MemoPart {

package/src/core/consistency_rules/consistency_rules.sysml

@@ -11,7 +11,7 @@ package memo_core_consistency_rules {
     // 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;
+    abstract constraint def MemoConsistencyRule :> MemoConstraint;
 
     part def ConsistencyRule specializes MemoPart {
         attribute appliesTo : String;

package/src/core/dimensions/dimensions.sysml

@@ -39,7 +39,19 @@ package memo_core_dimensions {
 
     // Editorial status of the model element itself (distinct from the
     // lifecycle of the thing the element describes).
+    // This is the ONE status vocabulary in MEMO: every element carries
+    // `status : ElementStatusKind`, whatever its metaclass. The former
+    // per-family variants (RequirementStatusKind, LinkStatusKind,
+    // MemoNeed::needStatus) are gone — three overlapping status dropdowns on
+    // one element was cognitive load, not precision.
+    //
+    // The V&V states the requirement variant carried (implemented, verified,
+    // validated) are deliberately NOT here: they are facts about links, not
+    // editorial states. An element is implemented when a Realizes link exists,
+    // verified when VerifiedBy does, validated when Validates does. Duplicating
+    // them as an attribute lets the attribute disagree with the graph.
     enum def ElementStatusKind {
+        enum proposed;
         enum draft;
         enum inReview;
         enum approved;

package/src/core/enumerations/memo_enumerations.sysml

@@ -27,14 +27,6 @@ package memo_core_enumerations {
         enum medium;
         enum low;
     }
-    enum def RequirementStatusKind {
-        enum draft;
-        enum approved;
-        enum implemented;
-        enum verified;
-        enum validated;
-        enum retired;
-    }
     enum def RequirementNotationKind {
         enum freeText;
         enum ears;
@@ -68,6 +60,31 @@ package memo_core_enumerations {
         enum mechanical;
         enum fluidic;
     }
+    // AADL (SAE AS5506) port category. Distinct from InterfaceKind, which says
+    // WHAT crosses a port; this says HOW it is delivered, and the difference is
+    // safety-relevant: when a deadline is missed a `data` port overwrites the
+    // last sample and loses it, while an `event` or `eventData` port queues,
+    // and a queue that outgrows its bound is a different failure with a
+    // different mitigation. MEMO carried the distinction on items and not on
+    // ports, so neither failure could be argued about at the boundary where it
+    // happens.
+    enum def PortCategoryKind {
+        doc /* Sampled. The reader sees the most recent value; a missed
+             * deadline drops a sample and never blocks. */
+        enum data;
+        doc /* Queued signal with no payload. A missed deadline grows the
+             * queue; overflow is the failure to bound.
+             *
+             * Quoted because `event` is reserved in SysML v2 — the same
+             * treatment GovernKind's `'use'` already gets. AADL's word is kept
+             * rather than paraphrased to `queued`: it is the term the standard
+             * and every AADL tool use, and a renamed one would not survive a
+             * round trip. */
+        enum 'event';
+        doc /* Queued signal carrying a payload — the queueing semantics of
+             * `event` with the value of `data`. */
+        enum eventData;
+    }
     enum def FlowKind {
         enum information;
         enum command;
@@ -79,6 +96,22 @@ package memo_core_enumerations {
         enum audit;
         enum power;
     }
+    // Direction of a flow across a boundary.
+    //
+    // Track A2 removed this from PORTS: a port usage says `in` / `out` /
+    // `inout` natively, which is the language's own spelling and the only one
+    // a conforming tool reads. The enum survives because four non-port
+    // constructs still carry a direction and none of them is a port, so none
+    // of them can use the keyword:
+    //
+    //   Interface.direction / .directionality   (interface def)
+    //   LogicalConnector.direction              (connection def)
+    //   LogicalExchange.direction               (part def)
+    //   ComponentExchange.direction             (part def)
+    //   OperationalInteraction.direction        (part def)
+    //
+    // Deleting it would have cost those five their direction; the reinvention
+    // was only ever the port case.
     enum def DirectionKind {
         enum input;
         enum output;
@@ -118,6 +151,25 @@ package memo_core_enumerations {
         enum formalProof;
         enum modelChecking;
     }
+    // The submission regime a project targets, and the regimes a standard has
+    // standing in. This is the axis that decides which clauses a project is
+    // required to claim: `required(project)` is the clauses of every standard
+    // whose `appliesToRegime` intersects the regimes the project's
+    // ProjectMethodBinding declares.
+    //
+    // The members are spelled as the regulatory designations themselves rather
+    // than in the lowerCamel convention the rest of this file uses. All 44 DHF
+    // templates already carry these exact strings in `required_for`, and any
+    // transformation between the enum and those arrays would be a hardcoded
+    // spelling map in TypeScript — the one thing the standards axis exists to
+    // avoid. One vocabulary, one spelling, declared here.
+    enum def RegulatoryRegimeKind {
+        enum CE;
+        enum MDR;
+        enum UKCA;
+        enum FDA_510k;
+        enum FDA_PMA;
+    }
     enum def ArtifactKind {
         enum plan;
         enum requirementSpecification;
@@ -205,12 +257,6 @@ package memo_core_enumerations {
         enum deadlineMonotonic;
         enum EDF;
     }
-    enum def LinkStatusKind {
-        enum planned;
-        enum active;
-        enum verified;
-        enum obsolete;
-    }
     enum def BehaviorPropertyKind {
         enum stateInvariant;
         enum transitionRule;