# configuration/grammar/data/template.checklist.data.json > 109 lines of code and 0 definitions. Tree: GovLab Context Language: json Layer: domain Canonical: https://banes-lab.com/anatomy/context#file-context-configuration-grammar-data-template-checklist-data-json Source text: https://banes-lab.com/source/context/configuration/grammar/data/template.checklist.data.json.txt Listed in [configuration/grammar/data](https://banes-lab.com/api/source/context/configuration/grammar/data.md), after [configuration/grammar/data/template.audit.data.json](https://banes-lab.com/source/context/configuration/grammar/data/template.audit.data.json.md) and before [configuration/grammar/data/template.composition.data.json](https://banes-lab.com/source/context/configuration/grammar/data/template.composition.data.json.md). ## Contained in - [configuration/grammar/data](https://banes-lab.com/anatomy/context/folder-context-configuration-grammar-data.md) ## Source ```json { "copyright": "PAG (Pattern Abstract Grammar) © Bane's Lab, CC BY-SA 4.0. Used with the author's explicit permission; attribution must be preserved. See ../../../LICENSE.", "check": { "by": [ "the template round-trip check, which fills the template and validates the result against the grammar", "the slot check, which requires every declared slot to appear in the body and every slot in the body to be declared" ], "population": "this template's body and slots, and every document created from it", "freshness": "a verdict stands until the template, its document type or the grammar changes", "refusal": "the gate fails on a dangling slot, an unregistered type, or a filled template that does not validate", "observation": "none: a template is static text, and nothing observes it while a run executes", "evidence": "fires-and-accepts: one suite plants a slot the body never carries and a template of an unregistered type, another plants a retired head in a real template, and every filled template validates clean", "authority": "the template's document type and the grammar, which every document created from the template conforms to" }, "type": "CHECKLIST", "title": "Checklist Meta-Template (ten-node evidence-bearing generator)", "slots": [ { "name": "project.governance_policy", "description": "host governance policy doc (always read)", "required": true, "kind": "string" }, { "name": "project.principle_ontology", "description": "host principle ontology — the authoritative principle catalog to resolve the full set from", "required": true, "kind": "string" }, { "name": "project.architecture_rules", "description": "host architecture rules doc (read for algorithm/protocol/pattern/decomposition/principle/contract tasks)", "required": true, "kind": "string" }, { "name": "project.design_guide", "description": "host design guide (read for style/token/layout/surface/ui tasks)", "required": false, "kind": "string" }, { "name": "project.component_docs", "description": "host component docs (read for component/module/element/render/boundary tasks)", "required": false, "kind": "string" }, { "name": "registry", "description": "the codebase's discovery/resolution registry", "required": false, "kind": "string" }, {"name": "logger", "description": "the codebase's structured logger", "required": false, "kind": "string"}, {"name": "limits.max_lines", "description": "per-unit line budget", "required": false, "kind": "string"}, {"name": "limits.max_files", "description": "per-concern file budget", "required": false, "kind": "string"}, { "name": "toolchain.build.execute", "description": "the blocking build command", "required": true, "kind": "string" }, {"name": "verify_cmd", "description": "the blocking verify command", "required": true, "kind": "string"}, {"name": "task_description", "description": "the raw task text", "required": true, "kind": "string"}, { "name": "task_name", "description": "kebab-case name for the output file", "required": true, "kind": "string" } ], "constraints": [ "declaration_required", "gate_per_node", "contract_reads_prior_output", "population_declared", "refusal_before_write", "invariant_has_objector", "evidence_grounded", "observe_before_plan", "prior_knowledge_untrusted", "worth_before_work", "principle_activation_bound_to_validator", "semantic_protocol_selection", "genesis_orders_phases", "four_d_graph_z_x_y_w", "ripple_chains_named", "unknown_is_not_pass", "bounded_repair_from_earliest_node", "deterministic_render", "generation_vs_execution_gates_separate" ], "body": "---\nname: {task_name}\ntype: CHECKLIST\nversion: 1.0.0\n---\n\nTHIS CHECKLIST GENERATES a dependency-ordered, evidence-bearing implementation checklist whose framing, worth, seeing, derivation, projection, formalization, admissibility, verification, commitment and termination are each produced and gated by the node that owns that decision.\n\n%% META %%:\n priority: {project.governance_policy} > {project.principle_ontology} > this template > {project.architecture_rules} > {task_description}\n trust: tool_output = TRUSTED, prior_knowledge = UNTRUSTED\n objective: {task_description}\n jurisdiction: {task_description} and the tree the governing documents declare | external: every surface the governing documents do not name\n recursion_limit: 3\n\n# NODE 1 — ORIENT [epistemic · ontology · set-theory · yields: entity-set + evidence]\n@purpose: \"establish authority, trust and current-system evidence by framing the task through the ontological dimensions\"\n@axis_question: \"What is it?\"\n@genesis: existence\n@cue: \"OBSERVE_BEFORE_PLAN\"\nCONTRACT:\n input: {task_description}\n transform: READ_RESOURCE {project.governance_policy} INTO policy; READ_RESOURCE {project.principle_ontology} INTO ontology; DISCOVER_RESOURCES INTO discovered; EXTRACT_FACTS change_relation FROM {task_description} INTO change\n constraints: {project.architecture_rules} is read on an algorithm, protocol, pattern, decomposition, principle or contract task; {project.design_guide} on a style, token, layout, surface or ui task; {project.component_docs} on a component, module, element, render or boundary task; a dimension is walked only when relevant\n output: context_bundle\nDECLARE context_bundle: object\nSET context_bundle = {intent: change.requested_outcome, change_relation: change.change_relation, dimensions: , sources: [policy, ontology], discovered: discovered, evidence: , unresolved: change.ambiguity}\nHANDOFF GATE (evidence-bearing):\n rule_id: \"ORIENT\" yields: boolean\n [check] core authority loaded (evidence: context_bundle.sources) over: the governing documents measured: / \n [check] change_relation resolved (evidence: change.change_relation is not unknown)\n [check] every always-relevant dimension has a readout and the evidence inventory is non-empty (evidence: context_bundle.evidence)\n result: pass → NODE 2 | missing authority → REPAIR (owner: NODE 1) | unknown → BLOCKED\n\n# NODE 2 — INTENT [conative · teleology · optimization · yields: objective + branch-ranking]\n@purpose: \"resolve what the work is for, enumerate admissible branches, and gate on the highest-worth one before any seeing\"\n@axis_question: \"What is it for?\" @mandatory\n@genesis: difference\n@cue: \"WORTH_BEFORE_WORK\"\nCONTRACT:\n input: context_bundle from NODE 1\n transform: ANALYZE_CONTENT context_bundle FOR candidate branches INTO branches; FOR EACH branch IN branches: CALCULATE_METRIC utility minus cost FROM branch INTO branch.worth; RANK branches BY worth\n constraints: a branch is admissible only when it satisfies the change_relation and the hard constraints; the selected branch is the highest-worth admissible one\n output: teleology_bundle\nDECLARE teleology_bundle: object\nSET teleology_bundle = {objective: context_bundle.intent, branches: branches, selected: }\nHANDOFF GATE (tel-priority injection-gate):\n rule_id: \"INTENT\" yields: boolean over ranking\n [check] objective stated (evidence: teleology_bundle.objective)\n [check] an admissible branch exists (evidence: branches with admissible true) over: branches measured: / \n [check] selected is the argmax of utility minus cost (evidence: the ranking's first entry)\n result: pass → NODE 3 | no admissible branch → REPAIR (owner: NODE 1) | selected is not argmax → REPAIR (owner: NODE 2) | unknown → BLOCKED\n\n# NODE 3 — SEE [epistemic · analysis · graph · yields: lens-set + analytic edges]\n@purpose: \"select the analytical lenses relevant to the selected branch and read the system through them\"\n@axis_question: \"How is it to be seen?\"\n@genesis: relation\n@cue: \"SELECT_LENSES_BEFORE_DERIVING\"\nCONTRACT:\n input: teleology_bundle from NODE 2\n transform: ANALYZE_CONTENT context_bundle.discovered AGAINST INTO observations; EXTRACT_FACTS relational edges FROM observations INTO relational_edges\n output: analysis_bundle\nDECLARE analysis_bundle: object\nSET analysis_bundle = {lenses: , observations: observations, relational_edges: relational_edges}\nHANDOFF GATE (evidence-bearing):\n rule_id: \"SEE\" yields: edge-list + boolean\n [check] every active lens has an observation (evidence: observations) over: analysis_bundle.lenses measured: / \n [check] relational edges present where dependencies were discovered (evidence: relational_edges against discovered registrations)\n [check] no observation is inferred from a name alone (evidence: every observation cites a read)\n result: pass → NODE 4 | gap → REPAIR (owner: NODE 3) | unknown → BLOCKED\n\n# NODE 4 — DERIVE [epistemic · reasoning · logic · yields: principle and protocol truths]\n@purpose: \"activate the principles that govern the seen decision surfaces and select protocols by semantic fit\"\n@axis_question: \"Why, and what follows?\"\n@genesis: relation\n@cue: \"DERIVE_FROM_EVIDENCE\"\nCONTRACT:\n input: analysis_bundle from NODE 3\n transform: FOR EACH principle IN {project.principle_ontology}: ANALYZE_CONTENT analysis_bundle.observations AGAINST principle.activate_when INTO fit; APPEND {principle, fit, validator} TO active_principles; ANALYZE_CONTENT teleology_bundle.selected AGAINST INTO selected_protocols\n constraints: every active principle binds a decision test and a validator; a protocol is selected by semantic fit, never by a trigger word; the verification protocol is always present\n output: derivation_bundle\nDECLARE derivation_bundle: object\nSET derivation_bundle = {active_principles: active_principles, selected_protocols: selected_protocols}\nHANDOFF GATE (evidence-bearing):\n rule_id: \"DERIVE\" yields: boolean\n [check] every active mandatory principle binds a validator (evidence: active_principles) over: active_principles measured: / \n [check] every selected protocol carries a semantic reason (evidence: selected_protocols.reason)\n [check] the verification protocol is present (evidence: selected_protocols)\n result: pass → NODE 5 | gap → REPAIR (owner: NODE 4) | unknown → BLOCKED\n\n# NODE 5 — PROJECT [epistemic · reasoning · logic · yields: 4D graph edge-list]\n@purpose: \"decompose into phases whose order is the substrate genesis of the artifacts, and project the dependency and ripple graph\"\n@axis_question: \"What follows downstream?\"\n@genesis: structure\n@cue: \"DECOMPOSE_AS_GENESIS\"\nCONTRACT:\n input: derivation_bundle from NODE 4\n transform: FOR EACH protocol IN derivation_bundle.selected_protocols: COMPOSE_ARTIFACT phase FROM protocol USING ; APPEND phase TO phases; COMPOSE_ARTIFACT graph FROM phases USING ; ORDER phases BY topological Z then genesis rank\n constraints: a phase never depends on a later-genesis output than it produces; severity is metadata that routes failure, never an ordering axis; an empty W carries the evidence it was assessed\n preserves: every relational edge from NODE 3\n output: phase_records\nDECLARE phase_records: array\nSET phase_records = \nHANDOFF GATE (evidence-bearing):\n rule_id: \"PROJECT\" yields: edge-list + boolean\n [check] the Z graph is acyclic and genesis-consistent (evidence: zero cycles, zero inversions) over: phase_records measured: / \n [check] every phase declares inputs, outputs, a genesis stage and all four axes (evidence: phase_records)\n [check] order is dependency-topological then genesis with severity as metadata only (evidence: no severity grouping)\n result: pass → NODE 6 | cycle or inversion → REPAIR (owner: NODE 5) | unknown → BLOCKED\n\n# NODE 6 — ACT [epistemic · formalization · computation · yields: task procedures]\n@purpose: \"formalize phases into atomic, target-specific tasks under binding execution constraints, with full ripple chains\"\n@axis_question: \"What does it resolve to?\"\n@genesis: transformation\n@cue: \"FORMALIZE_EXECUTABLE_TASKS\"\nCONTRACT:\n input: phase_records from NODE 5\n transform: FOR EACH phase IN phase_records: COMPOSE_ARTIFACT tasks FROM phase USING ; FOR EACH task IN tasks: ANALYZE_CONTENT task FOR INTO task.ripple; APPEND task TO task_records\n constraints: the host's patterns bind every step, dependency through {registry}, observability through {logger}, size within {limits.max_lines} and {limits.max_files}; a build or verify task runs {toolchain.build.execute} or {verify_cmd} as a blocking step; a ripple names entities, never counts\n output: task_records\nDECLARE task_records: array\nSET task_records = \nHANDOFF GATE (evidence-bearing):\n rule_id: \"ACT\" yields: procedure + set-cardinality\n [check] at least one task per phase (evidence: task_records against phase_records) over: phase_records measured: / \n [check] every task is atomic and target-specific with an evidence contract (evidence: expected evidence per task)\n [check] every task carries every ripple dimension with names (evidence: task.ripple)\n result: pass → NODE 7 | non-atomic or missing ripple → REPAIR (owner: NODE 6) | unknown → BLOCKED\n\n# NODE 7 — CONSTRAIN [conative · teleology · optimization · yields: admissibility boolean]\n@purpose: \"gate the formalized plan on admissibility before verification: still worth executing, still on the selected branch, within the hard limits\"\n@axis_question: \"Is it still worth it, and is it allowed?\" @mandatory\n@genesis: constraint\n@cue: \"ADMISSIBLE_BEFORE_VERIFY\"\nCONTRACT:\n input: task_records from NODE 6\n transform: CALCULATE_METRIC realized cost FROM task_records INTO realized_cost; FOR EACH task IN task_records: ANALYZE_CONTENT task AGAINST teleology_bundle.selected INTO trace; COMPARE realized_cost AGAINST teleology_bundle.selected.cost\n output: admissibility\nDECLARE admissibility: object\nSET admissibility = {ok: , realized_cost: realized_cost, off_branch: , limit_breaches: }\nHANDOFF GATE (teleology admissibility gate):\n rule_id: \"CONSTRAIN\" yields: boolean\n [check] realized cost within the branch budget (evidence: realized_cost against the budget)\n [check] every task traces to the selected branch (evidence: admissibility.off_branch empty) over: task_records measured: / \n [check] no hard limit breached (evidence: admissibility.limit_breaches empty)\n result: pass → NODE 8 | cost over budget or off branch → REPAIR (owner: NODE 2) | limit breach → REPAIR (owner: NODE 6) | unknown → BLOCKED\n\n# NODE 8 — VERIFY [evaluative · verification · logic + probability · yields: validation report]\n@purpose: \"judge the generated reasoning against evidence, falsification, confidence and semantic policy before commitment\"\n@axis_question: \"Is it real?\" @mandatory\n@genesis: constraint\n@cue: \"VERIFY_REASONING_NOT_IMPLEMENTATION\"\nCONTRACT:\n input: admissibility from NODE 7\n transform: EXTRACT_FACTS material claims FROM {phase_records, task_records} INTO claims; FOR EACH claim IN claims: SEARCH_CONTENT context_bundle.evidence FOR claim.support INTO support; VALIDATE_ARTIFACT {phase_records, task_records} AGAINST INTO findings\n constraints: a claim is supported only with evidence, never by the absence of a contradiction; confidence is a number tested against a threshold; policy is semantic, never a substring ban; an unmeasured claim is unknown, and unknown is not pass\n output: validation_report\nDECLARE validation_report: object\nSET validation_report = {status: , findings: findings, confidence: , examined: context_bundle.evidence, unresolved: context_bundle.unresolved}\nHANDOFF GATE (ver-stop gate):\n rule_id: \"VERIFY\" yields: boolean\n [check] every finding names what it examined (evidence: findings carry evidence and a rule id)\n [check] every material claim has non-empty evidence and a named refuter (evidence: claims) over: claims measured: / \n [check] confidence is at or above the threshold (evidence: validation_report.confidence)\n [check] status is pass with zero blocking findings (evidence: validation_report.findings)\n standing: moved-set \n result: pass → NODE 9 | repair_required → REPAIR (owner: ) | unknown → BLOCKED\n\n# REPAIR EDGE (verify refutes back to the earliest invalid node, bounded by the recursion limit)\nCONTRACT:\n input: validation_report.findings, or a failed admissibility\n transform: FOR EACH finding IN findings: ORDER finding BY ; \n constraints: bounded by recursion_limit; severity orders the repairs among failures and never softens a verdict; a downstream record is never restored after an upstream repair\n output: repaired records at pass, or a blocked terminal with the remaining findings\n\n# NODE 9 — COMMIT [evaluative · representation · information-theory · yields: rendered artifact]\n@purpose: \"serialize only validated records into the one canonical representation, deduplicated, adding no new decision\"\n@axis_question: \"How is it encoded?\"\n@genesis: emergence\n@cue: \"COMMIT_WITHOUT_NEW_DECISIONS\"\nCONTRACT:\n input: validation_report from NODE 8\n transform: COMPOSE_ARTIFACT rendered FROM {context_bundle, teleology_bundle, phase_records, task_records, validation_report} USING ; REDUCE rendered TO \n constraints: rendering adds no architecture decision; identical content collapses to one representation; a future execution checkbox stays unchecked; every phase carries its genesis stage and its four axes\n preserves: every ripple impact by name\n output: rendered\n freshness: fingerprint(validation_report) + fingerprint(this document)\nHANDOFF GATE (evidence-bearing):\n rule_id: \"COMMIT\" yields: hash + boolean\n [check] no phase or task encoded twice (evidence: the deduplication pass) over: phase_records and task_records measured: / \n [check] no future execution checkbox pre-checked (evidence: a render scan)\n [check] no architecture decision introduced at render (evidence: the rendering rules)\n result: pass → NODE 10 | integrity defect → REPAIR (owner: NODE 9) | unknown → BLOCKED\n\n# NODE 10 — TERMINATE [evaluative · termination · set-theory · yields: artifact]\n@purpose: \"stop only on saturation and completion and verification; otherwise block on external input, never a self-assessed stop\"\n@axis_question: \"Is it done?\" @mandatory\n@genesis: emergence\n@cue: \"TERMINATE_EXPLICITLY\"\nCONTRACT:\n input: rendered from NODE 9\n transform: VALIDATE_ARTIFACT rendered AGAINST INTO render_check; PERSIST_ARTIFACT rendered TO <{task_name} checklist>; REPORT_RESULT generation_result TO \n constraints: exactly one terminal, success or blocked; ter-block routes to REQUEST_DECISION; a self-assessed done is not ter-stop\n output: generation_result\n freshness: fingerprint(rendered) + fingerprint(this document)\nHANDOFF GATE (ter-stop gate):\n rule_id: \"TERMINATE\" yields: boolean\n [check] status is success or blocked and an output file is named (evidence: generation_result)\n [check] success only when saturation and completion and verification all hold (evidence: the termination set) over: the termination set measured: / \n [check] repair cycles within recursion_limit (evidence: the repair count)\n [check] no future execution checkbox pre-checked (evidence: render_check)\n refuse: the destination changed since it was read before PERSIST_ARTIFACT\n standing: moved-set \n result: pass → TERMINATE | integrity defect → REPAIR (owner: NODE 9) | unknown → BLOCKED\n\n# CROSS-NODE INVARIANTS\nINVARIANT ontology-before-teleology: authority, trust and the ontology of the change are resolved before its teleology, and both before any seeing over: every generation binds: the generator objector: [check] core authority loaded at NODE 1\nINVARIANT four-gates-always: the worth, admissibility, evidence and termination gates run on every generation over: every generation binds: the generator objector: [check] status is success or blocked at NODE 10\nINVARIANT typed-decisions: every decision resolves to its declared shape, a ranking never satisfied by a boolean over: every node binds: the generator objector: [check] selected is the argmax at NODE 2\nINVARIANT genesis-order: a phase never depends on a later-genesis output than it produces over: phase_records binds: the generator objector: [check] the Z graph is acyclic and genesis-consistent at NODE 5\nINVARIANT prior-output-only: a node reads only the prior node's output contract over: every node binds: the generator objector: [check] input names NODE n-1 or a declared variable\nINVARIANT evidence-not-absence: a claim is supported only with evidence, never by the absence of a contradiction, and unknown is not pass over: every claim binds: the generator objector: [check] every material claim has non-empty evidence at NODE 8\nINVARIANT repair-from-earliest: a failed gate repairs from the earliest owning node and never restores a downstream record over: every repair binds: the generator objector: [check] repair cycles within recursion_limit at NODE 10\nINVARIANT generation-not-execution: a gate resolved while generating is separate from a gate that runs when the checklist is executed, and the latter ships unchecked over: every rendered gate binds: the generator objector: [check] no future execution checkbox pre-checked at NODE 10\n\nREPORT:\n subject: NODE 10\n verdict: pass | fail | unknown\n domain: declared measured \n populations: phases , tasks , claims supported , claims unknown \n inputs: {task_description} , {project.governance_policy} , {project.principle_ontology} \n code: this document \n output: {task_name} checklist \n refusals: []\n unresolved: []\n completion: saturated complete verified \n" } ```