From b2313beae87902e9e13ae88057858cc92a5f8019 Mon Sep 17 00:00:00 2001 From: cndgrr <59120057+cndgrr@users.noreply.github.com> Date: Tue, 4 Aug 2026 10:58:59 +0000 Subject: [PATCH 1/2] docs(builder): a displaced predecessor is not the check's verdict Step 1 ruled what a rollup entry means and never said which entry to read. A job in a cancel-in-progress group displaces itself, so a head routinely carries a CANCELLED node beside the SUCCESS that replaced it, and read by class alone that head is not green while checks_state calls it SUCCESS. State the collapse ahead of the classes it feeds: newest entry by start time, and a CANCELLED entry is not the check's word while a non-cancelled sibling stands at the same head. All-cancelled and pending are untouched. Refs #276 --- BUILDER.md | 49 ++++++++++++++++++++++++++++++++++++++-------- changelog.d/276.md | 10 ++++++++++ 2 files changed, 51 insertions(+), 8 deletions(-) create mode 100644 changelog.d/276.md diff --git a/BUILDER.md b/BUILDER.md index 44d3316..bdb7780 100644 --- a/BUILDER.md +++ b/BUILDER.md @@ -252,14 +252,47 @@ CONTRIBUTING; the shared flow lives here and is not restated there.) explicitly and names the evidence (e.g. "the same job fails identically on `origin/main` at ``"). Silence about a red check is what is prohibited; an argued exception shifts the burden to the author. - *Green* is a ruled term (operator, 2026-07-27), and it is read from - each check's **`conclusion`**, never its `status`: a check carrying a - terminal conclusion is green or not-green by that conclusion whatever - its `status` field still reports — the two can disagree, and on #259 a - finished job's `status` lagged its own `conclusion: success` at the - head. A check with no conclusion at all is neither class: a configured - run still in progress is not green, and waiting for it is compliance, - not a stall. A **cancelled or stale** check is not a green head — + *Green* is a ruled term (operator, 2026-07-27), and it is read in two + steps, because a head carries more rollup entries than it has checks: + first pick the entry that is a check's word at this head, then + classify that entry. **A check's word at a head is its newest entry + by start time, and a `CANCELLED` entry is not that word while the + same check carries a non-cancelled entry at the same head.** The + survivor is the verdict about these bytes; the entry it displaced + reported nothing about them. That shape is routine rather than + exotic: a job in a `cancel-in-progress` concurrency group displaces + *itself* whenever two events land inside one of its runs, so one job + appears twice on one sha — #275's head at `806e99e1` carried + `labels / scope` `CANCELLED` started at 23:45:19Z beside + `labels / scope` `SUCCESS` started at 23:45:31Z, and that head is + green, with no argued exception owed. Say **start** time and mean it: + a cancelled run does not stop the moment its replacement begins, so + the dead run's completion routinely postdates the live run's start, + and a reader who dates entries by completion picks the corpse. When + *every* entry a check has at the head is cancelled, nothing survives + to be its word: that check has not reported at all, and it stays + not-green by the classes below — the all-cancelled context is the + case this leaves exactly where it was. Nor is any of this a new + class. The 2026-07-27 gloss that what survives at a head is same-head + cancellation was written against supersession by a newer push, not + against a job displacing itself inside its own concurrency group, and + `checks_state`'s #139 carve-out has read it that way in the machine's + voice ever since — cancelled entries dropped only where the context + keeps a non-cancelled survivor, an all-cancelled context left intact + and still blocking — so doctrine and gate partition alike on a mixed + context. What the *machine* drops from the rollup before it grades + anything is a different question, and crew's to describe rather than + this file's. + Then classify that entry, and classify it from its **`conclusion`**, + never its `status`: a check carrying a terminal conclusion is green or + not-green by that conclusion whatever its `status` field still + reports — the two can disagree, and on #259 a finished job's `status` + lagged its own `conclusion: success` at the head. A check with no + conclusion at all is neither class: a configured run still in progress + is not green, and waiting for it is compliance, not a stall. Picking + the newest entry never settles a live one: where the survivor is the + run still going, the head is not green and you wait on it exactly as + you would have. A **cancelled or stale** check is not a green head — *stale* means a check belonging to a superseded head, which the head-scoped rollup does not show anyway, so what survives there is same-head cancellation, never a same-head node whose `status` lags its diff --git a/changelog.d/276.md b/changelog.d/276.md new file mode 100644 index 0000000..7d2dcdc --- /dev/null +++ b/changelog.d/276.md @@ -0,0 +1,10 @@ +### Changed + +- BUILDER.md's green ruled term now says which entry to read before it says + what an entry means: a check's word at a head is its newest entry by start + time, and a cancelled entry is not that word while the same check carries a + non-cancelled one at that head (#276). +- A check whose every entry at the head is cancelled is unchanged — nothing + survived to be its word, so it never reported and is not green — and the + collapse mirrors `checks_state`'s carve-out rather than adding a class + (#276). From 4c8398a15dcd91f409d5fbc2ba96df4aba6ab3dc Mon Sep 17 00:00:00 2001 From: cndgrr <59120057+cndgrr@users.noreply.github.com> Date: Tue, 4 Aug 2026 11:29:13 +0000 Subject: [PATCH 2/2] docs(builder): the collapse rule, without the incident MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round 1 on #286: codex, claude and kimi each blocked on the same thing — the amended paragraph carried incident narrative that CONTRIBUTING.md's doctrine conventions keep in the cited record. Drop #275's head sha and both start stamps, the cancel-in-progress episode sentence, and the four clauses of 2026-07-27 gloss provenance. Carry checks_state's carve-out as one clause with a bare (#139, #276). The rule is unchanged and still decides #275's head unaided: two entries for one check, newest by start time wins, and the cancelled one is not the check's word while a non-cancelled sibling stands. --- BUILDER.md | 38 ++++++++++++++------------------------ 1 file changed, 14 insertions(+), 24 deletions(-) diff --git a/BUILDER.md b/BUILDER.md index bdb7780..fe2d5fb 100644 --- a/BUILDER.md +++ b/BUILDER.md @@ -259,30 +259,20 @@ CONTRIBUTING; the shared flow lives here and is not restated there.) by start time, and a `CANCELLED` entry is not that word while the same check carries a non-cancelled entry at the same head.** The survivor is the verdict about these bytes; the entry it displaced - reported nothing about them. That shape is routine rather than - exotic: a job in a `cancel-in-progress` concurrency group displaces - *itself* whenever two events land inside one of its runs, so one job - appears twice on one sha — #275's head at `806e99e1` carried - `labels / scope` `CANCELLED` started at 23:45:19Z beside - `labels / scope` `SUCCESS` started at 23:45:31Z, and that head is - green, with no argued exception owed. Say **start** time and mean it: - a cancelled run does not stop the moment its replacement begins, so - the dead run's completion routinely postdates the live run's start, - and a reader who dates entries by completion picks the corpse. When - *every* entry a check has at the head is cancelled, nothing survives - to be its word: that check has not reported at all, and it stays - not-green by the classes below — the all-cancelled context is the - case this leaves exactly where it was. Nor is any of this a new - class. The 2026-07-27 gloss that what survives at a head is same-head - cancellation was written against supersession by a newer push, not - against a job displacing itself inside its own concurrency group, and - `checks_state`'s #139 carve-out has read it that way in the machine's - voice ever since — cancelled entries dropped only where the context - keeps a non-cancelled survivor, an all-cancelled context left intact - and still blocking — so doctrine and gate partition alike on a mixed - context. What the *machine* drops from the rollup before it grades - anything is a different question, and crew's to describe rather than - this file's. + reported nothing about them. Say **start** time and mean it: a + cancelled run does not stop the moment its replacement begins, so the + dead run's completion routinely postdates the live run's start, and a + reader who dates entries by completion picks the corpse. When *every* + entry a check has at the head is cancelled, nothing survives to be + its word: that check has not reported at all, and it stays not-green + by the classes below — the all-cancelled context is the case this + leaves exactly where it was. This states a collapse and not a new + class: `checks_state`'s carve-out drops a cancelled entry only where + its context keeps a non-cancelled survivor, and leaves an + all-cancelled context intact and still blocking, so doctrine and gate + partition alike on a mixed context (#139, #276). What the *machine* + drops from the rollup before it grades anything is a different + question, and crew's to describe rather than this file's. Then classify that entry, and classify it from its **`conclusion`**, never its `status`: a check carrying a terminal conclusion is green or not-green by that conclusion whatever its `status` field still