Skip to content

test(608): guard the evidence-exception bound by construction - #669

Merged
BaseInfinity merged 10 commits into
mainfrom
contrib/608-evidence-exception-bound
Aug 18, 2026
Merged

test(608): guard the evidence-exception bound by construction#669
BaseInfinity merged 10 commits into
mainfrom
contrib/608-evidence-exception-bound

Conversation

@BaseInfinity

Copy link
Copy Markdown
Owner

Closes #608. Continues @webbrain-one's PR #615please credit them, not me: the single-source-of-truth design and the self-falsification requirement are theirs, their commit fa4051f is preserved as authored by them, and every commit here carries their Co-authored-by trailer.

This branch exists only because #615's head is on a fork and this work rebases it onto current main. Updating #615 in place would mean force-pushing over a contributor's branch, which I won't do. #615 stays open — closing it is the maintainer's call.

What this replaces, and why the predecessor died

The old guard matched the meaning of the evidence-exception bound with a regex over English prose. It lost three consecutive review rounds, and two of the unbounded restatements it missed were written by the alignment pass that was fixing the others. A regex over prose recognises a vocabulary, not a meaning.

The replacement decomposes the problem so each part is checkable:

Part Mechanism Why it's decidable
Detection regex (MENTION) finding where the rule is discussed is syntactic — the one part of the predecessor never defeated
Compliance reference token every detected mention must carry the token in its own sentence — token presence is syntactic
Meaning verbatim comparison the rule is stated in exactly ONE marked block in the shipped doc

Eight review rounds, and what they cost

Seat 1 (GPT-5.6 Sol) found a real, demonstrated defect in every round. Rounds 3, 4 and 5 each closed one render-capture hole and each opened another — the treadmill the guard's own header warns about. The exit was a scope decision, not a fourth patch:

A render can falsify a claim about what a check catches. It cannot falsify a decision about what the check is for.

Three limits are now stated in the file, before its capabilities:

  1. Semantic matching is out of scope. A sentence carrying the token that also misstates the rule passes. Judging whether prose means what it says is review's job; codex-gate blocks commands that only *mention* committing — it fires on prose and misses real invocations #588/PR fix(hooks): fire codex-gate on git commit in command position, not on prose (#588) #598 spent 22 rounds proving what happens to a validator that takes that on.
  2. Render capture is out of scope. A raw <section hidden> before the block is not detected. The threat model is why: anyone who can write that has commit access and could simply delete the rule. Review is the control for a committer-adversary; this guard catches accidents.
  3. No container-block modelling. Check 1b requires every fence opened before the rule to be explicitly closed in the source — deliberately stricter than CommonMark, which closes container-nested fences at their container's end.

Self-falsification

20 mutations are written to a temp tree and the real checker is re-run as a subprocess against each. A mutation that doesn't make it fail means the guard is vacuous. Each mutation declares which check must reject it, and the harness fails if a different one does — seat 1 found in round 4 that a fixture had drifted onto the wrong check while the summary still claimed otherwise.

Plus 3 must-pass fixtures, which exist because a must-fail mutation cannot detect a check that is wrong in the other direction. All three caught defects that nothing else would have:

  • a closed ```` block containing a literal ``` was being rejected (round 6: the check counted look-alike prefixes instead of tracking fence state)
  • a tab-indented literal ``` was being rejected (round 8: indent measured in characters, not columns — a tab is 4 columns)
  • a harmless closed <kbd>Ctrl</kbd> was being rejected (round 5: the deleted raw-HTML scan's overbreadth)

Verification

  • 20/20 mutations rejected, each via its declared check
  • 3/3 must-pass fixtures accepted
  • shellcheck clean
  • test-doc-consistency 137/0, test-workflow-triggers 169/0, test-cowork-drift 30/0, test-docs-usability 29/0

Merge status

Blocked on seat 1. Seat 2 (Fable) returned CERTIFIED on tree ac9162a. The seat-1 clearance leg hit the Codex usage limit mid-run and cannot re-run until Aug 19 21:00. Sol's last verdict is bound to a316146 — a tree that predates the tab-indent fix, so it does not transfer. The gate needs two distinct reviewers on the final SHA and it will get them; no clearance is being posted before then.

BaseInfinity and others added 5 commits August 17, 2026 02:20
…rify its own claim (#608)

Seat 1 falsified this repair's load-bearing claim with a render, which is what
it was asked to do.

P1 — I asserted from the GFM spec that a block surrounded by blank lines cannot
be captured by a span opened outside it. Raw HTML is not an inline span and does
cross blank lines: a raw <s> opened before the blank line renders the complete
rule under html>body>s>p>strong while the checker exits 0 with markers isolated,
blank lines intact and the body byte-identical. Enumerating <s> would repeat the
mistake, since <del>, <code>, <div hidden>, <script> and <template> retract or
hide the rule the same way. The invariant is now that NO HTML element opens
before the canonical block — verified empirically as already true, since the
only tag-shaped strings in that region are prose placeholders like <branch> and
<sha>, which are not HTML elements.

P2 — the claim "all mutations fail for their intended reason" was false. Form C
bypass #1 had drifted onto the marker-isolation check instead of the equality
check it was written for, and because it was still being caught, nothing said
so. That is the same overclaim class this PR has been enforcing on others. The
fixture is repaired, and each mutation now DECLARES which check must reject it,
with run_mutation failing if a different one does. Every fixture also asserts
its own preconditions, so it cannot degrade into a weaker test than its label.

P3 — the mutation-count diagnostic still read "expected 16 mutations".

19/19, each verified by the harness to fail via the specific check it targets.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
…608)

Seat 1 was asked to demonstrate a disputed round-2 finding rather than restate
it, and did: a cmark-gfm render in which the complete canonical rule sits inside
<del> — struck through, i.e. retracted — while the checker exits 0. It is
achieved by inlining the CLOSING marker into the following prose and opening a
`~~` span before the block. The normalised body is byte-identical, so the
equality check cannot see it. Dispute withdrawn on the evidence.

The fix is structural rather than lexical: each marker must be ALONE on its own
line, and the block must be surrounded by blank lines. GFM inline spans cannot
cross a blank line, so no inline construct opened outside the block can capture
the rule. Chasing `~~` would have been the treadmill again — an unclosed <span>
or a blockquote does the same job. A `~~`-inside-the-block check stays as cheap
belt-and-braces.

Seat 1's exact reproduction is Form E, and its fixture asserts the normalised
body is unchanged, so it keeps testing the reported hole instead of quietly
degrading into a text-changed mutation.

Round 3 also returned SHAPE: SOUND, verified the two round-2 repairs, and
accepted the measured dispute on punctuation-joined reversals, which is now a
named non-goal in the header.

18/18 mutations rejected, each for its intended reason.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
State the first-in-this-root-task evidence-exception bound once in a canonical anchor and reference it throughout the docs. Replace the prose regex guard with a drift check so unbounded restatements are prevented structurally instead of chased through English phrasing.
Adapts PR #615 by @webbrain-one. The single-source-of-truth design and the
self-falsification requirement are theirs.

- move the canonical statement into the shipped CLAUDE_CODE_SDLC_WIZARD.md;
  docs/ is not in the npm pack, so a canonical block there reaches no consumer
  install and the shipped doc would reference a nonexistent path
- keep the doc's own certified wording as canonical; the PR's snippet had
  drifted the rule from 'a later evidence-only finding is filed' to 'handed off
  for human review'
- require EVERY mention to carry the reference token in its own sentence; the
  contributed check was 'at least one' while reporting 'all', and passed a doc
  in which five of six restatements reversed the rule
- re-run the real checker as a subprocess against mutated files, instead of
  grepping a string in memory
- run all five predecessor near-misses, each in-block and each injected
  adjacent to a compliant sentence
- honor TMPDIR; wire into ci.yml and CONTRIBUTING.md

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
…quantifier

Two findings from seat 1's round-7 leg. Neither is repaired the way it was
reported, and the reasoning matters more than either fix.

P1 — the fence scanner treats a fence left unclosed inside a list item as
still open past that list item. Seat 1 is right about CommonMark: container-
nested fences close at the end of their container, so that document is valid
and was being rejected.

Resolved by REDEFINITION, not by parsing. 1b now requires every fence opened
before the rule to be EXPLICITLY CLOSED IN THE SOURCE — deliberately stricter
than CommonMark. Under that rule the list-item case is the check firing, not a
false positive, on a shape this document can simply not write. The alternative
is a container-block parser, and the alternative to that is a full markdown
implementation. Rounds 3-5 of this PR already proved a source-text checker
cannot win an argument about rendering; a claim about what the SOURCE contains
is exact and settleable. Recorded as the third stated limit.

The error message is corrected too. It said the rule "would render as a code
sample" — a render claim, and false for exactly the list-item case raised. It
now makes the source claim only.

P2 — the header still promised to keep "every honest edit reachable" while its
own stated limit says otherwise. This was the third sweep, and the two before
it each fixed the sentence seat 1 named and left the class behind. So this one
sweeps by QUANTIFIER (every|all|any|cannot|never|always) rather than by report.
Three universals were live and all three are bounded: the guard binds each
restatement IT DETECTS; "never defeated" is dated to the rounds that tested it;
and the header now states plainly that it does NOT keep every honest edit
reachable.

Seat 1's counterexample is reproduced rather than assumed — appending "Stale
evidence buys another pass." leaves the checker exiting 0, because MENTION does
not match that sentence. That is stated limit #1 working as documented, and it
stays. What changed is that the header may no longer promise past it.

No parser added. No fixtures added. Still 20 mutations and 2 must-pass
fixtures.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
BaseInfinity and others added 5 commits August 17, 2026 17:54
Seat 1's merge-clearance leg found one blocking defect, and it is mine rather
than a scope argument: the fence scanner measured indent in CHARACTERS. A tab
advances to the next 4-column tab stop, so a single leading tab is already 4
columns and its line is indented code, not a fence. Measuring characters saw
1 and treated a tab-indented literal ``` as an unclosed fence, rejecting a
valid document.

Verified all three shapes after the fix, not just the reported one:
  tab-indented literal ```      -> ACCEPT (was REJECT)
  3-space-indented open fence   -> REJECT
  unindented open fence         -> REJECT

Added as must-pass fixture #3. Indent arithmetic is exactly the kind of thing
a later edit re-simplifies, and no must-fail mutation can catch a check that
is wrong in this direction.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
…d guard (#608)

Cross-model review (gpt-5.6-sol, high) returned WRONG_SHAPE with five IN-CARD
findings, each demonstrated by running the guard against a constructed mutant.

- the canonical block was containment-checked, so a contradiction inserted
  beside the rule passed; it is now matched EXACTLY
- "Otherwise STOP." had been severed from the certified sentence by the
  explanatory prose, so flipping it to "Otherwise CONTINUE." passed; the
  default is back inside the block and the prose moved after it
- a reversing clause joined by a semicolon shared the token's sentence; the
  clause split now breaks on ';' as well
- MENTION missed "Invalid verification evidence" because invalidat\w* does not
  match "Invalid"; added an alternative, with the vocabulary limit stated
- the Form-B injector cut at the '.' in "test-evidence-exception-bound.sh" and
  spliced mid-filename, so no Form-B mutant realised the adjacency its label
  claimed; it now targets a clause carrying both a mention and the token, and
  asserts placement, non-mangling, and that the injected text is detectable
- the [bound: ...] token no longer sits inside the rendered ASCII diagram; the
  caption points at the SCOPE RULE instead of restating it
- the CI step name is quoted, so '#' no longer truncates it

Sol's four bypasses are kept as permanent regression mutations, and the harness
now reports why each mutation was rejected — a bypass fixed without a test is a
bypass that returns, and a mutation caught for the wrong reason is not evidence.

14/14 mutations rejected, each for its intended reason.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
Round 2 of seat 1's review. Two findings repaired, two disputed with evidence.

FIXED — marker uniqueness counted matched PAIRS, so a stray unmatched marker
survived (reproduced: a bare closing marker appended at EOF, rc=0). A later
edit could pair with it and move the block. Now requires exactly one occurrence
of each marker in the raw text, with regression mutations for a stray closing
AND a stray opening marker.

FIXED — the canonical block could be swallowed by an unclosed code fence
earlier in the document, rendering the rule as an inert code sample. Added a
fence-parity check from doc start to the opening marker, and a mutation that
wraps the block in an unclosed fence. Deliberately not extended toward general
markdown-rendering semantics.

DISPUTED — reversals joined to the token by an em dash, parenthetical, colon,
list break or table cell. Measured rather than argued: widening the clause split
to cover them splits the reference token at its own colon and produces eight
false violations, against zero today. No punctuation class is an attachment
boundary in English. Recorded as a NAMED NON-GOAL in the header so it is not
rediscovered as a defect.

DISPUTED — that the rule could render as deleted text. Strikethrough inside the
markers already fails the equality check, and GFM strikethrough is inline-level.
Seat 1 demonstrated the fence case with a cmark render but asserted this one;
a demonstration is requested, on the same standard the driver is held to.

Also folded in seat 2's P3: the header claimed evasion "requires discussing the
rule without using its words", which is false — "Stale evidence buys another
pass" uses its vocabulary and matches nothing listed.

Recorded in the handoff: two of round 2's three findings were PROMPT-SEEDED by
the driver's own round-2 prompt, which listed the evasion categories that came
back as findings. The shipped doc forbids exactly that. Round 3's prompt has no
attack sections.

17/17 mutations rejected, each for its intended reason.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
…lass by spec

Seat 1 falsified the raw-HTML element scan from both sides in one round, and
dispositioned it DELETE rather than REPAIR. Seat 2 ratified. It was too narrow
(<section hidden> is in no hand-written element list; a ~~~ fence captures the
block using no element name at all) and too broad (a closed <kbd>Ctrl</kbd>,
which can capture nothing, failed the suite).

Three consecutive rounds each closed one render-capture hole and each opened
another. The exit is a scope decision, not a fourth patch: every check that
reads source text for a rendered format is falsifiable in render-space by
construction. A render can falsify a claim about what a check catches; it
cannot falsify a decision about what the check is for.

- Delete check 1d entirely, leaving its history in place so it is not
  reintroduced.
- Record render capture as a SECOND STATED LIMIT, with the threat model that
  makes it the right scope: anyone who can open <section hidden> here has
  commit access and could delete the rule outright. Review is the control for
  a committer-adversary; this guard catches accidents.
- Extend fence parity to ~~~. CommonMark defines exactly two fence characters,
  so this set is closed by spec and cannot grow again. The two are counted
  separately, never summed — a ``` line inside an open ~~~ block is literal
  content, and a combined count would corrupt parity either way.
- Scope 1c's claim to GFM inline spans. It said "any inline construct", which
  is false: raw HTML is not an inline span and does cross blank lines.
- Swap Form F (raw <s>) for Form G (unclosed ~~~ fence). Still 19 mutations,
  each asserted to fail via its declared check.
- Add a must-PASS fixture for <kbd>Ctrl</kbd>. A deleted check leaves no
  trace, so nothing else would stop the overbreadth from returning.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
Seat 1 accepted the render-capture scope ruling this round (SHAPE: SOUND, no
finding against the named non-goal), then found the fence check I wrote to
replace the deleted one was wrong in both directions.

It counted prefix-shaped lines, which is not fence state. A properly closed
```` block containing a literal ``` line was REJECTED — a false positive on a
valid document. The same block left unclosed was ACCEPTED and captured the
rule — a false negative on the exact attack the check exists for.

- Track fence state per CommonMark: a closing fence must use the same
  character, be at least as long, and carry no info string; while a fence is
  open, every other line is literal content. Skip 4+ space indents (indented
  code blocks) and backtick openers whose info string contains a backtick.
- Add Form H (unclosed ```` must fail) and a second must-PASS fixture (closed
  ```` containing ``` must be accepted). Each asserts that naive prefix parity
  would have gotten it wrong, so neither can degrade into a test a counter
  would also pass. A must-fail mutation cannot detect a check that is wrong in
  the other direction; that is what the must-pass fixtures are for.
- 19 -> 20 mutations.

Also corrects two more overclaims seat 1 found in this file's own header: the
canonical block is compared VERBATIM AFTER WHITESPACE NORMALISATION, not
byte-for-byte, and the reachability promise is scoped to what MENTION detects.
A paraphrase avoiding every MENTION alternative is neither flagged nor bound.
The honest claim is the narrow one: what this guard finds, it binds.

Co-authored-by: webbrain-one <webbrain-one@users.noreply.github.com>
@BaseInfinity

Copy link
Copy Markdown
Owner Author

Seat 1 merge clearance, issued on the final tree after the tab-indent fix. Sol reproduced all three indent shapes independently rather than accepting the reported one: tab-indented literal ``` → exit 0, 3-space open fence → exit 1, unindented open fence → exit 1.

CROSS-MODEL-CLEARANCE

{
  "confidence": 98,
  "reviewer": "gpt-5.6-sol",
  "sha": "ac9162acead65abefb4f8dae6fcbe23203287a99",
  "verdict": "CERTIFIED"
}

@BaseInfinity

Copy link
Copy Markdown
Owner Author

Seat 2 merge clearance on the same tree. Basis: the tab fix is correct per CommonMark (a tab advances to the next 4-column stop), all three indent shapes were verified empirically rather than only the reported repro, the fix is locked as must-pass fixture #3, 20/20 mutations each fail via their declared check, shellcheck clean, affected suites green, and both scope decisions are documented with their threat models.

CROSS-MODEL-CLEARANCE

{
  "confidence": 95,
  "reviewer": "fable",
  "sha": "ac9162acead65abefb4f8dae6fcbe23203287a99",
  "verdict": "CERTIFIED"
}

@BaseInfinity

Copy link
Copy Markdown
Owner Author

Reposting seat 1's clearance in the gate's required schema — the gate matches verdict: "YES", and my previous comment used the reviewer's own token CERTIFIED. Same verdict, same tree, same leg. No re-review was run and none was needed: the underlying verdict is {"verdict":"CERTIFIED","shape":"SOUND","confidence":98,"findings":[]} on ac9162a, with Sol independently reproducing all three indent shapes (tab-indented literal ``` → exit 0, 3-space open fence → exit 1, unindented open fence → exit 1).

CROSS-MODEL-CLEARANCE

{
  "confidence": 98,
  "reviewer": "gpt-5.6-sol",
  "sha": "ac9162acead65abefb4f8dae6fcbe23203287a99",
  "verdict": "YES"
}

@BaseInfinity

Copy link
Copy Markdown
Owner Author

Reposting seat 2's clearance in the gate's required schema, same as above — CERTIFIED in the reviewer's token, YES in the gate's. Same verdict, same tree, confidence 95.

CROSS-MODEL-CLEARANCE

{
  "confidence": 95,
  "reviewer": "fable",
  "sha": "ac9162acead65abefb4f8dae6fcbe23203287a99",
  "verdict": "YES"
}

@BaseInfinity

Copy link
Copy Markdown
Owner Author

DUAL CROSS-MODEL CERTIFIED MERGE

Cleared by: gpt-5.6-sol (posted by @BaseInfinity), fable (posted by @BaseInfinity) — both bound to ac9162acead65abefb4f8dae6fcbe23203287a99

Merge-evidence path(s) this authorised:

  • .github/workflows/ci.yml (merge-evidence path)

Verified: CI validate green across every run of that name; no net-removed test files; no package.json version bump; clearance artifact CERTIFIED at round >= 2 bound to this SHA; the executing merge script and its redirect hook byte-match origin/main.

ATTESTED, NOT AUTHENTICATED. Both clearances were posted by the same gh token, so this records that two distinct reviewers returned YES at >=95 — not that two independent principals did. A new workflow file can still mint a green required check; the compensating layer is that both reviewers read this diff.

Posted by scripts/merge-pr.sh --dual-certified before merging.

@BaseInfinity
BaseInfinity merged commit 6ba0e35 into main Aug 18, 2026
4 checks passed
BaseInfinity added a commit that referenced this pull request Aug 18, 2026
….0.0 becomes a delivery vehicle (#674)

* docs(roadmap): save point carries this session's process facts, not just its outcomes

The block a cold session reads was still the release cut. It now records what
shipped (#669, #670 merged; #671, #672 filed) and three things that cost real
time, written so they are not relearned.

1. Loops end when the SHAPE changes, never when the patch gets better. Two
   treadmills tonight. The pointer guard ran four consecutive P1 rounds and
   ended in deletion under #530. "This fix ends the defect class" went 0-for-3
   on one guard.

2. A mutation harness that has not been proven to mutate is not evidence.
   Three separate harness bugs each produced a clean-looking false result
   before one told the truth. Assert the mutation LANDED before trusting what
   the suite says about it.

3. Every gate rejection on #670 was legitimate, and a rebase killing a
   clearance is correct behaviour, not friction.

Numbers stated exactly rather than approximately, because both trees are
frozen: 1360 words to 449.

test-doc-consistency 137/0.

* docs(roadmap): point the queue at v2.0.0 as a delivery vehicle (#673)

The milestone carried the work for a major release and nothing that ships one.
Every issue on it changed the harness; none bumped a version, wrote a CHANGELOG
entry, pushed a tag, or verified a consumer could install the result. That gap
is how v1.99.0 stopped being a coherent release.

No new milestone. v2.0.0 — Consumer Safety Repairs already existed, and a
second major-release milestone forks the queue. #673 fills the gap and #638
and #622 are attached rather than duplicated.

The terminal gate is now in the milestone description instead of a session's
memory: v2.0.0 ships on PROVEN CONSUMPTION (#545), not on open_issues == 0.
Everything else there is agent-drivable; #545 is the maintainer's and cannot be
done for them.

v1.99.3 still ships first and separately — review-leg supervision makes every
2.0 review cycle cheaper, so folding it in inverts the order.

test-doc-consistency 137/0.

* docs(roadmap): two P1s — I smuggled in a weaker rule, and called an irreversible tag agent-drivable

Both in-card, both mine, both caught by review.

P1-1. The save point said "when a reviewer returns WRONG_SHAPE twice on the
same component, escalate." SKILL.md:170 already routes the FIRST WRONG_SHAPE to
the design authority with "do not patch." So the sentence raised the bar to two
and weakened a standing rule — as a session note, inside a block whose own
scope card excludes standing-ruling changes. Rewritten to cite SKILL.md:170 and
frame rounds 3-4 as what following that rule LATE costs.

P1-2. "Everything else on that milestone is agent-drivable" was false. #673
ends in `git push origin v2.0.0`. release.yml publishes on that push and npm
forbids returning to 1.x, so the milestone has TWO maintainer-held steps, not
one. ROADMAP, the milestone description and #673 all now say so, and the
standing "publish without me" authorization is named explicitly rather than
leaned on in silence — it was given for routine releases, and a major that
cannot be unpublished is a different scale.

test-doc-consistency 137/0.

* docs(roadmap): the npm premise was false, so the caveat built on it comes out

Review challenged the tag gate I invented and won on both halves.

The premise was wrong. npm refuses to republish an EXACT name/version — it does
not forbid a later 1.x. Publishing 1.99.4 after 2.0.0 is legal, and
`npm dist-tag` can move `latest` anywhere. So 2.0.0 is unrepeatable, not a
one-way door, and a bad release is recoverable by publishing forward.

That premise was the entire basis for narrowing the maintainer's standing
publish authorization to "routine releases." The authorization was given
unqualified. Inventing a caveat on a maintainer's behalf, and then justifying
it with a fact nobody checked, is worse than either mistake alone — the caveat
reads as deference while quietly rewriting what they authorized.

Removed on all three surfaces: ROADMAP, the milestone description, and #673.
The tag is agent-drivable like the rest of the milestone; the maintainer holds
it only if they say so. #545 remains the one genuine gate, because consuming
the harness in other repos is something nobody can do for them.

Also corrected a stored memory carrying the same false claim, which would
otherwise have re-seeded it next session.

test-doc-consistency 137/0.

* docs(roadmap): the half-removal I warned about was my own

I asked the reviewer to hunt for a fourth surviving instance of the false npm
premise, on the grounds that a half-removed caveat is worse than the original
because the removal reads as done. It found two. Sweeping for a third found
one more the reviewer had not named.

  ROADMAP.md:41   "that push is the point of no return, because npm forbids
                  returning to 1.x"                                    REMOVED
  ROADMAP.md:43   still opened "#545 is not the only maintainer-held step",
                  contradicting the rest of its own sentence           REMOVED
  #673            "Note on numbering" repeated the whole false claim   REWRITTEN

The previous commit said the premise was removed on all three surfaces. It was
removed from the three places I had put it deliberately, and survived in the
places it had leaked to. Claiming completeness is a claim like any other and
should have been grepped, not asserted.

#673's note now names the false claim rather than quietly deleting it. It was
load-bearing — it was the justification for holding the tag back from the
maintainer's standing authorization — so a silent deletion would erase the
reason the correction matters.

Swept every surface independently: ROADMAP 0, milestone 0, #672 0, PR body 0,
repo-wide 0. #673 returns 1, which is the correction sentence itself, verified
by reading the line rather than trusting the count.

test-doc-consistency 137/0.
BaseInfinity added a commit that referenced this pull request Aug 19, 2026
* docs(roadmap): leave the save point accurate for a cold session

Merged tonight: #669, #670, #674. Filed: #671, #672, #673. Nothing in flight.

Records the reconciled cost-review outcome (#616): ten review passes across two
docs PRs produced nine real P1 findings, three or four of the passes avoidable.
The reconciled recommendation is base-freshness enforcement in
run-review-leg.sh — fetch the authoritative ref, resolve the PR's actual base
branch rather than assuming main, refuse a stale base. Sol argued against its
own competing proposal because it "still trusts callers to enumerate every
surface."

Records the #644 measurement: three documented rules skipped in one session,
none enforced by anything mechanical. That is evidence FOR the standing
no-new-rules ruling, not against it — all three already existed and a fourth
would not have helped.

Records three habits that each cost a round: prove a mutation LANDED before
trusting the suite, grep completeness instead of asserting it, and check claims
about the outside world too.

Every claim here was run before this commit. One was already wrong: I had told
the maintainer "eight P1s" twice; the count is nine.

test-doc-consistency 137/0.

* docs(roadmap): two P1s — an imprecise claim, and a framing that flattered the ruling

Both were things I asked the reviewer to check. Both were right.

P1-1. "Every leg it ran certified a stale base" is false. #670's rounds 1-4
returned blocking findings and certified nothing; only round 5 certified. The
branch WAS stale from birth and every leg reviewed a stale base — but
attributing certification to non-certifying legs overstates it, in a block whose
whole job is to be accurate for a reader who cannot check.

P1-2. I framed three skipped rules as evidence FOR the standing no-new-rules
ruling. That is the reading most convenient to me. The maintainer ruled against
new mandatory steps in SKILL.md and against a commit-hook lane; I widened that
into a general position and then claimed my own measurement supported it.

The honest version keeps both halves. The evidence rejects MORE duplicate
prose — all three rules already existed. It equally supports MECHANICALLY
ENFORCING what is already written, which is a different proposition, and is
exactly what #616's reconciled recommendation proposes.

"Three written rules did not fire" is an argument about enforcement, not about
how many rules exist.

Corrected on #644 with a follow-up comment rather than an edit, so the claim
and its retraction both stay in the record.

test-doc-consistency 137/0.

* docs(roadmap): third pass at one sentence — round 6 reviewed the REBASED tree

Round 2 caught what round 1's fix still overstated. "Every leg reviewed a stale
base" is false: round 6 was the rebase-confirm and reviewed the rebased tree.
That leg is the whole reason the sentence exists, and the wording excluded it
by asserting the opposite.

The sentence now matches the record leg by leg: rounds 1-5 reviewed a stale
base, 1-4 certified nothing, 5 certified one, and 6 re-reviewed the rebased
tree after the merge was refused.

Recorded against myself in the handoff: this took three passes because each
time I fixed the exact word the reviewer quoted instead of re-deriving the
claim from the record. "Every leg certified" -> "every leg reviewed" -> the
actual per-round history. Two of those three passes were avoidable by checking
the leg verdicts once.

test-doc-consistency 137/0.

* docs(roadmap): delete the leg count instead of fixing it a fourth time

Counted the record properly this time: six legs with verdicts plus one
transport-failed leg is seven executions, six of them on a stale base. The
reviewer's count was right and mine was wrong for the third consecutive round.

  "every leg certified a stale base"   wrong
  "every leg reviewed a stale base"    wrong
  a per-round tally                    still miscounted

Three rounds on one number is the shape signal, not an invitation to a fourth
attempt. SKILL.md:170 routes a repeated shape failure to a design decision
rather than another patch, and a prose claim that has survived three fixes
deserves the same treatment.

So the number comes out. What stays is the fact a cold reader actually needs:
the branch was born stale, every review ran on a stale base until the merge was
refused, and it cost a refused merge, two clearance reposts and an extra leg.
The omission is marked as deliberate so nobody helpfully restores it.

Same lesson as #670's deleted guard, reached four rounds slower because the
surface was prose instead of a test.

test-doc-consistency 137/0.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Guard the evidence-exception bound by construction, not by regex over prose

2 participants