Count what the boundary record grounds from the blocks, rather than in the line that prints the bound

[iderex]

The issue this belongs to

Closes #432

What changed

The invariants run prints, beside every verdict, that the boundary itself is not
read "although three rules above are grounded in the record that draws it". That
clause counted the rules the boundary record grounds and the register holds four.
The count is deleted rather than corrected, because the run already prints each
block's grounds line in its own first section, and the sentence now says what it
was about: three of the rules above hold a list of what has been named.

docs/gate-parity.md carried the same count in the opengrep.yml row, in a clause
that landed one commit ago as "the three grounded in 0003". It names the three that
hold such a list now, and records what it said.

No block changes. No rule, pattern, path, subject or fixture is touched.

What failure it prevents

A reader sizing a green run from the accounting line, and taking from it a count of
which rules rest on the boundary record that has never agreed with the register it
counts. The line is the bound satisfied is worth in the parity register: the
rules hold names rather than purposes, so a green run is not a run that found the
boundary uncrossed. That bound is unchanged. What was wrong beside it is a number
that was wrong on its first run and printed with every verdict after it - the shape
.github/targets/targets already records of itself in its own header, arriving in
the accounting line rather than in a reason.

It was found by reading the run's own output against the grounds fields of the
blocks the same run prints.

Evidence

Read at the commit being pushed, b0d86ec567b695c2c5ce3bab4d3496b78dfe6291, except
where a command names another.

The count, against the register

git show d24800225f8e009f7596c39e32005682cc04cb41:.github/invariants/invariants.sh | sed -n '328p'
  echo "NOT MADE HERE: that boundary itself, although three rules above are grounded in the record that draws it. Each holds a list of what has been named - a set of dependency names, a set of view words, one trait - so a crossing written in a name nobody listed walks past all three, and a green run here is not a run that found the boundary uncrossed."

git show origin/main:.github/invariants/rules | awk '/^id: /{id=$2} /^grounds: /{print id"  "$2}' | grep '0003-what-the-core-does-not-do.md'
no-text-output  docs/decisions/0003-what-the-core-does-not-do.md
no-user-interface-dependency  docs/decisions/0003-what-the-core-does-not-do.md
no-view-vocabulary  docs/decisions/0003-what-the-core-does-not-do.md
no-sentence-for-a-person  docs/decisions/0003-what-the-core-does-not-do.md

Four. The fourth is no-text-output, which holds no list of names, so the count
and the sentence after it are about two different sets.

It was four on the day the line landed

git log origin/main --format='%h %ad %s' --date=short -S'three rules above are grounded' -- .github/invariants/invariants.sh
f718593 2026-08-26 Refuse the three boundary crossings that can be written down (#77) (#198)
git show f718593:.github/invariants/rules | awk '/^id: /{id=$2} /^grounds: /{print id"  "$2}' | grep -c '0003-what-the-core-does-not-do.md'
4

git log origin/main --format='%h %ad %s' --date=short -S'no-text-output' -- .github/invariants/rules | tail -1
ecc9a6f 2026-08-25 Refuse the mistakes a compiler cannot see (#82) (#192)

What the run prints now

bash .github/invariants/invariants.sh check | sed -n '/what this run did not read/,$p' | sed -n '3p'
NOT MADE HERE: that boundary itself. Three of the rules above hold a list of what has been named - a set of dependency names, a set of view words, one trait - so a crossing written in a name nobody listed walks past all three, and a green run here is not a run that found the boundary uncrossed. Which rules the record that draws the boundary grounds is on those blocks rather than counted here.

The legs run here

bash .github/invariants/invariants.sh check | tail -1
Every rule above was applied to its subject and refused nothing.
bash .github/doc-paths/doc-paths.sh check | tail -1
Every path these documents name resolves against the tracked set.

Both exited 0.

cargo build --locked --all-targets ; echo "exit=$?"
exit=0
cargo test --locked ; echo "exit=$?"
exit=0

git diff --stat origin/main...HEAD
 .github/invariants/invariants.sh | 12 +++++++++++-
 docs/gate-parity.md              |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

What a guard here refuses, and the proof it bites

Nothing here adds or edits a guard. The change is to a printed accounting line and
to a comment above it. Every rule block, pattern, path, subject and fixture is
byte-identical, which is what the diff above shows: the only file under
.github/invariants/ that changes is the loader, and the change is inside the
section that runs after the verdict.

What this does not cover

• .github/shell-analysis/shell-analysis.sh was NOT run on this machine.
  shellcheck is not installed here and the script reports that rather than
  passing. The leg on the gate is what judges this change's shell, and no local run
  stands in for it.
• Which rules hold a list of names. CONTRIBUTING.md says five and the
  register's own header names three of them by id. Both read correctly against the
  blocks and neither is re-opened.
• Whether no-text-output belongs among the name-list rules. Its pattern is a
  set of macro names somebody wrote down, and this tree's own reading puts it
  outside that family. The subject here is a count of what the record grounds,
  which is a different field.
• Any block in the register. No rule, pattern, path, subject or fixture is
  touched, and the set the run judges is what it was.
• A check that would refuse the next one. Nothing in this tree compares a
  number typed into a printed line against the register it counts, and this adds no
  rule.
• The eight rows of the parity register carrying the waiting verdict. The row
  touched here reads satisfied, and the decision Eight parity rows wait on a register that closed with every entry answered #377 holds is not reached.
• The coverage, mutation and cross-toolchain legs. None was run here.

Who has read it

Nobody other than the author has read this change. There is no second reader on
this board tonight, and the evidence above stands in place of one: the defect was
found by running the check and reading its output against the register it counts,
and the repair is readable in the same output.