Skip to content

The merge-queue proposal carries a measured contention rate, with the instrument named - #10378

Merged
gunbai-bot[bot] merged 3 commits into
mainfrom
session/bold-ram-844-queue-evidence
Sep 4, 2026
Merged

gunbai-bot[bot] merged 3 commits into
mainfrom
session/bold-ram-844-queue-evidence

Conversation

@gunbai-bot

@gunbai-bot gunbai-bot Bot commented Sep 4, 2026

Copy link
Copy Markdown
Contributor

MAIN-Q argued for the merge queue from the failure it prevents — stale-green, a PR validated against a base that pre-dates a newly landed gate. That argument is sound and it is a priori. This adds the measurement.

What was measured

docs/design-failure-modes.md is a generated projection whose merge driver refuses whenever both sides changed it since the base — which is every landing, for any branch that also touched it. Over one 12-hour window on 2026-09-04: 48 landings on main, 14 of them touching that file.

The annotation names the git log invocations that re-derive those figures over any window, rather than presenting the numbers as the authority, and dates the run that produced the ones quoted. §6's rule is that a measurement is cited by naming the producer; here the producer is three one-line commands a reader can run against any base.

Why the rate is not the interesting number

The figure that decides the case is its relation to validation time. Once the interval between collisions falls below the time to get a resolved head through the required aggregate, resolving promptly cannot win: every resolution is obsolete before the run that would validate it finishes.

And resolving faster makes it worse, not better — each attempt is a new head, a fresh queue position, and a fresh set of voided approvals. Three lanes were in that state simultaneously on the measured date, and one branch ran six regenerate-then-remerge cycles and converged zero times.

Why a queue rather than discipline

Serialised landing dissolves this by construction: each conflict is resolved once, against a base that cannot move underneath the resolution while it is being validated.

The alternative available without a queue — resolve once, at the moment of landing, and let the branch sit behind its base until then — is the same discipline enforced by hand. That is why it works, and why it does not scale past the lanes willing to observe it.

Scope

Annotation only on gunbc_merge_queue_proposal. No type, no predicate, no behaviour, no live repository setting read or written. The sign-off gate is untouched: the proposal remains MergeQueueUnsigned and converge still refuses.

This branch touches only dag/gunbc/repo/repo_ruleset.dag, so it does not contend with the row PRs on roster.dag or the projection.

🤖 Generated with Claude Code

https://claude.ai/code/session_01RPZR4RfT74eH25bQQZzFKL

Brian Searls and others added 2 commits September 4, 2026 08:22
… instrument named

MAIN-Q argued for the queue from the stale-green failure it prevents. That
argument is sound and it is a priori; this adds the measurement, because a
proposal carrying an observed contention rate is a different artifact from one
reasoning about a hypothetical.

The evidence is `docs/design-failure-modes.md`, a generated projection whose
merge driver refuses whenever both sides changed it since the base -- which is
every landing, for any branch that also touched it. Over one 12-hour window,
48 landings on main, 14 of them touching that file.

The figure that decides the case is not the rate but its RELATION to validation
time: once the interval between collisions falls below the time to get a
resolved head through the required aggregate, resolving promptly cannot win.
Every resolution is obsolete before the run that would validate it finishes, and
resolving faster makes it worse -- each attempt is a new head, a fresh queue
position, and a fresh set of voided approvals. Three lanes were in that state at
once on the measured date; one branch ran six regenerate-then-remerge cycles and
converged zero times.

Serialised landing dissolves it by construction: each conflict is resolved once,
against a base that cannot move underneath the resolution while it is validated.

Per §6 the annotation names the git invocations that RE-DERIVE the figures over
any window rather than presenting the numbers as the authority; the run reported
is dated so a reader can see which window produced it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RPZR4RfT74eH25bQQZzFKL
…e conditional

The annotation said the driver refuses "whenever both sides changed it since the
base, which is every landing for any branch that also touched it". The first
clause is right; the subordinate one is a universal, and the same measurement
beside it refutes it -- 14 of 48 landings touched the projection, so a branch
that touched it collides only once main also does.

A live counterexample sat beside the measurement: a branch in this very
contention with main=1, ours=0, rc=0, no refusal.

The conditional is stronger rather than weaker, because it carries the rate: the
refusal is certain WHEN both sides moved, and the probability of that grows with
how long a branch stays open against a 14-in-48 churn. So the cost falls on
exactly the branches that wait -- which is every branch waiting on a queue
position, and therefore still an argument for the queue.

As written, the first fast landing that did not collide would have read as a
falsification of the whole annotation, and a universal quantifier in an
authority file is what later readers cite rather than re-derive.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RPZR4RfT74eH25bQQZzFKL
… BOTH function nicknames

`repo_ruleset_converge_entry` holds this file's own path; `repo_ruleset_converge_function` and
`repo_ruleset_verify_function` hold the spellings "converge" and "verify". Each occurs exactly
once in the repository -- its own declaration -- with nothing in `dag/` or `src/` reading it.

They are more than unused. §4c: an ordinary String whose only purpose is commentary is
misplaced or dead data, mechanically indistinguishable from program data, which is the shape
the 215-row sweep removed and the reason `//` exists as the quarantine boundary. §3: a path
standing where the containment tree already names the module is positional naming and decays
the way a file:line pointer decays, and a String spelling a function name is a nickname for a
symbol the namespace authority already knows rather than a citation of one.

THREE RATHER THAN TWO IS THE POINT. A review named `repo_ruleset_converge_entry`; a second
reader found `repo_ruleset_verify_function` on the line below; `repo_ruleset_converge_function`
sat between them, unnamed by either, identical in class and equally dead. Fixing the named
sites and leaving the third would be the site-versus-class error at one remove -- and worse
than leaving all three, because the reviews that would have surfaced the survivor are then
marked addressed.

Landed here rather than as its own PR: this branch already touches this file, so the deletion
costs no additional head, approval re-issue, or CI draw.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RPZR4RfT74eH25bQQZzFKL
@gunbai-bot
gunbai-bot Bot merged commit c3bf89d into main Sep 4, 2026
7 checks passed
@gunbai-bot
gunbai-bot Bot deleted the session/bold-ram-844-queue-evidence branch September 4, 2026 16:15
gunbai-bot Bot pushed a commit that referenced this pull request Sep 4, 2026
… converge() this change removes

One conflicted path, dag/gunbc/repo/repo_ruleset.dag, resolved to preserve BOTH
authorized deltas rather than by taking a side:

- #10378's contention-rate annotation (its first hunk) auto-merged untouched.
- #10378's SECOND delta was deleting three dead `String` rows --
  repo_ruleset_converge_entry / _converge_function / _verify_function. That is the
  §4c prose-as-data cleanup this branch had identified and routed to MAIN-Q; it
  landed there first, so the deletion is taken and the two rows this branch still
  carried are gone.
- This branch's world_* handler restructuring is kept whole.

MAIN'S "VERIFY IS READ-ONLY AND CONVERGE WRITES" NOTE IS DROPPED, and that is the one
resolution that is not mechanical. It describes two entry points; this change deletes
the mutating one along with apply_desired_ruleset, so after the merge the file declares
`verify()` and nothing else, and nothing in the tree cites `apply_desired_ruleset` or
`repo_ruleset_converge_function`. Keeping the note would leave a §3 citation of a symbol
that no longer exists -- a note is not preserved by being carried, only by staying true.

THE ROSTER ORDINAL IS RENUMBERED TWENTY-FIRST -> TWENTY-THIRD, which the merge forces and
a grep would have hidden. Main's highest transition is now TWENTY-SECOND (#10355), so
TWENTY-FIRST follows nothing. It is also not free for the taking: #10355 was itself
numbered twenty-first on an earlier head and renumbered rather than reused, so that a
citation of "the twenty-first entry" would not resolve to two rows across time. An
abandoned ordinal and an unused one are indistinguishable by counting, so the vacancy is
a trap rather than an invitation.

The consumed-row obligation is discharged by main's own deletion: the roster goes
258 -> 33 rows, being main's 31 plus this change's 2, which is exactly the blocker run
33889309585 reported (255 consumed admissions due on a roster-touching change) while its
floor read FloorClean with claims_failed=0.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015EdHQ244XXdBKRKGX6jrV4
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.

0 participants