Skip to content

Sync next into main - #84

Merged
mmacedoeu merged 2931 commits into
mainfrom
next
Oct 17, 2026
Merged

mmacedoeu merged 2931 commits into
mainfrom
next

Conversation

@mmacedoeu

Copy link
Copy Markdown
Contributor

Sync next into main

Promotes the next integration lane into main.

Relationship

main is a strict ancestor of next, so this is a fast-forward with no
conflicts and no merge resolution
:

main bc1c7820
next cd5afbd1
Commits on next not on main 2931
Commits on main not on next 0

The diff is large because this lane carries a long history of accumulated
work; the relationship is strictly linear, so nothing here discards or
rewrites anything on either branch.

Branch retention

next is not deleted by this PR and must not be deleted. It stays as the
integration lane. No auto-merge or cleanup automation is configured against it:
sync-next.yml automerges with merge-method: merge and does not set
delete-branch.

CI state at cd5afbd1

All ten workflows triggered by a push to next are passing:

CI · commit-message-lint · Coverage · Exercise Path CI · Lint · Quota Router ·
Quota Router Python SDK · Rust CI · Security Scan · ZK Capability Circuit CI

CI on this push would run against main per its own triggers; the signal that
matters is that the tip commit is green on the lane it was built on.

Fixes at the tip of this lane

The nine most recent commits took next from seven failing workflows to green:

  • b8a9b14d telegram-cli did not compile. DeterministicEnvelope::verify
    gained an explicit algorithm parameter in ac31b1fe; this caller was never
    updated, and the crate is excluded from the main workspace so the workspace
    check never reached it.
  • acbd85e5 the cross-language verifier looked for the CLI under the
    member directory; cargo writes to the workspace target directory. A stale
    committed binary was masking it.
  • 02d64b12, d6c9e2dd, c9ea2662, cb754760, cd5afbd1
    the lockfile was gitignored, so every CI checkout resolved from scratch, and
    zip 0.6.x has been yanked from crates.io in its entirety. cairo-vm
    requires it non-optionally in every version. Three workspaces were affected
    (root, quota-router-pyo3, quota-router); the latter two are excluded from
    the workspace and so needed their own lockfiles and their own dependency-pin
    refresh.
  • fc5ff61b, 7873eee2 the coverage job was losing the hosted runner to
    memory exhaustion. Split across eight shards over 61 crates, with one
    instrumented build per shard instead of four.

Review note

Because this is a fast-forward of a long-lived lane rather than a focused
change, reviewing commit-by-commit is not practical. The most recent nine
commits are the ones that changed CI behaviour; everything before them is the
lane's accumulated history.

The detection fix in lint_no_vh_accepted.sh changed its verdict from
PASS to 51 findings. Those findings are real debt and are recorded here
rather than resolved, because writing a Version History for a document
is author work and not mechanical repair.

18 Accepted RFCs have no Version History section at all. 33 have the
section with no data rows under it. 104 pass.

The 18 are listed in full. The 33 are not duplicated, because the live
output of the linter is the authority and a transcribed list would drift
the first time a file is fixed.

Also verified and recorded: 0001-mission-lifecycle.md sits under draft
but its Status block reads Accepted, and it has no Version History. That
is a placement and status inconsistency in its own right, so it is called
out as its own acceptance criterion instead of being folded into the
list.

The section sign defect is recorded because it is the third instance of
the same class in this repository. A pattern written against a bare
section name silently misses the form this repo actually writes, which is
the same failure the citation regex had.
lint_section_cites.sh guarded against an empty corpus with
if ACCEPTED is 0, fail "no files were examined". ACCEPTED is the result
of classifying a cite, not evidence that anything was examined. A corpus
whose cites are all alphabetic, such as §Identity, never reaches the
ACCEPTED counter, so the lint examined every cite and then reported that
it had examined nothing.

Confirmed with a two-line corpus containing two §Identity style cites.
Before, it exited 1 with "no files were examined". After, it reports
SCANNED=1, EXAMINED=2, ACCEPTED=0, NON_CANONICAL=2 and passes.

The guard now tests SCANNED and EXAMINED separately, so a genuinely
empty root still fails, a root of files with no cites states that plainly
as a real result rather than an error, and only a root with no files at
all claims the lint verified nothing.

Also adds the two counters the summary never had. The linter reported
ACCEPTED, NON_CANONICAL and REJECTED but never said how many cite tokens
it looked at, so a change in scope would be invisible. It now reports
SCANNED=247 files and EXAMINED=10281 cite tokens on the current tree.

Scope is unchanged. It still reads RFC_ROOT only, which covers 10281 of
29515 §cite tokens in the repository, the rest living in docs, missions
and the two top-level governance documents. That gap is recorded
separately rather than fixed here, because widening it changes what the
linter rejects and is a maintainer decision.

The 58 rejections are unchanged and remain false positives. All 58 are
the phantom-token class, and every one is an audit finding id such as
§1a and §9b rather than a section. One cited in place: a Mitigation
clause carrying RFC-0963 §1a. The CI-wired linter already exempts this
class in its is_section_anchor.
Pattern found while fixing lint_no_vh_accepted.sh. Four check scripts
report a verdict their own output contradicts. None lies about the number
it prints. Each prints a number describing a different population than
the reader assumes, which is why all four read as clean.

lint_no_vh_accepted.sh counted every markdown file in CHECKED but only
detected Accepted RFCs in PASS, hiding a skip of 148 of 155.
lint_status_vh_sync.sh compared against the oldest version history row.
lint_section_cites.sh guarded on ACCEPTED, a classification result rather
than a count of work, and reported an empty run after examining every
cite in the corpus.
mutation-verify-guards.sh treats any argument as a name filter, so an
unmatched filter yields passed=0 and exit 0 with no warning. Not fixed
here because the mutation harness is covered by a separate mission.

The unifying question for future review is not whether a lint is
correct but whether its counter describes the population its verdict is
about. All four were correct arithmetic over the wrong set.

Also measured, because neither cite linter printed a total: together they
examine 10281 of 22169 tracked cite tokens. The rest live in docs, in
missions, and in the two top level governance documents. Widening scope
is a maintainer decision, not a mechanical change, because the non-RFC
corpus contains anchors with no RFC number at all.

The two linters actually wired into CI both print their corpus size and
their baseline coverage. Neither defect here could survive that, and
copying that behaviour is cheaper than fixing these case by case.
The script treated any argument as a substring guard filter and skipped
everything that did not match. Running it with --help reported
passed=0 skipped=10 and exited 0. There was no help output, because
--help matched no guard name. The summary read like a result.

A typo in a guard name failed the same way and is the case that matters.
Someone verifying one guard by name could mistype it, have every guard
skipped, and get a success exit from a run that verified nothing.

Three changes.

- -h and --help print usage and list every available guard, so the name
  is discoverable instead of guessed.
- A filter matching no guard exits 1 and says the run verified nothing.
- A partial filter still exits 0 but reports how many guards it skipped
  and by which filter, so a narrowed run cannot be mistaken for a full
  one.

Verified in all four directions.

- no argument: 10 of 10, exit 0, unchanged
- a real filter: passes, and now also reports the 9 skipped
- a mistyped filter: exit 1 with an explicit failure, was exit 0
- --help: usage plus the guard list, exit 0

The second and third cases produced identical passed=0 skipped=10 output
before this change. Same numbers, opposite meanings, and nothing in the
output distinguished them. The exit code now does.

Also updates the mission that recorded this, which had deferred the fix
to avoid drifting from the mutation harness mission. That was the wrong
call. A known defect left filed because a second mission also mentions
it is the same as a defect left unfiled, and it keeps a trap live for
anyone who mistypes a guard name.
lint_plan_yaml_vh_sync.sh incremented CHECKED before the file-type
filter, so any non-markdown file in the plan root inflated the count
without being examined and CHECKED stopped matching the sum of its own
classification counters.

Confirmed with a text file alongside one markdown plan: CHECKED=1,
IN_SYNC=0, and no NO_VH_NO_YAML either. One file counted, zero examined.
The sum of the classification counters did not reconcile with the total,
which is the same arithmetic signature that hid the skip in
lint_no_vh_accepted.sh.

Harmless on the current tree only because the plan directory happens to
contain nothing but markdown files. That is not a property the script
can rely on, so the increment moves after the filter.

Verified with the same fixture before and after. After the fix, with the
non-markdown file present, CHECKED=1 and IN_SYNC=1 for a plan that is
genuinely in sync, so the count and the classification agree again. The
real corpus is unchanged at 6 checked and 6 NO_VH_NO_YAML.

One correction to my own reading while checking this. The first fixture
I wrote omitted a version field from the YAML frontmatter, so IN_SYNC=0
was the correct verdict rather than a symptom of the fix failing. The
counter was already right and the fixture was wrong. Rewritten with a
version field, which is what made the reconciliation visible.
A mission recording a linters current behaviour goes stale the moment
that linter changes. Three claims in this set were checked against the
tree rather than assumed.

live verification found two stale and one accurate. lint_no_vh_accepted
exited 0 when its census table recorded that, and now exits 1 with 51
findings, because the detection fix in this session changed its verdict.
Its row is corrected. The mutation-verify-guards note describing help
flag behaviour that has since been fixed is marked as fixed and points at
the mission that fixed it.

The status linter row still reads 1 real finding and re-verification
confirms it. So do the section cite figures, at 58 rejections over 10281
examined cite tokens.

The 1323 unique findings figure for validate_cites was recorded before
five subsequent commits. Rather than trust it, the script was re-run
end to end on the current tree. It reports the identical summary and
recomputes to exactly 1323 unique findings, so the claim stands.

Also verified as still accurate: RFC-0105 still resolves to three files
across two categories, and two RFCs still use the section sign prefixed
version history heading.

The general point is the one the previous mission already argues. A
number in a document is a claim about the tree, and it decays silently.
The two linters wired into CI print their corpus size on every run,
which is why nobody has to wonder whether a recorded figure still holds.
The anchors linter is one of only two checks wired into CI and is the
gate a reader would trust with a citation. It builds its heading index
from rfcs, docs, missions and CLAUDE.md, then checks citations only
inside rfcs. It knows every heading in the repository and verifies
references in about a third of it.

Proven with a control rather than inferred from the source. The identical
sentence carrying a plainly invented anchor was planted in both trees.
In rfcs it is reported with file and line. In docs it is not reported and
the run exits 0. Same string, same run, two verdicts decided purely by
directory. Both probe files were removed immediately.

Scale, counted directly against the repository: 3714 multi-word anchors
in rfcs are checked, and 6370 sit outside it across docs, missions and
CLAUDE.md. missions is the second largest population and is written by
the agents this process is built for.

CLAUDE.md is the sharpest case and is called out as its own acceptance
criterion. It carries three BLUEPRINT pointers and two do not resolve.
Verified by hand rather than assumed: Mission Lifecycle exists as a
heading, The RFC Process and Multi-Mission Decomposition do not. The
linter indexes CLAUDE.md as a source of valid anchor names and never
checks whether the references inside it are valid.

The other wired linter also walks rfcs only, and that one is narrower by
design because it resolves symbols inside RFC code blocks. The
distinction is that the anchors linter indexes four trees and reads one.

Scope is a maintainer decision, so nothing was changed. The 6370 figure
is a population count and not a finding count, and widening the scope
would surface findings that then need baselining deliberately.
CLAUDE.md carried three section references that resolve to no heading
anywhere in the tree. It is the first file any agent reads, and the
linter that would have caught them indexed CLAUDE.md as a source of valid
names without ever checking the references inside it.

Ground truth was established with the linter own normalisation and then
confirmed by hand with an exact-heading search, because the linter has
been wrong before in this session.

§The RFC Process cited a BLUEPRINT.md section that does not exist. The
heading is local to CLAUDE.md, so the reference now points at the local
section instead of a document path.

§Multi-Mission Decomposition exists in no document. The content the
sentence describes lives under Mission Lifecycle and Consistency
Checklist, and those are what it now cites.

§RFC Reference Conventions Reaffirmed missed its heading because the
heading carries a parenthesised suffix that normalisation does not strip.
The citation now matches the heading.

The linter now checks CLAUDE.md as well as indexing it. Verified by
planting an invented anchor in the file, which is reported with a line
number and exits 1. Previously the identical string planted under docs
was silently ignored, which is how the gap was found.

Widening the linter to the docs and missions trees is still a maintainer
decision and is recorded separately. CLAUDE.md was taken here because it
is one file, it is the highest-traffic document in the repository, and it
had live broken pointers today.
The mission recorded that CLAUDE.md was indexed but never checked, and
listed bringing it into scope as an open acceptance criterion. Both are
now done, so the mission is corrected rather than left describing a gap
that no longer exists.

Its own acceptance criterion said CLAUDE.md should be in scope regardless
of the wider decision, and the reason recorded is that it is one file and
had live broken pointers. It turned out to have three, not the two a
previous mission had recorded. The third is a parenthesised heading
suffix that normalisation does not strip, which is why it survived a
manual reading as well as the earlier automated pass.

The wider docs and missions scope is untouched and still a maintainer
decision. The population figures in the mission are unchanged and remain
what they claim to be, a count of anchors rather than a count of
findings.
The obvious argument is that the anchors linter misses 6370 anchors so
it should scan docs and missions too. That argument is wrong on the
numbers. Every figure was produced by running the linters own normalize,
is_section_anchor and heading index against both trees before changing
anything.

Widening would report 2789 findings. That splits into three classes and
none of the three is a plain dangling section.

1538 are extraction artifacts. The anchor pattern runs a name to the
next backtick, pipe, newline, comma or dash, and in prose-heavy
documents routinely runs past the end of the reference, so a citation
of RFC-0011-d §Mission Decomposition M9 swallows its closing paren and
the following words. There is no heading by that name and there should
not be.

827 resolve as a real section name followed by a qualifier, such as
§Implementation Phases 1 or §Adversary A5. This is the trailing
qualifier case already filed separately. The rejected prefix fallback
would have accepted these by trimming, and would also have accepted
§Gas Model against a Gas heading, which is a genuine dangling
reference. The distinction is that 1, A5, B and TV1 are identifiers with
a recognisable shape while Model is an English word, and that
distinction is available to a resolver but not to a regex.

432 remain, and are the only candidates for real findings.

Two corrections made while writing this up. The first draft of the table
apportioned the qualifier count across trees from a combined measurement
and produced a row that was arithmetically self-contradictory. Re-measured
per tree: 338 in docs, 489 in missions. And the remaining row was written
as an approximation before being measured at all, which is the exact
habit this repository keeps punishing. It is now measured: 186 and 246.

Also checked and rejected as the missing piece: RFC titles live in an H1
the heading index does not read, but indexing them resolves only 8 of
1259.

The temptation is to widen and let the baseline absorb the result. That
produces a green gate whose baseline records mostly regex over-capture,
which is the opposite of what a baseline is for.
CLAUDE.md makes the no-line-refs rule a hard architectural rule. A corpus
scan finds 91 section references written in exactly the forbidden form,
across 18 files, concentrated in docs/audits.

Examples are quoted verbatim in the mission, such as a file line reading
mission §F.3 L72 plus RFC §F.3 L740, and another reading mission §Test
Vectors header L205.

No gate catches these for two reasons and the second matters more. The
references sit outside the tree the anchors linter scans. And even once
docs is in scope, a compound reference would be reported as a dangling
section, which is the wrong diagnosis. The heading is present. What is
wrong is the suffix, not the target. Fixing the line number is not
required to make the citation resolve, and a reader sent to add a heading
that already exists will add a second one.

This needs its own check rather than being swept up by anchor resolution.

Found while testing the candidate terminator set recommended in the
previous commit. Tightening the extraction made raw dangling counts fall
while plausible names rose by 40, and every newly-plausible name was a
real anchor whose forbidden line suffix had previously been absorbed
into the name and so excluded by the plausibility filter used to
separate signal from regex over-capture. That is the useful part of that
experiment.

Counts corrected during the writeup. The first draft said 84 across 17
files, which was wrong. Exact figures are 91 occurrences across 18 files,
90 of them in docs and missions and 1 in an RFC, that one inside a
Mermaid diagram label where a line reference may be defensible and is
called out separately rather than lumped in with the audit documents.
The previous commit recommended adding a closing paren and a colon to
the anchor pattern terminators, as the cheaper prerequisite to widening
the scan scope. That recommendation was made without running it, which
is the habit this repository keeps punishing. It has now been measured.

Raw dangling findings fall as expected, 1168 to 1097 in docs and 1629
to 1569 in missions. Plausible candidates rise instead, 524 to 535 and
735 to 764. The reason is not noise. A tighter boundary stops absorbing
a forbidden line number suffix into the name, so references that were
previously indistinguishable from regex over-capture become visible as
data. All 40 newly visible items are line number convention violations,
now filed separately.

The property that makes this safe to do first is that the gated tree is
byte identical either way. rfcs extracts 5500 anchors under both
patterns and reports the same findings. A change that prepares the
ungated trees has no effect on the tree CI actually enforces.

That is the argument for doing the terminator change before the scope
change rather than bundling them, and it is now an argument with numbers
behind it rather than an ordering preference.
The previous commit recommended the anchor terminator change as safe to
make first, on the evidence that rfcs extracts the same number of anchors
under both patterns. That evidence was the wrong measurement and the
recommendation does not survive it.

Extraction count is not findings. Counting findings against the baseline
over rfcs and CLAUDE.md gives findings 1533 falling to 1478, baselined
entries falling from 584 to 520, and 25 new findings that are not
baselined. The change turns CI red.

The mechanism is not obscure. 80 findings disappear because a closing
paren or colon now truncates a compound reference, and 64 baselined
entries stop matching their site. But 25 references that were previously
invisible become visible, and they do not resolve. Four of those are
themselves over-capture artifacts of the new boundary, such as an audit
proof generation reference that still swallows an opening quote. The rest
are real dangling names including §The RFC Process, §Part 3, §Phantom
Types, §Implicit Assumptions and §Appendix A.

So the prerequisite is real but it is not a safe first commit. It needs
to land with either a baseline extension or a batch of citation repairs,
and the 64 orphaned baseline entries need rewriting to match the new
boundaries. That is a deliberate change to a CI gate.

Nothing was changed in the linter. The previous two commits made the same
claim about rfcs being unchanged, and this commit is the correction rather
than a retraction of the mission, which now records the reversal and the
numbers that caused it.
The previous commit described the 25 references the terminator change
would surface as real dangling names. Checking them individually
reverses that. 23 of the 25 are near-misses, where a proper prefix of the
captured name is a real heading in the tree.

The clearest case is §Implicit Assumptions, which was called dangling.
The heading Implicit Assumptions Audit exists in three RFCs, so what the
reference actually is, is a real section cited without the qualifier that
distinguishes it. The same holds for Implementation Phases Commit 1,
Audit Proof Generation, HW Key Custody, Lifecycle and Determinism.

Only 2 are hard-dangling, and both are still over-capture rather than a
missing heading. One is a cross-reference arrow swallowed by the new
boundary and one is a Roles and Adversary compound.

This changes the conclusion about what the change implies, not whether it
is allowed. The 25 are the same family as the qualifier problem the
mission already describes, so the prerequisite is a resolver change rather
than a corpus repair. What the terminator change surfaces is mostly
citations that are nearly right rather than ones that are wrong, which
makes it far less alarming and much cheaper to land than the previous
entry implied.

It still turns CI red, so it remains a maintainer decision. Nothing in the
linter was changed.

Recording this rather than quietly editing the sentence, because the same
class of error has now happened three times in this area. A count was
called a conclusion twice, and a bulk classification was called a set of
facts once. Checking the items rather than the aggregate is what caught
it.
Last turn a proper prefix resolver was recommended as the single highest
value change, on reasoning rather than measurement. It has now been
built and measured, and the numbers are strong.

The mechanism already exists. The linter does not match a name against
headings directly, it calls candidates, which produces progressively
shorter forms. That truncation handles exactly one shape, a
parenthetical. It does not drop a trailing qualifier, which is the shape
most outstanding findings have. The extension is additive and leaves the
parenthetical path untouched.

Measured on the gated tree of rfcs plus CLAUDE.md, which is what CI
enforces. Findings go from 1237 to 438 under the resolver alone, and to
401 with the previously measured terminator change. 799 findings are
resolved and 242 baselined entries become dead.

The check that decided it is the one the rejected prefix fallback failed.
That fallback was rejected for accepting §Gas Model against a Gas
heading. So the question was measured directly rather than argued: how
many findings resolve by a single word heading. The answer is zero. Every
resolution lands on a multi-word heading, which is the single constraint
that separates a resolver that removes noise from one that hides errors.

The combined change still turns CI red, so it is not applied. The 108
unbaselined findings were broken down rather than assumed: 93 were
already unbaselined on today's tree, which carries 653 of them, and 15
are genuinely new across 11 distinct names. Each was checked against the
heading index and none resolves.

One resolver addresses three recorded problems at once, the 827
qualified citations outside the gated tree, the 23 near misses the
terminator change alone would surface, and 242 baseline entries that
exist only because the matcher cannot truncate.
The proposal filed in the previous commit was for machinery this codebase
already contains. resolves does not merely call candidates. It falls back
in both directions, handling an anchor that carries words the heading does
not, which is exactly what the proposal claimed to add. Its loop bound
refuses to resolve down to a single word, which is the constraint the
proposal presented as its own safety property.

Commit 9496e19 added that fallback earlier in this same session, and its
message cites the same corpus examples the proposal rediscovered,
Implementation Phases Phase 1 and Adversarial Review Process Dry Run.
The proposal was made after it.

The measurements were wrong for a related reason. Every figure came from
a simulation that reimplemented the resolution loop instead of calling it,
so it missed that numeric anchors are only checked on lines citing a
project RFC, and it replaced the real bidirectional fallback with a plain
membership test. The simulation reported 1237 findings on the gated tree
where the live linter reports 599.

The mission is archived rather than deleted, as a record of a carefully
measured proposal for a change that was already there.

The parent mission carried the same fault and is corrected. Its 827
qualified citations re-measure to 477, docs findings to 476 and missions
to 587, using the real resolver. The problem is real and the ordering
recommendation stands, but the work is closer to 40 percent of the size
claimed. That is the difference between an afternoon and a month, so it
matters even though the conclusion survives.

The check that would have caught this is the cheapest one available. Read
the function that is called, not the one being looked at, and run git log
with a pickaxe on the distinctive comment before proposing the behaviour.
Four proposals in this area were measured by copying the linters
resolution loop into a scratch script. All four were wrong, twice for the
same reasons: the copy omitted the numeric anchor gate, so external
specification references were reported, and the copy replaced resolves
with a plain membership test, discarding the bidirectional prefix
fallback the linter already has. One of those four proposals was for a
resolver that had been added in the same session.

scripts/measure_anchor_lint.py imports the linter as a module and calls
normalize, is_section_anchor, resolves, heading_names and
project_rfc_numbers directly. There is no copy to drift. It measures the
gated tree as CI runs it, and any other tree on request, reporting
occurrences and name site findings separately because the linter prints
one and the baseline is keyed on the other.

Calibrated two ways.

On the gated tree it reproduces the live linter exactly, at 599
occurrences, 395 names, 590 baselined and 0 that would turn CI red.

Against a fault, deleting the prefix fallback from resolves moves its
reading from 590 findings to 1104 and from 0 new to 514. It tracks the
code rather than agreeing with a frozen model, which is the property the
four faulty simulations lacked.

Authoritative figures, superseding every earlier number in the widening
mission. The gated tree plus the terminator variant costs 12 new
findings, not the 25 previously claimed. Widening to docs costs 538 and
to missions 644.

The mission now records these as the numbers to plan against, and states
that the earlier figures came from a simulation and are superseded. The
ordering recommendation survives. The sizes do not.
The anchor linter measured 12 findings the terminator change would
surface on the gated tree. All 12 were inspected individually rather than
summarised, and two are genuine broken citations.

Both cited a BLUEPRINT section named The RFC Process while quoting the
RFC lifecycle text. No such heading exists in BLUEPRINT. The quoted
content lives under the heading RFC, Request for Comments, so both now
cite that.

That removes both entries from the baseline, which is the only baseline
change in this commit.

The other ten were examined and deliberately not touched.

Three Part 3 references are a prose line wrap, not a citation defect.
The anchor runs to end of line and is already correct, so the citation
needs no repair.

Five are over-capture rather than a missing heading. A swallowed quote
mark, a cross reference arrow, and a compound role reference.

Phantom Types and NodeType Gating Matrix have no heading by those names
anywhere, so those references are baselined debt rather than something to
silently rewrite.

Two mistakes of my own, recorded because both were caught by checking
rather than by reading.

I first edited a third file to expand a Part 3 citation, which caused a
blank line and a duplicated word, and then reverted it. The duplication
had been introduced by my own earlier replacement, not present in the
repository, so the file needed no change at all and now has none.

Because the baseline is keyed on name and site, editing any RFC shifts
every baselined reference below it and turns the linter red. That happened
twice here. The lesson is recorded rather than the churn: any edit to a
document with baseline entries needs a re-baseline in the same change,
and a bulk replacement over a file containing a Version History table
will also rewrite that table.
The mission filed two turns ago said 91 section references carry line
numbers. Re-measured with the tool rather than the ad hoc grep that
produced it, the true figure is 102 across 18 files, 100 in docs, 13 in
missions and 1 in rfcs.

The old grep required the reference to be a single alphabetic word plus a
number, so multi-word references were missed entirely. Real examples it
skipped include a Layer C and D reference and a Mission Decomp reference,
both of which carry a line number.

The per-file table in that mission was built from the same narrow regex
and has been regenerated from measurements. Every row is now a measured
value.

The mission also claimed the terminator change is what surfaced these,
counting 40 unmasked. Measured against the linter own functions it
unmasks 2, in docs and none in missions. The 40 came from the faulty
simulation, and was counted with a pattern requiring the whole name to end
in a number, which excluded any reference continuing past it.

The finding stands and is now reproducible. scripts/measure_anchor_lint.py
grows a --line-refs mode that reports these as their own diagnosis rather
than folding them into anchor resolution, where they would be reported as
missing headings and send a reader to add a heading that already exists.

Counting these now needs no simulation and no ad hoc grep. That was the
point of the mission and it is finally a check rather than a claim.
The widening mission carried a correction appended at the end while its
opening tables and frontmatter description still led with figures from
the faulty simulation. A reader arriving at the file would take the first
number they saw, which was the wrong one.

The tables are now marked superseded where they appear, and the
description leads with the measured figures instead. The reasoning and
the ordering recommendation are unchanged, so the entry is worth keeping
rather than deleting. Only its sizes were wrong.

Correcting my own correction along the way. The rewritten description
first said the costs were spread across 16 files in docs and 18 in
missions. The tool reports files scanned, which is 886 and 785, and the
files actually carrying findings are 163 and 216. Both figures were
guesses dressed as measurements. Measured properly, the description now
carries findings across files with findings, out of files scanned.

That is the same failure this mission exists to record, arriving again
inside the act of correcting it. The check is cheap and it caught it.
The anchor coverage gap mission led with figures from a hand-rolled copy
of the linters resolution loop and described them as produced by
importing the linter and calling its own functions. That was not what
happened, and the numbers were close but wrong.

Re-measured with scripts/measure_anchor_lint.py, which does import it.

- missions anchors were 3618 and are 3667
- CLAUDE.md showed 2 dangling and now shows 0, because its three broken
  pointers have been fixed and it is now scanned
- docs and missions dangling are 538 and 644, not 553 and 627

The coverage figure is 38 percent of 9881 in-scope references, leaving
6119 unexamined. I first wrote 35 percent in two places. Recomputing it
against the corrected totals gives 38, and 35 was never right.

The section describing the cost of the gap still described CLAUDE.md as
carrying two broken pointers. It carried three and all are now fixed, so
that section is rewritten as what the episode established rather than as a
current defect.

The passage explaining why the scanner figures differ now records both
disagreements in this repository rather than one. They resolved in
opposite directions. An independent scanner once over-reported because
it lacked the reverse-prefix rule. The simulation behind the widening
mission under-reported because it dropped the numeric-anchor gate and
replaced resolves with a membership test. Both are the same mistake,
reimplementing resolution logic instead of calling it.
The sibling scope missions counted section anchors with a loose grep for
a capitalised word followed by another word. That does not match what
the linter actually examines, so both missions carried anchor counts the
tool would not reproduce.

Re-counted with ANCHOR and is_section_anchor via
scripts/measure_anchor_lint.py.

- rfcs 3752, unchanged
- docs 2452 rather than 2417
- missions 3667 rather than 3953
- CLAUDE.md 10 rather than 6

Unexamined anchors outside the gated tree are 6119, not 6370. The
missions figure was previously the larger of the two errors and is now
the smaller.

The widening mission keeps its simulated tables because the reasoning
behind them is still useful, and each is now marked superseded where it
appears rather than only in an appendix. Its remaining prose sections
carried the same figures as current statements and are marked too.

No linter or gate changed. Every count in this thread now reproduces with
one command, and the two that were produced by a search the tool does not
perform are labelled as such.
The line reference mission listed building a check and gating on it as a
single acceptance criterion, and the tool that now performs the
measurement was added without anyone separating the two.

measure_anchor_lint.py with --line-refs finds the 102 references and
reports each with its file and line. It exits 0 always, because its other
modes describe the cost of a change rather than judge correctness, and a
tool that exits 0 on a corpus it knows contains violations would be
misleading in the other direction.

So the two are now separate criteria. Building the measurement is done.
Deciding whether it becomes a gate is not, and it should not be recorded
as though the first implies the second.

This distinction runs through the tool as a whole. Every mode measures
the anchor linter behaviour, and none of them is wired into CI. That is
deliberate for a tool whose output is used to decide what a change costs,
and it is stated in the module docstring rather than left for a reader to
infer from the absence of a workflow entry.
The linter required the Version History heading to be unnumbered. This
corpus also numbers its top level sections, so the same table appears as
a numbered heading in many documents, and those files were reported as
having no Version History at all.

Twelve of the eighteen findings in that class carried a fully populated
table under a numbered heading. The real number of Accepted RFCs with no
Version History section is 6, not 18, so the total is 39 rather than 51.

Measured across the whole tree before editing: allowing an optional
section number recognises 14 files and loses none. The number is optional
rather than required, so the change can only widen recognition.

Verified in both directions by mutation.

- adding a numbered Version History to a file that lacked one is now
  accepted, where it was previously reported
- deleting a populated numbered Version History is still reported

The mission is renamed and its figures corrected, including the per-file
lists, which now show the 6 real findings and name the 12 that were
misreported.

This is the second heading-shape blind spot in the same linter. The first
was a leading section sign. Both were cases of the pattern being written
against a bare heading name while the corpus writes a decorated one.
The linter counted a Version History as data only when it was a table
whose version column began with a bare digit. This corpus uses three
renderings and the check recognised one, so it reported populated
histories as empty.

- 28 files write the version column as v2.12 rather than 2.12
- 5 files write the whole history as bullets, either a bolded version and
  date or a date followed by a version

So the reported figure goes 39 to 6. Six Accepted RFCs genuinely have no
Version History section. That is the number the mission should have
carried from the start, and it is a quarter of what was first filed.

Three implementation notes, each found by testing rather than reading.

mawk on this system does not support interval quantifiers, so a date
pattern written that way matched nothing and turned the whole linter red.
Written with explicit repetition.

A single optional-bold optional-v alternative failed to match a bolded
bare version, which has no dot after it. Split into two alternatives.

The bullet rule is single-line only. A multi-line version with an
em-dash inside a bracket expression matched nothing at all.

Verified in both directions after each change. Adding a history in any
of the three renderings is accepted, and stripping the entries from a
populated one is still reported.

Also files a separate finding found while checking this: one RFC carries
two Version History tables that both claim version 2.12 with different
content, and a reader cannot tell which is authoritative.
The rule proposed in mission a-capitalized-word-after-a-section-name was
never measured, only argued. This adds a --qualifier mode that partitions the
two-word identifier-shaped names by verdict, calling the linters own
functions.

It calls resolves rather than reimplementing it, because the existing prefix
fallback added earlier in the session already handles the three-word case. Of
the unresolved names in the gated tree, 26 carry an identifier-shaped trailing
token and none of them is unresolved once the fallback is applied. The class
the rule actually addresses is the two-word one the fallback floors out of:
20 names on the gated tree, 15 in docs, 22 in missions.

The guard is not optional. Listing the items rather than counting them turned
up three classes a shape-only rule rescues wrongly:

  - Top K and The V2, where the head is a bare common word and trimming it
    produces a resolution against nothing that means anything. This is the
    laundering the originating mission warned about, reached by a different
    route than the one it described.
  - Ten L### tails, which are CLAUDE.md convention violations rather than
    qualifiers. Accepting them deletes the only signal they have, since the
    line-ref measurement is not wired into CI.
  - One over-capture containing a closing paren, whose real defect is the
    extraction boundary.

So the rule as shipped carries three exclusions, each with its reason inline.

Measured rather than assumed, the rule cannot turn CI red: gated findings go
from 588 to 523 and the count that would fail the gate stays at zero before
and after. It rescues 20 baselined names and makes 65 baseline entries
stale, which is inert since the gate only tests findings minus baseline.
The identifier-qualifier rule was argued for in two missions and never
measured. Measuring it against the linters own functions, rather than a copy
of the loop, changes the ordering.

On the gated tree the class the rule was proposed to handle is already fully
resolved by the prefix fallback added earlier in the session. Of 394
unresolved names, 26 carry an identifier-shaped trailing token and none of
them survives the existing fallback. The two-word case the fallback floors out
of is the whole population, and it is 20 names.

Listing those 20 rather than counting them is what produced the finding. Three
classes are rescued wrongly and a shape-only rule cannot tell them apart from
the genuine ones:

  - Top K and The V2, where the head is a bare common word. This is the
    laundering the originating mission warned against, reached by a different
    route than the one it considered.
  - Ten L### tails, which are CLAUDE.md convention violations. Accepting them
    removes the only signal, since the line-ref measurement is not wired.
  - One over-capture whose real defect is the extraction boundary.

So the rule as shipped carries three exclusions, each with its reason inline.

Measured rather than assumed, it cannot turn CI red. Gated findings go from
588 to 523 and the count that would fail the gate stays at zero before and
after.

The dominant class of unresolved name is over-capture, where the extraction
boundary ran past the end of the reference. Ninety-eight names in rfcs against
twenty for the qualifier rule. The terminator change is the prerequisite, not
the qualifier rule, and it was already measured at twelve new findings.

The superseded mission is archived rather than deleted, and its frontmatter
claim that the ordering still stands is corrected where it appears rather than
only in a banner.

Separately, an edit against that mission failed to match text the reader could
see, and cat -A showed why. Its description was an unterminated quoted scalar,
which in YAML swallows every following key. A corpus scan found 33 such
documents, including an Accepted RFC.

Three linters read frontmatter for status and version fields and all three use
awk line matching, so none of them can observe that a document is unparseable.
Checked rather than assumed: their patterns read a single field and survive all
three observed causes, so the 33 are latent rather than active misreports.

Two are repaired here, one of them authored earlier in the session that found
the class. scripts/lint_frontmatter.py makes the figure reproducible, names the
cause rather than reporting one invalid bucket, exits 2 when it examines
nothing, and was proved to detect a real defect. The first mutation attempt
did not move the count because it stripped a quote from an unquoted scalar and
changed nothing.
The first version of scripts/lint_frontmatter.py classified each failure from
the loader's message text. It reported 29 unquoted values, 3 alias errors and
1 reserved indicator.

The 3 were wrong and so was the accounting around them. Five documents are
misfenced, and a misplaced fence produces whatever symptom the first body
character happens to cause, so the loader described four of them as alias
errors about a leading double asterisk and one as an unquoted value. Checking
each of the five against its fence positions showed every one swallows one to
nine lines of prose beginning with a retro-supersession marker.

The cause split is 27, 5 and 1. The total stayed at 33 throughout, which is
what makes this the worst kind of measurement error to catch: every
arithmetic cross-check passed while the composition was wrong. What exposed it
was printing one document per line and noticing that the reported error line
was a line of prose rather than a line of metadata.

The replacement test is structural. A column-zero line that is neither a key
nor a list item is body text, and a block containing one is misfenced. The
first structural attempt used a blank line followed by a top-level line and
over-matched by two, because that is ordinary YAML.

Also recorded in the mission, alongside the corrected table: the five
misfenced documents carry a colon-space in their own descriptions as well, so
moving the fence is necessary and not sufficient for any of them.
The corpus now parses end to end. scripts/lint_frontmatter.py reports 243 of
243 documents with frontmatter accepted by a YAML loader and 0 failures, down
from 33.

Repairs by shape rather than one rule applied to everything:

  - 28 plain scalars quoted. An unquoted value cannot contain a colon-space
    without the loader reading a nested mapping.
  - 5 closing fences moved up. Each had been placed one to nine lines after the
    metadata, swallowing a retro-supersession paragraph.
  - 1 author line in RFC-0907 quoted, since a bare at-sign is a reserved
    indicator.

A shape the classifier had folded into the unquoted-value bucket surfaced during
the repair and is fixed in the same pass. In 0855p-b-state-machine-types a list
item carried a quoted scalar followed by a trailing parenthetical, and a quoted
YAML scalar cannot be followed by anything. The parenthetical was folded into
the string rather than deleted, so nothing is lost.

Content preservation is verified rather than assumed. Every non-fence line of
all 33 files was compared against HEAD with YAML quoting neutralised, and all 33
are character-identical. Prettier then rewrote seven of them to prefer single
quotes, which is its own YAML style choice and was re-verified after.

The check that matters most is the one about the readers this finding is
about. Both guards that read frontmatter for status and version produce output
that is byte-identical before and after the repair. That is the predicted
result and it is what distinguishes this from a silent behaviour change.

Two guards, lint_status_vh_sync and lint_plan_yaml_vh_sync, exit 1. Both were
already exiting 1 before these changes. The corpus-wide comparison above is
what establishes that rather than an assumption.

A first repair attempt was reverted. It placed the relocated fence one line
after the prose instead of before it, an off-by-one in index arithmetic that
produced files which still failed to parse. The second attempt asserts the
opening fence is at line one before writing, and that assertion fired on its
own off-by-one before touching anything.

Still open and left for a maintainer: whether the new gate is wired into CI.
The corpus is clean, so it would land green, but CI files are owner policy.
The guard reported 135 documents as having a Version History with no data
rows. Every one of the 135 had data rows. It was reading a rendering the
corpus does not use, and a summary line made that look like one healthy
number.

Five reader defects, each measured rather than assumed:

  - vh_line_num matched only a bare heading, so a numbered or section-signed
    Version History left it empty and sent the per-file loop into its continue
    before any comparison. Those files were never examined. A guard printing
    nothing is indistinguishable from a guard verifying everything, which is
    the same defect as the empty-corpus check already at the foot of this
    script.
  - the row scan required a space and pipe immediately after the version, so
    every column-aligned table read as empty.
  - the row scan required a dot in the version, so a bare integer or a
    v-prefixed integer read as empty.
  - only table rows counted, so 27 bullet-rendered histories read as empty.
  - versions were compared as strings, so 2.14 and 2.14.0 read as different.

After the fix, NO_VH is 0 and IN_SYNC rises from 15 to 33. The single
out-of-sync finding is now genuine rather than a false one: RFC-0855p-c
declares version 1.0.0 against a history whose latest row is 0.1.4, which was
invisible because its section heading is numbered.

Has-no-rows and has-no-version-column are now separate questions, reported as
a new informational class rather than conflated.

Mutation-tested in both directions, because a relaxed pattern can make a guard
too permissive. Bumping a version on an in-sync document raises
OUT_OF_SYNC. Emptying a Version History table raises NO_VH_ROWS. Restoring
returns both to silent.

One bug was mine and is worth recording. The version-normalising helper
aborted under set -u on exactly the two-component versions it existed to
handle, because the suffix-strip form trips unbound variable on an unset
element and this script runs set -euo pipefail. It passed a standalone test
because that test did not have set -u active, and it surfaced only under
bash -x.

Separately, the six Accepted RFCs missing a Version History are now compliant
and the guard exits 0. Four were renamed from an ambiguous History heading
that already held dated revision history, which is conformance rather than
authorship. Two gained a reconstructed section built from commit history,
which is not, and that mission now says so and asks for author review.
All six Dependency Validation pins are behind the companion's own Status
header, RFC-0963 by three versions. M37 synced five of six companions and
never reached RFC-0960, the one document that records their versions. The
hard-block markers stay correct, so this is bookkeeping rather than a gate
failure.

Also sharpens the RFC-0959 row: its version is present in the document but
buried in a prose Note, not the Status header.
Six threats carry sixteen named mechanisms. Six hold. Nine of the ten that
fail reduce to one missing thing: there is no constraint evaluator anywhere,
so Threat 2 claims an ordering guarantee about a verifier that does not
exist, Threat 6 binds via an encoding nothing applies, and Threat 1 tracks
no redemption count at all. Threat 5 describes privacy levels with no type
to carry them.

Threat 4 is the best built of the six and is corrected in my draft:
MultiEnvelope is fully implemented and has zero consumers, which is the
Marketplace reachability caveat again rather than an absence.

Records five measurement errors of my own, including the head truncation
that made me call MultiEnvelope absent.
The one genuinely open question in the document is resolved honestly. The
hierarchical vault policy lattice is built in all three cited legs, and the
section explains its own earlier deferral as a review note rather than
hiding it. All six companion citations resolve.

Two defects survive. The WrappedOnly leg is cited as RFC-0965 section 3.5,
which is AuditWindow, and WrappedOnly is section 3.7. That citation is well
formed, so no shape-based linter can catch it, which distinguishes it from
the recorded wrong-document gap. And RFC-0960 and RFC-0964 both say the
Constraint set has 23 variants while RFC-0964 own table enumerates 25 and
the code declares 25. Only the prose is stale.
The LANDED table names four files. All four exist, and all four of v013
structural claims hold exactly, including the absent parent_vault_id lock
which is annotated with its reason. That makes it the most accurate file
level list in a document whose Key Files section names eleven paths of
which ten do not exist.

Two claims inside it fail. v014 describes from_vault_id and to_vault_id as
foreign key references and the migration has no REFERENCES clause, while
other migrations in the repo do use them. And the 108 fixture vault_id
matrix is called byte exact when its anti drift guard compares the
derivation against itself.

Proved the second by mutation. Changing the BLAKE3 domain separator left
the guard passing while a different test in the same file failed, which
corrected my assumption that the file had no pinned vectors. It has ten.
Mutations reverted.
The existing mission called the slash ledger substrate sound. That holds
at the storage layer, which I re-verified end to end, but not for the in
memory mirror block the RFC presents as backing the slashing model. It
specifies seven fields with an integer loss column. ProviderStake has six
and the loss column is f64, which is the field the RFC argued must be
integer to avoid round trip ambiguity.

Testing the whole domain rather than the one boundary the RFC names shows
the f64 is harmless. Over zero to one million micro values there are zero
false bans, zero missed bans and zero round trip losses. So this is a
documentation and typing defect, not a correctness one, and the mission
now says so instead of leaving the type mismatch to imply a live bug.
CLAUDE.md mandates mermaid and tells authors to convert existing ASCII
diagrams. The convention was adopted, 69 of 157 accepted RFCs contain
mermaid blocks. Nothing measures it, and the 9 suite local battery contains
no diagram check. So 32 accepted RFCs still carry 696 lines of box drawing
diagrams and 18 documents use both conventions in the same file. RFC-0900
has 3 mermaid blocks and 10 ASCII lines.

Verified the absence by reading the battery rather than searching for it.
The finding also argues against a blanket check, since byte layout boxes in
the numeric RFCs are a case mermaid cannot express and converting them
would be a downgrade.
Section Specification defines QuotaListing, QuotaPurchase and QuotaRouter
plus listQuota, purchaseQuota and routePrompt. The three types have no
implementation and the three functions appear nowhere. The implemented
facade is Ask shaped instead.

RouterConfig is the dangerous one. A real struct by that name exists at
forty call sites, belongs to RFC-0927, whose mission is archived, and shares
zero fields with RFC-0900 seven. A reader who greps the name finds real work
and concludes the section shipped.

Security and Privacy also promises no central storage fifteen lines above a
subsection specifying SQL migrations and a Stoolap fork driver, with four
crates carrying schemas. Credit where due: the prompt privacy row is an
honest trust assumption disclosure and both reference paths exist.
I filed the RFC-0900 specification sweep without reading section Version
History, and it was nine lines above what I measured. Version 1.1 already
declared the TypeScript interfaces a wire shape reference with the Rust
impl canonical, so the absent listing types and functions are declared
rather than defective. That reading is withdrawn.

The RouterConfig half survives and sharpens. Under the RFC's own precedence
rule, the one specified interface with a Rust counterpart is RouterConfig,
and that counterpart implements RFC-0927 with zero field overlap. So the
document that promised Rust is canonical points at another RFC type, and
RFC-0900 marketplace routing config has no canonical representation at all.

All symbol counts and reproduction commands are unchanged. Only the
interpretation was wrong.
Read the whole document before filing this time, which mattered. Section
Version History v1.1 already discloses that phases 2 through 4 remain future
work and that phase 1 shipped as task_market. So the absence of dynamic
pricing, worker selection and rewards is declared, not defective.

Phase 1 is real though. All five checked items verify, and the phase table
agrees exactly with the history row. But task_market has zero production
callers, only its module declaration and a test file. It wraps the already
unreachable marketplace in a second unreachable module. The reachability
mission is amended to v1.1 rather than duplicated.

Its related RFCs section is the outlier. Three of four entries are wrong.
RFC-0124 is cited under two different invented titles in one file and the
real RFC-0124 declares that it supersedes itself. RFC-0140 was renumbered
to RFC-0740 and two accepted RFCs cite the dead number.
TokenAmount appears 111 times across 13 RFC documents and is defined in
none of them. No struct, no enum, no type alias, no prose definition, and
zero occurrences anywhere in the tree. Three of the thirteen are Accepted,
with 22 uses in RFC-0918, 21 in RFC-0955 and 7 in RFC-0630.

The corpus already settled this question once. RFC-0105 is Accepted and
names pricing as a primary domain for its scaled integer DQA, which is
implemented at determin/src/dqa.rs with eight missions behind it. RFC-0105
never mentions TokenAmount, so the parallel was never recorded as a
decision. It is a no parallel abstractions violation arriving through
thirteen documents instead of one.

RFC-0918 uses TokenAmount in 21 f64 computations, which is the ambiguity
DQA exists to remove, and its supply demand ratio returns f64 MAX as a
supply exhausted guard. Phases 2 through 4 are declared future work, so
this is an unmade decision with a written downstream consequence rather
than a defect today.
RFC-0955 calls RFC-0955-R1 a sibling Draft at a rfcs/draft path five times.
Neither is true. R1 sits under rfcs/accepted and its own Status header reads
Accepted with the dependency gate satisfied. The two documents cite each
other as evidence for the same fact, which is circular.

Phase 5 presents six unchecked boxes as an acceptance gate on R1 promotion.
That promotion has happened, and five of the six conditions hold anyway, so
the gate is not gating. One named file, the test vectors blob, is genuinely
absent.

R1 also contradicts itself. Its Status says Accepted, its Version History
still labels its only row 1.0-draft. lint_no_vh_accepted.sh passes all of
this because it checks a Version History table exists and never compares it
against the Status. Three recorded missions cover adjacent gaps and none
covers this one.

Also measured the f64 share invariant exhaustively. 204 of 4851 three way
percent compositions do not sum to exactly 1.0, and the RFC own example is
one of the ones that happen to pass.
I asked whether the version label disagreeing with the Status header is
corpus wide, which would have made it a tooling matter. It is not. Of 148
Accepted RFCs detected, exactly one has no non-draft version row at all,
and that is RFC-0955-R1. RFC-0955 is internally consistent on its own
labels.

The first version of that measurement was wrong. Taking the last Version
History row as the newest flagged three documents, but RFC-0012-v3 and
RFC-0014-v3 run their tables newest first, so a historical draft row
landed last and looked current. Both are correct. The robust test asks
whether any row carries a non-draft label, which does not depend on
position.

That episode is recorded as a caution for whoever writes the lint. Tables
in this corpus are ordered inconsistently, so a check for this has to be
absence based rather than position based.
lint_no_vh_accepted.sh requires a Version History table in every Accepted RFC
and checks only that it exists. M37 satisfied it by adding tables to RFCs that
lacked them. Nine Accepted RFCs now have a Version History whose single row
reads Retroactive VH table addition, six more carry it as a second row, and
one has it appended to a real history.

M37 turns out to do two disjoint jobs across 23 files. This corrects my
earlier read of it as a five-file status sync, so the companion-pins mission is
amended to v1.1. RFC-0960 is in neither set, which confirms that finding on a
wider measurement.

The credit matters here. The rows say they are retroactive rather than
inventing a plausible history, which is the honest choice and matches how the
resolved six-document repair was done. The gap is that an honest placeholder
and a real history are indistinguishable to every tool in the tree.
RFC-0630 names thirteen types and implements none. All thirteen phase boxes
are unchecked and accurate, which is worth saying because most of the corpus
is not honest about this.

The finding is that three of its names are already taken by unrelated
definitions. ProofBundle exists four times, three carrying only proof bytes
and the fourth adding CASM metadata, where RFC-0630 wants a layer proofs
tree rolled into a batch proof with a verification flag. RewardDistribution
exists as a PoRelay enum discriminant rather than a payout struct.
InferenceTask is defined in RFC-0630 and used unattributed in RFC-0918.

That generalizes the RouterConfig collision recorded for RFC-0900. In a
Rust workspace an unimplemented RFC type name is not an empty namespace, and
the more load bearing the RFC the likelier something claimed it first.

RFC-0630 is also the third TokenAmount user and the first that would need a
real answer at implementation time, since it uses the type as a struct field
in a consensus critical payout structure rather than in future work
pseudocode.
missions/archived/0934-a is archived as complete and checks off six
properties of RFC-0934 budget enforcement. Five are not in the code. The
atomic UPDATE has no guard clause so nothing is checked. check_budget holds
no SQL at all, being a Rust read then compare. reset_budget has zero
callers. query_optional, the API the mission claims to use, exists nowhere
in the workspace. And there is no send_alert, so the webhook is a column
nobody posts to.

The more serious one is not among the six. update_spend has no production
caller, so no request records spend and the proxy budget check compares a
value live traffic never advances. It fails toward under billing, which is
why nothing flagged it.

RFC-0934 is the careful document here, which is what made the claims
checkable. It names its own TOCTOU risk twice in bold, discloses its one
budget per entity limitation and its 30 day month drift. The archived
mission was not edited.
The no-line-refs check had only ever been run over files this audit
touches. Run across the tree it returns 10695 instances in 326 files,
so the standing zero was a scoped result being quoted as a total.

Twelve instances sat in live missions written during this audit, in two
forms. Quoted panic transcripts and source excerpts carried line numbers
because they are verbatim program output, so they keep their paths and
now say that line and column are elided under the rule. One call-site
table used line numbers as identifiers, which was a choice rather than a
quote, and is now keyed by symbol instead.

Two claimed missions still hold one instance each and were not authored
here, so they are left for their owners.
Seventh sweep of a self-describing structure in an accepted economics
RFC, and the one that settles the pattern. Everything in RFC-0910 that
describes executed behaviour is correct and was checked by running it.
Everything describing intended behaviour is wrong.

Four Key Files rows and none resolves. Two RFC rows point at rfcs/draft
when both documents were promoted. Two code rows point into
crates/quota-router, which is not in the workspace. The same document
already names quota-router-core correctly in its Test Vectors note, so
one section tracked the crate split and the section below it did not.
There is no tokenizer.rs anywhere, so the fourth row names a module
split that never happened.

Phase 1 is recorded as not implemented by two checklists in a document
that ticks all ten of its components immediately above the box denying
it, and whose archive mission closed it on 2026-04-27. The RFC was then
revised twice and neither revision ticked it. The denial is false by
execution. 32 tests pass, including the RFC's own pricing hash vector.

get_canonical_tokenizer is described three ways, by the RFC, by the
archived mission, and by the code, and no two agree. The RFC also
contradicts itself, calling the function prefix-free in one section and
prefix-only in four others. The fallback branch has no test at all, which
a mutation proved by breaking one arm and leaving the suite green.

The Phase 1 to 2 migration note matters most. It calls exact-match-only
Phase 2 a data entry task of 15 to 20 rows. The table has 26, and an
exact-match table cannot reproduce an unbounded prefix fallback. By
execution only the o-series diverges, returning o200k today and
cl100k_base afterwards, which is a different token count and therefore a
different cost on the newest model family.
RFC-0909 sits in rfcs/final, which the blueprint defines as Implemented
and stable, and that tier holds exactly two economics RFCs. Its final
revision did the opposite. The v69 changelog records that it reclassified
the cross-router token_source requirement from MUST to SHOULD, and every
section added for that purpose is present and correctly worded. Three
passages the reclassification was meant to reach were not edited,
including invariant 6, which still reads MUST under a heading stating
that these invariants MUST hold at all times.

The document now states its central claim six ways at three strengths.
Two entries deny outright what four others assert, and both denials were
added by the same revision that left the assertions standing.

The vectors are sound. All four were executed and match, and the v67
normalization requirement is implemented and tested. What they cannot do
is isolate token_source, because TV2 varies request_id in the same row.
So the one input whose agreement was downgraded is the one input the
table cannot demonstrate, and the Token Source Divergence Handling
section rests on exactly that claim. Measured directly, changing only
token_source on TV1 inputs yields an event_id present in none of the four
published vectors.

Also recorded: a stale Draft label for RFC-0910, the only one in the
whole accepted and final corpus, a wrong path for the RFC-0903-B1
amendment, and a dependency rationale crediting RFC-0126 with JSON
canonicalization for a path the same RFC forbids JSON on.
All three pre-call checks exist and all thirteen of their tests pass,
including the two rejection cases the Test Plan names. Production
constructs exactly one of them. TagFilterCheck and HealthCheck have no
construction site anywhere outside their own module, so no HTTP health
probe is ever issued and no tag is ever filtered.

Three independent conditions each prevent the tag check from rejecting
anything. It is never constructed, request tags are hardcoded empty at
the one production site, and the deployment tag lists are hardcoded
empty at that same site. Any one would suffice.

The tests pass because the fixture builds DeploymentInfo a second way,
taking allowed and blocked as parameters. The suite covers the logic
honestly and the production path cannot reach it, which makes this a
missing wiring rather than missing logic.

The trait that makes the checks extensible is never named outside its
own module and no trait object exists anywhere. Production calls an
inherent method the RFC never describes, on a concrete type, so the
pipeline is closed to further implementations. The router integration
is absent entirely and the configuration toggle does not exist, leaving
a Cargo feature as the only gate.

The production site was initially assumed to be test code, since it
sits below a cfg(test) module and is indented as though inside it. That
was settled by compiling a probe error at the site without cfg(test),
which failed, proving the site is production. Had the assumption stood,
every finding here would have inverted.
DeterministicEnvelope::verify gained an explicit algorithm parameter in
ac31b1f, which widened 38 key parameters and moved envelope
verification to a second algorithm. Every adapter that verifies an
inbound envelope was updated to name its algorithm, except this one.
The crate is excluded from the main workspace so the workspace check
never reached it, and the clippy step in the lint workflow swallows its
exit code, so nothing local caught it. Only the two telegram steps in
the CI workflow compile this crate, and both were failing with E0061.

The adapter already names the algorithm in its own comment, which says
to verify the Ed25519 signature when a verifying key is configured, and
the field holding that key is already called verifying_key. So this is a
mechanical fix matching every sibling adapter rather than a decision
about which scheme applies.

Adds the octo-algo-ed25519 path dependency with a comment recording
why the algorithm is passed explicitly, and names the Ed25519 id at the
call site. The surrounding error handling is untouched.

Verified against the exact commands the CI workflow runs. The check and
the clippy pass both exit zero. The adapters own envelope tests cannot
be executed locally because a standalone build resolves against crates
io where every zip 8 release is yanked, which is pre-existing and
reproduces with this change reverted, so the fix is compile and lint
verified rather than behaviour verified.
The cross language verifier looks for the CLI under the member
directory, at cli/target/release and then cli/target/debug. Cargo never
writes there. Cargo writes to the workspace root target directory, and
determin is its own workspace with members equal to cli, and is excluded
from the repository workspace, so the binary lands in determin/target.

Both verifier scripts had the stale path. What hid it was a build
artifact committed under determin/cli/target/release, produced back when
determin/cli was a standalone package rather than a workspace member.
Removing those committed artifacts, which the branch now does, exposed
the path and the cross language verifier failed all one thousand tests
with the binary reported missing.

Asking cargo for the target directory removes the assumption rather
than restating it, so moving the workspace again cannot reintroduce it.

Verified by execution. verifier.py at the count the CI step uses reports
one thousand passed and zero failed, which the previous path could not
reach at all.
CI went red on six workflows for a reason no code change reaches. Every
cairo-vm version, which the cairo stack this repository vendors depends
on non optionally, requires zip 0.6.6 or later within the 0.6 line. All
seven releases of that line, 0.6.0 through 0.6.6, have been yanked from
crates.io, so there is no version left to select. The lockfile was
gitignored, so every checkout performed a fresh resolve and the resolve
could not complete.

A lockfile that already pins a yanked version keeps building. Cargo
refuses to select a yanked version, it does not invalidate one that is
already locked. That is why this works locally and did not on a runner.

Verified in a pristine clone. Without the lockfile the resolve fails
with the yank error, matching the runner logs exactly. With it, both a
locked and an unlocked resolve succeed.

Only the root lockfile is un ignored. The sub workspace lockfiles stay
ignored, since the failing builds are the root workspace ones.

Patching crates io was considered and is not available. The index entry
for zip 0.6.6 records no repository, and the upstream project has no tag
for that release, so there is no git source for a patch to point at.
The Python SDK workflow builds its wheel with maturin, which resolves
quota-router-pyo3 as a standalone workspace. That crate is excluded from
the repository workspace on purpose, since its full feature pulls pyo3
into feature unification and breaks linking for other members, so it
never sees the root lockfile. Its own lockfile was ignored as well. The
build therefore performed the same fresh resolve the root build was
doing and failed on the same yanked zip release.

Verified by resolution rather than inspection. Cargo metadata inside
that crate exits zero once the lockfile is present.

This is the only excluded crate any workflow builds, so the root lock
and this one are the complete set. The remaining sub-workspace
lockfiles stay ignored.
The wheel build failed to compile octo-cap-macaroon because Dqa does not
implement Borsh in the copy of octo-determin it compiled against.

The cause is a floating self-referential dependency. Eleven crates declare
octo-determin as a git dependency on this repository's own next branch.
The pyo3 crate is excluded from the workspace, so it never picks up the
workspace patch that redirects that dependency to the local path, and it
resolves the git form against whatever its lockfile pins. The lockfile
pinned revision dfab8f2, which predates the Borsh implementations. The
branch name never floats on its own, because a lockfile holds the pin
until the lockfile is regenerated, so the staleness was invisible.

The lockfile diff shows the old revision did not list borsh as a
dependency at all, which is what the missing implementations imply.

Refreshing that one package moves the pin to the current head.
Building with the exact feature set the wheel job uses now succeeds.
The coverage job was losing the hosted runner. GitHub annotation on the
failed run reads that the runner lost communication with the server, and
that anything which starves it for CPU or memory can cause this. The
Generate coverage step ran sixty four minutes, produced no log output,
and never recorded a step conclusion.

The job is structurally several times over the runner budget rather
than marginally over. It instruments and relinks the whole workspace
and then does a second full instrumented build for quota-router-core.
That is about ninety seven crates, ten thousand eight hundred and
eleven test functions and five hundred and sixty five thousand lines,
with matrix-sdk still inside the scope.

Two changes, neither of which alters which lines are covered.

Debug info drops to line tables through CARGO_PROFILE_TEST_DEBUG.
Coverage needs line mappings, not the full debuginfo payload, and full
debuginfo is the dominant consumer of both build disk and link time
RAM. The build workflow already disables debug info for that reason.

Parallelism is bounded on both axes. The -j flag caps concurrent
rustc and link processes, and test-threads caps concurrent test
threads. Peak RSS scales with both. This trades wall clock for fitting
in the runner.

Verified by running the exact combination locally against a small
crate, where tests execute and a coverage report is produced.
actionlint passes, which is the gate the lint workflow applies here.

Deliberately not taking the other options yet. Sharding across runners
or narrowing the measured set would both help more, but both change
what the number means or what the job costs, which is an owner
decision. This change only makes the existing measurement survivable.
The memory caps in the previous commit were the cheap half. This does
the other two things, which together are the real fix. Split the job
across runners, and stop measuring the parts of the tree where coverage
was never informative.

Sharding. Eight shards, chosen so the heaviest is about a sixth of the
monolith. quota-router-core, octo-network and octo-cli each get their own
shard because any one of them alone is large. The crates that pull very
large external dependency trees are isolated too, so only the shard that
needs matrix-sdk or telethon pays to build it.

Narrowing. Thirty six crates are dropped, about 161k LOC and 2,373
tests. Layer D transport adapters go, because coverage of protocol
binding glue is high cost and low signal. The whatsapp group goes
because its link step already OOMs the runner, and it is now a named
group rather than a per-crate note because the two onboarding crates
depend on the excluded adapter and would silently drag that same tree
back into a shard. This narrows what is measured, not what is built, so
a kept crate that dev-depends on an excluded one still builds it.

Single pass. The old summary step invoked cargo llvm-cov a second time
purely to emit JSON, so the suite executed four times per job across the
two coverage passes and the two summary passes. Each shard now emits
lcov and JSON from one run, with the report subcommand building JSON
from the profiles already on disk.

Verified rather than assumed. Every shard compiles under the exact flags
it will run with, checked one at a time. The report subcommand was run
against a real crate to confirm it reuses profiles instead of executing
tests again. The merge and threshold path was run end to end on
synthetic shard reports and reproduces 382 of 454 as 84.1 percent.
actionlint passes.
Quota Router failed on the first push of this branch with the same
yanked zip error that took out six other workflows, and I did not follow
it up. It then stopped appearing in run listings, which read as fixed.
It was not fixed.

The workflow is path filtered to quota-router and octo-transport, so
once my later commits touched neither, it simply stopped running. The
defect was still live underneath.

quota-router is excluded from the workspace, so it resolves standalone
and never sees the root lockfile added earlier. Its own lockfile was
ignored as well. Verified by moving the lockfile aside and resolving,
which reproduces the exact yank failure, then restoring it and
resolving again, which succeeds.

Tracking this lockfile matches the workflow path filter, so the push
that carries it runs the job and verifies the fix instead of assuming
it.

The other excluded workspaces were checked rather than assumed.
determin, octo-transport, sync-e2e-tests, octo-telegram-onboard and
octo-telegram-onboard-core carry no cairo-lang-executable entry in
their lockfiles, and zk-vendor/stwo-sys is only ever built as a path
dependency of zk-circuit inside the root workspace, so those stay
ignored.
The lockfile added in the previous commit fixed the yanked zip resolve.
The workflow then compiled far enough to reach a second failure: Dqa
does not implement Borsh in the copy of octo-determin this workspace
compiled against.

Identical to the failure already fixed for the Python SDK crate, and
for the same reason. That lockfile pinned octo-determin to revision
8781f2e, which predates the Borsh implementations. The revision does
not list borsh as a dependency at all, which the refreshed lockfile
shows directly by gaining blake3 and borsh entries.

Moving the pin to the current head.

Verified with the exact commands the workflow runs rather than a
nearby substitute. Clippy with all targets, all features and warnings
denied exits zero, the format check exits zero, and a full all-targets
check exits zero.
@mmacedoeu
mmacedoeu merged commit 3948f94 into main Oct 17, 2026
101 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant