templates/finding.template.md
templates/finding.template.md is a file in Coordination Surface. 81 lines of code and 0 definitions.
<!-- FINDING SURFACE -->
# A venue's measured half: this tree's own instances, one row per claim, carrying what observes it.
# Copy to `<subject>.finding.md` in the declared findings root. The class half lives in a model and never here.
# Model: `models/coordination.model.md`. The class decides what a row means, and this surface carries what it came to here.
═══════════════════ LIFETIME (declared, read rather than inferred) ═══════════════════
**The values are drawn from the class surface's closed sets and are not restated here as a second copy.**
Retention, mutability and removal authority each draw from the set stated there, and an unlisted value is an
approved extension to that set rather than a naming choice taken here.
**The file default:** retention `current-truth`, because a row records the state after a repair and gives way to
a newer version of itself. Mutability `owner-rewritable`, because any seat may correct a row, announced before
the edit lands. Removal authority `author`, because the party who wrote a row retires it.
**A section declares only where it differs from that default**, so the default stays one statement and the
exceptions are the whole of the cost.
| section | axis | value | why |
| ------------------------------------------ | ---------- | -------- | --------------------------------------------------------------------------------------------------- |
| this LIFETIME block and the CONTRACT block | mutability | `frozen` | written from the template and never edited in a live surface, so a correction lands in the template |
**And the observer column is why this surface is not current truth in the ordinary sense.** A row naming
`nothing` as its observer is a measurement that the tree was searched and none was found, so replacing it
silently when an observer later lands is correct while deleting it is not, because the measurement is an operand
of every count taken over this table. A row leaves by being superseded by its own newer version, never by being
pruned because it reads as negative.
═══════════════════ CONTRACT (permanent) ═══════════════════
## What decides a row, and where that decision lives
**The framework deciding a row lives in the model and is never restated here.** The fields, the reachable states,
the families of control and every rejected state are class content. One contract in two files is two copies with
nothing keeping them equal, and the copy no party re-reads is the one a reader takes. **The model says how a row
is decided, and this surface carries only what the decision came to here.**
**An adopter copies the model and never a populated finding surface.** A baseline embedded in a template makes the
next adopter inherit another project's incidents as laws, so this template ships the shape and carries no row, and
a surface raised from it is empty until its own tree is measured.
## The row grammar
**The specimen is fenced so every scanner reads it as a row mentioned rather than claimed.** A surface raised from
this template unfences its own table with the placeholders resolved, and a write form derives the column set from
the specimen below rather than transcribing it.
```text
| <mechanism> | <evidence> | <range> | <reach> | <failure mode answered> |
```
| column | what it carries | what makes it wrong |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
| `mechanism` | the construct being measured, named as a shape rather than as a file | a path or a tool name, which stops being resolvable the moment either moves |
| `evidence` | what observes it, and in which direction: a check that fires, one that fires and accepts, an absent capability, a discovery-time refusal, or `nothing` | a verdict quoted from a run, which is a cache with no invalidation |
| `range` | the population the measurement covers, named by its members' shape | a count, which answers how many and never which, so every arithmetic axis skips it in silence while the field reads as evidence |
| `reach` | the party the observation actually reaches, which is rarely the party that wrote the mechanism | the mechanism's author, which is presence standing in for delivery |
| `failure mode answered` | the shape that failed and how it presented, or the absent token `—` | an episode, a date, a party or an ordering, which is a diary entry in the form of a row |
**A count is never transcribed into a row.** Where a range is a population the pipeline derives, the row names the
population and the report on disk carries the size, because a transcribed count is a derived fact maintained by
hand, wrong from the first change no party propagated and reading as current throughout.
**The last column is the row's other half, and the absent token in it is a real answer.** A row records the state
after a repair, so without the failure it answered, a later reader sees a proven capability and cannot tell it was
operationally absent for a whole prior period, what made it reachable, or that the same absence returns the moment
a new surface copies an old template. The absent token states that the mechanism was correct as first built.
**A row states the shape that failed and never the episode**, which is the same permission a rule's own measured
clause carries: the construct and how it presented are the operand, while who, when and in what order are
archaeology this surface does not hold.
## A section that measures claims rather than mechanisms takes its own columns
**A claim is not a mechanism, so it never borrows columns that mean something else.** Where a surface records what
its parties claim beside what it observes, the two are different operands of one question and are tabled
separately. The kind is recorded per component rather than per claim, because a claim whose components denote
different sorts of thing has no single kind, and recording one erases exactly the structure the comparison is
computed from.
**A pair cell takes the value of its worst component pair and names the component that produced it**, so a pair
reads as unresolved only where a component pair genuinely is. **A set is only as comparable as its least comparable
component**, because admitting one predicate makes the question undecidable by text for every claim it is paired
against, including components that are perfectly extensional.
**`UNEVALUABLE` is a measurement and never a verdict that two things overlap.** A surface reporting either
disjointness or collision from unevaluable pairs asserts a computation no party performed.
## The value column and the reason column are two axes
**The value is drawn from a closed set and is the joinable operand, and the reason is for a reader and joins on
nothing.** A row stated as one prose cell reads as governed and is joinable by nothing, which is the construct this
surface class exists to record, arriving inside the surface recording it.
## Gate
- Every row carries every declared column, because an omitted cell states nothing where the absent token states something.
- A range naming a quantity rather than members fails, because the axis that would compare it cannot.
- A count of any set the pipeline derives fails wherever it appears in a cell.
- `nothing` in the observer position is a pass, because it is the measurement, not the absence of one.
═══════════════════ THE ROWS ═══════════════════
**A surface raised from this template carries no row until its own tree is measured.** An empty table is the
correct state of a finding surface no party has measured yet, and it can be told apart from a measured one, which is
the whole reason the section is born present and empty.
| mechanism | evidence | range | reach | failure mode answered |
| --------- | -------- | ----- | ----- | --------------------- |