Rosetta to green: cause-first batch plan + multi-session coordination (child of #2560)

[squid-protocol]

Child of epic #2560. Full assessment with the cell-family breakdown: https://claude.ai/code/artifact/9bc0a5a3-5268-4e6a-8d2c-ea8924a45889

This issue is the handoff surface. Every session (any model, any vendor) working rosetta reads
this issue top to bottom including comments before touching anything, claims one item by
comment, and leaves a status comment when it stops. The per-language issues (#2561–#2607) are
not the work queue; they get a scripted status comment after each batch's regen (Batch E).

Session start protocol (every session, every time)

1. gh issue view <this> --comments — the last comment per item is its true state.
2. Re-bless check (replaces the pin check, retired by Cross-repo choreography is circular, and every way it broke today failed green — drop the ENGINE_REF dance, machine-check the invariants #2682/ci: rosetta-audit without pins -- baseline-classified, refuses to no-op (#2682) #2699): gh issue list --repo squid-protocol/keyword-rosetta --search "corpus owes a re-bless against engine main" in:title --state open. If that issue is open, the corpus is behind engine main and the first job is the re-bless it lists. There is no pin to compare any more (KEYWORD_ROSETTA_REF deleted 2026-09-04).
3. Read docs/bias_data.json / docs/bias_report.md from keyword-rosetta main — bias-history.yml regenerates it on every corpus push and nightly against engine main, and the report header names the engine SHA. Do not regenerate locally to triage; regenerate only to verify a change before a PR.
4. Claim: comment claiming <item id> — <model> — branch <name>. One item per session unless the
   item says "fan-out".
5. Stop: comment status <item id>: <done|blocked|partial> — <branch/PR> — <what remains>.
   Unfinished branches are pushed, never left local.
6. Never mix layers in one PR (rule regex | slicer/DAG | scoring). One Closes #N per line in PR bodies — a comma-list closes only the first (yaml: missing "ownership" rule — action.yml author: / OpenAPI info.contact: idiom uncaptured #2646/yaml: missing "cleanup" rule — shell-embedded teardown verbs (rm -rf <path>, docker rm/down, kill) inside run:/script: blocks uncaptured #2647 stayed open for a day because of it).
7. From Batch F on, claim a family, not a language or a batch (F.5 is the one fan-out).

Model tiers

tier	use for	why
T1 — Fable / Opus	classification across languages, writing fix shapes, ledger verdicts, attributing regen movers, every golden-master bless review, Batch D	judgment work; the failure mode is a plausibly-explained wrong number baked into a baseline
T2 — Sonnet	implementing a filed fix shape + strict tests, the regen/PR mechanics after a T1 review, tools scripting in Batch E, resolver fix in C	bounded tasks with a machine gate (verify_language.py, pytest, crucible_check.py)
T3 — Haiku / Gemini flash-class	the 32 per-language decoy edits (fan-out), #2660's 11 per-language anchor checks (fan-out), capstone prose from the template	templated, one language at a time, each self-checked by the verifier before it can be wrong

Rule of thumb: a T3 item must have a mechanical pass/fail the model runs itself; a T2 item must
have a written fix shape from T1; T1 owns anything that ends in a manifest number or a bless.

Batch 0 — unblock the gate owner: repo admin tier: none

• 0.1 gh api -X PATCH repos/squid-protocol/gitgalaxy/actions/variables/KEYWORD_ROSETTA_REF -f value=<corpus main sha> then gh workflow run rosetta-audit.yml --ref main → green. (Run 33657474420 proved the stale state: 13 languages fail = PR Update README with improved mapping description #29's set.)
• 0.2 Process: add "bump KEYWORD_ROSETTA_REF" as the last checklist line of the engine-PR template's Cross-repo section.

Batch A — corpus only (keyword-rosetta), one PR, one regen

• A.1 fan-out, T3 — decoy migration per rosetta#17 template (PR test(security): add comprehensive test suite for security and complia… #23 is the worked example) for: ada apex c cpp csharp dart dockerfile embedded_python go groovy haskell java javascript kotlin livecode lua m4 makefile matlab objective-c perl php powershell ruby scala scheme shell solidity swift tcl typescript zig. Done criterion per language: verify_language.py <lang> --report shows exactly +1 high_risk_execution from the new literal and no other delta vs the current manifest except removed decoy hits. Each language = one commit on the shared branch corpus/decoy-migration-wave2.
• A.2 T2 — css/html empty probe bodies: plant css doc/globals/ownership/safety_bypasses and html cleanup/telemetry per SPEC.md; ~20 cells.
• A.3 T2 — authoring fixes: perl =cut; apex Type.forName chain (gives apex a DAG); agc CA-register args; header @author swaps apex/agc/fortran; yaml single doc plant (drop one of name:/description:); cobol *> @return line (cobol: doc rule's AUTHOR-vs-ownership collision needs a corpus-side doc line planted before the engine fix (#2659 follow-up) #2661 step 1). Plus the four languages A.1's list missed — abap, assembly, cobol, sqlite still carry the retired shared sentence translated into their own vocabulary ('IF TRUNCATE FAILS TRY SELECT AGAIN', "if jmp fails try syscall again", 'IF ALTER FAILS TRY OPEN AGAIN', 'IF UPDATE FAILS TRY SELECT AGAIN'): same rosetta#17 template, same per-language gate, and screen the keyword against the risk_* inputs and the filler words too (see A.1's status comment for what that catches).
• A.4 T1 — ledger: extend Tier-2 args-morphology entry to css/html/yacc/yaml/makefile/dockerfile/sqlite (not agc — A.3's CA A plant already took it to the median); normalise every entry's signal to |-joined metric names (needed by E.1).
• A.5 T1 — regen (bias_report.py), attribute every mover, manifest notes, PR with Cross-repo section. Expect branch/io/safety medians to move; say so in the body. → keyword-rosetta#32 (Batch A). Pin bump owed after merge.

Batch B — engine batch 3 (gitgalaxy), one PR + one corpus rebless + pin bump

• B.1 T1 — file: doc-block double-count (java groovy kotlin php scala: /**+@param; solidity ///+@param; apex @author in doc, livecode (+~14 siblings): doc rule claims 'Author:' which ownership already owns — every header author line double-counts (ada has the correct pattern) #2659 shape; cobol cobol: doc rule's AUTHOR-vs-ownership collision needs a corpus-side doc line planted before the engine fix (#2659 follow-up) #2661 step 2). One issue, fix shape = count a docblock once (pair opener with tags, python/embedded_python: doc rule counts each docstring twice (open and close delimiters both match, no pairing) #2658 precedent). → doc rules count one doc comment once per marker AND once per tag — 18 languages, 8 red rosetta cells (the #2658 shape, unswept) #2672, family widened to 18 languages (adds c cpp objective-c dart javascript typescript swift yacc csharp as latent off-corpus double-counters); absorbs perl doc: a correctly-closed POD block counts twice (=pod + =cut) — the #2658 delimiter shape #2670 and cobol: doc rule's AUTHOR-vs-ownership collision needs a corpus-side doc line planted before the engine fix (#2659 follow-up) #2661 step 2. apex @author is dormant, not a live cell — A.3 dodged it corpus-side; fix shape covers it anyway.
• B.2 fan-out, T3 — globals rule audit: 11 more languages share zig/dart's ^[ \t]* any-indentation anchor (#2651 follow-up) #2660: for each of assembly cpp css dockerfile go haskell kotlin livecode lua perl scheme, scratch-scan an indented same-named declaration; report real/not-real with the scan output. T1 decides the list. → report on globals rule audit: 11 more languages share zig/dart's ^[ \t]* any-indentation anchor (#2651 follow-up) #2660. Only go is real with the zig + dart: globals rule anchors ^[ \t]* so function-local var/const count as globals (+150% on the rosetta corpus) #2651 fix shape. assembly/css/lua/perl: fix harmful (indentation is not scope). cpp/dockerfile/haskell: inert or 0 incidence. livecode: not in the family (no anchor). kotlin/scheme: real FP but the col-0 anchor deletes the true positive too — need their own issue. B.3 ships go only.
• B.3 T2 — implement B.1 + confirmed B.2 + yacc: %union type declarations have real record/struct morphology but class_start is wired None #2644 html: srcdoc attribute (embedded document + script) is invisible to every structural signal #2645 yaml: missing "ownership" rule — action.yml author: / OpenAPI info.contact: idiom uncaptured #2646 yaml: missing "cleanup" rule — shell-embedded teardown verbs (rm -rf <path>, docker rm/down, kill) inside run:/script: blocks uncaptured #2647 swift: api rule matches bare 'open' anywhere, including inside string literals #2544 groovy func_start: paren-less builder call (raw _("x")) misdetected as function when no longer masked by a nested FP #2558, each with strict positive/negative tests (+ ReDoS detonation for new quantified regexes) in tests/extraction/languages/test_<lang>_strict.py. → DONE: wave 1 fix(core-engine): Rosetta batch 3 wave 1 — five registry-regex fixes with no corpus movement (#2669) #2677 (go/kotlin/swift/groovy + groovy func_start: statement keywords (new/return/throw) pass as prefix tokens, so 'throw new Foo(x)' and 'return bar(x)' misdetect as declarations — 8.6% of real branch-1 matches #2676), wave 2 fix(core-engine): Rosetta batch 3 wave 2 — doc-comment pairing, rule over-claims, three None rules (#2669) #2681 (doc family 17 langs, apex apex import rule: re.IGNORECASE neutralises the [A-Z] guard, so every qualified reference (foo.bar) counts as an import #2671, safety_bypasses/io over-claim: four rules count tokens another rule owns (livecode global, lua _G+collectgarbage, fortran COMMON, dockerfile apt-get clean) — the #2659 shape #2675 three langs, html/yaml None rules). yacc: %union type declarations have real record/struct morphology but class_start is wired None #2644 pulled (needs a slicer-layer allowlist change); fortran withdrawn from safety_bypasses/io over-claim: four rules count tokens another rule owns (livecode global, lua _G+collectgarbage, fortran COMMON, dockerfile apt-get clean) — the #2659 shape #2675 (documented intentional double-classification).
• B.4 T1 — post-A residuals: sqlite io 11, tcl io 8, haskell/livecode/lua safety_bypasses 4 — classify, file with fix shapes, add to B.3 only if regex-level. Re-read sqlite's io after A.3 migrates its decoy: the old sentence's SELECT is an io keyword there, so part of that 11 is corpus-side, not engine-side. Same caution for tcl (A.1 already took its io 2→1 by dropping the prose open) and for haskell/livecode/lua safety_bypasses. → all figures were pre-A and the set was incomplete. Post-A: io RED sqlite 9, tcl 7, dockerfile 5 (missed); safety_bypasses RED lua/livecode/haskell 4 and swift/sqlite/html 0 (the low side, entirely missed), amber apex/fortran 3, yaml 1. Split: engine-side regex → safety_bypasses/io over-claim: four rules count tokens another rule owns (livecode global, lua _G+collectgarbage, fortran COMMON, dockerfile apt-get clean) — the #2659 shape #2675 (livecode/lua/fortran safety_bypasses + dockerfile io all claim tokens another rule owns; all four land on planted — B.3 material). Corpus-side → keyword-rosetta#33 (empty probe_bypass in html/sqlite/swift, half-planted yaml, apex risk-idiom collision, sqlite decoy via SELECT). Remainder is ledger, not fix: tcl source dual import/io, the cleanup-close family in c/lua/tcl, haskell unsafePerformIO (unavoidable).
• B.5 T1 — scoped-diff check, golden-master bless (user go-ahead), corpus rebless PR with ENGINE_REF=pull/N/head, pin bump in the engine PR. → DONE: scoped diff 710 diffs / 0 unexplained; both golden masters blessed (e994d2a); corpus rebless keyword-rosetta#35 merged with ENGINE_REF=pull/2681/head; pin bumped to 216d57ab (full 40-char SHA).

Batch C — graph layer (gitgalaxy), parallel with A/B

• C.1 T1 — filed as network_risk_sensor: dependency resolver drops relative imports that carry an extension (./b.sh -> key 'sh'), zeroing every network metric for shell/powershell/yaml/javascript #2668: network_risk_sensor._resolve_target rewrites ./b.sh → //b/sh, looks up sh, builds no edge; zeroes popularity/betweenness/closeness/producer_ratio for shell, powershell, yaml, javascript. Guard already exists in galaxyscope.py ~L1870. → DONE — filed as network_risk_sensor: dependency resolver drops relative imports that carry an extension (./b.sh -> key 'sh'), zeroing every network metric for shell/powershell/yaml/javascript #2668 with the fix shape and the four token forms.
• C.2 T2 — implement: strip leading .//../, skip dot→slash when the trailing segment is a known extension; strict test with the four token forms + typescript/c controls. Add _dependency_capture for m4 include() and yacc #include (scheme: no _dependency_capture — whole DAG missing, and orphan->api conversion can never fire (tech-debt systematically inflated) #2652 shape). → fix(core-engine): graph layer — relative-import resolution (#2668) + m4/yacc dependency capture (#2669 C.2) #2685 MERGED (aacfe5da). Shipped as ordered lookup forms rather than a known-extension gate — literal path first, dot-rewrite last — which needs no extension set in the sensor and cannot regress (272-case differential vs the legacy implementation: 26 changes, all None→correct or wrong→correct). m4/yacc captures included. New bug found while attributing the diff: galaxyscope popularity tally: a bare filename import raises popularity on every same-stemmed file in the repo, unscoped by language or directory (#2540's shape, in the tally instead of the DAG) #2684 (the popularity tally credits every same-stemmed file in a scan — fortran USE targets resolve case-sensitively in the dependency DAG (uppercase legacy style loses the whole import graph) #2540's shape in the tally rather than the DAG).
• C.3 T1 — bless review: real repos with ./x.js imports gain edges; the diff must be graph-only. Corpus rebless PR; remove m4/yacc from no-dependency-capture-languages. → DONE: diff verified graph-only (no extraction-signal column moved); both golden masters blessed (160 zero-dep / 165 full-precision, byte-identical to the pre-bless attribution); corpus rebless keyword-rosetta#38 MERGED with ENGINE_REF=pull/2685/head; ledger entry retired (languages_seen emptied, still_reproduces false); bias report red 270 → 236 with all 38 band changes improvements. ENGINE_REF reset open as keyword-rosetta#39; pin bump still owed after it merges.

Batch D — design pass (gitgalaxy) tier: T1 only blocked on A, B, C merged

• D.1 design issue: shape-descriptor invariance (avg_func_complexity, control_flow_ratio, cog_raw, gini, internal density, structural_mass — 166 cells), risk formulas: audit language-tier membership (embedded_python lands tier3) + decide how rosetta bias reporting treats documented Fc/Irc tier constants #2653 tier constants, ×3 flux (state-flux ×3 branch-context weighting: undocumented, and phantom-triggered by branch keywords inside string literals #2546) with matlab: mandatory 'out = x' return-convention assignments count as state_mutation (+450% vs median) — intended? #2654 as sub-case. Options: normalise against planted branch count / exclude as documented design / ledger as morphology. User approval before any edit. → Design (D.1): shape-descriptor comparability — the 160 cells decompose into five mechanisms, only 15 of which are a real design question #2689. The premise did not survive measurement: the 160 cells (not 166 — post-C figure) are five mechanisms wanting four different answers, and none of them needs an engine code change. 18 = markdown/html have zero functions so every per-function descriptor is undefined (report n/a, GATING.md's None-rule precedent). 30 = control_flow_ratio divides by structural_boundaries, which the corpus never plants, gates or displays — branch is pinned at 3-4 while the denominator ranges 0-45, so "normalise against planted branch count" cannot help. 92 = composites of inputs that are already ledgered (E.1 just needs to follow derivation edges). 5 = slicer segmentation. 15 = the real question: mainstream languages whose inputs are all in band but whose composite is not, i.e. formula non-linearity. Also tested and REJECTED the median-mixes-populations hypothesis (procedural-only median moves the counts by 0-1 cells).
• D.2 implement per approved design; large rebless; corpus regen. → DONE: keyword-rosetta#41. Five validated ledger entries take the shape family to zero unexplained cells and the corpus-wide count 224 → 175. No engine change, as D.1 predicted — but verifying each mechanism instead of asserting "morphology" turned up two real engine bugs, filed as functions_found counts the slicer's synthetic __global_context__ buckets, inflating every per-function descriptor for 5 languages #2691 (the slicer's __global_context__ bucket counted as a function in 5 languages, diluting every per-function descriptor) and ada: a single typed parameter counts as 3 args — the comma-free whitespace-split fallback splits 'Env : Integer' into three tokens #2692 (ada counts one typed parameter as three via a whitespace-split fallback). D.1's own recommendation to plant structural_boundaries was withdrawn: it is a per-language vocabulary tally, not a structural count, so planting cannot equalise it.

Batch E — bookkeeping

• E.1 T2, can start now — keyword-rosetta tools: after A.4, bias_report.py/language_deviations.py mark a red cell "explained" when a validated entry names that metric+language; exit code = epic close criterion. → keyword-rosetta#40. 444 out-of-band cells, 220 already accounted for (116 ledgered, 92 derived, 12 undefined), 224 genuinely unexplained — the ledger was carrying 116 answers the report never read, machine-readable only because A.4 normalised the signal fields. --gate exits nonzero while anything is unexplained (off by default; verify.yml unaffected). control_flow_ratio (21 cells) deliberately left unexplained rather than marked derived, because its denominator structural_boundaries is unplanted — see Design (D.1): shape-descriptor comparability — the 160 cells decompose into five mechanisms, only 15 of which are a real design question #2689 bucket B.
• E.2 T2 — script: one status comment per language issue from bias_data.json + ledger (before/after bands, buckets, owning batch). Run after each batch regen. rosetta[jcl]: cross-language consistency — 13 red / 7 amber metrics, 2 ledgered shapes #2581's jcl comment is the template. → DONE: keyword-rosetta#43. tools/issue_status.py generates each language's status comment from bias_data.json + ledger with the gate's own verdicts; posted to all 46 (rosetta[abap]: cross-language consistency — 3 red / 3 amber metrics, 2 ledgered shapes #2561–rosetta[zig]: cross-language consistency — 4 red / 2 amber metrics, 5 ledgered shapes #2607). Resolves issues by title search, not a stored map.
• E.3 T3 — generate the 41 missing §10 capstones → re-scoped by docs: rosetta capstones for the two languages that qualify (#2669 E.3) #2696: a capstone is written when a language's tracking issue closes, as part of closing it (the language-status skill forbids a §10 before a real sweep). abap + groovy delivered; shell needs §1–§9 first. Standing rule, owned by F.6.
• E.4 T1 — close per-language issues whose tool exit code is 0; comment the criterion that applies. → DONE: abap rosetta[abap]: cross-language consistency — 3 red / 3 amber metrics, 2 ledgered shapes #2561, groovy rosetta[groovy]: cross-language consistency — 2 red / 2 amber metrics, 4 ledgered shapes #2576, shell rosetta[shell]: cross-language consistency — 1 red / 5 amber metrics, 5 ledgered shapes #2599 closed — the three whose gate exits 0. Each closing comment states what the criterion is not: all three still have out-of-band metrics; what makes them clean is that every one carries a recorded reason. Flagged, not silently fixed: cobol rosetta[cobol]: cross-language consistency — 4 red / 8 amber metrics, 5 ledgered shapes #2567 and jcl rosetta[jcl]: cross-language consistency — 13 red / 7 amber metrics, 2 ledgered shapes #2581 are closed but no longer pass the gate (closed pre-E.1 under human judgement) — reopening is an epic-owner call.

Batch F — the last 152, one cause family per session approved 2026-09-04

Plan: https://claude.ai/code/artifact/0f9f00d4-818e-4895-9e52-7ceb5fa4fc4d. State at approval: bias_report.py --gate unexplained = 152 (444 → 224 → 175 → 152), corpus main 6d26261 vs engine a334839. The regen is free and automatic now, so the unit of work is a cause family, not a batch-and-regen. Each session ends with one number here: unexplained before → after, read from corpus main the next morning.

• F.1 T1 decided, T2 build → keyword-rosetta#48 (152 → 91 with F.2; leaks filed as length leaks: func_internal_density, avg_func_loc and control_flow_ratio read file length with content and tier held equal (rosetta F.1 design pass) #2705; tier must be held equal — see status comment) — — verbosity family (keyword_hits 17, coding_loc 13, total_loc 12, token_mass 7 = 49 cells). Decision: out of the gate. They measure how long the 12-probe program came out, which the corpus does not control (mainstream languages all sit within a few % of the median; the out-of-band tail is markdown/m4/yacc/jcl/css/html/dockerfile/makefile/yaml/sqlite short, haskell/scheme dense). Report them as a context group, excluded from banding and --gate; say so in SPEC.md + GATING.md. Plus the length-leak check: for each derived metric, over the languages whose planted inputs for it are all on the median, correlate the metric against coding_loc; a strong correlation is ONE engine finding on that formula (cite the source line, as DERIVED_INPUTS does), not N language cells. Known candidates: dependency_density (= import / (coding_loc × control_flow_ratio)), cog_raw's LOC term, structural_mass's loc/50, risk_tech_debt LOC normalisation (risk formulas: audit language-tier membership (embedded_python lands tier3) + decide how rosetta bias reporting treats documented Fc/Irc tier constants #2653's note). Each flag becomes a UEF small-file normalization isn't achieving its intent — redesign scoring so identical intent scores identically regardless of file size (design pass for Fable) #2655-style design question, filed as an engine issue, not fixed in this PR. Expected: 152 → ~103 before any leak is acted on.
• F.2 T2 → keyword-rosetta#48 (12 cells derived; betweenness js/python → F.5) — — derivation edges for the graph family (dependency_density 10, dependency_links 2, betweenness_score 2): dependency_density → (import, coding_loc, control_flow_ratio), dependency_links → import, betweenness → the DAG inputs, each with the record_keeper/sensor line cited. Same keyword-rosetta tools PR as F.1. markdown's dependency_density 0.75 with a None import rule does not fit the formula — send it to F.5 if it survives. Expected 8–10 of 14 become derived.
• F.3 T1 design → keyword-rosetta#50 (91 → 67; stratified tier medians + ungated unplanted inputs + vocabulary label; membership audit on risk formulas: audit language-tier membership (embedded_python lands tier3) + decide how rosetta bias reporting treats documented Fc/Irc tier constants #2653 awaiting a decision) — — risk formulas: audit language-tier membership (embedded_python lands tier3) + decide how rosetta bias reporting treats documented Fc/Irc tier constants #2653 tier constants (33 risk_* cells with every input in band; ~20 are tiers). Evidence: risk_tech_debt is byte-identical (29.88) across exactly the engine's tier-1 set {csharp, dart, go, java, rust, swift, typescript}; risk_documentation steps 29.9 / 40.8 / 55.8 by tier with doc/ownership on plant. Decision: option (a) — bias_report.py divides Fc/Irc out before banding, raw values stay in bias_data.json; plus the membership audit risk formulas: audit language-tier membership (embedded_python lands tier3) + decide how rosetta bias reporting treats documented Fc/Irc tier constants #2653 already narrowed (embedded_python is python). Classify the 13 non-tier cells in the same session: risk_api_exposure/risk_documentation at 0 for ada/haskell/sqlite/yaml/dockerfile (the api == 0 short-circuit A.2 met in css), risk_concurrency on a zero median for agc_assembly/swift, risk_stability markdown. Output: design comment on risk formulas: audit language-tier membership (embedded_python lands tier3) + decide how rosetta bias reporting treats documented Fc/Irc tier constants #2653, then one corpus tools PR, and an engine PR only if membership changes.
• F.4 T1 classify → T2/T3 execute — orphan/api/encapsulation census (raw_state_slop_orphans 16, raw_arch_api 10, def_encapsulation 7, encapsulation_ratio 5, state_slop_duplicates 1 = 39). Outputs of galaxyscope's Contextual Baseline Fix, mostly on no-call-graph languages (dockerfile, makefile, markdown, yaml, sqlite, jcl, css, html) plus a mainstream tail (python, go, perl, zig, javascript). Method: galaxyscope --db-only --debug, read [WORKER-TRACE] extracted functions for per language (CLAUDE.md recipe), sort into (i) no call graph so every probe is an orphan, (ii) orphan→api conversion via popularity, (iii) genuine over-count (orphan census counts non-function shapes on non-call-graph languages, making orphan→api conversion unauditable #2547 shape). Verify (iii) on language-crucible before filing — B.2's lesson. Expected: one ledger family for the no-call-graph languages (~25 cells), a few plants, at most one engine issue.
• F.5 fan-out, T3 + T1 verdicts — the 17 single cells: classes_found cobol/css/dockerfile/jcl/kotlin, class_start cobol/css/jcl/yaml, args m4, globals csharp, high_risk_execution yacc, state_mutation yaml, test yaml, functions_found dockerfile/html/sqlite, plus whatever F.2 leaves. Per cell: reproduce with verify_language.py <lang> --report, one paragraph of cause, propose plant / rule fix / ledger; mechanical check = the change moves exactly that cell and nothing else in the manifest. yacc: %union type declarations have real record/struct morphology but class_start is wired None #2644 (yacc class_start) stays blocked on the detector allowlist and may end as a ledgered n/a. One corpus PR per wave of accepted verdicts; engine cells filed with fix shapes.
• F.6 T2, standing — closure loop after every nightly regen: tools/issue_status.py <lang> --post for languages that moved; close any language whose language_deviations.py exits 0, writing its capstone as part of closing (E.3's rule); reopen any closed language that no longer passes (decision 2026-09-04: F.6 owns reopening automatically — today cobol rosetta[cobol]: cross-language consistency — 4 red / 8 amber metrics, 5 ledgered shapes #2567 and jcl rosetta[jcl]: cross-language consistency — 13 red / 7 amber metrics, 2 ledgered shapes #2581 fail the gate, abap rosetta[abap]: cross-language consistency — 3 red / 3 amber metrics, 2 ledgered shapes #2561 drifted to 1 amber). apex, matlab and solidity qualify for closure today.

Order is by cells closed per decision: F.1+F.2 (one PR, → ~95) → F.3 (→ ~75) → F.4 (→ ~45) → F.5 (→ ~0), F.6 throughout. Housekeeping done at approval: #2544 + #2558 closed (shipped in #2677, comma-list Closes), keyword-rosetta#17 closed (40/40 migrated), KEYWORD_ROSETTA_REF variable deleted.

Stacking rules (unchanged from GATING.md, restated so no session has to rediscover them)

• Commit corpus edits before verifying (census walks tracked files only).
• Every manifest number cites a validated ledger entry; unexplained delta = stop.
• One layer per engine PR; one corpus rebless PR per engine PR, opened against engine main after the engine PR merges (label the engine PR rosetta:rebless-owed when it moves the corpus). No ENGINE_REF, no pin.
• Scoped-diff check before every bless; unrelated movers are attributed to a named merged PR or the bless waits.
• Worktrees outside any path containing a tmp component.

[squid-protocol]

claiming A.1 — claude-opus-5 — branch `corpus/decoy-migration-wave2` (keyword-rosetta)

Session-start checks:

• Pin: `KEYWORD_ROSETTA_REF` = `c8edf78` = keyword-rosetta `origin/main` ✅ (Batch 0.1 is done — checking the box below)
• Cache: `docs/bias_data.json` last touched 2026-09-02 12:38:49 (938a2dc), last engine merge on main 2026-09-02 12:27:35 (3ac9182 / feat(metrics): evidence-mass floor replaces the UEF's six small-file guards (#2655) #2667) → cache is newer ✅
• `ENGINE_REF` = `main`; local engine checkout at 3ac9182, running the `full_precision` venv.

Running the 32 languages sequentially rather than fanning out to T3 sessions (single-session run, same mechanical gate per language: `verify_language.py --report`, one commit per language). Will report per-language results here.

[squid-protocol]

status A.1: done — branch corpus/decoy-migration-wave2 (keyword-rosetta, pushed, 32 commits, one per language). No PR yet: Batch A is one PR + one regen, so A.1 waits for A.2–A.5 on the same branch.

All 32 languages migrated to the danger-only string decoy per rosetta#17 / SPEC §String decoy, and all 32 gates PASS. Baseline was green for all 32 before the first edit, so every number below is a clean before→after.

Method (the mechanical self-check this item asked for)

Keyword choice was not eyeballed. For each language I ran the candidate literal through the language's live compiled rules (tools/_registry.active_rules) and required:

1. exactly one high_risk_execution match, and
2. zero matches in any scored signal — the 21 PLANTED/measure columns plus the seven non-planted signals that feed a risk_* formula (concurrency, sync_locks, reflection_metaprogramming, immutability_locks, spec_exposure, debug_prints, llm_api), derived from _registry.risk_dependencies() rather than assumed.

That rule reproduces all three pilot choices unaided (python eval, fortran rejects GOTO for ASSIGN, rust abort), which is what made me trust it. It also caught things a reading wouldn't: Thread.Abort (csharp) and Thread.stop (java) hit concurrency → risk_cognitive_load/risk_concurrency; iex (powershell) hits reflection_metaprogramming → risk_cognitive_load. All three were rejected. Filler words were checked the same way: text matches dart's and embedded_python's ui_framework rule, so those two use plain <kw> decoy line. Unscored collateral (panics_and_aborts, ipc_rpc_bridges, serialization_parsing, structural_boundaries) was allowed and is named in each commit.

Then, per language: edit → commit (census walks tracked files) → verify_language.py --report → account for every delta → manifest + decoy entry + notes → gate.

Results

language	danger keyword	file	verified deltas
ada	OS_Exit	b.adb	high_risk_execution 0→1, branch 1→0, state_mutation 6→2
apex	emptyRecycleBin	b.cls	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
c	system	b.c	high_risk_execution 0→1, branch 1→0, io 1→0, state_mutation 9→3
cpp	system	b.cpp	high_risk_execution 0→1, branch 1→0, safety 1→0, state_mutation 9→3
csharp	Process.Start	b.cs	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
dart	exit	b.dart	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
dockerfile	eval	b.dockerfile	branch 1→0, io 1→0, state_mutation 4→2
embedded_python	machine.reset	b.py	high_risk_execution 0→1, branch 2→0, safety 3→2, io 1→0, state_mutation 6→2
go	os.Exit	b.go	high_risk_execution 0→1, branch 1→0, state_mutation 11→5
groovy	execute	b.groovy	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
haskell	die	b.hs	high_risk_execution 0→1, branch 1→0, safety 1→0, state_mutation 6→2
java	Unsafe	b.java	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
javascript	eval	a.js	high_risk_execution 0→1, branch 2→0, safety 3→2
kotlin	System.exit	b.kt	high_risk_execution 0→1, branch 2→0, state_mutation 6→2
livecode	answer	b.lc	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 9→3
lua	os.remove	b.lua	high_risk_execution 0→1, branch 1→0, state_mutation 6→2
m4	esyscmd	b.m4	high_risk_execution 0→1
makefile	sudo	b.mk	high_risk_execution 0→1, io 1→0
matlab	exit	b.m	high_risk_execution 0→1, branch 2→0, safety 1→0, io 1→0, safety_bypasses 3→2, state_mutation 14→6
objective-c	abort	b.mm	high_risk_execution 0→1, branch 1→0, state_mutation 9→3
perl	system	b.pl	high_risk_execution 0→1, branch 2→0, safety 1→0, io 1→0, state_mutation 9→3
php	popen	b.php	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
powershell	kill	b.ps1	high_risk_execution 0→1, branch 2→0, safety 1→0, io 1→0, state_mutation 6→2
ruby	system	b.rb	high_risk_execution 0→1, branch 1→0, safety_bypasses 3→2, state_mutation 6→2
scala	Runtime.getRuntime.exec	b.scala	high_risk_execution 0→1, branch 2→0, state_mutation 6→2
scheme	eval	b.scm	none — see below
shell	sudo	b.sh	high_risk_execution 0→1, branch 1→0, io 1→0, safety_bypasses 3→2, state_mutation 6→2
solidity	selfdestruct	b.sol	high_risk_execution 0→1, branch 2→0, state_mutation 9→3
swift	assertionFailure	b.swift	high_risk_execution 0→1, branch 2→0, api 4→3, state_mutation 6→2
tcl	exec	b.tcl	high_risk_execution 0→1, branch 2→0, safety 1→0, io 2→1, safety_bypasses 3→2, state_mutation 9→3
typescript	eval	b.ts	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2
zig	std.process.exit	b.zig	high_risk_execution 0→1, branch 2→0, safety 1→0, state_mutation 6→2

Placement: every literal already sat inside its probe_state-family function except javascript, which had it at module scope in a.js — the exact python pilot shape (flat 500-char fallback let probeSafety's typeof dampen it). Moved into probeGlobals; eval then reads +1. dockerfile and makefile have no function bodies to scope to and needed none (no safety keyword in either file).

Four shapes worth recording

• The common case (25 languages). The retired "if" was a phantom branch inside the mutation probe, so state_mutation collapses by exactly ×3 on the scoped hits (state-flux-branch-weighting). E.g. matlab 14→6 = 4 scoped mutations dropping to ×1 plus 2 elsewhere.
• eval was never the danger keyword there. matlab, ruby, shell, tcl all match eval under safety_bypasses, not high_risk_execution — so their old decoy was measuring the wrong family and their safety_bypasses drops 3→2.
• Already-counting decoys. dockerfile (eval) and scheme (eval) already scored the danger hit; the redesign only strips the branch/io contamination. scheme moved no count at all — its sexp-anchored branch rule never matched the prose if, so its decoy now says what it always measured.
• swift api 4→3. The old sentence's "open" is a Swift access-level keyword, so it had been inflating api — a planted, scored column — from inside a string this whole time.

Not in A.1, noticed while sweeping

Four languages still carry the old shared sentence in their own vocabulary and are not on A.1's list: abap ('IF TRUNCATE FAILS TRY SELECT AGAIN'), assembly ("if jmp fails try syscall again"), cobol ('IF ALTER FAILS TRY OPEN AGAIN'), sqlite ('IF UPDATE FAILS TRY SELECT AGAIN'). Same defect, same fix shape. cobol and sqlite both have open items in this batch already (A.3's cobol *> @return, B.4's sqlite io 11) — suggest folding these four into A.3 rather than opening a wave 3. Seven languages have no string decoy at all (agc_assembly, css, html, jcl, markdown, yacc, yaml); css/html are A.2's.

After this branch's A.2–A.4 land, the A.5 regen should expect the branch/safety/io/state_mutation medians to move down across the board — the pilot's bucket-5 "honest language vs inflated median" wobble resolving, since 35 of 46 languages now read the same way.

[squid-protocol]

claiming A.2 — claude-opus-5 — same branch corpus/decoy-migration-wave2 (Batch A is one PR, so A.2 stacks on A.1's 32 commits).

Also done as asked: A.3 now carries the four languages A.1's list missed (abap, assembly, cobol, sqlite), and B.4 is annotated to re-read sqlite's io after that migration — the old sentence's SELECT is an io keyword there, so part of that 11 is corpus-side. Both edits are in the issue body.

[squid-protocol]

status A.2: done — 2 commits on corpus/decoy-migration-wave2 (plant(css), plant(html)), pushed. Both gates PASS, 6 planted cells filled, nothing else moved.

file	cell	before → after	planted as
a.css	globals	0 → 2	html {} / body {} inside probe-globals
b.css	safety_bypasses	0 → 2	*::before {} / *::after {} inside probe-bypass
main.css	doc	0 → 1	/** block on the entry at-rule
main.css	ownership	0 → 1	/* Author: ... */
b.html	telemetry	0 → 2	two navigator.sendBeacon(...) after probe_telemetry's <script>
c.html	cleanup	0 → 2	clearInterval(...) / clearTimeout(...) after probe_cleanup's

The four choices that were not free

• css safety_bypasses is not a bare * line. The rule's first alternative is ^[ \t]*\*, but * is also in the globals alternation (:root|html|body|\*), so * {} would have counted twice, in two different planted columns. *::before matches safety_bypasses and misses globals (no {/, after the *). An #id { selector — the rule's other alternative — would have tripped the class_start = 0 tripwire.
• css ownership is Author:, not @author. The doc rule is /\*\*\s*|/\*\s*@(?:param|return|author|…), so a /* @author … */ header lands in both doc and ownership. That is the livecode (+~14 siblings): doc rule claims 'Author:' which ownership already owns — every header author line double-counts (ada has the correct pattern) #2659 shape B.1 is filing a fix for — not something to bake into a baseline on purpose.
• html plants are element text, not on*= handlers. onclick="clearInterval(1)" fires reflection_metaprogramming (an input to risk_cognitive_load, so a scored column moves) plus listeners. Measured, then rejected.
• html telemetry is not <script src="…analytics…">. That is the rule's other form, but src= is an io keyword, so it would have added 2 io to b.html and muddied a planted column. And both plants sit deliberately outside the <script> tags: the polyglot splitter hands script bodies to the JS lens (ledger html-script-func-start-unreachable, html func_start is unreachable end-to-end: the polyglot splitter consumes <script>/<style> tags before html's rules run #2549), so a body inside the tag would exercise javascript's rules, not html's — the opposite of what this corpus measures.

For A.4 / A.5

• css io, state_mutation, cleanup, telemetry and html globals, high_risk_execution, state_mutation stay 0 because the registry defines no rule — those are n/a cells, not misses. Recorded in each manifest's notes.
• css api, encapsulation, dead_code stay 0 but are plantable (@property, @scope, /* .foo {). SPEC treats those four as plant-if-plantable, so they are a genuine gap — just not one A.2 asked for. Noted in the manifest so nobody re-derives it; suggest deciding in A.4 whether they get planted before the A.5 regen or ledgered as deliberate.
• Expect the A.5 regen to move css risk_documentation (doc+ownership now nonzero), css risk_safety_score (safety_bypasses 0→2) and html risk_* touching telemetry/cleanup. All six cells are planted intent, so they should move toward the medians, not away.

Next: A.3 (now including the four abap/assembly/cobol/sqlite decoys) unless you want A.4 first.

[squid-protocol]

A.2 follow-up pushed (plant(css): api + encapsulation on main.css) — gate now 80 assertions, PASS.

api was the one that cost a cell: _calc_api_exposure short-circuits to 0.0 when api == 0, so css read risk_api_exposure 0.0 against a 5.29 median purely because the probe was unplanted. encapsulation was not even a manifest key before; it is now pinned 1/0/0/0 across the four files.

dead_code deliberately left at 0, though /* .foo {} */ matches: no language in the corpus plants it, its median is 0, and the report scores a zero median on exact agreement — planting it in css alone would manufacture a red risk_dead_code cell instead of closing one. Written into the manifest notes so it is not re-derived.

For A.5 attribution: encapsulation_ratio is 1 - globals/(total_vars + globals) — a function of globals, not of the encapsulation signal. So A.2 planting globals 2 in a.css is what moves css off 1.0 toward the 0.75 median. Attribute it to the globals plant, not to the encapsulation one.

---

claiming A.3 — claude-opus-5 — same branch corpus/decoy-migration-wave2.

[squid-protocol]

status A.3: done — 10 commits on corpus/decoy-migration-wave2, pushed. Full-corpus gate re-run: 46/46 PASS. Every listed item plus the four folded-in decoys.

item	result
perl =cut	the big one — see below
apex Type.forName chain	dependency_links 0 → live; a/b/c popularity 1, betweenness .167/.167/0, closeness .25/.333/.375, producer_ratio .5/.5/1.0; api 0→3 each
agc CA-register args	args 2 → 13 (4/3/3/3), avg_func_args 0.167 → 1.0 = median
header @author swaps	apex only — agc and fortran were already clean
yaml single doc plant	doc 2 → 1
cobol *> @return (#2661 step 1)	doc 1 → 2 by design, ledgered, awaiting step 2
abap / assembly / cobol / sqlite decoys	migrated, all four gates green

perl =cut was not a doc nit

main.pl had =pod with no =cut. detector.py ~L3042 (the #2239 POD strip) blanks from a POD opener to the next =cut or, failing that, to end of file:

m_end = pod_end.search(safe_code, m_start.start())
end_idx = m_end.end() if m_end else len(safe_code)

So the whole of main.pl was invisible to the structural slicer, and the corpus had been recording that as perl's morphology. One line:

main.pl	before	after
avg_func_loc	0.0	6.75
avg_func_complexity	0.0	0.75
func_internal_density	0.0	0.111
structural_mass	104.52	11.9 (siblings 8.3 / 11.44 / 9.36)

That was functions_found 9 against a 13 median — exactly main.pl's four subs — and it is the direct cause of perl's avg_func_loc -27%, avg_func_complexity -38%, max_func_complexity -50%, func_complexity_gini -53%, func_internal_density -49%, control_flow_ratio -40% and structural_mass +212%. Seven cells from one missing line. The only signal it moves is doc 1→2, because =cut is in the same alternation as the POD openers with no pairing — the #2658 shape. Filed as #2670, ledger perl-pod-delimiter-double-count, and it belongs in B.1's single fix shape.

apex: one missing chain, seven cells

apex was the only language with no dependency chain at all — SPEC's main→a→b→c was never expressed, because apex has no import statement and nobody had planted Type.forName, the one idiom its _dependency_capture reads. Planting it closed dependency_links, dependency_density, popularity, betweenness, closeness, producer_ratio and risk_api_exposure: with popularity > 0 the Contextual Baseline Fix converts each file's 3 uncalled probes to api 3 (existing ledger shape, apex added to languages_seen). Deliberate collateral: Type.forName ×3 is also reflection_metaprogramming, a risk_cognitive_load input — attribute any cog movement there at A.5.

Header swapped // @author: → // Author:: apex's doc rule still lists @author, which ownership owns exclusively, so doc read 2 against a planted 1. agc and fortran needed nothing — post-#2659 their author line gives ownership only and a separate line gives doc. Verified, not assumed.

cobol is stuck at doc 2 until the engine moves

Planted *> @return the probe result, so doc is now AUTHOR. + the new line = 2. cobol cannot dodge this the way apex did: its ownership rule matches only AUTHOR. — there is no second header idiom — so the interim 2 is unavoidable, not a choice. Ledger cobol-2661-author-doc-collision, still_reproduces true; settles at 1 when #2661 step 2 lands.

agc: the gap was invisible for a reason

args counts register-target ops, \b(CA|CS|TS|…)[ \t]+(A|Q|L|Z)\b. Most probes opened with CAF ZERO, which looks like it should match and does not — \bZ\b fails against ZERO. Each function now opens with CA A (the argument arrives in the accumulator). b.agc's PROBESTATE had two args hits, so its surplus XCH Q became XCH TEMP, keeping state_mutation.

Two process notes

• A silent tooling bug, found and fixed: my notes-append helper compared json.dumps(old) (ASCII-escaped) against the file text, so any manifest whose notes contained an em dash matched nothing and kept its old notes while the tool reported success. Ten A.1 manifests were affected (ada, c, cpp, csharp, dockerfile, haskell, m4, perl, scala, tcl). Caught by auditing all 34 manifests for the marker string instead of trusting exit codes; backfilled in chore(notes). Counts and decoy outcome fields — GATING's actual citation requirement — were correct throughout.
• string-literal-selective-shielding updated: it still said "remaining 37 languages_seen re-author as their sweeps touch them". All 40 are done, and the entry now carries the screening rule and the five findings (eval is safety_bypasses not danger in matlab/ruby/shell/tcl; swift's api counted the prose open; abap's "third profile" was the Silencer Region; scheme moved no count at all; assembly keeps its ×3 flux because ret is a branch keyword).

Batch A is now A.4 (ledger, T1) → A.5 (regen + PR, T1). Not claiming either yet.

[squid-protocol]

claiming A.4 — claude-opus-5 — same branch corpus/decoy-migration-wave2 (keyword-rosetta).

Session-start checks:

• Pin: KEYWORD_ROSETTA_REF = c8edf78 = keyword-rosetta origin/main ✅
• Cache: docs/bias_data.json 2026-09-02 12:38:49 > last engine merge on main 12:27:35 (3ac9182 / feat(metrics): evidence-mass floor replaces the UEF's six small-file guards (#2655) #2667) ✅
• Branch up to date with origin/corpus/decoy-migration-wave2 (A.1–A.3, 46 commits).

One correction to the item before I start, from the current branch rather than from the pre-A cache: agc_assembly is already out of the args set. A.3's CA A fix took its args 2 → 13 and avg_func_args 0.167 → 1.0, i.e. exactly the median. A.4's list was written against the stale bias_data.json. So the extension covers seven languages — css, html, yacc, yaml, makefile, dockerfile, sqlite — and agc gets recorded as resolved-by-authoring, not ledgered as morphology.

[squid-protocol]

status A.4: done — 2 commits on corpus/decoy-migration-wave2 (keyword-rosetta, pushed). Full-corpus gate re-run: 46/46 PASS. Batch A is now A.5 (regen + PR) only.

Part 1 — the args shape

New ledger entry args-no-parameter-surface-morphology, signal: args|avg_func_args, disposition intended-morphology, over cobol + css, dockerfile, html, makefile, sqlite, yacc, yaml. Cited in all eight manifests' notes.

The shared criterion, checked per language against the live registry rather than asserted: the construct the corpus counts as a function (the language's func_start rule) declares no parameter list, and the args rule matches a different construct entirely — so SPEC's "each probe taking exactly one argument where the language expresses arguments" has nothing to attach to. Corpus-wide args against the 13 median: css 3, html 3, dockerfile 4, yacc 2, makefile 1, sqlite 1, cobol 1, yaml 0.

Where planting anyway is mechanically possible I priced it with finditer instead of hand-waving, and the split is the interesting part:

language	args rule actually matches	plant-anyway verdict
css	functional notation (calc|var|url|…) in declarations — all 3 hits are the @import chain's url("a.css")	calc() reaches 13 at zero overlap cost — declined on meaning
html	attributes (data-*, name, value, …) — the 3 hits are a.html's data-testid ×2 and main.html's name="author" ownership meta	data-probe= is clean (name=/value= also fires api) — declined on meaning
dockerfile	ARG — a file-scoped build variable, 1 per file by design	9 more ARGs are overlap-free (and unlike ENV, no globals) — declined: nothing would consume them
yacc	$$/$n, genuinely yacc's nearest parameter surface	rejected on cost: { $$ = $1; } also scores state_mutation, so 12 actions move a planted scored column to fill an unplanted one
yaml	a with: block — which binds to uses:, never to the corpus's run: steps	rejected on cost: a uses: line fires import and _dependency_capture → forged edges in the planted main→a→b→c DAG
makefile	$(call f,…) / $(1) — main.mk's one hit is its $(call probe_branch) dispatch	rejected twice: define matches the macros rule, not func_start (converting probes would delete 12 planted func_starts), and $(call …) fires the scored reflection_metaprogramming
sqlite	placeholders, VALUES (…), CTE parameter lists — all DML	rejected on cost: every DML verb that can carry one (SELECT|INSERT|UPDATE|DELETE|REPLACE) is also an io keyword here, and sqlite's io is B.4's largest residual

cobol-args-clause-match-morphology keeps its id (cited in data/cobol/expected_signals.json) and its two cobol-specific sub-findings, and now cross-references the general shape. The generalisation also gains cobol avg_func_args, which that entry's args-only signal never reached.

agc_assembly is not in the entry — as flagged on claiming. Its args rule matches register-target operands and the AGC calling convention really does pass an argument in the accumulator, so it has a parameter surface; A.3's CA A plant took args 2 → 13 and avg_func_args 0.167 → 1.0. Item list ticked with that correction written in.

Part 2 — signal normalisation

16 of the 61 entries held prose (import DAG / popularity), + separators, or (various). Every token is now a canonical name — a bias-report metric or a registry signal key — sorted and unique, with the contract written into the ledger's _doc. Audit: 62/62 conformant, every languages_seen a known language.

Three rewrites were judgment rather than transcription:

• The join is a cross-product, so a collective entry over languages with nothing itemised would mark their red cells explained — the exact "plausibly-explained wrong number" failure the tier table warns about. batch4-dual-keyword-overlaps drops dart, groovy, objective-c, scala, scheme, zig (no dual-rule keyword in their manifest notes; groovy's and objective-c's args behaviour belongs to ts-callparen-args); batch5-tier2-morphology-shapes drops markdown and yacc, both already covered by their own entries. Reasons recorded in each verdict, not just in this comment.
• markdown removed from no-dependency-capture-languages — a real mis-record, worth C.2/C.3 knowing. The entry had markdown as "no import rule at all", but a None import rule is not a None _dependency_capture: markdown defines a live capture (the inline-link form [text](target), wired by markdown: capture relative links as dependency edges (rosetta #2587, dependency_links 0 vs median 3) #2638) and its DAG resolves — dependency_links 3, popularity 0.75, betweenness 0.0833, producer_ratio 0.5, the same profile as python/fortran/swift. m4 and yacc remain, and their pinned family is now named in full: links/density/popularity/betweenness/closeness/producer_ratio 0, pagerank at the uniform 1/N 0.2, blast radius 200, api 0 and therefore risk_api_exposure 0.0 against a 5.29 median — that red cell is what this entry has to own, so the signal list says so.
• census-requires-git-tracked gets an empty signal. It is a workflow fact (untracked folders produce no numbers at all), not an explanation for a cell, and an empty signal can never match the join. Documented in _doc as the sentinel for that class.

Two red cells become explained as a side effect: jcl/api (batch5 now names api; na_check.py --regenerate shrinks docs/na_baseline.json from 28 to 27) and markdown/avg_func_args, added with functions_found to markdown-lit-plane-morphology, whose verdict already established both ("no callable units … hence functions_found 0"). That was the last red args-family cell in the corpus with no entry naming it. na_check.py reports no new unreviewed absences.

For A.5 and E.1

• A.5: A.4 changed no corpus counts — only ledger, manifest notes and the n/a baseline — so the regen's movers are still A.1–A.3's alone. Attribution stays as A.1/A.2/A.3 predicted: branch/safety/io/state_mutation medians down across the board, css risk_api_exposure/risk_documentation/risk_safety_score, html telemetry/cleanup risk columns, perl's seven morphology cells, apex's seven graph+api cells, agc avg_func_args.
• E.1: the join it needs is signal.split("|") × languages_seen, which bias_report.classify_na already does for n/a cells — E.1 is the same predicate applied to red cells. Two things to build in rather than rediscover: an entry with still_reproduces: false describes a resolved shape and must not explain a live red cell; and the _doc contract should be enforced by the tool (unknown token, unsorted, unknown language → fail), otherwise the next entry re-introduces prose.

[squid-protocol]

claiming A.5 — claude-opus-5 — same branch corpus/decoy-migration-wave2. Pin/cache re-checked at the top of this session (comment above); the regen is what supersedes the cache. Batch A is one PR, so this closes it.