Repository navigation
fix: post-#1701 follow-up batch (9 issues) - #1824
Merged
Merged
Conversation
`cyclomatic`, `cognitive` and `nexits` reported an `average` / `min` /
`max` triple drawn from two populations: the divisor counted function
spaces (`function_spaces` for cyclomatic, `nom.total()` for the other
two, which also counts spaceless closures such as Python lambdas) while
the numerator and the extrema folded every space's own value, the file
unit and containers included. `fn f() {}` reported cyclomatic
`average 2.0` against `min 1, max 1`; a Python function holding one
lambda reported cognitive `average 7.0` against `min 14, max 14`; and
the unit's own 0 pinned file-level cognitive `min` at 0 on nearly every
file. 3 499 spaces in DeepSpeech, 400 in pdf.js and 392 in serde had an
average outside `[min, max]`.
All three now fold numerator, divisor and extrema from one predicate —
the space's recorded `kind == SpaceKind::Function`, read once in the
walk's `compute_minmax` and handed to each metric — and merge the new
function-only accumulators up through containers. The published
all-space `sum` is unchanged (it is what MI and WMC read), and every
`sum` / `value` across the three corpora is byte-identical before and
after. A subtree with no function space reports `0.0 / 0 / 0`. The
cyclomatic divisor seed moves out of `FuncSpace::new` into the same
fold, so one site decides membership for all three statistics;
`compute_averages` no longer feeds `nom.total()` to cognitive / nexits.
The `Cognitive | Nexits => [Nom]` dependency is kept so a selection
naming either still emits the same blocks.
The book gains an "Aggregate population" section the cognitive,
cyclomatic and nexits chapters link to; the accessor docs, the
`average` helper's convention note, and the Python stub's dependency
text say which spaces the three fields read. Snapshots move on
`average` / `min` / `max` only: 117 in-tree, 1 636 in the integration
submodule (bumped to 234c55bd, pushed), three CSV rows, three web
fixtures; `.role-coverage-observed.txt` is refreshed for the gitlink.
`function_population_tests.rs` pins the issue's three reproducers and
the Python / Rust / C / Java / Kotlin / JavaScript fixtures where the old
divisor and the new population differ (spaceless lambdas, and
`Function` spaces `nom` never counted: `static {}`, accessors, `init`),
each with its value on `main` beside the derivation, plus an invariant
sweep over eleven languages re-deriving mean / min / max from the tree.
Every production line is verified by perturbation; `nargs`' two-channel
form of the same defect is #1809.
Fixes #1284
…break N The Cognitive Complexity white paper (v1.7, "Ignore shorthand", p. 6) ignores null-coalescing operators as a one-line spelling of `if (x == null) …`. Cognitive now does too: `??` and `??=` in the JS family, C# and PHP, Elvis `?:` in Kotlin and Groovy, and Perl's defined-or `//` / `//=` no longer fold into the boolean sequence. Cyclomatic keeps paying each as a decision (#230's choice stands there), and `&&=` / `||=` keep scoring where a shared arm or classifier spelled all three. Safe navigation (`?.`, `&.`, `?->`, `??.`, `?[`) was never read by cognitive; one fixture per language now pins that at 0, anchored on cyclomatic so a plain access cannot pass. PHP's `break N` / `continue N` is B1's `break NUMBER` / `continue NUMBER` and pays a flat +1 for any explicit argument — `break 1;` included, as sonar-php increments on `tree.argument() != null` — in place of the +0 #435 chose. The gate is a named, non-comment child of the jump, not the `integer` kind, since the grammar admits any expression there. Every pinned test is re-derived with the paper section it follows and reads cyclomatic as proof the ignored operator is still in its fixture. The module header of `cognitive.rs` states the policy once; the `NullSafe` row comments drop the consumer sentence that stated the old one, per `.claude/rules/macro-comments.md`. The book's cognitive chapter now says the operators are ignored, lists Ruby's `redo` / `retry` under the deviations, and removes `break N` from them. 32 integration snapshots move, cognitive fields only (submodule d411e605); `.role-coverage-observed.txt` is refreshed for the gitlink. Fixes #1800 Fixes #1765
The `DocTarget` rows in `roles/typescript.rs` and `roles/tsx.rs` own the four parameter kinds through the shared `js_family_doc_targets!` fragment but expose no parameter-only subset; tsc's after-code rule applies to parameters and to nothing else in the row, so the Checker in `checker/typescript.rs` and `checker/tsx.rs` carries that subset under a `// role-bypass: allow(DocTarget)` exemption. Decision (b): keep the exemption, add no `Parameter` role. One consumer in two dialects does not justify a 30th role that reopens all 29 other tables, mostly as `absent`. The two row comments now state that in one sentence so the next reader does not re-ask, and the two exemption reasons cite the decision instead of #1701. Comment-only: `git diff -U0` carries no non-`//` hunk, the three role gates pass with byte-identical baselines, and `make self-scan-baseline-fresh` reports 0 added / 0 removed / 0 worsened / 0 improved. Fixes #1796
…rds assert what they drop The role tables pinned one of the two inputs a context-dropping forward hands a row: `TEXT_GATED` for the bytes, nothing for the chain (lesson 103, lesson 114). A gate marked `gated_by f no_chain` / `text_gated_by f no_chain` / `opens_by f no_chain` now has the signature `fn(&Node, &[u8])` and is called with two arguments, so the chain is unobtainable by construction rather than by promise; each row emits `CHAIN_GATED` (any owner gate or `opens_by` without the mark) and `canonical()` carries both flags so the Python reader is held to both. `callable_when`, `pays_itself_when` and a payer's gate reject the modifier: no chain-less forward reads them, and the JS `FuncOpener` rows carry a chain-reading `callable_when` beside an `opens_space` fold that never calls it. Forwards assert exactly what they drop: `impl_byte_gated_row_predicate!` asserts `!CHAIN_GATED` on `DocComment` / `DocRunDirective` (17 uses); the byte-less `is_func_space` / `get_space_kind` pair asserts `!TEXT_GATED && !CHAIN_GATED` on `FuncOpener` and `Container` in 21 languages. Elixir overrides rather than forwards; Ruby's `FuncOpener` is chain-gated by design and stays pinned by `ruby_byte_less_spellings_stay_the_kind_table`. Only those two roles may carry `opens` / `opens_by`, so an opener on a third role cannot bypass the two-row assertion. The signature proves "no chain parameter", not "no ancestry read": `no_chain_rows_answer_alike_under_the_empty_chain` compares every `!CHAIN_GATED` row under the real and the empty chain on every corpus candidate, and holds the new `node_resolved_parent_lookups` counter still, so a `Node::parent` climb is reported whatever it answers. Migration: 90 references (55 `gated_by`, 34 `text_gated_by`, 1 `opens_by`) across 24 table files; 40 gate fns lose their chain parameter. Zero drift: 0 of 46 606 outputs differ over 3 329 corpus files in 25 languages; the three role baselines are byte-identical. `.bca-baseline.toml` refreshed for `roles/mod.rs`'s `loc.*` rows. Fixes #1793
Checkpoint review of waves 1-2 (astra-review) found three gaps. The no_chain backstop bracketed owns_kind with the parent and sibling climb counters but not the opens_space fold that follows, and owns_kind never reaches an `opens_by` fn - so a Node::parent climb added to Kotlin's `class_or_interface` escaped both halves (the comparison half cannot see a climb that reads the same tree under either chain). Bracket the fold too; verified with utils/perturb.py: the same perturbation is UNCAUGHT before and caught after. Correct the doc that claimed the comparison half catches a parent-kind read. The book's aggregate-population section said every other metric's average / min / max is a per-space average; NArgs keeps its two function and closure channels divided by NOM's counts (#1809). Say so. Five NullSafe row comments (csharp, groovy, kotlin, perl, php) still explained which consumer scores which token; per macro-comments.md a row states the grammar fact and the reading lives at the consumer, where each abc/ and cyclomatic/ module already states it. Refs #1793, #1284, #1800
`HoldsDocInBody` was a residual by name only: the row declares the kinds beyond `FuncOpener` and `Closure` whose body a language's doc tool reads a comment into, and `Checker::holds_doc_comment_in_body` composes `is_func ∪ is_closure ∪ <row>` with its body-child test. The name read as the full set. `DocBodyResidual` says what the row holds, in the noun shape of its siblings (`DocTarget`, `DocRunOpener`, `DocRunDirective`); the module doc now states the residual definition and that a kind moving between `FuncOpener`/`Closure` and this row changes nothing the Checker answers. Rename only (maintainer decision D4): no adapter, gate or test semantics change; `holds_doc_in_body` → `doc_body_residual` for the projection module and `holds_doc_in_body_kind!` → `doc_body_residual_kind!` for the Checker macro; every `absent` reason string is unchanged. `utils/role_tables.py` derives the role set from `mod.rs` and needs no edit. Zero drift: 0 of 46 606 outputs differ over 3 329 corpus files in 25 languages; the three role baselines are byte-identical. `.bca-baseline.toml` refreshed for `roles/mod.rs`'s `loc.sloc`. Fixes #1797
The `exclude_tests` prune ended an outer-attribute run at the first sibling that was not an `AttributeItem`, so a comment between `#[cfg(test)]` and the item it decorates kept the item: `src/wire.rs` carried 218 SLOC of `mod tests` in the gated self-scan. rustc reads a `//` or `/* */` comment as no token, so the attribute still applies, and reads an outer `///` as a `#[doc]` attribute of the same run. Both production scans (`rust_attributed_item` forward, `rust_outer_attr_marks_test` backward) and both test oracles now read past a comment of either kind, through a shared `rust_attribute_run_member` that takes the kinds from the `Comment` and `DocComment` rows. An outer doc comment above the attribute opens the run the way an attribute does (`rust_attribute_run_start`), so its row goes with the pruned item; a plain comment above the first attribute, and a `//!` inner doc comment, are not the item's and stay. A plain comment inside a run is answered by the reach of the row that opened it, never read backward on its own, so a long stretch of `//` rows stays linear; `nom/deep-doc-comment-run` prices the doc-row form of the run (1.86 with the reach removed, 1.08 with it). Fixes #1647
An attribute is public iff any of the accessors it generated is public (#1399, maintainer decision D3). `attr_accessor :b` synthesises the reader `b` and the writer `b=`, and `private :b` names the reader alone, so the attribute stays public; `attr_reader :b; private :b` leaves no accessor public and `class_npa` drops by one, the only value that moves. `private :b=`, `private :b, :b=`, `public :b` promoting back, `protected :b`, several symbols, and `attr_reader :initialize` (auto-private reader, public writer) each follow from the rule, every one measured on ruby 3.0.2. `npa`'s consumer gains `leave_call` and keys a ledger by `(name, RubyAccessor)`, and the mechanics `npm` already had — the declaration slots, the by-name re-file covering the declarations so far, the resolve at the end of the body, the hand-up of what a nested visibility call returns, the auto-private name list — move to `npa/ruby_ledger.rs` so the two consumers share one `RubyLedger<K>` and one `ruby_leave_visibility_call`. `npm`'s observable behaviour is unchanged and its tests are untouched. An `attr_*` macro now also hands its accessor names up to an enclosing keyword, so `private public attr_accessor :x` composes as `npm`'s `private public def x` does. §3: `private "foo"` is `private :foo`. `ruby_symbol_name` becomes `ruby_name_argument` and accepts a `string` whose whole content is one `string_content` — no interpolation, no escape — for both consumers through the shared `ruby_argument_names`, which also lets `attr_reader "f"` declare. §2 (splat, bare identifier, nested call) stays unmodelled by decision; `ruby_argument_names` answers nothing for those shapes and the npa twin of npm's existing test pins it. Perturbations of the fold, the re-file, the `:b=` split, both string arms, the auto-private rule, the hand-up and the ledger's coverage are each caught by the tests named on the issue, as is deleting the visibility line from every fixture whose total the rule lets move. Fixes #1399
phpDocumentor's `Define` factory (`Reflection/Php/Factory/Define.php`,
`matches`) turns an `Expression` holding a `FuncCall` whose `Name`
prints exactly `define` into a constant carrying the statement's
DocBlock. bca read every expression statement as taking none, so the
block above `define('X', 1);` was `cloc` only.
The `DocTarget` row of `roles/php.rs` now owns `expression_statement`
under a `no_chain` byte gate on the callee: a bare `define` or the
fully qualified `\define`, which PHP-Parser's `NameResolver` prints as
`define`; `DEFINE`, `defined`, a namespace-qualified `Foo\define`, a
`namespace\define` and an assigned `$x = define(...)` stay plain. The
checker's signature set reads the row's kind table less the statement,
since a DocBlock after a call's arguments binds forward like one after
any statement's expression; `a_docblock_inside_a_statement_is_in_no_signature`
pins it. The row's parity exception is recorded in
`doc_tests/parity.rs`, and `.role-coverage-baseline.txt` drops the
`expression_statement` entry the row now claims.
A `define()` inside a function body is a constant to the tool too
(`Function_` descends its statements), but bca's in-body policy
withholds every in-body DocBlock before the binding runs; the row in
`dloc.rs` records that divergence.
Refs #1646
…structural command `doxygen_standalone` decides whether a C-family doc block carries a command that makes it an entry of its own (`@file`, `@class X`, …). It already read past the text Doxygen's scanner does not read for commands — a fence, a backtick span, an HTML comment, a format block, an escape — but not two more `commentscan.l` `<Comment>` rules: text quoted with `"` and closed on the same line (`"\""[^"\n]*"\""`), and a `<![CDATA[` section, which runs to `]]>` or the end of the block. A `/** "@file" */` above `#include` therefore stood alone and counted as `dloc` where Doxygen attaches it to nothing. `literal_end` gains the two arms. An unclosed `"` is one character, so the command after it is still read; the classifier rows pin both directions and the `dloc.rs` table the four dialects share pins the counts. Derived from the lexer rules (#1646 records the lines), not from a run: the x86-64 Doxygen release does not run on this host. Refs #1646
Three read-only review passes (reuse, clarity, efficiency) over the batch diff; the Improve findings applied as one commit. Reuse. The byte-less `is_func_space` / `get_space_kind` forwards carried the same four-term `const` assert in 42 per-language files; `impl_byte_less_func_space!` and `impl_byte_less_space_kind!` emit it once each, the crate's convention for the sibling forwards. The function-space population #1284 added was folded in four copies across cyclomatic (twice), cognitive and nexits; `FunctionPopulation<T>` in `metrics/mod.rs` holds numerator, count and extrema and is what each metric's `average` / `min` / `max` read, so the three cannot describe different populations by construction. The `MAX` sentinel collapse the accessors each repeated lives in its `min()`, which also let cognitive and nexits derive `Default`. Efficiency. `ruby_argument_names` allocated a `Vec` per call argument on both Ruby walks where `main` had none; it answers an iterator. Clarity. The `no_chain` backstop's narrative sits on the test it describes, not on the probe struct, and no longer says "one language"; `class_or_interface_no_chain` sits beside its three-argument original; `literal_end` asks `delimited_end` before the backtick span instead of excluding the fence with a `.filter(|_| ..)`; `RubyAttributes::read`'s comment says it records rather than counts; a `Range::clone` in `tally` is a slice; a dead `enum_glob_use` allow goes. No output changes: lib and integration suites green, no snapshot moved.
The `rust-optimize` analysis over the batch diff, with each macro claim probed under rustc 2024 before applying. `ruby_argument_names` answers `Option::into_iter().chain(..)` of the one-symbol and `%i[..]` shapes instead of a hand-rolled three-variant iterator; the same three shapes, no custom type, and the private enum no longer shares a name with npm's `RubyArgumentNames` alias. `ruby_name_argument` is private, its only callers being in its file. The `text_gated_kind` / `chain_gated_kind` detector rules take an optional literal `holds_payer` — a detector emits `true` and re-emits nothing, so `$(holds_payer)?` is sound there where the folds, which must re-emit the word, cannot use it; three rule pairs become three rules and the DSL pins hold. `FunctionPopulation` keeps `min` as `Option<T>` rather than a `MAX` sentinel, so `PopulationValue` needs no `ZERO` / `MAX` and the struct derives `Default`; an empty population still reports 0. Test code: the four Ruby npa re-filing tests share `assert_class_npa` rather than restating one loop; the prune-shape test compares the two halves without an owned copy of the expected names. No output changes.
Two audits over the batch's new and re-pinned tests, each finding verified by utils/perturb.py before and after the fix. The #1284 invariant sweep counted "spaces where the old and new populations differ" from cyclomatic alone, and every non-function space in its eleven fixtures scored 0 cognitive and 0 nexits — so for those two metrics a numerator folding every space read the same as the function-only one and the sweep passed under the perturbation. The Python and JS fixtures now carry module-level flow, and the counter is per metric with a floor the module-flow fixtures must meet. Three re-pinned snapshots kept the derivation prose from the old `nom.total()` divisor beside values the function-space population now produces; each states the new population and the `main`-side value, and the two Python tests gained an integer assert on `sum`. The #1399 re-filing test had no fixture pairing an `attr_*` with a later `private_class_method :b` / `public_class_method :b`, so dropping the `targets_singleton` guard was uncaught across npa and npm; two classes measured on ruby 3.0.2 pin it. Test code only.
… findings The whole-branch review pass (six readers over origin/main..HEAD). The one bug: #1765's PHP `break N` fix was not swept across siblings, and its resolution claimed no other grammar has a numeric-level jump. Bash does (POSIX `break n`), parsed as a plain `command` with no jump kind — grammar-dispatch §9 — so the cognitive arm reads the leading word off the `name` field and a named level after it: +1 for any written level, `break 1` included, +0 for the bare word, the reading PHP took. `f() { for …; do for …; do break 2; done; done; … }` scored 5 on main and scores 7; cyclomatic is 6 either way and anchors the fixture. PHP `define()` (#1646) missed `(define('X', 1));` — PHP-Parser drops grouping parentheses, so phpDocumentor attaches the DocBlock; the gate now reads through them. An imported alias (`use function Vendor\make as define;`) is NameResolver's and not this gate's: documented on the gate and pinned as reading as written. Docs. The book dated the #1284 change to 2.4, which is the release that *has* the old behaviour; its deviations intro said PHP break N was off the list while the list still carried it. Both say what they mean, and the row covers Bash. The Python test docstring and a spaces_tests comment still described the old divisor. Two NullSafe row comments (Kotlin, C#) kept a consumer sentence the checkpoint trim had missed. "What the mechanism cannot see" now names the backstop's corpus bound: a `no_chain` owner no fixture spells is neither compared nor counted. The average-population rule had seven copies; `FunctionPopulation`'s doc is the one in-tree narrative, the book the user-facing one, and the three accessor docs and two walk comments link there. The nested-keyword `D x W` note on the Ruby ledger says it is new to npa, not inherited: npa gathered nothing before #1399. Refs #1765, #1646, #1284, #1793, #1399
astra-review of the review-fix commit found two things in the new
Bash `break n` arm.
`break --` and `continue --` are the bare jumps with the option
terminator written, and scored +1 as if `--` were a level; the level
read now skips it, so `break --` is +0 and `break -- 2` is +1. Pinned
by two rows in `bash_jump_pays_for_any_explicit_level_1765` (sum 10,
cyclomatic 8 either way), verified by perturbing the read back.
A function the script defines under the builtin's name — `break() {
…; }`, legal outside POSIX mode — is read as the builtin, because the
walk resolves no names. The earlier commit's premise that the name is
impossible was wrong; the gap is a syntactic limit every leading-word
reading shares, stated on the helper and pinned by
`bash_jump_reading_is_syntactic_1765` rather than left to be found.
The three `*_average` accessor docs name the book's *Aggregate
population* section, reachable from the published docs, rather than a
private type.
Refs #1765, #1284
…the batch review The lessons-learned pass over fix/batch-2026-11-04. No new numbered entry: every candidate was a standing obligation, which is a rule's, or an instance of a mechanism lesson 114 already names. Lesson 114 gains the #1793 sub-example: the read counter its closing sentence asked for exists now (`Node::parent` records `node_resolved_parent_lookups`), the answer-agreeing perturbation it was built to catch, and the second call site the first placement missed — the `opens_space` fold an `opens_by … no_chain` fn is reached through. testing.md's "Seed the state you claim to assert on" gains the #1284 instance — a fold restricted to a sub-population reads the same as the unrestricted one while every excluded member contributes zero — and its Lesson one clause for it. grammar-dispatch.md's sibling sweep says to dump the construct in each grammar rather than search for a kind name, since a §9 construct has none to find (#1765's Bash `break n`). AGENTS.md's issue-body guidance records that the host proxy has rejected table-carrying comments of a few kilobytes and the gist route that took them (#1399, #1646). Refs #1793, #1284, #1765, #1399, #1646
Codecov Report❌ Patch coverage is Additional details and impacted files@@ Coverage Diff @@
## main #1824 +/- ##
========================================
Coverage 98.37% 98.38%
========================================
Files 395 396 +1
Lines 118113 118832 +719
Branches 117678 118397 +719
========================================
+ Hits 116199 116911 +712
- Misses 1202 1211 +9
+ Partials 712 710 -2
Flags with carried forward coverage won't be shown. Click here to find out more.
🚀 New features to boost your workflow:
|
This branch was previously deployed
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.
Post-#1701 follow-up batch: the issues the role tables made cheaper to fix well. Plan: the brief and execution plan were reviewed by astra-review and sol-review before work started; five design decisions (D1–D5 below) were put to the maintainer and are recorded in each issue's
## Resolution.Issues
cyclomatic/cognitive/nexitsaverage/min/maxall read theSpaceKind::Functionpopulation — numerator, divisor and extrema from one predicate (FunctionPopulation<T>); spaceless closures leave the divisor;sumunchanged. D1: scope is these three;nargs' two-channel form is #1809.??/??=, Elvis?:, Perl/////=no longer score; cyclomatic unchanged; safe navigation pinned at 0 in 9 languages. D2: PHPbreak N/continue N+1 for any explicit level,break 1included — and Bashbreak n, found by the whole-branch review.after_codebypass; decision on the twoDocTargetrows.no_chaingate modifier. D5 + A+B: ano_chaingate has signaturefn(&Node, &[u8])(compiler-enforced), every row emitsCHAIN_GATEDbesideTEXT_GATED, 21 byte-less forwards assert!TEXT_GATED && !CHAIN_GATED, 17 byte-gated forwards assert!CHAIN_GATED, and a derived backstop compares every unchained row under the real and the empty chain withNode::parentclimb counters bracketing bothowns_kindand theopens_spacefold.HoldsDocInBody→DocBodyResidual; no adapter change.///above the attribute pruned with the item.src/wire.rsself-scan sloc 718 → 495.private :bthrough the shared Ruby ledger;private "foo"resolves for npm and npa; splat / non-literal stay unmodelled by decision.define()DocBlock (through grouping parentheses; imported aliases documented asNameResolver's), Doxygen quoted text and<![CDATA[. Six Doxygen bullets remain on the issue with a triage table.Review and passes
simplify-rust(42 asserts → 2 macros;FunctionPopulation<T>; −308 lines),rust-optimize,audit-tests(3 tests made to discriminate, each perturbation-verified) — all zero-drift against the post-batch tree.review,code-review max, performance, under-reviewed areas, astra-review, architecture) → one fix commit; astra-review of that commit → one more (Bashbreak --is no level; the function-named-breaklimit stated and pinned).lessons-learned: no new numbered entry; lesson 114 gains the refactor(roles): add child_gated_by and CHAIN_GATED so byte-less forwards assert no gate reads the chain #1793 sub-example; three rule additions.Evidence
make pre-commit:BCA_GATE: passon HEAD.check-test-lang-gates-compare COMPARE_REF=origin/mainOK.role-census/role-coverage/role-bypassOK (bypass baseline empty).self-scan-baseline-fresh0/0/0/0;self-scan-profile-paritybyte-identical.chain-audit650 passed.role-parity-corpuspass.bench-scaling111/111.07822c69) → post-batch: 22 272 of 46 606 outputs differ, all in metric views, 0 inops/dump/find/count— attributed per item on each issue. Every refactor item and every pass: 0 / 46 606 against its own base, with the command and bothbca --versionbuild-input digests on the issue.utils/perturb.py,old/newstrings) are on each issue; long records are gist-linked.origin/main(the gix branch, then chore(deps): drop basic-toml from enums via askama features (RUSTSEC-2026-0374) #1822);.bca-baseline.tomlregenerated at each-mergeconflict, never resolved; batch content verified byte-identical against a backup ref both times.Submodule
tests/repositories/big-code-analysis-output→d411e605(pushed; #1284 and #1800 snapshots)..role-coverage-observed.txtrefreshed in the same commits.Closes #1284, #1800, #1765, #1796, #1793, #1797, #1647, #1399. Refs #1646, #1809.