Repository navigation
ci(review): budget the slot lookup that licenses a notice comment - #13657
Conversation
cbd2b09 to
f5dbb80
Compare
Design Review (Fable 5) — ✅ PASSDesign-level review of Design-Verdict: PASS Existing duplicate slot comments stay forever: this PR prevents new ones but reconciles none — sweep open PRs for double markers once. Suggestions
[DESIGN-REVIEWED] bd66a68 |
First Principles Review (Fable 5) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Verify the trade Not justified as shipped
What this change shipsInventory (9 items) — 8 justifiedIntent: stop review lanes from posting a second notice comment under one marker when the slot read silently fails — a FIX.
I checked [FIRST-PRINCIPLES-REVIEWED] bd66a68 |
GPT 5.6 Review — ✅ human override acceptedHuman judgment by @bolichen97 overrides the GPT 5.6 finding for [GPT-OVERRIDE] bd66a68 This comment is updated in place on each push. The model was not re-run because an authorized human decision supersedes it. False positive or not applicable? A repository writer can comment: |
Opus 5 Review — ✅ no blocking findingsReviewed Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
f5dbb80 to
df3f843
Compare
Round 2 -- dispositions for
|
| # | write | slot | head | writes? | why |
|---|---|---|---|---|---|
| 1 | notice PATCH | occupied | still $HEAD |
yes | the notice is about the revision the PR is on |
| 2 | notice PATCH | occupied | moved to B | no | replaces B's verdict, and nothing restores it |
| 3 | notice PATCH | occupied | unreadable | no | cannot tell 1 from 2, and writing is the destructive direction |
| 4 | notice CREATE | empty, read answered | still $HEAD |
yes | -- |
| 5 | notice CREATE | empty, read answered | moved to B | no | presents a superseded revision's line as the current one |
| 6 | notice CREATE | empty, read answered | unreadable | no | as 3 |
| 7 | notice CREATE | read failed | any | no | round 1's gate: a swallowed read is not an empty slot |
| 8 | verdict, attempt 1 | any | any | yes, unconditionally | see below |
| 9 | verdict, attempt >1 | any | moved or unreadable | no | already guarded (rc=4) |
| 10 | verdict, attempt >1 | accepted override | -- | no | already guarded (rc=5) |
Case 8 is the qualifier, and it is why the rule says notice. For a verdict, withholding is the expensive direction: the marker comment is the only thing a freshness verifier reads, so a run that declines to publish leaves the revision indistinguishable from one no lane ever reviewed. Extending this gate to retry_comment_write's first attempt would turn an unreadable head into a silently withheld verdict, which is the failure mode this lane family already has an open report for. A notice carries no verdict, so declining costs a stale line. That asymmetry is the whole basis for the split, and a test asserts the verdict path does not carry head_unchanged while the notice path does.
The report-only arm is deliberately ungated. A first pass put head_unchanged on all three arms; the behavioural test then showed that when both reads fail the run printed only the head warning and swallowed the fact that the slot was unreadable. An arm that writes nothing needs no licence, so it is now elif [ "$lookup_ok" -eq 0 ] and both facts reach the log. Pinned in both directions.
Eight notice write sites across the five lanes, all now licensed. The seven lanes with no notice write are asserted to have neither the gate nor a write, so one cannot appear ungated later.
Red on the pre-gate tree. Against f5dbb80425 with only the test file swapped in: 12 failed, 29 passed. The behavioural case is the one that names the defect: assert not (calls_dir / "patch-calls.txt").exists() fails as assert not True, so the pre-gate branch did PATCH its stale notice over the newer revision's verdict. The 29 passes are the lanes with no notice write plus round 1's own pins, so the redness is located rather than a wash.
Backend Lint and Type Check (3.12) -- fixed
test/test_ai_review_workflows.py was not black-formatted. Reformatted; black --check, flake8 and isort --check-only clean.
Build Windows Installer (x64) -- not attributable to this diff
.github/scripts/test-windows-installer.ps1:221, "Windows installation exceeded the 120-second ceiling". A wall-clock ceiling on the hosted Windows runner, reached after a successful build and sign. This diff is five review-workflow YAMLs plus one Python test file; none of them is read by the installer build, the NSIS step, or the install probe. Re-measured on the new head rather than re-run, and it will be reported here if it recurs.
Local verification
test/test_ai_review_workflows.py, -n0: 988 passed.
df3f843 to
390825e
Compare
Round disposition, head
|
| shard | failing test | assertion |
|---|---|---|
Backend Tests (Windows) (7) |
test/test_runtime_cleanup_windows.py::test_repeated_windows_provider_shutdown_reclaims_entire_tree |
AssertionError: owned processes still alive: [1208, 7576, 6868] |
Backend Tests (Windows) (4) |
test/test_platform_compat.py::TestProcessDescendants::test_native_observed_grandchild_survives_snapshot_gap |
OSError: Windows descendant handles unavailable: [840, 2120, 2824], each candidate open=winerror=5 |
Open issue #13495 ("windows: recycled PIDs can make descendant scan retain an
unrelated process", labels bug, platform: windows, area: core, claimed)
already carries both signatures in its own evidence table: the literal
owned processes still alive: [...] assertion and the literal
OSError: Windows descendant handles unavailable, across four unrelated heads,
described there as reddening unrelated PRs. Closed #13563 documents the
winerror=5 recycled-parent-PID mechanism that appears verbatim in the shard 4
annotation above, including the query_unvalidated=identity= diagnostic and
root_at_scan=.
Cross-head evidence that this diff cannot be the cause:
- On the preceding head
f5dbb80425, all 8 of 8 Windows shards weresuccess. - The
src/tree object is byte-identical across the two heads
(0cf25baaed544255f7967a07424d9d6d6d1add96on both). - Both failing test files are byte-identical across the two heads
(35f71b60c0de...and5172c114d579...on both). - This commit's file list contains no
src/path and neither failing test file.
Same source, same tests, 8 of 8 green then 2 of 8 red. Not re-run: the re-run
allowance on this PR covers installation-read-limit logs only, and these logs are
process-lifecycle failures.
Two observations from this round's logs
This PR's own subject reproduced live. The GPT 5.6 Review annotation reads
GPT 5.6 Review produced a verdict for 390825e2cfa5... but could not publish it, so this run's verdict is not in the slot. A computed verdict was withheld and
nothing republishes it, which is exactly the recovery gap this change set was
opened against. Recorded on the follow-up design issue rather than here.
The new gate was observed working under a real read limit. UX Review emitted
both warnings at once: that its slot was unreadable after 6 attempts, and that
the head was unreadable so the notice was deliberately not written. Two separate
facts reaching the log is the reason the report-only arm is ungated while every
write arm is gated. A single combined warning would have hidden the unreadable
slot.
No code change this round; no push, so no review lane was re-rolled by this
comment.
390825e to
13288e3
Compare
|
Round disposition, head Opus 5 finding 1 -- UPHELD and fixed
Fixed: the head read now carries the same six-attempt, 5s-linear-backoff budget as the New pin Opus 5 finding 2 -- UPHELD and fixed
Enumerated rather than spot-fixed. Eight call sites, two classes, and the class is
The restructure script classified all eight and refused unless exactly four moved; the New pin The structural pin now encodes both classes per lane, deriving the class from whether Design CONCERNS -- cleared as its own text askedIts stated clear condition was "the description documents the head-freshness gate (its First Principles CONCERNS item 5 -- disagreement recorded, gate retainedIts Subtraction asks to defer The gate stays and the disagreement is written into the body rather than resolved Backend Tests (Windows) (4) and (7) -- not attributable, trackedTracked open flakes, each matched by test node id:
Both files are byte-identical to this PR's base and nothing under Local evidence
|
|
Round disposition, head The red on the parent was not a verdict
It was not re-run. A re-run would have been cancelled by this round's push through the Opus 5 CANDIDATE 1 -- UPHELD, and it is this PR's own regressionIts discovery pass, readable in the run log even though the verdict never reached the
Verified against the code rather than taken on trust. The creating arms ran Fixed by reading the slot LAST on the creating arms. Enumerated, eight call sites, and
The reordering script classified all eight by whether the arm owns a CREATE branch and New pin Opus 5, the misattributing warning -- UPHELD and fixed
Opus 5, marker uniqueness unpinned -- UPHELD and pinnedThe step's own comment claims one marker makes the slot one slot, and nothing held it.
One residual, pinned rather than hiddenOn a replace-only arm the order must be slot-then-head, so the head answer is up to a Evidence46 tests pass on this head. Against the parent with only the test file replaced: 4 |
A review lane's override, no-contract and skip notices pick between PATCH and CREATE from a marker lookup of their own, separate from the guarded upsert that publishes a verdict. That lookup was a single attempt whose error was swallowed, so an API flake answered "the slot is empty" and the branch created a second comment against a slot that already held one. Two comments under one marker do not come back out: a later lookup patches whichever id it picks and the other keeps whatever line it carries. Enumerated all twelve lanes. Five define such a lookup; four branches across three of them create from it, and the rest only patch. All five now share one byte-identical budgeted body -- six attempts, 5s linear backoff -- that reports whether the read answered separately from what it found. A create runs only when the read answered; an unreadable slot writes nothing and says which notice did not land. Refs #13100 Refs #8350
3602a58 to
bd66a68
Compare
|
Round disposition, head F2 -- UPHELD and fixed at the rootThree lanes staged the override note at the literal path Fixed by staging it under New pin Both F1 -- disputed, and the dispute is about the premise rather than the orderingF1 asks for the head to be reconfirmed after the slot lookup, because the lookup's own So the ordering is not where this is decided. The premise underneath it is. The gate exists because an earlier GPT finding, also fenced-UPHELD, held that turning a The If that measurement stands, the head licence was built on a premise that does not hold, Removing a fix that answered a fenced-UPHELD finding is not a change to make from inside
No Evidence58 tests pass on this head. Against the parent with only the test file replaced: 3 failed |
|
Board state on head
All four are stamped with this head, so none is a stale slot carrying an older Two reds earlier on this revision were infrastructure and both cleared on a second
Two things this changes about the earlier disposition. First Principles has moved from CONCERNS to PASS on this head, so its item-5 Subtraction Three of the four review lanes now pass on exactly the code the remaining finding objects The finding is security-class and fenced, so its only clearance path is a human override |
|
Evidence on the disputed premise, head The premise, as it was recorded when the head gate was first added: giving the slot 1. Static: every path from the deciding read to the write, enumerated
On all 63 paths that reach a deciding read, the segment from that read to 2. Runtime: the real interval, with the backoff actually elapsingThe extracted step scripts were run under a stub Two intervals are reported because the dispute turns on telling them apart.
What the numbers say
The 75-second figure is real. It belongs to The second consequence matters as much as the first. On the base form This does not clear the current finding. It is a security-class fenced finding and its Reproduce with the two scripts used here, both kept outside the repository tree in this |
|
/ai-review override gpt bd66a68: the loss-bearing variant needs a push after Verified independently against
The adjudicator reached the same conclusion and flagged it ( Authorizer: bolichen97. |
Human judgment recorded@bolichen97 marked the gpt AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
What is the problem?
Four branches across three review workflows create a notice comment from a slot read
whose failure is swallowed. The read is a single
gh apicall whose error is discarded,so "the read answered and the slot is empty" and "the read never answered" both arrive
as one empty string. On the empty string the branch takes its CREATE arm.
When the read in fact failed against an occupied slot, that CREATE produces a second
comment under the same marker. A later lookup patches whichever id it picks first; the
other keeps whatever line it carries, and no run reconciles them.
The divergence this started from:
first-principles-review.ymlcreated from anunretried read while
fork-first-principles-review.yml, its own fork twin, onlypatched.
Why this issue matters to the user
A reviewer reads one comment per lane. Two comments under one marker means the board
can show a stale verdict beside a current one with nothing to say which is which, and
the stale one can carry a blocking line.
The failing read is not rare. It is the GitHub App installation rate limit, which
exhausts for minutes at a time and refuses every call in the window, so the branch most
likely to take its CREATE arm on a bad read is the one running during an outage.
How our fix solves it, symptom to root cause
The symptom is a duplicate comment. The immediate cause is the
elsearm creatingone. The root cause is that the branch cannot distinguish two different facts -- "the
read answered and the slot is empty" from "the read never answered" -- because both
arrive as one empty captured string.
The fix separates them. Each step now declares one budgeted lookup that sets
lookup_okandexistingindependently:verdict already carry, because the API exhaustion window that breaks this read
lasts minutes rather than one request.
awk 'NR == 1'rather thanhead -n1, which SIGPIPEs thegh apicall underpipefailand is itself a swallowed read.A CREATE now runs only behind
elif [ "$lookup_ok" -eq 1 ]. When the read neveranswered, the step writes nothing and emits a
::warning::naming which notice didnot land and for which revision -- the safe failure, because the lane's verdict is
still carried by its step output and its check-run conclusion, while a duplicate
comment is not recoverable by any run.
The head-freshness gate, and why the verdict path is exempt
Adding the retry budget above has a cost that has to be paid in the same change:
it stretches the gap between reading the slot and writing to it from milliseconds to
about 75 seconds. A newer revision can publish its verdict into the slot inside that
window, and this run then holds a real comment id pointing at a verdict for a revision
it never reviewed. Writing there replaces that verdict with a superseded revision's
notice, and nothing puts it back.
So every notice write, PATCH and CREATE alike, is licensed by
confirm_head: one morebyte-identical shell body, shared by the same five lanes, that re-reads
repos/$REPO/pulls/$PRand compares it to the revision the notice is about. Threeoutcomes, one licence:
That read carries the same six-attempt budget as the slot read, for the same reason and
measured on this PR: both reads sit inside one exhaustion window, so a lane that has
just spent 75 seconds retrying the slot is the least likely to get this one answered
first time. Unbudgeted, a single blip reads as a moved head; on the override-note arm
that withholds the note while
verdict=OVERRIDEis still emitted, leaving a blockingcomment standing over an override a human already accepted, which
security-scope-review.ymlnames as the one comment state nothing later clears.Where
confirm_headis called, and in which order relative to the slot read, dependson what the arm does with an empty slot. Both classes are pinned:
design-review.yml,first-principles-review.yml,ux-review.ymlfirst-principles-review.yml,ux-review.yml,fork-first-principles-review.yml,fork-ux-review.ymlThe order on the creating arms is the second cost of the retry budget, and it has to be
paid in the same change. A CREATE decides on
existingbeing empty. With the slot readfirst and the head check second, up to 75 seconds of backoff sit between reading the slot
and acting on that read, so another run on the SAME head -- a lane re-run, or a run
cancelled by
cancel-in-progresswhoseif: always()post step keeps executing -- canpublish into the slot inside the gap and the CREATE lands beside it. Both runs pass the
head check, so the head licence alone does not catch this. Reading the slot last closes
it.
Two arms deliberately carry no head licence.
The arm that only REPORTS an unreadable slot writes nothing, so it needs none.
Requiring one there swallows the slot fact in exactly the run that most needs it: when
both reads fail, the log would name only the head. An earlier revision of this change
gated that arm and the behavioural test caught it.
retry_comment_write, the verdict path, still checks the head only from its secondattempt. A verdict withheld is the expensive direction: the slot is the only thing a
freshness verifier reads, so a run that declines to publish leaves its revision
indistinguishable from one no lane judged. That is the harm #13100 describes. A notice
carries no verdict, so withholding one costs a stale line. This asymmetry is the whole
reason the rule says "notice" rather than "every write", and it is pinned from both
directions.
Enumerated across all twelve review lanes, not spot-fixed.
defines lookup= thenotice step declares
find_existing;creates= some branch in it creates a commentrather than only patching one.
claude-review.ymlcodex-review.ymldesign-review.ymlfirst-principles-review.ymlfirst-principles-review.ymlfirst-principles-review.ymlfork-design-review.ymlfork-first-principles-review.ymlfork-gpt-review.ymlfork-opus-review.ymlfork-security-scope-review.ymlfork-ux-review.ymlsecurity-scope-review.ymlux-review.ymlux-review.ymlFour create sites across three files were the duplicate-comment defect. The five lanes
that define a lookup now share two byte-identical bodies,
find_existingandconfirm_head, pinned the wayretry_comment_writeandguarded_comment_upsertalready are, so neither budget can drift lane by lane.
design-review.yml's overridenote carried its own private
OV_MARKERand inline read; it now uses the step's singlemarker and single lookup.
What tests we did
test/test_ai_review_workflows.py, new classTestNoticeSlotLookupLicensesEveryCreate,43 selected tests pass.
Structural, over all twelve lanes:
test_slot_lookup_is_one_budgeted_body_wherever_it_is_defined-- the fivefind_existingbodies are byte-identical, budgeted, carry no|| trueand nohead -n1, and setlookup_okandexistingas separate facts.test_every_notice_create_sits_behind_the_gate-- parametrized with the per-caseverdict above. Every notice create is immediately preceded by the
lookup_ok -eq 1gate; a lane that creates nothing must not gain an ungated create; a lane that reads
the slot must account for the unreadable case.
test_no_notice_read_keeps_its_own_unbudgeted_copy-- no step retains a privatemarker read.
test_head_confirmation_is_one_body_wherever_a_notice_is_written-- the fiveconfirm_headbodies are byte-identical, read the head from the PR rather than theevent payload, carry the same six-attempt budget, and return on a moved head without
retrying it, since a definite answer is not a transient failure.
test_every_notice_write_is_licensed_by_a_confirmed_head-- both arm classes fromthe order table, per lane, with the class derived from whether the arm owns a
CREATE branch rather than asserted.
test_the_verdict_path_does_not_take_the_notice_head_gate-- the qualifier, holdingretry_comment_writeout.test_a_replace_arm_still_writes_from_a_head_read_taken_before_the_write-- theresidual, pinned at its current answer rather than left implicit.
test_one_marker_serves_every_write_in_the_step-- one marker name, one value, oneliteral string per step, which is what a split slot would show.
Behavioural, with a stubbed
ghon PATH:test_an_unreadable_slot_creates_nothing_and_says_so-- every comments read failswhile the slot already holds this lane's comment. Zero creates, zero PATCHes, six
read attempts, six head attempts, a warning naming the revision.
test_a_moved_head_leaves_the_newer_revision_verdict_in_the_slot-- the read fails,sleeps, a newer revision publishes into the slot, the retry then succeeds with a real
comment id. Nothing is written.
test_a_transient_head_read_is_retried_not_read_as_a_moved_head-- an acceptedoverride, an occupied slot, and a head read that blips twice before answering with
the same head. The note replaces the blocking comment rather than the blip leaving it
standing.
test_a_skip_arm_with_an_empty_slot_asks_nothing_about_the_head-- a readable emptyslot on a skip arm reads no head at all and says nothing about a notice it was never
going to write.
test_a_create_arm_reads_the_slot_after_the_head_backoff-- the slot is empty whenthe head check starts and taken by the time it finishes, which is another run on this
same head publishing during the wait. The arm patches the occupant instead of adding
a second comment.
Red on base. Run against the parent commit in a detached worktree with only the
test file replaced, the class gives 8 failed / 35 passed. Each behavioural failure is
its own defect stated as an assertion:
assert not (calls_dir / "create-calls.txt").exists()fails, asecond comment against an occupied slot while every read failed.
assert not (calls_dir / "patch-calls.txt").exists()fails, a stalenotice patched over a newer revision's verdict.
assert (calls_dir / "patch-calls.txt").exists()fails, oneblip read as a moved head.
assert not (calls_dir / "head-calls.txt").exists()fails,a head read on an arm with nothing to write.
assert not (calls_dir / "create-calls.txt").exists()fails against the slot-read-first order, a second comment beside the occupant that
arrived while the head check was retrying.
Each of the last two was measured separately against the intermediate revision that
carried the earlier order, so every pin is shown to discriminate against the code it
replaces rather than only against the original base.
The 35 passes are the seven lanes that legitimately carry no notice read, so the tests
are not failing indiscriminately.
The five workflows parse as YAML and every modified step is
bash -nclean. Thecomment-history gate passes against the base, black, isort and flake8 are clean.
Any other suggestions on the work
The existing pin
test_the_lookup_that_gates_a_verdict_write_is_retriedcarries acomment excusing these very reads, on the grounds that "an override lookup, a skip
notice that updates a comment if one happens to exist -- an empty answer there writes
nothing and strands nothing." That is true of the skip notices and false of the
override and no-contract notices, which create. The reasoning is worth revisiting
wherever else it is relied on.
#13595 proposes the complementary change on the patch-only arms: have a skip notice
CREATE its keyed comment when none exists, so an absent slot means only "the lane never
got that far". It names the same sites this PR touches. The two compose rather than
conflict -- this PR supplies the gate that makes such a create safe, since a create
taken from a swallowed read is precisely the duplicate hazard. When #13595 lands, those
lanes flip their
createsflag in_NOTICE_LANES, keep thelookup_ok -eq 1gate, andmove
confirm_headahead of the branch as the placement table requires; the pins'failure messages say so.
A recorded disagreement between two advisory lanes. First Principles asks, as a
Subtraction, for
confirm_headand its pins to be deferred to their own change, on thegrounds that the duplicate-comment defect is closed by the lookup budget and the create
gate alone. That is correct about the duplicate defect and it is not the whole cost:
the retry budget this PR adds is what opens the read-to-write window, which GPT 5.6
raised as a blocking finding against this PR's own earlier revision. Shipping the budget
without the licence would leave a hazard this change introduces, so the licence stays
and the disagreement is recorded here rather than resolved silently. The same lane's
other items carry no Subtraction.
Opus 5 raised the findings that produced the head-read budget, the skip-arm placement,
and the slot-read-last order on the creating arms. Each is fixed with a behavioural pin,
red against the revision it replaces.
One residual is left and pinned rather than hidden. On a replace-only arm the order has
to be slot-then-head, so the head answer is up to a minute old when the PATCH runs. The
head check narrows that window and cannot close it: the slot holds one comment id
whichever revision wrote it, so re-reading the id proves nothing about whose body is
there now, and closing it needs a conditional write the API does not offer. The exposure
is bounded where a creating arm's is not -- a stale PATCH overwrites one comment, while a
stale CREATE adds a second under one marker that no run removes.
test_a_replace_arm_still_writes_from_a_head_read_taken_before_the_writeasserts thecurrent answer so a later reading does not mistake it for solved.
One dead assignment removed in
design-review.yml:MARKERwas assigned the identicalstring twice in the same step. Behaviour is unchanged by construction -- the variable
already held that exact value at the second assignment -- and removing it makes the
step's own single-marker comment structurally true rather than coincidentally so.
Two
Backend Tests (Windows)shards were red on an earlier head of this branch fromtracked flakes #10768 and #12359, in
test/test_platform_compat.pyandtest/test_runtime_cleanup_windows.py. Neither file, and no file undersrc/, differsfrom this PR's base; both shards were green on the following head.
This PR does not address the stranded-verdict recovery gap #13100, #13456 and #13595
describe: a lane whose verdict is computed and then withheld because the slot is
occupied still never republishes it. That needs a different mechanism and is tracked in
#13659, which this PR's own CI has now reproduced twice --
GPT 5.6 ReviewandOpus 5 Revieweach computed a verdict for a head of this branch and could not publishit, so neither verdict reached the slot.
The override note is staged under the runner's own temp dir. Three lanes spelled that
one path
/tmp/ai-override-note.mdwhile every other body in the same files uses therunner temp dir, so two lanes on one runner wrote the same file and any test executing
that arm wrote it on the host.
test_no_notice_body_is_staged_at_a_hardcoded_host_pathholds the rule over the five lanes this change owns and records, by name, the one
instance left outside them --
claude-review.yml's/tmp/claude-summary.md, which thisPR does not touch -- so it is visible rather than quietly excluded by the lane filter.
Both
$RUNNER_TEMP/xand${RUNNER_TEMP:-/tmp}/xare accepted; several fork lanes usethe stricter first form and the rule is about the literal path, not the spelling.
One finding on this revision is disputed rather than fixed, and it is recorded here
because it cannot be settled by reordering. A reviewer asks for the head to be
reconfirmed after the slot lookup, on the grounds that the lookup's own backoff
invalidates an earlier head licence. That is true, and its mirror image is equally true:
the previous revision read the slot first and was told, correctly, that the backoff then
invalidated the slot answer. Both reads carry the same budget, so whichever runs second
staleness the other, and reconfirming after the lookup only moves the window a third
time -- the adjudication on that finding says so itself.
The measurement that decides it:
find_existingreturns from inside its success branch,before the
sleepthat follows a failed attempt. So the read that DECIDES a write isadjacent to that write in both the single-attempt and the budgeted form; the budget
lengthens the wait BEFORE an answer arrives, not the gap after it. The premise that the
budget widened a read-to-write window from milliseconds to about 75 seconds does not hold
against that control flow, which makes the head licence built on it the thing to
re-examine rather than its ordering. That is a maintainer's call, not this PR's, so the
licence stays in place and the dispute is stated rather than acted on.
Refs #13100
Refs #8350