@memoarchitect/ontology 0.7.0 → 0.8.22

package/src/rules/ontology/ontology_invariants.sysml

@@ -67,7 +67,7 @@ package memo_rules_ontology {
     constraint def SafetyCriticalFunctionVerifiedRule :> MemoConsistencyRule {
         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";
@@ -91,6 +91,218 @@ 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
+    // WorkflowStep (an action def); `verifiedBy`'s source was typed MemoPart and
+    // most of its sources are requirement defs; `precedes` was typed
+    // ArchitectureElement and joins OperationalActivity to OperationalActivity.
+    // 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 thing: an architecture element, an actor, a behaviour, or a port. Never by another requirement or by a document.";
+        attribute predicateExpression = "targetsOf(satisfiedBy)->forAll(conformsTo(ArchitectureElement) or conformsTo(Actor) 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 an architecture element or an action.";
+        attribute predicateExpression = "sourcesOf(allocatedTo)->forAll(conformsTo(ArchitectureElement) 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 an architecture element or to an actor — ARCADIA System Analysis allocates to the system OR to an actor, which the former ArchitectureElement-typed end made impossible.";
+        attribute predicateExpression = "targetsOf(allocatedTo)->forAll(conformsTo(ArchitectureElement) or conformsTo(Actor))";
+        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: architecture elements or behaviours, at both ends.";
+        attribute predicateExpression = "sourcesOf(precedes)->forAll(conformsTo(ArchitectureElement) or construct == 'action') and targetsOf(precedes)->forAll(conformsTo(ArchitectureElement) 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(ArchitectureElement) 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('ArchitectureElement')->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('ArchitectureElement')->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 tailoring = RuleTailoringKind::invariant;

package/src/viewpoints/catalog/memo_viewpoint_catalog.sysml

@@ -34,8 +34,8 @@ package memo_viewpoints_catalog {
         attribute :>> purpose = "Workflow steps, decisions, parallel work, handoffs, and roles.";
         attribute :>> defaultViewKind = DiagramViewKind::actionflow;
     }
-    part vpOperativeScenario : Viewpoint {
-        attribute :>> id = "VP-CAT-005"; attribute :>> name = "OperativeScenarioViewpoint";
+    part vpScenario : Viewpoint {
+        attribute :>> id = "VP-CAT-005"; attribute :>> name = "ScenarioViewpoint";
         attribute :>> purpose = "Selected paths through workflows: variants, conditions, variation points.";
         attribute :>> defaultViewKind = DiagramViewKind::actionflow;
     }
@@ -151,7 +151,7 @@ package memo_viewpoints_catalog {
     }
     // A software sequence diagram is a VIEW conforming to this viewpoint
     // (ISO/IEC/IEEE 42010): it frames the runtime message ordering between
-    // SoftwareComponents realizing a FunctionalScenario. The viewpoint is the
+    // SoftwareComponents realizing a functional MemoScenario. The viewpoint is the
     // reusable spec; the diagram of a specific model is the view.
     part vpSoftwareSequence : Viewpoint {
         attribute :>> id = "VP-CAT-027"; attribute :>> name = "SoftwareSequenceViewpoint";

package/src/viewpoints/clinical/clinical_viewpoint.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_clinical_clinical_viewpoint {
         attribute :>> includedLayers = ("context", "assurance");
         attribute :>> explorerLane = "assurance";
         attribute :>> explorerOrder = 4;
-        attribute :>> allowedElementKinds = ("Actor", "UseContext", "Evidence");
+        attribute :>> allowedElementKinds = ("Actor", "UseContext", "MemoEvidence");
         attribute :>> userExtensible = true;
     }
 }

package/src/viewpoints/context/context_viewpoint.sysml

@@ -29,7 +29,7 @@ package memo_viewpoints_context_context_viewpoint {
         // boundary picture. Projects derive their own verbs from it and are
         // picked up through the specialization closure. The three older
         // relations remain for models authored before it existed.
-        attribute :>> allowedRelationshipKinds = ("InteractsInContext", "InteractsWith", "ExchangesWith", "ConnectsPhysically");
+        attribute :>> allowedRelationshipKinds = ("InteractsInContext", "InteractsWith", "flow", "bind", "connect");
         attribute :>> userExtensible = true;
     }
 }

package/src/viewpoints/cybersecurity/cybersecurity_viewpoint.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_cybersecurity_cybersecurity_viewpoint {
         attribute :>> includedLayers = ("cybersecurity", "software_structure", "hardware_structure", "interfaces", "risk", "assurance");
         attribute :>> explorerLane = "assurance";
         attribute :>> explorerOrder = 3;
-        attribute :>> allowedElementKinds = ("CybersecurityAsset", "Threat", "Vulnerability", "CyberHazard", "CyberRisk", "CyberMitigation", "SecurityRequirement", "TrustBoundary", "ThreatScenario");
+        attribute :>> allowedElementKinds = ("CybersecurityAsset", "Threat", "Vulnerability", "CyberHazard", "CyberRisk", "CyberMitigation", "SecurityRequirement", "TrustBoundary", "MemoScenario[scenarioKind=threat]");
         attribute :>> allowedRelationshipKinds = ("ThreatenedBy", "Exploits", "RealizedByScenario", "Mitigates", "DerivesCyberRequirement", "ImpactsSafety", "CrossesTrustBoundary");
         attribute :>> documentUsage = ("Secure Product Development", "Threat Model", "Cybersecurity Risk Assessment", "QMSR");
         attribute :>> userExtensible = true;

package/src/viewpoints/definitions/memo_viewpoint_definitions.sysml

@@ -1,4 +1,5 @@
 package memo_viewpoints_definitions {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;

package/src/viewpoints/functional/functional_viewpoint.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_functional_functional_viewpoint {
         attribute :>> includedLayers = ("functions");
         attribute :>> explorerLane = "architecture";
         attribute :>> explorerOrder = 2;
-        attribute :>> allowedElementKinds = ("SystemFunction", "FunctionalFlow", "FunctionalFlowStep", "FunctionalScenario", "FunctionalExchange");
+        attribute :>> allowedElementKinds = ("SystemFunction", "ComponentFunction", "FunctionalFlow", "FunctionalFlowStep", "MemoScenario[scenarioKind=functional]", "FunctionalExchange");
         attribute :>> userExtensible = true;
     }
 }

package/src/viewpoints/functional/views/function_allocation_view/function_allocation_view.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_functional_views_function_allocation_view {
     part :>> selectionQuery {
         attribute :>> id = "QRY-FUNC-002";
         attribute :>> name = "FunctionAllocationQuery";
-        attribute :>> includeElementKinds = ("SystemFunction", "LogicalComponent");
+        attribute :>> includeElementKinds = ("SystemFunction", "ComponentFunction", "LogicalComponent");
         attribute :>> includeLayers = ("functions", "logical_structure");
         attribute :>> rationaleText = "Auto-populate function-to-component allocation from the functions and logical structure layers.";
     }

package/src/viewpoints/functional/views/system_functional_tree_view/system_functional_tree_view.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_functional_views_system_functional_tree_view {
     part :>> selectionQuery {
         attribute :>> id = "QRY-FUNC-001";
         attribute :>> name = "SystemFunctionalTreeQuery";
-        attribute :>> includeElementKinds = ("SystemFunction");
+        attribute :>> includeElementKinds = ("SystemFunction", "ComponentFunction");
         attribute :>> includeLayers = ("functions");
         attribute :>> rationaleText = "Auto-populate the functional tree from the functions layer.";
     }

package/src/viewpoints/operational/operational_viewpoint.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_operational_operational_viewpoint {
         attribute :>> includedLayers = ("context", "operational", "system");
         attribute :>> explorerLane = "architecture";
         attribute :>> explorerOrder = 1;
-        attribute :>> allowedElementKinds = ("Actor", "UseContext", "OperationalActivity", "OperativeScenario");
+        attribute :>> allowedElementKinds = ("Actor", "UseContext", "OperationalActivity", "MemoScenario[scenarioKind=operative]");
         attribute :>> userExtensible = true;
     }
 }

package/src/viewpoints/operational/views/use_case_view/use_case_view.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_operational_views_use_case_view {
     part :>> selectionQuery {
         attribute :>> id = "QRY-OPS-001";
         attribute :>> name = "UseCaseQuery";
-        attribute :>> includeElementKinds = ("Actor", "UseContext", "OperativeScenario");
+        attribute :>> includeElementKinds = ("Actor", "UseContext", "MemoScenario[scenarioKind=operative]");
         attribute :>> includeLayers = ("context", "operational");
         attribute :>> rationaleText = "Auto-populate the use case view from the context and operational layers.";
     }

package/src/viewpoints/ui_layout/ui_layout_viewpoint.sysml

@@ -21,7 +21,7 @@ package memo_viewpoints_ui_layout_ui_layout_viewpoint {
         attribute :>> explorerLane = "architecture";
         attribute :>> explorerOrder = 4;
         attribute :>> allowedElementKinds = ("ScreenCapture", "UIElement", "UserInterface");
-        attribute :>> allowedRelationshipKinds = ("CapturesScreen", "NavigatesTo", "Composes", "SatisfiedBy", "ElementTriggersAction");
+        attribute :>> allowedRelationshipKinds = ("CapturesScreen", "NavigatesTo", "Composes", "satisfy", "ElementTriggersAction");
         attribute :>> defaultViewKind = DiagramViewKind::geometry;
         attribute :>> userExtensible = true;
     }

package/src/viewpoints/verification/verification_viewpoint.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_verification_verification_viewpoint {
         attribute :>> includedLayers = ("requirements", "assurance");
         attribute :>> explorerLane = "assurance";
         attribute :>> explorerOrder = 5;
-        attribute :>> allowedElementKinds = ("Requirement", "VerificationCase", "ValidationCase", "Evidence", "TestArtifact");
+        attribute :>> allowedElementKinds = ("Requirement", "VerificationCase", "ValidationCase", "MemoEvidence");
         attribute :>> userExtensible = true;
     }
 }

package/src/viewpoints/verification/views/verification_coverage_view/verification_coverage_view.sysml

@@ -20,7 +20,7 @@ package memo_viewpoints_verification_views_verification_coverage_view {
     part :>> selectionQuery {
         attribute :>> id = "QRY-VER-001";
         attribute :>> name = "VerificationCoverageQuery";
-        attribute :>> includeElementKinds = ("Requirement", "VerificationCase", "ValidationCase", "Evidence");
+        attribute :>> includeElementKinds = ("Requirement", "VerificationCase", "ValidationCase", "MemoEvidence");
         attribute :>> includeLayers = ("requirements", "assurance");
         attribute :>> rationaleText = "Auto-populate V&V coverage from the requirements and assurance layers.";
     }

package/examples/extensions/README.md

@@ -1,16 +0,0 @@
-# Extension examples
-
-An extension is a regular SysML package selected by a MEMO methodology. MEMO
-does not define a separate extension metaclass. `MethodologyDefinition` and
-`ProjectMethodBinding` already accept packages through `includedModule`.
-
-- `template/` is the starting structure for an extension.
-- `clinical/` specializes `OperationalWorkflow` with clinical procedure data.
-
-Extensions specialize or reference base types. They do not redefine
-activities, workflows, architecture elements, relationships, or constraints
-already expressed by the base ontology.
-
-Extension packages remain outside `src/` and outside the `memo::` namespace.
-Projects import an extension package directly and include it in their selected
-methodology.

package/examples/extensions/template/src/extension.sysml

@@ -1,15 +0,0 @@
-// Replace the package name and included module with extension-specific names.
-package memo_extension_template {
-    private import ScalarValues::*;
-    private import memo_methodology_core::*;
-
-    part extensionMethod : MethodologyDefinition {
-        attribute :>> id = "EXT-METH-001";
-        attribute :>> name = "ExtensionMethod";
-        attribute :>> version = "0.1.0";
-        attribute :>> domain = "project extension";
-        attribute :>> description = "Adds a project or domain package to the selected MEMO methodology.";
-        attribute :>> baseMethodName = "MedicalDeviceLightDefault";
-        attribute :>> includedModule = "replace_with_extension_package";
-    }
-}