@memoarchitect/ontology 0.7.0 → 0.8.24

package/src/rules/closure/closure_rules.sysml

@@ -10,7 +10,7 @@ package memo_rules_closure {
     // ─── Risk Layer Rules ────────────────────────────────────────────────
 
     constraint def HazardMitigationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-001";
+        attribute :>> id = "CR-MED-001";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
@@ -20,7 +20,7 @@ package memo_rules_closure {
     }
 
     constraint def HazardSeverityRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-002";
+        attribute :>> id = "CR-MED-002";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::error;
@@ -30,7 +30,7 @@ package memo_rules_closure {
     }
 
     constraint def RiskControlVerificationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-003";
+        attribute :>> id = "CR-MED-003";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "RiskControlMeasure";
         attribute severity = RuleSeverityKind::error;
@@ -40,7 +40,7 @@ package memo_rules_closure {
     }
 
     constraint def InitialRiskMatrixRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-004";
+        attribute :>> id = "CR-MED-004";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Risk";
         attribute severity = RuleSeverityKind::warning;
@@ -52,7 +52,7 @@ package memo_rules_closure {
     // ─── Requirements Layer Rules ────────────────────────────────────────
 
     constraint def SysReqTraceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-010";
+        attribute :>> id = "CR-MED-010";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::error;
@@ -62,7 +62,7 @@ package memo_rules_closure {
     }
 
     constraint def SwReqTraceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-011";
+        attribute :>> id = "CR-MED-011";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=software]";
         attribute severity = RuleSeverityKind::error;
@@ -80,7 +80,7 @@ package memo_rules_closure {
     // ─── Architecture Layer Rules ────────────────────────────────────────
 
     constraint def SwComponentSafetyClassRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-020";
+        attribute :>> id = "CR-MED-020";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
@@ -90,7 +90,7 @@ package memo_rules_closure {
     }
 
     constraint def SwComponentReqRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-021";
+        attribute :>> id = "CR-MED-021";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::warning;
@@ -100,7 +100,7 @@ package memo_rules_closure {
     }
 
     constraint def LogicalFunctionAllocationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-022";
+        attribute :>> id = "CR-MED-022";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SystemFunction";
         attribute severity = RuleSeverityKind::warning;
@@ -112,7 +112,7 @@ package memo_rules_closure {
     // ─── Verification Layer Rules ────────────────────────────────────────
 
     constraint def VerificationCaseMethodRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-030";
+        attribute :>> id = "CR-MED-030";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
@@ -122,7 +122,7 @@ package memo_rules_closure {
     }
 
     constraint def VerificationCaseTargetRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-031";
+        attribute :>> id = "CR-MED-031";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::error;
@@ -132,7 +132,7 @@ package memo_rules_closure {
     }
 
     constraint def EvidenceProductionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-032";
+        attribute :>> id = "CR-MED-032";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "VerificationCase";
         attribute severity = RuleSeverityKind::warning;
@@ -144,7 +144,7 @@ package memo_rules_closure {
     // ─── Cybersecurity Layer Rules ───────────────────────────────────────
 
     constraint def ThreatMitigationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-040";
+        attribute :>> id = "CR-MED-040";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Threat";
         attribute severity = RuleSeverityKind::error;
@@ -154,7 +154,7 @@ package memo_rules_closure {
     }
 
     constraint def AssetThreatLinkRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-041";
+        attribute :>> id = "CR-MED-041";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "CybersecurityAsset";
         attribute severity = RuleSeverityKind::warning;
@@ -166,7 +166,7 @@ package memo_rules_closure {
     // ─── Interface Rules ─────────────────────────────────────────────────
 
     constraint def LogicalInterfaceDirectionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-050";
+        attribute :>> id = "CR-MED-050";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Interface";
         attribute severity = RuleSeverityKind::error;
@@ -178,7 +178,7 @@ package memo_rules_closure {
     // ─── Conditional Rules ───────────────────────────────────────────────
 
     constraint def SafetyClassCVerificationRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-101";
+        attribute :>> id = "CR-MED-101";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::error;
@@ -203,7 +203,7 @@ package memo_rules_closure {
     // triggers. Chrome must be DECLARED `decoration`; an element left
     // unclassified fails rather than passing as scenery.
     constraint def UiElementDesignRecordRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-110";
+        attribute :>> id = "CR-MED-110";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::error;
@@ -217,7 +217,7 @@ package memo_rules_closure {
     // The interactive-form restriction lives in the predicate because it spans
     // several enum values.
     constraint def ControlInvokesFunctionRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-111";
+        attribute :>> id = "CR-MED-111";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
@@ -230,7 +230,7 @@ package memo_rules_closure {
     // unconfirmed machine guess must never reach a design review looking like
     // an engineering decision.
     constraint def BoundsDetectionConfirmedRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-112";
+        attribute :>> id = "CR-MED-112";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "UIElement";
         attribute severity = RuleSeverityKind::warning;
@@ -242,7 +242,7 @@ package memo_rules_closure {
     // A screenshot with no build behind it is undated design intent, not
     // evidence of what the device does.
     constraint def ScreenCaptureProvenanceRule :> MemoConsistencyRule {
-        attribute id = "CR-MED-113";
+        attribute :>> id = "CR-MED-113";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "ScreenCapture";
         attribute severity = RuleSeverityKind::error;

package/src/rules/crosslayer/cross_layer_rules.sysml

@@ -7,7 +7,7 @@ package memo_rules_crosslayer {
     private import memo_core_enumerations::*;
 
     constraint def RiskToReqTraceRule :> MemoConsistencyRule {
-        attribute id = "XL-001";
+        attribute :>> id = "XL-001";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::warning;
@@ -17,7 +17,7 @@ package memo_rules_crosslayer {
     }
 
     constraint def ReqToArchTraceRule :> MemoConsistencyRule {
-        attribute id = "XL-002";
+        attribute :>> id = "XL-002";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Requirement[requirementKind=system]";
         attribute severity = RuleSeverityKind::warning;

package/src/rules/ontology/ontology_invariants.sysml

@@ -12,7 +12,7 @@ package memo_rules_ontology {
     // ─── Structure ───────────────────────────────────────────────────────
 
     constraint def ContainmentAcyclicRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-001";
+        attribute :>> id = "CR-ONT-001";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "Model";
         attribute severity = RuleSeverityKind::error;
@@ -21,7 +21,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def NestedPartConnectedRule :> MemoConsistencyRule {
-        attribute id = "AR-IBD-001";
+        attribute :>> id = "AR-IBD-001";
         attribute tailoring = RuleTailoringKind::invariant;
         // Internal-block connectivity is a structural-architecture concern, so
         // the subject is the structural component — not every MemoPart. UI
@@ -44,7 +44,7 @@ package memo_rules_ontology {
     // ─── Deployment and realization ──────────────────────────────────────
 
     constraint def RuntimeTracesToModuleRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-011";
+        attribute :>> id = "CR-ONT-011";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "SoftwareComponent";
         attribute severity = RuleSeverityKind::warning;
@@ -53,7 +53,7 @@ package memo_rules_ontology {
         constraint { true }
     }
     constraint def PatientContactCharacterizedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-032";
+        attribute :>> id = "CR-ONT-032";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "PhysicalComponent";
         attribute severity = RuleSeverityKind::error;
@@ -65,25 +65,25 @@ package memo_rules_ontology {
     // ─── Assurance coverage ──────────────────────────────────────────────
 
     constraint def SafetyCriticalFunctionVerifiedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-040";
+        attribute :>> id = "CR-ONT-040";
         attribute tailoring = RuleTailoringKind::invariant;
-        attribute appliesTo = "SystemFunction";
+        attribute appliesTo = "MemoFunction";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Safety-critical functions (criticality high or catastrophic) must trace to at least one verification case.";
         attribute predicateExpression = "not(criticality == 'high' or criticality == 'catastrophic') or verifiedBy->size() >= 1";
         constraint { true }
     }
     constraint def CriticalTaskValidatedRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-041";
+        attribute :>> id = "CR-ONT-041";
         attribute tailoring = RuleTailoringKind::invariant;
-        attribute appliesTo = "UserTask[criticality=high]";
+        attribute appliesTo = "OperativeAction[criticality=high]";
         attribute severity = RuleSeverityKind::error;
         attribute rationaleText = "Critical tasks (criticality high or catastrophic) must trace to usability validation (FDA HF guidance; IEC 62366-1 summative evaluation).";
         attribute predicateExpression = "not(criticality == 'high' or criticality == 'catastrophic') or validates->size() >= 1";
         constraint { true }
     }
     constraint def UseErrorTracesToHazardRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-042";
+        attribute :>> id = "CR-ONT-042";
         attribute tailoring = RuleTailoringKind::invariant;
         attribute appliesTo = "UseError";
         attribute severity = RuleSeverityKind::warning;
@@ -91,10 +91,222 @@ package memo_rules_ontology {
         attribute predicateExpression = "not(severity == 'serious' or severity == 'critical' or severity == 'catastrophic') or causes->size() >= 1 or tracesRisk->size() >= 1";
         constraint { true }
     }
+    // ─── Relation end conformance (Track A0) ─────────────────────────────
+    //
+    // These rules carry the constraints that `connection def` end TYPES used to
+    // carry in memo_core_relationships. The types had to go: KerML forbids a
+    // port or a behaviour from specializing a part-based type, so a
+    // `MemoPart`-typed end forced every endpoint to be a part — which is why
+    // ports are part defs, why a function is a part with its behaviour stapled
+    // on, and why `allocate <function> to <actor>` is rejected. See the Track A0
+    // note at the top of memo_core_relationships.
+    //
+    // Each rule states what its end stated, in the one vocabulary that survives
+    // the metaclass split:
+    //
+    //   * `conformsTo(Base)` — SysML specialization against a MEMO base. This is
+    //     the part the end type expressed, and it still works within a metaclass.
+    //   * `construct == 'action' | 'port' | 'state' | …` — the SysML METACLASS.
+    //     No MEMO base can say this, because the bases are per-metaclass by
+    //     construction; a type-based end could only ever admit one of them.
+    //
+    // Several of these are WIDER than the end they replace, and deliberately so:
+    // the ends were being violated by content that already shipped. `composes`
+    // was typed MemoPart/MemoPart and links StateMachine (a state def) to
+    // OperativeAction (an action def); `verifiedBy`'s source was typed MemoPart and
+    // most of its sources are requirement defs; `precedes` was typed
+    // a part-only type and joins OperativeAction to OperativeAction.
+    // A rule that reproduced the old type exactly would have failed on the
+    // flagship example on the day it landed. What each rule asserts is the
+    // constraint the end MEANT, stated so it can be checked.
+    //
+    // Subject scope is `Model`, following CR-ONT-001: a statement about the ends
+    // of a relation quantifies over its LINKS, not over elements of one kind, so
+    // no per-element subject can reach it. The cost is that a violation names
+    // the rule and not the offending link; the rationale text names the relation
+    // and the admissible types so the report is still actionable.
+
+    constraint def SatisfiedBySourceKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-060";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Only a requirement or a need is satisfied by something. The source end of SatisfiedBy must conform to MemoRequirementElement.";
+        attribute predicateExpression = "sourcesOf(satisfiedBy)->forAll(conformsTo(MemoRequirementElement))";
+        constraint { true }
+    }
+    constraint def SatisfiedByTargetKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-061";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A requirement is satisfied by a designed part, a behaviour, or a port. Never by another requirement or by a document.";
+        attribute predicateExpression = "targetsOf(satisfiedBy)->forAll(conformsTo(MemoPart) or construct == 'action' or construct == 'port')";
+        constraint { true }
+    }
+    constraint def VerifiedByTargetKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-062";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A verification case verifies a requirement, a risk control, an architecture element, a behaviour, or a port — something a test can be run against. Not a view, not an evidence record.";
+        attribute predicateExpression = "sourcesOf(verifiedBy)->forAll(conformsTo(MemoPart) or construct == 'requirement' or construct == 'action' or construct == 'port')";
+        constraint { true }
+    }
+    constraint def AllocatedToSourceKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-063";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Allocation runs from a function or a behaviour to where it runs. The source end of AllocatedTo is a part or an action.";
+        attribute predicateExpression = "sourcesOf(allocatedTo)->forAll(conformsTo(MemoPart) or construct == 'action')";
+        constraint { true }
+    }
+    constraint def AllocatedToTargetKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-064";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A function is allocated to a part — including a system or actor — as ARCADIA System Analysis requires.";
+        attribute predicateExpression = "targetsOf(allocatedTo)->forAll(conformsTo(MemoPart))";
+        constraint { true }
+    }
+    constraint def ComposesParentKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-065";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A whole in a decomposition is a part, a behaviour, or a state machine. A requirement does not compose anything.";
+        attribute predicateExpression = "sourcesOf(composes)->forAll(conformsTo(MemoPart) or construct == 'action' or construct == 'state')";
+        constraint { true }
+    }
+    constraint def ComposesChildKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-066";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A part in a decomposition is a part, a behaviour, a state, or a port — a component owns its ports, and a workflow owns its steps.";
+        attribute predicateExpression = "targetsOf(composes)->forAll(conformsTo(MemoPart) or construct == 'action' or construct == 'state' or construct == 'port')";
+        constraint { true }
+    }
+    constraint def PrecedesEndKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-067";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "Precedence orders things that happen: parts or behaviours, at both ends.";
+        attribute predicateExpression = "sourcesOf(precedes)->forAll(conformsTo(MemoPart) or construct == 'action') and targetsOf(precedes)->forAll(conformsTo(MemoPart) or construct == 'action')";
+        constraint { true }
+    }
+    constraint def PerformsPerformerKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-068";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A performer is an operational entity, an actor, or a system action — a part or a behaviour. The end's own documentation said 'or system action' while its MemoPart type forbade one.";
+        attribute predicateExpression = "sourcesOf(performs)->forAll(conformsTo(MemoPart) or construct == 'action')";
+        constraint { true }
+    }
+    constraint def EnablesEnablerKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-069";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "An enabling system or function enables a workflow: the enabling end is a part or a behaviour.";
+        attribute predicateExpression = "sourcesOf(enables)->forAll(conformsTo(MemoPart) or construct == 'action')";
+        constraint { true }
+    }
+    constraint def BindsToInterfaceEndKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-070";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A port binds to an interface. The bound end is an interface definition, which the former InterfaceElement-typed end could not hold at all — Interface specializes MemoInterface, an interface def, not a part.";
+        attribute predicateExpression = "sourcesOf(bindsToInterface)->forAll(conformsTo(InterfaceElement) or construct == 'port') and targetsOf(bindsToInterface)->forAll(conformsTo(InterfaceElement) or construct == 'interface' or construct == 'port')";
+        constraint { true }
+    }
+    constraint def CrossesTrustBoundaryEndKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-071";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "Model";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A boundary is a boundary element or a port; what crosses it is an asset or an exchange item.";
+        attribute predicateExpression = "sourcesOf(crossesTrustBoundary)->forAll(conformsTo(InterfaceElement) or construct == 'port') and targetsOf(crossesTrustBoundary)->forAll(conformsTo(MemoPart) or construct == 'item')";
+        constraint { true }
+    }
+
+    // CR-ONT-002's replacement. ComponentExchange's endpoints are `ref`
+    // features, not links, and the builder projects them as element-ID STRINGS
+    // in the attribute map (a §13.3 string pseudo-reference) — so they cannot be
+    // reached with sourcesOf/targetsOf. They are resolved here by looking the id
+    // up in the kind extent, which is the same statement made the long way.
+    constraint def ComponentExchangeSourceEndpointKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-072";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "ComponentExchange";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "An exchange starts at a component or at a boundary port. Stating it as a rule is what let the endpoint refs stop being MemoPart-typed, which is what lets PhysicalPort and SoftwarePort become port defs.";
+        attribute predicateExpression = "attributes.sourceEndpoint == '' or allOfKind('MemoPart')->exists(id == subject.attributes.sourceEndpoint) or allOfKind('InterfaceElement')->exists(id == subject.attributes.sourceEndpoint) or allOfKind('MemoPort')->exists(id == subject.attributes.sourceEndpoint)";
+        constraint { true }
+    }
+    constraint def ComponentExchangeTargetEndpointKindRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-073";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "ComponentExchange";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "An exchange ends at a component or at a boundary port, on the same grounds as CR-ONT-072.";
+        attribute predicateExpression = "attributes.targetEndpoint == '' or allOfKind('MemoPart')->exists(id == subject.attributes.targetEndpoint) or allOfKind('InterfaceElement')->exists(id == subject.attributes.targetEndpoint) or allOfKind('MemoPort')->exists(id == subject.attributes.targetEndpoint)";
+        constraint { true }
+    }
+
+    // ─── The functional chain ────────────────────────────────────────────
+    //
+    // What makes ComponentFunction a definition of its own rather than an enum
+    // member on SystemFunction. An enum value cannot change a multiplicity, and
+    // "answerable to exactly one component" is the whole content of the concept.
+
+    constraint def ComponentFunctionAllocatedRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-074";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "ComponentFunction";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "A component function is the responsibility of exactly one component, and AllocatedTo is what names it. A component function allocated nowhere is a responsibility nobody has accepted; one allocated twice is a responsibility nobody owns. A system-level responsibility with no single owner is a SystemFunction, which allows that.";
+        attribute predicateExpression = "allocatedTo->size() == 1";
+        constraint { true }
+    }
+    constraint def FunctionDecomposesIntoFunctionsRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-075";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "MemoFunction";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "The functional chain decomposes functions into functions. A function composed of a component, or owned by one, is confusing allocation with decomposition — the component is named by AllocatedTo, never by Composes.";
+        attribute predicateExpression = "composes->forAll(conformsTo(MemoFunction))";
+        constraint { true }
+    }
+
+    // Track A3. The flow is the edge; the exchange part carries the budget and
+    // assurance attributes. The two halves are bound by a SHARED NAME — the flow
+    // usage is named with its exchange — and this is what makes that binding a
+    // checked fact rather than a convention someone can quietly break.
+    //
+    // It needs `linksOf`, because the question is about a link's IDENTITY, not
+    // about what sits at its ends: `sourcesOf`/`targetsOf` yield the elements at
+    // the ends and can never answer it. Naming the flow is what the grammar's
+    // restored FlowDeclaration name makes possible at all.
+    constraint def ExchangeHasFlowRule :> MemoConsistencyRule {
+        attribute :>> id = "CR-ONT-076";
+        attribute tailoring = RuleTailoringKind::invariant;
+        attribute appliesTo = "ComponentExchange";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "An exchange states that something crosses a boundary, which is an EDGE, and the edge is a native flow. The part def exists for the budget and assurance attributes a reader has to find from the edge, so the two are named alike and this rule holds them together. An exchange with no flow is a budget attached to nothing.";
+        attribute predicateExpression = "linksOf(flow)->exists(id == subject.id)";
+        constraint { true }
+    }
+
     constraint def AlternateScenarioHasBaseRule :> MemoConsistencyRule {
-        attribute id = "CR-ONT-043";
+        attribute :>> id = "CR-ONT-043";
         attribute tailoring = RuleTailoringKind::invariant;
-        attribute appliesTo = "MemoScenario";
+        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 != ''";

package/src/rules/quantitative/quantitative_rules.sysml

@@ -7,7 +7,7 @@ package memo_rules_quantitative {
     private import memo_core_enumerations::*;
 
     constraint def HazardMaxControlsRule :> MemoConsistencyRule {
-        attribute id = "QT-001";
+        attribute :>> id = "QT-001";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "Hazard";
         attribute severity = RuleSeverityKind::info;
@@ -17,7 +17,7 @@ package memo_rules_quantitative {
     }
 
     constraint def SwComponentMaxInterfacesRule :> MemoConsistencyRule {
-        attribute id = "QT-002";
+        attribute :>> id = "QT-002";
         attribute tailoring = RuleTailoringKind::assurance;
         attribute appliesTo = "SoftwareModule";
         attribute severity = RuleSeverityKind::info;