# checklist-creation > Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks, its productions as a… Page: Ontology · Algorithms Canonical: https://banes-lab.com/ontology/algorithms#algo-domain-checklist-creation Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks, its productions as a grammar, what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain. Relations diagram What composes what inside this domain. ```mermaid flowchart LR n_orientation_stage["Orientation Stage"] n_authoritative_source_loading["Authoritative Source Loading"] n_trust_anchor["Trust Anchor"] n_intent_directionality_normalization["Intent & Directionality Normalization"] n_skeptical_context_acquisition["Skeptical Context Acquisition"] n_dynamic_discovery_pattern_generation["Dynamic Discovery Pattern Generation"] n_teleological_intent_gate["Teleological Intent Gate"] n_planning_stage["Planning Stage"] n_principle_activation["Principle Activation"] n_protocol_semantic_selection["Protocol Semantic Selection"] n_phase_decomposition["Phase Decomposition"] n_four_dimensional_phase_graph["Four-Dimensional Phase Graph"] n_dependency_linearization["Dependency Linearization"] n_severity_assignment["Severity Assignment"] n_loop_class_labeling["Loop Class Labeling"] n_compilation_stage["Compilation Stage"] n_codebase_pattern_enforcement["Codebase Pattern Enforcement"] n_verb_template_binding["Verb Template Binding"] n_task_atomization["Task Atomization"] n_ripple_chain_analysis["Ripple Chain Analysis"] n_validator_coverage["Validator Coverage"] n_structured_observability_context["Structured Observability Context"] n_cross_cutting_surface_coverage["Cross-Cutting Surface Coverage"] n_legacy_elimination["Legacy Elimination"] n_hierarchical_numbering["Hierarchical Numbering"] n_admissibility_constraint_stage["Admissibility Constraint Gate"] n_validation_stage["Validation Stage"] n_semantic_debt_policy["Semantic Debt Policy"] n_evidence_based_claim_verification["Evidence-Based Claim Verification"] n_validation_suite_battery["Validation Suite Battery"] n_repair_stage["Repair Stage"] n_bounded_repair_loop["Bounded Repair Loop"] n_severity_failure_routing["Severity Failure Routing"] n_rendering_stage["Rendering Stage"] n_checklist_output_rendering["Checklist Output Rendering"] n_explicit_termination["Explicit Termination"] n_cross_stage_invariants["Cross-Stage Invariants"] n_checklist_creation_kernel["Checklist Creation Kernel"] n_checklist_governance_concern[""] n_orientation_stage --> n_authoritative_source_loading n_orientation_stage --> n_trust_anchor n_orientation_stage --> n_intent_directionality_normalization n_orientation_stage --> n_skeptical_context_acquisition n_orientation_stage --> n_dynamic_discovery_pattern_generation n_skeptical_context_acquisition --> n_dynamic_discovery_pattern_generation n_planning_stage --> n_principle_activation n_planning_stage --> n_protocol_semantic_selection n_planning_stage --> n_phase_decomposition n_planning_stage --> n_four_dimensional_phase_graph n_planning_stage --> n_dependency_linearization n_planning_stage --> n_severity_assignment n_planning_stage --> n_loop_class_labeling n_phase_decomposition --> n_four_dimensional_phase_graph n_phase_decomposition --> n_severity_assignment n_phase_decomposition --> n_loop_class_labeling n_compilation_stage --> n_verb_template_binding n_compilation_stage --> n_codebase_pattern_enforcement n_compilation_stage --> n_task_atomization n_compilation_stage --> n_ripple_chain_analysis n_compilation_stage --> n_validator_coverage n_compilation_stage --> n_structured_observability_context n_compilation_stage --> n_cross_cutting_surface_coverage n_compilation_stage --> n_legacy_elimination n_compilation_stage --> n_hierarchical_numbering n_task_atomization --> n_codebase_pattern_enforcement n_validation_stage --> n_validation_suite_battery n_validation_stage --> n_evidence_based_claim_verification n_validation_stage --> n_semantic_debt_policy n_repair_stage --> n_severity_failure_routing n_repair_stage --> n_bounded_repair_loop n_rendering_stage --> n_checklist_output_rendering n_rendering_stage --> n_explicit_termination n_checklist_creation_kernel --> n_orientation_stage n_checklist_creation_kernel --> n_teleological_intent_gate n_checklist_creation_kernel --> n_planning_stage n_checklist_creation_kernel --> n_compilation_stage n_checklist_creation_kernel --> n_admissibility_constraint_stage n_checklist_creation_kernel --> n_validation_stage n_checklist_creation_kernel --> n_repair_stage n_checklist_creation_kernel --> n_rendering_stage n_checklist_creation_kernel --> n_cross_stage_invariants n_checklist_creation_kernel --> n_phase_decomposition n_checklist_creation_kernel --> n_explicit_termination ``` ### Orientation Stage - Stage: [orient](https://banes-lab.com/records/stage/orient.md) - Axis: [ontology](https://banes-lab.com/records/reason/axis-ontology.md) - Math type: [set-theory](https://banes-lab.com/records/reason/math-type-set-theory.md) - Yields: set | boolean Details Intent 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. Invariant Prior knowledge is untrusted; discover before assume; read authority before analysis; a resolved change-direction and a non-empty evidence inventory are the handoff precondition. Flow ```text RawTask + GoverningDocs → AuthorityLoad → ContextDiscovery → IntentNormalization → ContextBundle|RepairRoute ``` Productions ```bnf OrientationStage ::= "," "->" "->" "->" "->" ContextBundle ::= "," "," "," "," "," "," "," OrientationHandoff ::= "authority_loaded" "," "intent_and_change_direction_resolved" "," "evidence_inventory_non_empty" "->" "pass_to_planning" | "repair_owner_orientation" ``` Composes [Authoritative Source Loading](https://banes-lab.com/records/algo/authoritative-source-loading.md), [Trust Anchor](https://banes-lab.com/records/algo/trust-anchor.md), [Intent & Directionality Normalization](https://banes-lab.com/records/algo/intent-directionality-normalization.md), [Skeptical Context Acquisition](https://banes-lab.com/records/algo/skeptical-context-acquisition.md), [Dynamic Discovery Pattern Generation](https://banes-lab.com/records/algo/dynamic-discovery-pattern-generation.md) Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [metaprogramming_modeling](https://banes-lab.com/records/force/metaprogramming-modeling.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds none Before ```text Planning starts from the task text alone — prior model knowledge treated as current system truth. ``` After ```text raw task + governing docs → load authority → discover current system → normalize intent + change_relation → context_bundle{evidence_inventory non-empty} ``` ### Authoritative Source Loading - Stage: [orient](https://banes-lab.com/records/stage/orient.md) - Axis: [ontology](https://banes-lab.com/records/reason/axis-ontology.md) - Math type: [set-theory](https://banes-lab.com/records/reason/math-type-set-theory.md) - Yields: set | boolean Details Intent 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. Invariant Task decomposition is grounded in authoritative host rules read before analysis; a missing required source blocks at the orientation owner. Flow ```text TaskDescription → CoreSources + TriggeredSources → SourceRead → LoadedContext|BlockMissing ``` Productions ```bnf AuthoritativeSourceLoading ::= "->" "," "->" "->" SourceSelection ::= "always_read_core" "," "read_conditional_source_when_trigger_present" SourceValidationGate ::= "all_required_sources_loaded" | "blocked_missing_source" ``` Composes none Composed by [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md) Forces [metaprogramming_modeling](https://banes-lab.com/records/force/metaprogramming-modeling.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text Decomposition grounded in memory, not the host's rules; a missing source is discovered too late. ``` After ```text task → always-read core{governance, principle-ontology} + triggered{architecture, design, component} → read before analysis → block on a missing required source ``` ### Trust Anchor - Stage: [orient](https://banes-lab.com/records/stage/orient.md) - Axis: [ontology](https://banes-lab.com/records/reason/axis-ontology.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant Planning reliability depends on explicit source trust; untrusted input cannot ground a task until it is verified. Flow ```text InputSource → TrustClassification → UsagePolicy ``` Productions ```bnf TrustAnchor ::= "->" "," "->" UsagePolicy ::= "trusted_can_ground_tasks" | "untrusted_requires_verification" ``` Composes none Composed by [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [security_governance](https://banes-lab.com/records/force/security-governance.md) Grounds none Before ```text Every input trusted equally — a narrative doc grounds a task the same as a build result. ``` After ```text inputs → trusted{source files, schema/config, build/validator output, tool output} vs untrusted{narrative docs, comments, prior knowledge} → untrusted requires verification before it grounds a task ``` ### Intent & Directionality Normalization - Stage: [orient](https://banes-lab.com/records/stage/orient.md) - Axis: [ontology](https://banes-lab.com/records/reason/axis-ontology.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant The change relation is explicit before planning; an unknown direction is surfaced as an unresolved question. Flow ```text TaskDescription → IntentExtraction → DirectionalityAnalysis → NormalizedIntent + Ambiguity ``` Productions ```bnf IntentDirectionalityNormalization ::= "," "->" "," "," "->" "," ChangeRelation ::= "introduce" | "retain" | "remove" | "analyze" | "mention" | "unknown" ``` Composes none Composed by [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md) Forces [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text 'update Foo' planned without resolving whether Foo is introduced, retained, or removed. ``` After ```text task → outcome + actions + entities → change_relation{introduce|retain|remove|analyze|mention} → unknown direction recorded as an unresolved question, never assumed ``` ### Skeptical Context Acquisition - Stage: [orient](https://banes-lab.com/records/stage/orient.md) - Axis: [ontology](https://banes-lab.com/records/reason/axis-ontology.md) - Math type: [set-theory](https://banes-lab.com/records/reason/math-type-set-theory.md) - Yields: set | boolean Details Intent Extract task keywords, generate discovery probes dynamically, inspect the existing implementation, and prevent new work from redefining architecture that already exists. Invariant Planning discovers current artifacts before making architecture assumptions. Flow ```text NormalizedIntent → Keywords → DiscoveryProbes → DiscoveredArtifacts + Evidence ``` Productions ```bnf SkepticalContextAcquisition ::= "->" "->" "->" "->" KeywordExtraction ::= "technical_nouns" "," "action_verbs" "," "file_refs" "," "folders" DiscoveredArtifacts ::= "base_classes" "," "implementations" "," "registrations" "," "migrations" "," "signatures" ``` Composes [Dynamic Discovery Pattern Generation](https://banes-lab.com/records/algo/dynamic-discovery-pattern-generation.md) Composed by [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md) Forces [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text New work redefines a Foo abstraction that already exists, unseen. ``` After ```text normalized intent → keywords → dynamic discovery probes → discovered artifacts{base classes, implementations, registrations} + evidence, before any architecture assumption ``` ### Dynamic Discovery Pattern Generation - Stage: [orient](https://banes-lab.com/records/stage/orient.md) - Axis: [ontology](https://banes-lab.com/records/reason/axis-ontology.md) - Math type: [computation](https://banes-lab.com/records/reason/math-type-computation.md) - Yields: procedure Details Intent 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. Invariant Discovery probes are generated from task keywords, never from a fixed assumption list. Flow ```text Keywords → Globs + Greps + Targets → ProbeExecution ``` Productions ```bnf DynamicDiscoveryPatternGeneration ::= "->" "," "," DiscoveryProbe ::= "," "," ProbeTool ::= "Glob" | "Grep" | "Read" ``` Composes none Composed by [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md), [Skeptical Context Acquisition](https://banes-lab.com/records/algo/skeptical-context-acquisition.md) Forces [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [metaprogramming_modeling](https://banes-lab.com/records/force/metaprogramming-modeling.md) Grounds none Before ```text Discovery runs a fixed checklist of globs, blind to the task's own nouns. ``` After ```text keywords{nouns, verbs, folders, file-refs} → generated globs + greps + target-files from the task's own language, not a fixed enumeration ``` ### Teleological Intent Gate - Stage: [intent](https://banes-lab.com/records/stage/intent.md) - Axis: [teleology](https://banes-lab.com/records/reason/axis-teleology.md) - Math type: [optimisation](https://banes-lab.com/records/reason/math-type-optimisation.md) - Yields: boolean | ranking Details Intent 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. Invariant Teleology is mandatory-always: planning never proceeds on a branch that is not the argmax(utility - cost) over admissible branches; no admissible branch routes to a blocked report, never a guess. Flow ```text ContextBundle → AdmissibleBranchEnumeration → UtilityCostScoring → ArgmaxSelection|Blocked ``` Productions ```bnf TeleologicalIntentGate ::= "->" "->" "->" | BranchSelection ::= "argmax_utility_minus_cost_over_admissible" | "blocked_no_admissible_branch" ``` Composes none Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds [tel-priority](https://banes-lab.com/records/reason/node-tel-priority.md) Before ```text Decomposition begins on the first approach that comes to mind — no worth comparison, so effort is spent before the objective is ranked. ``` After ```text context_bundle → enumerate admissible decomposition branches → score utility - cost → select the argmax → WORTH_BEFORE_WORK gate before any planning ``` ### Planning Stage - Stage: [derive](https://banes-lab.com/records/stage/derive.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant Order is by dependency, never by severity; every active principle binds a decision test and a validator; a protocol is never selected from a trigger word alone. Flow ```text ContextBundle → ActivePrinciples → SelectedProtocols → PhaseGraph → LinearizedPhases|CycleRepair ``` Productions ```bnf PlanningStage ::= "->" "->" "->" "->" "->" PlanningHandoff ::= "z_graph_acyclic" "," "every_phase_has_inputs_outputs_four_axes" "," "order_topological_severity_metadata_only" "," "every_mandatory_principle_binds_a_validator" "->" "pass_to_compilation" | "repair_owner_planning" ``` Composes [Principle Activation](https://banes-lab.com/records/algo/principle-activation.md), [Protocol Semantic Selection](https://banes-lab.com/records/algo/protocol-semantic-selection.md), [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md), [Four-Dimensional Phase Graph](https://banes-lab.com/records/algo/four-dimensional-phase-graph.md), [Dependency Linearization](https://banes-lab.com/records/algo/dependency-linearization.md), [Severity Assignment](https://banes-lab.com/records/algo/severity-assignment.md), [Loop Class Labeling](https://banes-lab.com/records/algo/loop-class-labeling.md) Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [modularity](https://banes-lab.com/records/force/modularity.md) Grounds none Before ```text Phases grouped under SPRINT: CRITICAL headers; a protocol picked from a trigger word. ``` After ```text context_bundle → activate principles (each binds a decision-test + validator) → select protocols by semantic fit → decompose → 4D graph → linearize by dependency (severity is metadata) ``` ### Principle Activation - Stage: [derive](https://banes-lab.com/records/stage/derive.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant A principle is activated only with an explicit applicability decision and a bound validator; a label alone is never proof that local reasoning occurred. Flow ```text ContextBundle → DecisionSurfaces → PrincipleFit → ActivePrincipleSet ``` Productions ```bnf PrincipleActivation ::= "->" "->" "," "," ApplicabilityDisposition ::= "applies" | "uncertain" | "not_applicable" Severity ::= "mandatory" | "recommended" | "contextual" | "discouraged" ``` Composes none Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md) Grounds none Before ```text 'SRP applies' asserted as a label, with no decision-test and nothing that enforces it. ``` After ```text decision surfaces → test each principle{applies|uncertain|not-applicable + reason} → bind validator + severity → a label alone is never proof reasoning occurred ``` ### Protocol Semantic Selection - Stage: [derive](https://banes-lab.com/records/stage/derive.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant Protocols are selected by semantic fit against the requested transition, never from a trigger word; the verification protocol is always included. Flow ```text ContextBundle + ActivePrinciples → SemanticMatch → SelectedProtocols → VerificationInjected ``` Productions ```bnf ProtocolSemanticSelection ::= "," "," "->" "->" "->" Protocol ::= "module-separation" | "extension-no-modify" | "dependency-inversion" | "intention-emission" | "invariant-inheritance" | "registry-resolution" | "security-hardening" | "performance-eng" | "infra-provisioning" | "resilience-recovery" | "replacement-elim" | "enforcement-authoring" | "verification-gate" ``` Composes none Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md), [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md) Grounds none Before ```text The word 'secure' in the task auto-selects the security protocol. ``` After ```text requested transition + surfaces → semantic-fit match against the protocol library → selected set → the mandatory verification protocol always injected ``` ### Phase Decomposition - Stage: [project](https://banes-lab.com/records/stage/project.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [graph](https://banes-lab.com/records/reason/math-type-graph.md) - Yields: edge-list Details Intent 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. Invariant A phase is a protocol step enriched with inputs, outputs, validation, severity, and dependency metadata, ordered by dependency and never by severity. Flow ```text SelectedProtocols → VerbChains → PhaseSet → AnnotatedPhases ``` Productions ```bnf PhaseDecomposition ::= "->" "->" "->" PhaseAnnotation ::= "id" "," "verb" "," "objective" "," "inputs" "," "outputs" "," "affected_artifacts" "," "principles" "," "severity" "," "loop_class" "," "graph_4d" ``` Composes [Four-Dimensional Phase Graph](https://banes-lab.com/records/algo/four-dimensional-phase-graph.md), [Severity Assignment](https://banes-lab.com/records/algo/severity-assignment.md), [Loop Class Labeling](https://banes-lab.com/records/algo/loop-class-labeling.md) Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [metaprogramming_modeling](https://banes-lab.com/records/force/metaprogramming-modeling.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text A protocol's steps emitted as a flat task list with no inputs, outputs, or dependency metadata. ``` After ```text selected protocols → verb chains → phases annotated{id, verb, objective, inputs, outputs, principles, severity, loop_class, 4D graph} ``` ### Four-Dimensional Phase Graph - Stage: [project](https://banes-lab.com/records/stage/project.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [graph](https://banes-lab.com/records/reason/math-type-graph.md) - Yields: edge-list Details Intent 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. Invariant A phase exposes not only order but ripple; an empty propagation axis carries explicit no-downstream-consumer evidence. Flow ```text Phase → Z + X + Y + W Graph ``` Productions ```bnf FourDPhaseGraph ::= "->" "," "," "," SequentialAxis ::= "Z: prior_required_phases" LateralAxis ::= "X: independent_peer_phases" DiagonalAxis ::= "Y: shared_data_or_output_relationships" PropagationAxis ::= "W: superseded_state, propagated_contracts, breaks_if_omitted" ``` Composes none Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md), [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md) Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [model_governance](https://banes-lab.com/records/force/model-governance.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text A phase records only its order — its downstream ripple is invisible. ``` After ```text phase → Z{prior required phases} + X{independent peers} + Y{shared-data} + W{superseded state, propagated contracts, breaks-if-omitted}; empty W carries no-consumer evidence ``` ### Dependency Linearization - Stage: [project](https://banes-lab.com/records/stage/project.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [graph](https://banes-lab.com/records/reason/math-type-graph.md) - Yields: edge-list Details Intent 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. Invariant Phases are linearized by topological dependency order; severity never controls order; a cycle blocks and routes to planning repair. Flow ```text PhaseGraph → CycleCheck → TopologicalOrder|BlockedCycle ``` Productions ```bnf DependencyLinearization ::= "->" "->" | LinearizationResult ::= "pass_topological_order" | "blocked_cycle" ``` Composes none Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md) Forces [causality_ordering](https://banes-lab.com/records/force/causality-ordering.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text Phases ordered by priority label; a hidden cycle ships undetected. ``` After ```text phase graph → detect Z-cycles (block on any) → topological Z-order with a stable tie-breaker; severity never controls order ``` ### Severity Assignment - Stage: [project](https://banes-lab.com/records/stage/project.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [optimisation](https://banes-lab.com/records/reason/math-type-optimisation.md) - Yields: boolean | ranking Details Intent 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. Invariant Severity reflects principle risk and is metadata that routes failure; it is never a grouping or ordering axis. Flow ```text Phase → LocalPrinciples → WorstSeverity ``` Productions ```bnf SeverityAssignment ::= "->" "->" "->" ``` Composes none Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md), [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md) Forces [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds [tel-priority](https://banes-lab.com/records/reason/node-tel-priority.md) Before ```text Severity used as a section header that groups the phases. ``` After ```text phase → worst severity of its governing principles → per-phase metadata that routes the repair, never a grouping or ordering axis ``` ### Loop Class Labeling - Stage: [project](https://banes-lab.com/records/stage/project.md) - Axis: [reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent Classify each phase by its verb into a construction, perceptual, cognitive, executive, or linking loop class so the phase's cognitive role is explicit. Invariant Every phase carries an explicit cognitive loop class derived from its verb. Flow ```text Verb → LoopClass → LoopPattern ``` Productions ```bnf LoopClassLabeling ::= "->" "->" LoopClass ::= "Construction" | "Perceptual" | "Cognitive" | "Executive" | "Linking" ``` Composes none Composed by [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md), [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md) Forces [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds none Before ```text A phase's cognitive role is implicit in its verb. ``` After ```text verb → loop class{Construction|Perceptual|Cognitive|Executive|Linking} → the phase's cognitive role made explicit ``` ### Compilation Stage - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [computation](https://banes-lab.com/records/reason/math-type-computation.md) - Yields: procedure Details Intent 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. Invariant Every emitted task is atomic and target-specific with an evidence contract, and carries all nine ripple dimensions expressed as names, never counts. Flow ```text PhaseRecords → TaskTemplates + PatternConstraints → AtomicTasks → RippleChains + Numbering ``` Productions ```bnf CompilationStage ::= "->" "," "->" "->" "->" CompilationHandoff ::= "every_task_atomic_and_target_specific" "," "every_task_has_evidence_contract" "," "nine_ripple_dimensions_with_names" "->" "pass_to_validation" | "repair_owner_compilation" ``` Composes [Verb Template Binding](https://banes-lab.com/records/algo/verb-template-binding.md), [Codebase Pattern Enforcement](https://banes-lab.com/records/algo/codebase-pattern-enforcement.md), [Task Atomization](https://banes-lab.com/records/algo/task-atomization.md), [Ripple Chain Analysis](https://banes-lab.com/records/algo/ripple-chain-analysis.md), [Validator Coverage](https://banes-lab.com/records/algo/validator-coverage.md), [Structured Observability Context](https://banes-lab.com/records/algo/structured-observability-context.md), [Cross-Cutting Surface Coverage](https://banes-lab.com/records/algo/cross-cutting-surface-coverage.md), [Legacy Elimination](https://banes-lab.com/records/algo/legacy-elimination.md), [Hierarchical Numbering](https://banes-lab.com/records/algo/hierarchical-numbering.md) Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [object_creation](https://banes-lab.com/records/force/object-creation.md) Grounds none Before ```text Phases emitted as vague tasks with count-only ripple ('touches 3 consumers'). ``` After ```text phase records → bind verb templates + codebase-pattern constraints → atomize → attach 9-dimension named ripple chain → number N.N.N ``` ### Codebase Pattern Enforcement - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant Codebase patterns are binding execution constraints; a forbidden form is rewritten to its required form before the task is emitted. Flow ```text Task → PatternViolationScan → RequiredRewrite → CompliantTask ``` Productions ```bnf CodebasePatternEnforcement ::= "->" "->" "->" PatternDomain ::= "factory_creation" | "dependency_injection" | "registry_discovery" | "event_emission" | "ports_adapters" | "contract_first" | "encapsulation" | "structured_observability" | "bounded_complexity" | "secrets_management" | "input_validation" | "least_privilege" | "config_externalization" | "fail_fast" | "legacy_elimination" | "enforcement_rule" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md), [Task Atomization](https://banes-lab.com/records/algo/task-atomization.md) Forces [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [object_creation](https://banes-lab.com/records/force/object-creation.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text A task says 'construct Foo' with no required pattern — direct instantiation slips through. ``` After ```text task → scan forbidden forms → rewrite each to its required form{factory, DI, registry, events, ports, contract-first, fail-fast, secrets} before emit ``` ### Verb Template Binding - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [computation](https://banes-lab.com/records/reason/math-type-computation.md) - Yields: procedure Details Intent 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. Invariant An execution verb becomes a task only through a template that binds its tools and a blocking validation command. Flow ```text Verb → TaskPattern → Tools → ValidationCommand ``` Productions ```bnf VerbTemplateBinding ::= "->" "," "," Verb ::= "ANALYZE" | "FIND" | "EXTRACT" | "CREATE" | "VERIFY" | "FILTER" | "EXECUTE" | "WRITE" | "READ" | "LINK" | "ITERATE" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [metaprogramming_modeling](https://banes-lab.com/records/force/metaprogramming-modeling.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds none Before ```text 'CREATE Foo' becomes a task with no tools and no way to validate it. ``` After ```text verb → task pattern + tool set + blocking validation command → a verb becomes a task only through a validated template ``` ### Task Atomization - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [computation](https://banes-lab.com/records/reason/math-type-computation.md) - Yields: procedure Details Intent 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. Invariant A task is small enough to execute and strict enough to validate, carrying its own evidence contract and done-condition. Flow ```text Phase → TaskGroups → AtomicActions + Gates → AtomicTasks ``` Productions ```bnf TaskAtomization ::= "->" "->" "->" "->" AtomicTask ::= "," "," "," "," ``` Composes [Codebase Pattern Enforcement](https://banes-lab.com/records/algo/codebase-pattern-enforcement.md) Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [modularity](https://banes-lab.com/records/force/modularity.md) Grounds none Before ```text One coarse task 'refactor the Foo module' — too big to execute or validate. ``` After ```text phase → task groups → atomic actions (gated by codebase patterns) → each carries an evidence contract + validation method + done-condition ``` ### Ripple Chain Analysis - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [graph](https://banes-lab.com/records/reason/math-type-graph.md) - Yields: edge-list Details Intent 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. Invariant Every task exposes all nine downstream dimensions as named impacts; ripple is never count-only and never filtered to the first match. Flow ```text Task → RippleDimensions → NamedImpacts → DownstreamChain ``` Productions ```bnf RippleChainAnalysis ::= "->" "->" "->" RippleDimensionSet ::= "registry" "," "contracts" "," "persistence" "," "security" "," "infrastructure" "," "performance" "," "observability" "," "enforcement" "," "consumers" ImpactSet ::= | "none_with_applicability_evidence" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text Impact recorded as a count ('affects 4 things'), filtered to the first match. ``` After ```text task → 9 dims{registry, contracts, persistence, security, infrastructure, performance, observability, enforcement, consumers} → every named downstream impact + consequence-if-omitted; empty dim carries applicability evidence ``` ### Validator Coverage - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant A new or changed architectural invariant is protected by an automated detector that is registered and active — never convention-only. Flow ```text Pattern → DetectorDiscovery → AuthorOrUpdate → RegisterAndRegenerate → EnforcementActive ``` Productions ```bnf ValidatorCoverage ::= "->" "->" "->" "->" CoverageDecision ::= "update_existing_detector" | "author_new_detector" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md) Grounds none Before ```text A new Foo invariant protected by a convention no check enforces. ``` After ```text pattern → discover a detector or author one → register + regenerate the catalog → the rule becomes an active gate, not a convention ``` ### Structured Observability Context - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant An observability task carries schema-complete, queryable context matched to its concern, never a stringified blob. Flow ```text Task → ObservabilityTrigger → RequiredContext → SchemaValidation ``` Productions ```bnf StructuredObservabilityContext ::= "->" "->" "->" RequiredContext ::= "error" | "violation" | "event" | "lifecycle" | "contract" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [observability_traceability](https://banes-lab.com/records/force/observability-traceability.md) Grounds none Before ```text An error task emits a stringified blob instead of queryable context. ``` After ```text task → observability trigger{error|violation|event|lifecycle|contract} → required schema-complete, machine-queryable context matched to the concern ``` ### Cross-Cutting Surface Coverage - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant A change is not covered until its security, performance, infrastructure, and resilience consequences are gated, not only its structural ones. Flow ```text Task → SurfaceDetection → SurfaceGates → CoverageVerification ``` Productions ```bnf CrossCuttingSurfaceCoverage ::= "->" "->" "->" SurfaceSet ::= "security" | "performance" | "infrastructure" | "resilience" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [security_governance](https://banes-lab.com/records/force/security-governance.md), [performance_scaling](https://banes-lab.com/records/force/performance-scaling.md), [resilience_recovery](https://banes-lab.com/records/force/resilience-recovery.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text A change gated only on structure; its threat, budget, and failure consequences uncovered. ``` After ```text task → surfaces{security, performance, infrastructure, resilience} → a gate per surface → coverage beyond structure verified ``` ### Legacy Elimination - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant There is exactly one live path; dead, dual, deprecated, and fallback code is removed in the same change, never deferred. Flow ```text Change → SupersededDetection → SamePassRemoval → SinglePathGate ``` Productions ```bnf LegacyElimination ::= "->" "->" "->" SupersededPathSet ::= "dual_path" | "fallback" | "deprecated" | "dead_code" | "orphaned_export" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text A replaced Foo path left behind beside its successor as a dual path 'for now'. ``` After ```text change → detect superseded{dual-path, fallback, deprecated, dead code, orphaned export} → delete in the same change → exactly one live path remains ``` ### Hierarchical Numbering - Stage: [act](https://banes-lab.com/records/stage/act.md) - Axis: [formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - Math type: [algebra](https://banes-lab.com/records/reason/math-type-algebra.md) - Yields: ordered-structure Details Intent Render addressable coordinates — Phase N, Task N.N, Subtask N.N.N — assigned only after the phase order is stable. Invariant Checklist execution requires stable, addressable task coordinates numbered after order is fixed. Flow ```text Phases → Tasks → Subtasks → N.N.N Coordinates ``` Productions ```bnf HierarchicalNumbering ::= "->" "->" "->" HierarchicalId ::= "N" | "N.N" | "N.N.N" ``` Composes none Composed by [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) Forces [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text Tasks numbered before the phase order is stable, so ids churn. ``` After ```text stable order → Phase N → Task N.N → Subtask N.N.N → addressable coordinates assigned only after order is fixed ``` ### Admissibility Constraint Gate - Stage: [constrain](https://banes-lab.com/records/stage/constrain.md) - Axis: [teleology](https://banes-lab.com/records/reason/axis-teleology.md) - Math type: [optimisation](https://banes-lab.com/records/reason/math-type-optimisation.md) - Yields: boolean | ranking Details Intent 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. Invariant Teleology is mandatory-always: a plan is verified only after realised cost is within budget, every hard limit holds, and every task traces to the selected branch; the cost is never silently accepted. Flow ```text TaskRecords + PhaseRecords + SelectedBranch → RealisedCostSum → BudgetAndLimitCheck → Admissible|RouteBack ``` Productions ```bnf AdmissibilityConstraintGate ::= "," "," "->" "->" "->" AdmissibilityVerdict ::= "admissible_within_budget_and_limits" | "inadmissible_route_to_intent" | "limit_breach_route_to_act" ``` Composes none Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text The compiled plan goes straight to verification — its realised cost is never checked against the selected branch's budget, so an over-budget or off-branch plan is verified and shipped anyway. ``` After ```text task_records + phase_records → sum realised cost → compare to branch budget + hard limits → every task traces to the selected branch → ADMISSIBLE_BEFORE_VERIFY gate | route back to intent/act ``` ### Validation Stage - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant A claim is supported only with evidence, never because no contradiction was found; policy is semantic on the relation to a concept, never a substring ban. Flow ```text ContextBundle + Phases + Tasks → ValidationSuites → ClaimVerification → SemanticPolicy → ValidationReport ``` Productions ```bnf ValidationStage ::= "," "," "->" "," "," "->" ValidationReport ::= "pass" | "repair_required" | "blocked" ``` Composes [Validation Suite Battery](https://banes-lab.com/records/algo/validation-suite-battery.md), [Evidence-Based Claim Verification](https://banes-lab.com/records/algo/evidence-based-claim-verification.md), [Semantic Debt Policy](https://banes-lab.com/records/algo/semantic-debt-policy.md) Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [model_governance](https://banes-lab.com/records/force/model-governance.md), [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md) Grounds none Before ```text A claim marked supported because no contradiction was found; policy enforced by banning a word. ``` After ```text context + phases + tasks → GV-* suites → verify every claim by evidence → semantic-debt rubric (relation to a concept) → validation report ``` ### Semantic Debt Policy - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant Policy keys on the relation to a concept, so a prohibited design cannot pass by renaming and legitimately mentioning, analyzing, or removing debt is never blocked. Flow ```text Content → ConceptMatch → RelationClassification → Allowed|Violation|Investigate ``` Productions ```bnf SemanticDebtPolicy ::= "->" "->" "->" ConceptRelation ::= "introduce" | "retain" | "remove" | "analyze" | "mention" | "assert" PolicyDecision ::= "allowed" | "violation" | "investigate" ``` Composes none Composed by [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md) Forces [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text A substring ban blocks the word 'fallback' but the fallback design passes by renaming. ``` After ```text content → match a controlled concept → classify the relation{introduce|retain → violation; mention|analyze|remove → allowed} → a renamed prohibited design still fails ``` ### Evidence-Based Claim Verification - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant A material claim is supported only with evidence whose scope matches it; absence of contradiction is never treated as support. Flow ```text Records → MaterialClaims → EvidenceWeighing → ClaimVerdicts ``` Productions ```bnf EvidenceBasedClaimVerification ::= "->" "->" "->" ClaimVerdict ::= "supported" | "contradicted" | "not_applicable" | "unsupported" ``` Composes none Composed by [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [model_governance](https://banes-lab.com/records/force/model-governance.md) Grounds [ver-evidence](https://banes-lab.com/records/reason/node-ver-evidence.md) Before ```text 'Foo has no other consumers' asserted with no search recorded. ``` After ```text records → material claims → weigh supporting vs contradicting evidence → verdict{supported|contradicted|not-applicable|unsupported}; a zero-result claim records its searched scope ``` ### Validation Suite Battery - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [logic](https://banes-lab.com/records/reason/math-type-logic.md) - Yields: boolean Details Intent 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. Invariant Every gate names the evidence it examined and carries an owner stage; zero blocker or error findings is the sole pass condition. Flow ```text GeneratedRecords → SuiteChecks → OwnedFindings → Pass|RepairRequired ``` Productions ```bnf ValidationSuiteBattery ::= "->" "->" "->" ValidationSuite ::= "GV-STATE" | "GV-AUTHORITY" | "GV-ACTIVATION" | "GV-PLAN" | "GV-TASKS" | "GV-RIPPLE" | "GV-SEMANTIC" | "GV-EVIDENCE" | "GV-OUTPUT" SuiteVerdict ::= "pass" | "repair_required" ``` Composes none Composed by [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [observability_traceability](https://banes-lab.com/records/force/observability-traceability.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text A validation gate is a bare checkmark that names no evidence. ``` After ```text records → GV-STATE/AUTHORITY/ACTIVATION/PLAN/TASKS/RIPPLE/SEMANTIC/EVIDENCE/OUTPUT → each finding names what it examined + an owner stage → zero blocker/error is the only pass ``` ### Repair Stage - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [dynamical-systems](https://banes-lab.com/records/reason/math-type-dynamical-systems.md) - Yields: boolean | counter Details Intent 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. Invariant Repair originates at the earliest invalid stage, cascades invalidation forward only, and is bounded; a downstream record is never restored after an upstream repair. Flow ```text Findings → EarliestOwner → Invalidate + Rerun → Repaired|Blocked ``` Productions ```bnf RepairStage ::= "->" "->" "->" "->" RepairTermination ::= "status_pass_to_rendering" | "cycle_exceeds_max_blocked" ``` Composes [Severity Failure Routing](https://banes-lab.com/records/algo/severity-failure-routing.md), [Bounded Repair Loop](https://banes-lab.com/records/algo/bounded-repair-loop.md) Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [resilience_recovery](https://banes-lab.com/records/force/resilience-recovery.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```text A finding patched at the last stage; upstream cause left intact, downstream records stale. ``` After ```text findings → earliest responsible owner stage → apply fix → invalidate every dependent downstream → re-run from that stage (bounded to 3 cycles) ``` ### Bounded Repair Loop - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [dynamical-systems](https://banes-lab.com/records/reason/math-type-dynamical-systems.md) - Yields: boolean | counter Details Intent 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. Invariant The repair loop is bounded by a fixed cycle limit; exceeding it terminates as blocked rather than looping unbounded. Flow ```text RepairRequired → CycleGuard → InvalidateAndRegenerate → Pass|Blocked ``` Productions ```bnf BoundedRepairLoop ::= "->" "->" "," "->" BoundedTermination ::= "repaired_pass" | "repair_limit_exceeded_blocked" ``` Composes none Composed by [Repair Stage](https://banes-lab.com/records/algo/repair-stage.md) Forces [resilience_recovery](https://banes-lab.com/records/force/resilience-recovery.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds none Before ```text Repair loops unbounded, re-deriving forever on an unfixable finding. ``` After ```text repair-required → cycle guard → invalidate + regenerate downstream → exceeding max_cycles terminates as blocked with the remaining findings ``` ### Severity Failure Routing - Stage: [verify](https://banes-lab.com/records/stage/verify.md) - Axis: [verification](https://banes-lab.com/records/reason/axis-verification.md) - Math type: [optimisation](https://banes-lab.com/records/reason/math-type-optimisation.md) - Yields: boolean | ranking Details Intent 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. Invariant Severity governs the failure route, not the phase order; each severity maps to exactly one route. Flow ```text Finding → Severity → RepairRoute ``` Productions ```bnf SeverityFailureRouting ::= "->" "->" RepairRoute ::= "block_and_repair" | "repair" | "disposition_required" | "investigate" ``` Composes none Composed by [Repair Stage](https://banes-lab.com/records/algo/repair-stage.md) Forces [resilience_recovery](https://banes-lab.com/records/force/resilience-recovery.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds [tel-priority](https://banes-lab.com/records/reason/node-tel-priority.md) Before ```text Every finding blocks the same way, regardless of severity. ``` After ```text finding → severity → route{blocker → block+repair; error → repair; warning → disposition; lower → investigate} → severity routes failure, never phase order ``` ### Rendering Stage - Stage: [commit](https://banes-lab.com/records/stage/commit.md) - Axis: [representation](https://banes-lab.com/records/reason/axis-representation.md) - Math type: [information-theory](https://banes-lab.com/records/reason/math-type-information-theory.md) - Yields: hash | novelty-score Details Intent 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. Invariant Rendering adds no new architecture decision, leaves future execution gates unchecked, and terminates exactly once; it never stops prematurely while repairable nor loops beyond the cycle bound. Flow ```text ValidatedRecords|BlockedReport → DeterministicRender → SuccessArtifact|BlockedArtifact ``` Productions ```bnf RenderingStage ::= | "->" "->" GenerationResult ::= "success_output_file" | "blocked_output_file" ``` Composes [Checklist Output Rendering](https://banes-lab.com/records/algo/checklist-output-rendering.md), [Explicit Termination](https://banes-lab.com/records/algo/explicit-termination.md) Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text Rendering invents a new architecture decision and pre-checks future execution boxes. ``` After ```text validated records | blocked report → deterministic render → exactly one terminal{success artifact | blocked report}; future execution checkboxes left unchecked ``` ### Checklist Output Rendering - Stage: [commit](https://banes-lab.com/records/stage/commit.md) - Axis: [representation](https://banes-lab.com/records/reason/axis-representation.md) - Math type: [information-theory](https://banes-lab.com/records/reason/math-type-information-theory.md) - Yields: hash | novelty-score Details Intent 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. Invariant The rendered artifact preserves linear execution order, dependency topology, and every ripple impact by name, and leaves every future execution checkbox unchecked. Flow ```text Context + Phases + Graphs + Ripples + Gates → ChecklistMarkdown ``` Productions ```bnf ChecklistOutputRendering ::= "->" "->" "->" "->" "->" "->" AppendixSet ::= "file_organization" "," "evidence_inventory" "," "registry_contract_enforcement_changes" ``` Composes none Composed by [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [observability_traceability](https://banes-lab.com/records/force/observability-traceability.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) Grounds none Before ```text The checklist drops ripple impacts to counts and renders inactive principles as mandatory. ``` After ```text context → principle disposition → phases in Z-order{loop class, severity, 4D graph, named ripple} → N.N.N tasks with evidence contracts → per-phase gate → appendices → final blocking gate (all unchecked) ``` ### Explicit Termination - Stage: [terminate](https://banes-lab.com/records/stage/terminate.md) - Axis: [termination](https://banes-lab.com/records/reason/axis-termination.md) - Math type: [set-theory](https://banes-lab.com/records/reason/math-type-set-theory.md) - Yields: set | boolean Details Intent 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. Invariant Termination is explicit and bounded: one of success or blocked, no premature stop, no unbounded loop. Flow ```text ValidationStatus → TerminalSelection → WrittenArtifact ``` Productions ```bnf ExplicitTermination ::= "->" "->" "->" TerminalSelection ::= "write_success_artifact" | "write_blocked_report" ``` Composes none Composed by [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md) Named in the derivation of [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [resilience_recovery](https://banes-lab.com/records/force/resilience-recovery.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds [ter-stop](https://banes-lab.com/records/reason/node-ter-stop.md) Before ```text The generator stops while the status is still repairable, or loops past its bound. ``` After ```text validation status → terminal selection{write success artifact | write blocked report} → render-integrity check → exactly one written artifact, no premature stop, no unbounded loop ``` ### Cross-Stage Invariants - Meta record Details Intent 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. Invariant The generator's cross-stage guarantees hold in every stage; violating any one invalidates the run regardless of local stage success. Flow ```text EveryStage → AlwaysRules + NeverRules → BoundGenerator ``` Productions ```bnf CrossStageInvariants ::= "," "->" InvariantClass ::= "authority_and_directionality_first" | "discover_before_assume" | "principle_bound_to_validator" | "dependency_order_severity_routes" | "single_output_contract_handoff" | "four_axis_graph_with_ripple" | "evidence_for_every_claim" | "generation_gate_not_execution_gate" | "repair_from_earliest_invalid_stage" | "deterministic_render_no_new_decision" ``` Composes none Composed by [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) Forces [model_governance](https://banes-lab.com/records/force/model-governance.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds none Before ```text Each stage guards its own rules; a global always/never guarantee is nowhere enforced. ``` After ```text every stage bound by ALWAYS{authority-first, discover-before-assume, principle-bound-to-validator, dependency-order, single-output handoff, 4D + ripple, evidence-for-claims, repair-from-earliest} + NEVER{prior-knowledge-as-evidence, protocol-from-trigger-word, substring-ban, severity-grouping} ``` ### Checklist Creation Kernel - Math type: [computation](https://banes-lab.com/records/reason/math-type-computation.md) - Yields: procedure Details Intent 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. Invariant Checklist creation is a governance compiler: each of framing, decomposition, tasks, gates, repair, and termination is produced and gated by the stage that owns that decision, under one set of cross-stage invariants. Flow ```text Orientation → Planning → Compilation → Validation → Repair → Rendering ``` Productions ```bnf ChecklistCreationKernel ::= "->" "->" "->" "->" "->" ``` Composes [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md), [Teleological Intent Gate](https://banes-lab.com/records/algo/teleological-intent-gate.md), [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md), [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md), [Admissibility Constraint Gate](https://banes-lab.com/records/algo/admissibility-constraint-stage.md), [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md), [Repair Stage](https://banes-lab.com/records/algo/repair-stage.md), [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md), [Cross-Stage Invariants](https://banes-lab.com/records/algo/cross-stage-invariants.md) Forces [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [security_governance](https://banes-lab.com/records/force/security-governance.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds [derivation-loop](https://banes-lab.com/ontology/reasoning/reason-loop-derivation-loop.md) Grounded by [derivation-loop](https://banes-lab.com/ontology/reasoning/reason-loop-derivation-loop.md) Derivation map orient [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md) intent [Teleological Intent Gate](https://banes-lab.com/records/algo/teleological-intent-gate.md) derive [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md) project [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md) act [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) constrain [Admissibility Constraint Gate](https://banes-lab.com/records/algo/admissibility-constraint-stage.md) verify [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md) commit [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md) terminate [Explicit Termination](https://banes-lab.com/records/algo/explicit-termination.md) Before ```text A task compiled straight into a flat checklist, ungated and unordered. ``` After ```text orientation → planning → compilation → validation → repair → rendering, bound by cross-stage invariants → a validated dependency-ordered checklist or an evidence-bearing blocked report ``` ### - Meta record Details Intent → → → → → Invariant Any implementation checklist is generated as a validated, dependency-ordered execution graph whose every decision is owned and gated by a stage, not as a flat task list. Flow ```text Authority → Evidence → Principles → Phases → Graph → Ripples → Validation → Repair → Terminal ``` Productions ```bnf ChecklistGovernanceConcern ::= "->" "->" "->" "->" "->" CompletionCondition ::= "authority_and_directionality_resolved" "," "phases_dependency_ordered_with_4d_graph" "," "tasks_atomic_with_named_ripple_chains" "," "claims_evidence_backed" "," "semantic_policy_satisfied" "," "bounded_repair_converged" "," "single_terminal_emitted" ``` Composes none Forces [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [security_governance](https://banes-lab.com/records/force/security-governance.md), [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md), [model_governance](https://banes-lab.com/records/force/model-governance.md) Grounds none ## Links to - [Orient](https://banes-lab.com/records/stage/orient.md) - [Ontology](https://banes-lab.com/records/reason/axis-ontology.md) - [Set Theory](https://banes-lab.com/records/reason/math-type-set-theory.md) - [Authoritative Source Loading](https://banes-lab.com/records/algo/authoritative-source-loading.md) - [Trust Anchor](https://banes-lab.com/records/algo/trust-anchor.md) - [Intent & Directionality Normalization](https://banes-lab.com/records/algo/intent-directionality-normalization.md) - [Skeptical Context Acquisition](https://banes-lab.com/records/algo/skeptical-context-acquisition.md) - [Dynamic Discovery Pattern Generation](https://banes-lab.com/records/algo/dynamic-discovery-pattern-generation.md) - [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md) - [metaprogramming_modeling](https://banes-lab.com/records/force/metaprogramming-modeling.md) - [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) - [control_coordination](https://banes-lab.com/records/force/control-coordination.md) - [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md) - [Logic](https://banes-lab.com/records/reason/math-type-logic.md) - [security_governance](https://banes-lab.com/records/force/security-governance.md) - [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md) - [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md) - [Computation](https://banes-lab.com/records/reason/math-type-computation.md) - [Intent](https://banes-lab.com/records/stage/intent.md) - [Teleology](https://banes-lab.com/records/reason/axis-teleology.md) - [Optimisation](https://banes-lab.com/records/reason/math-type-optimisation.md) - [architecture_evolution](https://banes-lab.com/records/force/architecture-evolution.md) - [Tel Priority](https://banes-lab.com/records/reason/node-tel-priority.md) - [Derive](https://banes-lab.com/records/stage/derive.md) - [Reasoning](https://banes-lab.com/records/reason/axis-reasoning.md) - [Principle Activation](https://banes-lab.com/records/algo/principle-activation.md) - [Protocol Semantic Selection](https://banes-lab.com/records/algo/protocol-semantic-selection.md) - [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md) - [Four-Dimensional Phase Graph](https://banes-lab.com/records/algo/four-dimensional-phase-graph.md) - [Dependency Linearization](https://banes-lab.com/records/algo/dependency-linearization.md) - [Severity Assignment](https://banes-lab.com/records/algo/severity-assignment.md) - [Loop Class Labeling](https://banes-lab.com/records/algo/loop-class-labeling.md) - [modularity](https://banes-lab.com/records/force/modularity.md) - [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md) - [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md) - [Project](https://banes-lab.com/records/stage/project.md) - [Graph](https://banes-lab.com/records/reason/math-type-graph.md) - [model_governance](https://banes-lab.com/records/force/model-governance.md) - [causality_ordering](https://banes-lab.com/records/force/causality-ordering.md) - [Act](https://banes-lab.com/records/stage/act.md) - [Formalisation](https://banes-lab.com/records/reason/axis-formalisation.md) - [Verb Template Binding](https://banes-lab.com/records/algo/verb-template-binding.md) - [Codebase Pattern Enforcement](https://banes-lab.com/records/algo/codebase-pattern-enforcement.md) - [Task Atomization](https://banes-lab.com/records/algo/task-atomization.md) - [Ripple Chain Analysis](https://banes-lab.com/records/algo/ripple-chain-analysis.md) - [Validator Coverage](https://banes-lab.com/records/algo/validator-coverage.md) - [Structured Observability Context](https://banes-lab.com/records/algo/structured-observability-context.md) - [Cross-Cutting Surface Coverage](https://banes-lab.com/records/algo/cross-cutting-surface-coverage.md) - [Legacy Elimination](https://banes-lab.com/records/algo/legacy-elimination.md) - [Hierarchical Numbering](https://banes-lab.com/records/algo/hierarchical-numbering.md) - [object_creation](https://banes-lab.com/records/force/object-creation.md) - [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md) - [observability_traceability](https://banes-lab.com/records/force/observability-traceability.md) - [performance_scaling](https://banes-lab.com/records/force/performance-scaling.md) - [resilience_recovery](https://banes-lab.com/records/force/resilience-recovery.md) - [Algebra](https://banes-lab.com/records/reason/math-type-algebra.md) - [Constrain](https://banes-lab.com/records/stage/constrain.md) - [Verify](https://banes-lab.com/records/stage/verify.md) - [Verification](https://banes-lab.com/records/reason/axis-verification.md) - [Validation Suite Battery](https://banes-lab.com/records/algo/validation-suite-battery.md) - [Evidence-Based Claim Verification](https://banes-lab.com/records/algo/evidence-based-claim-verification.md) - [Semantic Debt Policy](https://banes-lab.com/records/algo/semantic-debt-policy.md) - [Validation Stage](https://banes-lab.com/records/algo/validation-stage.md) - [Ver Evidence](https://banes-lab.com/records/reason/node-ver-evidence.md) - [Dynamical Systems](https://banes-lab.com/records/reason/math-type-dynamical-systems.md) - [Severity Failure Routing](https://banes-lab.com/records/algo/severity-failure-routing.md) - [Bounded Repair Loop](https://banes-lab.com/records/algo/bounded-repair-loop.md) - [Repair Stage](https://banes-lab.com/records/algo/repair-stage.md) - [Commit](https://banes-lab.com/records/stage/commit.md) - [Representation](https://banes-lab.com/records/reason/axis-representation.md) - [Information Theory](https://banes-lab.com/records/reason/math-type-information-theory.md) - [Checklist Output Rendering](https://banes-lab.com/records/algo/checklist-output-rendering.md) - [Explicit Termination](https://banes-lab.com/records/algo/explicit-termination.md) - [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md) - [Terminate](https://banes-lab.com/records/stage/terminate.md) - [Termination](https://banes-lab.com/records/reason/axis-termination.md) - [Ter Stop](https://banes-lab.com/records/reason/node-ter-stop.md) - [Teleological Intent Gate](https://banes-lab.com/records/algo/teleological-intent-gate.md) - [Admissibility Constraint Gate](https://banes-lab.com/records/algo/admissibility-constraint-stage.md) - [Cross-Stage Invariants](https://banes-lab.com/records/algo/cross-stage-invariants.md) - [The derivation loop](https://banes-lab.com/ontology/reasoning/reason-loop-derivation-loop.md)