Repository navigation
Conversation
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.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Sync
nextintomainPromotes the
nextintegration lane intomain.Relationship
mainis a strict ancestor ofnext, so this is a fast-forward with noconflicts and no merge resolution:
mainbc1c7820nextcd5afbd1nextnot onmainmainnot onnextThe 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
nextis not deleted by this PR and must not be deleted. It stays as theintegration lane. No auto-merge or cleanup automation is configured against it:
sync-next.ymlautomerges withmerge-method: mergeand does not setdelete-branch.CI state at
cd5afbd1All ten workflows triggered by a push to
nextare 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
mainper its own triggers; the signal thatmatters 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
nextfrom seven failing workflows to green:b8a9b14dtelegram-cli did not compile.DeterministicEnvelope::verifygained an explicit algorithm parameter in
ac31b1fe; this caller was neverupdated, and the crate is excluded from the main workspace so the workspace
check never reached it.
acbd85e5the cross-language verifier looked for the CLI under themember directory; cargo writes to the workspace target directory. A stale
committed binary was masking it.
02d64b12,d6c9e2dd,c9ea2662,cb754760,cd5afbd1the lockfile was gitignored, so every CI checkout resolved from scratch, and
zip0.6.x has been yanked from crates.io in its entirety.cairo-vmrequires it non-optionally in every version. Three workspaces were affected
(root,
quota-router-pyo3,quota-router); the latter two are excluded fromthe workspace and so needed their own lockfiles and their own dependency-pin
refresh.
fc5ff61b,7873eee2the coverage job was losing the hosted runner tomemory 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.