@xemahq/kernel-contracts 0.1.0

package/src/workflow/lib/canonical-concepts/concepts/change-intent.concepts.ts

@@ -0,0 +1,124 @@
+import { CanonicalConcept, ConceptKind } from '../canonical-concept-registry';
+
+const K = ConceptKind.ChangeIntent;
+
+export const CHANGE_INTENT_CONCEPTS: CanonicalConcept[] = [
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Work Type Roots (top-level classification — maps to RunType) ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'work-type:bootstrap', aliases: ['bootstrap'], kind: K },
+  { key: 'work-type:feature', aliases: ['feature-work'], kind: K },
+  { key: 'work-type:bug_fix', aliases: ['bug-fix-work', 'defect-fix'], kind: K },
+  { key: 'work-type:refactor', aliases: ['refactor-work', 'restructure-work'], kind: K },
+  { key: 'work-type:migration', aliases: ['migration-work', 'substrate-change'], kind: K },
+  { key: 'work-type:investigation', aliases: ['investigation-work', 'analysis-work', 'audit-work'], kind: K },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Build & Create ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'greenfield', aliases: ['greenfield', 'new-project', 'from-scratch', 'brand-new', 'net-new'], kind: K, parents: ['work-type:bootstrap'] },
+  { key: 'feature', aliases: ['feature', 'new-feature', 'enhancement', 'addition', 'feature-request'], kind: K, parents: ['work-type:feature'] },
+  { key: 'prototype', aliases: ['prototype', 'proof-of-concept', 'poc', 'spike', 'experiment', 'mvp'], kind: K, parents: ['work-type:feature'] },
+  { key: 'integration', aliases: ['integration', 'integrate', 'third-party', '3rd-party', 'vendor-integration', 'saas-integration'], kind: K, parents: ['work-type:feature'] },
+  { key: 'api-creation', aliases: ['api-creation', 'new-api', 'api-endpoint', 'new-endpoint'], kind: K, parents: ['work-type:feature'] },
+  { key: 'service-creation', aliases: ['service-creation', 'new-service', 'new-microservice', 'service-bootstrap'], kind: K, parents: ['work-type:feature'] },
+  { key: 'library-creation', aliases: ['library-creation', 'new-library', 'new-package', 'sdk-creation'], kind: K, parents: ['work-type:feature'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Modify & Improve ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'refactor', aliases: ['refactor', 'refactoring', 'restructure', 'rearchitect', 'code-cleanup'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'rewrite', aliases: ['rewrite', 'rewrite-from-scratch', 'rebuild', 'ground-up-rewrite'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'performance-tuning', aliases: ['performance-tuning', 'perf-tuning', 'optimization', 'speed-improvement', 'latency-reduction'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'tech-debt-reduction', aliases: ['tech-debt-reduction', 'tech-debt', 'debt-paydown', 'code-modernization'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'dependency-upgrade', aliases: ['dependency-upgrade', 'dependency-update', 'version-bump', 'package-upgrade', 'library-upgrade'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'framework-upgrade', aliases: ['framework-upgrade', 'major-version-upgrade', 'breaking-upgrade'], kind: K, parents: ['dependency-upgrade', 'work-type:refactor'] },
+  { key: 'config-change', aliases: ['config-change', 'configuration-update', 'env-change', 'settings-change'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'schema-change', aliases: ['schema-change', 'schema-update', 'column-add', 'table-alter', 'migration-script'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'api-versioning', aliases: ['api-versioning', 'version-bump-api', 'new-api-version', 'api-v2'], kind: K, parents: ['work-type:feature'] },
+  { key: 'ui-redesign', aliases: ['ui-redesign', 'ui-overhaul', 'design-refresh', 'ux-improvement'], kind: K, parents: ['work-type:feature'] },
+  { key: 'accessibility-improvement', aliases: ['accessibility-improvement', 'a11y-fix', 'wcag-compliance', 'aria-improvement'], kind: K, parents: ['work-type:feature'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Fix & Repair ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'bugfix', aliases: ['bugfix', 'bug-fix', 'fix', 'hotfix', 'patch', 'defect-fix'], kind: K, parents: ['work-type:bug_fix'] },
+  { key: 'emergency-fix', aliases: ['emergency-fix', 'p0-fix', 'critical-fix', 'production-incident', 'sev-1'], kind: K, parents: ['bugfix', 'work-type:bug_fix'] },
+  { key: 'security-patch', aliases: ['security-patch', 'cve-fix', 'vulnerability-fix', 'security-fix'], kind: K, parents: ['bugfix', 'work-type:bug_fix'] },
+  { key: 'data-fix', aliases: ['data-fix', 'data-repair', 'data-correction', 'data-cleanup', 'backfill'], kind: K, parents: ['work-type:bug_fix'] },
+  { key: 'regression-fix', aliases: ['regression-fix', 'regression', 'regression-bug'], kind: K, parents: ['bugfix', 'work-type:bug_fix'] },
+  { key: 'flaky-test-fix', aliases: ['flaky-test-fix', 'flaky-test', 'test-stability', 'test-reliability'], kind: K, parents: ['bugfix', 'work-type:bug_fix'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Migrate & Transform ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'migration', aliases: ['migration', 'migrate', 'data-migration', 'database-migration', 'platform-migration'], kind: K, parents: ['work-type:migration'] },
+  { key: 'cloud-migration', aliases: ['cloud-migration', 'lift-and-shift', 'cloud-native-migration', 'on-prem-to-cloud'], kind: K, parents: ['migration', 'work-type:migration'] },
+  { key: 'monolith-to-microservices', aliases: ['monolith-to-microservices', 'decomposition', 'service-extraction', 'strangler-fig'], kind: K, parents: ['migration', 'work-type:migration'] },
+  { key: 'language-migration', aliases: ['language-migration', 'language-rewrite', 'tech-stack-migration'], kind: K, parents: ['migration', 'work-type:migration'] },
+  { key: 'database-migration', aliases: ['database-migration', 'db-migration', 'orm-migration', 'schema-migration'], kind: K, parents: ['migration', 'work-type:migration'] },
+  { key: 'provider-migration', aliases: ['provider-migration', 'vendor-switch', 'cloud-provider-migration', 'service-migration'], kind: K, parents: ['migration', 'work-type:migration'] },
+  { key: 'data-format-migration', aliases: ['data-format-migration', 'serialization-change', 'encoding-change', 'protocol-migration'], kind: K, parents: ['migration', 'work-type:migration'] },
+  { key: 'migration-plan', aliases: ['migration-plan', 'migration-strategy', 'cutover-plan', 'migration-runbook'], kind: K, parents: ['work-type:investigation'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Deploy & Release ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'rollout', aliases: ['rollout', 'deployment', 'release', 'ship', 'go-live'], kind: K, parents: ['work-type:feature'] },
+  { key: 'rollback', aliases: ['rollback', 'revert', 'deployment-rollback', 'version-revert'], kind: K, parents: ['work-type:bug_fix'] },
+  { key: 'canary-release', aliases: ['canary-release', 'progressive-rollout', 'incremental-release'], kind: K, parents: ['rollout', 'work-type:feature'] },
+  { key: 'feature-flag-rollout', aliases: ['feature-flag-rollout', 'dark-launch', 'gradual-rollout', 'percentage-rollout'], kind: K, parents: ['rollout', 'work-type:feature'] },
+  { key: 'ci-cd-setup', aliases: ['ci-cd-setup', 'pipeline-setup', 'build-pipeline', 'deployment-pipeline'], kind: K, parents: ['work-type:feature'] },
+  { key: 'environment-setup', aliases: ['environment-setup', 'dev-environment', 'staging-setup', 'infra-setup'], kind: K, parents: ['work-type:feature'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Remove & Deprecate ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'deprecation', aliases: ['deprecation', 'deprecate', 'sunset', 'end-of-life', 'eol'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'decommission', aliases: ['decommission', 'service-removal', 'teardown', 'shutdown', 'retire'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'dead-code-removal', aliases: ['dead-code-removal', 'code-deletion', 'unused-code', 'cleanup'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'feature-removal', aliases: ['feature-removal', 'feature-sunset', 'feature-deprecation'], kind: K, parents: ['deprecation', 'work-type:refactor'] },
+  { key: 'breaking-change', aliases: ['breaking-change', 'breaking-api-change', 'incompatible-change'], kind: K, parents: ['work-type:refactor'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Test & Verify ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'testing', aliases: ['testing', 'test-coverage', 'qa', 'quality-assurance', 'test-suite'], kind: K, parents: ['work-type:investigation'] },
+  { key: 'load-testing', aliases: ['load-testing', 'stress-testing', 'performance-testing', 'benchmark'], kind: K, parents: ['testing', 'work-type:investigation'] },
+  { key: 'security-audit', aliases: ['security-audit', 'penetration-testing', 'pentest', 'security-review', 'security-assessment'], kind: K, parents: ['work-type:investigation'] },
+  { key: 'compliance-report', aliases: ['compliance-report', 'compliance', 'regulatory', 'compliance-assessment', 'audit-report'], kind: K, parents: ['work-type:investigation'] },
+  { key: 'chaos-testing', aliases: ['chaos-testing', 'resilience-testing', 'game-day', 'failure-injection'], kind: K, parents: ['testing', 'work-type:investigation'] },
+  { key: 'dr-testing', aliases: ['dr-testing', 'disaster-recovery-test', 'failover-test', 'recovery-test'], kind: K, parents: ['testing', 'work-type:investigation'] },
+  { key: 'e2e-test-setup', aliases: ['e2e-test-setup', 'end-to-end-testing', 'integration-test-setup'], kind: K, parents: ['testing', 'work-type:feature'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Document & Communicate ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'documentation', aliases: ['documentation', 'docs', 'api-docs', 'technical-writing'], kind: K, parents: ['work-type:investigation'] },
+  { key: 'architecture-decision', aliases: ['architecture-decision', 'adr', 'design-doc', 'rfc', 'tech-spec'], kind: K, parents: ['work-type:investigation'] },
+  { key: 'runbook-creation', aliases: ['runbook-creation', 'operational-doc', 'playbook-creation', 'sop'], kind: K, parents: ['documentation', 'work-type:investigation'] },
+  { key: 'onboarding-doc', aliases: ['onboarding-doc', 'getting-started', 'developer-guide', 'setup-guide'], kind: K, parents: ['documentation', 'work-type:investigation'] },
+  { key: 'incident-postmortem', aliases: ['incident-postmortem', 'postmortem', 'post-incident-review', 'retrospective'], kind: K, parents: ['work-type:investigation'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Monitor & Observe ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'monitoring-setup', aliases: ['monitoring-setup', 'observability-setup', 'instrumentation', 'telemetry-setup'], kind: K, parents: ['work-type:feature'] },
+  { key: 'alert-tuning', aliases: ['alert-tuning', 'alert-management', 'noise-reduction', 'alert-threshold'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'dashboard-creation', aliases: ['dashboard-creation', 'metric-dashboard', 'monitoring-dashboard'], kind: K, parents: ['work-type:feature'] },
+  { key: 'log-improvement', aliases: ['log-improvement', 'logging-enhancement', 'log-enrichment', 'structured-log-migration'], kind: K, parents: ['work-type:refactor'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Access & Permissions ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'access-control-change', aliases: ['access-control-change', 'permission-change', 'rbac-update', 'role-change'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'secret-rotation', aliases: ['secret-rotation', 'key-rotation', 'credential-rotation', 'password-rotation'], kind: K, parents: ['work-type:refactor'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Scale & Optimize ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'capacity-scaling', aliases: ['capacity-scaling', 'scale-up', 'scale-out', 'horizontal-scale', 'vertical-scale'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'cost-reduction', aliases: ['cost-reduction', 'cost-saving', 'resource-optimization', 'right-sizing'], kind: K, parents: ['work-type:refactor'] },
+  { key: 'caching-implementation', aliases: ['caching-implementation', 'add-cache', 'cache-layer', 'cache-strategy'], kind: K, parents: ['work-type:feature'] },
+  { key: 'database-optimization', aliases: ['database-optimization', 'index-creation', 'query-tuning', 'table-partitioning'], kind: K, parents: ['work-type:refactor'] },
+];

package/src/workflow/lib/canonical-concepts/concepts/concern.concepts.ts

@@ -0,0 +1,194 @@
+import { CanonicalConcept, ConceptKind } from '../canonical-concept-registry';
+
+const K = ConceptKind.Concern;
+
+export const CONCERN_CONCEPTS: CanonicalConcept[] = [
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Security ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'security', aliases: ['security', 'secure', 'vulnerability', 'hardening', 'appsec'], kind: K },
+  { key: 'authentication', aliases: ['authentication', 'authn', 'login', 'sign-in'], kind: K, related: ['authorization'] },
+  { key: 'authorization', aliases: ['authorization', 'authz', 'rbac', 'abac', 'permissions', 'access-control'], kind: K, related: ['authentication'] },
+  { key: 'encryption', aliases: ['encryption', 'aes', 'rsa', 'tls', 'ssl', 'encryption-at-rest', 'encryption-in-transit'], kind: K, parents: ['security'] },
+  { key: 'secret-management', aliases: ['secret-management', 'secrets', 'vault', 'key-management', 'kms'], kind: K, parents: ['security'] },
+  { key: 'cors', aliases: ['cors', 'cross-origin', 'cross-origin-resource-sharing'], kind: K, parents: ['security'] },
+  { key: 'csrf-protection', aliases: ['csrf', 'csrf-protection', 'cross-site-request-forgery', 'xsrf'], kind: K, parents: ['security'] },
+  { key: 'xss-prevention', aliases: ['xss', 'xss-prevention', 'cross-site-scripting', 'input-sanitization'], kind: K, parents: ['security'] },
+  { key: 'sql-injection-prevention', aliases: ['sql-injection', 'sqli', 'injection-prevention'], kind: K, parents: ['security'] },
+  { key: 'dependency-vulnerability', aliases: ['dependency-vulnerability', 'cve', 'supply-chain-security', 'dependency-audit'], kind: K, parents: ['security'] },
+  { key: 'zero-trust', aliases: ['zero-trust', 'zero-trust-architecture', 'zta'], kind: K, parents: ['security'] },
+  { key: 'mfa', aliases: ['mfa', 'multi-factor-authentication', '2fa', 'two-factor'], kind: K, parents: ['authentication', 'security'] },
+  { key: 'api-security', aliases: ['api-security', 'api-key-management', 'api-auth'], kind: K, parents: ['security'] },
+  { key: 'container-security', aliases: ['container-security', 'image-scanning', 'runtime-security'], kind: K, parents: ['security'] },
+  { key: 'network-security', aliases: ['network-security', 'firewall', 'network-policy', 'vpc', 'security-group'], kind: K, parents: ['security'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Performance ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'performance', aliases: ['performance', 'perf', 'latency', 'throughput', 'optimization'], kind: K },
+  { key: 'caching', aliases: ['caching', 'cache', 'cache-invalidation', 'cache-strategy', 'ttl'], kind: K, related: ['performance'] },
+  { key: 'query-optimization', aliases: ['query-optimization', 'slow-query', 'query-plan', 'explain-analyze', 'index-optimization'], kind: K, parents: ['performance', 'database'] },
+  { key: 'connection-pooling', aliases: ['connection-pooling', 'connection-pool', 'pool-management', 'pgbouncer'], kind: K, parents: ['performance', 'database'] },
+  { key: 'lazy-loading', aliases: ['lazy-loading', 'lazy-load', 'code-splitting', 'dynamic-import'], kind: K, parents: ['performance'] },
+  { key: 'bundle-size', aliases: ['bundle-size', 'tree-shaking', 'dead-code-elimination', 'bundle-optimization'], kind: K, parents: ['performance', 'frontend'] },
+  { key: 'memory-management', aliases: ['memory-management', 'memory-leak', 'garbage-collection', 'gc-tuning', 'heap'], kind: K, parents: ['performance'] },
+  { key: 'cpu-optimization', aliases: ['cpu-optimization', 'cpu-bound', 'compute-optimization'], kind: K, parents: ['performance'] },
+  { key: 'io-optimization', aliases: ['io-optimization', 'io-bound', 'disk-io', 'network-io'], kind: K, parents: ['performance'] },
+  { key: 'rendering-performance', aliases: ['rendering-performance', 'fps', 'jank', 'reflow', 'repaint', 'virtual-dom'], kind: K, parents: ['performance', 'frontend'] },
+  { key: 'database-indexing', aliases: ['database-indexing', 'index', 'composite-index', 'covering-index', 'partial-index'], kind: K, parents: ['performance', 'database'] },
+  { key: 'pagination', aliases: ['pagination', 'cursor-pagination', 'offset-pagination', 'keyset-pagination'], kind: K, parents: ['performance'] },
+  { key: 'n-plus-one', aliases: ['n+1', 'n-plus-one', 'n+1-query', 'eager-loading', 'dataloader'], kind: K, parents: ['performance', 'database'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Scalability / Availability ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'scalability', aliases: ['scalability', 'scaling', 'horizontal-scaling', 'auto-scaling', 'scale-out'], kind: K },
+  { key: 'high-availability', aliases: ['high-availability', 'ha', 'failover', 'disaster-recovery', 'dr', 'redundancy'], kind: K },
+  { key: 'load-balancing', aliases: ['load-balancing', 'load-balancer', 'lb', 'round-robin', 'sticky-sessions'], kind: K, parents: ['scalability'] },
+  { key: 'auto-scaling', aliases: ['auto-scaling', 'autoscaling', 'hpa', 'vpa', 'keda', 'scaling-policy'], kind: K, parents: ['scalability'] },
+  { key: 'database-replication', aliases: ['database-replication', 'read-replica', 'primary-replica', 'master-slave', 'replication-lag'], kind: K, parents: ['scalability', 'database'] },
+  { key: 'database-sharding', aliases: ['database-sharding', 'sharding', 'horizontal-partitioning', 'shard-key'], kind: K, parents: ['scalability', 'database'] },
+  { key: 'geo-distribution', aliases: ['geo-distribution', 'multi-region', 'geo-replication', 'edge-computing', 'latency-routing'], kind: K, parents: ['scalability'] },
+  { key: 'zero-downtime', aliases: ['zero-downtime', 'zero-downtime-deployment', 'rolling-update', 'blue-green', 'canary'], kind: K, parents: ['high-availability'] },
+  { key: 'graceful-shutdown', aliases: ['graceful-shutdown', 'graceful-termination', 'sigterm', 'drain'], kind: K, parents: ['high-availability'] },
+  { key: 'health-check', aliases: ['health-check', 'healthcheck', 'liveness-probe', 'readiness-probe', 'startup-probe'], kind: K, parents: ['high-availability'] },
+  { key: 'capacity-planning', aliases: ['capacity-planning', 'resource-sizing', 'load-forecasting'], kind: K, parents: ['scalability'] },
+  { key: 'backpressure', aliases: ['backpressure', 'back-pressure', 'flow-control', 'congestion-control'], kind: K, parents: ['scalability'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Resilience / Fault Tolerance ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'circuit-breaker', aliases: ['circuit-breaker', 'circuit-breaking', 'bulkhead', 'fault-isolation'], kind: K, parents: ['resilience'] },
+  { key: 'retry-strategy', aliases: ['retry', 'retry-strategy', 'exponential-backoff', 'retry-policy', 'jitter'], kind: K, parents: ['resilience'] },
+  { key: 'timeout-management', aliases: ['timeout', 'timeout-management', 'deadline', 'request-timeout', 'connection-timeout'], kind: K, parents: ['resilience'] },
+  { key: 'dead-letter-queue', aliases: ['dead-letter-queue', 'dlq', 'dead-letter', 'poison-message'], kind: K, parents: ['resilience', 'messaging'] },
+  { key: 'chaos-engineering', aliases: ['chaos-engineering', 'chaos-testing', 'chaos-monkey', 'fault-injection'], kind: K, parents: ['resilience', 'testing'] },
+  { key: 'disaster-recovery', aliases: ['disaster-recovery', 'dr', 'rpo', 'rto', 'backup-restore'], kind: K, parents: ['resilience'] },
+  { key: 'fallback-strategy', aliases: ['fallback', 'fallback-strategy', 'degraded-mode', 'graceful-degradation'], kind: K, parents: ['resilience'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Observability ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'observability', aliases: ['observability', 'monitoring', 'logging', 'tracing', 'metrics', 'apm'], kind: K },
+  { key: 'distributed-tracing', aliases: ['distributed-tracing', 'trace-context', 'trace-propagation', 'span', 'trace-id'], kind: K, parents: ['observability'] },
+  { key: 'structured-logging', aliases: ['structured-logging', 'log-aggregation', 'log-level', 'correlation-id'], kind: K, parents: ['observability'] },
+  { key: 'alerting', aliases: ['alerting', 'alert-fatigue', 'alert-routing', 'on-call', 'runbook'], kind: K, parents: ['observability'] },
+  { key: 'slo-sli', aliases: ['slo', 'sli', 'sla', 'error-budget', 'service-level'], kind: K, parents: ['observability'] },
+  { key: 'custom-metrics', aliases: ['custom-metrics', 'business-metrics', 'counter', 'gauge', 'histogram'], kind: K, parents: ['observability'] },
+  { key: 'dashboarding', aliases: ['dashboarding', 'dashboard', 'visualization', 'real-time-monitoring'], kind: K, parents: ['observability'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Data Consistency / Integrity ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'data-consistency', aliases: ['data-consistency', 'eventual-consistency', 'strong-consistency', 'causal-consistency'], kind: K },
+  { key: 'acid-transactions', aliases: ['acid', 'acid-transactions', 'transaction', 'serializable', 'isolation-level'], kind: K, parents: ['data-consistency', 'database'] },
+  { key: 'idempotency', aliases: ['idempotency', 'idempotent', 'idempotent-operations', 'idempotency-key'], kind: K, parents: ['data-consistency'] },
+  { key: 'data-validation', aliases: ['data-validation', 'input-validation', 'schema-validation', 'runtime-validation'], kind: K },
+  { key: 'data-integrity', aliases: ['data-integrity', 'referential-integrity', 'constraint', 'foreign-key', 'unique-constraint'], kind: K, parents: ['database'] },
+  { key: 'schema-evolution', aliases: ['schema-evolution', 'schema-migration', 'backward-compatible-schema', 'schema-versioning'], kind: K, parents: ['database'] },
+  { key: 'saga-pattern', aliases: ['saga', 'saga-pattern', 'distributed-transaction', 'compensating-transaction'], kind: K, parents: ['data-consistency', 'distributed-systems'] },
+  { key: 'outbox-pattern', aliases: ['outbox', 'outbox-pattern', 'transactional-outbox', 'reliable-messaging'], kind: K, parents: ['data-consistency', 'messaging'] },
+  { key: 'cqrs', aliases: ['cqrs', 'command-query-separation', 'read-model', 'write-model'], kind: K, parents: ['data-consistency'] },
+  { key: 'event-sourcing', aliases: ['event-sourcing', 'event-store', 'event-replay'], kind: K, parents: ['data-consistency'] },
+  { key: 'optimistic-locking', aliases: ['optimistic-locking', 'optimistic-concurrency', 'version-column', 'etag'], kind: K, parents: ['data-consistency', 'concurrency'] },
+  { key: 'pessimistic-locking', aliases: ['pessimistic-locking', 'row-lock', 'select-for-update', 'advisory-lock'], kind: K, parents: ['data-consistency', 'concurrency'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Concurrency / Parallelism ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'concurrency', aliases: ['concurrency', 'concurrent', 'thread-safety', 'race-condition', 'mutex', 'semaphore'], kind: K },
+  { key: 'parallelism', aliases: ['parallelism', 'parallel-processing', 'multi-threaded', 'worker-threads'], kind: K },
+  { key: 'async-processing', aliases: ['async-processing', 'async', 'asynchronous', 'background-jobs', 'queue-processing'], kind: K },
+  { key: 'distributed-locking', aliases: ['distributed-locking', 'distributed-lock', 'redlock', 'leader-election'], kind: K, parents: ['concurrency', 'distributed-systems'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Multi-tenancy / Isolation ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'multi-tenancy', aliases: ['multi-tenancy', 'multi-tenant', 'tenant-isolation', 'tenancy', 'tenant-aware'], kind: K },
+  { key: 'data-isolation', aliases: ['data-isolation', 'row-level-security', 'rls', 'schema-per-tenant', 'database-per-tenant'], kind: K, parents: ['multi-tenancy'] },
+  { key: 'resource-isolation', aliases: ['resource-isolation', 'namespace-isolation', 'resource-quota', 'limit-range'], kind: K, parents: ['multi-tenancy'] },
+  { key: 'noisy-neighbor', aliases: ['noisy-neighbor', 'noisy-neighbour', 'resource-contention', 'tenant-fairness'], kind: K, parents: ['multi-tenancy'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Compliance / Privacy ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'data-privacy', aliases: ['data-privacy', 'gdpr', 'pii', 'data-protection', 'ccpa'], kind: K },
+  { key: 'auditability', aliases: ['auditability', 'audit', 'audit-trail', 'compliance-logging', 'audit-log'], kind: K },
+  { key: 'data-retention', aliases: ['data-retention', 'retention-policy', 'data-lifecycle', 'data-archival', 'ttl-policy'], kind: K, parents: ['data-privacy'] },
+  { key: 'data-masking', aliases: ['data-masking', 'data-anonymization', 'pseudonymization', 'tokenization', 'redaction'], kind: K, parents: ['data-privacy'] },
+  { key: 'right-to-erasure', aliases: ['right-to-erasure', 'right-to-deletion', 'data-deletion', 'gdpr-erasure'], kind: K, parents: ['data-privacy'] },
+  { key: 'data-residency', aliases: ['data-residency', 'data-sovereignty', 'data-locality', 'geo-fencing'], kind: K, parents: ['data-privacy'] },
+  { key: 'compliance-certification', aliases: ['soc2', 'hipaa', 'pci', 'pci-dss', 'iso-27001', 'fedramp', 'hitrust'], kind: K, parents: ['auditability'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Rate Limiting / Throttling ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'rate-limiting', aliases: ['rate-limiting', 'rate-limit', 'throttling', 'request-limiting', 'api-quota'], kind: K },
+  { key: 'ddos-protection', aliases: ['ddos-protection', 'ddos', 'dos-prevention', 'waf'], kind: K, parents: ['rate-limiting', 'security'] },
+  { key: 'abuse-prevention', aliases: ['abuse-prevention', 'bot-detection', 'captcha', 'fraud-detection'], kind: K, parents: ['security'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── API Design / Contracts ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'api-versioning', aliases: ['api-versioning', 'version-negotiation', 'url-versioning', 'header-versioning'], kind: K },
+  { key: 'api-pagination', aliases: ['api-pagination', 'cursor-based', 'offset-based', 'relay-pagination'], kind: K, parents: ['api-design'] },
+  { key: 'api-deprecation', aliases: ['api-deprecation', 'sunset-header', 'deprecation-policy'], kind: K, parents: ['api-design'] },
+  { key: 'backward-compatibility', aliases: ['backward-compatibility', 'backwards-compatible', 'non-breaking', 'additive-change'], kind: K },
+  { key: 'contract-testing', aliases: ['contract-testing', 'consumer-driven-contract', 'pact-testing', 'api-contract'], kind: K, parents: ['testing'] },
+  { key: 'error-handling', aliases: ['error-handling', 'error-codes', 'error-response', 'problem-details', 'rfc-7807'], kind: K },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Frontend / UX Concerns ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'accessibility', aliases: ['accessibility', 'a11y', 'wcag', 'aria', 'screen-reader'], kind: K },
+  { key: 'internationalization', aliases: ['internationalization', 'i18n', 'localization', 'l10n', 'rtl', 'pluralization'], kind: K },
+  { key: 'responsive-design', aliases: ['responsive-design', 'responsive', 'mobile-first', 'adaptive-design', 'breakpoints'], kind: K, parents: ['frontend'] },
+  { key: 'seo', aliases: ['seo', 'search-engine-optimization', 'meta-tags', 'structured-data', 'sitemap'], kind: K, parents: ['frontend'] },
+  { key: 'core-web-vitals', aliases: ['core-web-vitals', 'cwv', 'lcp', 'fid', 'cls', 'inp', 'ttfb'], kind: K, parents: ['performance', 'frontend'] },
+  { key: 'progressive-enhancement', aliases: ['progressive-enhancement', 'graceful-fallback', 'no-javascript'], kind: K, parents: ['frontend'] },
+  { key: 'offline-support', aliases: ['offline-support', 'offline-first', 'service-worker', 'pwa', 'progressive-web-app'], kind: K, parents: ['frontend'] },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── DevOps / Operations ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'infrastructure-provisioning', aliases: ['infrastructure-provisioning', 'infra-provisioning', 'cloud-provisioning', 'iac'], kind: K },
+  { key: 'configuration-management', aliases: ['configuration-management', 'config-management', 'env-vars', 'config-drift'], kind: K },
+  { key: 'prod-access', aliases: ['prod-access', 'production-access', 'prod-write', 'break-glass'], kind: K },
+  { key: 'database-admin', aliases: ['database-admin', 'dba', 'database-administration', 'db-ops'], kind: K },
+  { key: 'incident-management', aliases: ['incident-management', 'incident-response', 'postmortem', 'blameless-postmortem', 'war-room'], kind: K },
+  { key: 'runbook-automation', aliases: ['runbook-automation', 'runbook', 'playbook', 'operational-procedure'], kind: K, parents: ['incident-management'] },
+  { key: 'cost-optimization', aliases: ['cost-optimization', 'cloud-cost', 'finops', 'right-sizing', 'spot-instances', 'reserved-instances'], kind: K },
+  { key: 'resource-limits', aliases: ['resource-limits', 'cpu-limit', 'memory-limit', 'resource-quota', 'oom-kill'], kind: K, parents: ['container-orchestration'] },
+  { key: 'log-management', aliases: ['log-management', 'log-rotation', 'log-retention', 'centralized-logging'], kind: K, parents: ['observability'] },
+  { key: 'certificate-management', aliases: ['certificate-management', 'tls-cert', 'ssl-cert', 'cert-rotation', 'lets-encrypt'], kind: K, parents: ['security'] },
+  { key: 'dns-management', aliases: ['dns-management', 'dns', 'domain-management', 'dns-propagation'], kind: K },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Code Quality / Maintainability ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'technical-debt', aliases: ['technical-debt', 'tech-debt', 'code-smell', 'code-rot'], kind: K },
+  { key: 'code-coverage', aliases: ['code-coverage', 'test-coverage', 'branch-coverage', 'line-coverage'], kind: K, parents: ['testing'] },
+  { key: 'dependency-management', aliases: ['dependency-management', 'dependency-update', 'version-pinning', 'lock-file'], kind: K },
+  { key: 'type-safety', aliases: ['type-safety', 'type-checking', 'strict-mode', 'type-narrowing'], kind: K },
+  { key: 'modular-architecture', aliases: ['modular-architecture', 'separation-of-concerns', 'loose-coupling', 'cohesion'], kind: K },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Messaging / Event-Driven ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'message-ordering', aliases: ['message-ordering', 'message-order', 'fifo', 'ordered-delivery', 'partition-key'], kind: K, parents: ['messaging'] },
+  { key: 'at-least-once-delivery', aliases: ['at-least-once', 'at-least-once-delivery', 'message-deduplication'], kind: K, parents: ['messaging'] },
+  { key: 'exactly-once-delivery', aliases: ['exactly-once', 'exactly-once-delivery', 'exactly-once-processing'], kind: K, parents: ['messaging'] },
+  { key: 'message-schema', aliases: ['message-schema', 'event-schema', 'schema-registry', 'avro', 'protobuf-schema'], kind: K, parents: ['messaging'] },
+  { key: 'event-driven-architecture', aliases: ['event-driven', 'eda', 'event-driven-architecture', 'pub-sub', 'event-bus'], kind: K },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ── Deployment Strategies ──
+  // ═══════════════════════════════════════════════════════════════════════════
+  { key: 'blue-green-deployment', aliases: ['blue-green', 'blue-green-deployment', 'blue/green'], kind: K, parents: ['deployment'] },
+  { key: 'canary-deployment', aliases: ['canary', 'canary-deployment', 'canary-release', 'progressive-rollout'], kind: K, parents: ['deployment'] },
+  { key: 'feature-flags', aliases: ['feature-flags', 'feature-toggle', 'feature-switch', 'dark-launch', 'kill-switch'], kind: K, parents: ['deployment'] },
+  { key: 'a-b-testing', aliases: ['a-b-testing', 'ab-testing', 'split-testing', 'experiment'], kind: K, parents: ['deployment'] },
+  { key: 'rollback-strategy', aliases: ['rollback', 'rollback-strategy', 'rollback-plan', 'deployment-rollback'], kind: K, parents: ['deployment'] },
+  { key: 'immutable-infrastructure', aliases: ['immutable-infrastructure', 'immutable-deployment', 'disposable-infrastructure'], kind: K, parents: ['deployment'] },
+  { key: 'gitops', aliases: ['gitops', 'git-ops', 'declarative-deployment'], kind: K, parents: ['deployment'] },
+];