# configuration/strings/tracking.strings.ts

> 54 lines of code and 5 definitions.

Tree: Site tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/tree#file-configuration-strings-tracking-strings-ts
Source text: https://banes-lab.com/assets/sources/source.23060db04e63eae7329da861ceac10e904a8e0aabe84476ac01364586053f053.generated.txt

## Definitions

- `GENERATOR_SAMPLE` (lexical_declaration, line 7)
- `CHECKLIST_TEMPLATE` (lexical_declaration, line 9)
- `REPORT_TEMPLATE` (lexical_declaration, line 12)
- `STAGE_DIAGRAM` (lexical_declaration, line 15)
- `TRACKING_SECTION` (lexical_declaration, line 18, exported)

## Source

```typescript
import { MARKDOWN_LANGUAGE, PAG_LANGUAGE } from "#configuration/constants/code.constants";
import type { Section } from "#types/document.types";
import { TRACKING_SECTION_ICON } from "#configuration/icons/grammar.icons";
import { TRACKING_SECTION_ID } from "#core/ids/grammar.ids";
import { templateBodyOf } from "#core/converters/grammar.converter";

const GENERATOR_SAMPLE = templateBodyOf("CHECKLIST");

const CHECKLIST_TEMPLATE =
    "# <the rendered checklist · what the generator emits, every box unchecked>\n\n## Worth\nObjective: <the outcome, named so the result can be checked against it>\nNot in scope: <the nearest things this change will not do>\nBranches ranked: <the way chosen, and why the others lost>\n\n## Admissible\nHard limits: <what no node may cross>\nCost: <what this is allowed to take, and the point past which it stops>\n\n## PHASE 1 — <name>                   [genesis: <stage> · severity: <routes the repair>]\nReads: nothing.\nRipple: <what this phase's output reaches, by name>\nGate: <the evidence PHASE 2 reads before it starts, over what set>\n- [ ] 1.1 <one change> · file: <where> · evidence: <what proves it> · verifier: <who reads it> · not: <what this task leaves alone>\n\n## PHASE 2 — <name>                   [genesis: <stage> · severity: <routes the repair>]\nReads: the output of PHASE 1.\nRipple: <what this phase's output reaches, by name>\nGate: <the evidence PHASE 3 reads, over what set>\n- [ ] 2.1 <one change> · file: <where> · evidence: <what proves it> · verifier: <who reads it> · not: <what this task leaves alone>\n\n## Termination\nThe run stops when the objective sentence reads true against the tree, not when the boxes are ticked.";

const REPORT_TEMPLATE =
    "# a verification report · a verdict with its standing, its domain and its reach\nsubject:   <the run>\nverdict:   <pass | fail | unknown>\nstanding:  <authoritative | withdrawn>      # withdrawn where a read surface moved beneath the run\ndomain:    declared <N> measured <n>         # what the run claimed to cover, and what it reached\nreached:   [<every surface the run read>]\nmoved:     [<surfaces that changed mid-run, if any>]\nrefusals:  <n> [<why the run declined to continue, if it did>]\nunresolved: <n> [<what stays open>]\n\n## NODE 1 — <name>\n### Gate: <what it checks>\n- status:   <pass | fail | unknown>\n- evidence: <file and locus, for every check>\n- over:     <the set the check ranged over, n of N>\n- failure:  <which check, what was found · only on fail>\n- owner:    <the node or party that owns the repair · only on fail>";

const STAGE_DIAGRAM =
    'flowchart TB\n    orient["Orient · observe before plan"]\n    intent["Intent · worth before work"]\n    see["See · the lenses, the relational edges"]\n    derive["Derive · principles and protocols by fit"]\n    project["Project · phases in genesis order, the four axes"]\n    act["Act · atomic tasks with evidence contracts and named ripple"]\n    constrain["Constrain · admissible, on budget, on branch"]\n    verify["Verify · the reasoning, against evidence, with its population"]\n    commit["Commit · one terminal, every box unchecked"]\n    terminate["Terminate · saturated, complete, verified"]\n    orient --> intent --> see --> derive --> project --> act --> constrain --> verify --> commit --> terminate\n    verify -. the repair edge · back to the earliest owning node, bounded .-> derive';

export const TRACKING_SECTION: Section = {
    icon: TRACKING_SECTION_ICON,
    id: TRACKING_SECTION_ID,
    intro: "This section covers the checklist template and the ten nodes of the loop that produce a checklist, each owning one kind of decision and closed by a gate, with the repair edge running between them, as shown in <cite>the ten nodes</cite>. <cite>checklist generator</cite> is the grammar's own checklist template record, and <cite>rendered checklist</cite> is the surface it emits. That surface carries what is true now and what remains, as described in derived state, and <cite>verification report</cite> is the verdict that travels with it.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, the nodes are walked in order and no node makes a decision another node owns. A task leaves the surface only once it is both done and verified, and the walk stops when the objective sentence reads true against the tree.",
                    boundary:
                        "A one-task change still walks every node, because a one-line fix can be a fix the project did not need, and orientation is what finds that out. What scales down is the size of each node's output, never the node set.",
                    cause: "A decision made by the wrong node is made without the evidence the owning node would have gathered.",
                    decision:
                        "A closed task is deleted rather than ticked, so the remaining set is the work and never a count.",
                    failureMode:
                        "A checklist says most of the units are done, two were undone by a later change, the bar still reads the same, and the next reader re-implements finished work while skipping the undone.",
                    kind: "lesson",
                    principle:
                        "For this reason a checklist is produced by owned, gated nodes, and its state is derived rather than typed.",
                    problem: "A checklist written in one sitting records the plan its author imagined.",
                    validation:
                        "To check this, name for each unit of a rendered checklist the node that decided it and the evidence that node read. A unit that cannot be traced to a node was authored, and a status marker on the surface stopped being true the first time the tree changed.",
                },
                {
                    kind: "text",
                    text: "The nodes are the derivation loop applied to a plan. Verification judges the reasoning, not the implementation, and its result line routes findings to the repair edge rather than forward, and an unknown to blocked. The commit node numbers the tasks only once the order is stable, and every phase it renders carries the genesis stage its node derived rather than a role label written beside it.",
                },
                {
                    kind: "text",
                    text: "A task's contract has five fields, and none of them is inferred. They are the change, the file, the evidence that proves it landed, the verifier that reads the evidence, and the non-goal, which lets the next reader refuse the addition that would have widened the task. A report carries the verdict with its standing, the domain it was measured over, and the reach it covered. The standing is derived in verify the verifier, and the reach is read as coverage, as described in a report, not a checkbox. A pass rate is a count no step derived, and the template has no field for one.",
                },
                { code: GENERATOR_SAMPLE, kind: "code", language: PAG_LANGUAGE, title: "checklist generator" },
                { code: CHECKLIST_TEMPLATE, kind: "code", language: MARKDOWN_LANGUAGE, title: "rendered checklist" },
                { code: REPORT_TEMPLATE, kind: "code", language: MARKDOWN_LANGUAGE, title: "verification report" },
                { caption: "the ten nodes", kind: "mermaid", text: STAGE_DIAGRAM },
            ],
            title: "Produced by nodes, derived by deletion",
        },
    ],
    title: "Planning templates",
};
```