@memoarchitect/ontology 0.6.5 → 0.8.22

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,11 +96,26 @@ 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;
         enum inputOutput;
-        enum bidirectional;
     }
     enum def CriticalityKind {
         enum low;
@@ -119,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;
@@ -192,11 +243,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;
@@ -206,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;
@@ -264,6 +309,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 +405,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 +641,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;