@memoarchitect/ontology 0.10.9 → 0.11.2

package/src/rules/closure/closure_rules.sysml

@@ -56,7 +56,7 @@ package memo_rules_closure {
     constraint def SysReqTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-010"; }
         attribute tailoring = RuleTailoringKind::assurance;
-        attribute appliesTo = "Requirement[requirementKind=system]";
+        attribute appliesTo = "Requirement[requirementType=system]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Requirements shall be traceable to stakeholder needs per ISO 13485.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
@@ -66,7 +66,7 @@ package memo_rules_closure {
     constraint def SwReqTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-MED-011"; }
         attribute tailoring = RuleTailoringKind::assurance;
-        attribute appliesTo = "Requirement[requirementKind=software]";
+        attribute appliesTo = "Requirement[requirementType=software]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Software requirements derive from system requirements per IEC 62304.";
         attribute predicateExpression = "derivesFrom->size() >= 1";
@@ -111,6 +111,40 @@ package memo_rules_closure {
         constraint { true }
     }
 
+    // A function that no edge reaches is not in the chain. This was a
+    // TypeScript rule (BV-002) applying to every action usage in the model,
+    // which reported a scenario and a flow step as defects for not being
+    // wired like a function. It is declared here instead: scoped by the
+    // ontology to the family it is about, tailorable by a methodology, and
+    // readable next to the rule that requires the allocation.
+    constraint def FunctionInChainRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-023"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute appliesTo = "MemoFunction";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A function participates in the functional chain through a flow or a succession, or through the functions it decomposes into. One that participates in none of them is unreachable behaviour: nothing triggers it and nothing consumes what it produces.";
+        // `downstream` and not a bare `composes`: the relation navigates both
+        // ways, so a bare name would exempt every child on the strength of
+        // having a parent. A decomposed function participates through its
+        // parts; a leaf has to be reached by an edge of its own.
+        attribute predicateExpression = "flow->size() >= 1 or succession->size() >= 1 or downstream(composes)->size() >= 1";
+        constraint { true }
+    }
+
+    // A user need names the user whose need it is. IEC 62366-1's user profile
+    // is typed on the User element — population, impairments, training,
+    // qualification — so the need points at that element rather than restating
+    // any of it in prose, which is what `userPopulationReference` was doing.
+    constraint def UserNeedIdentifiesUserRule :> MemoConsistencyRule {
+        @MemoIdentity { :>> providedId = "CR-MED-024"; }
+        attribute tailoring = RuleTailoringKind::assurance;
+        attribute appliesTo = "Need";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "A user need is a need someone has. Which users a device serves, and what they can be assumed to see, know and do, is the input a usability engineering file is built from (IEC 62366-1 5.1); a need that names no user leaves that input to prose.";
+        attribute predicateExpression = "not(needKind == 'user' or needKind == 'clinicalUser' or needKind == 'patientUser') or heldBy->size() >= 1";
+        constraint { true }
+    }
+
     // ─── Verification Layer Rules ────────────────────────────────────────
 
     constraint def VerificationCaseMethodRule :> MemoConsistencyRule {

package/src/rules/crosslayer/cross_layer_rules.sysml

@@ -21,7 +21,7 @@ package memo_rules_crosslayer {
     constraint def ReqToArchTraceRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "XL-002"; }
         attribute tailoring = RuleTailoringKind::assurance;
-        attribute appliesTo = "Requirement[requirementKind=system]";
+        attribute appliesTo = "Requirement[requirementType=system]";
         attribute severity = RuleSeverityKind::warning;
         attribute rationaleText = "Requirements-to-architecture traceability per IEC 62304.";
         attribute predicateExpression = "satisfiedBy->size() >= 1";

package/src/rules/ontology/ontology_invariants.sysml

@@ -349,13 +349,24 @@ package memo_rules_ontology {
         constraint { true }
     }
 
+    // The predicate here named three features that do not exist — `variantKind`,
+    // `baseScenario`, `variationPoint` — so it could never fail, and a rule that
+    // cannot fail is coverage on paper only. `baseScenario` is the one the
+    // scenario def deliberately refused: "a nominal/alternate pair are scenarios
+    // of the same workflow, distinguished by scenarioKind — no baseScenario
+    // back-ref". The base of an alternate IS the nominal scenario of its
+    // workflow, so the rule asks the containment that already expresses it.
     constraint def AlternateScenarioHasBaseRule :> MemoConsistencyRule {
         @MemoIdentity { :>> providedId = "CR-ONT-043"; }
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "OperativeScenario";
         attribute severity = RuleSeverityKind::error;
-        attribute rationaleText = "Alternate, exception, and recovery scenarios must identify their base scenario or variation point — never duplicate the workflow.";
-        attribute predicateExpression = "not(variantKind == 'alternate' or variantKind == 'exception' or variantKind == 'recovery') or baseScenario->size() == 1 or variationPoint != ''";
+        attribute rationaleText = "An alternate scenario is a variation of a nominal path, so it belongs to a workflow that has one. An alternate with no nominal sibling is either a workflow with no happy path or a scenario filed under the wrong parent.";
+        // A nominal scenario usually says nothing: `nominal` is the default on
+        // the definition, and a default is not written onto every usage. So the
+        // sibling test is "not alternate", and `conformsTo` keeps it from being
+        // satisfied by an ordinary step of the same workflow.
+        attribute predicateExpression = "not(scenarioKind == 'alternate') or composes.composes->exists(conformsTo(OperativeScenario) and scenarioKind != 'alternate')";
         constraint { true }
     }