Skip to content

0.7.0 integration: the answer-first stack reconciled with main - #710

Open
joyful-ii-V-I wants to merge 184 commits into
mainfrom
integration/070-1120
Open

joyful-ii-V-I wants to merge 184 commits into
mainfrom
integration/070-1120

Conversation

@joyful-ii-V-I

Copy link
Copy Markdown
Collaborator

The single 0.7.0 integration branch: the answer-first stack reconciled with main.

Two forked lines of 0.7.0 work plus main, merged into one branch. No rebase, no squash, no
cherry-pick — the merges carry the files in rather than replaying patches against a tree that lacks
them.

What this brings

144 non-merge commits over main (175 including merges). Of those, the part this PR had to
reconcile is 42 commits: integration/070-candidate and lane/r1b-priority share a merge base
2f5561c26 that already sits 54 commits past main, and diverge from it by only 23 and 19. The rest is
shared stack history that was already reconciled below that base — lane/af1-answerfirst (AF2) among it,
which is an ancestor of the base and so needed no landing step of its own. --cherry-mark finds
zero duplicate patches between the two lines.

By theme:

  • Answer-first --for — the paged answer (--page-bytes=), the key-body block
    (src/forkeybody.h), the signature index and the page layout (src/forpages.h, src/forsigx.h),
    and the page budget's explicit priority order.
  • --pack-task D1 rebuild — the --for head, the file tail, one key body, one token conversion;
    the tail's declared share is a floor; a truncated served body is disclosed as a cut.
  • Capped bodies (CB1) — the key block carries kKeyBodyMax = 5 (was 2) under a new monotone
    120-line cap, kCappedBodyLines.
  • --for routing (RT3) — call-path and quoted-literal questions are vetoed; a windowed routed
    answer continues itself.
  • --impact first window (IM1) — production rows and evidence importers lead it.
  • Macro see-through ceiling (BX2) — a per-macro ceiling on --callers/--uses see-through.
  • Verb/attribution fixes (BX1) — defGroupsRenumberMatches collects a dropped group's member so a
    printed table still lists it.
  • An opt-in SubagentStart primer hook, the --legend-seen= flag, --no-verb-route, one aggregate
    ci-gate job, and gate hygiene.
  • From main: the --lsp client-declared-language path and its --lsp-langmap= alias map, and the
    train-1117d1 extraction work.

How the merge was done

Union first (integration/070-candidate × lane/r1b-priority, zero human conflicts), then
main by sha ee8d1a50ea9be710c9b7b6a875b1afa7073d074c — by sha, not by name, so a concurrent
fetch cannot move the target. Both merges went through the repo's own scripts/merge_main.sh +
scripts/merge_resolve.py, which set-merge test/regression.sh's absorb list, settle the gatecount
sites, mark the binary-pinned files REGEN AFTER BUILD, and refuse a kParserVer that does not clear
both sides' bumps.

main left 13 files / 17 hunks for a person. The ones worth a reviewer's eye:

  • src/defattrib.h — the only genuine two-sided refactor collision. main split
    defGroupsDropSilent into defGroupsSilent + defGroupsDrop + a thin wrapper; the stack kept the
    monolith and added defGroupsRenumberMatches above it, so the naive merge left two definitions of
    one function in one header
    , which cannot compile. Resolved to main's structure with the stack's
    helper kept
    , because the stack's only semantic change to the monolith was replacing its ofMatch
    loop with that helper — and that loop lives, under main's split, inside defGroupsDrop. Main's
    split is therefore a strict superset of the shape the stack's change needs. In the second hunk main
    changed one word of a comment where the stack changed the behaviour, so the behaviour is kept
    (test/verbfixcheck.sh arm F7 pins it).
  • kParserVer / kIngestParserVerMirror — main 331, the stack 317, base 313. Both moved to
    332 (max+1), rich file tag 333, so neither side's cache can be read by the other's binary. Both
    provenance lists are kept as labelled history. test/qschemetrip.hash is re-pinned from the merged
    build
    (0a4ba8ec92…): neither side's value could be right once the parser version moves.
  • The flag-arm counters — base 27/225, main 27/226 (--lsp-langmap=), the stack 28/228. Neither
    side taken: 28 / 229, with both provenance lists merged. The three prose "long flags" counts went
    to 199, which is not an arithmetic guess — it is --help=all counted the gate's own way on the
    built binary.
  • skills/ripwire-mcp/SKILL.md — the stack split this skill into 7 files while main edited the
    monolith. The split is kept and main's two LSP-langmap commits (9b8c57052, b47088b6e) were
    ported into transports.md, the split file that owns --lsp: the textDocument.languageId
    path, the config search order, the [overrule] suffixes rule, and the explicit-@lang exception.
  • test/legendcoveragecheck.sh and src/mcpverbs.h — independent additions on both sides; both
    kept. The gate asserts no file-wide arm total, so the concatenation runs strictly more arms.
  • test/compactlegendfix/pre_l1_full/callers.xml — a hand-re-anchored pin, not a generated file.
    Both sides' edits were characterised mechanically and both applied; the result differs from main's
    side by exactly the stack's two insertions and nothing else.

Three gates exist on main and on neither line, and a merge taking the stack's side of
test/regression.sh would have dropped them silently.
fnvbasischeck, langordercheck and
qdrangecheck are all present and registered (two in the absorb list, one invoked by name). The
registry check proves the stronger statement: all 898 top-level test/*.sh files are registered exactly
once, no duplicate and no orphan — so no gate from either side was lost.

Measured gains (lane R1b, on lane BL1's units and instrument)

  • Body rung: 9 → 20 of 89 cells complete, 14 cells up, ZERO down, closing 11 of the 21-cell
    composition gap BL1 measured. R1b's control arm reproduces BL1's baseline body figure exactly
    (9 of 89), which is the strongest instrument agreement available between the two lanes.

  • Bytes: page 1 never grows by more than +679 B in any cell, 0 of 89 cells exceed the pre-registered
    +1,500 B per-cell cap, no cell's whole answer grows at all, and the population sheds 481 B on
    page 1 and 2,145 B overall.

  • Guard B-FILE-GOLD at zero tolerance: PASS — 122 → 122 gold FILE rows, 0 cells up and 0 cells
    down, and not one of the 11 repos moves in either direction
    (Newtonsoft.Json, bash-it, bat, black,
    eslint, gson, jq, libzmq, restic, sinatra, zod).

    That pass must be read with R1b's own caveat, which is the most important one in its readout. The
    loss channel is wide open: 33 of 89 cells do lose page-1 tail rows, 773 rows in total. The gold
    simply does not live in those rows — this population carries a median of 1 gold FILE row per task. On
    the orient-shaped cells that originally failed this guard, 8 of 9 losses persist. So the honest
    statement is "the file rung is unharmed on localisation-shaped questions, and the orient-shaped class
    is unmeasured here", not "the file rung is safe".

  • Function rung: +2 to +4 cells under every one of seven scoring definitions, with zero cells falling
    under any of them.
    The level is deliberately not quoted here: R1b re-scored the same answers seven
    ways and none reproduces lane BL1's 62, so BL1's grader remains the instrument of record for the
    level and the two must not be quoted side by side. Direction and the zero-loss property do not depend
    on the definition; the level does.

Three honest caveats

1. forkeybodycheck is RED, deliberately, and it is a real contract defect — not a gate to argue
with.
Owner ruling 87 names the fix: insertKeyBodies should stop passing the served argument to
keyBodies, so a body already on page 1 is not suppressed. The call is at src/forkeybody.h:253 (:239
is the declaration — an earlier mis-citation, corrected here). It is a one-argument, one-line change
that is unimplemented, identically, on both merged lines
— nobody has written it. Owner ruling 95
settles that it lands as a FOLLOW-UP PR with its gate written first
, and the reason is not scheduling:
87's gate has to be written red-first so that its green carries information, and that cannot happen
inside a 42-commit merge whose suite is green for other reasons. So the red here is carried knowingly,
not tolerated. Measured cost of leaving it: +2,145 B in one cell.

2. The function rung's LEVEL is not quoted beside lane BL1's 62. See above — seven definitions, none
reproducing it. Only the delta statement is quotable.

3. The programme's headline completeness pair was measured on a DIFFERENT configuration than the one
this PR ships.
The frozen candidate binary (built_from=79052376e) carries the fork-base answer-first
code: kKeyBodyMax = 2 and no line cap. This branch lands CB1's raise to 5 plus the 120-line
monotone cap
. Every figure quoted from that binary therefore describes code this PR does not ship. The
two agree on the body rung at 9 of 89 — and that agreement is expected rather than evidence of
equivalence, since this population's median task needs one body, so a cap of 2 is not binding for most
of it. Owner ruling 94 settles the consequence: the headline pair WILL be re-measured on this
branch's binary before 0.7.0 ships.
So this is not an open question but a ruled, pending step, and
until it completes the published pair describes a configuration this PR does not ship. The
re-measurement is a separate lane's work and is deliberately not attempted here — it needs this
binary first.

Verification

Built with cmake --build build --clean-first -j4 on a plain dev configure (never
-DCMAKE_BUILD_TYPE=Release, which would compile DEGRADED_PATH_ALERT out). --clean-first is not
optional here: this merge moves kIngestParserVerMirror, which is the repo's own worked example of a
stale object surviving repeated successful rebuilds. Exit 0, zero warnings, zero errors, and
--version reports built_from=0ebd18b66, equal to the branch tip.

Full gate suite:

python3 test/pargates.py . ./build/ripwire -j 2
gates=898 pass=891 fail=5 skip=2 wall=5055s (84 min) tree_writes=0

898 gates is exactly the registry total, and tree_writes=0 is the runner's own proof that nothing
edited the tree while it ran.

Eight failed on the first pass. Three were a procedural error of mine, not the merge: I built at the
main merge and two generated-file commits landed on top, so the binary's built_from trailed HEAD while
no src/ file differed. versioncheck, versionlabelcheck and mcpreloadasancheck were all correct to
fire, and all three pass after the clean rebuild at the tip.

The five real failures, each attributed against an unmodified ee8d1a50e build. None is main's.

gate main ours attribution
forkeybodycheck (K3) not on main FAIL expected, ruling 87 — see caveat 1
langidentitycheck PASS FAIL the binary, not the tree (below)
loopconservationcheck PASS FAIL inherited from stack history, not fixable here
showcasecapturecheck (D) PASS FAIL a merge resolution loss; generator refuses to re-record
w3fixbudgetcheck (H2) PASS FAIL --pack-task RP monotonicity, 1 of 24 points

Three of these want a maintainer's eye, so the detail is here rather than buried:

  • langidentitycheck fails on the binary, not on any source change. The shared-file Lang::
    ratchet is counted through the tool (runner.py --ratchet-only runs the binary's own --regex over
    src/), so I crossed tree × binary in all four cells: main's tree with our binary gives the same
    326/FAIL, and our tree with main's binary gives 325/PASS.
    A source-level count of distinct
    == Lang:: / != Lang:: lines is identical between the two trees, file for file. All three merge
    parents carry ceiling 325, so no side raised it. I did not raise the ceiling — the ratchet file
    says it may never rise, and there is no new predicate to move, so the gate's own suggested remedy does
    not fit this cause. This is a gate whose subject is the source but whose instrument is the binary, and
    it needs a decision rather than a lane's edit.
  • loopconservationcheck names a historical stack merge (2550bfdcd, absent from main) in which
    phantomdefcheck left the loop before the commit that declared its tombstone. The tree as it stands is
    correct and self-consistent — test/regression.sh:290 carries the # retired: tombstone and the gate
    file is absent from both trees — so this is bookkeeping in history, not a missing retirement, and it
    cannot be corrected without rewriting history.
  • showcasecapturecheck (D) reports 3/192 flags uncovered: --legend-seen, --no-verb-route, --page-bytes. Both sides carried the same dated capture and it conflicted; the tool took main's side.
    Neither side's capture is right for the merged binary — main's covers --lsp-langmap and misses the
    stack's three; the stack's covers all three and misses --lsp-langmap. The dictv pair was already
    re-recorded to the merged binary's. I ran the prescribed generator, test/showcase_capture.py, and it
    refused to write: its own window guard finds no --since=HEAD~N in [2,14] that demonstrates what
    the --in=src case promises on this merge-heavy tip. That is the generator behaving correctly, so the
    capture cannot be re-recorded on this branch as it stands. I did not force it and did not hand-edit the
    capture's "Not run" list to silence the arm — the flags are runnable, so listing them as not-run would
    be a false record.

Other verification:

  • Determinism: two full map runs byte-identical (26,405 B).
  • Well-formedness: xmllint --noout clean; zero newlines outside CDATA (G4).
  • --quality-delta: rc=2, regressions=111, minor=75, gating=2, with baseline="ref-pair"
    against ee8d1a50e. The ref-pair form is deliberate: on a committed tree the bare
    --quality-delta compares the tree against its own HEAD (head_basis="identity") and reports
    regressions=0 whatever the branch holds, so that green is free and is not quoted here. Both gating
    rows are inherited, not introduced
    : packBodies is byte-identical to lane/r1b-priority's and
    test/testrowpaths.py is unchanged against it, and the aggregate 111/75 is 144 commits from many
    lanes, each already accepted on its own.
  • ASan/UBSan: built --clean-first with -DRIPWIRE_ASAN=ON, exit 0, zero warnings, and six runs
    clean under -fno-sanitize-recover=all. The runs were chosen to actually enter the changed code: the
    default map carries no answer-first marker at all
    , while five --for/--pack-task runs at
    --page-bytes= 12000/8000/4000/2000 and a --pack-task run all show page="1", deferred=,
    capped="1" and the <bodies> block. What ASan does not reach, stated rather than glossed: under a
    sanitizer the CMake condition links neither allocator TU and leaves RIPWIRE_MEM_CEILING_HOOK
    undefined, so ASan structurally cannot exercise the memory ceiling this branch carries — that path's
    evidence is memceilingcheck in the plain build's suite, which passed, not the sanitizer run.
  • No stale-object artefact appeared anywhere: no std::length_error, no bad_alloc, no sanitizer region
    divisible by an old sizeof(Symbol).

Not in this PR

  • Ruling 87's one-line fix (above) and its gate — a follow-up PR, per ruling 95.
  • The PUBLISHED count snapshots, deliberately left alone (owner ruling 96). They are a dated
    snapshot, not a per-branch value
    — merge_main.sh says so in its own header. On this branch the
    published gate count still reads 876 (dated 2026-11-19) where the registry now names 883, and
    docs/LIMITS.md still reads 447 caps against a live 452. Both were verified not brought
    current by this merge, and both generators' --check passes, so the tree is self-consistent as it
    stands. Refreshing them (python3 docs/counts_snapshot.py refresh) is a separate pass after this
    lands — a regenerated published count that later proved wrong should not be attributable to this
    merge. What is in this PR is the merge's own gate-count regeneration, which manifestcheck
    requires; that was regenerated, never hand-edited.
  • The headline completeness re-measurement (ruling 94) — a separate lane, which needs this binary.

🤖 Generated with Claude Code

joyful-ii-V-I and others added 30 commits November 18, 2026 11:41
…ured

`--impact=intersection` answered `of="intersection" defs="1" reaches="2568"` and never
said WHERE that one definition is. Its file appeared only when a caller happened to live
in it; on textual's Region.intersection none does, so the blast radius of a change left
out the file the change is made in. A multi-group selector already lists its groups as
<def ix= t= [sc=] p=file:line/>; the one-group answer now prints that same row.

No new attribute and no new element: the compact legend's existing `def ix=` reading
applies, and --legend=full gets a one-sentence clause of its own (kSoleDefLegend), because
the multi-group clause describes of_def tokens no row of a one-group answer carries. Every
dialect of the verb: XML, columnar, --json def_table, MCP impact.

SCOPE: --impact only, by a stated reason. The radius of a change includes the file the
change is made in, so the definition is part of this verb's answer set. --callers,
--callees and --safe-delete keep the one-group answer without a table, as
attribmultidefcheck pins; impactsoledefcheck arm (6) holds that line.

MEASURED (lane t2-rankdefects, bar pre-registered; development data, the item-grain gold
is spent): on the 298 graded cells 211 -> 213 complete, 0 cells lost completeness, 282
cells byte-identical, cross-gold full pairs 253 -> 253 of 1,742. Over the 24 --impact
cells +1.84 % bytes against a 2 % bar; a row is 64 B, the rest is the legend clause, which
a --legend-have reader does not receive.

GATE, written first: test/impactsoledefcheck.sh, 19 arms, 8 of them red on the parent.

RE-PINNED, each by design:
  * attribmultidefcheck d_one: the one-group --impact arm now pins exactly ONE <def> row
    and still no of_def / prov on any row (plainSole).
  * compactlegendcheck A-PIN impact.xml: previous pin equals the parent binary byte for
    byte; the new one differs by the row and the clause, 4575 -> 4844 B.
  * test/legend_over_target.tsv: the clause registered present-only on ripwire.impact/v1,
    loop, mcp:impact (126 B) and full:impact (230 B).
  * printf_parity.manifest: impact and impact_json, the only two labels that moved.

OWED AT INTEGRATION (not editable from this lane): a changelog.d fragment, and
`docs/counts_snapshot.py refresh` — this gate takes gates.scripts drift to 11 against a
bound of 10, and the refresh rewrites docs/TUNING.md, LIMITS.md and EVALS.md.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
… is 1

--impact lists the files that import a file defining SYM as <f> rows. Every
one was printed <f via="import" p="…" lazy="0|1"/>. via="import" was a string
literal of the one emitter that prints the row (serialize.h emitImportRowsXml),
so it could not differ between two rows, and lazy="0" is the default arm of a
two-valued flag. Counted before the change: 2,898 of 2,898 rows carried the
literal and 2,844 of them lazy="0" (264 --impact answers: 24 graded cells and
240 drawn); the 100% rate is the source literal, not the sample.

THE RULE IS CONTEXT-FREE. A row gains via="import" before p=, and lazy="0"
when it has no lazy=. Nothing else is read, so the pre-change answer is rebuilt
from the delivered answer alone and every grader returns the verdict it
returned before. The --json dialect is untouched: a JSON reader has no tag to
read the kind from, and its import_reach array is the gate's second reference.

MEASURED on a draw registered before it was run (results/T3_LOSSLESS_1118,
PREREG Amendment 2): 160 --impact answers over 20 shallow corpora, 1,597
importer rows. The <impact> element is 3.02% shorter and the whole answer
3.97% (45,866 of 1,156,210 B); 160 of 160 rebuild byte for byte, no answer is
longer, 45 carry no importer row. On a frozen export of this repository
6.89% (n=12, 12 of 12 rebuild). The verb is 2.8% of the 298-cell graded
population's bytes, so the population-level saving is about 0.14%.

THE LEGEND. The compact reading of lazy=1 stays present-only, so it now prints
only where a lazy row is; what a row WITHOUT lazy= claims is a new reading
keyed on <f p=> under the impact schema, so an answer with no importer row pays
nothing. bench/legendtier/census.tsv is amended by derivation and says so in
place: the 22 of 39 answers that carried lazy on <f> are exactly the answers
that carry an importer row, so they carry the new `p f` entry; `lazy f` is
withdrawn rather than guessed (the census corpora are not in this repository;
13 of 264 answers carried a lazy="1" row on three other populations, under the
one-third rule). Without that the impact pack fails legendtiercheck K3 at 3.19x
(it priced a clause most answers no longer carry); with it, 2.84x.

THE GATE (test/importrowshortcheck.sh, 38 arms plus an opt-in scale arm; 21
red on the unmodified binary) reconstructs the dropped bytes and compares the WHOLE <impact> element
against two independent references: goldens captured from 994f002, and the
--json import_reach array. Mutation controls (a deleted row, a changed path, a
lazy flag added, one removed, a moved count outside the rows, the golden fed
in as new output, an empty document) each go red for the named reason.

Re-pinned, each by design: test/printf_parity.manifest (impact and help_all,
exactly those two of 42), test/compactlegendfix/pre_l1_full/impact.xml (by
hand, reversible by the same rule), and the row text eight gates grep for.
compactlegendcheck D27/D30 read their lazy= row from test/impactimportfix, the
one committed corpus with a lazy importer.

Not done here: docs/COMMANDS.md and the dated captures still show the old row
(docscommandscheck arm G is red at 994f002 before this change), and no
changelog.d fragment is written.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
…ss, 19.1 % of --affected bytes on the holdout

Owner directive 2026-11-18: the objective is the complete answer in the fewest bytes, and a LOSSLESS form is
approved even where it reverses E1 (2026-09-12, "every path verbatim", brace groups disqualified by name).
Paging the test list is not approved and is not done: every file is still named in the one call.

MEASURED FIRST (T4's 408 --affected answers, 27 repositories). The <g> lists are 48.3 % of the verb's bytes
and no path repeats inside an answer, so a table has nothing to index; what repeats is the directory and the
extension of sibling files. Share of all --affected bytes, census / holdout:
    flat per-directory runs  dir/{a,b}            12.5 % / 14.1 %   (the earlier E1-blocked design)
    per-answer directory table                    13.5 % / 15.0 %
    nested directories       a/{b/{x,y},c}        16.4 % / 17.2 %
    nested + extension       a/{b/{x,y},c}.py     19.8 % / 20.7 %   <- built
    the same, any-character suffix                20.6 % / 22.2 %   (declined: it splits file stems)

THE FORM
    <g hops="2" n="4" pf="src/{a/{x,y}.test.ts,b.ts},README" run_each="node {p}"/>
    [hops=2] (4 folded): src/{a/{x,y}.test.ts,b.ts}, README   (run each: node {p})        (--situ)

THE READER'S RULE, which needs no ripwire: split on the commas outside braces; PRE{A,B}SUF stands for
PREASUF,PREBSUF in that order, braces nest. It is bash brace expansion over comma lists, and it yields exactly
the n= paths in the order p= listed them.

WHAT KEEPS IT UNAMBIGUOUS AND KEEPS SMALL ANSWERS STILL
  - the row is RENAMED (pf=, "(n folded):"): p= / "(n):" are verbatim exactly as before, and a reader that
    knows only p= fails loudly on a folded row, never wrongly;
  - a list with a literal '{' or '}' in a path is never folded;
  - only contiguous items are grouped, so evidence order is the expansion order by construction;
  - a row folds only when that saves 8 B and a document only when its rows save 256 B in total; below the bar
    the answer is byte-identical and its legend says nothing about the form;
  - --affected, --test-gate and --situ opt in. JSON and every other verb on the row seam are byte-identical;
  - tests=, shown_tests=, run_first=, n=, the commands and the exit codes are computed as before.

HOLDOUT (211 change sets, three verbs, 639 cells; base = this branch's parent):
    --affected   719,387 -> 581,811 B  -19.12 %   folds 43 of 206, the other 163 byte-identical
    --test-gate  997,534 -> 859,958 B  -13.79 %
    --situ       833,229 -> 688,837 B  -17.33 %
  0 exceptions to "unfold(new) == base byte for byte outside the legend"; 0 exit codes moved; two runs
  byte-identical; one fired cell re-expanded by bash alone and compared with cmp.

NOT BUILT, BY MEASUREMENT: complement encoding ("every test file under R except these N"). A large answer
spreads its files over a median 18 evidence keys, so at most one row could be a complement: a 0.55 % ceiling
with the EXCEPT list priced, over a universe (what the crawl indexed and isTestPath accepted) a reader cannot
recompute from the answer or from the disk.

GATE, written and red before the source: test/affectedfoldcheck.sh. Three independent references — goldens
captured from the parent commit's binary (test/affectedfoldfix/golden), test/lib/pathfold.py (a reader and a
writer written from the rule, sharing no line with the C++), and bash's own brace expansion. Arms: unfold(new)
== golden for XML and --situ; the binary's fold == the reference writer's; what must not move (the
under-the-bar fixture, --json, --exercises, --pack-task, a literal-brace row beside folded ones); counts,
commands and exit codes; twelve mutation controls that go red; legend present-only; determinism; xmllint.

test/testrowpaths.py expands a folded row, so the gates that read through it are unchanged. Two private readers
learned the form: listingpagingcheck counts "(n folded):" as n files, and w3fixlegendcheck, which grepped full
paths in --situ's text, now reads them through the shared reader. The shard weight is affectedcheck's, borrowed,
not measured.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
`python3 docs/counts_snapshot.py refresh`, nothing hand-edited. affectedfoldcheck took the gate-script drift
from the bound (10) to 11, so the per-PR check asks for the refresh in the same change. The other moved totals
(caps, constants, tuning names) are drift that predates this lane. Kept as its own commit so an integrator who
refreshes on the train can drop it.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
…limited make -j

test/lib/headbinlib.sh built the HEAD comparison binary with a bare `cmake --build -j`, which hands make an
UNLIMITED -j: every translation unit of the ripwire target compiles at once, 1.3-3.4 GB per clang at -O3. On
2026-11-18 three such builds ran at once beside a runaway ripwire and the machine ran out of memory.

headbin_jobs now picks the count: CMAKE_BUILD_PARALLEL_LEVEL, else RIPWIRE_HEADBIN_JOBS, else the logical CPU
count under GITHUB_ACTIONS (the staging step runs alone on an idle runner, so CI keeps every core busy as
before), else max(1, min(ncpu/2, GiB/8)). A set but non-integer override is ignored with one stderr line.

bench/recalleval/run_r3diff.py's --jobs default was os.cpu_count(); it is now half the cores, at most 6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…emand reference files

An invoked skill loads its whole SKILL.md and keeps it in context for every later turn. The bodies
were 261,872 B in total (median 9,478 B, max 41,668 B), so one average invocation cost 3-5x the
entire per-session skill listing. Each SKILL.md is now the routing line, the decision, the one-call
recipe, the stop rule and how to read the answer's honesty signals, plus an index of reference
files in the same skill dir. Every other line of the old bodies moved verbatim into those files
(flat *.md beside SKILL.md, the house pattern; installed by install(DIRECTORY skills/) and by
install.sh's directory link/copy).

  SKILL.md total            261,872 B -> 52,931 B
  median / max              9,478 / 41,668 B -> 3,072 / 3,787 B
  frequency-weighted bytes per invocation (local verb telemetry) 26,254 B -> 3,553 B (-86%)

Descriptions are unchanged: filler-only cuts saved 86 characters (1.7%) and cost 2.4 pp of dev-split
bm25-desc routing (the swap trap again), so they were dropped before any held-out measurement.

Measured under the pre-registered following check (33 tasks, blind sonnet + fable raters given only
the skill text): correct first command 32/33 on both the old and the new bodies, per rater; the new
bodies sent a rater to a reference file on 1 task of 33. Lexical routing: bm25-desc unchanged
(split=test 64.6%), bm25-full judged 90 -> 94/160, for-routed judged 95 -> 100/160.

Also fixes text that was already stale: the router's primer said quality-delta covers 10 kinds and
that exit 2 means new debt; it covers 12 and exits 2 when code that already existed got worse.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…disclosed next=

OWNER DECISION 2026-11-18. `--for` answers answer-first by default (item R, until now
--legend=last) and stop after about 12 KB of rows. The coordinator's pricing on T6's
re-run answers turned the single stop into PAGING: every page continues the same row
stream at the same size, carries its own next=, and re-sends no legend. Pre-registered in
results/AF1_ANSWERFIRST_1118/PREREG.md before any src/ change.

WHY 5ee3ddb MADE IT OPT-IN, MEASURED. On the 154 design cells answer-first moves the
cut/floor MARKERS into the prefix (first marker past 2 KB: 93/147 legend-first, 8/147
answer-first) and moves their READINGS out: a bare 12,000 B answer-first prefix shows a
marker with no definition inside it in 137/154 cells (legend-first 0/154). A PAGE is not a
bare prefix: page 1 keeps the WHOLE document legend after its rows and before </ctx>, and
its own cut rides the ROOT (page= pages= withheld_bytes= next=), so the reader holds every
reading of every marker it was served. That is the collapse condition 5ee3ddb wrote.

THE MECHANISM (src/forpages.h). The answer is rendered whole, permuted answer-first, then
cut at row boundaries (rowvalue's row_cuts granularity; never after a comment or a section
open). Page 1 is the largest cut <= P from byte 0; page k the largest cut <= c(k-1) + P.
A continuation page is the ref posture: a slim root, the re-opened section, its rows, and
<about legend="ref" have="page1" .../>. est_tokens= prices each page as delivered in the
emitter's two rates; scaling the whole answer's number UNDER-read by 571 tokens on
formaxtokenscheck (B), because the bytes a page drops are not the answer's average mix.

NOT A SECOND MECHANISM. --token-budget sheds (forbudgetfit.h) and is a different contract:
the budgeted path keeps its legend-first shape unless --legend=last is SPELLED, and
--page-bytes refuses beside a budget. The page vocabulary reuses next=, the ref posture's
<about> and forUnbudgetedCall for the call every next= extends.

OPT-OUTS. --legend=first is the legend-first order, unpaged: byte-identical to the base
binary's default on 203/203 cells. --page-bytes=0 is the whole answer in one call:
byte-identical to the base binary's --legend=last on 203/203. ho-llvm-01 is PENDING (the
llvm memory defect lane M1 is fixing), not dropped.

GATES. test/forpagescheck.sh (new, P1-P9): row identity of the joined pages against
--page-bytes=0 at two sizes with a dropped-row negative control, no legend re-sent,
next= chains, determinism, refusals. Re-pinned for the new default, each with a reason
in place: foranswerfirstcheck (R9 -> R9 opt-out + R9d default), forrankordercheck (a
reading must ride a legend comment of THIS answer, not only one ahead of <sigs>),
budgetmonotonecheck (U is the whole legend-first answer a budget sheds), compactlegendcheck
(UG) and legendcoveragecheck (an answer-first legend trails the rows), printf_parity
(help text), flag counts 195 -> 196 (README x2, guide, deck x3), skill home for the flag.

OWED, not done here: showcase capture + docs/COMMANDS.md regeneration (showcasecapturecheck
(D) names --page-bytes uncovered), docs/gatecount_build.py (it writes docs/EVALS.md),
EVALS amendment text, changelog.d entry, MCP paging.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
tools/list is paid in every session by clients that load MCP schemas eagerly,
before the first question. On the base (82ed4c8) it was 47,411 B by
mcpmanifestcheck's metric (~11.9K tokens at 4 B/token, ~19.4K at 2.44).
17,365 B of that was description prose after the 33 pinned routing sentences.

Trimmed only that prose: descriptions 22,498 -> 15,133 B (UTF-8), manifest
-7,471 B (-15.8%). What went: clauses that repeated a property description,
the answer's own legend (XML verbs), the readOnlyHint annotation ("read-only"),
or described implementation: the short @file:LINE pointer (every field that
takes a seed already says so), the JSON key lists, the exemplar ordering rule
(still whole in the answer's legend; the "chosen by ROLE" phrase stays), "Same
handler as the CLI", cost-model notes. What stayed: every floor/"not a proof"
caveat, refusal and side-effect clause, band (1..12, 2..16, 1..1000),
batch's served set and derived exclusion count, valueRefs, the tests_to_run
row-shape clause for the legend-less JSON answers (304 -> 271 B, same facts),
and the full @file:LINE sentence on find_symbol.

Gate first: test/mcplisttrimcheck.sh pins every stanza minus its description
(names, order, inputSchema incl. property descriptions, required, annotations)
against test/mcplist_structure_golden.txt taken from the base binary, a 39,970 B
ceiling, two-server determinism, and a mutation control. RED on the base binary
(ceiling arm), GREEN here. mcpmanifestcheck's ceiling ratchets 47,420 -> 39,970
and its (1c) whereis twin moves 701 -> 545. Registered in regression.sh,
shard weights and gateexitcheck FAILFAST.

Owed (not touched by this lane): docs/counts_snapshot.py refresh
(gates.scripts 852 -> 853; it rewrites README, docs/EVALS.md, the deck and
docs/counts.tsv), and a changelog.d fragment.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…f (RIPWIRE_MEM_BUDGET_MB)

On 2026-11-18 a run over llvm-project grew ~5 GB/s inside buildGraph's resolve loop and reached 149.7 GB. The
memory guard (memguard.h, 65% of RAM) reads the footprint only at phase boundaries, in the crawl/parse workers
and in the file-graph fold; nothing between "graph-tables" and "graph-end" reads it, and one call can grow
without bound.

src/memceiling.h reads the footprint at operator new (largealloc.cpp, macOS): every allocation of 256 KiB or
more, and once per 64 MiB of smaller allocation per thread. Past the ceiling it refuses: one stderr line from a
stack buffer (no allocation inside operator new), nothing on stdout, std::_Exit(5) -- 5 is the memory refusal
everywhere. Disarmed it costs one relaxed load per operator new. --mcp/--lsp and builds that do not replace
operator new do not arm it and say so on stderr; a malformed value refuses the run (exit 1), as
RIPWIRE_MAX_MEMORY does. memstats::mark records the last phase boundary for the refusal line.

Proof, run once alone under the watchdog: llvm-project with RIPWIRE_MEM_BUDGET_MB=4000 refused with exit 5
at a 3018 MiB footprint, before a 1760 MiB allocation, after phase "model" (watchdog peak RSS 2723 MB).

test/memceilingcheck.sh: refusal shape and exit 5 at the floor, the unset control, byte-identical output
armed far above the need, typo refusals, and an MCP server that stays up under the variable.

infra/envnumber.h: the environment whole-number reader RIPWIRE_TAIL_SYM_WIDE_ROWS and the new knob share.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… or a signal-kill as its own state

A runaway ripwire with no timeout ran until macOS killed it, and the bench scripts read the result as an empty
answer or a generic error. The whole-repo spawns in bench_proof, scip_amb_precision, scip_match_diag,
scip_pin_precision, svectorab, timing_determinism, nestcal/measure, slice/run_slicerecall and legendtier/census
now carry a timeout, and a timeout or rc < 0 is reported by name instead of being counted. MCP sessions
(mcp_session_timing, spec_trace) read each reply through one bounded reader that raises TIMEOUT or KILLED.
A normal run's output is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ied to the default page size

Built from results/AF2_FIRST12K_1118/READOUT.md §SPEC (frozen after meeting its pre-registered bar:
within 12 KB, design 70->75 of 99, held-out 32->33 of 39, 0 flips). Order only: every byte of the
answer is still emitted once.

A  A comment that is a direct child of a top-level section (<graph_verb>, <reexports>, <fold> notes)
   joins the document legend; a zero-row self-closing <lego/>/<compose/> stub between <sigs> and <tail>
   goes directly after </tail>. A populated lego/compose does not move.
E1 Inside <graph_verb>, <met_bridge> is emitted ahead of the <path_gap> sides (an emitter swap).
G  GUARDED promotion: a RES section after </tail> (lit, dotted_strings, graph_verb, callers,
   selfhooks, manifest_rows, listed, ep, reexports, exemplar_family) moves directly ahead of <tail>
   only if the tail has more than 24 rows, ends past the stop, and tail row 24 still ends within the
   stop with it in place. The stop is kAnswerPageBytesDefault, the ONE default page-size constant that
   forpages.h's default IS, so the guard follows the owner if the default page becomes 6 KB. It is not
   per call: every page size windows the same document, so --page-bytes=0 stays the row-identity
   reference for all of them. The unguarded variant is an owner call and is not built.

ONE DEVIATION FROM THE SPEC, and why. The spec also lifts <sigs>'s demote:/decl-twin:/one-side:
comments. Those are POSITIONAL: each labels the <t> pointer rows that follow it, and
fordemoteallcheck read rows 9-10 as decl-twin and 11-26 as demote from exactly that order. Lifted
into the legend, every <t> reads as either kind -- fordemoteallcheck (d)/(j)/(x), fordecltwincheck,
foronesidecheck and forsiblingdemotecheck all went red on it. A lost disclosure is not a byte
saving, so <sigs> keeps them in place; the readout measures what that costs against AF2's figures.

GATES. foranswerfirstcheck: R1/R2 now judge AF2's UNIT multiset (open/close tags + direct
children) and the comment COUNT over every unit, R1n still fails on a dropped row; new arms
(A1) no section but <sigs>/<bodies> keeps a direct-child comment, (A2) no zero-row stub ahead of
<tail>, (G1) a promoted section leaves tail row 24 inside the stop with </tail> past it, (G2)
nothing moves when </tail> is inside the stop, (G0) the literal fixture must FIRE G. Against the
core binary A1/A2/G0 go red (controls). forpagescheck (P10): the flagless default is
--page-bytes=12000's page 1. Re-pinned: gvassemblycheck (e1) and graphformendpointscheck (f1)
compare the embedded verb answer without its lifted comments, (b1)/(g1) read the bridge/gap legend
from the document legend and expect the bridge first; foronesidecheck (t) takes the whole
legend-first answer as the U a fitting budget returns, as budgetmonotonecheck (a) does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…to the memory guard's limit

Owner, 2026-11-18: "On by default". The ceiling is now the memory guard's hard limit (65% of min(RAM, cgroup
memory.max), --max-memory, RIPWIRE_MAX_MEMORY: the flag wins over the variable as before), read at operator
new: one knob, one exit code (5). RIPWIRE_MEM_BUDGET_MB=<MiB> sets this line alone; RIPWIRE_MEM_BUDGET_MB=0
turns it off. The refusal names the knob that set the limit.

Portable hook: src/memceiling_new.cpp replaces operator new (malloc/free plus the hook) wherever
largealloc.cpp is not linked — Linux, Windows, other POSIX; never beside a sanitizer or RIPWIRE_ALLOC_COUNT,
which leave the line disarmed (RIPWIRE_MEM_CEILING_HOOK undefined). The readers are rw::os::mem_footprint:
phys_footprint, /proc/self/statm, GetProcessMemoryInfo commit charge. RIPWIRE_STATS prints the line's
reading count at graph-end.

An operator-new allocation can no longer pass the limit between two phase readings, so the overshoot memguard
disclosed is now refused for that memory; what the line cannot see (direct malloc, mmap, the small-allocation
stride) is still disclosed. largeallocpeakcheck arm M, red on the parent commit too, passes now.
memguardcheck B8s/B8bs and B12 assert memguard's own phase and parse lines, so they run with the line off;
B8/B8b accept its refusal as a real line.

test/memceilingcheck.sh: default-on, both knobs, the 0 override, byte-identical map/--json/--for with the line
on, off and armed high, typo refusals, and an MCP server that stays up.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…eclarations they measured

`--uses=patch_vary_headers` answered `defs="2"` and never said where either definition is; a
one-group --callers answer did the same, and a one-group --impact answer (T2's IMPACT-SOLE-DEF)
named the definition but not the header that declares it. Lane P1 found that 13 of the 16 gold
groups a routed --callers/--uses/--impact answer lost were the file that DEFINES or DECLARES the
symbol (results/P1_VERBROUTE_1118, SPEC §1).

THE RULE (pre-registered, results/V1_VERBDEF_1118/PREREG.md):
  * --callers (XML, columnar, --json), --uses (XML, columnar) and --impact, and the MCP twins
    find_referencing_symbols, uses and impact, print the <def> table on every answer whose
    selector resolved a definition group, one group included. --callees, --safe-delete and
    find_symbol keep a one-group answer table-less.
  * Each listed group's row is followed by one row per declaration tied to its definition (the
    existing identity rule: C family edit-check, TypeScript overload signatures), same ix=,
    bodyless="1". A header prototype is now named beside the definition (tally: proto.c:3 then
    proto.h:3). This applies to every <def> table, so one reading holds tool-wide.
  * Group listing unchanged (16-group cap, defs_listed=N). --uses rows name no group, so above
    16 groups it lists none and says defs_listed="0". Declaration rows have no cap of their own;
    they are bounded by defs=.
  * The rows are the root's first children (columnar: after the path table, before <cols>).

No new element or attribute: <def ix t sc p bodyless> as T2 printed it. The compact `def ix=`
reading and the full clauses are reworded for the declaration rows; --uses gains its own clause
(kUsesDefTableLegend: its rows name no group, so the of_def reading does not ride).

Also fixed: the compact `bodyless=N of total=` reading was read anywhere in the payload, so it
fired (107 B) on a `<def bodyless="1">` row; it is now scoped to <bodies>, the one element that
carries that count.

GATE, written first: test/verbdefrowscheck.sh, 44 arms, 24 red on the parent (57b4c3e); the
strip-identity arms pin the parent's bodies with the <def> rows removed.

RE-PINNED, each by design:
  * impactsoledefcheck (3): proto.c:3 then proto.h:3 (was the one group row); (6): --callers
    dropped from the "stays table-less" list.
  * attribmultidefcheck: the parser reads a repeated ix as a tied-declaration row (MEMBER), not a
    group; the one-group --callers arms (b_rp b_up b_q c_lost c_pick lf_stash lf_baz f_py1 j_u1)
    pin one group row plus their declaration rows.
  * defslookupcheck (B2, C): "one group" is now the count of distinct ix=, not "no <def> row".
  * sitesatshortcheck (C): the --uses golden is compared with the <def> rows stripped.
  * compactlegendcheck A-PIN callers.xml 3875 -> 4187 B, impact.xml 4844 -> 4887 B (checked
    mechanically: only the rows and the clause moved); (L) loop bar 8400 -> 8800 B (measured
    8789), twin 8200 -> 8700 B (measured 8644).
  * test/legend_over_target.tsv: def-row 126 -> 135 B (impact, loop, mcp:impact), sole-def
    230 -> 222 B (full:impact); new rows ripwire.callers/v1, ripwire.uses/v1, mcp:uses
    (def-row 135), full:callers and full:uses (sole-def 222), full:uses (uses-def-table 193).
  * printf_parity.manifest: callers, impact, uses, callers_json, impact_json, callers_limit.

OWED AT INTEGRATION (not editable from this lane): a changelog.d fragment; `docs/counts_snapshot.py
refresh` for the new gate (docs/TUNING.md, LIMITS.md, EVALS.md); a COMMANDS.md showcase
re-capture of --callers/--uses/--impact.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
One conflict: test/printf_parity.manifest (callers_limit, help_all). The
manifest is a function of the binary, so it was re-pinned from the merged
build (UPDATE_GOLDEN=1), not text-merged. Moved vs lane/af1-answerfirst:
callers impact uses callers_json impact_json callers_limit (V1's def rows);
moved vs lane/v1-verbdef: help help_all (AF1's --page-bytes). Nothing else.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts:
#	test/compactlegendcheck.sh
#	test/compactlegendfix/pre_l1_full/impact.xml
#	test/printf_parity.manifest

REGEN AFTER BUILD (binary-pinned files that took main's side; build, then scripts/merge_main.sh --regen-after-build BIN):
    test/printf_parity.manifest
…erged V1+T3 binary

The merge took T3's side of test/printf_parity.manifest (a binary-pinned file). Re-recorded with
UPDATE_GOLDEN=1 bash test/printffmtparitycheck.sh on a --clean-first build of the merge: callers and
callers_limit return to V1's pins (T3 did not move them), impact is new (V1's <def> rows and T3's short
importer rows in one answer), help_all keeps T3's pin (V1 did not move it).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…e-T3 tree

T3's goldens were taken at 994f002, before T2/V1. In the batch, a one-group --impact answer also prints
V1's <def> rows (and --json def_table), so arms B and E went red on the merged binary although T3's rows
rebuild exactly. Re-captured with the gate's own fixture lines and the binary built from 1ddf1c29a (V1
merged, T3 not): the only difference from the old goldens is those <def> rows / def_table (legend comment
and at= masked). importrowshortcheck: 39 PASS, 0 FAIL on the merged binary.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts:
#	README.md
#	docs/EVALS.md
#	docs/counts.tsv
#	present/deck5_ripwire_build.js
…ph question is answered by that verb, ROUTED

OWNER DECISION 2026-11-18 ("Accept V1, start RT1"). A bare --for whose text names a symbol
in backticks (lane P1's rule E) and asks who calls it, what it reaches or what breaks
(rule R) is answered by --callers / --impact / --uses. The verb's own answer is served,
with <route from="for" kind= verb= task= complete="not-proven" next=> as the root's
FIRST child, ahead of V1's <def> rows. complete= is never "1": nothing in a verb's bytes
proves completeness.

THE FALLBACK. Lane W1's frozen F1 (frozen_f1.py, transcribed in src/partialwarn.h) reads
the verb answer, --defs, --grep=LAST and a whole-word scan of the indexed corpus. When it
finds evidence of a miss (text-gap, macro, twin-defs, value-hop, target-floor) the route
says warn="1" why=… and the FIRST --for page rides as the root's last child, byte for byte
the opted-out answer's page 1, its own next= the second page. An absent warn= means no
evidence found, never proof. If F1 cannot run: P1's hybrid (why="kind" / "unchecked").

WHEN IT FIRES. Only on a bare --for (forUnbudgetedCall is the bare call, no --page-bytes,
no budget, XML, single root, default legend posture), and only when the verb resolves the
symbol as typed or by its last segment; anything else is the --for answer byte for byte.
--no-verb-route (the route's own next=) is the opt-out, byte-identical to the base binary.
A spelled --page-bytes never routes, so every page's next= stays a page of --for.
MCP `for` is unchanged: AF1 left MCP unpaged, and MCP clients hold the verbs as tools.

DEVELOPMENT (P1's 49 spent cells; results/RT1_ROUTE_1118): routed 21, warned 7; RT-final
41/49 complete vs --for 39/49, 0 cells losing a group, 7,533 vs 9,192 tokens/q; warn
recall 5/5, false alarms 2/16; rule E/R agree with rules.py 49/49, warn with frozen_f1.py
21/21. Confirmation on T5c's sealed set is in the readout.

GATE (written first; 22 arms red on the base): test/forverbroutecheck.sh — route fires,
does not fire (byte-identical), warn on a callback hop and a text gap, warn absent on a
plain chain, the opt-out, next= replay, legend coverage, determinism, well-formedness,
base identity (BASE_BIN=). Registered in regression.sh and the shard weights.
Re-pinned: printf_parity (help, help_all), shapingflagcheck (A) 25 -> 26 (the route reads
--max-tokens only to stand aside), fordeclrowcheck (n8) asks the --for answer with
--no-verb-route, flag counts 196 -> 197 (README x2, guide, deck x3), skills/ripwire-orient.
Legend: four <route> readings in compactlegend.h (present-only; dictv moves).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…g dropped

Lane V1 (results/V1_VERBDEF_1118) measured its <def> legend at about twice its rows: --callers +5.4 KB
legend vs +2.7 KB rows, --uses +7.3 KB vs +4.4 KB, pooled over 48 held-out cells. Three readings are
reworded, each keeping every term a reader needs (defs= groups, a definition then its tied
declarations, same ix=, bodyless=1 no body; the one-group clause's file:line, measured-from and
"no row carries of_def"; --uses' "a use-site row names no group"):
  * compact `def ix=` row (compactlegend.h)          133 -> 111 B
  * full kSoleDefLegend (graphlegend.h)              220 -> 167 B (+2 separator)
  * full kUsesDefTableLegend, now one sentence       191 -> 151 B (+2 separator)

MEASURED on V1's own cells (results/S1_SMALL_1118/fix1, V1's run/grade scripts, shared grader, matched
n=48 per verb, base = V1's frozen e6671f2 binary): complete and groups unchanged on all six
surfaces; bytes CLI callers 95,420 -> 94,364 (-1.11%), uses 87,631 -> 86,575 (-1.21%), impact
-0.31%; MCP find_referencing_symbols 109,994 -> 107,980 (-1.83%), uses -1.15%, impact -0.31%.

GATE, written first: test/verbdefrowscheck.sh (11), six arms: a byte ceiling per reading (112 / 175
/ 155 B) and the terms each must still carry; four RED on e6671f2.

RE-PINNED, each by design:
  * compactlegendcheck A-PIN callers.xml 4197 -> 4144 B, impact.xml 4903 -> 4850 B (the old
    kSoleDefLegend sentence replaced string for string; nothing else moved)
  * test/legend_over_target.tsv: def-row 135 -> 113 (6 rows), sole-def 222 -> 169 (3 rows, marker
    "the ONE defs= group"), uses-def-table 193 -> 153 (marker "a use-site row names no group")
  * printf_parity.manifest: callers, impact, uses, callers_limit
  * impactsoledefcheck (5): its marker is now "the ONE defs= group"

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
M2 turned the allocator-level memory ceiling on by default but could not edit src/cli.h, and left the exact
replacement in its readout: the sentence that said a peak over the limit between two readings is never
stopped is false for memory that goes through operator new. Replaced with M2's text (refused at operator
new, exit 5, RIPWIRE_MEM_BUDGET_MB, servers unarmed; only a peak the hook cannot see still finishes and
discloses). test/printf_parity.manifest: help_all re-recorded from a --clean-first build (the only label
that moved; the first-screen help is unchanged).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ate declaration is a stated known gap

Lane V1 (VERB-DEF-ROWS) prints a <def … bodyless="1"/> row for each declaration edit-check's identity rule
ties to the definition. The rule ties the control's `void grow();` but not the template member's declaration,
so --callers/--impact/--uses on the template fixture now differ from the control by exactly that row (and the
present-only legend reading it brings): 3 FAIL on the merged binary, also red at V1's own tip (e6671f2), so
a lane red the lane's gate run did not reach, not a composition defect. The byte-identity arm now compares
the answer element with bodyless <def> rows masked on both sides, and a KNOWN-GAP arm pins the difference
(control box.hpp:3 tied, template untied and silent) so tying template member declarations removes the mask
rather than passing silently.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…hard weights, counts snapshot refresh

- changelog.d: one fragment per change, written from each lane's readout (T2 impact one-group def, V1 verb
  def rows, T3 short importer rows, T4b pf= path fold, P2 tools/list trim, P3 short skill bodies, M2 memory
  ceiling default-on, M2 bounded head-binary build + bench timeouts). T3's fragment carries the correction its
  commit message (72419d3) needs: the <impact> element is 4.27 % shorter and the whole answer 3.97 %; the
  3.02 % in that message is the element's saving over whole-answer bytes. The commit is not rewritten.
- .github/pargates-shard-weights.json: importrowshortcheck (T3), memceilingcheck (M2) and namewalkcheck (M1)
  had no weight entry (the fifth gate registration, which nothing enforces); measured locally 2 s, 7 s, <1 s.
- python3 docs/counts_snapshot.py refresh + docs/gatecount_build.py on the composed tree: 859 gate scripts in
  the loop (the set union of the seven merged branches' loops minus phantomdefcheck, which the train removed
  at 82ed4c8 and the 994f002-based lanes still listed). Supersedes T4b's own refresh commit 9a6d496.
- skills/CONSOLIDATION.md: a dated entry for P3's body split, owed by that lane.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ined where they appear; legendcoveragecheck reaches them

Lane L1's page-legend census (results/L1_PAGELEGEND_1118) found attributes spelled `name=` in no legend
of their whole answer and on no floor. Reproduced on tiny corpora; each closed in the legend that
already defines the rest of its block (present-only, rides with the block):
  * --for graph_verb from_span=/to_span= (of_span=/and_span=): forgraphverb.h said "the *_span=
    attributes"; it now spells them (+19 B per graph_verb answer)
  * --for shortkey found=, rung key= and q= (q= found here): kShortKeyLegend head gains
    "found=0: no definition of X resolved; key= the name a rung searched, q= the Q of Q.leaf." (+89 B)
  * --for d slot_fields_more= (and slot_by_more=): kForCompactSlotJoinLegend said "_more= the rest" (+25 B)
  * --impact <rf by_name=>, and <rf via="name"> which only element-blind <e>/<s>/<c> rows covered: two
    element-qualified kCompactAttributeReadings rows, the full dialect's fix27 reading (+56 / +129 B)

WHY THE GATE MISSED THEM, both holes closed in test/legendcoveragecheck.sh:
  * Reach: no roster row produced those states. Four DEFAULT-ONLY rows on generated corpora now do
    (a --for path question, an unheld qualified name, a struct with six slot fields, a cut --impact
    window over a multi-definition selector partly reached by name), and arm (G-A19) fails when one
    stops carrying its attribute.
  * Reader: <shortkey>'s legend (before it) and the verb answer nested in <graph_verb> (legend after
    its open tag) were invisible, so 22 DEFINED attributes read as gaps once reached. shortkey joins
    TRAILING, a run of adjacent comments before a trailing block counts, graph_verb joins INNER, and
    an attribute is judged against the head plus every block comment that contains it. Fixed-document
    arms T9/T9b/T9c/T10/T10b pin it (mutation controls included).

GATE, written first: on the parent binary (G) reported 28 new default gaps (the 6 real ones + 22 reader
blindness); now (G) green, (G-A19) green, T1-T10b green. Also green: fnslotcheck, barrelshortkeycheck,
forsizetrimcheck, protoindexcheck, impactimportcheck, gvassemblycheck, graphformendpointscheck,
fordisclosurecheck, forroutecheck, legendrefcheck, compactlegendcheck, reexportcheck,
printffmtparitycheck. No re-pins; the dictionary identity (dictv) moves with the two rows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ers says not-applicable

Lane A4 (results/A4_SITU_PACK_1118, F1): --situ under a valid --legend-have= exited 0 with byte-identical
stdout and an EMPTY stderr, 33 of 33, the silence the C4 rule in applyCliRefPosture exists to prevent,
while --for prints a not-applicable line. The prose surfaces never reach that stage, so
checkLegendHandshake now prints the same line, naming the surface, whenever legendNonXmlReadSurface()
names one (--situ, --recall, --report, --mermaid, --html, --plan-lanes, --sarif, --eval*). Stdout and
the exit code are untouched; a stale value is still refused first, with no extra line.

GATE, written first: test/legendhavecheck.sh (S): S1 stdout byte-identical and same rc, S2 stderr says
not-applicable and names the surface (--situ and --recall), S3 [N] stale still refused. S2 RED on
e6671f2 (stderr empty), green now. No re-pins.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts:
#	test/compactlegendcheck.sh
#	test/compactlegendfix/pre_l1_full/impact.xml
#	test/printf_parity.manifest

REGEN AFTER BUILD (binary-pinned files that took main's side; build, then scripts/merge_main.sh --regen-after-build BIN):
    test/printf_parity.manifest
joyful-ii-V-I and others added 22 commits November 19, 2026 13:25
… one it replaced

  - testrowruncheck arm (5) read `<t p="…"/>` document-wide, so --for's file-tail rows — which the bundle
    now carries — were judged as tests_to_run rows carrying neither run= nor run_unknown=. The XML arm
    reads the <tests> ELEMENT now, the same scoping the shared reader got in the commit before this.
  - packtaskcheck's <far> arms are gone with the tier: there is no distance mask, so a symbol with no edge
    to the key body is not demoted to a name-only row, it keeps the shape --for's own head gives it. What
    was still a contract is kept and now stated as one — such a symbol gets no body and no <callers> row,
    however it is ranked — plus a new arm that the removed tier has not come back. The ledger arm follows
    the section order, and the tiny-budget arm reads total="1" (what qualified to be SERVED) while
    asserting exactly what it always did: the element is PRESENT and says it kept nothing.
  - packtaskmonotoncheck now reads TWO body denominators. `bodies_candidates` is the candidate set, which
    is what its monotonicity and fixture-arming arms are about; `bodies_total` is what qualified to be
    served, which is what its capped test must read. Reading the candidate count as "capped" had arm (b)
    accusing a correct bundle of stranding 46-73% of its budget, because kept < candidates is permanently
    true once one body is served by design and says nothing about bytes.

Pack-task gate subset: 97 of 98 green. The one left is showcasecapturecheck, whose capture records a
--legend-dict figure this lane moved; captures are regenerated, never hand-edited, and the base commit is
itself such a re-record, so it belongs to integration.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ot everything outside <tests>

The first form of this fix admitted only the `<t p=…/>` rows inside a <tests> element. That looked
equivalent to excluding the file-tail rows and was not: --test-gate spells tests_to_run rows that are not
wrapped in a <tests> element at all, so the inclusive form silently dropped them and turned
selectorchaincheck (d2) red — a gate that was green before this lane touched anything.

The exclusion is now scoped to the one element that spells the other meaning: a `<t>` row inside
<tail>…</tail> is a file-grain row, everything else is read as before. That cannot drop a row from a
document with no tail. Verified on all ten gates that import this reader: affectedcheck, affectedfoldcheck,
affectedgroupcheck, impactpartitioncheck, receiptpostcheck, rootrelemitcheck, selectorchaincheck,
testgatecheck, testrowruncheck, w3fixlegendcheck — nine green, and affectedfoldcheck red for an unrelated
reason (its arm (E) pins --pack-task's bytes against a pre-change capture; see the readout).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
… a degrade

The ASan run over --pack-task's paths printed a DEGRADED_PATH_ALERT on every --partition slice:
"<bodies> did not have the expected open/close shape — the served body is dropped". Nothing was wrong. A
slice's body share falls under kPackTaskSectionFloor, so packBodies is never called and bodiesXml is EMPTY;
the restate then took its unrecognised-shape branch and reported a degrade for a path working as designed.
A degrade alert that fires on the normal case is worse than none, because it is the alert that trains a
reader to ignore the next one.

The empty case is now its own branch: shown= is honestly 0, the key body rides as a pointer like every
other candidate, and nothing is disclosed because nothing was lost. The alert is left for the one case it
was written for — a <bodies> shape the restate genuinely cannot read.

STDOUT IS BYTE-IDENTICAL. Verified on test/fixture across six invocation shapes (--token-budget=600 /
2000 / 6000, --partition=3, --json, --legend=full): 6 identical, 0 different. Only stderr changes, so the
dev-set measurements taken with bin/ripwire.d1 (built from 83c55f1, one commit back) describe this code.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
… pin on graphlegend.h

The first FULL-suite run of the pass-3 candidate (890 gates) found three reds no lane's own targeted
run had executed. None is a stale pin; each is a real defect, two of them inherited from a merge.

- hashsetcheck (S): BX2's per-macro ceiling 6f023ca declared macroCeiling's `seen` as
  HashMap<std::uint64_t, char> and only ever asked contains() on it. The house rule is that a
  membership table is HashSet<K>; it is one now, with insert() in place of emplace( key, 1 ).
- gateexitcheck (G2): AR1's new test/subagentprimercheck.sh reported 34 verdicts through the
  one-line `… && ok … || no …` spelling. G1 makes ok() safe at the definition, but G2 pins the
  spelling the conversion achieved, and a new gate file does not get to reintroduce it. All 34 are
  now the suite's wrapped form; the `case … esac` verdicts and the one reversed `&& no … || ok …`
  site are untouched because G2 does not name them, and the gate is green.
- formatgatecheck (C): src/graphlegend.h is in scripts/formatcheck.sh's GATED set — the files that
  agree with .clang-format byte for byte — and f269297's DefTableLegendParts was written with
  aligned declarations and trailing comments, which .clang-format does not produce. Reformatted
  with clang-format 22.1.8 (WANT_MAJOR=22); only that struct's four lines moved.

Green at this commit: gateexitcheck, formatgatecheck, hashsetcheck, and the behaviour gates around
the two touched symbols — verbfixcheck (its [F2C] arms gate the very ceiling macroCeiling implements),
rustmacrocallcheck, attribmultidefcheck, verbdefrowscheck, mcpclidiffcheck, legendcoveragecheck,
capdisclosemapcheck.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…uite found

The 98-gate pack-task subset was run before this lane's last few commits and reported 97 of 98 green. The
full suite (890 gates, 869 pass, 3 skip, 18 fail) found eleven more, and these are the ones that cannot
change an answer byte:

  - changelogfragcheck / mcpmanifestcheck: my changelog.d fragment's first line has to be
    `### <Section> — <title>`. It was a bare title, so scripts/changelog_assemble.py refused the whole
    directory and two gates reported it.
  - fixedbufsweep (S2/S4): the committed fixed-buffer registry is a per-buffer COUNT plus prose, and four
    rows had rotted under this lane: `b` 10 -> 11 (the ledger's bodies line), `bodylessAttr` 2 -> 1 (the
    bare-wrapper placeholder branch is gone — a bundle with no body CANDIDATE has no bodyless owner to
    count), `tag` 2 -> 1 and 112 -> 144 B (the render-failed branch is the survivor and gained a capped=
    field), and the `farAttr` row is deleted with the <far> tier it described. serialize.h's
    xmlCommentText CALL-SITES list goes 17 -> 16: the W2-K restated body-omission marker was that site, and
    it went with restatePackTaskBodiesWrapper.
  - limitstablecheck / readmedriftcheck: docs/LIMITS.md regenerated (446 caps, 10 parameters), which this
    lane's new constants had made stale. Generated, not hand-edited.
  - gateexitcheck (G1/G2): my three gates spelled ok() without the accumulator every other gate has — a
    failed write of a PASS line turned a red arm green — and reported verdicts through the one-line
    `cond && ok … || no …` shape, which G2 forbids because a failed write makes it print FAIL for an arm
    that passed. All 23 verdict sites across the three are if/else now, and ok() is the house pair.

Not in this commit, and not hygiene: bodydialectcheck, bundleidcheck, callsrankordercheck,
compactlegendcheck and forsoftbudgetcheck are five REAL output-contract defects the suite found, each of
which changes answer bytes and therefore invalidates this lane's 596-answer measurement. They are reported
in the readout for a decision rather than fixed here, because the right scope for them is one iteration
together with the LocBench tail-starvation finding — see READOUT §5a and §6b.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Both were red for the same reason and neither was a disagreement about behaviour: they pin bytes this lane
changed on purpose. Regenerated, never hand-edited.

  - test/affectedfoldfix/golden/{big,brace,odd,small}.pack-task.xml, through the gate's own capture.sh.
    The FIRST attempt at this (earlier in the lane, reverted) passed capture.sh a RELATIVE binary path;
    capture.sh cd's into the fixture directory before running it, so the binary was not found, every
    pack-task output was EMPTY, and those empty files went over the committed goldens. This time the path is
    absolute and nothing is copied until each candidate is proven non-empty, over 1,000 B, xmllint-clean and
    carrying schema="ripwire.pack-task/v1". The four grew 8,216 -> 10,841, 7,639 -> 9,554, 7,193 -> 9,100 and
    3,374 -> 3,632 B, which is the file tail arriving.
  - docs/captures/COMMANDS_showcase_2026-11-19.md through test/showcase_capture.py (270 commands, rc=0),
    then docs/COMMANDS.md rebuilt FROM that fresh capture — in that order, because COMMANDS.md lifts its
    samples from the newest capture and rebuilding first would have carried the stale legend-dict figure
    onward.

asan/ was rebuilt to the same commit as build/, which is what mcpreloadasancheck refuses without (it
compares two binaries' answers and will not compare across source trees).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…say so

bodydialectcheck found it and it is the real thing: capped= on <bodies> read only `served < servedTotal`,
so a body that WAS emitted and then cut short reported capped="0". MEASURED over this lane's 596 dev
answers: 194 of them — 33% — carried `<b … truncated="1">` under `<bodies capped="0">`. A truncation the
document does not admit to is the same defect class as a false cap with the sign flipped, and it is the
reading truncvocabcheck already spells for this element ("rows all present but one is CUT: capped=1 with
shown == total").

capped= is now `served < servedTotal || servedCut`, the ledger's "(capped)" marker follows the same rule,
and the legend says it. The fix is BYTE-LENGTH NEUTRAL — `capped="0"` and `capped="1"` are the same width —
so the byte medians and the completeness counts in the readout's §5 are unaffected; one character changes on
194 answers.

My own honesty sweep (pb1_honesty.py H1) missed this, and the way it missed is worth recording: it allowed
capped="1" with shown == total when a row carried truncated="1", and never checked the converse. It had the
right concept and applied it in one direction only. H1 now reads both ways.

Also: PackBodiesTag is initialised with DESIGNATED initialisers. Adding servedCut mid-struct silently
re-slotted a positional aggregate — countBodylessCandidates() landed in servedCut and `false` in bodyless —
which compiled and would have inverted two disclosures.

bundleidcheck: its ledger parse is `grep -o 'ceiling [0-9]*' | head -1`, which matches "ceiling " with ZERO
digits. This lane's legend gained the phrase "the ceiling cut", so head -1 took the prose and every budget
reported "the ledger is unreadable". A gate reading a NUMBER must require a digit; tightened at its three
sites.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…s budget's

forsoftbudgetcheck (P2) found that `--pack-task --token-budget=6000` served different sections from the
DEFAULT --pack-task, whose budget is also 6000. Located: packTaskHeadRules was handed
`in.softTarget ? budgetTokens : 0`, and forHeadRoundRobinOn() reads that ceiling and returns false at 6000 —
so the default (0) emitted `files_first=` and the explicit twin did not. MEASURED on this repo:
`<sigs … docs_dropped="22" files_first="15">` against `<sigs … docs_dropped="22">`.

Two things were wrong with that, not one. It contradicts the verb's documented contract — "an explicit 6000
serves the default's sections byte for byte", which is kPackTaskHardBudgetSentence's own comment — and it
silently disabled, for EVERY explicit budget, the head round robin by file that PT1 measured as one of D1's
two locating mechanisms (4 of the gold files it recovers are head rows only through it).

The fix passes 0 in both paths: the default's verdicts are the ones both must share, and the default has no
caller budget to read. The byte budget still cuts the section — these predicates only decide whether the head
spends bytes on e=, the docs reorder and the round robin.

VERIFIED: the default answer on this repo is BYTE-IDENTICAL before and after, so the 596-answer dev
measurement describes this code unchanged. Only explicit non-default budgets move, and they move toward the
default. packlocatecheck, packkeybodycheck, bundleidcheck and truncvocabcheck re-run green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
… any section spends

PT1's design sentence for the file tail was "it takes its own share PLUS everything the sections before it
leave". The first D1 build implemented only the second half. The tail was the leftover with no floor, while
the head was allowed up to kPackTaskHeadRowDropPct (60%) of the post-header budget rather than its own 45%
share, and monotoneRoll charges a cut section its whole granted share. On a corpus with a long task echo and
long signatures the leftover was nothing.

MEASURED over LocBench's 303 tasks: the tail declared a 20% share and received 0.6% — a median shown="0" of
total="512" files — and on 82 of the 84 tasks the bundle failed to complete, the gold file it needed was in
that cut tail. Completion is counted in FILES and the tail is the section that names files, so a starved
tail is a bug and not a tuning shortfall. The cross-set picture says the same thing: the tail is fed on every
set that HIT its bar (SUB1 46 of 716 files, SFML 51 of 232, Multi-SWE 18 of 166) and starved to the bare
83 B shell on the one that missed.

The reserve is withheld from the spendable pool up front and handed back to the tail at the end, so the tail
still absorbs every leftover as well; quotaBase stays the full post-header budget so the other shares keep
their own percentages of it (45+20+8+2+5 = 80 = the pool left once the tail's 20 is reserved, so nothing is
over-committed by construction). A --partition slice reserves nothing: it carries no tail. The static_assert
now requires the head's bound to leave the key body AND THE TAIL their shares.

MEASURED on a 240-file fixture with long signatures and a 1,200-char task — LocBench's shape: the tail goes
from shown="0" / 46 B to shown="7" / 1,693 B. On this repo with a 1,200-char task: 83 B to 2,028 B.

test/packtailsharecheck.sh proves it, and is RED-FIRST against the pre-fix binary (arm (R) asserts that, so a
gate that stops exercising the defect says so instead of passing quietly). Its first fixture used 12 short
parameters and the pre-fix binary produced a byte-identical tail — arm (R) caught that the gate was vacuous,
which is why the fixture now carries 40 long-named parameters. Listed in test/regression.sh.

Also in this round, each closing a gate the full suite had found:
  - selfcheckcheck: --pack-task's five sink-less DISCLOSE( msg ) sites took the PackTaskRenderFaults sink
    (HeadShapeUnknown / BodiesShapeUnknown). The ratchet counts the sites that are SILENT IN RELEASE and its
    stated target is 0, so the pin was NOT bumped to absorb the three this lane added — converting them took
    the count 51 -> 46, below the old pin of 48, and the pin follows it DOWN.
  - compactlegendcheck: the compact legend was re-tightened (every reading kept, the wording around them cut)
    and the two clauses D1's answer needs that the 990 B target predates — the <bn> pointer row and the file
    tail's rows — are registered in test/legend_over_target.tsv as present-only, with their reasons.
    The kept ledger no longer contains a '>': it rides as a DATA comment that consumers slice with
    `<!-- ledger: [^>]*-->`, so "next= on <tail>" made the whole disclosure read as absent (FX4).
    P5 compares the tail fact by section and by whether it still discloses a cut, not verbatim: the tail is
    filled from what the DELIVERED document leaves and the compact legend is smaller, so the same budget
    legitimately buys the compact answer more tail rows (MEASURED: "kept 0 of 142" full, "kept 6 of 142"
    default). Holding that to a verbatim match would force the tail to be cut against a fixed legend
    allowance instead of the bytes actually delivered, which is what makes the per-answer ceiling hold.
  - callsrankordercheck and bodydialectcheck: their fixtures name the served body in backticks, because
    <callers> and <calls> are the KEY BODY's now; bodydialectcheck's omission-parity arm compares the
    --expand SELECTOR rather than a name recovered from it (a candidate can be a markdown heading whose own
    name contains ": "), its roster drops the removed <far> tier, and its (C) arithmetic arm gained the
    "rows all present but one is CUT" allowance its own (A) arm demands — without it the two arms contradict
    each other and no binary can satisfy both.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ut of packTaskBundleText

Owner ruling, 2026-11-19, on this lane's sizing: cognitive complexity 226 -> 348 while cyclomatic went only
129 -> 156, so +27 of the +122 was new logic and the rest was nesting weight. BEHAVIOUR DOES NOT MOVE — see
the byte-identity proof below.

Two cohesive blocks come out, and deliberately NOT the whole body under a new name: a rename would have
moved the finding onto a new symbol instead of fixing it, which is the flaw this lane reported in its own
cheaper option.

  - packTaskJsonTail( j, PackTaskJsonParts ) — 170 lines. The JSON dialect re-serializes the SAME section
    decisions the XML above already made, so it needs those decisions and nothing else. Its inputs are a
    PARTS RECORD following verbs_quality.h's QualityDeltaLegendParts: a flat record of already-computed
    values, const references for the containers, one comment per field, no std::function and no owning
    copies — read once, inside one call, every source outliving it. 33 fields, two of them deliberately
    non-const references because the callee takes their address (forClone's lens pointer, testPartition).
  - packTaskSettleRoot( whole, headerStr, buildHeader, lr, in, budgetTokens ) — 106 lines, the ceiling
    ladder and the priced root attributes. SIX inputs and no record at all: the block reads almost nothing
    from its surroundings, and the header BUILDER arrives as a template parameter because
    climbCeilingLadderBy already takes it as a callable, so nothing here needs an allocation.

MEASURED, on this repo:

  symbol                 cx            ccx
  packTaskBundleText     129 -> 113    226 -> 215     (base -> now: BELOW its own baseline on both)
  packTaskJsonTail       new:  34      new:  48
  packTaskSettleRoot     new:  13      new:  17

--quality-delta against the share-floor HEAD: regressions=4, all four new-symbol rows, gating=0. The
complaint was not relocated: the pre-existing symbol improved and neither new symbol is a monster.

BYTE IDENTITY, which is the only thing that makes a refactor safe. 240 invocations — three corpora
(test/fixture, src/, the repo) x five tasks including a 320-char and a 1,200-char one x {default, --json,
--legend=full, six token budgets x {XML, JSON}, --partition=3} — all 240 byte-identical to
bin/ripwire.sf, the frozen share-floor binary. The whole-dev-population diff over all 596 answers is the
commit that follows.

The first attempt was NOT identical, and that is the point of the proof: a word-boundary rename rewrote the
identifier inside a STRING LITERAL, so every --json answer carried `{"p.task":` and differed by exactly 4
bytes. 105 of 240 invocations caught it. Gates would not have: none of them reads the JSON root's first key.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The share floor, the compact-legend trim and the refactor landed after the captures were last regenerated at
ffc6b75, so three absolute pins were red at the tip. None is a disagreement about behaviour; each pins bytes
this lane changed on purpose. All three regenerated through their own generator, never hand-edited.

  - test/affectedfoldfix/golden/{big,brace,odd,small}.pack-task.xml, through the gate's own capture.sh with an
    ABSOLUTE binary path (capture.sh cd's into the fixture dir; a relative path silently writes empty goldens,
    which is how the first attempt in this lane damaged them). Each candidate was proven over 2,000 B and
    xmllint-clean before it was copied. The four shrank 10,841 -> 10,793, 9,554 -> 9,506, 9,100 -> 9,052 and
    3,632 -> 3,584 B: 48 B each, and the token-level diff shows the whole of it is the compact legend's shorter
    prose ("the ONE key body served" -> "the ONE key body", and three more clauses), with est_tokens following
    it down 1,528 -> 1,508. No row, no attribute and no body moved. The other 29 files capture.sh writes are
    untouched and still byte-identical to the base commit.
  - test/printf_parity.manifest, with UPDATE_GOLDEN_EXPECT=pack_task so the re-pin had to name the one label it
    was allowed to move: moved={pack_task}, 41 unchanged.
  - docs/captures/COMMANDS_showcase_2026-11-19.md through test/showcase_capture.py (270 commands), then
    docs/COMMANDS.md rebuilt FROM that fresh capture, in that order: COMMANDS.md lifts its samples from the
    newest capture, so rebuilding first would carry the stale legend-dict figure onward. The recorded
    --legend-dict figure now reads dictv=98a9457a5d5eb284 entries=1287, which is what the live binary prints.

Both build trees were rebuilt --clean-first at this tip first, because build/ was stamped e8f0dd5+dirty and
asan/ 6e22319, five commits behind: versioncheck, versionlabelcheck, g1freshcheck, mcpreloadasancheck and
cachefuzzcheck were all red on binary staleness rather than on anything in the source. The rebuilt build/ripwire
is byte-identical to the frozen bin/ripwire.rf across all 240 --pack-task invocations of the byte-identity
spread, so the re-stamped binary is the measured one.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The entry described D1's shape and the token conversion but said nothing about the three behaviours that
landed after it was written, and a changelog that records only the first half of a change is a defect of the
same kind as a readout that records only wins:

  - the file tail takes its declared share as a FLOOR, with the measurement that made it necessary (the tail
    declared 20% and received 0.6% over LocBench's 303 tasks; the gold file was in the cut tail on 82 of the
    84 tasks that did not complete) and the result (329 -> 420 of 596 bundles naming every file needed), plus
    the statement that the budget did not change.
  - <bodies capped=> now admits a served body that was truncated: 194 of 596 answers published capped="0"
    over a <b truncated="1"> row.
  - --pack-task --token-budget=6000 now serves what the default serves; the two differed by a section's
    reading because the explicit form passed its own budget into the head's lens rules.

Also fixed a spelling error in the entry itself: the pointer row is <bn … next="--expand=…"/>, not <b>, and
added test/packtailsharecheck.sh to the gate list.

The 891-gate suite ran at 94e149e, one commit before this one; this commit touches a single changelog
fragment and no source, so the 15 gates that read changelog.d were re-run at this tip instead of the suite:
binoverride, changelogfrag, deck, docdrift, docdemote, forliteral, forunused, mcpmanifest, mdembed,
prcontext, qschemetrip, qualitykinds, quality, queuehop, selfcheck — all green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…re the code

The gate before the code it measures (non-negotiable 1). Twelve arms pin the DELIVERY UNIT of
the one capped-body block --for and --pack-task are to share, and nothing about ranking:

  whole body at <=120 lines of indexed span (e= - l= + 1, the denominator SR1 measured and the
  only line count the index knows), HEAD-ONLY past it with the head's size stated, the cut
  disclosed through truncated=/lines=/next=, its CAUSE readable through a new cap_lines= so a
  line cap is not mistaken for the byte cut whose registered reading says "cut at the byte
  budget", a zero that says what was scanned, one block rather than six, and no anchor window.

The no-anchor arm (C6) is the one that keeps SB1's refutation enforced: a +-30 window anchored
on the query's best term holds the edit in 20 of 63 large bodies (31.7%), falling to 19.0%, so
the unit is head-only and a later lane may not reintroduce the window silently.

cap_lines= was checked free before it was introduced. head_only= was REJECTED: src/abicheck.h
already owns it on <ref> for --abi, where "head" means git HEAD.

RED on the frozen integration binary (results/INT1_070_1119/bin/ripwire-070cand-p3), on a
fixture, never by breaking a real document: C2 C3 C4 C5 C6 C7 C8 C9 C10 fail on the rule's
absence; C0 (non-vacuity, including a span self-check against the binary's own index), C1
(bodies that already fitted), C11 (determinism) and C12 (xmllint) pass as controls. No arm
passes for the wrong reason -- an earlier draft of C8 counted <b> rows anywhere and so passed
on three bodies arriving through three different shells, and an earlier C9 compared two
all-absent units; both now carry non-vacuity guards.

Registered in test/regression.sh in this commit (manifestcheck green, 891 gates). The published
count snapshot in docs/counts.tsv is left alone: it is a build product and regenerating it
serialises every lane that adds a gate.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
(cherry picked from commit 3799ff4247afe85c751f0b7aff13ba0f82be0439)
TWO KNOBS, BOTH DERIVED RATHER THAN PICKED.

1. kCappedBodyLines = 120, applied as min( span, 120 ) -- monotone, no discontinuity. The owner ruled
   this shape over SR1's "whole <=120, else a 15-line head": that shape saves more (CB1 measured -42.3%
   of candidate body lines against this one's -21.7%) but an answer whose size jumps 8x on a property
   the caller cannot see is the wrong trade, and it is worst in the fan-out shape where N subagents each
   budget alone with nothing to normalise them.

2. kKeyBodyMax 2 -> 5. GA1 DEV's gold functions per task run median 1, q75 3, p90 5, max 12, so a cap of
   2 could satisfy 71.9% of tasks and 5 satisfies 94.4%. The guard sits at p90 and the byte budget is what
   actually bounds the block. The premise offered for lifting it -- "the median task has 3 gold files" --
   does NOT hold on GA1, whose DEV median is 1 file and 1 function; only 28.1% of tasks need 3+ functions.
   The raise helps a real minority, and the readout says so rather than inheriting the stronger claim.

WHERE IT APPLIES, and why not everywhere. Three surfaces serve "this candidate's definition body" and all
three take the cap: <bodies of="key">, <bodies pick="name|member">, and --pack-task's. The route, hops and
launch groups keep bodyLineCap=0 -- their unit is a path through several definitions, not one candidate's
body. Which of the three fires depends on the query, so a rule bound to one of them would be a rule a
caller cannot predict; the gate therefore asserts the UNIT, not the shell.

DISCLOSURE: cap_lines=. truncated=/lines=/next= already say how much was cut, but compactlegend.h
registers truncated= as "cut at the byte budget", so reusing it alone for a LINE cap would make a
registered reading false (non-negotiable 3). cap_lines= names the cap that cut; a byte cut carries none,
so the two causes are distinguishable from the row alone. head_only= was rejected: src/abicheck.h owns it
on <ref> for --abi, where "head" means git HEAD.

BYTE IDENTITY, by construction and then measured. bodyLineCap defaults to 0 through packBodies,
renderBodyElement and routeBodiesXml, so every caller that does not opt in cannot reach capBodyAtLines.
17 non-vacuous verb arms on htop are byte-identical (map, hotspots, lint, deps, clones, dead-code,
test-gate, impact, uses, callers, around, expand, path, exemplar, lego, grep, pr-context); an 18th (situ)
compared two empty outputs and is reported as vacuous, not as a pass. hopbodycheck (P4) independently
shows a 154-line HOPS body still cut at lines="1-46/154" with no cap_lines=, which is the uncapped groups
proved by output rather than by reading the defaults.

GATES. test/cappedbodycheck.sh was red on this tree before this commit (9 arms) and is green after, with
C7 and C8 printing as DEFER: the owner put the six-shell consolidation out of scope, so those two bars
live in PREREG_CB1_1119_v2.md D1/D2 rather than being deleted or left as an unclearable red. An earlier
C2 asserted a marker's absence and failed on correct output -- with a 121-line span and a 120-line cap
exactly one line is cut and it is the closing brace -- so C2 now asserts the arithmetic.
test/forkeybodycheck.sh K6 is re-worded in THIS commit as the knob move requires, and a new K6b uses six
names so the cap of 5 is exercised rather than merely outnumbered; K6 alone would pass on any cap >= 3.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
(cherry picked from commit f481c6b0dcb7207ddd45d1eb136e247778a9d780)
…uilt

MECHANISM 2 IS NOT COMMITTED. Only its gate is. The implementation was written, measured, and reverted.

WHAT RC1 MEASURED, and why the failure is worse than its frequency. 8 of 69 release first calls exceed the
client's 30,000-character limit -- 11.6% against 1 of 234 on dev, about 27x, Fisher p = 3.8e-05 -- and it is
a routed-verb problem: 7 of 14 routed --impact, 1 of 9 uses, 0 of 39 unrouted --for. All 8 crossers carry a
--for page; none of the 10 non-carriers crosses. When an answer crosses, the client replaces it with a
~2.3 KB envelope whose 2 KB preview lands INSIDE THE LEGEND on all 8, so the agent gets ZERO answer rows and
complete=/has_more= go with them; in 5 stored persisted cases 0 of 5 agents reopened the saved file.

WHAT I BUILT AND THEN REVERTED. A descending spec ladder on the carried page's render took it from 14,531 B
to 8,292 B, -43%, with the page still present and page1="1" intact, so EX1's +65K SE/question survives.
Two measurements killed it:

  1. The bound I pre-registered was on bytes the mechanism cannot move. The page is 8,292 B of which
     3,034 B (36.6%) is its own legend, and the parent routed answer carries NO legend -- so the page's
     legend is the document's only definition of the attributes its rows emit and legendcoveragecheck would
     fail without it. The ladder bottoms out at a spec of 800 and the page still emits 8,231-8,292 B. A total
     bound of 8,000 B is unreachable at any spec.
  2. It shrinks the page SILENTLY. The carried page's root carries no page=/pages=/withheld_bytes= at all,
     before or after, and setting both forPageBytes and pageBytesSpec on the reflow does not produce them --
     the unrouted paged call does emit them, so they are stripped or never attached in the routed assembly.
     An agent would get 43% fewer rows with nothing saying rows were withheld and no next= to recover them.
     That is the silent cut non-negotiable 3 exists to forbid, so the mechanism does not ship to clear a
     byte bound.

THE GATE IS THE DELIVERABLE, and its (R3) is the arm that stopped the ship. (R3) first PASSED on the silent
cut, reading an absent set of paging attributes as "nothing was cut" -- the shape the coordinator warned
about, where a must-not-print check passes on unfixed code by construction. It now compares against the base
binary and FAILS on a page that is smaller without disclosing. (R0) is the non-vacuity guard and it earned
its place: the route fires only on a BARE --for=Q, so my first five attempts to reproduce a carried page
passed --legend=compact and silently removed the entire subject of the gate. (R2) pins shrink-never-drop,
(R4)/(R5) are byte-identity controls against RIPWIRE_BASE_BIN. R1/R1b/R3 print as DEFER with the blocker and
their bars live in PREREG_CB1_1119_v3.md G2/G3/G6/G7.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
(cherry picked from commit 29651e1b37d56f5ce576c8603c31225294872593)
…t headers

The generated half of the lane, rebuilt here rather than carried across. docs/LIMITS.md is REGENERATED from
this branch's own constants (§8: generated files are regenerated, never text-merged) and the count proves why
that matters -- 446 caps here against 447 on lane/cb1-code, because that branch also carries p3's lineage.
Cherry-picking the file would have imported a cap count this tree cannot produce.

The two changelog fragment headers take the corrected form `### <Section> — <title>`; the cherry-picked
commits carry the pre-fix `### Changed`, which changelogfragcheck and mcpmanifestcheck both reject.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…cords a lost line

TWO REAL REGRESSIONS THIS LANE CAUSED, found by running the suite against PB1's TIP ITSELF rather than
against my merge commit. Both are in gate code, not in the product.

1. forbodyslotcheck (MC5) read "no <b n=render_screen>" on a document that plainly contains it.
   Its bodies() parser did not strip comments, and the legend DEFINES `<b …>` rows by printing their own
   tag text -- so `<b ` appeared twice (once in a comment, once as the real row) while `</b>` appeared
   once. The regex matched the LEGEND's `<b `, then ran `(.*?)</b>` to the real row's close, swallowing
   that row's open tag into the body group: attributes came back EMPTY and n came back None while the
   CDATA still looked right. This lane's new `cap_lines` legend entry, which begins `<b `, is what pushed
   the comment count from zero to one and exposed it.
   The gate already strips comments for its ROW parser (strip_slot, same file), so this is its own idiom
   applied where it was missing. Same class as the miscount OR1 recorded, where a legend's own <bodies>
   was read as an answer's.
   THE PRODUCT WAS NEVER WRONG, and that is measured, not assumed: the CLI's and MCP's <b> rows are
   byte-identical (lines="1-47/176" truncated="1" next= cap_lines="120" on both) and their CDATA is
   byte-identical at 4,876 bytes / 47 lines. I had reported an MCP/CLI parity break, then retracted it on
   a bad reference, and the parity was intact throughout.

2. gateexitcheck (G1): ok() in this lane's two new gates printed a PASS line without recording a FAILED
   WRITE, so a lost line would be silent and the gate would still exit 0. Both now use the house form,
   and defer() got the same protection.

HOW BOTH WERE FOUND, because the method is the point. My reference binary was built at my own MERGE
commit, which carries PB1's tip AND p3's lineage -- two differences from the baseline, so "fails on the
reference too" could not tell "pre-existing" from "mine". Building PB1's TIP ITSELF settles it: its legend
dictionary is dictv=98a9457a5d5eb284 entries=1287, exactly what the committed capture records, and
forbodyslotcheck, gateexitcheck and showcasecapturecheck all PASS there. Three of the clean branch's five
suite failures were mine, not one.

STILL RED, AND DELIBERATELY: showcasecapturecheck. Mine, and the arithmetic is unambiguous -- the capture
records entries=1287, PB1's tip is 1287, this branch is 1288 because `cap_lines=` is a new dictionary
entry. The gate says "regenerate the capture, do not hand-edit the number". I am NOT regenerating it in a
lane: test/showcase_capture.py writes docs/captures/COMMANDS_showcase_<TODAY>.md, and
docs_commands_build.py's newest_capture() takes sorted(glob)[-1] -- so a lane-side regeneration plants a
capture that every later COMMANDS.md lifts from, which is the propagate-a-pin trap. It belongs to the
integration capture re-record, with this commit naming the exact cause.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`promoteGuarded` walked the post-tail sections ONCE, in emitter order, inside a
finite guard headroom, so a section won a promotion slot by its POSITION rather
than its value. That is fine while every promotable name is signature-shaped, and
it breaks the moment a body-bearing section joins the same list: in verbs_for.h's
emission order the body sections come before `lit`, so a body consumed the
headroom `lit` had been using and `lit` was deferred to a later page, silently
un-promoting a section AF2's measured gains were built on (legendseencheck went
green->red; measured by lane R1).

AF2's frozen `kPromotable` is left exactly as frozen and a second, lower-priority
class is added beside it, `kPromotableBody` = { "fold", "bodies" }. The walk
becomes two class-ordered sweeps over the same list, in the same emitter order,
against the same single headroom accumulator:

  pass 1  promote every kPromotable section that fits   -- the parent's own walk
  pass 2  promote every kPromotableBody section that fits in what pass 1 left

and the emitted order is [already ahead of tail] [promoted RES] [promoted BODY]
<tail> [not promoted]. Pass 1 reads the same list in the same order against the
same stop with `used` starting at 0, and a section of no promotable class never
consumed headroom before either, so pass 1 promotes exactly what AF2's G promotes;
because pass 2's sections are emitted BEHIND pass 1's, their byte offsets do not
move either. Crowding-out is therefore removed BY CONSTRUCTION -- there is no
input for which a body can take a RES section's slot -- and when pass 1 exhausts
the headroom nothing moves and the answer is the parent's byte for byte.

Same guard, same stop (kAnswerPageBytesDefault), same emitter order within a
class, tail rows 1..kGuardTailRows still never move. The one class sweep is
`promoteClassSweep`, a named file-scope helper rather than a lambda, because the
first version pushed promoteGuarded's complexity from 11 to 18 and gated
--quality-delta; the refactor is byte-identical on 89 of 89 measured pages.

MEASURED on a fresh orientation gold set (89 tasks, 11 repos, 11 languages, one
worktree per task at its own base commit), three arms with identical argv:

  gold FILE named on page 1      unchanged in every cell and every repo (0 down)
  edit FUNCTION named            +2 to +4 cells, 0 down (definition-independent)
  edit-function BODY delivered   9 -> 20 cells of 89, 14 up, 0 down
  page-1 bytes                   delta median 0, max +679 B, 0 cells over +1,500 B
  whole answer                   never grows; population sheds 481 B / 2,145 B
  byte-identical no-op           56 of 89 cells

and the mechanism bar: RES_ahead and deferred= identical to the parent in 89 of
89 cells, against 3 cells where widening kPromotable itself displaced `lit`. The
instrument is armed -- it fails on that build -- so its green carries information.

What this does NOT fix, stated because no ordering rule can: the guard reserves
tail rows 1..24 and nothing more, so on a cell whose tail overflows the page any
promoted body still pushes the DEEPEST tail rows to a later page. That is not a
priority question; it is a zero-sum trade between more file pointers and one body,
and it is why 8 of the 9 file-rung losses lane R1 measured on a map/orient corpus
survive this change while the 1 caused by crowding-out does not. Settling it needs
a cue read from the question, not an ordering (owner ruling 86, its own lane).

Gates: foranswerfirstcheck gains G6/G6n/G7 -- the RES section is still promoted
AND delivered on page 1 with its block-local legend, and no RES section was
displaced by a promotion. G7 asserts an absence, so it was proved red against a
scratch build that widens kPromotable instead, read off that binary's generated
output. The AF2 arm's RES tuple is restored to AF2's ten with a separate body
class beside it. legendseencheck is green again (3 block-local lit legends, the
parent's own value). forkeybodycheck (K3) is RED and left red: a promoted
<bodies pick="name"> makes KB1 skip a body already served on the page, so its key
group carries one named definition instead of two. No body is lost from any
answer; that is KB1's contract and a separate change (owner ruling 87).

G1: asan tree built --clean-first, 8 runs rc 0 with zero stderr, seven of them
targeted at the changed path because the default map never enters answerFirst.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ion/070-1120

# Conflicts:
#	docs/COMMANDS.md
#	docs/captures/COMMANDS_showcase_2026-11-19.md
#	test/printf_parity.manifest

REGEN AFTER BUILD (binary-pinned files that took main's side; build, then scripts/merge_main.sh --regen-after-build BIN):
    docs/COMMANDS.md
    docs/captures/COMMANDS_showcase_2026-11-19.md
    test/printf_parity.manifest
…ion/070-1120

# Conflicts:
#	README.md
#	docs/COMMANDS.md
#	docs/REFERENCE_GUIDE.md
#	docs/captures/COMMANDS_showcase_2026-11-19.md
#	present/deck5_ripwire_build.js
#	skills/ripwire-mcp/SKILL.md
#	src/cli.h
#	src/defattrib.h
#	src/ingest_cache.h
#	src/mcpverbs.h
#	src/quality.h
#	test/compactlegendfix/pre_l1_full/callers.xml
#	test/legendcoveragecheck.sh
#	test/printf_parity.manifest
#	test/qschemetrip.hash
#	test/qschemetripcheck.sh

REGEN AFTER BUILD (binary-pinned files that took main's side; build, then scripts/merge_main.sh --regen-after-build BIN):
    docs/COMMANDS.md
    docs/captures/COMMANDS_showcase_2026-11-19.md
    test/printf_parity.manifest
…nd pair, COMMANDS.md)

scripts/merge_main.sh --regen-after-build, from: ripwire 0.6.10-dev.160+gc17dc32b6 (dev, AppleClang 21.0.0.21000101, emit=std::print, built_from=c17dc32b6)

    changelog.d/proven-site-keeps-namesakes.md
    docs/COMMANDS.md
    docs/captures/COMMANDS_showcase_2026-11-19.md
    test/printf_parity.manifest

parity labels re-pinned: callers callers_limit help help_all impact uses
The hash is a build product of this tree, so neither merged side's value could be
right once kParserVer and kIngestParserVerMirror move to 332 (above main's 331 and
the 0.7.0 stack's 317). Re-pinned once with UPDATE_GOLDEN=1 on the merged build
c17dc32; the log entry names the hash and both superseded values.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@coderabbitai

coderabbitai Bot commented Nov 20, 2026 •

Copy link
Copy Markdown

Important

Review skipped

Too many files!

This PR contains 319 files, which is 19 over the limit of 300.

To get a review, reduce the PR to 300 files or fewer by splitting it into smaller PRs or changing its base branch.

Enable usage-based reviews in Billing to review now. Otherwise, wait until the next included review is available.
You're only billed for reviews past your plan's rate limits ($0.25/file).

Run configuration

Commits

Reviewing files that changed from the base of the PR and between ee8d1a5 and 21d4b66.

Files ignored due to path filters: 55

  • bench/legendtier/census.tsv is excluded by !**/*.tsv
  • docs/captures/COMMANDS_showcase_2026-11-18.md is excluded by !docs/captures/**
  • docs/captures/COMMANDS_showcase_2026-11-19.md is excluded by !docs/captures/**
  • docs/captures/COMMANDS_showcase_2026-11-20.md is excluded by !docs/captures/**
  • docs/counts.tsv is excluded by !**/*.tsv
  • test/affectedfoldfix/build.sh is excluded by !test/*fix/**
  • test/affectedfoldfix/capture.sh is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.affected.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.affected.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.exercises.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.pack-task.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.situ.txt is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.test-gate.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.test-gate.json is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/big.test-gate.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.affected.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.affected.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.exercises.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.pack-task.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.situ.txt is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.test-gate.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.test-gate.json is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/brace.test-gate.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.affected.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.affected.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.exercises.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.pack-task.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.situ.txt is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.test-gate.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.test-gate.json is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/odd.test-gate.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/rc.txt is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.affected.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.affected.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.exercises.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.pack-task.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.situ.txt is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.test-gate.full.xml is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.test-gate.json is excluded by !test/*fix/**
  • test/affectedfoldfix/golden/small.test-gate.xml is excluded by !test/*fix/**
  • test/capdisclose.map is excluded by !**/*.map
  • test/compactlegendfix/pre_l1_full/callers.xml is excluded by !test/*fix/**
  • test/compactlegendfix/pre_l1_full/impact.xml is excluded by !test/*fix/**
  • test/importrowshortfix/golden/c.impact.json.golden is excluded by !test/*fix/**
  • test/importrowshortfix/golden/c.impact.xml is excluded by !test/*fix/**
  • test/importrowshortfix/golden/cap.impact.xml is excluded by !test/*fix/**
  • test/importrowshortfix/golden/js.impact.columnar.xml is excluded by !test/*fix/**
  • test/importrowshortfix/golden/js.impact.json.golden is excluded by !test/*fix/**
  • test/importrowshortfix/golden/js.impact.xml is excluded by !test/*fix/**
  • test/importrowshortfix/golden/py.impact.json.golden is excluded by !test/*fix/**
  • test/importrowshortfix/golden/py.impact.xml is excluded by !test/*fix/**
  • test/langidentity/ratchet.tsv is excluded by !**/*.tsv
  • test/legend_over_target.tsv is excluded by !**/*.tsv
  • test/printf_parity.manifest is excluded by !test/printf_parity.manifest
  • test/qschemetrip.hash is excluded by !test/*.hash
Files selected for processing: 319

  • .github/pargates-shard-weights.json
  • .ripwire_quality_acks
  • CMakeLists.txt
  • INSTALL.md
  • README.md
  • bench/bench_proof.py
  • bench/headtohead/r3-headroom-2026-08-03/timing_determinism.py
  • bench/legendtier/census.py
  • bench/mcp_session_timing.py
  • bench/nestcal/measure.py
  • bench/recalleval/run_r3diff.py
  • bench/scip_amb_precision.py
  • bench/scip_match_diag.py
  • bench/scip_pin_precision.py
  • bench/slice/run_slicerecall.py
  • bench/spec_trace.py
  • bench/svectorab.py
  • changelog.d/710-msvc-lambda-constexpr-table.md
  • changelog.d/affected-path-fold.md
  • changelog.d/ar1-subagent-primer.md
  • changelog.d/bounded-headbin-bench-timeouts.md
  • changelog.d/c-param-slot.md
  • changelog.d/cb1-capped-body.md
  • changelog.d/cb1-carried-page-gate.md
  • changelog.d/def-reading-trim.md
  • changelog.d/dict-core-packs.md
  • changelog.d/for-callees-veto.md
  • changelog.d/for-callers-first.md
  • changelog.d/for-page1-early-stop.md
  • changelog.d/for-route-continue.md
  • changelog.d/for-route-vetoes.md
  • changelog.d/for-verb-route.md
  • changelog.d/grep-degraded-unsuppressed.md
  • changelog.d/grep-held-files.md
  • changelog.d/header-static-includers.md
  • changelog.d/impact-first-window.md
  • changelog.d/impact-import-row-short.md
  • changelog.d/impact-one-group-def.md
  • changelog.d/int1-defrow-quality.md
  • changelog.d/int1-p3-suite-reds.md
  • changelog.d/kb1-key-body.md
  • changelog.d/langidentity-comment-not-a-predicate.md
  • changelog.d/legend-have-not-applicable.md
  • changelog.d/legend-seen.md
  • changelog.d/macro-see-through-one-hop.md
  • changelog.d/mcp-tools-list-trim.md
  • changelog.d/memory-ceiling-default.md
  • changelog.d/notfound-text-evidence.md
  • changelog.d/onesidereach-unsigned-wrap.md
  • changelog.d/packtask-d1.md
  • changelog.d/proven-site-keeps-namesakes.md
  • changelog.d/r1b-priority-rule-promotion-classes.md
  • changelog.d/rust-transcriber-calls.md
  • changelog.d/showcase-capture-merge-heavy-tip.md
  • changelog.d/skills-short-bodies.md
  • changelog.d/tl1-sigx.md
  • changelog.d/tl1-tail-samedir.md
  • changelog.d/undefined-attrs-a19.md
  • changelog.d/untied-decl-row.md
  • changelog.d/verb-def-rows.md
  • changelog.d/versions.md
  • docs/COMMANDS.md
  • docs/EVALS.md
  • docs/LIMITS.md
  • docs/REFERENCE_GUIDE.md
  • docs/TUNING.md
  • header-static-includers.md
  • hooks/opencode/ripwire-legend-seen.js
  • hooks/ripwire-codex-legend-seen.sh
  • hooks/ripwire-legend-seen.sh
  • hooks/ripwire-subagent-primer.sh
  • present/deck5_ripwire_build.js
  • scripts/optremarks.py
  • skills/CONSOLIDATION.md
  • skills/install.sh
  • skills/ripwire-before-you-build/SKILL.md
  • skills/ripwire-before-you-build/build-reference.md
  • skills/ripwire-change-check/SKILL.md
  • skills/ripwire-change-check/branches.md
  • skills/ripwire-change-check/pr-context.md
  • skills/ripwire-change-check/symbol-checks.md
  • skills/ripwire-find-bug/SKILL.md
  • skills/ripwire-find-bug/branches.md
  • skills/ripwire-fresh-eyes/SKILL.md
  • skills/ripwire-fresh-eyes/coupling-refactor.md
  • skills/ripwire-fresh-eyes/dark-docs-plans.md
  • skills/ripwire-fresh-eyes/dead-clones-lint.md
  • skills/ripwire-fresh-eyes/hotspots-churn.md
  • skills/ripwire-fresh-eyes/owners.md
  • skills/ripwire-graph-query/SKILL.md
  • skills/ripwire-graph-query/graph-query-reference.md
  • skills/ripwire-handoff/SKILL.md
  • skills/ripwire-handoff/handoff-reference.md
  • skills/ripwire-layers/SKILL.md
  • skills/ripwire-layers/layers-reference.md
  • skills/ripwire-mcp/SKILL.md
  • skills/ripwire-mcp/edit-verbs.md
  • skills/ripwire-mcp/read-verbs-lazy.md
  • skills/ripwire-mcp/read-verbs.md
  • skills/ripwire-mcp/session-legend.md
  • skills/ripwire-mcp/transports.md
  • skills/ripwire-mcp/wiring.md
  • skills/ripwire-navigate/SKILL.md
  • skills/ripwire-navigate/blast-radius.md
  • skills/ripwire-navigate/deep-dive.md
  • skills/ripwire-navigate/trace.md
  • skills/ripwire-opt-remarks/SKILL.md
  • skills/ripwire-opt-remarks/optremarks-reference.md
  • skills/ripwire-orient/SKILL.md
  • skills/ripwire-orient/ladder.md
  • skills/ripwire-orient/notes-resume.md
  • skills/ripwire-orient/partition-zoom.md
  • skills/ripwire-orient/subagent-brief.md
  • skills/ripwire-perf-target/SKILL.md
  • skills/ripwire-perf-target/perf-reference.md
  • skills/ripwire-quality-bar/SKILL.md
  • skills/ripwire-quality-bar/debt-ci.md
  • skills/ripwire-quality-bar/drill-down.md
  • skills/ripwire-quality-bar/loop.md
  • skills/ripwire-quality-bar/panel.md
  • skills/ripwire-quality-bar/playbook.md
  • skills/ripwire-reuse-first/SKILL.md
  • skills/ripwire-reuse-first/reuse-reference.md
  • skills/ripwire-router/SKILL.md
  • skills/ripwire-router/defaults.md
  • skills/ripwire-router/legend.md
  • skills/ripwire-router/moments.md
  • skills/ripwire-router/primer.md
  • skills/ripwire-router/scope.md
  • skills/ripwire-security-scan/SKILL.md
  • skills/ripwire-security-scan/code-pass.md
  • skills/ripwire-security-scan/skill-mcp-scan.md
  • skills/ripwire-write-tests/SKILL.md
  • skills/ripwire-write-tests/write-tests-reference.md
  • src/aliashop.h
  • src/callhierarchy.h
  • src/cli.h
  • src/codexdoctor.h
  • src/columnar.h
  • src/compactlegend.h
  • src/declinedsites.h
  • src/defattrib.h
  • src/foranswerfirst.h
  • src/fordecltwin.h
  • src/forfilesyms.h
  • src/forgraphverb.h
  • src/forkeybody.h
  • src/forlegendentries.h
  • src/foronesidereach.h
  • src/forowner.h
  • src/forpage.h
  • src/forpages.h
  • src/forreexport.h
  • src/forroute.h
  • src/forsiblingdemote.h
  • src/forsigx.h
  • src/forslots.h
  • src/graph.h
  • src/graphlegend.h
  • src/handoffwindow.h
  • src/hopbody.h
  • src/infra/envnumber.h
  • src/ingest_cache.h
  • src/ingest_names.h
  • src/ingest_valuerefs.h
  • src/largealloc.cpp
  • src/legenddict.h
  • src/legendpacks.h
  • src/legendseen.h
  • src/main.cpp
  • src/mcp.h
  • src/mcprefusal.h
  • src/mcpverbs.h
  • src/memceiling.h
  • src/memceiling_new.cpp
  • src/memstats.h
  • src/notfoundtext.h
  • src/packtask.h
  • src/partialwarn.h
  • src/partition.h
  • src/quality.h
  • src/resolve.h
  • src/search.h
  • src/selectorrefuse.h
  • src/serialize.h
  • src/situ.h
  • src/subjectanchor.h
  • src/testmap.h
  • src/valuerefindex.h
  • src/verbs_for.h
  • src/verbs_forroute.h
  • src/verbs_grep.h
  • src/verbs_navigate.h
  • src/wrap.h
  • test/affectedfoldcheck.sh
  • test/agenttablecheck.sh
  • test/anchorbodycheck.sh
  • test/attribmultidefcheck.sh
  • test/barrelshortkeycheck.sh
  • test/bodydialectcheck.sh
  • test/budgetmonotonecheck.sh
  • test/bundleidcheck.sh
  • test/callsrankordercheck.sh
  • test/cappedbodycheck.sh
  • test/carriedpageboundcheck.sh
  • test/codexdoctorcheck.sh
  • test/compactlegendcheck.sh
  • test/compactroutecheck.sh
  • test/cpptmplscopecheck.sh
  • test/deckcheck.sh
  • test/deckcheck_allowlist.txt
  • test/deeptailcheck.sh
  • test/defslookupcheck.sh
  • test/detailcheck.sh
  • test/docdemotecheck.sh
  • test/docdemotegolden_for.xml
  • test/docdemotegolden_noroute.xml
  • test/epmanifestcheck.sh
  • test/estchargecheck.sh
  • test/fixedbufsweep.sh
  • test/fnslotcheck.sh
  • test/foranswerfirstcheck.sh
  • test/forbodyfoldcheck.sh
  • test/forbodyslotcheck.sh
  • test/fordeclrowcheck.sh
  • test/fordecltwincheck.sh
  • test/fordemoteallcheck.sh
  • test/fordocbodycheck.sh
  • test/forexemplarcheck.sh
  • test/forfileanchorcheck.sh
  • test/forfilesymscheck.sh
  • test/forkeybodycheck.sh
  • test/forliteralcheck.sh
  • test/formanifestcheck.sh
  • test/formaxtokenscheck.sh
  • test/fornotesbudgetcheck.sh
  • test/foronesidecheck.sh
  • test/forpagescheck.sh
  • test/forrankordercheck.sh
  • test/forroutecheck.sh
  • test/forsectioncollapsecheck.sh
  • test/forselfhookcheck.sh
  • test/forsiblingdemotecheck.sh
  • test/forsigspancheck.sh
  • test/forsigxcheck.sh
  • test/forsoftbudgetcheck.sh
  • test/fortailwidecheck.sh
  • test/forverbroutecheck.sh
  • test/gateexitcheck.sh
  • test/graphformendpointscheck.sh
  • test/graphlegendbudgetcheck.sh
  • test/grepdegradedcheck.sh
  • test/gvassemblycheck.sh
  • test/handoffwindowcheck.sh
  • test/hazardpatterncheck.sh
  • test/impactfirstwindowcheck.sh
  • test/impactimportcheck.sh
  • test/impactsoledefcheck.sh
  • test/importcapcheck.sh
  • test/importrowshortcheck.sh
  • test/langidentity/runner.py
  • test/langidentitycheck.sh
  • test/legendcoveragecheck.sh
  • test/legendhavecheck.sh
  • test/legendseencheck.sh
  • test/legendseenhookcheck.sh
  • test/legendseenportcheck.sh
  • test/lib/headbinlib.sh
  • test/lib/importrowrecon.py
  • test/lib/pathfold.py
  • test/lib/softbudget.py
  • test/listingpagingcheck.sh
  • test/loopconservationcheck.sh
  • test/mcpforroutecheck.sh
  • test/mcplist_structure_golden.txt
  • test/mcplisttrimcheck.sh
  • test/mcpmanifestcheck.sh
  • test/mcptranchecheck.sh
  • test/memceilingcheck.sh
  • test/memguardcheck.sh
  • test/mentioncheck.sh
  • test/nextaposcheck.sh
  • test/notfoundtextcheck.sh
  • test/packcallersharecheck.sh
  • test/packkeybodycheck.sh
  • test/packlocatecheck.sh
  • test/packtailsharecheck.sh
  • test/packtaskcheck.sh
  • test/packtaskmonotoncheck.sh
  • test/packtaskquotacheck.sh
  • test/paramslotcheck.sh
  • test/pathroutecheck.sh
  • test/pyimportprecisecheck.sh
  • test/qschemetripcheck.sh
  • test/reexportcheck.sh
  • test/regression.sh
  • test/rootspellingcheck.sh
  • test/rubyargcheck.sh
  • test/rubyconstcheck.sh
  • test/rubyrecvcheck.sh
  • test/rustmacrocallcheck.sh
  • test/rustrootscheck.sh
  • test/selfcheckcheck.sh
  • test/sentencesubjectcheck.sh
  • test/shapingflagcheck.sh
  • test/showcase_capture.py
  • test/sitesatshortcheck.sh
  • test/skilltruthcheck.sh
  • test/subagentprimercheck.sh
  • test/subjectanchorcheck.sh
  • test/sublistcountcheck.sh
  • test/testrowpaths.py
  • test/testrowruncheck.sh
  • test/truncvocabcheck.sh
  • test/verbdefrowscheck.sh
  • test/verbfixcheck.sh
  • test/w3fixbudgetcheck.sh
  • test/w3fixlegendcheck.sh
  • test/withgraphcheck.sh

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

joyful-ii-V-I and others added 7 commits November 20, 2026 14:58
…n compile them

`windows (cl, ninja)` failed on PR #710 with two errors and nothing else:

  src/forroute.h(196): error C2326: 'hasCallWord::<lambda_1>::operator ()':
                       function cannot access 'kSuffixes'
  src/forroute.h(393): error C2326: 'pathNounThenPrep::<lambda_1>::()::<lambda_1>::operator ()':
                       function cannot access 'kPreps'

Both tables were function-local `constexpr` arrays odr-used from INSIDE a lambda
(one nesting level for kSuffixes, two for kPreps). MSVC refuses a lambda's access
to an enclosing function's automatic constexpr table; clang-cl, AppleClang and gcc
all accept it, which is why `windows (clang-cl, ninja)` passed on the same tip and
no other job in the matrix saw this.

Giving both tables static storage duration removes the question rather than working
around it: a variable with static storage duration is never captured, so no implicit
capture is required of any compiler. This is also the house form — `src/` already has
286 in-function `static constexpr` tables, including the sibling `kNouns` in
src/forfilepage.h.

Not a behaviour change: the cues, their order and the rules that read them are
untouched. The remaining 19 function-local `constexpr` tables in `src/` are passed as
the ARGUMENT to the algorithm and so are evaluated in the enclosing function's scope,
never accessed by a lambda; `cl` compiled all 19 in the run that rejected these two.

UNVERIFIED LOCALLY: this machine has no MSVC, and AppleClang accepted the code both
before and after, so the local build cannot distinguish the two states. CI's
`windows (cl, ninja)` job is the only instrument for this fix.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ports

The `qd-range` job fails on PR #710 with exactly the two gating rows IN3 measured
locally (its §6.2 ref-pair run: regressions=111 minor=75 gating=2 — CI reproduced
all three figures):

  complexity src/serialize.h::rw::packBodies   (src/serialize.h:8199, 101 -> 115)
  complexity xml_rows                          (test/testrowpaths.py:142, 26 -> 33)

Both are inherited by this integration, not introduced by it, and I re-proved it
independently rather than carrying IN3's claim:

  - `git diff --name-only 0295652 HEAD -- test/testrowpaths.py` is EMPTY, so that
    file is byte-identical to lane/r1b-priority.
  - no hunk of src/serialize.h between 0295652 and this tip touches packBodies:
    `git diff -U0` hunk headers jump 3870 -> 10033, and packBodies is at 8199.

Neither row was acked on any contributing lane because each lane's own
--quality-delta range kept it under the gating bar; they gate only at the aggregate
ee8d1a5..HEAD range qd-range measures, which sums 144 non-merge commits. So this
is a range-aggregation effect, not a regression this PR performs.

Acked with --ack-only so the integration's CI reports the integration's own defects
rather than two pre-existing ones. Decomposing packBodies belongs to the lane that
owns it, not to a merge resolution. Verified after the write:
`--quality-delta=ee8d1a50e..HEAD` reports baseline="ref-pair" gating="0" rc=0
(acked 15 -> 19; the four rows are packBodies' complexity/params/verbosity and
xml_rows' complexity).

REVERSIBLE AND REVIEWABLE: this is a judgement, not a defect fix. Dropping it is
deleting these ledger rows. Note the tool's documented heal-forward overwrote the
prior reasons on three packBodies rows (WAVE-2 close, lane FE-B, V1 harvest); they
are recoverable verbatim from this commit's parent.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…so a merge-heavy tip can regenerate

chooseInWindow refused to write the whole 270-command capture because the --in=DIR case had no usable
--since window. Measured on integration/070-1120: the available change windows touch 1 src/ file
(HEAD~2..HEAD~4) or 53 (HEAD~5 and every anchor beyond it, the merge's own two parents included), while
the case needs 4..22 — the merge of main contributes 53 files by itself, so the cliff is one commit wide
and no anchor search can cross it.

The window was not what failed. In the wide window the tool's answer is COMPLETE: the scoped
<recent scope="src"> page carries capped="1" has_more="1" next_offset= next=, and the
<symbols stubbed=> stub follows it. Only the capture's own 30-display-line cut hid them, behind a global
<recent> block the tool caps at 40 rows.

So the cut now keeps the trailing ELEMENT a caption promises, exactly as it already keeps a trailing
LEGEND (trailing_legend_start, INT1 2026-11-19): keep_from_start beside it, with fmt_block/publish_block
taking the element to keep. Only lines past the ordinary 30-line window qualify, so a block that already
shows its element renders byte-identically and no capture that regenerated before moves.

chooseInWindow and its eight named steps are UNCHANGED -- with the cut keeping the scoped page its first
pass finds a window on its own: "--in= case window derived as HEAD~6 (margin HEAD~5 holds)".
inCaseUnshown takes the same keepFrom the published block is formatted with, so what the probe measures
stays what a reader sees.

Disclosed on both sides, because the elided part moved from the end to the middle: the preamble's "How to
read the blocks" paragraph says one block keeps a trailing element and that the elided lines there are the
middle of the preceding global block, and the case's caption says so when the kept tail was needed --
measured per run by re-rendering the same window with the plain cut.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
… not only when it starts with one

Found once the generator could write at all (the previous commit), by running the capture's own coverage
check against the regenerated document: arm (G) went red with "caption claims [adaptive but the block has
no such clause" on --for="tree-sitter parse of a source file" --adaptive.

Not a behaviour difference between the binaries -- both emit the clause, verified by crossing tree x
binary on the same tree (merged 37da0ae and main ee8d1a5 each print it once). The clause had MOVED:
with main's binary it sits on display line 2, inside the head comments the preamble promises in full; with
the merged binary the answer-first --for document carries its legend in the TAIL.

And the re-wrap could not see that tail. The seam test was startswith("<"), so the raw line that CLOSES
such an answer -- `}]]></b></fold><tail total=…><t …></tail><!-- legend --></ctx>`, beginning with the
CDATA body's own `}` -- was left whole: one 300-byte-truncated display line holding the entire tail, legend
included, which the 30-line window then dropped and trailing_legend_start could not keep because it never
saw it as lines. MEASURED on this repo: 91 display lines against 164 once the seam test looks inside the
line, where the final six ARE the trailing legend and one of them carries [adaptive: kept N of N].

So the test now accepts any long line that CONTAINS a seam. The JSON branch is tested FIRST so an object
line keeps its own seams, and a line under the 300-byte cut is untouched either way. The direction is
strictly more content published: the old path showed 300 bytes of that line and nothing else of it, the
new one re-wraps it and the ordinary window and marker apply.

This is a PRE-EXISTING generator defect, not a regression of the previous commit: a keepFrom=None block
takes min( trailing_legend_start, len(lines) ), which is what it took before. The refusal was hiding it --
nothing had regenerated this capture against an answer-first binary.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…the merged build

The merge of main took main's side of the dated capture and marked it REGEN AFTER BUILD (IN3), so neither
side's capture fitted the merged binary: main's showed --lsp-langmap and missed the stack's three new
flags, the stack's was the reverse. The generator refused to re-record on this tip until the two previous
commits; this is the re-record.

270 commands, exit 0, recorded on a CLEAN tree at bc21766 (the first run was discarded because an
uncommitted generator edit made it read at="…+dirty"). The --in= case's window was DERIVED, not pinned:
"--in= case window derived as HEAD~8 (margin HEAD~7 holds)".

test/showcase_coverage_check.py against this capture and this binary:
  PASS (D) coverage: 192/192 flags covered (heading or Not-run)   <- was 3/192 uncovered
  PASS (E) caption-vs-error     PASS (F) contrast-pair: 24 pairs
  PASS (G) header-clause: 2 claim(s) checked, all fulfilled       <- the seam fix

docs/COMMANDS.md is regenerated from it in the same commit, because docscommandscheck arm (G) requires
the shipped document to be reproducible from the committed capture plus the binary: 195 flags in 7
sections, 176 samples, and --check reports the documented set equals the binary set.

The "Not run (and why)" list is UNCHANGED -- no flag was moved into it to make an arm pass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…unt is disclosed as a floor

The ratchet counted src/ingest_crawl.h:124 -- the `//` sentence explaining why Metal rides on
Lang::Cpp -- as the 326th shared-file `== Lang::` predicate against a ceiling of 325. The line is
identical on main and on this branch and no side added it; it became VISIBLE because the grep verb now
serves, with their floor disclosed, the hits it used to withhold in a parse_degraded file. In such a
file no span tier is known, so --grep-in=code cannot exclude a comment there: measured, that flag's
listing is byte-identical to the default's and both count 326, so passing it on the ratchet command
would have been a no-op. The fix therefore belongs in the counter.

count_predicates now skips a hit whose line begins `//` or `/*`, alongside the `case Lang::` rejection
it already had. `*` is deliberately not a comment opener: src/ holds real code lines that start with
one and compare (`*okOut = rc == 0;`, src/diffhunks.h:135), so rejecting a leading `*` would one day
drop a genuine `*lang == Lang::Cpp`.

DIRECTION, stated because this is a bar-adjacent edit on a shared gate: it DOES lower the count from
326 to 325 and make the gate pass. It is legitimate only because it removes a FALSE finding and makes
the counter measure the subject the ratchet file names -- a comment is no more a predicate than a
`case` label, which the counter already excluded. The ceiling is NOT raised: the ceiling row and the
six perlang rows are byte-identical to 2d03f0b by sha256, and the governed quantity (325) equals it.
The comment is NOT reworded, because that would pin the output and the next prose predicate re-breaks
it. Proved against generated listings, not edited source: the same saved --regex listing counts 326
with the previous counter and 325 with this one, and an 11-arm fixture keeps every real-code shape
counted (==, !=, a trailing // on a code line, a tab-indented predicate, a *-dereference predicate)
while rejecting the three comment shapes, with the per-language exclusion untouched.

Ruling 108, the same counter's second defect, is DISCLOSED here rather than fixed: the hit regex
requires `in=`, which the tool omits for a hit with no enclosing symbol, so such a row is dropped
silently -- MEASURED, 12 real `l == Lang::X` lines in src/langfacts.h:544-555 are counted by nobody and
the printed 325 stands against 337 served rows (IN5's source-level 339 says at least one further line
is not served at all, so 12 is itself a floor). The gate's own PASS/FAIL line, ratchet.tsv's header and
langidentitycheck.sh's contract paragraph now all call the figure a FLOOR and say the ceiling's
quantity is wrong in the SAFE direction -- too low, so the bar is stricter than it reads. The ceiling is
deliberately not re-based: making `in=` optional lifts the figure to 337 at once, and that file's rule
is "may fall and may never rise".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…fixbudgetcheck's H2 cell, with a REVISIT each

Two owner-ruled acks (104, 105) for integration/070-1120. Neither gate has an ack or waiver mechanism --
the repo's only ack ledger is .ripwire_quality_acks, which keys quality-delta findings, and no gate reads
a known-failure list -- so each ack is RECORDED, in the header of the gate a reader opens when the red
appears, and both gates STAY RED. Nothing was relaxed, no arm or grid point was removed, and
.ripwire_quality_acks is untouched.

loopconservationcheck (ruling 104). Arm (A): `2550bfdcd752 (parent e6671f2): 1 entry vanished from
the loop with no '# retired:' tombstone: phantomdefcheck`. THE MERGE is "Merge branch 'lane/v1-verbdef'
into lane/rt1-route", on the stack's shared history -- in integration/070-candidate, lane/cb1-code-clean
and lane/bx2-fix2-ceiling alike, absent from main, which is why main passes and this branch does not. The
gate is correct about history; the tree it guards is right today (the retirement is declared at
test/regression.sh:290 and test/phantomdefcheck.sh exists on neither tree); and it cannot be otherwise
without rewriting that merge out of the history (forbidden) or changing the conservation rule itself to
let a later commit's tombstone discharge an earlier vanish -- which needs its own red-first arm and is not
an integration branch's edit. Every mutation control (B..I) is green on the same run, so the walker is
live and this red carries information. REVISIT when that rule is designed, or when this history is no
longer an ancestor of what ships.

w3fixbudgetcheck H2 (ruling 105). ONE of 24 points, and the cell is named so nobody re-derives it: lens
--pack-task, task length `mid`, budget 3000 -- the top budget step, judged against the 1600 step below it
-- `the 9 row(s) served do not extend the 4 served at the budget below -- RP is not a growing rank
prefix`. The other 23 points hold, non-vacuity is green at 19 of 24, and main passes the whole arm, so
the behaviour travels with the --pack-task D1 rebuild on the cb1/r1b chain and not with the merge. RP is
a property of --pack-task's own per-section share assembly, which this gate itself calls a SOFT target;
making the 3000-budget page a rank prefix of the 1600-budget one is a product change owned by that lane.
REVISIT with the --pack-task section-share owner as part of 0.7.0's budget work.

Both failures were reproduced locally on this tip before the acks were written, and both files took pure
INSERTIONS: a line-level sha256 comparison against 2d03f0b reports removed=0 for each.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant