@memoarchitect/ontology 0.4.4

package/src/rules/coverage/coverage_rules.sysml

@@ -0,0 +1,258 @@
+// C2 coverage rule packs per regulatory standard — Epic EE-3.
+//
+// Coverage rules assert model-level *existence* ("the model must contain at least
+// one X for standard S"). Existence over the whole model is not a single-subject
+// boolean predicate, so it has no `constraint { … }` body. The legacy
+// `predicate="coverageCheck"` parts were likewise never evaluated by the rule engine
+// (toClosureRule returned undefined for coverageCheck), so they produced no
+// violations — parity is preserved by keeping these as metadata-only constraint defs.
+//
+// Each rule retains its standard / clause / coverageTarget metadata so the coverage
+// catalog and DHF traceability stay intact; the constraint loader skips defs with no
+// require/assert body, so none of these fire. Model-level coverage is reported by the
+// completeness tooling, not the per-subject constraint evaluator. The proprietary
+// `predicate="…"` attribute pattern is removed per EE-3.
+package memo_rules_coverage {
+    private import ScalarValues::*;
+
+    private import memo_core_consistency_rules::*;
+    private import memo_core_enumerations::*;
+
+    // ─── ISO 14971: Risk Management ──────────────────────────────────────
+
+    constraint def iso14971HazardCoverage {
+        attribute id = "COV-14971-001";
+        attribute appliesTo = "Hazard";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "ISO 14971 clause 5.4 requires hazard identification.";
+        attribute standardReference = "ISO 14971";
+        attribute clause = "5.4";
+        attribute coverageTarget = "Hazard";
+    }
+
+    constraint def iso14971RiskMatrixCoverage {
+        attribute id = "COV-14971-002";
+        attribute appliesTo = "RiskMatrix";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "ISO 14971 clause 5.5 requires risk estimation and evaluation criteria.";
+        attribute standardReference = "ISO 14971";
+        attribute clause = "5.5";
+        attribute coverageTarget = "RiskMatrix";
+    }
+
+    constraint def iso14971ResidualRiskCoverage {
+        attribute id = "COV-14971-003";
+        attribute appliesTo = "OverallResidualRiskEvaluation";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "ISO 14971 clause 8 requires overall residual risk evaluation.";
+        attribute standardReference = "ISO 14971";
+        attribute clause = "8";
+        attribute coverageTarget = "OverallResidualRiskEvaluation";
+    }
+
+    // ─── IEC 62304: Software Lifecycle ───────────────────────────────────
+
+    constraint def iec62304SwArchCoverage {
+        attribute id = "COV-62304-001";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "IEC 62304 clause 5.3 requires software architecture.";
+        attribute standardReference = "IEC 62304";
+        attribute clause = "5.3";
+        attribute coverageTarget = "SoftwareComponent";
+    }
+
+    constraint def iec62304SwReqCoverage {
+        attribute id = "COV-62304-002";
+        attribute appliesTo = "SoftwareRequirement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "IEC 62304 clause 5.2 requires software requirements specification.";
+        attribute standardReference = "IEC 62304";
+        attribute clause = "5.2";
+        attribute coverageTarget = "SoftwareRequirement";
+    }
+
+    // ─── FDA 21 CFR 820: Quality System ──────────────────────────────────
+
+    constraint def fda820DesignInputCoverage {
+        attribute id = "COV-820-001";
+        attribute appliesTo = "SystemRequirement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "21 CFR 820.30(c) requires design inputs including requirements.";
+        attribute standardReference = "FDA 21 CFR 820";
+        attribute clause = "820.30(c)";
+        attribute coverageTarget = "SystemRequirement";
+    }
+
+    constraint def fda820DesignVerificationCoverage {
+        attribute id = "COV-820-002";
+        attribute appliesTo = "VerificationCase";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "21 CFR 820.30(f) requires design verification.";
+        attribute standardReference = "FDA 21 CFR 820";
+        attribute clause = "820.30(f)";
+        attribute coverageTarget = "VerificationCase";
+    }
+
+    // ─── ISO 13485: Quality Management ───────────────────────────────────
+
+    constraint def iso13485StakeholderNeedCoverage {
+        attribute id = "COV-13485-001";
+        attribute appliesTo = "StakeholderNeed";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "ISO 13485 clause 7.2 requires determination of customer requirements.";
+        attribute standardReference = "ISO 13485";
+        attribute clause = "7.2";
+        attribute coverageTarget = "StakeholderNeed";
+    }
+
+    // ─── ISO 14155: Clinical Investigations ──────────────────────────────
+
+    constraint def iso14155UseContextCoverage {
+        attribute id = "COV-14155-001";
+        attribute appliesTo = "UseContext";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "ISO 14155 requires definition of clinical investigation context.";
+        attribute standardReference = "ISO 14155";
+        attribute clause = "6";
+        attribute coverageTarget = "UseContext";
+    }
+
+    // ─── FDA Cybersecurity Guidance ──────────────────────────────────────
+
+    constraint def fdaCyberThreatCoverage {
+        attribute id = "COV-CYBER-001";
+        attribute appliesTo = "Threat";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires threat modeling.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.A";
+        attribute coverageTarget = "Threat";
+    }
+
+    constraint def fdaCyberAssetCoverage {
+        attribute id = "COV-CYBER-002";
+        attribute appliesTo = "CybersecurityAsset";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires asset identification.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.A";
+        attribute coverageTarget = "CybersecurityAsset";
+    }
+
+    constraint def fdaCyberVulnerabilityCoverage {
+        attribute id = "COV-CYBER-003";
+        attribute appliesTo = "Vulnerability";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires vulnerability analysis.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.B";
+        attribute coverageTarget = "Vulnerability";
+    }
+
+    constraint def fdaCyberTrustBoundaryCoverage {
+        attribute id = "COV-CYBER-004";
+        attribute appliesTo = "TrustBoundary";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires trust boundary identification.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.A";
+        attribute coverageTarget = "TrustBoundary";
+    }
+
+    constraint def fdaCyberThreatScenarioCoverage {
+        attribute id = "COV-CYBER-005";
+        attribute appliesTo = "ThreatScenario";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires threat scenario analysis.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.A";
+        attribute coverageTarget = "ThreatScenario";
+    }
+
+    constraint def fdaCyberMitigationCoverage {
+        attribute id = "COV-CYBER-006";
+        attribute appliesTo = "CyberMitigation";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires risk mitigation.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.C";
+        attribute coverageTarget = "CyberMitigation";
+    }
+
+    constraint def fdaCyberRiskCoverage {
+        attribute id = "COV-CYBER-007";
+        attribute appliesTo = "CyberRisk";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires cyber risk assessment.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.B";
+        attribute coverageTarget = "CyberRisk";
+    }
+
+    constraint def fdaCyberHazardCoverage {
+        attribute id = "COV-CYBER-008";
+        attribute appliesTo = "CyberHazard";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires cyber-safety hazard mapping.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.B";
+        attribute coverageTarget = "CyberHazard";
+    }
+
+    constraint def fdaCyberSecurityReqCoverage {
+        attribute id = "COV-CYBER-009";
+        attribute appliesTo = "SecurityRequirement";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "FDA cybersecurity guidance requires security requirements derivation.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.C";
+        attribute coverageTarget = "SecurityRequirement";
+    }
+
+    constraint def fdaCyberVerificationCoverage {
+        attribute id = "COV-CYBER-010";
+        attribute appliesTo = "VerificationCase";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "FDA cybersecurity guidance requires security testing and verification.";
+        attribute standardReference = "FDA Cybersecurity";
+        attribute clause = "V.D";
+        attribute coverageTarget = "VerificationCase";
+    }
+
+    // ─── IEC 62366: Usability Engineering ────────────────────────────────
+
+    constraint def iec62366ActorCoverage {
+        attribute id = "COV-62366-001";
+        attribute appliesTo = "Actor";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "IEC 62366 clause 5.1 requires user profile specification.";
+        attribute standardReference = "IEC 62366";
+        attribute clause = "5.1";
+        attribute coverageTarget = "Actor";
+    }
+
+    // ─── IEC 60601-1: General Safety ─────────────────────────────────────
+
+    constraint def iec60601HarmCoverage {
+        attribute id = "COV-60601-001";
+        attribute appliesTo = "Harm";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "IEC 60601-1 clause 4.2 requires identification of hazards and harms.";
+        attribute standardReference = "IEC 60601-1";
+        attribute clause = "4.2";
+        attribute coverageTarget = "Harm";
+    }
+
+    // ─── IEC 82304-1: Health Software ────────────────────────────────────
+
+    constraint def iec82304SwSystemCoverage {
+        attribute id = "COV-82304-001";
+        attribute appliesTo = "SoftwareSystem";
+        attribute severity = RuleSeverityKind::error;
+        attribute rationaleText = "IEC 82304-1 requires health software product definition.";
+        attribute standardReference = "IEC 82304-1";
+        attribute clause = "6.1";
+        attribute coverageTarget = "SoftwareSystem";
+    }
+}

package/src/rules/crosslayer/cross_layer_rules.sysml

@@ -0,0 +1,38 @@
+// C4 cross-layer rule pack — native KerML constraints (Epic EE-3).
+// Traceability between architecture layers, migrated from ConsistencyRule
+// predicate-attribute parts to native `constraint def` bodies.
+package memo_rules_crosslayer {
+    private import ScalarValues::*;
+
+    private import memo_core_consistency_rules::*;
+    private import memo_core_enumerations::*;
+
+    constraint def riskToReqTraceRule {
+        attribute id = "XL-001";
+        attribute appliesTo = "Hazard";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Risk-requirement traceability required for regulatory submissions.";
+        attribute predicateExpression = "derivesFrom->size() >= 1";
+        constraint { true }
+    }
+
+    constraint def reqToArchTraceRule {
+        attribute id = "XL-002";
+        attribute appliesTo = "SystemRequirement";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Requirements-to-architecture traceability per IEC 62304.";
+        attribute predicateExpression = "satisfiedBy->size() >= 1";
+        constraint { true }
+    }
+
+    // XL-003 had minCount=0 (advisory only), so the native form is vacuously true
+    // (size >= 0). Retained for metadata/rationale parity; flags nothing.
+    constraint def cyberToSafetyTraceRule {
+        attribute id = "XL-003";
+        attribute appliesTo = "CyberHazard";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "FDA cybersecurity guidance requires linking cybersecurity to patient safety.";
+        attribute predicateExpression = "impactsSafety->size() >= 0";
+        constraint { true }
+    }
+}

package/src/rules/lifecycle/lifecycle_rules.sysml

@@ -0,0 +1,41 @@
+// C3 lifecycle rule pack — Epic EE-3.
+// These rules express lifecycle-stage *ordering* (requirements before architecture,
+// risk before verification, evidence after verification). Ordering across the whole
+// model is not a single-subject boolean predicate, so it has no `require constraint`
+// body — and the legacy parts never enforced anything either (they carried
+// predicate=requireRelationship with no relationshipType, so they matched nothing).
+//
+// They are retained here as metadata-only constraint defs (id, subject, rationale)
+// so the catalog and traceability stay intact; the constraint loader skips defs that
+// have no require/assert body, so they evaluate to nothing — exactly as before.
+// The proprietary `predicate="…"` attribute pattern is removed per EE-3.
+package memo_rules_lifecycle {
+    private import ScalarValues::*;
+
+    private import memo_core_consistency_rules::*;
+    private import memo_core_enumerations::*;
+
+    constraint def reqBeforeArchRule {
+        attribute id = "LC-001";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "IEC 62304 requires requirements to precede architecture decomposition.";
+        // Lifecycle ordering — model-level, no single-subject predicate.
+    }
+
+    constraint def riskBeforeVerificationRule {
+        attribute id = "LC-002";
+        attribute appliesTo = "VerificationCase";
+        attribute severity = RuleSeverityKind::warning;
+        attribute rationaleText = "Risk controls drive verification scope per ISO 14971.";
+        // Lifecycle ordering — model-level, no single-subject predicate.
+    }
+
+    constraint def evidenceAfterVerificationRule {
+        attribute id = "LC-003";
+        attribute appliesTo = "Evidence";
+        attribute severity = RuleSeverityKind::info;
+        attribute rationaleText = "Evidence is produced by executing verification — ordering matters for DHF assembly.";
+        // Lifecycle ordering — model-level, no single-subject predicate.
+    }
+}

package/src/rules/quantitative/quantitative_rules.sysml

@@ -0,0 +1,34 @@
+// C5 quantitative rule pack — native KerML constraints (Epic EE-3).
+// Numeric cardinality bounds migrated from cardinalityCheck predicate parts to
+// native `constraint def` bodies. The aggregate ratio rule (QT-003) is a
+// model-level metric, not a single-subject predicate, and is omitted (see note).
+package memo_rules_quantitative {
+    private import ScalarValues::*;
+
+    private import memo_core_consistency_rules::*;
+    private import memo_core_enumerations::*;
+
+    constraint def hazardMaxControlsRule {
+        attribute id = "QT-001";
+        attribute appliesTo = "Hazard";
+        attribute severity = RuleSeverityKind::info;
+        attribute rationaleText = "Excessive controls per hazard suggests the hazard is too broad and should be decomposed.";
+        attribute predicateExpression = "mitigatesHazard->size() >= 0 and mitigatesHazard->size() <= 10";
+        constraint { true }
+    }
+
+    constraint def swComponentMaxInterfacesRule {
+        attribute id = "QT-002";
+        attribute appliesTo = "SoftwareComponent";
+        attribute severity = RuleSeverityKind::info;
+        attribute rationaleText = "High interface count indicates excessive coupling; consider decomposition.";
+        attribute predicateExpression = "threatenedBy->size() >= 0 and threatenedBy->size() <= 8";
+        constraint { true }
+    }
+
+    // QT-003 (RequirementVerificationRatio, "≥80% of requirements verified") is an
+    // aggregate coverage metric over the whole requirement set, not a per-subject
+    // predicate, so it has no `constraint { … }` form. It remains a
+    // model-level metric (completeness / coverage tooling), not a native constraint.
+    // Do not reintroduce a `predicate="coverageCheck"` part for it.
+}

package/src/viewpoints/clinical/clinical_evidence_view.sysml

@@ -0,0 +1,13 @@
+package memo_viewpoints_clinical_clinical_evidence_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+
+                view def MemoClinicalEvidenceView :> MemoDocumentView {
+    attribute :>> viewKind = DocumentViewKind::Clinical;
+    attribute :>> generationRule = "Include use contexts, actors, and clinical evidence supporting the device's intended use, filtered to clinical concern.";
+    attribute :>> outputKind = (ViewOutputKind::documentSection);
+    attribute :>> presentationKind = (PresentationKind::narrativeSection);
+                }
+}

package/src/viewpoints/clinical/clinical_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_clinical_clinical_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part clinicalViewpoint : Viewpoint {
+        attribute :>> id = "VP-CLIN";
+        attribute :>> name = "ClinicalViewpoint";
+        attribute :>> title = "Clinical Viewpoint";
+        attribute :>> shortDescription = "Shows clinical context, users, use environment, and clinical evidence.";
+        attribute :>> longDescription = "Default viewpoint derived from the context and assurance layers for clinical stakeholders — intended use, patient/clinician interaction, clinical evidence, and clinical safety claims.";
+        attribute :>> purpose = "Communicate clinical use context and clinical evidence for the device.";
+        attribute :>> audience = (AudienceKind::clinicalEngineer, AudienceKind::regulatoryEngineer);
+        attribute :>> stage = WorkflowStageKind::context;
+        attribute :>> abstractionLevel = "clinical";
+        attribute :>> outputKind = (ViewOutputKind::documentSection, ViewOutputKind::table);
+        attribute :>> presentationKind = (PresentationKind::narrativeSection);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::clinical);
+        attribute :>> includedLayers = ("context", "assurance");
+        attribute :>> allowedElementKinds = ("Actor", "UseContext", "Evidence");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/context/context_viewpoint.sysml

@@ -0,0 +1,25 @@
+package memo_viewpoints_context_context_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part contextViewpoint : Viewpoint {
+        attribute :>> id = "VP-CTX";
+        attribute :>> name = "ContextViewpoint";
+        attribute :>> title = "System Context Viewpoint";
+        attribute :>> shortDescription = "Shows actors, use context, and system boundary.";
+        attribute :>> longDescription = "Default viewpoint derived from the context layer to communicate who interacts with the device, under which use conditions, and where trust or safety boundaries exist.";
+        attribute :>> purpose = "Communicate operational context and boundaries.";
+        attribute :>> audience = (AudienceKind::systemArchitect);
+        attribute :>> stage = WorkflowStageKind::context;
+        attribute :>> abstractionLevel = "system";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::blockDiagram);
+        attribute :>> concernKinds = (ConcernKind::safety, ConcernKind::interoperability);
+        attribute :>> includedLayers = ("context");
+        attribute :>> allowedElementKinds = ("Actor", "UseContext", "IntendedUse", "OperationalEntity", "TrustBoundary", "LogicalComponent");
+        attribute :>> methodologyReference = ("default-layer-viewpoint");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/context/system_context_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_context_system_context_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_context_context_viewpoint::*;
+
+                view systemContextView : MemoDiagramView {
+                    expose memo_viewpoints_context_system_context_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-CTX-001";
+    attribute :>> name = "SystemContextView";
+    attribute :>> title = "System Context View";
+    attribute :>> shortDescription = "Actors, use context, and system boundary.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::blockDiagram);
+    attribute :>> diagramType = "bdd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include actors, use contexts, and trust boundaries at the system boundary.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-CTX-001";
+        attribute :>> name = "SystemContextQuery";
+        attribute :>> includeElementKinds = ("Actor", "UseContext", "TrustBoundary");
+        attribute :>> includeLayers = ("context");
+        attribute :>> rationaleText = "Auto-populate the system context view from the context layer.";
+    }
+    part :>> viewpointDefinition = contextViewpoint;
+                }
+}

package/src/viewpoints/cybersecurity/cybersecurity_assessment_view.sysml

@@ -0,0 +1,13 @@
+package memo_viewpoints_cybersecurity_cybersecurity_assessment_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+
+                view def MemoCybersecurityAssessmentView :> MemoDocumentView {
+    attribute :>> viewKind = DocumentViewKind::CybersecurityAssessment;
+    attribute :>> generationRule = "Include cyber risks, exploitability, mitigations, security requirements, verification, residual risk, and postmarket evidence references.";
+    attribute :>> outputKind = (ViewOutputKind::documentSection);
+    attribute :>> presentationKind = (PresentationKind::riskTable);
+                }
+}

package/src/viewpoints/cybersecurity/cybersecurity_viewpoint.sysml

@@ -0,0 +1,27 @@
+package memo_viewpoints_cybersecurity_cybersecurity_viewpoint {
+    private import ScalarValues::*;
+
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part cybersecurityViewpoint : Viewpoint {
+        attribute :>> id = "VP-CYB";
+        attribute :>> name = "CybersecurityViewpoint";
+        attribute :>> title = "Cybersecurity Viewpoint";
+        attribute :>> shortDescription = "Shows assets, trust boundaries, threats, vulnerabilities, cyber hazards, cyber risks, and mitigations.";
+        attribute :>> longDescription = "Default viewpoint derived from the cybersecurity layer, using STRIDE-style threat categories by default while allowing safety and privacy impacts to be traced into the broader model.";
+        attribute :>> purpose = "Communicate cybersecurity design, threat analysis, and cyber risk posture.";
+        attribute :>> audience = (AudienceKind::securityEngineer);
+        attribute :>> stage = WorkflowStageKind::risk;
+        attribute :>> abstractionLevel = "analysis";
+        attribute :>> outputKind = (ViewOutputKind::diagram);
+        attribute :>> presentationKind = (PresentationKind::custom);
+        attribute :>> concernKinds = (ConcernKind::cybersecurity, ConcernKind::privacy, ConcernKind::safety);
+        attribute :>> includedLayers = ("cybersecurity", "software_structure", "hardware_structure", "interfaces", "risk", "assurance");
+        attribute :>> allowedElementKinds = ("CybersecurityAsset", "Threat", "Vulnerability", "CyberHazard", "CyberRisk", "CyberMitigation", "SecurityRequirement", "TrustBoundary", "ThreatScenario");
+        attribute :>> allowedRelationshipKinds = ("ThreatenedBy", "Exploits", "RealizedByScenario", "MitigatesVulnerability", "DerivesCyberRequirement", "ImpactsSafety", "CrossesTrustBoundary");
+        attribute :>> methodologyReference = ("stride-default", "fda-cybersecurity-default");
+        attribute :>> documentUsage = ("Secure Product Development", "Threat Model", "Cybersecurity Risk Assessment", "QMSR");
+        attribute :>> userExtensible = true;
+    }
+}

package/src/viewpoints/cybersecurity/threat_model_view.sysml

@@ -0,0 +1,13 @@
+package memo_viewpoints_cybersecurity_threat_model_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+
+                view def MemoCybersecurityThreatModelView :> MemoDocumentView {
+    attribute :>> viewKind = DocumentViewKind::ThreatModel;
+    attribute :>> generationRule = "Include assets, trust boundaries, threat scenarios, vulnerabilities, mitigations, and trace links to safety/privacy concerns.";
+    attribute :>> outputKind = (ViewOutputKind::documentSection);
+    attribute :>> presentationKind = (PresentationKind::narrativeSection);
+                }
+}

package/src/viewpoints/definitions/memo_viewpoint_definitions.sysml

@@ -0,0 +1,82 @@
+package memo_viewpoints_definitions {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+
+    part def Viewpoint specializes DocumentedElement {
+        attribute purpose : String;
+        attribute audience : AudienceKind[*];
+        attribute stage : WorkflowStageKind;
+        attribute abstractionLevel : String;
+        attribute outputKind : ViewOutputKind[*];
+        attribute presentationKind : PresentationKind[*];
+        attribute concernKinds : ConcernKind[*];
+        attribute includedLayers : String[*];
+        attribute allowedElementKinds : String[*];
+        attribute allowedRelationshipKinds : String[*];
+        attribute filterExpression : String;
+        attribute methodologyReference : String[*];
+        attribute extendsViewpointIds : String[*];
+        attribute userExtensible : Boolean;
+    }
+
+    part def ViewRule specializes TraceableElement {
+        attribute elementTypeName : String;
+        attribute relationTypeName : String;
+        attribute strength : RuleStrengthKind;
+        attribute rationaleText : String;
+    }
+
+    part def ViewSelectionQuery specializes TraceableElement {
+        attribute includeElementKinds : String[*];
+        attribute includeRelationshipKinds : String[*];
+        attribute includeLayers : String[*];
+        attribute includeConcerns : ConcernKind[*];
+        attribute includeStatusTags : String[*];
+        attribute selectionExpression : String;
+        attribute rationaleText : String;
+    }
+
+    view def MemoView :> Views::View, DocumentedElement {
+        attribute outputKind : ViewOutputKind[*];
+        attribute presentationKind : PresentationKind[*];
+        attribute filterExpression : String;
+        attribute queryDescription : String;
+        attribute dataSourceDescription : String;
+        attribute autoPopulate : Boolean;
+        part viewpointDefinition : Viewpoint;
+        ref subjectElement : TraceableElement[*];
+        ref exposesElement : TraceableElement[*];
+        ref exposesRelationship : SemanticLink[*];
+        part selectionQuery : ViewSelectionQuery[*];
+    }
+
+    view def MemoDiagramView :> MemoView {
+        attribute viewKind : DiagramViewKind;
+        attribute diagramType : String;
+        attribute layoutHint : String;
+        attribute styleHint : String;
+    }
+
+    view def MemoDocumentBackedView :> MemoView {
+        attribute version : String;
+        attribute lifecycleState : LifecycleStateKind;
+        attribute generationRule : String;
+        attribute marketScope : String;
+    }
+
+    view def MemoDocumentView :> MemoDocumentBackedView {
+        attribute viewKind : DocumentViewKind;
+    }
+
+    part def ViewInclusionRule specializes TraceableElement {
+        attribute includeElementKinds : String[*];
+        attribute includeRelationshipKinds : String[*];
+        attribute includeLayers : String[*];
+        attribute includeConcerns : ConcernKind[*];
+        attribute selectionExpression : String;
+        attribute rationaleText : String;
+    }
+}

package/src/viewpoints/functional/function_allocation_view.sysml

@@ -0,0 +1,29 @@
+package memo_viewpoints_functional_function_allocation_view {
+    private import ScalarValues::*;
+
+                private import memo_viewpoints_definitions::*;
+                private import memo_core_enumerations::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
+
+                view functionAllocationView : MemoDiagramView {
+                    expose memo_viewpoints_functional_function_allocation_view::*;
+                    attribute depth = 2;
+    attribute :>> id = "VIEW-FUNC-002";
+    attribute :>> name = "FunctionAllocationView";
+    attribute :>> title = "Function Allocation View";
+    attribute :>> shortDescription = "Functions allocated to logical components.";
+    attribute :>> outputKind = (ViewOutputKind::diagram);
+    attribute :>> presentationKind = (PresentationKind::blockDiagram);
+    attribute :>> diagramType = "bdd";
+    attribute :>> autoPopulate = true;
+    attribute :>> queryDescription = "Include functions and the logical components they are allocated to.";
+    part :>> selectionQuery {
+        attribute :>> id = "QRY-FUNC-002";
+        attribute :>> name = "FunctionAllocationQuery";
+        attribute :>> includeElementKinds = ("LogicalFunction", "LogicalComponent");
+        attribute :>> includeLayers = ("functions", "logical_structure");
+        attribute :>> rationaleText = "Auto-populate function-to-component allocation from the functions and logical structure layers.";
+    }
+    part :>> viewpointDefinition = functionalViewpoint;
+                }
+}