{ "category": "checklist-creation", "tier": "process", "check": { "by": [ "the generator's validation stage and its validation suite", "the structured-document validator over the checklist template" ], "population": "every phase and task the generated checklist carries", "freshness": "a verdict stands until the plan, its sources or the codebase it targets change", "refusal": "the generator renders no checklist while a blocker or error finding remains, and terminates blocked past its repair bound", "observation": "none: a checklist is verified before execution; its tasks name the checks that observe execution", "evidence": "fires-and-accepts: a suite plants a retired head in a real template and validates the unplanted templates clean, while the generator's own stage is stated as a class", "authority": "the plan and its sources, which the checklist is derived from" }, "records": [ { "id": "orientation-stage", "stage": "orient", "axis": "ontology", "mathType": "set-theory", "yields": "set | boolean", "title": "Orientation Stage", "exemplar": { "before": "Planning starts from the task text alone — prior model knowledge treated as current system truth.", "after": "raw task + governing docs → load authority → discover current system → normalize intent + change_relation → context_bundle{evidence_inventory non-empty}", "lang": "flow", "medium": "composite" }, "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": [ "RawTask + GoverningDocs", "AuthorityLoad", "ContextDiscovery", "IntentNormalization", "ContextBundle|RepairRoute" ], "productions": [ { "lhs": "OrientationStage", "rhs": " \",\" \"→\" \"→\" \"→\" \"→\" " }, { "lhs": "ContextBundle", "rhs": " \",\" \",\" \",\" \",\" \",\" \",\" \",\" " }, { "lhs": "OrientationHandoff", "rhs": "\"authority_loaded\" \",\" \"intent_and_change_direction_resolved\" \",\" \"evidence_inventory_non_empty\" \"→\" \"pass_to_planning\" | \"repair_owner_orientation\"" } ], "composes": [ "authoritative-source-loading", "trust-anchor", "intent-directionality-normalization", "skeptical-context-acquisition", "dynamic-discovery-pattern-generation" ], "force": [ "metaprogramming_modeling", "correctness_verification", "control_coordination" ] }, { "id": "authoritative-source-loading", "stage": "orient", "axis": "ontology", "mathType": "set-theory", "yields": "set | boolean", "title": "Authoritative Source Loading", "exemplar": { "before": "Decomposition grounded in memory, not the host's rules; a missing source is discovered too late.", "after": "task → always-read core{governance, principle-ontology} + triggered{architecture, design, component} → read before analysis → block on a missing required source", "lang": "flow", "medium": "composite" }, "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": [ "TaskDescription", "CoreSources + TriggeredSources", "SourceRead", "LoadedContext|BlockMissing" ], "productions": [ { "lhs": "AuthoritativeSourceLoading", "rhs": " \"→\" \",\" \"→\" \"→\" " }, { "lhs": "SourceSelection", "rhs": "\"always_read_core\" \",\" \"read_conditional_source_when_trigger_present\"" }, {"lhs": "SourceValidationGate", "rhs": "\"all_required_sources_loaded\" | \"blocked_missing_source\""} ], "composes": [], "force": [ "metaprogramming_modeling", "correctness_verification" ] }, { "id": "trust-anchor", "stage": "orient", "axis": "ontology", "mathType": "logic", "yields": "boolean", "title": "Trust Anchor", "exemplar": { "before": "Every input trusted equally — a narrative doc grounds a task the same as a build result.", "after": "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", "lang": "flow", "medium": "composite" }, "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": [ "InputSource", "TrustClassification", "UsagePolicy" ], "productions": [ { "lhs": "TrustAnchor", "rhs": " \"→\" \",\" \"→\" " }, {"lhs": "UsagePolicy", "rhs": "\"trusted_can_ground_tasks\" | \"untrusted_requires_verification\""} ], "composes": [], "force": [ "correctness_verification", "security_governance" ] }, { "id": "intent-directionality-normalization", "stage": "orient", "axis": "ontology", "mathType": "logic", "yields": "boolean", "title": "Intent & Directionality Normalization", "exemplar": { "before": "'update Foo' planned without resolving whether Foo is introduced, retained, or removed.", "after": "task → outcome + actions + entities → change_relation{introduce|retain|remove|analyze|mention} → unknown direction recorded as an unresolved question, never assumed", "lang": "flow", "medium": "composite" }, "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": [ "TaskDescription", "IntentExtraction", "DirectionalityAnalysis", "NormalizedIntent + Ambiguity" ], "productions": [ { "lhs": "IntentDirectionalityNormalization", "rhs": " \",\" \"→\" \",\" \",\" \"→\" \",\" " }, { "lhs": "ChangeRelation", "rhs": "\"introduce\" | \"retain\" | \"remove\" | \"analyze\" | \"mention\" | \"unknown\"" } ], "composes": [], "force": [ "semantic_consistency", "correctness_verification" ] }, { "id": "skeptical-context-acquisition", "stage": "orient", "axis": "ontology", "mathType": "set-theory", "yields": "set | boolean", "title": "Skeptical Context Acquisition", "exemplar": { "before": "New work redefines a Foo abstraction that already exists, unseen.", "after": "normalized intent → keywords → dynamic discovery probes → discovered artifacts{base classes, implementations, registrations} + evidence, before any architecture assumption", "lang": "flow", "medium": "composite" }, "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": [ "NormalizedIntent", "Keywords", "DiscoveryProbes", "DiscoveredArtifacts + Evidence" ], "productions": [ { "lhs": "SkepticalContextAcquisition", "rhs": " \"→\" \"→\" \"→\" \"→\" " }, { "lhs": "KeywordExtraction", "rhs": "\"technical_nouns\" \",\" \"action_verbs\" \",\" \"file_refs\" \",\" \"folders\"" }, { "lhs": "DiscoveredArtifacts", "rhs": "\"base_classes\" \",\" \"implementations\" \",\" \"registrations\" \",\" \"migrations\" \",\" \"signatures\"" } ], "composes": ["dynamic-discovery-pattern-generation"], "force": [ "runtime_extensibility", "correctness_verification" ] }, { "id": "dynamic-discovery-pattern-generation", "stage": "orient", "axis": "ontology", "mathType": "computation", "yields": "procedure", "title": "Dynamic Discovery Pattern Generation", "exemplar": { "before": "Discovery runs a fixed checklist of globs, blind to the task's own nouns.", "after": "keywords{nouns, verbs, folders, file-refs} → generated globs + greps + target-files from the task's own language, not a fixed enumeration", "lang": "flow", "medium": "composite" }, "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": [ "Keywords", "Globs + Greps + Targets", "ProbeExecution" ], "productions": [ { "lhs": "DynamicDiscoveryPatternGeneration", "rhs": " \"→\" \",\" \",\" " }, {"lhs": "DiscoveryProbe", "rhs": " \",\" \",\" "}, {"lhs": "ProbeTool", "rhs": "\"Glob\" | \"Grep\" | \"Read\""} ], "composes": [], "force": [ "runtime_extensibility", "metaprogramming_modeling" ] }, { "id": "teleological-intent-gate", "stage": "intent", "axis": "teleology", "mathType": "optimization", "yields": "boolean | ranking", "grounds": ["reasoning:tel-priority"], "title": "Teleological Intent Gate", "exemplar": { "before": "Decomposition begins on the first approach that comes to mind — no worth comparison, so effort is spent before the objective is ranked.", "after": "context_bundle → enumerate admissible decomposition branches → score utility - cost → select the argmax → WORTH_BEFORE_WORK gate before any planning", "lang": "flow", "medium": "composite" }, "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": [ "ContextBundle", "AdmissibleBranchEnumeration", "UtilityCostScoring", "ArgmaxSelection|Blocked" ], "productions": [ { "lhs": "TeleologicalIntentGate", "rhs": " \"→\" \"→\" \"→\" | " }, { "lhs": "BranchSelection", "rhs": "\"argmax_utility_minus_cost_over_admissible\" | \"blocked_no_admissible_branch\"" } ], "composes": [], "force": [ "correctness_verification", "control_coordination", "architecture_evolution" ] }, { "id": "planning-stage", "stage": "derive", "axis": "reasoning", "mathType": "logic", "yields": "boolean", "title": "Planning Stage", "exemplar": { "before": "Phases grouped under SPRINT: CRITICAL headers; a protocol picked from a trigger word.", "after": "context_bundle → activate principles (each binds a decision-test + validator) → select protocols by semantic fit → decompose → 4D graph → linearize by dependency (severity is metadata)", "lang": "flow", "medium": "composite" }, "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": [ "ContextBundle", "ActivePrinciples", "SelectedProtocols", "PhaseGraph", "LinearizedPhases|CycleRepair" ], "productions": [ { "lhs": "PlanningStage", "rhs": " \"→\" \"→\" \"→\" \"→\" \"→\" " }, { "lhs": "PlanningHandoff", "rhs": "\"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", "protocol-semantic-selection", "phase-decomposition", "four-dimensional-phase-graph", "dependency-linearization", "severity-assignment", "loop-class-labeling" ], "force": [ "correctness_verification", "architecture_evolution", "control_coordination", "modularity" ] }, { "id": "principle-activation", "stage": "derive", "axis": "reasoning", "mathType": "logic", "yields": "boolean", "title": "Principle Activation", "exemplar": { "before": "'SRP applies' asserted as a label, with no decision-test and nothing that enforces it.", "after": "decision surfaces → test each principle{applies|uncertain|not-applicable + reason} → bind validator + severity → a label alone is never proof reasoning occurred", "lang": "flow", "medium": "composite" }, "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": [ "ContextBundle", "DecisionSurfaces", "PrincipleFit", "ActivePrincipleSet" ], "productions": [ { "lhs": "PrincipleActivation", "rhs": " \"→\" \"→\" \",\" \",\" " }, {"lhs": "ApplicabilityDisposition", "rhs": "\"applies\" | \"uncertain\" | \"not_applicable\""}, {"lhs": "Severity", "rhs": "\"mandatory\" | \"recommended\" | \"contextual\" | \"discouraged\""} ], "composes": [], "force": [ "correctness_verification", "architecture_evolution", "contract_compatibility" ] }, { "id": "protocol-semantic-selection", "stage": "derive", "axis": "reasoning", "mathType": "logic", "yields": "boolean", "title": "Protocol Semantic Selection", "exemplar": { "before": "The word 'secure' in the task auto-selects the security protocol.", "after": "requested transition + surfaces → semantic-fit match against the protocol library → selected set → the mandatory verification protocol always injected", "lang": "flow", "medium": "composite" }, "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": [ "ContextBundle + ActivePrinciples", "SemanticMatch", "SelectedProtocols", "VerificationInjected" ], "productions": [ { "lhs": "ProtocolSemanticSelection", "rhs": " \",\" \",\" \"→\" \"→\" \"→\" " }, { "lhs": "Protocol", "rhs": "\"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": [], "force": [ "correctness_verification", "semantic_consistency", "runtime_extensibility" ] }, { "id": "phase-decomposition", "stage": "project", "axis": "reasoning", "mathType": "graph", "yields": "edge-list", "title": "Phase Decomposition", "exemplar": { "before": "A protocol's steps emitted as a flat task list with no inputs, outputs, or dependency metadata.", "after": "selected protocols → verb chains → phases annotated{id, verb, objective, inputs, outputs, principles, severity, loop_class, 4D graph}", "lang": "flow", "medium": "composite" }, "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": [ "SelectedProtocols", "VerbChains", "PhaseSet", "AnnotatedPhases" ], "productions": [ { "lhs": "PhaseDecomposition", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "PhaseAnnotation", "rhs": "\"id\" \",\" \"verb\" \",\" \"objective\" \",\" \"inputs\" \",\" \"outputs\" \",\" \"affected_artifacts\" \",\" \"principles\" \",\" \"severity\" \",\" \"loop_class\" \",\" \"graph_4d\"" } ], "composes": [ "four-dimensional-phase-graph", "severity-assignment", "loop-class-labeling" ], "force": [ "correctness_verification", "metaprogramming_modeling", "control_coordination", "architecture_evolution" ] }, { "id": "four-dimensional-phase-graph", "stage": "project", "axis": "reasoning", "mathType": "graph", "yields": "edge-list", "title": "Four-Dimensional Phase Graph", "exemplar": { "before": "A phase records only its order — its downstream ripple is invisible.", "after": "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", "lang": "flow", "medium": "composite" }, "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": [ "Phase", "Z + X + Y + W Graph" ], "productions": [ { "lhs": "FourDPhaseGraph", "rhs": " \"→\" \",\" \",\" \",\" " }, {"lhs": "SequentialAxis", "rhs": "\"Z: prior_required_phases\""}, {"lhs": "LateralAxis", "rhs": "\"X: independent_peer_phases\""}, {"lhs": "DiagonalAxis", "rhs": "\"Y: shared_data_or_output_relationships\""}, {"lhs": "PropagationAxis", "rhs": "\"W: superseded_state, propagated_contracts, breaks_if_omitted\""} ], "composes": [], "force": [ "contract_compatibility", "model_governance", "control_coordination", "architecture_evolution" ] }, { "id": "dependency-linearization", "stage": "project", "axis": "reasoning", "mathType": "graph", "yields": "edge-list", "title": "Dependency Linearization", "exemplar": { "before": "Phases ordered by priority label; a hidden cycle ships undetected.", "after": "phase graph → detect Z-cycles (block on any) → topological Z-order with a stable tie-breaker; severity never controls order", "lang": "flow", "medium": "composite" }, "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": [ "PhaseGraph", "CycleCheck", "TopologicalOrder|BlockedCycle" ], "productions": [ { "lhs": "DependencyLinearization", "rhs": " \"→\" \"→\" | " }, {"lhs": "LinearizationResult", "rhs": "\"pass_topological_order\" | \"blocked_cycle\""} ], "composes": [], "force": [ "causality_ordering", "control_coordination", "correctness_verification" ] }, { "id": "severity-assignment", "stage": "project", "axis": "reasoning", "mathType": "optimization", "yields": "boolean | ranking", "grounds": ["reasoning:tel-priority"], "title": "Severity Assignment", "exemplar": { "before": "Severity used as a section header that groups the phases.", "after": "phase → worst severity of its governing principles → per-phase metadata that routes the repair, never a grouping or ordering axis", "lang": "flow", "medium": "composite" }, "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": [ "Phase", "LocalPrinciples", "WorstSeverity" ], "productions": [ { "lhs": "SeverityAssignment", "rhs": " \"→\" \"→\" \"→\" " } ], "composes": [], "force": [ "control_coordination", "architecture_evolution" ] }, { "id": "loop-class-labeling", "stage": "project", "axis": "reasoning", "mathType": "logic", "yields": "boolean", "title": "Loop Class Labeling", "exemplar": { "before": "A phase's cognitive role is implicit in its verb.", "after": "verb → loop class{Construction|Perceptual|Cognitive|Executive|Linking} → the phase's cognitive role made explicit", "lang": "flow", "medium": "composite" }, "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": [ "Verb", "LoopClass", "LoopPattern" ], "productions": [ {"lhs": "LoopClassLabeling", "rhs": " \"→\" \"→\" "}, { "lhs": "LoopClass", "rhs": "\"Construction\" | \"Perceptual\" | \"Cognitive\" | \"Executive\" | \"Linking\"" } ], "composes": [], "force": ["control_coordination"] }, { "id": "compilation-stage", "stage": "act", "axis": "formalization", "mathType": "computation", "yields": "procedure", "title": "Compilation Stage", "exemplar": { "before": "Phases emitted as vague tasks with count-only ripple ('touches 3 consumers').", "after": "phase records → bind verb templates + codebase-pattern constraints → atomize → attach 9-dimension named ripple chain → number N.N.N", "lang": "flow", "medium": "composite" }, "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": [ "PhaseRecords", "TaskTemplates + PatternConstraints", "AtomicTasks", "RippleChains + Numbering" ], "productions": [ { "lhs": "CompilationStage", "rhs": " \"→\" \",\" \"→\" \"→\" \"→\" " }, { "lhs": "CompilationHandoff", "rhs": "\"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", "codebase-pattern-enforcement", "task-atomization", "ripple-chain-analysis", "validator-coverage", "structured-observability-context", "cross-cutting-surface-coverage", "legacy-elimination", "hierarchical-numbering" ], "force": [ "correctness_verification", "control_coordination", "architecture_evolution", "object_creation" ] }, { "id": "codebase-pattern-enforcement", "stage": "act", "axis": "formalization", "mathType": "logic", "yields": "boolean", "title": "Codebase Pattern Enforcement", "exemplar": { "before": "A task says 'construct Foo' with no required pattern — direct instantiation slips through.", "after": "task → scan forbidden forms → rewrite each to its required form{factory, DI, registry, events, ports, contract-first, fail-fast, secrets} before emit", "lang": "flow", "medium": "composite" }, "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": [ "Task", "PatternViolationScan", "RequiredRewrite", "CompliantTask" ], "productions": [ { "lhs": "CodebasePatternEnforcement", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "PatternDomain", "rhs": "\"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": [], "force": [ "architecture_evolution", "object_creation", "correctness_verification" ] }, { "id": "verb-template-binding", "stage": "act", "axis": "formalization", "mathType": "computation", "yields": "procedure", "title": "Verb Template Binding", "exemplar": { "before": "'CREATE Foo' becomes a task with no tools and no way to validate it.", "after": "verb → task pattern + tool set + blocking validation command → a verb becomes a task only through a validated template", "lang": "flow", "medium": "composite" }, "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": [ "Verb", "TaskPattern", "Tools", "ValidationCommand" ], "productions": [ { "lhs": "VerbTemplateBinding", "rhs": " \"→\" \",\" \",\" " }, { "lhs": "Verb", "rhs": "\"ANALYZE\" | \"FIND\" | \"EXTRACT\" | \"CREATE\" | \"VERIFY\" | \"FILTER\" | \"EXECUTE\" | \"WRITE\" | \"READ\" | \"LINK\" | \"ITERATE\"" } ], "composes": [], "force": [ "correctness_verification", "metaprogramming_modeling", "control_coordination" ] }, { "id": "task-atomization", "stage": "act", "axis": "formalization", "mathType": "computation", "yields": "procedure", "title": "Task Atomization", "exemplar": { "before": "One coarse task 'refactor the Foo module' — too big to execute or validate.", "after": "phase → task groups → atomic actions (gated by codebase patterns) → each carries an evidence contract + validation method + done-condition", "lang": "flow", "medium": "composite" }, "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": [ "Phase", "TaskGroups", "AtomicActions + Gates", "AtomicTasks" ], "productions": [ { "lhs": "TaskAtomization", "rhs": " \"→\" \"→\" \"→\" \"→\" " }, { "lhs": "AtomicTask", "rhs": " \",\" \",\" \",\" \",\" " } ], "composes": ["codebase-pattern-enforcement"], "force": [ "correctness_verification", "control_coordination", "modularity" ] }, { "id": "ripple-chain-analysis", "stage": "act", "axis": "formalization", "mathType": "graph", "yields": "edge-list", "title": "Ripple Chain Analysis", "exemplar": { "before": "Impact recorded as a count ('affects 4 things'), filtered to the first match.", "after": "task → 9 dims{registry, contracts, persistence, security, infrastructure, performance, observability, enforcement, consumers} → every named downstream impact + consequence-if-omitted; empty dim carries applicability evidence", "lang": "flow", "medium": "composite" }, "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": [ "Task", "RippleDimensions", "NamedImpacts", "DownstreamChain" ], "productions": [ { "lhs": "RippleChainAnalysis", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "RippleDimensionSet", "rhs": "\"registry\" \",\" \"contracts\" \",\" \"persistence\" \",\" \"security\" \",\" \"infrastructure\" \",\" \"performance\" \",\" \"observability\" \",\" \"enforcement\" \",\" \"consumers\"" }, {"lhs": "ImpactSet", "rhs": " | \"none_with_applicability_evidence\""} ], "composes": [], "force": [ "runtime_extensibility", "correctness_verification", "architecture_evolution" ] }, { "id": "validator-coverage", "stage": "act", "axis": "formalization", "mathType": "logic", "yields": "boolean", "title": "Validator Coverage", "exemplar": { "before": "A new Foo invariant protected by a convention no check enforces.", "after": "pattern → discover a detector or author one → register + regenerate the catalog → the rule becomes an active gate, not a convention", "lang": "flow", "medium": "composite" }, "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": [ "Pattern", "DetectorDiscovery", "AuthorOrUpdate", "RegisterAndRegenerate", "EnforcementActive" ], "productions": [ { "lhs": "ValidatorCoverage", "rhs": " \"→\" \"→\" \"→\" \"→\" " }, {"lhs": "CoverageDecision", "rhs": "\"update_existing_detector\" | \"author_new_detector\""} ], "composes": [], "force": [ "correctness_verification", "runtime_extensibility" ] }, { "id": "structured-observability-context", "stage": "act", "axis": "formalization", "mathType": "logic", "yields": "boolean", "title": "Structured Observability Context", "exemplar": { "before": "An error task emits a stringified blob instead of queryable context.", "after": "task → observability trigger{error|violation|event|lifecycle|contract} → required schema-complete, machine-queryable context matched to the concern", "lang": "flow", "medium": "composite" }, "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": [ "Task", "ObservabilityTrigger", "RequiredContext", "SchemaValidation" ], "productions": [ { "lhs": "StructuredObservabilityContext", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "RequiredContext", "rhs": "\"error\" | \"violation\" | \"event\" | \"lifecycle\" | \"contract\"" } ], "composes": [], "force": ["observability_traceability"] }, { "id": "cross-cutting-surface-coverage", "stage": "act", "axis": "formalization", "mathType": "logic", "yields": "boolean", "title": "Cross-Cutting Surface Coverage", "exemplar": { "before": "A change gated only on structure; its threat, budget, and failure consequences uncovered.", "after": "task → surfaces{security, performance, infrastructure, resilience} → a gate per surface → coverage beyond structure verified", "lang": "flow", "medium": "composite" }, "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": [ "Task", "SurfaceDetection", "SurfaceGates", "CoverageVerification" ], "productions": [ { "lhs": "CrossCuttingSurfaceCoverage", "rhs": " \"→\" \"→\" \"→\" " }, {"lhs": "SurfaceSet", "rhs": "\"security\" | \"performance\" | \"infrastructure\" | \"resilience\""} ], "composes": [], "force": [ "security_governance", "performance_scaling", "resilience_recovery", "architecture_evolution" ] }, { "id": "legacy-elimination", "stage": "act", "axis": "formalization", "mathType": "logic", "yields": "boolean", "title": "Legacy Elimination", "exemplar": { "before": "A replaced Foo path left behind beside its successor as a dual path 'for now'.", "after": "change → detect superseded{dual-path, fallback, deprecated, dead code, orphaned export} → delete in the same change → exactly one live path remains", "lang": "flow", "medium": "composite" }, "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": [ "Change", "SupersededDetection", "SamePassRemoval", "SinglePathGate" ], "productions": [ { "lhs": "LegacyElimination", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "SupersededPathSet", "rhs": "\"dual_path\" | \"fallback\" | \"deprecated\" | \"dead_code\" | \"orphaned_export\"" } ], "composes": [], "force": [ "architecture_evolution", "correctness_verification" ] }, { "id": "hierarchical-numbering", "stage": "act", "axis": "formalization", "mathType": "algebra", "yields": "ordered-structure", "title": "Hierarchical Numbering", "exemplar": { "before": "Tasks numbered before the phase order is stable, so ids churn.", "after": "stable order → Phase N → Task N.N → Subtask N.N.N → addressable coordinates assigned only after order is fixed", "lang": "flow", "medium": "composite" }, "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": [ "Phases", "Tasks", "Subtasks", "N.N.N Coordinates" ], "productions": [ { "lhs": "HierarchicalNumbering", "rhs": " \"→\" \"→\" \"→\" " }, {"lhs": "HierarchicalId", "rhs": "\"N\" | \"N.N\" | \"N.N.N\""} ], "composes": [], "force": [ "control_coordination", "architecture_evolution" ] }, { "id": "admissibility-constraint-stage", "stage": "constrain", "axis": "teleology", "mathType": "optimization", "yields": "boolean | ranking", "title": "Admissibility Constraint Gate", "exemplar": { "before": "The compiled plan goes straight to verification — its realized cost is never checked against the selected branch's budget, so an over-budget or off-branch plan is verified and shipped anyway.", "after": "task_records + phase_records → sum realized cost → compare to branch budget + hard limits → every task traces to the selected branch → ADMISSIBLE_BEFORE_VERIFY gate | route back to intent/act", "lang": "flow", "medium": "composite" }, "intent": "Gate the formalized plan on teleological admissibility before verification: sum the realized 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 realized cost is within budget, every hard limit holds, and every task traces to the selected branch; the cost is never silently accepted.", "flow": [ "TaskRecords + PhaseRecords + SelectedBranch", "RealizedCostSum", "BudgetAndLimitCheck", "Admissible|RouteBack" ], "productions": [ { "lhs": "AdmissibilityConstraintGate", "rhs": " \",\" \",\" \"→\" \"→\" \"→\" " }, { "lhs": "AdmissibilityVerdict", "rhs": "\"admissible_within_budget_and_limits\" | \"inadmissible_route_to_intent\" | \"limit_breach_route_to_act\"" } ], "composes": [], "force": [ "correctness_verification", "control_coordination", "architecture_evolution" ] }, { "id": "validation-stage", "stage": "verify", "axis": "verification", "mathType": "logic", "yields": "boolean", "title": "Validation Stage", "exemplar": { "before": "A claim marked supported because no contradiction was found; policy enforced by banning a word.", "after": "context + phases + tasks → GV-* suites → verify every claim by evidence → semantic-debt rubric (relation to a concept) → validation report", "lang": "flow", "medium": "composite" }, "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": [ "ContextBundle + Phases + Tasks", "ValidationSuites", "ClaimVerification", "SemanticPolicy", "ValidationReport" ], "productions": [ { "lhs": "ValidationStage", "rhs": " \",\" \",\" \"→\" \",\" \",\" \"→\" " }, {"lhs": "ValidationReport", "rhs": "\"pass\" | \"repair_required\" | \"blocked\""} ], "composes": [ "validation-suite-battery", "evidence-based-claim-verification", "semantic-debt-policy" ], "force": [ "correctness_verification", "model_governance", "semantic_consistency" ] }, { "id": "semantic-debt-policy", "stage": "verify", "axis": "verification", "mathType": "logic", "yields": "boolean", "title": "Semantic Debt Policy", "exemplar": { "before": "A substring ban blocks the word 'fallback' but the fallback design passes by renaming.", "after": "content → match a controlled concept → classify the relation{introduce|retain → violation; mention|analyze|remove → allowed} → a renamed prohibited design still fails", "lang": "flow", "medium": "composite" }, "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": [ "Content", "ConceptMatch", "RelationClassification", "Allowed|Violation|Investigate" ], "productions": [ { "lhs": "SemanticDebtPolicy", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "ConceptRelation", "rhs": "\"introduce\" | \"retain\" | \"remove\" | \"analyze\" | \"mention\" | \"assert\"" }, {"lhs": "PolicyDecision", "rhs": "\"allowed\" | \"violation\" | \"investigate\""} ], "composes": [], "force": [ "semantic_consistency", "correctness_verification", "architecture_evolution" ] }, { "id": "evidence-based-claim-verification", "stage": "verify", "axis": "verification", "mathType": "logic", "yields": "boolean", "grounds": ["reasoning:ver-evidence"], "title": "Evidence-Based Claim Verification", "exemplar": { "before": "'Foo has no other consumers' asserted with no search recorded.", "after": "records → material claims → weigh supporting vs contradicting evidence → verdict{supported|contradicted|not-applicable|unsupported}; a zero-result claim records its searched scope", "lang": "flow", "medium": "composite" }, "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": [ "Records", "MaterialClaims", "EvidenceWeighing", "ClaimVerdicts" ], "productions": [ { "lhs": "EvidenceBasedClaimVerification", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "ClaimVerdict", "rhs": "\"supported\" | \"contradicted\" | \"not_applicable\" | \"unsupported\"" } ], "composes": [], "force": [ "correctness_verification", "model_governance" ] }, { "id": "validation-suite-battery", "stage": "verify", "axis": "verification", "mathType": "logic", "yields": "boolean", "title": "Validation Suite Battery", "exemplar": { "before": "A validation gate is a bare checkmark that names no evidence.", "after": "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", "lang": "flow", "medium": "composite" }, "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": [ "GeneratedRecords", "SuiteChecks", "OwnedFindings", "Pass|RepairRequired" ], "productions": [ { "lhs": "ValidationSuiteBattery", "rhs": " \"→\" \"→\" \"→\" " }, { "lhs": "ValidationSuite", "rhs": "\"GV-STATE\" | \"GV-AUTHORITY\" | \"GV-ACTIVATION\" | \"GV-PLAN\" | \"GV-TASKS\" | \"GV-RIPPLE\" | \"GV-SEMANTIC\" | \"GV-EVIDENCE\" | \"GV-OUTPUT\"" }, {"lhs": "SuiteVerdict", "rhs": "\"pass\" | \"repair_required\""} ], "composes": [], "force": [ "correctness_verification", "observability_traceability", "architecture_evolution" ] }, { "id": "repair-stage", "stage": "verify", "axis": "verification", "mathType": "dynamical-systems", "yields": "boolean | counter", "title": "Repair Stage", "exemplar": { "before": "A finding patched at the last stage; upstream cause left intact, downstream records stale.", "after": "findings → earliest responsible owner stage → apply fix → invalidate every dependent downstream → re-run from that stage (bounded to 3 cycles)", "lang": "flow", "medium": "composite" }, "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": [ "Findings", "EarliestOwner", "Invalidate + Rerun", "Repaired|Blocked" ], "productions": [ { "lhs": "RepairStage", "rhs": " \"→\" \"→\" \"→\" \"→\" " }, {"lhs": "RepairTermination", "rhs": "\"status_pass_to_rendering\" | \"cycle_exceeds_max_blocked\""} ], "composes": [ "severity-failure-routing", "bounded-repair-loop" ], "force": [ "resilience_recovery", "control_coordination", "correctness_verification" ] }, { "id": "bounded-repair-loop", "stage": "verify", "axis": "verification", "mathType": "dynamical-systems", "yields": "boolean | counter", "title": "Bounded Repair Loop", "exemplar": { "before": "Repair loops unbounded, re-deriving forever on an unfixable finding.", "after": "repair-required → cycle guard → invalidate + regenerate downstream → exceeding max_cycles terminates as blocked with the remaining findings", "lang": "flow", "medium": "composite" }, "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": [ "RepairRequired", "CycleGuard", "InvalidateAndRegenerate", "Pass|Blocked" ], "productions": [ { "lhs": "BoundedRepairLoop", "rhs": " \"→\" \"→\" \",\" \"→\" " }, {"lhs": "BoundedTermination", "rhs": "\"repaired_pass\" | \"repair_limit_exceeded_blocked\""} ], "composes": [], "force": [ "resilience_recovery", "control_coordination" ] }, { "id": "severity-failure-routing", "stage": "verify", "axis": "verification", "mathType": "optimization", "yields": "boolean | ranking", "grounds": ["reasoning:tel-priority"], "title": "Severity Failure Routing", "exemplar": { "before": "Every finding blocks the same way, regardless of severity.", "after": "finding → severity → route{blocker → block+repair; error → repair; warning → disposition; lower → investigate} → severity routes failure, never phase order", "lang": "flow", "medium": "composite" }, "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": [ "Finding", "Severity", "RepairRoute" ], "productions": [ {"lhs": "SeverityFailureRouting", "rhs": " \"→\" \"→\" "}, { "lhs": "RepairRoute", "rhs": "\"block_and_repair\" | \"repair\" | \"disposition_required\" | \"investigate\"" } ], "composes": [], "force": [ "resilience_recovery", "control_coordination" ] }, { "id": "rendering-stage", "stage": "commit", "axis": "representation", "mathType": "information-theory", "yields": "hash | novelty-score", "title": "Rendering Stage", "exemplar": { "before": "Rendering invents a new architecture decision and pre-checks future execution boxes.", "after": "validated records | blocked report → deterministic render → exactly one terminal{success artifact | blocked report}; future execution checkboxes left unchecked", "lang": "flow", "medium": "composite" }, "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": [ "ValidatedRecords|BlockedReport", "DeterministicRender", "SuccessArtifact|BlockedArtifact" ], "productions": [ { "lhs": "RenderingStage", "rhs": " | \"→\" \"→\" " }, {"lhs": "GenerationResult", "rhs": "\"success_output_file\" | \"blocked_output_file\""} ], "composes": [ "checklist-output-rendering", "explicit-termination" ], "force": [ "correctness_verification", "control_coordination", "architecture_evolution" ] }, { "id": "checklist-output-rendering", "stage": "commit", "axis": "representation", "mathType": "information-theory", "yields": "hash | novelty-score", "title": "Checklist Output Rendering", "exemplar": { "before": "The checklist drops ripple impacts to counts and renders inactive principles as mandatory.", "after": "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)", "lang": "flow", "medium": "composite" }, "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": [ "Context + Phases + Graphs + Ripples + Gates", "ChecklistMarkdown" ], "productions": [ { "lhs": "ChecklistOutputRendering", "rhs": " \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" " }, { "lhs": "AppendixSet", "rhs": "\"file_organization\" \",\" \"evidence_inventory\" \",\" \"registry_contract_enforcement_changes\"" } ], "composes": [], "force": [ "correctness_verification", "observability_traceability", "architecture_evolution" ] }, { "id": "explicit-termination", "stage": "terminate", "axis": "termination", "mathType": "set-theory", "yields": "set | boolean", "grounds": ["reasoning:ter-stop"], "title": "Explicit Termination", "exemplar": { "before": "The generator stops while the status is still repairable, or loops past its bound.", "after": "validation status → terminal selection{write success artifact | write blocked report} → render-integrity check → exactly one written artifact, no premature stop, no unbounded loop", "lang": "flow", "medium": "composite" }, "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": [ "ValidationStatus", "TerminalSelection", "WrittenArtifact" ], "productions": [ { "lhs": "ExplicitTermination", "rhs": " \"→\" \"→\" \"→\" " }, {"lhs": "TerminalSelection", "rhs": "\"write_success_artifact\" | \"write_blocked_report\""} ], "composes": [], "force": [ "resilience_recovery", "control_coordination", "correctness_verification" ] }, { "id": "cross-stage-invariants", "title": "Cross-Stage Invariants", "exemplar": { "before": "Each stage guards its own rules; a global always/never guarantee is nowhere enforced.", "after": "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}", "lang": "flow", "medium": "composite" }, "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": [ "EveryStage", "AlwaysRules + NeverRules", "BoundGenerator" ], "productions": [ { "lhs": "CrossStageInvariants", "rhs": " \",\" \"→\" " }, { "lhs": "InvariantClass", "rhs": "\"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": [], "force": [ "model_governance", "correctness_verification", "architecture_evolution", "control_coordination" ], "meta": true }, { "id": "checklist-creation-kernel", "principleRef": "directed-acyclic-graph", "grounds": ["reasoning:derivation-loop"], "mathType": "computation", "yields": "procedure", "derivationMap": [ {"stage": "orient", "record": "orientation-stage"}, {"stage": "intent", "record": "teleological-intent-gate"}, {"stage": "derive", "record": "planning-stage"}, {"stage": "project", "record": "phase-decomposition"}, {"stage": "act", "record": "compilation-stage"}, {"stage": "constrain", "record": "admissibility-constraint-stage"}, {"stage": "verify", "record": "validation-stage"}, {"stage": "commit", "record": "rendering-stage"}, {"stage": "terminate", "record": "explicit-termination"} ], "title": "Checklist Creation Kernel", "exemplar": { "before": "A task compiled straight into a flat checklist, ungated and unordered.", "after": "orientation → planning → compilation → validation → repair → rendering, bound by cross-stage invariants → a validated dependency-ordered checklist or an evidence-bearing blocked report", "lang": "flow", "medium": "composite" }, "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": [ "Orientation", "Planning", "Compilation", "Validation", "Repair", "Rendering" ], "productions": [ { "lhs": "ChecklistCreationKernel", "rhs": " \"→\" \"→\" \"→\" \"→\" \"→\" " } ], "composes": [ "orientation-stage", "teleological-intent-gate", "planning-stage", "compilation-stage", "admissibility-constraint-stage", "validation-stage", "repair-stage", "rendering-stage", "cross-stage-invariants" ], "force": [ "runtime_extensibility", "correctness_verification", "security_governance", "architecture_evolution", "control_coordination" ] }, { "id": "checklist-governance-concern", "title": "", "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": [ "Authority", "Evidence", "Principles", "Phases", "Graph", "Ripples", "Validation", "Repair", "Terminal" ], "productions": [ { "lhs": "ChecklistGovernanceConcern", "rhs": " \"→\" \"→\" \"→\" \"→\" \"→\" " }, { "lhs": "CompletionCondition", "rhs": "\"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": [], "force": [ "runtime_extensibility", "correctness_verification", "security_governance", "architecture_evolution", "model_governance" ], "meta": true } ] }