# The algo records whose force is correctness_verification This index as JSON: https://banes-lab.com/json/api/facets/algo/force/correctness-verification ## Entries - [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. - [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. - [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. - [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. - [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): → → → → → → → → → → → - [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. - [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. - [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. - [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. - [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. - [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. - [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): → → → → → → → → - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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): → → → → → → → - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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): → → → → - [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. - [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): → → → → → - [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. - [](https://banes-lab.com/records/algo/living-accumulation-concern.md): → → → → → - [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. - [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 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 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 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): → → → → → - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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. - [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 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. - [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): → → → →