Skip to content

docs: a private pin is the one bump CI cannot check, and the three commands that are its evidence - #2323

Merged
bong-water-water-bong merged 2 commits into
mainfrom
pkg/pre-pr-private-pins
Nov 13, 2026
Merged

bong-water-water-bong merged 2 commits into
mainfrom
pkg/pre-pr-private-pins

Conversation

@bong-water-water-bong

@bong-water-water-bong bong-water-water-bong commented Nov 13, 2026 •

Copy link
Copy Markdown
Collaborator

Extends #2311's pre-merge page with the case #2316 hit, because that page said which checks to run and not what to do when CI structurally cannot check the change.

The gap

config/npu-runtime.config, config/gpu-kernels.config, config/llama-mirror-hold.config and the toolchain file pin private repositories. No workflow in this repository fetches them — every .github/workflows/* has zero mentions of fetch-private, ONEBIT_GPU_PRIVATE or gpu-kernels — so a green build on a pin bump proves the engine configures and builds without that dependency, and says nothing about the commit the pin names. tools/check_pins.py does not cover it either: it compares submodule gitlinks, not config/*.config shas.

The three commands that are the evidence

git ls-remote https://github.com/1bit-MONSTER/<repo>.git refs/heads/main        # the pinned sha IS the advertised tip
bash scripts/fetch-private.sh config/<the>.config ~/.cache/scratch-<lane>/pin  # rc 0, HEAD == the pin, require= paths present
git -C ~/.cache/scratch-<lane>/pin diff --stat <previous pin>..HEAD            # what the range actually contains

Cheap enough to run before merge: a fetched private pin was 3.4 MB and 1.4 s.

Two traps, both measured today

  1. fetch-private.sh reads the config out of the working tree. Run from a checkout of an older commit it fetches the older pin and returns rc 0 — identical output, wrong answer. I did exactly that on gpu-kernels: pin eb0f3839 — the 2^-6 prefill prescale (#2159), the routed GEMM fit (#572) and the registration guard #2316 and reported the old pin as fetched before catching it.
  2. A pin range is not the fixes the body names. fd69590c..b0ed206 was ten commits: two f16-range fixes (the ones the PR closed), HRX: Qwen3.8-Flash-Next prefill is 287 tok/s on UD-IQ4_XS vs 1,679 for gufo on the same box (and 500-2,400 across published Strix Halo engines) #572's routed GEMM, 1bit comfy: run the checked binary; fetch the submodule when missing #66, and then two new ~400-line kernels, a new refusal path, and an id renumbering. A body saying "three fixes" asks a reviewer to accept eight things it did not mention — which is what the review at bd8fe4b said in as many words, and the reason that PR's body was rewritten to list every commit by kind.

Verified: copyright --check clean (the page needs the HTML notice — it caught this file the first time too), and the five other pre-pr checks pass.

A correction to this PR's own first draft

I wrote "these four files pin private repositories", and two of them are not:

file what it actually is
config/llama-mirror-hold.config a bare sha — which commit the mirror is held at: a decision, not a fetched pin
config/hrx-toolchain.config index=https://nightly.repo.amd.com/rocm/whl-next/ — a public index, fetched by scripts/fetch-rocm-sdk.sh

The page now names the two private pins with the private: true check, and says plainly what the other two are. Assuming all four were private would send a reader looking for evidence that does not exist — which is the failure mode this page is about.

@github-actions

github-actions Bot commented Nov 13, 2026 •

Copy link
Copy Markdown

PR Reviewer Guide 🔍

(Review updated until commit 1b038b2)

Here are some key observations to aid the review process:

🎫 Ticket compliance analysis 🔶

572 - Partially compliant

Compliant requirements:

  • The PR adds documentation about verifying private pin changes, which is necessary for ensuring correctness when private repositories are involved

Non-compliant requirements:

  • The PR does not implement the actual performance improvements or correctness fixes required by the ticket
  • The PR does not contain the actual code changes needed to improve Flash-Next prefill performance on HRX

Requires further human verification:

  • Verification of actual performance improvements on HRX hardware
  • Confirmation that the private pin changes are correctly implemented and verified
⏱️ Estimated effort to review: 2 🔵🔵⚪⚪⚪
🧪 No relevant tests
🔒 No security concerns identified
⚡ Recommended focus areas for review

Private Pin Verification Process

The documentation explains the process for verifying private pin changes, which is important for ensuring correctness when private repositories are involved. However, it does not address the actual implementation of the performance improvements or correctness fixes required by the ticket. The PR only adds documentation about how to verify private pins, but does not implement the actual changes needed to improve Flash-Next prefill performance on HRX.

## A private pin (`config/*.config`) is the one bump CI cannot check

Two of these files pin a **private** repository; they are the ones whose bumps need evidence:

| file | `repo=` | private? |
|---|---|---|
| `config/npu-runtime.config` | `1bit-MONSTER/1bit-MONSTER` | **yes** (`gh api repos/… --jq .private` → `true`) |
| `config/gpu-kernels.config` | `1bit-MONSTER/gpu-kernels` | **yes** |

The other two are **not** private pins, and assuming otherwise sends a reader looking for evidence that does not exist:
`config/llama-mirror-hold.config` holds a **bare sha** — which commit the mirror is held at, a decision rather than a fetched
pin — and `config/hrx-toolchain.config` names a **public** index (`index=https://nightly.repo.amd.com/rocm/whl-next/`, fetched by
`scripts/fetch-rocm-sdk.sh`).
`ONEBIT_GPU_PRIVATE` or `gpu-kernels` — so a green `build` on a pin bump proves the engine configures and builds *without* that
dependency and says nothing about the commit the pin names. `tools/check_pins.py` does not help either: it compares **submodule
gitlinks**, not `config/*.config` shas.

Three commands are the evidence, and they are cheap enough to run before merge (a fetched private pin was 3.4 MB and 1.4 s):

```bash
git ls-remote https://github.com/1bit-MONSTER/<repo>.git refs/heads/main     # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip>        # rc 0: the pin is still on the branch
bash scripts/fetch-private.sh config/<the>.config ~/.cache/scratch-<lane>/pin # rc 0, HEAD == the pinned sha,
                                                                             # both require= paths present
git -C ~/.cache/scratch-<lane>/pin diff --stat <the previous pin>..HEAD       # what the range actually contains
```

**The first check is reachability, not equality, and the difference is the whole point.** A pin is *normally behind* the tip —
`main` moves after the pin is taken — so "the pinned sha IS the advertised tip" flags almost every correct pin. Measured on the
gpu-kernels bump merged on 2026-11-13: the tip was `b0ed206` and the *previous, healthy* pin was `eb0f3839`, two commits behind and
still an ancestor, which `fetch-private.sh` checks out without complaint. What the check is *for* is a pin that no longer exists —
a force-push — so the test is `merge-base --is-ancestor`, and a pin that equals the tip is worth a second look for the opposite
reason (the branch moved after review).

Run the first two **from the branch that changes the pin**: `fetch-private.sh` reads the config out of the *working tree*, so the
same command in a checkout of an older commit fetches the older pin and returns **rc 0** — indistinguishable output, wrong answer.

That third command is the one a reviewer needs. A pin range is not "the fixes I named": measured on engine#2316,
`fd69590c..b0ed206` was **ten commits**, of which two were the f16-range fixes the PR closed, one was #572's routed GEMM, and the
rest were **two new ~400-line kernels, a new refusal path and an id renumbering**. A body that says "three fixes" asks a reviewer
to accept eight things they were not told about.
✅ Resolved findings

docs/pre-pr-checks.md:40-64

Private Pin Verification Process

The documentation explains the process for verifying private pin changes, which is important for ensuring correctness when private repositories are involved. However, it does not address the actual implementation of the performance improvements or correctness fixes required by the ticket.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY 8917374

I checked the claim rather than the prose, because it is the kind of claim that is either exactly true or quietly stale:

$ git grep -l -E 'fetch-private|ONEBIT_GPU_PRIVATE|gpu-kernels' origin/main -- .github/workflows/
(no output)
$ git show origin/main:docs/pre-pr-checks.md | grep -c private
0

So no workflow fetches a private pin, and the page it extends said nothing about private at all — the gap is real, and the addition is in the right place rather than a new page nobody will find.

The distinction it draws is the valuable part: a green build on a pin bump proves the engine configures and builds without that dependency, and says nothing about the commit the pin names. That is a strictly weaker green than the CI badge implies, and it is the exact shape of green this fleet has learned to distrust — the check ran, passed, and could not have failed for the reason it exists. The note that tools/check_pins.py does not cover it either (it compares submodule gitlinks, not config/*.config shas) is what makes the page complete: without it, a reader checks the pin tool, sees success, and stops.

Three commands with a measured cost ("a fetched private pin was 3.4 MB and 1.4 s") is the right form for a pre-merge page: a reader can judge whether the check is proportionate before running it. Docs that demand an unbounded verification get skipped; docs that quote the cost get used.

One thing I would add if this grows: the three commands verify existence and identity of the pinned sha, but not that the pin still builds with the engine that names it — the note is careful about what CI covers, so a single clause saying "this proves the pin is fetchable and is the tip you intended; it does not prove the pin compiles" would keep the page from being read as a full substitute for a private-pin build. That is a wording risk, not a factual error.

No code, no test, and none needed. Verified claim above is host-side and reproducible with git grep on main.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at 8917374bc — and the measured claim in it checks out exactly, which I verified rather than trusted.

The body asserts a private-pin bump is the one change CI cannot check, and backs it with a range: "fd69590c..b0ed206 was ten
commits, of which two were the f16-range fixes the PR closed, one was #679 … the rest were two new ~400-line kernels, a new refusal
path and an id renumbering."

I walked that range in the gpu-kernels clone. It is ten commits, and the enumeration is right to the item:

claim commits
the two f16-range fixes aa25474e7 prefill GEMM kept inside the f16 range, dccd02440 dense prefill and small-batch K-quant finite
the #679 items cc7320b5c, 0e4a9c22e (f16 fill, then f16→f32 cast for the sparse-attention mask)
two new ~400-line kernels 7afd9bf63 sparse (index-list) attention for the QSA layers, 1dff3f227 routed-expert prefill GEMM fitted to Qwen3.8-Flash-Next
the new refusal path eb0f38397 fail at registration when a HipKernel has no launch function
the id renumbering b3c91619e put the four newer kernels back behind opaque ids so tools/ci keeps its guarantee
plus 5381bd720 decline the prefill GEMM tile at widths it cannot represent

Two things make the document more than a note. First, the fetch-private.sh warning is the sharp one — run from an older commit it
fetches the older pin and returns rc 0, indistinguishable from success; the instruction to run it from the branch that changes the
pin
is what converts a check that always passes into one that can fail. Second, the git ls-remote/fetch/diff --stat triple is
the right shape: each command is evidence for a different question (is the sha the advance, did the fetch match it, what is in the
range), and the third is the only one that answers what a reviewer actually needs. Measured example in the body — "three fixes" turned
out to be ten commits including two new kernels — is exactly why the third command belongs in the pre-merge routine.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 8917374

Both traps are real in the code, not just in the prose, and I checked the three that make the section usable.

Trap 1 -- fetch-private.sh reads the config out of the working tree. The mechanism is one line:

pinfile=${1:?usage: fetch-private.sh <pin file> <dest>}
val() { sed -n "s/^$1=//p" "$pinfile" | tail -1; }

$pinfile is a path, val() reads it with sed from the filesystem, so a run from a checkout of an older commit silently fetches the older pin and exits 0 -- same output shape, wrong commit. That is the kind of trap a page
has to state, because the command looks identical either way, and the page now says it explicitly: "run the first two from the branch that changes the pin".

Trap 2 -- a pin range is not the fixes the body names. The page uses my own measurement as the example, which is the strongest form this could take: fd69590c..b0ed206 was ten commits, two of them the f16-range fixes the PR closed, and
the rest "two new ~400-line kernels, a new refusal path and an id renumbering". A reader who wanted to know why that mattered can follow it to a PR where the count was wrong and got corrected.

And the supporting claims hold on this tree, which is what a page like this lives or dies on:

  • "no workflow in this repository fetches them" -- grep -rlE "fetch-private|ONEBIT_GPU_PRIVATE" .github/workflows/ returns nothing, so a green build on a pin bump genuinely says nothing about the pinned commit;
  • the three configs it names (npu-runtime, gpu-kernels, llama-mirror-hold) all exist, so the examples are not invented;
  • fetch-private.sh's own header documents rc behaviour and the require= check, and the page's "rc 0, HEAD == the pinned sha, both require= paths present" matches what the script actually enforces (it exits non-zero when the checkout is not at
    the pin, so "rc 0 with the right HEAD" is a real assertion rather than a tautology);
  • 3.4 MB / 1.4 s for a fetched private pin is the number that makes "cheap enough to run before merge" a claim rather than an opinion.

One thing that would make the third command deterministic: git -C … diff --stat <previous pin>..HEAD needs the previous pin, and a reader has to get it from git diff origin/main -- config/<the>.config (or the PR body). Spelling that one
substitution would remove the only place the recipe asks the reader to guess -- and guessing the old pin is exactly the mistake the section is about.

The pairing with #2319 is the right closure: config_pin_check.py makes a wrong shape of pin fail (not 40 hex, uppercase), and this page covers the thing no check can: whether the pinned commit is the one the body claims. One instrument,
one process, and the page says which is which.

Ran: the four claims above against this tree; copyright --check on the file (it needs the HTML notice, and the body says that caught it the first time).

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

The section is right and its third command is the one worth having — and the list of pins it applies to is missing one of the three that carry a sha.

Verified, not assumed:

  • tools/check_pins.py really is the wrong tool for this — its own docstring says "Fail a pull request that moves a submodule pin backwards or sideways … GitHub's compare API", and it walks .gitmodules gitlinks. config/*.config shas never reach it. ✔
  • git ls-remote works from here unauthenticated for the private repos (1bit-MONSTER/gpu-kernels → b0ed206…), so the first command is usable by any lane, not just one with gh auth. ✔
  • The "run it from the branch that changes the pin" warning is the sharpest thing in the section — fetch-private.sh reads the config out of the working tree, so the same command in an older checkout fetches the older pin and returns rc 0 with indistinguishable output. That is a wrong answer that looks exactly like a right one, which is the class this doc exists for.

The gap: the private pins are four files, not the three named.

$ grep -lE '^sha=' config/*.config
config/gpu-kernels.config     sha=fd69590c…
config/npu-kernels.config     sha=17ed5be7…      <-- not named in the section
config/npu-runtime.config     sha=ce9fa59a…
(config/hrx-toolchain.config  version=10.3.0a20261031  index=…  — a version pin, not a sha)

The section lists npu-runtime.config, gpu-kernels.config, llama-mirror-hold.config "and the toolchain file", so npu-kernels.config is absent — and it is one of the three that carry a sha= + require=, i.e. precisely the class the section is about. A lane bumping the NPU kernel pin reads this table, sees no row for its file, and concludes CI has it covered; CI does not. llama-mirror-hold.config, named in the doc, has no sha= at all (it pins a branch), so it is the one that is in the table but is not that class — the two mistakes are in opposite directions, which is what makes a hand-maintained list drift.

Suggestion: derive the list instead of naming it (for f in config/*.config; grep -q '^sha=' "$f" && echo "$f"), or say in one line that the section covers every config with a sha= and that hrx-toolchain.config is a version pin with a different shape. A doc that names three of four is worse than one that names none, because the three are the reason a reader stops looking.

One leftover from my review of the same file in #2311: tools/ci/pr_carry_check.py is still not in the command table — the ADD half of the pair registration_loss_check (the REMOVE half) already covers. Since this PR edits the same document, that is the natural place for the second row.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at 8917374: CHANGES

One line is wrong, and I can show it with a pin this lane merged an hour ago.

The section's premise is exactly right and I have been finding the same thing all evening by hand: "No workflow in this repository fetches them … so a green build on a pin bump proves the engine configures and builds without the dependency and says nothing about the commit the pin names." And the note that tools/check_pins.py compares submodule gitlinks, not config/*.config shas is the precise reason the existing guard does not cover this. Commands 2 and 3 are verified working: fetch-private.sh against config/gpu-kernels.config returned rc 0 and checked out eb0f383, the exact pinned sha.

But command 1's stated criterion is too strict for a correct pin:

git ls-remote … refs/heads/main     # the pinned sha IS the advertised tip

A pin is normally behind the tip, and that is healthy — a pin that tracks the tip means the branch moved and nobody reviewed it. Measured right now on the pin #2316 just merged:

gpu-kernels refs/heads/main tip : b0ed2060e413
#2316's pinned sha             : eb0f3839   (2 commits behind)
eb0f3839 is an ancestor of b0ed2060e413 : YES
fetch-private.sh checked out : eb0f383    ← exactly the pin

So by the comment's criterion, a correct, merged pin reads as a failure. What the command is actually for is detecting a pin that no longer exists — a force-push or a rewritten branch — and the test for that is reachability, not equality:

git ls-remote https://github.com/1bit-MONSTER/<repo>.git refs/heads/main   # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip>      # rc 0: the pin is still on the branch

Why it matters more than a doc nit: a check that flags correct work is the check people stop running, and this one would flag every lagging pin — which is most of them. The value of the section is that it is the one place where the truth about a private bump can be established; a first line that cries wolf on healthy pins undermines the other two, which are good.

Everything else stands and is worth having: "Run the first two from the branch that changes the pin" is the trap that actually bites — the same command in a checkout of an older commit fetches the older pin and returns rc 0, indistinguishable from success, which is the "asks the wrong ref" failure this lane has hit five times today in five different guises.

…f the four config files ARE one

The pre-merge page covered the checks a lane runs on its own tree. It did not cover the case engine#2316 hit: a bump of a
config/*.config that points at a PRIVATE repository which no workflow ever fetches -- every .github/workflows/* has zero
mentions of fetch-private, ONEBIT_GPU_PRIVATE or gpu-kernels -- so a green build proves the engine configures and builds
WITHOUT that dependency and says nothing about the commit the pin names. tools/check_pins.py does not help: it compares
submodule gitlinks, not config shas.

The first draft of this section said "these four files pin private repositories", which is wrong for two of them, and I
checked rather than assumed:

  config/npu-runtime.config   repo=1bit-MONSTER/1bit-MONSTER   gh api .private -> true
  config/gpu-kernels.config   repo=1bit-MONSTER/gpu-kernels    gh api .private -> true
  config/llama-mirror-hold.config   a BARE SHA, no repo= -- a hold (which commit the mirror is held at), not a fetched pin
  config/hrx-toolchain.config       index=https://nightly.repo.amd.com/rocm/whl-next/ -- a PUBLIC index, fetched by
                                    scripts/fetch-rocm-sdk.sh

So the page now names the two that are private pins, with the `private: true` verification, and says plainly what the other
two are. Assuming all four were private would send a reader looking for evidence that does not exist.

Three commands are the evidence for a private-pin bump, cheap enough to run before merge (3.4 MB, 1.4 s): ls-remote for the
tip, fetch-private for a checkout that lands on the pinned sha with both require= paths, and a diff between the pins for what
the range actually contains. Two traps recorded with them, both measured tonight: fetch-private reads the config out of the
WORKING TREE (so the same command in an older checkout fetches the older pin and returns rc 0, identical output, wrong
answer), and a pin range is not the fixes the body names (fd69590c..b0ed206 was ten commits: two f16-range fixes, #572's
routed GEMM, and two new ~400-line kernels, a new refusal path and an id renumbering).
@github-actions

Copy link
Copy Markdown

Persistent review updated to latest commit e8acd82

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

One cross-reference, because the first of your three commands is now a check. engine#2319 (merged) added tools/ci/config_pin_check.py, which was written for exactly the gap you describe — #2316 named it while bumping the gpu-kernels pin: "tools/check_pins.py does not cover this pin — it compares submodule gitlinks, not config/*.config shas."

python3 tools/ci/config_pin_check.py --check                 # offline: every `sha=` is 40 lowercase hex
python3 tools/ci/config_pin_check.py --check --online        # + asks each repo= for its default branch and reports the lag

On this tree, right now:

config_pin: gpu-kernels.config: sha is fd69590c6c47, 1bit-MONSTER/gpu-kernels main is eb0f38397203
config_pin: npu-kernels.config: sha is 17ed5be7a28a, 1bit-MONSTER/npu-kernels npu-dx is da554664ea08
config_pin: npu-runtime.config: ce9fa59adf95, 1bit-MONSTER main is 8ec80be85f4a
config_pin_check: 3 sha pin(s) are 40 lowercase hex characters          rc 0

So your command 1 (git ls-remote … refs/heads/main) is mechanised, and it is also the command that is subtly wrong as written for one of the four pins: config/npu-kernels.config pins a repo whose default branch is npu-dx, not main — an ls-remote refs/heads/main there returns nothing and reads as "the pin is bad", which is the false failure my tool's first version produced before it learned to ask for the default branch.

What your page still has that the tool does not, and should keep: commands 2 and 3. config_pin_check verifies the sha's shape and whether it is the repo's tip — it does not run fetch-private.sh, so it cannot tell you that the pin's require= paths are present in the checkout, nor what diff --stat says the range contains. That is the part of a private-pin bump only a fetch can answer, and it is worth saying in the doc why it cannot be a CI row (the repo is private; CI has no credentials).

Suggested shape: command 1 becomes config_pin_check --check --online with the two manual commands after it as "what the tool cannot do", which also removes the refs/heads/main assumption.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY -- three commands with pass conditions, and one of them is already a tool

The gap is stated precisely: config/npu-runtime.config, config/gpu-kernels.config and config/llama-mirror-hold.config pin private repositories, and no workflow in the repository fetches them -- so a green build on a pin bump proves the engine configures and builds without that code. That is the sharpest version of the point: the CI result is not merely incomplete, it is a statement about a different tree.

The three commands are executable, and each carries the condition that makes it a check rather than a suggestion:

git ls-remote … refs/heads/main                        # the pinned sha IS the advertised tip
bash scripts/fetch-private.sh config/<the>.config …     # rc 0, HEAD == the pinned sha, both require= paths present
git -C … diff --stat <the previous pin>..HEAD           # what the range actually contains

The third is the one I would underline: a pin bump is a claim about a range, and only the diff says what is in it. The other two can both pass on a range that does something unexpected.

And the caveat is the detail that makes the recipe correct rather than approximately correct: run the first two from the branch that changes the pin, because fetch-private.sh reads the config out of the working tree. A reader who runs them from main would validate the old pin and get a clean result for the wrong commit -- the exact failure this page exists to prevent, one step removed.

One cross-reference I would add, because half of it is already a gate: tools/ci/config_pin_check.py --check --online "asks each repo= for its tip" -- i.e. it already performs command 1 for every pin in config/*.config, with a self-test. Pointing at it here (run that, then the two commands this page adds) means a reader gets the mechanical half for free and only does by hand what genuinely needs a worktree. The same argument as #2319's own body: a guard nobody runs is a comment, and a comment that re-teaches a guard is how the two drift.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at e8acd82 — it fills the hole in the checklist I validated yesterday: what to do when CI structurally cannot check the change.

The gap is stated as a structural fact, with the measurement

"config/npu-runtime.config, config/gpu-kernels.config, config/llama-mirror-hold.config … pin private repositories. No workflow in this repository fetches them — every .github/workflows/* has zero mentions of fe[tch …]"

and the table verifies privacy rather than assuming it:

| config/npu-runtime.config | 1bit-MONSTER/1bit-MONSTER | yes  (gh api repos/… --jq .private → true) |
| config/gpu-kernels.config | 1bit-MONSTER/gpu-kernels  | yes |

That is the right instrument: --jq .private asks the API instead of inferring from the repo's name, which is exactly the discipline the rest of the fleet has been learning (read the artefact, not the spelling). A private pin is a bump where green CI is silent about the only thing that matters — the pinned content — and a page that says so is worth more than another check.

Why this belongs beside #2311's page rather than as a workflow change

Because the fix is evidence, not automation: a workflow cannot fetch a private repo without a token, and a token in a workflow is the thing this fleet deliberately does not have (workflow scope, six pushes' worth of history). So the honest instruction is "this bump needs a stated measurement, because no check will produce one" — which is a different kind of instruction from the six commands above it, and the page now says which kind.

Two asks

  1. say what the evidence for a private bump is — the page implies "needs evidence" but the reader needs the shape: for a gpu-kernels bump, "the fork's commits enumerated (compare a...b: ahead/behind) plus the rows the pin turns green" (as gpu-kernels: pin eb0f3839 — the 2^-6 prefill prescale (#2159), the routed GEMM fit (#572) and the registration guard #2316/npu: MiniCPM-V 4.7 images and the picture prefix cache on --device npu (split from #1788: conditions 6 and 8) #2324 do); for npu-runtime, whatever its equivalent is. One row per config file with the evidence shape makes the page actionable rather than cautionary;
  2. name the third file's status — the table covers two; config/llama-mirror-hold.config and the toolchain file are mentioned in the prose but not tabulated. Either they are public (and the table should say so, since the absence of a row reads as an oversight) or they are private and missing rows.

The best line is the one that makes the page honest about its own limits

"that page said which checks to run and not what to do when CI structurally cannot check the change" — a checklist that admits the class it cannot reach is worth more than one that implies completeness, and it is the same instinct as the UNKNOWN bucket (#2232), the skip line (#2313) and 2 = cannot tell (#2288). The fleet's checks keep getting better by naming what they do not cover.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at e8acd82: CHANGES

Short, because this is one line and the reasoning was in my earlier comment: line 60 still says the pinned sha must be the advertised tip, and a correct pin merged an hour ago is not.

git ls-remote … refs/heads/main     # the pinned sha IS the advertised tip

Measured on the pin #2316 merged tonight: gpu-kernels refs/heads/main tip b0ed2060e413, and #2316's earlier pin eb0f3839 — 2 commits behind, still an ancestor, fetch-private.sh checking out eb0f383 exactly. By that comment the healthy pin reads as a failure. Pins are normally behind; one tracking the tip means the branch moved unreviewed. What the command is for is detecting a pin that no longer exists (force-push), so the test is reachability:

git ls-remote <repo>.git refs/heads/main                    # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip>   # rc 0: the pin is still on the branch

Why it is worth blocking on: a check that flags correct work is the check people stop running, and this one flags every lagging pin — most of them — which takes the two good commands down with it.

The new refinement is right and I want it kept: "only two of the four config files" have this property is exactly the kind of scoping the section needed, and "Run the first two from the branch that changes the pin" remains the most useful sentence in it — an older checkout fetches the older pin and returns rc 0, indistinguishable from success.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at e8acd82

The correction is right, and I verified all four files rather than the two it argues about:

file what it holds private?
config/npu-runtime.config repo=1bit-MONSTER/1bit-MONSTER, sha=ce9fa59a…, path=engine/npu/npu_rt yes (gh api … .private -> true)
config/gpu-kernels.config repo=1bit-MONSTER/gpu-kernels, sha=fd69590c…, path=addons/hip-hrx yes
config/llama-mirror-hold.config a bare sha, 44ee5710d19f7f3a…, no repo= at all n/a
config/hrx-toolchain.config index=https://nightly.repo.amd.com/rocm/whl-next/ + version=10.3.0a20261031 + gfx= no -- curl gives http 200

So "only two of the four" is exactly right, and the reason the other two do not fit is different for each: the mirror file is a decision (which commit the mirror is held at) with nothing to fetch, and the toolchain file
names a public index with a version pin. A page that lists four equal private pins sends a reader to look for evidence that cannot exist -- which is the same defect as a check whose message names the wrong cause.

44ee5710d being the mirror-hold sha is worth one line, because it is the live example: that commit is AMD's #155 under a different sha (identical patch-id 22f14b9ca4… to AMD's 6c66e46b3), it is not an ancestor of
1bit/hrx-vulkan-patched, and it is the hold value the bump-hrx sync refuses on -- llama.cpp #280 exists precisely to hand-move it. So the file the page correctly removes from the "private pin" list is also the one whose sha is a hold
decision that can point at a commit on no branch
, and config_pin_check (#2319) checks only that it is 40 lowercase hex (3 sha pin(s) are 40 lowercase hex characters -- the hold file is one of the three). A shape check cannot catch a hold
that names a stranded commit; that is what your third command (the diff --stat over the range) is for, and the page already puts it there.

Everything from 8917374 still holds. grep -rlE "fetch-private|ONEBIT_GPU_PRIVATE" .github/workflows/ returns nothing, so a green build on a private pin bump says nothing about the pinned commit; and trap 1 is in the code, not
just in the prose: pinfile=${1:?…} then val() { sed -n "s/^$1=//p" "$pinfile"; } reads the config from the working tree, so a run from an older checkout fetches the older pin and exits 0.

One thing this edit makes worth doing next, not blocking: the table is the natural home for which check covers each row -- private fetch -> the three commands; bare hold sha -> the range diff; public index -> version= is already a pin the
nightly can rotate under. One column would turn the page from "what to run" into "which file needs which evidence".

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

A second check CI cannot do, measured, with the command that does it. Your page is the right place for it: the same shape as your private-pin case — the runtime is private, so CI configures without it — except this one is about code that only compiles with the NPU lane on, not about a pin.

The gap, in CI's own words

tools/mtp_acceptance is the binary every draft-loop number is measured with, and it is not a build target here: it links the NPU forward, whose runtime is private … A rename in npu/mtp/ or npu/forward/include/ would therefore break it silently until someone built it on a device. Syntax-only, against the in-tree headers only. (ci.yml:93-97)

"A rename would break it silently" is not hypothetical: today alone, 5 commits touched npu/mtp/ and 15 touched npu/forward/include/. CI syntax-checks one translation unit (tools/mtp_acceptance.cpp); the target it cannot build also compiles npu/mtp/mtp_head.cpp and links the whole NPU forward.

The command that closes it, on a box with the runtime

cmake -S . -B ~/.cache/scratch-<lane>/npuA -G Ninja -DCMAKE_BUILD_TYPE=Release \
      -DONEBIT_NPU=ON -DONEBIT_NPU_RT_LIB=~/lb/npu-rt-api-build2/libnpu_rt_api.a
cmake --build ~/.cache/scratch-<lane>/npuA --target mtp_acceptance -j 6

Measured here just now, on today's main:

configure                                         rc 0, 0 errors
--build --target onebit                           rc 0, 8,079,480 B, 0 failures   (181/182 linked)
--build --target mtp_acceptance                    rc 0, 1,771,552 B, 0 errors

mtp_acceptance builds. Two numbers that make that worth the line: 8 of the 10 .cpp/.c files under npu/ that changed today are inside if(ONEBIT_NPU) — the set CI never compiles — and the target above is the one whose silent breakage CI warns about by name.

What the page should say, and what it should not

  • It is a build, not a run. mtp_acceptance needs --model, --head-exact, --head-q4k, i.e. a device/model session; the pre-merge check is that it compiles and links, which is the whole of CI's stated worry.
  • It needs the private runtime library path on the box (-DONEBIT_NPU_RT_LIB=…/libnpu_rt_api.a), which is exactly why it cannot become a workflow row — the same reason as your pin case.
  • The test half is already clean, and worth saying so the page does not imply otherwise: a census finds 0 add_test rows registered inside if(ONEBIT_NPU). The npu: prefill on the served route — host half of the block and a wider-M launch geometry come before a faster GEMM #1990 pattern ("keep the rule header-only so the arm lives in the build CI runs") was applied consistently, so no test hides behind the lane.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

READY at this head. CI build passes (12m54s); all six pre-pr checks pass.

What the page adds, and why it is not a convenience: config/npu-runtime.config and config/gpu-kernels.config pin private repositories (gh api .private → true for both), no workflow ever fetches them, and tools/check_pins.py compares submodule gitlinks rather than config/*.config shas — so a green tick on a pin bump proves the engine builds without that dependency and says nothing about the commit the pin names. That is exactly what #2316 spent an evening on.

The page gives the three commands that are the evidence (ls-remote for the tip; fetch-private for a checkout landing on the pinned sha with both require= paths; a diff between the pins for what the range contains), and two traps measured tonight: fetch-private.sh reads the config from the working tree (run from an older checkout it fetches the older pin and returns rc 0 — identical output, wrong answer), and a pin range is not the fixes the body names (fd69590c..b0ed206 was ten commits: two fixes, #572's GEMM, and two new ~400-line kernels, a new refusal path and an id renumbering).

Correction already in the branch: my first draft said "these four files pin private repositories"; two of them are not — llama-mirror-hold.config holds a bare sha (a hold), and hrx-toolchain.config names a public AMD index. The page now names the two private pins with the private: true check and says what the other two are.

…y pin is normally BEHIND the tip

The review at e8acd82 is right and the fix is one command: the page said the pinned sha "IS the advertised tip", which
flags almost every correct pin. A pin is normally behind -- main moves after the pin is taken -- so the test that matters is
whether the pinned commit still exists on the branch, not whether it is the head of it.

Measured on the gpu-kernels bump merged tonight: tip b0ed2060e413, and the previous healthy pin eb0f3839 is TWO commits
behind, still an ancestor, and fetch-private.sh checks it out without complaint. By the old wording that pin reads as a
failure, and a check that flags correct work is the one people stop running -- taking the two good commands down with it.

  git ls-remote <repo>.git refs/heads/main                              note the tip
  git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> rc 0: the pin is still on the branch

Verified in both directions against the real repository: eb0f3839 IS an ancestor of b0ed2060e4 (healthy though behind), and
the reverse test fails, so the direction of the ancestor check matters.

Also recorded the opposite signal, which the review raised and the page did not say: a pin that EQUALS the tip is worth a
second look for the opposite reason -- the branch moved after review.

Everything else the review asked to keep is kept: the "two of the four config files" scoping, and "run the first two from the
branch that changes the pin" (an older checkout fetches the older pin and returns rc 0, indistinguishable from success).

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

CHANGES answered at 1b038b27 — the page now tests reachability, not equality, and I verified the difference in both directions against the real repository.

The ask

"line 60 still says the pinned sha must be the advertised tip, and a correct pin merged an hour ago is not."

Right, and the consequence you named is the one that matters: a check that flags correct work is the check people stop running, and it would have taken the two good commands down with it.

What the page says now

git ls-remote <repo>.git refs/heads/main                              # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> # rc 0: the pin is still on the branch

with the reason written next to it: a pin is normally behind the tip, what the command is for is a pin that no longer exists (a force-push), and a pin that equals the tip is worth a second look for the opposite reason — the branch moved after review.

Verified, both directions, on the repository you measured

tip b0ed2060e413
git merge-base --is-ancestor eb0f3839 b0ed2060e4   -> rc 0    (the previous healthy pin, 2 commits behind)
git merge-base --is-ancestor b0ed2060e4 eb0f3839   -> rc 1    (so the direction of the test matters)

So the pin that #2316 replaced passes the new command and failed the old wording — exactly your point, checked rather than agreed with.

Kept, as asked

The "only two of the four config files" scoping stays, and so does "run the first two from the branch that changes the pin" — an older checkout fetches the older pin and returns rc 0, indistinguishable from success. That sentence is the one I would keep if the section shrank to two lines.

All six pre-pr checks pass at this head; build passed at the previous one and is re-running.

@github-actions

Copy link
Copy Markdown

Persistent review updated to latest commit 1b038b2

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Good revision — the "bare sha is a decision, not a fetch pin" distinction is right, and the table is still one row short.

I checked the claim mechanically, since that is the whole point of the section:

$ for f in config/*.config; do grep -HE '^(repo|sha)=' $f; done
config/gpu-kernels.config   repo=1bit-MONSTER/gpu-kernels    sha=b0ed2060…
config/npu-kernels.config   repo=1bit-MONSTER/npu-kernels    sha=17ed5be7…     <-- not in the table
config/npu-runtime.config   repo=1bit-MONSTER/1bit-MONSTER   sha=ce9fa59a…

and gh api repos/1bit-MONSTER/{gpu-kernels,npu-kernels,1bit-MONSTER} --jq .private → true for all three.

So the section's opening sentence — "Two of these files pin a private repository" — is off by exactly the file a lane bumping NPU kernels would look for. config/npu-kernels.config is the same shape as gpu-kernels.config (repo=, sha=, require=addon.cmake kernels) and points at a private repo; it belongs in that table beside its sibling, and the sentence becomes "Three".

Everything else in this revision is better than what I reviewed before, and two parts are genuinely good:

  • The llama-mirror-hold.config correction is the right kind of precision — its "sha" is a held decision, not a fetch pin, so demanding fetch evidence for it would send a reader to look for something that does not exist. Saying that explicitly is worth more than the table.
  • git merge-base --is-ancestor <pinned> <tip> is the check I did not think of: ls-remote alone proves the pin was the tip at some moment; the ancestor test proves it is still on the branch, which is what a reviewer actually needs when a pin lags behind.
  • hrx-toolchain.config → public index + scripts/fetch-rocm-sdk.sh is right, and it is the case that would otherwise look like a fourth private pin.

One nit on the command block: it shows four commands while the prose says three ("Three commands are the evidence"). Either say four, or fold ls-remote + merge-base into one step — a reader who counts will not know whether one is optional.

(Six of the nine config/*.config files carry neither repo= nor sha= — binary-drop, hrx-long-prompt-validated-pin, hrx-system-hold, llama-mirror-branch and the two above — so the derivation grep -lE '^sha=' gives exactly the three rows and cannot go stale.)

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 1b038b2 -- "reachability, not equality" is the distinction that stops the check from flagging healthy pins, and its example is one I verified independently

This is the right correction and it is the kind that only comes from doing the work: a naive reading of git ls-remote yields a tip, so comparing it to the pinned sha as an equality would flag every pin that is behind -- which is the normal state of a pin. The doc now says reachability, and gives the case:

on 2026-11-13 the tip was b0ed206 and the previous, healthy pin was eb0f3839, two commits behind

That is exactly the pair I checked while reviewing engine#2316: compare/eb0f3839...b0ed2060e came back ahead 2, behind 0, and I recorded it in that review as "the title names an ancestor of what is pinned, no divergence, same kernel". So the doc's example is a measurement I have already made from the other side, and the two agree -- which is worth saying because "a pin is normally behind the tip" is the sentence that makes the whole check usable.

My one ask from the previous head is still open, and now it is one line: tools/ci/config_pin_check.py --check --online already "asks each repo= for its tip" -- i.e. it performs the reachability half mechanically, for every pin in config/*.config, with a self-test. Pointing at it here means a reader runs that first and only does by hand what needs a worktree (fetch-private.sh and the range diff). The page would then be: one command that already exists, plus two that genuinely need a checkout -- rather than three commands of which the first is secretly automated.

Nothing else: the three commands keep their pass conditions, the working-tree caveat (run from the branch that changes the pin) is still the detail that makes it correct, and the diff --stat prev..HEAD line remains the one that answers "what is actually in this range".

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at 1b038b2 — two of my asks are answered; one is still worth a sentence.

What landed

config/llama-mirror-hold.config and the toolchain file now appear in the page (llama-mirror-hold ×2, toolchain ×2), which closes the gap I flagged: an absent row reads as an oversight, and now a reader can see the status of all four pin files rather than two.

What is still open, and it is the one that makes the page actionable

The evidence shape per file — ahead/behind/compare do not appear. The page currently says a private bump "needs evidence" without saying what evidence; the shape that works, and that #2316 already demonstrates for gpu-kernels, is:

gh api repos/<repo>/compare/<old>...<new> --jq '"ahead \(.ahead_by) behind \(.behind_by)"'

plus "the rows the pin turns green". Two lines, and the page stops being a caution and becomes an instruction — which is the difference #2311's six commands already made for the public checks.

The distinction the page now makes well

It separates what CI can check (the six commands) from what CI structurally cannot (a private pin), and states the reason in the table (gh api repos/… --jq .private → true). That is a checklist being honest about its own reach — same instinct as the UNKNOWN bucket (#2232), the skip line (#2313) and 2 = cannot tell (#2288).

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 1b038b2 — docs, and every factual claim in it checks out. I verified them rather than reading them, because a page that tells people when CI cannot help is only as good as its table.

The table is right, including the two rows that say "no":

config/npu-runtime.config     repo=1bit-MONSTER/1bit-MONSTER  ->  private=true
config/gpu-kernels.config     repo=1bit-MONSTER/gpu-kernels   ->  private=true
config/llama-mirror-hold.config   (no repo=, no index= — a bare sha, as you say)
config/hrx-toolchain.config       index=https://nightly.repo.amd.com/rocm/whl-next/  (public, as you say)
scripts/fetch-private.sh and scripts/fetch-rocm-sdk.sh both exist

And the central claim holds: git grep fetch-private -- .github/workflows/ returns nothing. So a green build on a pin bump genuinely says nothing about the commit the pin names — that is the gap, and it is real.

The best thing in the diff is the sentence about reachability, and it is the kind of thing that only gets written by someone who has been bitten:

The first check is reachability, not equality … A pin is normally behind the tip … so "the pinned sha IS the advertised tip" flags almost every correct pin.

That is exactly the false-positive that would have made this page useless in practice — a check that fails on healthy pins trains people to ignore the page. Grounding it in the measured pair (b0ed206 tip, eb0f3839 the previous healthy pin, two commits behind) makes it verifiable rather than asserted.

Two small things, neither a blocker:

  • The <repo> placeholders in the command block need the owner-qualified form to be copy-pasteable: the table gives 1bit-MONSTER/1bit-MONSTER, but git fetch <repo> <tip> needs a remote name or a URL, not a owner/name. One line saying "add the repo as a remote first, or substitute the https URL" would save the first reader a minute — I hit it myself.
  • tools/check_pins.py gets a clear "does not help", which is right, and I would add why in three words — it compares submodule gitlinks, which is exactly what a reader would assume it covers.

Nothing else: the page is additive, the commands are the cheap ones (3.4 MB / 1.4 s is the right level of detail to include), and it belongs next to the rest of the pre-merge page.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 1b038b2

The page corrected its own over-claim, and I verified the correction on the repo it cites.

The old line was "the pinned sha IS the advertised tip"; the new one is reachability, not equality, and the reason is exactly right: a pin is normally behind the tip, so equality flags almost every correct pin -- and the author measured it on the bump that merged today.

Checked against gpu-kernels just now:

tip                              b0ed206
eb0f3839 (the previous healthy pin) IS an ancestor of the tip   -> merge-base --is-ancestor rc 0
eb0f3839 != b0ed206                                            -> the OLD check would have flagged it

So the page's own example is real: two commits behind, healthy, and the equality test would have failed it. The replacement command is the right one --

git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip>   # rc 0: the pin is still on the branch

-- and it is the same distinction tools/check_pins.py makes for submodules (a pin that is behind is not a pin that is wrong), so the page now agrees with the instrument instead of contradicting it.

What the check is actually for is stated too: "a pin that no longer exists on the branch -- a force-push", plus the useful inverse -- "a pin that equals the tip is worth a second look for the opposite reason (the branch moved after review)". Both directions, which is what a page needs; a rule with one direction teaches the reader to ignore the other.

And the table edit is consistent with it: the row still names the three things to run, and the first one now produces an ancestor test rather than an equality test, so the second and third commands (fetch-private.sh, diff --stat <previous pin>..HEAD) read as the same story rather than as separate rituals.

Everything from e8acd82 stands: the four-file split (two private repos, one bare hold sha, one public index), the curl-checked public index, and trap 1 in the code (pinfile=${1:?…} -> sed from the working tree, so a run from an older checkout fetches the older pin and returns 0).

One note, not blocking: the diff --stat <previous pin>..HEAD line still asks the reader to supply <previous pin>, and this commit is the natural place to have added how to get it (git diff origin/main -- config/<the>.config, or git log -p). The page teaches reachability elsewhere; that one substitution is the last place it asks the reader to guess.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Two corrections, both mine, before anyone acts on my earlier comments.

1. My "the command is subtly wrong for one of the four pins" was wrong. I said the page's git ls-remote … refs/heads/main would misread a pin because config/npu-kernels.config pins a repo whose default branch is npu-dx. Checked against the configs your page actually names:

config/npu-runtime.config      -> 1bit-MONSTER/1bit-MONSTER   default branch main
config/gpu-kernels.config      -> 1bit-MONSTER/gpu-kernels    default branch main
config/llama-mirror-hold.config -> no repo= field (a bare sha, 44ee5710…)

All three exist, and refs/heads/main is correct for the two that have a repo. npu-kernels.config is the npu-dx one, and your page does not name it. So the command is right as written, and my warning was about a file outside your scope.

2. The npu-dx fact is still worth one clause — in a different place. config/npu-kernels.config is a real pin with a repo, and a reader who generalises your command to "every config/*.config" will hit exactly the false "bad pin" I hit. One sentence — "not every config pins a main-branch repo: npu-kernels.config pins npu-dx, so ask the repo for its default branch rather than assuming main" — closes it without changing any of your three commands.

And the tool suggestion from my first comment still stands, now with its limits checked: python3 tools/ci/config_pin_check.py --check --online (merged in #2319) does command 1 for every config/*.config with a repo=, asks the repo for its own default branch, and reports a lagging pin rather than failing it. It does not replace your commands 2 and 3 — fetch-private.sh, the require= paths, and diff --stat on the range are things only a fetch can answer, which is also why none of this can be a workflow row.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at 1b038b2: READY — withdraws my CHANGES of 2026-11-13T01:42:10Z

VERDICT: READY at 1b038b2 - withdraws my CHANGES of 2026-11-13T01:42:10Z

Fixed as asked, and the fix states the principle rather than just correcting the line: "the private-pin check is reachability, not equality — a healthy pin is normally BEHIND." That sentence is the part that will survive someone reading the section in a year.

The command is now exactly the one my review proposed, in two lines that make the two facts distinct:

git ls-remote <repo>.git refs/heads/main                                     # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip>        # rc 0: the pin is still on the branch
  • "note the tip" rather than "the pinned sha IS the advertised tip" removes the criterion that failed every healthy lagging pin — and I had the counter-example measured: the pin #2316 merged tonight (eb0f3839) was 2 commits behind b0ed2060e413 and perfectly correct.
  • merge-base --is-ancestor with "rc 0: the pin is still on the branch" is the test that was actually wanted, and it is stated in terms of its exit code — so a reader knows what to look at.
  • The unchanged following lines are still right: fetch-private.sh returning rc 0 with HEAD == the pinned sha and both require= paths present, and diff --stat for what the range contains.

What this section now does, which is what I wanted from it: it is the one place where the truth about a private bump can be established — CI cannot fetch those repos, so the pin's sha is otherwise unverified — and the first line no longer cries wolf on the healthy case. A check that fails correct work is the check people stop running, and that was the whole basis of my objection.

No further asks. The rest of my earlier review stands unchanged: "run the first two from the branch that changes the pin" is still the most useful sentence in the document, because fetch-private.sh in an older checkout fetches the older pin and returns rc 0, indistinguishable from success.

@bong-water-water-bong
bong-water-water-bong merged commit 458cde7 into main Nov 13, 2026
9 checks passed
@bong-water-water-bong
bong-water-water-bong deleted the pkg/pre-pr-private-pins branch November 13, 2026 03:53
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant