# The algo face > 451 records. This index as JSON: https://banes-lab.com/json/api/records/algo ## Fields - `domain`: [agent-creation](https://banes-lab.com/api/facets/algo/domain/agent-creation.md) (26), [agent-workflow](https://banes-lab.com/api/facets/algo/domain/agent-workflow.md) (27), [anti-patterns](https://banes-lab.com/api/facets/algo/domain/anti-patterns.md) (8), [arch-relationships](https://banes-lab.com/api/facets/algo/domain/arch-relationships.md) (43), [Architectural Clusters](https://banes-lab.com/api/facets/algo/domain/architectural-clusters.md) (22), [Architectural Rules](https://banes-lab.com/api/facets/algo/domain/architectural-rules.md) (47), [architecture](https://banes-lab.com/api/facets/algo/domain/architecture.md) (46), [automation](https://banes-lab.com/api/facets/algo/domain/automation.md) (25), [centralization](https://banes-lab.com/api/facets/algo/domain/centralization.md) (24), [checklist-creation](https://banes-lab.com/api/facets/algo/domain/checklist-creation.md) (39), [codebase-verification](https://banes-lab.com/api/facets/algo/domain/codebase-verification.md) (22), [context-verification](https://banes-lab.com/api/facets/algo/domain/context-verification.md) (18), [css-cascade](https://banes-lab.com/api/facets/algo/domain/css-cascade.md) (10), [governed-plan-loop](https://banes-lab.com/api/facets/algo/domain/governed-plan-loop.md) (6), [living-profile](https://banes-lab.com/api/facets/algo/domain/living-profile.md) (9), [mode-driven-response-schema](https://banes-lab.com/api/facets/algo/domain/mode-driven-response-schema.md) (5), [pag](https://banes-lab.com/api/facets/algo/domain/pag.md) (12), [pattern-distillation](https://banes-lab.com/api/facets/algo/domain/pattern-distillation.md) (31), [quality-engine](https://banes-lab.com/api/facets/algo/domain/quality-engine.md) (8), [taxonomy](https://banes-lab.com/api/facets/algo/domain/taxonomy.md) (12), [test-coverage](https://banes-lab.com/api/facets/algo/domain/test-coverage.md) (11) - `force`: [ad-hoc-lock-ordering (deadlock)](https://banes-lab.com/api/facets/algo/force/ad-hoc-lock-ordering-deadlock.md) (1), [architecture_evolution](https://banes-lab.com/api/facets/algo/force/architecture-evolution.md) (73), [asymmetric-lifecycle (resource-leaks)](https://banes-lab.com/api/facets/algo/force/asymmetric-lifecycle-resource-leaks.md) (1), [backward_compatibility (debt)](https://banes-lab.com/api/facets/algo/force/backward-compatibility-debt.md) (1), [boolean-flag-soup (illegal-states)](https://banes-lab.com/api/facets/algo/force/boolean-flag-soup-illegal-states.md) (1), [broad-privilege (blast-radius)](https://banes-lab.com/api/facets/algo/force/broad-privilege-blast-radius.md) (1), [causality_ordering](https://banes-lab.com/api/facets/algo/force/causality-ordering.md) (17), [contract_compatibility](https://banes-lab.com/api/facets/algo/force/contract-compatibility.md) (91), [control_coordination](https://banes-lab.com/api/facets/algo/force/control-coordination.md) (50), [convention-only-enforcement (drift)](https://banes-lab.com/api/facets/algo/force/convention-only-enforcement-drift.md) (1), [correctness_verification](https://banes-lab.com/api/facets/algo/force/correctness-verification.md) (214), [cross-context-leak (model-corruption)](https://banes-lab.com/api/facets/algo/force/cross-context-leak-model-corruption.md) (1), [cross-service-2PC (coupling)](https://banes-lab.com/api/facets/algo/force/cross-service-2pc-coupling.md) (1), [deferring (forgetting)](https://banes-lab.com/api/facets/algo/force/deferring-forgetting.md) (1), [deprecation (debt)](https://banes-lab.com/api/facets/algo/force/deprecation-debt.md) (1), [discipline-release (human-error)](https://banes-lab.com/api/facets/algo/force/discipline-release-human-error.md) (1), [domain_boundary](https://banes-lab.com/api/facets/algo/force/domain-boundary.md) (30), [dual-path (confusion)](https://banes-lab.com/api/facets/algo/force/dual-path-confusion.md) (1), [env-fallback-default (silent-misconfig)](https://banes-lab.com/api/facets/algo/force/env-fallback-default-silent-misconfig.md) (1), [event_messaging](https://banes-lab.com/api/facets/algo/force/event-messaging.md) (19), [evolution-without-approval (architectural-drift)](https://banes-lab.com/api/facets/algo/force/evolution-without-approval-architectural-drift.md) (1), [fallback (debt)](https://banes-lab.com/api/facets/algo/force/fallback-debt.md) (1), [feedback-ignored (stagnation)](https://banes-lab.com/api/facets/algo/force/feedback-ignored-stagnation.md) (1), [flat-state-explosion (combinatorial-growth)](https://banes-lab.com/api/facets/algo/force/flat-state-explosion-combinatorial-growth.md) (1), [for_now (deferring)](https://banes-lab.com/api/facets/algo/force/for-now-deferring.md) (1), [guess-based-capacity (saturation)](https://banes-lab.com/api/facets/algo/force/guess-based-capacity-saturation.md) (1), [hardcoded-secrets (exposure)](https://banes-lab.com/api/facets/algo/force/hardcoded-secrets-exposure.md) (1), [hardcoded-wiring (rigidity)](https://banes-lab.com/api/facets/algo/force/hardcoded-wiring-rigidity.md) (1), [hidden-dependency (concealed-coupling)](https://banes-lab.com/api/facets/algo/force/hidden-dependency-concealed-coupling.md) (1), [hidden-invalidity (false-consistency)](https://banes-lab.com/api/facets/algo/force/hidden-invalidity-false-consistency.md) (1), [hidden-nondeterminism (unreproducible)](https://banes-lab.com/api/facets/algo/force/hidden-nondeterminism-unreproducible.md) (1), [imperative-config (drift)](https://banes-lab.com/api/facets/algo/force/imperative-config-drift.md) (1), [implicit-contract (silent-breakage)](https://banes-lab.com/api/facets/algo/force/implicit-contract-silent-breakage.md) (1), [implicit-retention (hidden-leaks)](https://banes-lab.com/api/facets/algo/force/implicit-retention-hidden-leaks.md) (1), [legacy (debt)](https://banes-lab.com/api/facets/algo/force/legacy-debt.md) (1), [location-addressing (brittleness)](https://banes-lab.com/api/facets/algo/force/location-addressing-brittleness.md) (1), [metaprogramming_modeling](https://banes-lab.com/api/facets/algo/force/metaprogramming-modeling.md) (18), [metric-health (symptom-tracking)](https://banes-lab.com/api/facets/algo/force/metric-health-symptom-tracking.md) (1), [model_governance](https://banes-lab.com/api/facets/algo/force/model-governance.md) (73), [modularity](https://banes-lab.com/api/facets/algo/force/modularity.md) (69), [mutable-state (unpredictability)](https://banes-lab.com/api/facets/algo/force/mutable-state-unpredictability.md) (1), [object_creation](https://banes-lab.com/api/facets/algo/force/object-creation.md) (8), [observability_traceability](https://banes-lab.com/api/facets/algo/force/observability-traceability.md) (24), [opaque-runtime (blind-operation)](https://banes-lab.com/api/facets/algo/force/opaque-runtime-blind-operation.md) (1), [optional (user-orientation)](https://banes-lab.com/api/facets/algo/force/optional-user-orientation.md) (1), [parent-callbacks (tight-coupling)](https://banes-lab.com/api/facets/algo/force/parent-callbacks-tight-coupling.md) (1), [partial-commit (corruption)](https://banes-lab.com/api/facets/algo/force/partial-commit-corruption.md) (1), [pattern-without-compression (inefficiency)](https://banes-lab.com/api/facets/algo/force/pattern-without-compression-inefficiency.md) (1), [performance_scaling](https://banes-lab.com/api/facets/algo/force/performance-scaling.md) (14), [resilience_recovery](https://banes-lab.com/api/facets/algo/force/resilience-recovery.md) (33), [retraction (complexity)](https://banes-lab.com/api/facets/algo/force/retraction-complexity.md) (1), [runtime_extensibility](https://banes-lab.com/api/facets/algo/force/runtime-extensibility.md) (60), [security_governance](https://banes-lab.com/api/facets/algo/force/security-governance.md) (31), [semantic_consistency](https://banes-lab.com/api/facets/algo/force/semantic-consistency.md) (94), [separation (duplication)](https://banes-lab.com/api/facets/algo/force/separation-duplication.md) (1), [shared-ownership (ambiguity)](https://banes-lab.com/api/facets/algo/force/shared-ownership-ambiguity.md) (1), [shortcuts (debt)](https://banes-lab.com/api/facets/algo/force/shortcuts-debt.md) (1), [silent-errors (unknown-failure)](https://banes-lab.com/api/facets/algo/force/silent-errors-unknown-failure.md) (1), [speculative-pattern (accidental-complexity)](https://banes-lab.com/api/facets/algo/force/speculative-pattern-accidental-complexity.md) (1), [state_transaction](https://banes-lab.com/api/facets/algo/force/state-transaction.md) (33), [streaming_dataflow](https://banes-lab.com/api/facets/algo/force/streaming-dataflow.md) (7), [synchronous-cross-autonomy-boundary (fragility)](https://banes-lab.com/api/facets/algo/force/synchronous-cross-autonomy-boundary-fragility.md) (1), [timestamp-ordering (wall-clock-dependency)](https://banes-lab.com/api/facets/algo/force/timestamp-ordering-wall-clock-dependency.md) (1), [unbounded-lifetime (leaks)](https://banes-lab.com/api/facets/algo/force/unbounded-lifetime-leaks.md) (1), [unlimited-complexity (cognitive-overload)](https://banes-lab.com/api/facets/algo/force/unlimited-complexity-cognitive-overload.md) (1), [unmeasured-optimization (guesswork)](https://banes-lab.com/api/facets/algo/force/unmeasured-optimization-guesswork.md) (1), [unobserved-execution (missed-learning)](https://banes-lab.com/api/facets/algo/force/unobserved-execution-missed-learning.md) (1), [untyped-boundary (invalid-state)](https://banes-lab.com/api/facets/algo/force/untyped-boundary-invalid-state.md) (1), [unvalidated-input (injection)](https://banes-lab.com/api/facets/algo/force/unvalidated-input-injection.md) (1), [unversioned-breaking-change (consumer-breakage)](https://banes-lab.com/api/facets/algo/force/unversioned-breaking-change-consumer-breakage.md) (1) - `meta`: [false](https://banes-lab.com/api/facets/algo/meta/false.md) (413), [true](https://banes-lab.com/api/facets/algo/meta/true.md) (38) ## Entries - [Evidence-Before-Generation](https://banes-lab.com/records/algo/evidence-before-generation.md): Discover available context, inspect target-domain resources, extract concrete facts, construct a knowledge base, and generate only from verified evidence. - [Semantic Operation Boundary](https://banes-lab.com/records/algo/semantic-operation-boundary.md): Define required work as semantic operations, defer runtime execution details to adapters, and reject runtime-specific primitives from the portable core contract. - [Capability Profile](https://banes-lab.com/records/algo/capability-profile.md): Detect filesystem, search, execution, persistence, validation, and user-interaction capabilities; mark unsupported capabilities; substitute where safe; block where required capability is non-substitutable. - [Creation History Collision](https://banes-lab.com/records/algo/creation-history-collision.md): Load existing agent and invocation registries, map existing identities, compare target name and domain, and require the developer's decision before refinement, renaming, replacement, or cancellation. - [Domain Cache Validation](https://banes-lab.com/records/algo/domain-cache-validation.md): Normalize the domain path, compute a domain hash, search cache entries, calculate cache age, and reuse cached knowledge only when cache identity and TTL are valid. - [Scope Extraction](https://banes-lab.com/records/algo/scope-extraction.md): Determine whether the target is a resource, directory, module, repository, or unknown scope; then extract interfaces, declarations, dependencies, systems, or boundaries appropriate to that scope. - [Non-Destructive Domain Investigation](https://banes-lab.com/records/algo/non-destructive-domain-investigation.md): Prepare static investigation, optionally prepare safe executable analysis, prohibit source mutation, execute or emulate analysis, and merge observable outputs into domain intelligence. - [Domain Knowledge Base](https://banes-lab.com/records/algo/domain-knowledge-base.md): Store target scope, discovered structure, purposes, dependencies, interfaces, patterns, statistics, timestamp, and evidence sources in a reusable knowledge object. - [Risk Complexity Reversibility](https://banes-lab.com/records/algo/risk-complexity-reversibility.md): Analyze domain dependencies, side effects, resource count, interface count, dependency patterns, and uncertainty factors to assign risk, complexity, reversibility, and uncertainty. - [Existing Pattern Extraction](https://banes-lab.com/records/algo/existing-pattern-extraction.md): Inspect existing agent specifications, count phase markers, validation gates, and semantic operations, extract reusable structures, and derive baseline design conventions. - [Knowledge Documentation Relevance](https://banes-lab.com/records/algo/knowledge-documentation-relevance.md): Discover knowledge documents, read descriptions, compare them against domain characteristics, score relevance, and exclude irrelevant documents from core reasoning. - [Principle Extraction](https://banes-lab.com/records/algo/principle-extraction.md): Start from structural principles, test applicability against domain characteristics, add domain-specific principles from relevant documents, and exclude runtime-specific principles from the core. - [Adaptive Phase Boundary](https://banes-lab.com/records/algo/adaptive-phase-boundary.md): Select phase count from risk and complexity, assign phase boundaries, and strengthen validation density for high-risk or high-complexity domains. - [Phase Validation Requirement](https://banes-lab.com/records/algo/phase-validation-requirement.md): For every phase boundary, generate explicit validation requirements from the phase purpose, adapter-separation needs, evidence-grounding needs, and safety constraints. - [Portable Contract Composition](https://banes-lab.com/records/algo/portable-contract-composition.md): Compose identity, purpose, methodology, domain scope, characteristics, capabilities, phases, validation strategy, constraints, and required outputs into a runtime-neutral agent contract. - [Validation Strategy Composition](https://banes-lab.com/records/algo/validation-strategy-composition.md): Define pre-generation, during-generation, and post-generation checks that enforce capabilities, creation history, evidence grounding, adapter separation, schema validity, and absence of unsupported assumptions. - [Replacement Safety](https://banes-lab.com/records/algo/replacement-safety.md): If replacing an existing artifact, require prior approval, archive existing artifacts, verify archive persistence, and block new persistence if archival cannot be confirmed. - [Adapter Rendering](https://banes-lab.com/records/algo/adapter-rendering.md): Render the portable contract into runtime-specific agent specification, invocation contract, and audit artifacts only through adapter-defined schemas and destinations. - [Audit Artifact](https://banes-lab.com/records/algo/audit-artifact.md): Record agent name, domain, operation mode, runtime environment, risk, complexity, reversibility, uncertainty, phase count, validation gates, evidence sources, capability profile, adapter identity, portability status, and timestamp. - [Semantic Compliance Validation](https://banes-lab.com/records/algo/semantic-compliance-validation.md): Re-read the persisted agent specification, search for semantic operations, phase markers, validation gates, and runtime-specific leakage, then mark compliant only when required counts pass and leakage is absent. - [Evidence Grounding Validation](https://banes-lab.com/records/algo/evidence-grounding-validation.md): Search generated output for unsupported claims and evidence references, compare generated claims against the knowledge base, calculate grounding score, and reject artifacts below threshold. - [Algorithmic Embodiment Validation](https://banes-lab.com/records/algo/algorithmic-embodiment-validation.md): Verify that generated agents contain phase gates, declaration-before-use structure, calculated metrics, exact thresholds or comparisons, and iterative discovery patterns. - [Final Generation Report](https://banes-lab.com/records/algo/final-generation-report.md): Summarize generated agent, target domain, operation mode, adapter, risk, complexity, reversibility, uncertainty, phase count, validation-gate count, compliance results, artifact references, degraded mode, and unsupported capabilities. - [Agent Generation Completion](https://banes-lab.com/records/algo/agent-generation-completion.md): Accept the generated agent as complete only when semantic-compliance, evidence-grounding above threshold, and algorithmic-embodiment all pass and the audit trail is recorded; otherwise route to regeneration or a blocked report. - [Agent Creator Kernel](https://banes-lab.com/records/algo/agent-creator-kernel.md): Load configuration, detect capabilities, check creation history, validate cache, discover domain evidence, build knowledge base, analyze characteristics, extract principles, define phases, compose portable contract, render adapter artifacts, validate outputs, audit, and report. - [](https://banes-lab.com/records/algo/agent-generation-concern.md): → → → → → → → → → → → - [Hybrid Workflow Orchestration](https://banes-lab.com/records/algo/hybrid-workflow-orchestration.md): Classify workflow phases by execution verb, run discovery and investigation agents in parallel forked contexts, run action and mutation agents sequentially, and coordinate all agents through shared artifacts and handoff signals. - [DSL Compliance Loading](https://banes-lab.com/records/algo/dsl-compliance-loading.md): Load grammar, keyword, operator, workflow, and checklist references before workflow generation, then require generated content to follow the declared DSL, naming, handoff, execution, forking, spawning, and capability rules. - [File Modification Recovery](https://banes-lab.com/records/algo/agent-workflow-file-modification-recovery.md): When a file modification conflict occurs, detect the error, re-read the current file, merge the intended delta into the current content, write the complete new version, verify persistence, and log recovery automatically without asking the developer. - [Context Forking Configuration](https://banes-lab.com/records/algo/context-forking-configuration.md): Assign forked context to discovery, investigation, and documentation agents; assign normal context to action and validation agents; preserve model and parallel eligibility metadata per agent class. - [Verb-Based Execution Classification](https://banes-lab.com/records/algo/verb-based-execution-classification.md): Extract the primary verb from each agent purpose, classify it against parallel or sequential verb sets, and bind execution mode, context, and parallel eligibility. - [Workspace Configuration Discovery](https://banes-lab.com/records/algo/workspace-configuration-discovery.md): Read workspace configuration, extract zones, semantic extensions, root path, agent definitions, shared zone, workflow zone, and task zone before generating any workflow artifacts. - [Shared Document Workspace](https://banes-lab.com/records/algo/shared-document-workspace.md): Pre-create workflow documents once, require every agent to read and edit the same documents, prohibit duplicate versions, and enforce single source of truth across phases. - [Workflow Type Document Selection](https://banes-lab.com/records/algo/workflow-type-document-selection.md): Analyze workflow objective, classify workflow type, select five to eight semantically distinct core documents, and map each document to a non-overlapping purpose. - [Agent Sequence Definition](https://banes-lab.com/records/algo/agent-sequence-definition.md): For each agent slot, create an agent object with name, type, phase, purpose, methodology, inputs, outputs, validation gates, document responsibilities, focus areas, edit protocol, agent activation, and 4D graph. - [Agent Document Responsibility](https://banes-lab.com/records/algo/agent-document-responsibility.md): For each core document, require every agent to read current state, identify outdated or incorrect content, remove stale sections, replace with new discoveries, avoid duplicate findings, and maintain single source of truth. - [Agent Activation Invocation](https://banes-lab.com/records/algo/agent-activation-invocation.md): For every agent activation, construct a spawn invocation with agent type, prompt, description, model, and context; use forked context for parallel agents and normal context for sequential agents. - [Parallel Batch Execution](https://banes-lab.com/records/algo/parallel-batch-execution.md): Accumulate adjacent parallel agents into a batch, invoke all spawns in a single concurrent batch, wait for all completions, and merge findings through shared documents. - [Sequential Agent Execution](https://banes-lab.com/records/algo/sequential-agent-execution.md): Execute state-changing or validation agents one at a time in normal context, pass handoff context from the previous phase, wait for completion signal, then activate the next agent. - [Four-Dimensional Agent Graph](https://banes-lab.com/records/algo/four-dimensional-agent-graph.md): For each agent, build sequential dependencies, lateral parallel peers, diagonal artifact/data dependencies, and propagation effects including superseded state, propagated contracts, and breakage risks. - [Handoff Signal](https://banes-lab.com/records/algo/handoff-signal.md): Require every agent to end with a structured handoff signal containing completed agent, phase status, artifact location, next agent, execution mode, context used, findings, files, validation status, parallel results, 4D graph, and orchestrator action. - [Orchestrator Action](https://banes-lab.com/records/algo/orchestrator-action.md): Interpret handoff action as activate next agent, pause for the developer, or complete workflow; automatically continue unless a critical decision or repeated recovery failure requires the developer's involvement. - [Workflow Coordination Sequence](https://banes-lab.com/records/algo/workflow-coordination-sequence.md): Pre-create documents, execute parallel batches where eligible, execute sequential agents one at a time, update checkpoints, validate single source of truth, and mark workflow completion. - [Workflow Recovery Loop](https://banes-lab.com/records/algo/workflow-recovery-loop.md): If an agent fails validation, read shared documents, identify unmet expectation, research the error pattern, relaunch the agent with adapted context, and pause for the developer after bounded recovery attempts. - [Checklist Integration](https://banes-lab.com/records/algo/checklist-integration.md): Create a workflow progress checklist in the artifact workspace, include execution model metadata, phases in linear dependency order with severity metadata, task checkboxes, progress bars, success criteria, and agent-edit coordination rules. - [Phase Documentation Template](https://banes-lab.com/records/algo/phase-documentation-template.md): For each agent phase, render phase header, execution mode, context mode, methodology, 4D graph, artifact flow, focus areas, deliverable, and agent activation example. - [Workflow Principles Mapping](https://banes-lab.com/records/algo/workflow-principles-mapping.md): Derive workflow principles from the agent sequence, first agent grounding role, final agent quality guarantee, intermediate agent contributions, automation, context awareness, recovery, scalability, hybrid execution, context forking, and workspace integration. - [Capability Invocation Protocol](https://banes-lab.com/records/algo/capability-invocation-protocol.md): Define specialized capability invocation patterns, classify which capabilities run forked or normal, include examples, and allow workflows to call capabilities for research, validation, calculation, and specialized subroutines. - [Template Assembly](https://banes-lab.com/records/algo/template-assembly.md): Assemble frontmatter, workspace config, overview, phase documentation, checklist requirements, orchestration protocol, handoff format, coordination sequence, capability integration, workflow principles, and domain notes into one workflow artifact. - [First-Time Initiation](https://banes-lab.com/records/algo/first-time-initiation.md): After generating the workflow template, present a summary and request explicit first-run action: execute workflow, edit template, or cancel. - [Workflow Validation Gate](https://banes-lab.com/records/algo/workflow-validation-gate.md): Validate DSL compliance, workspace discovery, dynamic agent count, execution classification, context configuration, 4D graphs, handoff protocol, hybrid execution, checklist integration, capability integration, template assembly, dynamic paths, uppercase filenames, and agent-oriented content. - [Workflow Creation Kernel](https://banes-lab.com/records/algo/workflow-creation-kernel.md): Load DSL and orchestration references, configure file recovery and context forking, discover workspace zones and agents, select shared documents, define dynamic agent sequence, classify execution mode, build 4D graphs, define handoff protocol, assemble coordination sequence, integrate checklist and capabilities, generate phase documentation, assemble template, and validate success criteria. - [](https://banes-lab.com/records/algo/workflow-orchestration-concern.md): → → → → → → → → - [Structural Core](https://banes-lab.com/records/algo/structural-core.md): The architectural rules that preserve structural integrity — a single authoritative source, no shortcuts, no fallbacks, no duplication, no orphaned artifacts. - [Correctness Core](https://banes-lab.com/records/algo/correctness-core.md): The rules ensuring behavioral correctness and validity — no silent failures, no hidden invalidity, feedback acted on, results observed. - [Evolution Principles](https://banes-lab.com/records/algo/evolution-principles.md): The rules governing how a system changes over time — no backward-compat cruft, no deprecation debt, no legacy retention, no 'for now'. - [Resource Core](https://banes-lab.com/records/algo/resource-core.md): The rules governing resource lifecycle and ownership — bounded lifetime, single ownership, no leaks, no implicit retention. - [Execution Core](https://banes-lab.com/records/algo/execution-core.md): The rules governing execution flow — a single observable path, no deferring, no dual-path branching, nothing unobserved. - [Computation Core](https://banes-lab.com/records/algo/computation-core.md): The rules governing computation determinism and purity — no mutable shared state, no hidden nondeterminism, reproducible results. - [Security Core](https://banes-lab.com/records/algo/security-core.md): The rules governing security posture — no hardcoded secrets, validated input, least privilege, no insecure fallbacks. - [Performance Core](https://banes-lab.com/records/algo/performance-core.md): The rules governing performance discipline — measured optimization, planned capacity, no guesswork. - [Contracts Core](https://banes-lab.com/records/algo/contracts-core.md): The rules governing interfaces and contracts — explicit typed boundaries, versioned change, no implicit or breaking contracts. - [Causality Core](https://banes-lab.com/records/algo/causality-core.md): The rules governing causal ordering and time — logical ordering, retractable state, no wall-clock dependence. - [Declarative Core](https://banes-lab.com/records/algo/declarative-core.md): The rules favoring declarative over imperative — declared configuration, separated concerns, no imperative wiring. - [Extensibility Core](https://banes-lab.com/records/algo/extensibility-core.md): The rules governing extension — declarative discovered wiring over hardcoded, no imperative hardcoded registration. - [Observability](https://banes-lab.com/records/algo/observability.md): The rules ensuring a system is observable — emitted metrics and signals, no unobserved execution, no opaque runtime. - [Enforcement Core](https://banes-lab.com/records/algo/enforcement-core.md): The rules ensuring discipline is enforced programmatically — automated gates over convention, no discipline-only reliance. - [Atomic Boundary](https://banes-lab.com/records/algo/atomic-boundary.md): The rules governing atomicity — a transactional boundary that fully commits or fully rolls back, no partial commit, no deferring within. - [Human Factors](https://banes-lab.com/records/algo/human-factors.md): The rules governing human ergonomics — bounded cognitive complexity, acted-on feedback, explicit approval, no unlimited options. - [Domain Modeling](https://banes-lab.com/records/algo/domain-modeling.md): The rules governing domain boundaries — bounded contexts, ubiquitous language, no leaky context. - [Design Patterns Core](https://banes-lab.com/records/algo/design-patterns-core.md): The rules governing design-pattern use — patterns applied only to demonstrated recurrence, no speculative pattern application. - [State Pattern](https://banes-lab.com/records/algo/state-pattern.md): The State design pattern — encapsulate state-dependent behavior in distinct state objects so transitions replace conditional branching. - [Separation of Concerns](https://banes-lab.com/records/algo/separation-of-concerns.md): The principle of separating a system into distinct concerns so each is addressed and changed independently. - [Concurrency Correctness](https://banes-lab.com/records/algo/concurrency-correctness.md): The rules ensuring correct concurrent behavior — no data races, well-defined interleavings, verified with models such as Petri nets. - [Capacity Planning](https://banes-lab.com/records/algo/capacity-planning.md): The activity of forecasting resource demand and provisioning capacity to meet it, informed by queuing theory. - [Constraints Over Shortcuts](https://banes-lab.com/records/algo/no-shortcuts.md): Replace a debt-incurring shortcut with an encoded constraint that makes the invalid state unrepresentable, so the rule holds without relying on discipline. - [Forward Compatibility Over Backward Compatibility](https://banes-lab.com/records/algo/no-backward-compat.md): Replace accreted legacy input shapes with one forward-compatible envelope that carries extensions, so evolution compounds instead of branching. - [Fail-Fast Over Fallback](https://banes-lab.com/records/algo/no-fallback.md): Replace a silent fallback default with a required input that halts loudly when absent, so missing configuration surfaces at the boundary. - [Explicit Removal Over Deprecation](https://banes-lab.com/records/algo/no-deprecation.md): Replace a deprecated alias kept for compatibility with outright removal, so the single current name is the only path. - [Greenfield Over Legacy](https://banes-lab.com/records/algo/no-legacy.md): Replace a legacy-mode branch with one current algorithm, deleting the old path rather than gating it behind a flag. - [Single-Path Determinism Over Dual-Path](https://banes-lab.com/records/algo/no-dual-path.md): Collapse a flag-selected dual path into one deterministic path, removing the branch and the flag that caused ambiguity. - [Immediacy Over Deferring](https://banes-lab.com/records/algo/no-deferring.md): Replace a deferred follow-up with an atomic action that completes every coupled effect now, so nothing is forgotten. - [Mandatory Over Optional](https://banes-lab.com/records/algo/no-optional.md): Replace an optional dependency with a mandatory one, removing the null-guarded branch so behavior is system-defined not caller-defined. - [Now Over For-Now](https://banes-lab.com/records/algo/no-for-now.md): Replace a temporary in-memory placeholder with the real durable implementation immediately, so the stopgap never ossifies. - [Observed Execution Over Unobserved](https://banes-lab.com/records/algo/no-unobserved.md): Wrap an unobserved effect in structured telemetry so every execution emits a learnable signal on success and failure. - [Compression Over Repetition](https://banes-lab.com/records/algo/no-uncompressed.md): Extract a repeated pattern into one parameterized form, so the behavior lives once and duplication cannot drift. - [Approved Evolution Over Unapproved](https://banes-lab.com/records/algo/no-unapproved.md): Gate a structural dependency behind a recorded architecture decision, so evolution proceeds only through approved boundaries. - [Enforced Feedback Over Ignored](https://banes-lab.com/records/algo/no-ignored-feedback.md): Turn a logged-and-ignored warning into an enforced result, so negative feedback changes control flow instead of scrolling past. - [Single Owner Over Shared Ownership](https://banes-lab.com/records/algo/no-shared-ownership.md): Give one service authority over a piece of state and propagate to others by event, removing multi-writer ambiguity. - [Bounded Lifetime Over Unbounded](https://banes-lab.com/records/algo/no-unbounded.md): Replace an unbounded cache with a capacity-bounded structure that evicts and clears, so memory release is deterministic. - [Enforced Symmetry Over Asymmetric Lifecycle](https://banes-lab.com/records/algo/no-asymmetric.md): Pair every acquire with a guaranteed release via try/finally, so a fault mid-use cannot leak the resource. - [Explicit Retention Over Implicit](https://banes-lab.com/records/algo/no-implicit-retention.md): Replace an anonymous listener push with an explicit retention token that names its owner and exposes release. - [Structural Release Over Discipline](https://banes-lab.com/records/algo/no-discipline-release.md): Replace manual release calls with a language disposal scope, so cleanup is enforced structurally, not by the developer's memory. - [Immutable Data Over Mutable State](https://banes-lab.com/records/algo/no-mutable.md): Replace in-place mutation with a pure transform returning new data, so state transitions are reproducible. - [Errors As Language Over Silent Errors](https://banes-lab.com/records/algo/no-silent.md): Replace a null-on-failure return with a typed result union, so failure is machine-processable rather than swallowed. - [Explicit Invalidity Over Hidden](https://banes-lab.com/records/algo/no-hidden-invalidity.md): Model invalid state as an explicit variant rather than coercing to a plausible default that hides uncertainty. - [Event Emission Over Parent Callbacks](https://banes-lab.com/records/algo/no-callbacks.md): Replace a parent-supplied callback with an emitted event, decoupling the producer from its consumers. - [Monotonic Growth Over Retraction](https://banes-lab.com/records/algo/no-retraction.md): Replace destructive deletion with an append-only removal event, so history is monotonic and projectable. - [Semantic Addressing Over Location Addressing](https://banes-lab.com/records/algo/no-location.md): Replace positional path addressing with a semantic identity reference, so references survive structural change. - [Ordinal Time Over Timestamps](https://banes-lab.com/records/algo/no-timestamps.md): Replace wall-clock ordering with an ordinal sequence, so event order is logical and clock-independent. - [Homoiconicity Over Separation](https://banes-lab.com/records/algo/no-separation.md): Fuse behavior and its separate metadata into one homoiconic data structure that is both the rule and its description. - [Bounded Complexity Over Unlimited](https://banes-lab.com/records/algo/no-unlimited.md): Constrain an open-ended rule surface to a bounded grammar with depth and fan-out limits, capping cognitive load. - [Computed Health Over Metric Health](https://banes-lab.com/records/algo/no-metrics.md): Replace threshold-on-metrics health with a symbolic diagnosis that names the causes of an unready state. - [Secret Store Over Hardcoded Secrets](https://banes-lab.com/records/algo/no-hardcoded-secrets.md): Replace an inline secret with a resolved read from a secret store that fails fast when the secret is absent. - [Boundary Validation Over Unvalidated Input](https://banes-lab.com/records/algo/no-unvalidated-input.md): Parse and validate untrusted input at the boundary into a typed shape, failing fast on malformed data. - [Least Privilege Over Broad Privilege](https://banes-lab.com/records/algo/no-broad-privilege.md): Narrow a broad capability to the minimal typed interface a task needs, shrinking the blast radius. - [Config Externalization Over Env Fallback](https://banes-lab.com/records/algo/no-env-fallback.md): Replace env-var-or-default reads with a validated config loaded at boot that fails fast on missing values. - [Profile-First Over Unmeasured Optimization](https://banes-lab.com/records/algo/no-unmeasured-optimization.md): Gate any optimization behind a measured profile, so effort is evidence-driven rather than speculative. - [Rule As Code Over Convention](https://banes-lab.com/records/algo/no-convention-enforcement.md): Replace a written convention with an automated gate, so the invariant is enforced by code not by memory. - [Design By Contract Over Implicit Contract](https://banes-lab.com/records/algo/no-implicit-contract.md): State pre-conditions, post-conditions, and invariants explicitly, so a boundary's contract is checkable not assumed. - [Versioned Evolution Over Breaking Change](https://banes-lab.com/records/algo/no-breaking-change.md): Introduce change behind a version so existing consumers keep a stable contract while new ones adopt the new shape. - [Schema-Validated Boundary Over Untyped](https://banes-lab.com/records/algo/no-untyped-boundary.md): Type and schema-validate every boundary crossing, so invalid state cannot enter the typed core. - [Atomic Boundary Over Partial Commit](https://banes-lab.com/records/algo/no-partial-commit.md): Wrap coupled writes in an all-or-nothing boundary, so a fault cannot leave state half-applied. - [Saga Compensation Over Distributed 2PC](https://banes-lab.com/records/algo/no-distributed-2pc.md): Replace a cross-service two-phase commit with a saga of compensable steps, preserving service autonomy. - [Async Events Over Synchronous Cross-Boundary](https://banes-lab.com/records/algo/no-sync-cross-boundary.md): Replace a synchronous call across an autonomy boundary with an asynchronous event, decoupling in time. - [Observable Signals Over Opaque Runtime](https://banes-lab.com/records/algo/no-opaque-runtime.md): Emit structured signals around runtime behavior, so operation is observable rather than blind. - [Injected Dependency Over Hidden](https://banes-lab.com/records/algo/no-hidden-dependency.md): Surface a concealed dependency as a constructor parameter, inverting control and revealing coupling. - [Convention Discovery Over Hardcoded Wiring](https://banes-lab.com/records/algo/no-hardcoded-wiring.md): Replace enumerated wiring with convention-based discovery, so new components register without editing a central list. - [Declarative Config Over Imperative](https://banes-lab.com/records/algo/no-imperative-config.md): Replace imperative setup steps with declarative configuration describing the desired state. - [Anti-Corruption Layer Over Cross-Context Leak](https://banes-lab.com/records/algo/no-leaky-context.md): Insert an anti-corruption layer at a context boundary, so a foreign model cannot corrupt the local one. - [Injected Nondeterminism Over Hidden](https://banes-lab.com/records/algo/no-hidden-nondeterminism.md): Inject clocks, randomness, and IO so the core is deterministic and testable, isolating nondeterminism at the edge. - [Pattern By Fit Over Speculative Pattern](https://banes-lab.com/records/algo/no-speculative-pattern.md): Introduce a pattern only when a present force demands it, avoiding accidental complexity from anticipated needs. - [Document Truth Alignment](https://banes-lab.com/records/algo/document-truth-alignment.md): For any document that states facts about a codebase, separate invariant facts (counts, paths, names, and the doc-type's structural schema) from variant prose, bind each invariant to a code-derived value through a stable key, compile the document from a template, and gate the output so a stated fact can never drift from the code it describes. - [Architectural Contract Kernel](https://banes-lab.com/records/algo/architectural-contract-kernel.md): For any programmatic system, identify architectural concerns, define explicit contracts for each concern, bind implementations to those contracts, validate invariants, observe behavior, and evolve through versioned change. - [Responsibility Boundary](https://banes-lab.com/records/algo/responsibility-boundary.md): Partition behavior into cohesive units, assign each unit one reason to change, hide internal details, expose only intentional interfaces, and reject cross-boundary leakage. - [Coupling Control](https://banes-lab.com/records/algo/coupling-control.md): Detect dependency directions, invert dependencies toward abstractions, restrict imports to approved boundaries, and preserve autonomy between modules. - [Interface Contract](https://banes-lab.com/records/algo/interface-contract.md): Define explicit interfaces with preconditions, postconditions, invariants, error semantics, version rules, and compatibility guarantees before implementation. - [Substitutability](https://banes-lab.com/records/algo/substitutability.md): Validate that every implementation of an abstraction preserves the abstraction’s behavior, accepts valid parent inputs, returns valid parent outputs, and does not strengthen forbidden constraints. - [Canonical Data](https://banes-lab.com/records/algo/canonical-data.md): Normalize incoming data into a canonical schema, validate types and semantics, preserve one source of truth, and translate at system boundaries only. - [Domain Boundary](https://banes-lab.com/records/algo/domain-boundary.md): Identify bounded contexts, define ubiquitous language inside each context, map relationships between contexts, and use anti-corruption layers when semantics differ. - [Self-Description Manifest](https://banes-lab.com/records/algo/self-description-manifest.md): Require every component to declare identity, capabilities, contracts, dependencies, configuration, health model, and version metadata in a machine-readable manifest. - [Runtime Discovery](https://banes-lab.com/records/algo/runtime-discovery.md): Discover available components by manifest, convention, registry, or service endpoint; validate discovered candidates against contracts; bind dynamically only after compatibility checks. - [Extension Point](https://banes-lab.com/records/algo/extension-point.md): Define stable extension contracts, register implementations through IoC or plugin registries, isolate plugin failures, and expose deterministic loading order. - [Construction Boundary](https://banes-lab.com/records/algo/construction-boundary.md): Hide object creation behind factories, builders, prototypes, or abstract factories so callers depend on creation contracts rather than concrete constructors. - [Structural Mediation](https://banes-lab.com/records/algo/structural-mediation.md): Insert adapters, facades, proxies, bridges, or decorators where incompatible structure, access control, abstraction separation, or behavior layering is required. - [Behavioral Dispatch](https://banes-lab.com/records/algo/behavioral-dispatch.md): Externalize variable behavior into strategies, template hooks, observers, or mediators while preserving stable orchestration contracts. - [Architectural Style Boundary](https://banes-lab.com/records/algo/architectural-style-boundary.md): Select an architectural style by dependency direction, deployment needs, domain size, team topology, and change isolation requirements; enforce style through boundary rules. - [Port Adapter](https://banes-lab.com/records/algo/port-adapter.md): Place domain logic behind inbound and outbound ports, implement external technology through adapters, and forbid domain dependence on infrastructure. - [Event Messaging](https://banes-lab.com/records/algo/event-messaging.md): Convert state changes into events, classify domain versus integration events, publish through durable channels, consume idempotently, and preserve ordering where required. - [Saga Compensation](https://banes-lab.com/records/algo/saga-compensation.md): For long-running distributed workflows, split work into steps, persist progress, define compensating actions, and recover from partial failure through forward or backward correction. - [Transaction Boundary](https://banes-lab.com/records/algo/transaction-boundary.md): Define atomic state-change boundaries, isolate concurrent mutation, enforce consistency rules, and commit or roll back as a unit. - [Idempotent Side Effect](https://banes-lab.com/records/algo/idempotent-side-effect.md): Assign a stable operation identity, check whether the effect was already applied, execute only once, and return the same semantic result for repeated requests. - [Deterministic Core](https://banes-lab.com/records/algo/deterministic-core.md): Push nondeterminism to system edges, keep core logic pure where possible, use immutable inputs, and make outputs reproducible under identical inputs. - [Verification Fitness](https://banes-lab.com/records/algo/verification-fitness.md): Define executable architecture rules, validate with static analysis, specification tests, property tests, and runtime checks, then block release when critical rules fail. - [Error Boundary](https://banes-lab.com/records/algo/error-boundary.md): Detect invalid state early, fail fast for programmer errors, fail safe for recoverable runtime faults, fail secure for security-sensitive failures, and return typed errors. - [Resilience Control](https://banes-lab.com/records/algo/resilience-control.md): Wrap remote or unreliable calls with timeout, retry, circuit breaker, bulkhead isolation, fallback, and backpressure policies. - [Recovery Deployment](https://banes-lab.com/records/algo/recovery-deployment.md): Continuously health-check services, isolate failed instances, fail over to redundancy, roll back unsafe releases, and use canary or blue-green deployment for controlled exposure. - [Observability Trace](https://banes-lab.com/records/algo/observability-trace.md): Attach correlation and causation identifiers to every operation, emit structured logs, metrics, traces, and audit records, then connect them into an explainable execution graph. - [Causality Ordering](https://banes-lab.com/records/algo/causality-ordering.md): Model events as a dependency graph, assign causal metadata, preserve happens-before relationships, and reject or compensate for invalid ordering. - [Performance Scaling](https://banes-lab.com/records/algo/performance-scaling.md): Measure workload, identify bottlenecks, choose vertical or horizontal scaling, partition load, cache safe data, enforce rate limits, and benchmark continuously. - [Cache Correctness](https://banes-lab.com/records/algo/cache-correctness.md): Cache only data with defined freshness, key identity, invalidation triggers, consistency expectations, and fallback behavior. - [Portability Environment](https://banes-lab.com/records/algo/portability-environment.md): Externalize configuration, standardize protocols, isolate platform assumptions, package runtime dependencies, and validate parity across environments. - [Security Policy](https://banes-lab.com/records/algo/security-policy.md): Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, protect secrets, and enforce policy continuously. - [Governance Evolution](https://banes-lab.com/records/algo/governance-evolution.md): Assess architecture against quality attributes, record decisions, analyze impact, enforce standards with fitness functions, and evolve through documented change. - [Control Plane](https://banes-lab.com/records/algo/control-plane.md): Separate control concerns from data execution, centralize policy/configuration/authentication/logging where beneficial, and decentralize runtime execution where autonomy is required. - [Declarative Metaprogramming](https://banes-lab.com/records/algo/declarative-metaprogramming.md): Represent behavior as data, validate the model or DSL, compile or interpret it into runtime behavior, and restrict reflection or code generation behind safety contracts. - [Streaming Dataflow](https://banes-lab.com/records/algo/architecture-streaming-dataflow.md): Process data sequentially through bounded pipeline stages, preserve forward-only semantics where required, apply backpressure, and keep stages stateless unless state is explicitly modeled. - [Model Lifecycle Governance](https://banes-lab.com/records/algo/ai-model-governance.md): Register models and datasets, version prompts and artifacts, evaluate behavior against benchmarks, validate safety constraints, trace inference inputs, and monitor drift after deployment. - [RAG Knowledge Boundary](https://banes-lab.com/records/algo/rag-knowledge-boundary.md): Retrieve knowledge from indexed sources, validate relevance and freshness, ground generation in retrieved evidence, and distinguish known, inferred, and unsupported output. - [Architecture Selection Meta-Algorithm](https://banes-lab.com/records/algo/architecture-selection-meta-algorithm.md): Given a concern, classify its force type, select the corresponding contract family, compose required invariants, bind implementation patterns, and attach validation gates. - [Universal Architectural Concern Template](https://banes-lab.com/records/algo/universal-architectural-concern-template.md): For any architectural concern, define its intent, boundary, contract, invariants, allowed variation, forbidden leakage, validation strategy, observability model, and evolution policy. - [Architectural Contract Algebra](https://banes-lab.com/records/algo/architectural-contract-algebra.md): → → → → → → → - [Manifest-Driven Documentation](https://banes-lab.com/records/algo/manifest-driven-documentation.md): For a module whose public surface is machine-derivable, make its metadata manifest the single documentation source of truth: authored narrative lives in mandated, shape-validated manifest fields (with self-expanding custom fields), the API surface is collected deterministically from the built type-declarations, one marker-layered document is compiled per module from both, and a governance router runs the context-detection rules on the manifest strings where a manifest governs (rendering each field to its markdown fragment first) and on the document itself where none exists. Beyond the module document, a manifest may declare typed documents — each a form plus concern that routes through the pure location function to a computed path — generated and drift-checked the same way, so the manifest is the single content generator with no separate template mechanism. - [Consumer Config SSOT](https://banes-lab.com/records/algo/consumer-config-ssot.md): For any reusable package that must stay agnostic of the applications consuming it, hardcode zero consumer-specific truths in package source; declare every consumer-specific value in one consumer-owned config of typed sections, load it through a framework the leaf packages never import, and hand each package only the section it needs through an injection surface — so a package drops into any consumer without a literal about that consumer leaking through its source. - [Finite State Machine](https://banes-lab.com/records/algo/finite-state-machine.md): Model behavior as a finite set of states with explicit legal transitions, so illegal state combinations are unrepresentable. - [Statecharts](https://banes-lab.com/records/algo/statecharts.md): Extend a flat state machine with hierarchy and parallel regions, so independent concerns compose without state explosion. - [Petri Nets](https://banes-lab.com/records/algo/petri-nets.md): Model concurrent flow as places, tokens, and transitions, so reachability and deadlock are analyzable before runtime. - [Queuing Theory](https://banes-lab.com/records/algo/queuing-theory.md): Size a system from arrival and service rates, so capacity and wait time are predicted rather than guessed. - [Static-to-Dynamic Readiness](https://banes-lab.com/records/algo/static-to-dynamic-readiness.md): Detect static implementation patterns, classify whether they are intentional or problematic, measure maintainability pressure, verify convention strength, and automate only when stability or fallback exists. - [Runtime-Neutral Automation Boundary](https://banes-lab.com/records/algo/runtime-neutral-automation-boundary.md): Express discovery, reading, searching, validation, persistence, and reporting as semantic operations, then delegate concrete mechanics to runtime adapters. - [Automation Operation Mode](https://banes-lab.com/records/algo/automation-operation-mode.md): Detect operation mode, bind allowed actions, prohibit source mutation outside implementation mode, and emit analysis, design, implementation, or validation artifacts accordingly. - [Capability Degradation](https://banes-lab.com/records/algo/capability-degradation.md): Declare required capabilities, probe availability, emulate missing behavior where safe, disclose unavailable capability, and downgrade confidence or block dependent operations. - [Automation Opportunity Detection](https://banes-lab.com/records/algo/automation-opportunity-detection.md): Search target scope for manual registries, hardcoded references, static lists, and duplicated discovery logic; then classify each finding with count, location, role, and maintenance signal. - [Intentional Static Separation](https://banes-lab.com/records/algo/intentional-static-separation.md): For each static pattern, compare size, frequency, stability, and risk; classify small or stable patterns as intentionally static candidates instead of automation debt. - [Breaking Point Calculation](https://banes-lab.com/records/algo/breaking-point-calculation.md): Measure current item count, estimate growth rate, compare against cognitive and maintenance limits, compute time or units until threshold breach, and assign severity. - [Automation Priority Ordering](https://banes-lab.com/records/algo/automation-priority-ordering.md): Convert breaking points into urgency scores using severity, projected time-to-break, affected scope, and expected maintenance cost, then sort candidate migrations. - [Convention Strength Analysis](https://banes-lab.com/records/algo/convention-strength-analysis.md): Discover related resources, extract naming tokens and organization patterns, calculate consistency percentages, and mark auto-discovery readiness only when convention strength passes threshold. - [Extension Interface Discovery](https://banes-lab.com/records/algo/extension-interface-discovery.md): Search for inheritance, composition, shared method contracts, and shared schema contracts; group similar implementations; infer interface candidates when implementation count exceeds threshold. - [Scalability Projection](https://banes-lab.com/records/algo/scalability-projection.md): Measure current resource counts, project tenfold and hundredfold growth, assess manual maintenance feasibility, and identify where dynamic discovery becomes necessary. - [Performance-Aware Discovery Design](https://banes-lab.com/records/algo/performance-aware-discovery-design.md): Estimate discovery and loading cost, compare large-scale cost against performance targets, introduce caching only when justified, and record failure modes. - [Dynamic Extension Architecture](https://banes-lab.com/records/algo/dynamic-extension-architecture.md): Infer extension contracts, define discovery conventions, validate discovered implementations against the contract, preserve manual registration fallback, and report discovered, skipped, failed, and manual items. - [Centralized Reference Resolver](https://banes-lab.com/records/algo/centralized-reference-resolver.md): Group duplicated hardcoded references, derive resolver names, define scope-safe resolution rules, provide configuration override fallback, and map each old reference to a resolver migration. - [Cache Invalidation Strategy](https://banes-lab.com/records/algo/cache-invalidation-strategy.md): Define cache keys by scope, convention, adapter version, and implementation identity; invalidate by resource change, explicit request, time expiry, or implementation version change. - [Manual Fallback Preservation](https://banes-lab.com/records/algo/manual-fallback-preservation.md): Keep explicit registration paths for non-conforming or exceptional implementations, order manual entries deterministically, and report manual items separately from auto-discovered items. - [Dynamic Failure Isolation](https://banes-lab.com/records/algo/dynamic-failure-isolation.md): On individual discovery, loading, or validation failure, isolate the failing item, continue with valid items where safe, and report the failed item with reason. - [Entry Point Migration](https://banes-lab.com/records/algo/entry-point-migration.md): Locate composition roots, identify manual registrations and hardcoded references, compose updates that use discovery registries and centralized resolvers, and apply only in implementation mode. - [Measured-vs-Estimated Validation](https://banes-lab.com/records/algo/measured-vs-estimated-validation.md): Run validation when execution is available; otherwise estimate from static evidence, label the result as estimated, and never report estimated performance as measured. - [Architecture Validation Before Persistence](https://banes-lab.com/records/algo/architecture-validation-before-persistence.md): Validate generated contracts, registries, resolvers, plans, and entry point updates against schemas and architectural rules before saving or modifying any artifact. - [Knowledge Capture](https://banes-lab.com/records/algo/knowledge-capture.md): Load or initialize the automation knowledge base, merge new detections, conventions, scalability concerns, architecture designs, migration history, and validation outcomes, then persist when capability exists. - [Automation Session Report](https://banes-lab.com/records/algo/automation-session-report.md): Summarize detected patterns, convention readiness, scalability pressure, dynamic architecture, generated artifacts, implementation status, measured versus estimated validation, and limitations. - [Automation Completion Status](https://banes-lab.com/records/algo/automation-completion-status.md): Mark the static-to-dynamic automation complete only when convention strength passed, a manual fallback is preserved, performance and architecture validation passed with measured provenance, and any degraded capability is disclosed; otherwise report planned-only or blocked. - [Automation Kernel](https://banes-lab.com/records/algo/automation-kernel.md): Load configuration, verify capabilities, initialize knowledge, detect static patterns, classify automation opportunity, analyze conventions, assess scale and performance, design dynamic architecture, optionally implement, validate, update knowledge, and report. - [](https://banes-lab.com/records/algo/automation-concern.md): → → → → → → → - [Runtime-Agnostic Adapter Boundary](https://banes-lab.com/records/algo/runtime-agnostic-adapter-boundary.md): Express all workflow operations as semantic verbs, delegate runtime-specific mechanics to adapters, and prohibit repository-, shell-, framework-, model-, or path-specific logic from entering the core contract. - [Operation Mode Gating](https://banes-lab.com/records/algo/operation-mode-gating.md): Detect the requested operation mode, bind permitted capabilities, reject source mutation outside execution mode, and emit only artifacts valid for the current mode. - [Capability Disclosure](https://banes-lab.com/records/algo/capability-disclosure.md): Declare required capabilities, probe or emulate each capability, mark unavailable capabilities explicitly, and downgrade confidence where capability gaps affect evidence quality. - [Pattern Classification](https://banes-lab.com/records/algo/pattern-classification.md): Extract the target pattern description, classify it into a known centralization category, select a search strategy, select a validation strategy, and request the developer's decision only when classification remains ambiguous. - [Refactor Intent Classification](https://banes-lab.com/records/algo/refactor-intent-classification.md): Determine whether the scattered pattern represents a duplication problem, default multiple-occurrence problems to replacement refactor, and require explicit debt justification for additive enhancement. - [Research Guidance](https://banes-lab.com/records/algo/research-guidance.md): Query available external or local guidance, extract best practices and anti-patterns, score research quality, and disclose reduced confidence when current external research is unavailable. - [Iterative Variation Discovery](https://banes-lab.com/records/algo/iterative-variation-discovery.md): Search for the primary pattern, inspect match context, infer variants, add new variants to the search set, and repeat until no new variations appear or the iteration cap is reached. - [Detection Registry](https://banes-lab.com/records/algo/detection-registry.md): For every discovered occurrence, record resource, location, local context, matched pattern, extracted value, occurrence role, variation type, and discovery iteration. - [Canonical Variation Selection](https://banes-lab.com/records/algo/canonical-variation-selection.md): Compare all detected variations by frequency, completeness, architectural fitness, and semantic coverage, then select the canonical implementation from evidence rather than preference. - [Architecture Compliance Targeting](https://banes-lab.com/records/algo/architecture-compliance-targeting.md): Load relevant architecture and validation guidance, inspect existing centralized patterns, check naming and capacity constraints, detect conflicts, and select a justified centralization target. - [Existing Solution Conflict](https://banes-lab.com/records/algo/existing-solution-conflict.md): Search existing centralized locations for the same or overlapping pattern, classify whether to reuse, extend, create a distinct target, or cancel, and require the developer's decision when conflict resolution is not mechanically safe. - [Migration Action Mapping](https://banes-lab.com/records/algo/migration-action-mapping.md): Convert every detection-registry occurrence into an explicit migration action, including old content, replacement strategy, skip policy, and justification requirement. - [Atomic Refactor Phase](https://banes-lab.com/records/algo/atomic-refactor-phase.md): Divide the refactor into ordered phases, attach actions, attach verification criteria, attach rollback behavior, and prevent progression until the phase verification passes. - [Replacement Refactor](https://banes-lab.com/records/algo/replacement-refactor.md): Create the centralized implementation, establish reference infrastructure, migrate all occurrences, delete old definitions, verify zero duplication, and run final validation. - [Additive Debt Gate](https://banes-lab.com/records/algo/additive-debt-gate.md): When a proposed abstraction leaves old patterns in place, require explicit approval, document retained debt, define deprecation conditions, and prohibit calling the result complete centralization. - [Rollback-Centered Execution](https://banes-lab.com/records/algo/rollback-centered-execution.md): Before each destructive or high-risk phase, create a checkpoint, execute actions, verify results, and roll back immediately on critical action or verification failure. - [Pattern-Specific Validation](https://banes-lab.com/records/algo/pattern-specific-validation.md): Select validation checks by pattern type, execute or mark each unavailable, verify architecture compliance, check all known variations for orphaned duplicates, and compute validation score. - [Zero-Duplication Verification](https://banes-lab.com/records/algo/zero-duplication-verification.md): Search every known primary and variant pattern outside the approved centralized location, classify remaining matches as approved or orphaned, and require zero unapproved matches for replacement refactors. - [Validation Score](https://banes-lab.com/records/algo/validation-score.md): Count total validation checks, count passed checks, divide safely, and mark complete only when the score is perfect and no remaining issues exist. - [Developer Decision Gate](https://banes-lab.com/records/algo/developer-decision-gate.md): Request the developer's decision before destructive, ambiguous, conflict-prone, additive-with-debt, or high-risk actions, then bind the selected decision into subsequent plan state. - [Completion Truthfulness](https://banes-lab.com/records/algo/completion-truthfulness.md): Mark centralization complete only if all critical criteria pass, all old patterns are removed or justified, zero duplication is verified, validation evidence is recorded, and remaining issues are empty. - [Centralization Report](https://banes-lab.com/records/algo/centralization-report.md): Compose a final report containing classification, research confidence, detection metrics, architecture decision, plan, execution status, validation score, remaining issues, artifact references, and unavailable capabilities. - [Centralization Kernel](https://banes-lab.com/records/algo/centralization-kernel.md): Initialize runtime context, classify the target pattern, gather research, discover all variations, analyze architecture, build a refactor plan, optionally execute migration, validate zero duplication, and report status. - [](https://banes-lab.com/records/algo/centralization-concern.md): → → → → → → → - [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md): Establish authority, trust, intent, and change-directionality, and gather current-system evidence before any planning, emitting a context bundle that is the sole artifact the planning stage reads. - [Authoritative Source Loading](https://banes-lab.com/records/algo/authoritative-source-loading.md): Resolve the always-read core sources plus the conditional sources whose triggers appear in the task, read them before analysis, and block with a blocker finding if any required source is missing. - [Trust Anchor](https://banes-lab.com/records/algo/trust-anchor.md): Classify every input by trust level — source files, schema/config/data, build and validator output, tool output, and structured logs are trusted; narrative docs, comments, prior codebase knowledge, and unverified claims are untrusted and require verification before use. - [Intent & Directionality Normalization](https://banes-lab.com/records/algo/intent-directionality-normalization.md): Normalize the task into a requested outcome, actions, and entities, and resolve the change relation — introduce, retain, remove, analyze, or mention — that later stages key their semantic policy on; an unresolved direction is recorded as ambiguity, never silently assumed. - [Skeptical Context Acquisition](https://banes-lab.com/records/algo/skeptical-context-acquisition.md): Extract task keywords, generate discovery probes dynamically, inspect the existing implementation, and prevent new work from redefining architecture that already exists. - [Dynamic Discovery Pattern Generation](https://banes-lab.com/records/algo/dynamic-discovery-pattern-generation.md): Convert extracted nouns, verbs, folders, and file references into glob, grep, and target-file probes generated from the task's own language rather than a fixed enumeration. - [Teleological Intent Gate](https://banes-lab.com/records/algo/teleological-intent-gate.md): Resolve what the checklist is for before planning it: enumerate the admissible decomposition branches, score each by utility minus cost against the normalized intent and change relation, and gate on the highest-worth admissible branch before any seeing or deriving. - [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md): Activate the principles that govern the current decision surfaces, select protocols by semantic fit against the requested transition, decompose them into phases, build the four-dimensional graph, and linearize the phases by dependency. - [Principle Activation](https://banes-lab.com/records/algo/principle-activation.md): Test each principle in the ontology catalog against the current decision surfaces, mark it applies, uncertain, or not-applicable with a reason, and bind every applied principle to a decision test, a validator, and a severity that later routes its repair. - [Protocol Semantic Selection](https://banes-lab.com/records/algo/protocol-semantic-selection.md): Match the requested state transition and architecture surfaces semantically against the protocol library, select every protocol whose use-condition fits, and always inject the mandatory verification protocol. - [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md): Expand each selected protocol's verb chain into phases, and annotate every phase with an id, verb, objective, preconditions, inputs, outputs, affected artifacts, local principles, severity, loop class, and a four-dimensional graph. - [Four-Dimensional Phase Graph](https://banes-lab.com/records/algo/four-dimensional-phase-graph.md): For every phase, model the sequential dependency axis, the lateral independent-peer axis, the diagonal shared-data axis, and the propagation axis carrying superseded state, propagated contracts, and what breaks if the edge is omitted. - [Dependency Linearization](https://banes-lab.com/records/algo/dependency-linearization.md): Detect cycles in the sequential Z-graph, block if any exist, and otherwise order the phases in topological Z-order with a stable tie-breaker so execution order is fixed by dependency alone. - [Severity Assignment](https://banes-lab.com/records/algo/severity-assignment.md): Derive each phase's severity from the worst severity of its governing principles; severity is per-phase metadata that selects the repair route, while execution order stays linear by dependency. - [Loop Class Labeling](https://banes-lab.com/records/algo/loop-class-labeling.md): Classify each phase by its verb into a construction, perceptual, cognitive, executive, or linking loop class so the phase's cognitive role is explicit. - [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md): Compile each phase into atomic, target-specific tasks under binding codebase-pattern execution constraints, attach a full nine-dimension named ripple chain to every task, and number the hierarchy N.N.N. - [Codebase Pattern Enforcement](https://banes-lab.com/records/algo/codebase-pattern-enforcement.md): Bind every emitted step to the required architecture pattern for its concern — factory construction, dependency injection, registry discovery, event emission, ports and adapters, contract-first boundaries, encapsulation, structured observability, bounded complexity, secrets management, input validation, least privilege, config externalization, fail-fast, legacy elimination, and enforcement authoring — rewriting each forbidden form into its required form. - [Verb Template Binding](https://banes-lab.com/records/algo/verb-template-binding.md): Map each execution verb to a task pattern, a tool set, and a blocking validation command, so a verb becomes a checklist task only through a validated template. - [Task Atomization](https://banes-lab.com/records/algo/task-atomization.md): Extract atomic, target-specific actions from each phase group, gate every action through the codebase-pattern constraints, and attach an evidence contract, local principle checks, a validation method, and a done-condition to each. - [Ripple Chain Analysis](https://banes-lab.com/records/algo/ripple-chain-analysis.md): Analyze each task across nine impact dimensions — registry, contracts, persistence, security, infrastructure, performance, observability, enforcement, and consumers — and record every named downstream effect with its consequence-if-omitted rather than a count, retaining an empty dimension with explicit applicability evidence. - [Validator Coverage](https://banes-lab.com/records/algo/validator-coverage.md): For every architectural pattern introduced or referenced, discover an existing detector or author a new one, register it, and regenerate the catalog so the rule becomes an active enforcement gate rather than a convention. - [Structured Observability Context](https://banes-lab.com/records/algo/structured-observability-context.md): Detect whether a task touches errors, contract or invariant violations, events, or resource lifecycle, and require the matching structured, machine-queryable observability context instead of a free-form message. - [Cross-Cutting Surface Coverage](https://banes-lab.com/records/algo/cross-cutting-surface-coverage.md): Gate the software surface beyond structure — security, performance, infrastructure and deployment, and resilience — so a change's threat, budget, config, and failure consequences are covered, not only its structural ones. - [Legacy Elimination](https://banes-lab.com/records/algo/legacy-elimination.md): For any change that touches a replaced, deprecated, dual-path, or fallback code path, delete the superseded path and its orphaned exports in the same completed change so exactly one forward path remains. - [Hierarchical Numbering](https://banes-lab.com/records/algo/hierarchical-numbering.md): Render addressable coordinates — Phase N, Task N.N, Subtask N.N.N — assigned only after the phase order is stable. - [Admissibility Constraint Gate](https://banes-lab.com/records/algo/admissibility-constraint-stage.md): Gate the formalised plan on teleological admissibility before verification: sum the realised cost, compare it to the selected branch's budget and hard limits, and confirm every task traces to the selected branch — an over-budget, limit-breaching, or off-branch plan is inadmissible and routes back rather than being silently accepted. - [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md): Judge the generated reasoning — not the future implementation — against evidence and semantic policy: run the governance validation suites, verify every material claim by evidence, and apply the semantic-debt rubric before rendering. - [Semantic Debt Policy](https://banes-lab.com/records/algo/semantic-debt-policy.md): Classify the relation a task holds to each controlled debt concept — backward-compatibility path, failure-masking fallback, deprecated or dual production path, deferred required work, shortcut debt, and unsupported superlative claim — blocking only the introduce and retain relations while allowing mention, analysis, quotation, and removal. - [Evidence-Based Claim Verification](https://banes-lab.com/records/algo/evidence-based-claim-verification.md): Extract every material claim from the generated records, weigh supporting against contradicting evidence in the inventory, and classify each as supported, contradicted, not-applicable, or unsupported — recording the searched scope for a zero-result claim. - [Validation Suite Battery](https://banes-lab.com/records/algo/validation-suite-battery.md): Run the governance validation suites over the generated context, phases, tasks, and claims — state integrity, authority, principle activation, plan graph, tasks, ripple, semantic policy, evidence, and output serializability — and emit findings that each name what was examined and carry an owner stage. - [Repair Stage](https://banes-lab.com/records/algo/repair-stage.md): Route every finding to its earliest responsible owner stage, apply the fix, invalidate every dependent record downstream, and re-run from that stage — bounded to a fixed number of cycles, after which the run terminates as blocked with the remaining findings. - [Bounded Repair Loop](https://banes-lab.com/records/algo/bounded-repair-loop.md): Cap the repair loop at a fixed cycle limit, and on each cycle repair from the earliest invalid stage, invalidate all downstream records, and regenerate them; exceeding the limit sets the run blocked with the remaining findings. - [Severity Failure Routing](https://banes-lab.com/records/algo/severity-failure-routing.md): Use each finding's severity to choose its repair route — a blocker blocks and repairs, an error repairs, a warning requires a disposition, and anything lower is investigated. - [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md): Serialize only validated records into the checklist deterministically, or render the blocked report, emitting exactly one terminal — success or blocked — with future execution checkboxes left unchecked, and stop within the cycle bound. - [Checklist Output Rendering](https://banes-lab.com/records/algo/checklist-output-rendering.md): Emit the markdown checklist — governing context, principle disposition, phases in Z-topological order with loop class, severity, four-dimensional graph, and named ripple chains, hierarchically numbered tasks with evidence contracts, per-phase execution gates, appendices, and a final blocking execution gate — all left unchecked for future execution. - [Explicit Termination](https://banes-lab.com/records/algo/explicit-termination.md): Guarantee the generator stops with exactly one terminal — a written success artifact whose rendering integrity is verified, or a written blocked report — never a premature stop while the status is repairable and never a loop beyond the cycle bound. - [Cross-Stage Invariants](https://banes-lab.com/records/algo/cross-stage-invariants.md): Bind every stage to the always-and-never rules of the generator — resolve authority and directionality before planning, discover before assuming, activate principles with a bound validator, order by dependency with severity as routing metadata, read only the prior stage's output contract through one evidence-bearing handoff, represent all four graph axes, require evidence for every claim, separate generation gates from future execution gates, repair from the earliest invalid stage, and render deterministically. - [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md): Run the six-stage generator in order — orientation, planning, compilation, validation, repair, and rendering — bound by the cross-stage invariants, compiling a task description into a validated, dependency-aware execution checklist or an evidence-bearing blocked report. - [](https://banes-lab.com/records/algo/checklist-governance-concern.md): → → → → → - [Verification Loop](https://banes-lab.com/records/algo/verification-loop.md): Initialize verification context, execute the verification suite, classify failures, remediate violations, and repeat until pass or iteration limit. - [Context Initialization](https://banes-lab.com/records/algo/context-initialization.md): Discover architecture documents, load design guidance, initialize result containers, set iteration counters, and define maximum remediation attempts. - [Verification Execution](https://banes-lab.com/records/algo/verification-execution.md): Run the configured verification procedure, capture raw output, parse errors and warnings, and derive pass status from zero-error condition. - [Early Success Exit](https://banes-lab.com/records/algo/early-success-exit.md): If verification has no errors, report successful compliance and terminate without remediation. - [Violation Classification](https://banes-lab.com/records/algo/violation-classification.md): For each verification error, classify the violation into a known remediation category and attach the matching strategy. - [Severity-Ordered Remediation](https://banes-lab.com/records/algo/severity-ordered-remediation.md): Group classified violations by category, order groups by severity, and apply fixes from highest architectural risk to lowest. - [Iteration Bound](https://banes-lab.com/records/algo/iteration-bound.md): Increment iteration count before remediation, compare it to the maximum allowed attempts, and stop with partial success when the bound is exceeded. - [File-Scoped Fix](https://banes-lab.com/records/algo/file-scoped-fix.md): Read the violating file, analyze the violation type, transform content according to design guidance, write the updated content, and preserve compatibility with verification rules. - [File Limit Remediation](https://banes-lab.com/records/algo/file-limit-remediation.md): When a file exceeds the allowed size, split responsibilities into smaller compliant artifacts, preserve imports and exports, and rewire references. - [Import Boundary Remediation](https://banes-lab.com/records/algo/import-boundary-remediation.md): Detect invalid cross-boundary imports, locate the approved dependency path or shared abstraction, rewrite imports, and verify dependency direction. - [Naming Convention Remediation](https://banes-lab.com/records/algo/naming-convention-remediation.md): Compare file, folder, class, or symbol names against naming rules, derive compliant names, rename artifacts, and update all references. - [Base-Class Compliance Remediation](https://banes-lab.com/records/algo/base-class-compliance-remediation.md): Detect classes missing required base abstraction, refactor inheritance or composition according to role rules, migrate duplicated lifecycle logic into hooks, and verify behavior remains represented. - [CSS Token Remediation](https://banes-lab.com/records/algo/css-token-remediation.md): Replace hardcoded style values with approved design tokens, verify token availability, and run style validation. - [DOM Factory Remediation](https://banes-lab.com/records/algo/dom-factory-remediation.md): Replace direct DOM manipulation with the approved DOM factory, component factory, or rendering abstraction. - [Console Usage Remediation](https://banes-lab.com/records/algo/console-usage-remediation.md): Replace direct console calls with the approved logging abstraction, preserve severity and message context, and verify no direct console usage remains. - [Lifecycle Symmetry Remediation](https://banes-lab.com/records/algo/lifecycle-symmetry-remediation.md): Detect resources created without corresponding cleanup, add destroy or teardown paths, and verify create/destroy symmetry. - [Stylelint Post-Fix](https://banes-lab.com/records/algo/stylelint-post-fix.md): After remediation, run style validation, parse style errors, apply style-specific corrections, and block re-verification until style checks pass or are reported. - [Reverification Gate](https://banes-lab.com/records/algo/reverification-gate.md): After fixes and style validation, rerun the full verification suite rather than trusting local corrections. - [Partial Success Reporting](https://banes-lab.com/records/algo/partial-success-reporting.md): When iteration bounds are exhausted, report remaining violations, categorize unresolved issues, and mark the result as requiring manual review. - [Completion Report](https://banes-lab.com/records/algo/completion-report.md): Report total iterations, fixed error count, remaining warnings, and final verification status. - [Codebase Verification Kernel](https://banes-lab.com/records/algo/codebase-verification-kernel.md): Load compliance context, run verification, parse results, exit on pass, classify violations on failure, remediate by severity, run post-fix style validation, and repeat until zero errors or iteration limit. - [](https://banes-lab.com/records/algo/compliance-verification-concern.md): → → → → → → → - [Phase-Separated Execution](https://banes-lab.com/records/algo/phase-separated-execution.md): Detect the current workflow phase, bind allowed operations to that phase, reject operations outside the phase contract, and emit only the artifact valid for that phase. - [Evidence-Gated Claim Verification](https://banes-lab.com/records/algo/evidence-gated-claim-verification.md): Extract claims, resolve each claim into observable evidence requirements, collect direct implementation evidence, classify each claim as verified, contradicted, or unverified, and report discrepancies. - [Validation Gate](https://banes-lab.com/records/algo/validation-gate.md): After each critical stage, evaluate declared success criteria, block downstream progression when critical criteria fail, and carry warning-state forward when noncritical criteria fail. - [File Modification Recovery](https://banes-lab.com/records/algo/file-modification-recovery.md): When a file mutation fails because state changed between read and edit, reread the current file, merge the intended delta into the current content, write the complete new version, and verify persistence. - [Trust Anchor Declaration](https://banes-lab.com/records/algo/trust-anchor-declaration.md): Declare the minimum assumptions required for the system to verify anything, bind all verification logic to those assumptions, and disclose the verification boundary. - [Environment Capability Verification](https://banes-lab.com/records/algo/environment-capability-verification.md): Before executing advanced behavior, probe required runtime dependencies, classify each dependency failure by severity, and degrade or block capability based on criticality. - [Tool Calibration](https://banes-lab.com/records/algo/tool-calibration.md): Create known-good and known-bad fixtures, run the verification tool against both, detect false positives and false negatives, and mark the tool reliable only if both controls pass. - [Behavioral Self-Test](https://banes-lab.com/records/algo/behavioral-self-test.md): Execute the system’s claimed behaviors against simple positive and negative cases, compare actual output to expected output, and treat mismatch as implementation evidence failure. - [Adversarial Input Testing](https://banes-lab.com/records/algo/adversarial-input-testing.md): Generate malicious, malformed, ambiguous, and deceptive inputs, execute the detection logic against them, and classify whether the system resists or accepts invalid patterns. - [Defensive String Normalization](https://banes-lab.com/records/algo/defensive-string-normalization.md): Reject null input, remove dangerous path/control patterns, normalize Unicode representation, and only pass sanitized strings to filesystem, parser, or command boundaries. - [Safe Arithmetic Contract](https://banes-lab.com/records/algo/safe-arithmetic-contract.md): Check operands before calculation, reject division by zero, reject non-finite results, enforce bounds, and return nullable or typed failure instead of unsafe numeric state. - [Recursion Control](https://banes-lab.com/records/algo/recursion-control.md): Increment depth on recursive entry, compare against maximum depth, reject excessive recursion, and unwind depth on completion. - [Recursive Self-Verification](https://banes-lab.com/records/algo/recursive-self-verification.md): Load the system’s own definition, extract self-claims, search for implementation evidence of each claim, classify discrepancies, and downgrade confidence when self-description exceeds implemented behavior. - [Advanced Tool Escalation](https://banes-lab.com/records/algo/advanced-tool-escalation.md): When direct tools cannot answer a verification question, synthesize a specialized analyzer, execute it against the target, parse its output, and integrate the result as evidence. - [Investigation Report](https://banes-lab.com/records/algo/investigation-report.md): Collect verified findings, failed checks, warnings, discrepancies, environmental limits, adversarial results, and confidence level into a structured report without performing remediation. - [Action Log](https://banes-lab.com/records/algo/action-log.md): Accept only documented gaps as input, apply bounded changes, version the modified artifact, verify the write, and emit an action log without discovering new scope. - [Contract-Based Verification Kernel](https://banes-lab.com/records/algo/contract-based-verification-kernel.md): Declare assumptions, detect phase, verify environment, calibrate tools, execute phase-legal behavior, test adversarially, enforce validation gates, self-verify claims, and emit a typed artifact. - [](https://banes-lab.com/records/algo/context-verification-concern.md): → → → → - [Cascade Layer Partition](https://banes-lab.com/records/algo/cascade-layer-partition.md): Declare one ordered set of named cascade layers once at the stylesheet root, assign every rule to exactly one layer, and let layer order — not selector specificity nor source order — decide precedence, so values, appearance, placement, and assembly can never fight for the same declaration. - [Token Source-of-Truth](https://banes-lab.com/records/algo/token-source-of-truth.md): Define every design primitive — color, space, radius, the type scale, size, duration, z-index — exactly once as a custom property in the tokens layer, and forbid any downstream literal where a token exists. - [Type-Keyed Appearance](https://banes-lab.com/records/algo/type-keyed-appearance.md): In the globals layer, define how every element and component type looks, its size, and its spacing exactly once, keyed only by element tag, `data-el` custom type, and the orthogonal `data-*` axes (`data-variant` paint, `data-size` scale, `data-gap` child rhythm, `data-tone` palette, `data-measure` width); never key appearance by a purpose-class, and let every value be a token. - [Custom Type Registration](https://banes-lab.com/records/algo/custom-type-registration.md): Extend the stylable element vocabulary beyond the native HTML tag set by registering each semantic type against a base tag and a `data-el` stamp; the registered type becomes a first-class node the globals layer binds one appearance contract to, so a concept no native tag can express — a field-label, an icon, a toast, an entry — is styled by its type, never by a class. - [Governed Construction Boundary](https://banes-lab.com/records/algo/governed-construction-boundary.md): Route all DOM creation through one governed factory that resolves a node spec of shape `{ el, variant, size, gap, tone, measure, layout, class, on, children }` against the type, handler, and component registries, maps each axis key to its `data-*` attribute, treats `class` as a gated hook (icon-font glyph, `u-*` utility, or `c-*` component — never bespoke, never appearance), throws on any unknown type, handler, or component, and refuses an inline `style` attribute. - [Placement Isolation](https://banes-lab.com/records/algo/placement-isolation.md): In the components layer, set only where a component sits — position, offsets, stacking, overlay — keyed by its type, and never its look, size, or spacing, which remain owned by globals. - [Assembly Composition](https://banes-lab.com/records/algo/assembly-composition.md): In the app layer, compose views from structural containers and arrange their children with flex or grid and token-valued gaps, pad each container once so its children are full-width and fill the padded box, forbid horizontal margins, and never set or override any element's or component's look. - [Layer Fitness Enforcement](https://banes-lab.com/records/algo/layer-fitness-enforcement.md): Bind each layer invariant to a machine check — layer order declared once, placement properties barred from globals, class selectors barred from globals, literals barred where a token exists, no horizontal margin, all DOM through the factory, no inline style — run them as hard errors with no warn tier and no inline disables, and gate the push on a clean verdict. - [Type-Migration Centralization](https://banes-lab.com/records/algo/type-migration-centralization.md): To move an existing purpose-class or page-scoped stylesheet into this model, treat every appearance-bearing class rule as a migration unit, derive the element type it decorates, register a custom `data-el` type when no tag or variant expresses it, move its look, size, and spacing into one global rule keyed by that type, demote any residual position into components and any residual layout into app, and verify that zero appearance rule keyed by a purpose-class remains outside the globals layer. - [CSS Type-Cascade Kernel](https://banes-lab.com/records/algo/css-type-cascade-concern.md): Declare one layer order, hold every value in tokens, key every appearance on a type — native or custom-registered — exactly once in globals, hold placement in components and assembly in app, create all DOM through a factory that stamps types and refuses inline style, and gate the whole contract behind machine fitness functions. - [Living Plan State](https://banes-lab.com/records/algo/living-plan-state.md): Treat the plan as durable append/update-only state — tasks carrying status and grounding, a considerations backlog, and a dismissed-key set — maintained every turn and re-delivered on restart, so anything discovered mid-pass is retained instead of falling out of scope. - [Boundary Reconciliation](https://banes-lab.com/records/algo/boundary-reconciliation.md): Capture considerations during a phase but act on them only at the phase boundary — triage each open consideration against code and canon into a confirmed task or a dismissed resolved-false key, deduping new opens against the confirmed and dismissed sets before triage. - [Phase Close Gate](https://banes-lab.com/records/algo/phase-close-gate.md): Make completion a gated state of the plan rather than a judgment call — a phase closes only when all tasks are done, a dry reconciliation pass holds, verify is clean for the chosen scope, and the coverage graph confirms the ripple set; otherwise the loop returns to execution. - [Plan Phase Verification](https://banes-lab.com/records/algo/plan-phase-verification.md): Before a composed plan reaches the developer, the engine loops it back through evidence, completeness, and adversarial-skepticism passes, reconciles the findings into the plan, and increments a loop-owned pass counter the model cannot forge; a render boundary blocks an unverified plan. - [Governed Autonomous Plan Loop](https://banes-lab.com/records/algo/governed-autonomous-plan-loop.md): Drive a large task to completion under gates — seed per phase, investigate, execute, self-inform from canon and self-audit, capture considerations, reconcile at the boundary, and close only when the plan is a mechanically resolved state, then re-seed the next phase. - [](https://banes-lab.com/records/algo/governed-plan-concern.md): → → → → → - [Profile Compose](https://banes-lab.com/records/algo/profile-compose.md): Specializing the RAG Knowledge Boundary, read the durable profile document (or an empty one), strip volatile metadata, and project a compact view injected into reasoning as retrieved memory rather than ground truth. - [Delta Capture](https://banes-lab.com/records/algo/delta-capture.md): Specializing the RAG Knowledge Boundary, accept a structured knowledge delta the reasoning turn self-reports inline, admit only facts verified within that same turn, and reject speculation without a separate extraction pass. - [Idempotent Merge](https://banes-lab.com/records/algo/idempotent-merge.md): Specializing the Idempotent Side Effect, assign each fact a stable identity, apply the delta per field kind, deduplicate and cap, and guarantee that re-applying the same delta yields the same document. - [Version Provenance](https://banes-lab.com/records/algo/version-provenance.md): Specializing Governance Evolution, detect whether the merge changed state, and only on real change bump the version, timestamp it, and append a modification record — leaving a no-op untouched. - [Deterministic Merge Core](https://banes-lab.com/records/algo/deterministic-merge-core.md): Specializing the Deterministic Core, keep compose and merge pure functions over immutable inputs with the clock injected, so identical inputs reproduce identical outputs. - [Persistence Fork](https://banes-lab.com/records/algo/persistence-fork.md): Specializing the Port Adapter, resolve the durable store by connection mode — an authoritative per-owner store when the trusted arm is connected, a read-only mirror otherwise — and write back only where accumulation is trusted. - [Seed Composition](https://banes-lab.com/records/algo/seed-composition.md): Specializing Canonical Data, overlay the accumulated knowledge onto the frozen baseline scope as additive context without mutating the baseline. - [Living Profile Kernel](https://banes-lab.com/records/algo/living-profile-kernel.md): Compose the accumulated knowledge onto the frozen baseline into a seed, run the reasoning turn, capture the inline verified delta, merge it idempotently under an injected clock, version only real change, and persist against the fork — looping per turn. - [](https://banes-lab.com/records/algo/living-accumulation-concern.md): → → → → → - [Composed Turn Contract](https://banes-lab.com/records/algo/composed-turn-contract.md): Compose a model turn's validation schema and its instruction from one self-registering field registry, projected per mode, so the schema the response is graded against and the instruction the model is given can never drift. - [Loop-Owned Mode Selection](https://banes-lab.com/records/algo/loop-owned-mode-selection.md): The loop assigns the (phase, activity) mode that selects which contract a response is validated against; the model's output carries no contract-selecting field, so a model can never grade itself against a contract it chose. - [Versioned Turn Provenance](https://banes-lab.com/records/algo/versioned-turn-provenance.md): Persist each accepted model turn as an append-only, mode-tagged, schema-versioned, causally ordered record with change-only provenance, so the turn history is a queryable, auditable log and a turn is never graded against a schema version its stored state never saw. - [Mode Contract Validation](https://banes-lab.com/records/algo/mode-contract-validation.md): Validate the model's response against the loop-selected mode contract and, on a validation miss, drive an error-specific self-healing retry bounded by the contract, so a response is accepted only when it satisfies the schema it is graded against. - [](https://banes-lab.com/records/algo/mode-driven-response-schema.md): Make the model's structured output a mode-driven composed contract — the output mirror of composed input context: per loop-owned mode the schema and instruction are projected from one field registry, the response is validated and self-heals against it, the typed fields are governed, and every turn is persisted as a versioned queryable record — so the output has one source, cannot drift from its instruction, and can be audited. - [PAG Document Declaration](https://banes-lab.com/records/algo/pag-document-declaration.md): Bind a document to a declared type and its default verb (THIS ) after the YAML frontmatter and before any node, then declare in the meta block what the document is for, which sources ground which, what it trusts, what it may touch and what it declares outside itself, and how far repair may recurse. - [PAG Keyword Ontology](https://banes-lab.com/records/algo/pag-keyword-ontology.md): Draw every operative token from a fixed, uppercase, code-frequent vocabulary partitioned into semantic categories, each token grounded to a record in the reasoning ontology, and bind targets to sources through explicit prepositions, so the model completes recognised structured patterns rather than interpreting prose. - [PAG Node Decomposition](https://banes-lab.com/records/algo/pag-node-decomposition.md): Group directives into nodes, each one decision on one reasoning axis, headed by its layer, axis, math type and the shape its decision yields, tagged with the substrate stage its artifact comes to be at, and contracted so that its input names the prior node's output or a declared slot, its transform is stated in semantic operations, and its output is the one record the next node reads. - [PAG Handoff Gate](https://banes-lab.com/records/algo/pag-validation-gate.md): Close every node with a handoff gate of three-to-five checks, each a claim about the output with the evidence that settles it and the population it was measured over, a refusal condition named before any irreversible write, the standing of the read set beside the verdict, and a result line that routes pass to the next node, each failure to the earliest node that owns its repair, and unknown to blocked. - [PAG Explicit Control Flow](https://banes-lab.com/records/algo/pag-explicit-control-flow.md): Express branching with IF / ELSE IF / ELSE, iteration with FOR EACH over a collection (never a bare FOR), and failure handling with TRY / CATCH, every conditional colon-terminated and every branch a complete directive sequence. - [PAG Invariant Record](https://banes-lab.com/records/algo/pag-constraint-boundary.md): State every behavioural invariant as a record with four slots: the property in a form that could be false, the set it quantifies over, the parties it binds, and the objector, the check that would disagree if the property stopped holding or none as declared debt, so an unwatched invariant is visible rather than assumed. - [PAG Semantic Operation](https://banes-lab.com/records/algo/pag-tool-invocation.md): Name every external effect as one of the semantic operations (discover, read, search, analyze, extract, calculate, compose, validate, persist, execute, request a decision, report) with a uniform WITH / USING parameter clause and an INTO / arrow result binding, so the document names what it does and an adapter binding resolves how, and no host's tool name enters the document. - [PAG Structure Declaration](https://banes-lab.com/records/algo/pag-coordination-construct.md): Make a document's structure explicit with the declaration that names it: a DAG for a dependency graph, a STATE_MACHINE for a lifetime or a set of derived states, a PRIORITY_QUEUE for a ranking, a FLOWCHART for the rendered projection of a declared structure, and for a shared surface the coordination model's SURFACE, RECORD and ITEM with their typed edges, derived states and the one post-and-wait operation, so ordering, ownership and state are declared as structure rather than narrated as prose. - [PAG Ambiguity Reduction](https://banes-lab.com/records/algo/pag-ambiguity-reduction.md): Replace interpretive prose with explicit structured tokens so the model completes recognized patterns, while accepting that output stays probabilistic: the grammar reduces input ambiguity, it does not constrain output tokens or guarantee determinism. - [PAG Authoring Kernel](https://banes-lab.com/records/algo/pag-authoring-kernel.md): Compose a PAG document as frontmatter and typed declaration, then a meta block with jurisdiction, then nodes each headed by its layer, axis, math type and yields, contracted to read the prior node's output, and closed by a handoff gate with evidence, population, refusal and the three verdicts, drawing directives from the semantic operations, control flow and structure declarations, and closing with invariant records and a report. - [PAG Well-Formedness Validation](https://banes-lab.com/records/algo/pag-well-formedness-validation.md): Scan a PAG document for structural and epistemic defects, each named for the shape it catches — a retired unit head, a node without a gate, a check without evidence, a gate without a population or with an empty one, an unknown left unrouted, a write without a refusal, an artifact without freshness, a node declared twice, an input naming no source, an invariant missing its set, parties or objector, a bare invariant block, a lowercase keyword, a bare FOR, a missing colon, a vague condition — and emit a token-based, regex-free verdict. - [](https://banes-lab.com/records/algo/pag-instruction-concern.md): → → → → → - [Analysis Workspace](https://banes-lab.com/records/algo/analysis-workspace.md): Create a unique analysis session, allocate phase/metric/migration artifact locations, load baseline documentation and registries, write a manifest, and block continuation if required context is unavailable. - [Registry Baseline](https://banes-lab.com/records/algo/registry-baseline.md): Read existing architectural registries, extract known base abstractions, count implementations, measure hierarchy depth, and record the current abstraction state before proposing changes. - [Compliance Gap](https://banes-lab.com/records/algo/compliance-gap.md): Discover implementation classes by role, detect which ones conform to expected base abstractions, calculate noncompliance counts, and compute architectural compliance rate. - [Semantic Domain Partitioning](https://banes-lab.com/records/algo/semantic-domain-partitioning.md): Group implementation resources by semantic role, such as manager, repository, handler, service, controller, adapter, or worker, then analyze each family separately. - [Behavioral Signature Extraction](https://banes-lab.com/records/algo/behavioral-signature-extraction.md): For each class in a semantic domain, inspect constructor behavior, lifecycle hooks, error handling, state management, dependency acquisition, and public orchestration methods. - [Cross-Class Pattern Detection](https://banes-lab.com/records/algo/cross-class-pattern-detection.md): Search across semantic domains for repeated imports, repeated initialization, repeated lifecycle code, repeated error handling, repeated state setup, and repeated dependency wiring. - [Behavioral Inconsistency](https://banes-lab.com/records/algo/behavioral-inconsistency.md): Detect multiple competing implementations of the same behavior, count each variation, compute dominant-pattern consistency, and flag low-consistency behavior for normalization. - [Sequential Chain Duplication](https://banes-lab.com/records/algo/sequential-chain-duplication.md): For each class in the role family, extract the ordered sequence of orchestration steps, align sequences across the family, and surface repeated ordered chains that no textual-duplication scan would catch. - [Temporal Coupling Detection](https://banes-lab.com/records/algo/temporal-coupling-detection.md): Detect must-precede and must-follow ordering constraints between operations in each class, intersect them across the role family, and surface the shared temporal-coupling contract that a base lifecycle would centralize. - [Relational Graph Duplication](https://banes-lab.com/records/algo/relational-graph-duplication.md): Build the dependency-acquisition subgraph for each class, test for isomorphic subgraphs across the role family, and surface repeated object-graph wiring that a base or factory would assemble once. - [Causal Wiring Duplication](https://banes-lab.com/records/algo/causal-wiring-duplication.md): Extract cause-to-effect edges (event to handler, failure to recovery, state change to reaction) per class, match trigger/reaction pairs across the role family, and surface repeated causal wiring that a base policy would centralize. - [Anomaly Outlier Detection](https://banes-lab.com/records/algo/anomaly-outlier-detection.md): Score each class's deviation from the dominant behavioral signature, identify the outliers, and name why each deviates, so inconsistency is localized to the deviant implementation rather than reported as an aggregate rate. - [Conceptual Duplication Detection](https://banes-lab.com/records/algo/conceptual-duplication-detection.md): Derive a name-independent semantic signature for each behavior (intent, input-to-output shape, effects), cluster behaviors by meaning rather than identifier, and surface same-meaning/different-name clusters that only the semantic lens can detect. - [Fractal Scale Duplication](https://banes-lab.com/records/algo/fractal-scale-duplication.md): Test whether a duplication shape recurs at more than one scale (method, class, module), and determine the scale at which the abstraction belongs, so single-scale scanning does not abstract at the wrong level. - [Anti-Pattern Classification](https://banes-lab.com/records/algo/anti-pattern-classification.md): Convert duplicated, inconsistent, and architecture-violating findings into anti-pattern records with type, occurrence count, impact, effort, severity, and affected resources. - [Anti-Pattern Priority Matrix](https://banes-lab.com/records/algo/anti-pattern-priority-matrix.md): Assign numeric impact and effort scores, calculate priority, sort anti-patterns, and group them into remediation bands. - [Abstraction Boundary Principle](https://banes-lab.com/records/algo/abstraction-boundary-principle.md): Evaluate each high-priority anti-pattern against boundary principles: universal, invariant, foundational, enforcing, and cognitive-load-reducing. - [Base-Class Candidate Selection](https://banes-lab.com/records/algo/base-class-candidate-selection.md): Promote an anti-pattern to a base-class candidate only when it satisfies enough boundary principles and applies across a meaningful portion of the semantic domain. - [Concrete-vs-Abstract Responsibility Split](https://banes-lab.com/records/algo/concrete-vs-abstract-responsibility-split.md): Partition the family's behavior into what is invariant across every member (the topology preserved under substitution) and what varies per member (the novelty); the invariant set becomes the concrete base, the variant set becomes the abstract seam. The concrete/abstract boundary is derived from the evidence, not read off a fixed lifecycle vocabulary — so the split holds for any paradigm, not only OOP class lifecycles. - [Template Method Lifecycle](https://banes-lab.com/records/algo/template-method-lifecycle.md): Define public lifecycle methods that enforce guard checks, call shared setup or cleanup, invoke subclass hooks, and centralize error handling. - [Base Schematic Composition](https://banes-lab.com/records/algo/base-schematic-composition.md): Generate the base abstraction from the selected candidate, enforce size constraints, split if oversized, and record which anti-patterns the abstraction eliminates. - [Migration Ordering](https://banes-lab.com/records/algo/migration-ordering.md): Sort target classes by complexity from lowest to highest, migrate simpler implementations first, and use early migrations to validate the abstraction before complex adoption. - [Backup-Verified Migration](https://banes-lab.com/records/algo/backup-verified-migration.md): For each target class, create a recoverable checkpoint, refactor it to extend or use the abstraction, verify the removed anti-pattern no longer exists, and restore from backup on failure. - [Anti-Pattern Elimination Verification](https://banes-lab.com/records/algo/anti-pattern-elimination-verification.md): After migration, search the entire target scope for old duplicate patterns, allow only approved base-location occurrences, and fail completion if unapproved duplicates remain. - [Registry Regeneration](https://banes-lab.com/records/algo/registry-regeneration.md): After creating or migrating abstractions, regenerate or update the architecture registry, reread it, and confirm the new base and migrated implementations are represented. - [Anti-Reintroduction Gate](https://banes-lab.com/records/algo/anti-reintroduction-gate.md): After eliminating an anti-pattern, author or strengthen the custom lint rule that statically forbids its reintroduction and any bypass of the new base, build the rule plugin, and regenerate the rule catalog, so the distilled boundary is enforced by a gate rather than by discipline. - [Distillation Metrics](https://banes-lab.com/records/algo/distillation-metrics.md): Calculate duplication reduction, code reduction, adoption rate, lines saved, maintenance burden reduction, and cognitive-load reduction after migration. - [Pattern Distillation History](https://banes-lab.com/records/algo/pattern-distillation-history.md): Append the completed analysis summary to a durable history log, store metric snapshots, and preserve lessons learned for future abstraction decisions. - [Completion Truthfulness](https://banes-lab.com/records/algo/pattern-distillation-completion-truthfulness.md): Mark pattern distillation complete only if workspace, baseline, semantic analysis, anti-pattern classification, abstraction selection, migration, verification, registry update, anti-reintroduction gate, and metrics logging all pass. - [Pattern Distiller Kernel](https://banes-lab.com/records/algo/pattern-distiller-kernel.md): Initialize an analysis workspace, read registry baselines, partition semantic domains, extract behavioral signatures, detect anti-patterns, prioritize them, evaluate abstraction boundaries, compose base schematics, migrate targets, verify elimination, update registries, calculate ROI, and persist history. - [](https://banes-lab.com/records/algo/pattern-distillation-concern.md): → → → → → → → → → → - [Quality Governance Loop](https://banes-lab.com/records/algo/quality-governance-loop.md): On each update (an apply), normalize the proposal, resolve a CheckPlan, verify it, and on failure fix-then-reverify the downstream set until the verdict is clean or the pass bound is reached, then escalate. - [Canonical Config Resolution](https://banes-lab.com/records/algo/canonical-config-resolution.md): Expand one canonical config across selected profiles and native rules into per-tool config, resolve exactly one owner per contested surface, detect the four conflict kinds fail-closed, route loosening or self-certification to the developer's gate, and emit a resolved plan. - [Stage Ordering](https://banes-lab.com/records/algo/stage-ordering.md): Build the runnability DAG from dependsOn, topologically order the cascade by the invalidates relation so fixes point forward, partition into normalization prefix, structural band, and semantic suffix, and permit back-edges only inside the suffix. - [Comment Normalization Remediation](https://banes-lab.com/records/algo/comment-normalization-remediation.md): Express the comment-strip rule once as canonical behavior, bind it per language from a comment-grammar descriptor, run the toolchain-free token-scan backing on the in-memory proposal and the real-AST backing in the sandbox, preserve directive comments, and trust a backing only after calibration and adversarial testing. - [Custom-Rule Derivation](https://banes-lab.com/records/algo/custom-rule-derivation.md): Derive a candidate rule from repeated evidence through anti-pattern classification, boundary-principle evaluation, and candidate selection, migrate with rollback, verify elimination, and admit a tightening rule while routing a self-certifying or loosening rule through the developer's gate. - [Machine Verdict Derivation](https://banes-lab.com/records/algo/machine-verdict-derivation.md): Derive the verify-stage verdict from the toolchain's machine output — exit codes and parsed findings — never from the model's reading, so a clean verdict is an observed machine fact. - [Bounded Cascade Termination](https://banes-lab.com/records/algo/bounded-cascade-termination.md): Terminate the verify-remediate cascade on the completion AND-gate — a clean verdict, or bounded progress where findings strictly decrease within the pass bound — escalating when neither holds. - [Quality-Engine Kernel](https://banes-lab.com/records/algo/quality-engine-concern.md): Resolve a canonical policy into a per-ecosystem CheckPlan, order its stages by the invalidates relation, normalize the proposal, run generation checks on the server and project tools via the relay, derive a machine verdict, and drive a bounded downstream cascade to clean — holding no runtime execution in the engine itself. - [Taxonomy Jurisdiction](https://banes-lab.com/records/algo/taxonomy-jurisdiction.md): Read the registry's root, container, bucket and ignore declarations, enumerate every file under a declared root, and separate the governed set from the ignored set and from the folders declared as neither, so jurisdiction is read rather than inferred. - [Reshape Risk Priority](https://banes-lab.com/records/algo/reshape-risk-priority.md): Score each governed container by how much reference surface a rename disturbs — importer count and the number of surfaces that resolve by pattern rather than by literal path — and rank ascending, so the pilot is the lowest-risk container and the highest-risk one lands last. - [Path Role Walk](https://banes-lab.com/records/algo/path-role-walk.md): Walk every governed path from its root, assign each folder depth a role from the declared grammar in the ordered sequence container then subject then concern, and emit the depth-to-role edge list together with the depths that repeat a role, revisit an earlier one, or exceed the cap. - [Concern Classification](https://banes-lab.com/records/algo/concern-classification.md): Read each governed file, assign the narrowest accurate concern from the declared vocabulary by its primary responsibility, record a file that fits two concerns as a split candidate, and break an irreducible overlap by the domain-ward layer, so classification is judgement against the file rather than pattern-matching against its path. - [Name Projection](https://banes-lab.com/records/algo/name-projection.md): Compose the target name from the assigned concern, the subject, and a variant taken only where a collision or a facet requires one, and derive the folder chain from that same concern, so the filename and its placement are one projection rather than two decisions. - [Container Reshape](https://banes-lab.com/records/algo/container-reshape.md): Convert one container at a time: split the multi-role files first, move and rename each remaining file to its projected name and folder, update every importer in the same pass, move the mirrored tests to match the new concern folders, and re-point every surface whose pattern encoded the old form. - [Vocabulary Admission Gate](https://banes-lab.com/records/algo/vocabulary-admission-gate.md): Hold every proposed word against the declared vocabularies and the rejection table, resolve and name the declared word that covers it where one does, refuse a word that names a process, an adjective, a grouping label, or a measurement, sort a surviving word by the is-a test into concerns or subjects, and admit it only by developer-approved registry edit. - [Discovery Verification](https://banes-lab.com/records/algo/discovery-verification.md): For every shape-discovered surface touched by the reshape, compare the member set it collects against what it collected before, and issue the verdict from that comparison, so a collection that silently emptied is caught rather than read as a clean pass. - [Taxonomy Ledger](https://banes-lab.com/records/algo/taxonomy-ledger.md): Record the registry version, the conversion state of each container, and every admitted and refused word with its reasoning, so the taxonomy's history is durable evidence rather than a fact re-derived from the tree on each pass. - [Taxonomy Completion](https://banes-lab.com/records/algo/taxonomy-completion.md): Mark the taxonomy complete only when every governed file resolves against the grammar at both levels, no split candidate is outstanding, and every shape-discovered surface has a preserved verdict, leaving it incomplete while any residual remains. - [Taxonomy Kernel](https://banes-lab.com/records/algo/taxonomy-kernel.md): Resolve jurisdiction from the registry, order the containers by reshape risk, walk each path into its ordered roles, classify each file to its narrowest concern, project the name and the folder chain together, reshape one container at a time, hold every proposed word at the admission gate, verify that pattern-resolved surfaces still collect what they collected, ledger the state, and terminate only when no residual finding remains. - [](https://banes-lab.com/records/algo/taxonomy-concern.md): → → → → → → → → → - [Coverage Workspace](https://banes-lab.com/records/algo/coverage-workspace.md): Establish the unit under test, load the test-surface catalog as the space of what can be wrong, and enumerate every surface the unit can carry, so coverage is measured against the full derivable space rather than an ad-hoc list. - [Surface Grid Walk](https://banes-lab.com/records/algo/surface-grid-walk.md): Walk the dimension-by-lens grid across the catalog, mark every cell that carries a surface, and surface the empty cells as candidate gaps using the anomaly lens, so a missing aspect is detected structurally rather than by recollection. - [Uncovered Gap Derivation](https://banes-lab.com/records/algo/uncovered-gap-derivation.md): Reduce the candidate-gap set to the cells this unit can fail in, yielding the required-but-uncovered surfaces that still owe a test, so effort is spent on gaps that can fail rather than the full cartesian complement. - [Coverage Risk Prioritisation](https://banes-lab.com/records/algo/coverage-risk-prioritisation.md): Score each required-uncovered surface by failure impact and reachability, rank the surfaces, and address the highest-risk gaps first, so limited testing effort removes the most risk. - [Technique and Invariant Selection](https://banes-lab.com/records/algo/technique-invariant-selection.md): For each prioritised surface, state the invariant that must hold and select the technique whose reasoning mode matches how that surface is observed, so the test asserts the right property by the right method. - [Test Authoring](https://banes-lab.com/records/algo/test-authoring.md): Realize each surface plan as an executable test: encode the predicate as an assertion and wire the evidence source the technique requires, producing a runnable test that covers the surface. - [Evidence Verdict](https://banes-lab.com/records/algo/evidence-verdict.md): Run each test, gather its evidence, and issue the verdict: pass or fail when the evidence set is non-empty, unknown when it is empty, so an untested or unrun surface reads as unknown rather than as a silent pass. - [Coverage Ledger](https://banes-lab.com/records/algo/coverage-ledger.md): Record each surface's verdict in a durable coverage ledger together with the residual uncovered and unknown set, so coverage state is reusable evidence rather than a fact re-derived on every run. - [Coverage Completion](https://banes-lab.com/records/algo/coverage-completion.md): Mark coverage complete only when every required surface carries a surface, a technique, and an invariant, and its verdict is non-unknown; any required surface still unknown leaves coverage incomplete. - [Test Coverage Kernel](https://banes-lab.com/records/algo/test-coverage-kernel.md): Load the surface catalog for a unit, walk the dimension-by-lens grid, derive the required-uncovered surfaces, prioritise them by risk, select a mode-matched technique and invariant per surface, author the test, issue an evidence verdict, ledger the state, and terminate only when no required surface remains unknown. - [](https://banes-lab.com/records/algo/test-coverage-concern.md): → → → →