# The algo records whose domain is arch-relationships This index as JSON: https://banes-lab.com/json/api/facets/algo/domain/arch-relationships ## Entries - [Architectural Relationship Record](https://banes-lab.com/records/algo/architectural-relationship-record.md): Represent every architectural concept as a typed relationship record containing scope, dependencies, reinforcing effects, enabled capabilities, conflicts, tensions, violations, detection signals, metrics, refactor actions, enforcement mechanisms, and severity. - [Architecture Knowledge Graph](https://banes-lab.com/records/algo/architecture-knowledge-graph.md): Parse all relationship records into a directed multigraph where concepts are nodes and fields such as requires, reinforces, enables, conflicts, tensions, detects, measures, refactors, and enforces are typed edges. - [Architectural Force Classification](https://banes-lab.com/records/algo/architectural-force-classification.md): Given a design issue or desired quality, classify it into a force family, then select all concepts whose scope, type, violation signals, and enabled capabilities match that force. - [Dependency Closure](https://banes-lab.com/records/algo/dependency-closure.md): For any target architectural concept, recursively collect its required concepts until no new requirements remain, then order the closure by dependency depth before implementation. - [Reinforcement Propagation](https://banes-lab.com/records/algo/reinforcement-propagation.md): When a concept is implemented or strengthened, traverse its reinforces and enables edges to identify secondary quality gains and architecture capabilities unlocked. - [Conflict and Tension Resolution](https://banes-lab.com/records/algo/conflict-and-tension-resolution.md): For each selected concept, collect conflicts and tensions, classify conflicts as prohibitive or resolvable, classify tensions as trade-offs, and require an explicit decision when severity or impact is high. - [Severity Policy](https://banes-lab.com/records/algo/severity-policy.md): Interpret severity as an enforcement policy: mandatory concepts become gates, recommended concepts become review findings, contextual concepts require scope justification, and discouraged concepts require explicit exception approval. - [Violation Detection](https://banes-lab.com/records/algo/violation-detection.md): For each concept applicable to the current scope, execute its detected_by signals against the implementation, map observations to violated_by patterns, and produce evidence-backed violation records. - [Measurement Normalization](https://banes-lab.com/records/algo/measurement-normalization.md): Convert each concept’s measured_by field into executable or reviewable metrics, collect metric values, normalize them to comparable scores, and attach confidence based on measurement quality. - [Refactor Selection](https://banes-lab.com/records/algo/refactor-selection.md): Given a violation record, select refactor actions from the concept’s refactored_by field, rank actions by severity, dependency closure, blast radius, and expected reinforcement gain. - [Enforcement Gate](https://banes-lab.com/records/algo/enforcement-gate.md): Translate each concept’s enforced_by field into static checks, contract tests, schema validation, CI gates, policy rules, runtime monitors, review gates, or architecture fitness functions. - [Architecture Assessment](https://banes-lab.com/records/algo/architecture-assessment.md): Select concepts relevant to a target scope, compute dependency closure, detect violations, measure evidence, rank findings by severity, and emit a prioritized architecture assessment. - [Modular Boundary Compliance](https://banes-lab.com/records/algo/modular-boundary-compliance.md): Evaluate SRP, separation of concerns, cohesion, coupling, encapsulation, information hiding, abstraction, modularity, composability, replaceability, and autonomy as a connected boundary cluster. - [Contract Compatibility](https://banes-lab.com/records/algo/contract-compatibility.md): For APIs, services, data, schemas, and protocols, validate explicit contracts, preconditions, postconditions, invariants, versioning, backward compatibility, forward compatibility, and interoperability. - [Canonical Semantics](https://banes-lab.com/records/algo/canonical-semantics.md): Detect duplicated or conflicting models, schemas, terms, rules, and data definitions; select or create canonical authority; normalize variants; enforce single source of truth. - [Domain Boundary Governance](https://banes-lab.com/records/algo/domain-boundary-governance.md): Identify bounded contexts, ubiquitous language, context relationships, domain model ownership, anti-corruption layers, and explicit boundary rules. - [Self-Description and Discovery](https://banes-lab.com/records/algo/self-description-and-discovery.md): Require components, services, APIs, plugins, and runtime structures to declare metadata, capabilities, contracts, dependencies, configuration, and health so they can be discovered and validated. - [Runtime Extensibility](https://banes-lab.com/records/algo/runtime-extensibility.md): Detect repeated core modification for variants, define extension points, create plugin contracts, register implementations, discover them dynamically, and isolate failures. - [Pattern Selection](https://banes-lab.com/records/algo/pattern-selection.md): Select creational, structural, or behavioral patterns based on the problem force: creation variation, interface mismatch, access control, behavior variation, notification, workflow reuse, or coordination complexity. - [Architectural Style Selection](https://banes-lab.com/records/algo/architectural-style-selection.md): Select monolith, modular monolith, layered, component-based, package-by-feature, clean, hexagonal, ports-and-adapters, or microservices architecture based on deployment autonomy, domain complexity, operational maturity, consistency needs, and coupling tolerance. - [Event and Messaging Consistency](https://banes-lab.com/records/algo/event-and-messaging-consistency.md): For asynchronous systems, validate event contracts, message schemas, idempotent consumers, outbox publication, correlation metadata, ordering guarantees, retry behavior, and dead-letter handling. - [State and Transaction Safety](https://banes-lab.com/records/algo/state-and-transaction-safety.md): Identify state mutation boundaries, enforce unit-of-work scope, validate invariants, apply concurrency control, guarantee idempotency where retries exist, and isolate side effects. - [Correctness Verification](https://banes-lab.com/records/algo/correctness-verification.md): Push nondeterminism to boundaries, prefer pure deterministic core logic, validate specifications with static analysis, type checks, property tests, contract tests, formal methods where useful, and reproducible test environments. - [Resilience Policy](https://banes-lab.com/records/algo/resilience-policy.md): Classify failure modes, apply fail-fast, fail-safe, fail-secure, retry, timeout, circuit breaker, fallback, bulkhead, backpressure, health check, failover, and rollback policies according to dependency criticality. - [Observability and Auditability](https://banes-lab.com/records/algo/observability-and-auditability.md): Attach correlation and causation identifiers, emit logs, metrics, traces, alerts, audit records, and runtime health signals, then reconstruct behavior as a causal execution graph. - [Causality and Ordering](https://banes-lab.com/records/algo/causality-and-ordering.md): Model distributed events as a dependency graph, attach causation metadata, validate happens-before relationships, and use sequence numbers, Lamport clocks, or vector clocks when physical timestamps are insufficient. - [Performance and Scalability](https://banes-lab.com/records/algo/performance-and-scalability.md): Establish workload model, profile runtime behavior, benchmark repeatably, identify bottlenecks, analyze time and space complexity, select scaling strategy, optimize only measured bottlenecks, and enforce SLO gates. - [Portability and Deployment Environment](https://banes-lab.com/records/algo/portability-and-deployment-environment.md): Externalize configuration, abstract platform dependencies, enforce standards compliance, containerize or package runtimes, validate environment parity, and isolate infrastructure-specific behavior behind adapters. - [Security Governance](https://banes-lab.com/records/algo/security-governance.md): Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, manage secrets, enforce policy as code, and continuously audit compliance. - [Architecture Evolution Governance](https://banes-lab.com/records/algo/architecture-evolution-governance.md): Assess architecture against quality attributes, document decisions, analyze impact, track gaps, define fitness functions, standardize patterns, and evolve through ADR-backed controlled change. - [Control Plane Coordination](https://banes-lab.com/records/algo/control-plane-coordination.md): Separate control-plane policy from data-plane execution, centralize configuration, authentication, logging, or orchestration only where shared governance is beneficial, and preserve local autonomy where decentralization is required. - [Metaprogramming Safety](https://banes-lab.com/records/algo/metaprogramming-safety.md): Treat code as data only through schemas, manifests, DSL grammars, reflection contracts, compile-time checks, runtime guards, and generated artifact validation. - [Streaming Dataflow](https://banes-lab.com/records/algo/streaming-dataflow.md): Process data through forward-only stages, preserve bounded memory, apply backpressure, checkpoint state where needed, and prefer stateless processing unless state is explicitly modeled. - [Model Architecture Governance](https://banes-lab.com/records/algo/model-lifecycle-governance.md): Register models, prompts, datasets, embeddings, retrieval sources, knowledge graphs, inference contracts, evaluation suites, explainability traces, safety gates, and monitoring policies. - [Architectural Recommendation](https://banes-lab.com/records/algo/architectural-recommendation.md): Given a target problem, query the graph for matching violated_by and detected_by signals, collect candidate concepts, compute required dependencies, remove conflicting concepts, rank by severity and reinforcement gain, then recommend an ordered implementation path. - [Architecture Fitness Function Generation](https://banes-lab.com/records/algo/architecture-fitness-function-generation.md): Convert mandatory and high-impact recommended records into executable fitness functions by binding detected_by signals to checks, measured_by fields to thresholds, and enforced_by fields to pipeline gates. - [Architecture Refactoring Roadmap](https://banes-lab.com/records/algo/architecture-refactoring-roadmap.md): Group violations by shared refactor actions, order remediation by prerequisite concepts, apply low-risk structural fixes first, then enforce newly satisfied concepts through gates. - [Concept Cluster Extraction](https://banes-lab.com/records/algo/concept-cluster-extraction.md): Group concepts into clusters by mutual requires, reinforces, enables, and shared scope; treat clusters as higher-order architectural concerns. - [Architecture Decision Support](https://banes-lab.com/records/algo/architecture-decision-support.md): For each proposed design decision, compute satisfied concepts, violated concepts, tensions introduced, conflicts triggered, enabled capabilities, and enforcement cost; require ADR when trade-offs are nontrivial. - [Relationship Schema Validation](https://banes-lab.com/records/algo/relationship-schema-validation.md): Validate every concept record for required fields, known relation names, parseable scope, valid severity, nonempty detection and enforcement metadata, and resolvable references where possible. - [Architecture Catalog Compiler](https://banes-lab.com/records/algo/architecture-catalog-compiler.md): Compile the relationship catalog into four executable artifacts: assessment rules, refactor playbooks, decision-support graphs, and governance gates. - [Master Architecture Governance Kernel](https://banes-lab.com/records/algo/master-architecture-governance-kernel.md): Parse the catalog, validate records, build the graph, classify target scope, select relevant concept clusters, compute dependency closure, detect violations, measure evidence, resolve conflicts, generate refactor plans, enforce gates, and record decisions. - [Architectural Relationship Algebra](https://banes-lab.com/records/algo/architectural-relationship-algebra.md): → → →