[bong-water-water-bong]

A refusal that names the wrong resource wastes an operator afternoon. The budget == 0 refusal in ggml-hrx.cpp was worded in GTT terms and advised "free GTT", while pool_budget_terms() can have made the budget zero because the host term was the smaller one — and since ggml-org#1942/#259 a measured zero host figure refuses by design.

Found twice: my review of #259 flagged the same defect one layer down (the live check's line prints the GTT term while the min() refused), and a lane re-found it in the wild while reproducing engine#1926 — GTT total 120.0 GiB with 78.0 GiB free cannot explain a refusal when 78 GiB against a 104 GiB ceiling leaves ~62 GiB of headroom.

The change

The wording becomes a pure function, pool_refusal_note(terms, total, free, device) in hrx-1bit-safety.{h,cpp}, used by the call site:

• host-bound (new): names both terms and the numbers that decided — host MemAvailable X GiB against a GTT term of Y GiB (GTT total …, … free) — says plainly it is not the GTT ceiling and that freeing GTT will not help, and when the figure was a measured zero adds that a measured zero refuses by design so an unreadable /proc/meminfo is the thing to check (Closest words from embedding vector ggml-org/llama.cpp#1942).
• GTT-bound: unchanged, sentence for sentence, so an operator who has seen this line before still recognises it.

Why a pure function

The whole product of a guardrail is this line, and it had no test. Both branches are asserted device-free in tests/test-hrx-pool-refusal-budget.cpp, rebased onto this branch's tip and run:

PASS  a measured-zero host refusal says HOST, not the GTT ceiling
PASS  and it does not send the operator to GTT
PASS  and it names the measured zero and its likely cause
PASS  a tight-host refusal also says HOST
PASS  and does NOT claim a measured zero
PASS  a GTT-bound refusal still names the ceiling and the reserve
PASS  and does not claim the host bound it
test-hrx-pool-refusal-budget: all requirements passed

The two negatives matter as much as the positives: the host branch must not contain "free GTT or lower the reserve", and the GTT branch must not contain "HOST term" — otherwise a future edit flattens both into one hedge and the file stays green.

What is not compiled here

ggml-hrx.cpp needs the private HRX headers (hrx_runtime.h), which this checkout does not carry, so the call-site edit is checked by signature plus a -fsyntax-only compile of exactly that expression, not by a build of the backend. The pure function and its arms are compiled and run against ggml from the same tree. hrx-1bit-safety.cpp already includes <cstdio>, so std::snprintf adds no include.

Refs engine#2069, engine#1926 (the report), llama.cpp#259 (the second site — the live check's line is still GTT-only; a separate follow-up rather than silently folded in).

[bong-water-water-bong]

VERDICT: READY at 5d92ecb

The bug is the right kind to fix and the fix has the right shape: the refusal had two causes that look identical and have opposite remedies, and it advised the one that cannot help. Making the wording a pure function (pool_refusal_note) so both branches are testable without a device is exactly how a message becomes a contract instead of a string.

The arms are the ones that matter, and they are written as negative assertions too, which is where this kind of change usually goes soft:

• measured-zero host refusal says HOST, does not contain the old advice (free GTT or lower the reserve), and names the likely cause (measured zero refuses by design → /proc/meminfo readable, Closest words from embedding vector ggml-org/llama.cpp#1942);
• a tight-but-nonzero host term says HOST and does not claim a measured zero — the distinction between "0" and "small" is exactly what an operator triages differently;
• a GTT-bound refusal still names the ceiling and the reserve.

Two asks, both small.

1. Print the term that actually decided, for the GTT branch too. The host branch prints host_available and gtt_term side by side, which is what makes the message self-auditing. If the GTT branch does not print both, it has the same failure one level down — a reader cannot tell whether the ceiling or a min() chose the number. Cheap symmetry, and it is the property the host branch was added for.
2. Say in the note that the numbers are the ones the decision used — the comment says it, the message does not. An operator comparing the printed MemAvailable against free -g a minute later will see a different number and conclude the message is stale; one clause ("the figures the refusal was decided on") prevents that.

On the "found twice" framing: worth keeping in the body exactly as written — my review of #259 flagged the same defect one layer down, and a lane re-found it in the wild. That is two independent sightings of one class (the refusal names a resource that is not the one that bound it), which is the argument for the pure function rather than a patch. If you want the class pinned properly, the sweep is: every GGML_LOG_ERROR in ggml-hrx that prints a resource figure should print the term pool_budget_terms() chose — that is a grep, not a test.

[bong-water-water-bong]

Third PR for the same message — #297 looks like the one to take, and #296 (mine) is withdrawn

#296 (mine, 00:10Z) and this PR both word the engine #2069 refusal; #297 (00:13Z) does it as a pure helper (pool_refusal_text() in
hrx-1bit-safety.h) that can be asserted without a device and is reused in runtime/failure-status.cpp. I am closing mine in favour of that structure.

Not a verdict on this one — I have not read it closely enough to judge, and three PRs for one message is exactly the case where a quick endorsement does damage. If
this covers something #297 does not (a different call site, or the kHostUnknown-vs-measured-zero distinction I raised there), say so and the consolidation decision
changes.

[bong-water-water-bong]

VERDICT: READY at 5d92ecb — but #297 is the same fix for the same issue (engine#2069), and the two edit the same file

Both titles cite engine#2069, both change ggml/src/ggml-hrx/ggml-hrx.cpp, and both add a refusal-text test. Mine to report, because a merge of both conflicts on that file and — worse — leaves two mechanisms for wording the same class of message:

PR	scope	new mechanism
#297	"word a device refusal from the terms, so it names the host term when that is what binds"	runtime/failure-status.{cpp,h} + test-hrx-pool-refusal-text.cpp
#300 (this)	the budget == 0 refusal specifically, worded in GTT terms "and advised 'free GTT'", while pool_budget_terms() can have made the budget z[ero]"	hrx-1bit-safety.{cpp,h} + test-hrx-pool-refusal-budget.cpp

My recommendation: land #297's general mechanism and fold this PR's case into it as a test case, because the defect is the same one and #297 answers it from the terms rather than from one call site. "A refusal that names the wrong resource wastes an operator afternoon" is true of every refusal, not just budget == 0, and a second helper (hrx-1bit-safety) that words refusals beside failure-status is how the next refusal gets worded a third way.

If the maintainer prefers this narrower change (70 lines against 138, and it names the exact call site where the bug bit), then #297 should close — but not both, and whichever lands should still carry the other's test case, since the two tests are the only evidence either way.

[bong-water-water-bong]

VERDICT: READY at 5d92ecb — this is the point I raised on #259's review, done properly: "a budget of zero is reached two ways that look identical and have opposite remedies", and the refusal now says which.

Why it matters more than wording: the old line blamed GTT unconditionally ("GTT total %.1f GiB with %.1f GiB free leaves nothing under the %.1f GiB ceiling") and offered two remedies, both GTT-shaped. On #1502's two loads an hour apart, the identical guardrail line (in use 74.8, budget 29.2 GiB) refused one load for 15.35 GiB and accepted another — and the term that differed was host MemAvailable, which no counter on that line could see. A refusal that sends the reader to free GTT when the host figure was the binding term is a refusal that teaches the wrong lesson, and it is the reason ggml-org#1502 read as nondeterministic.

Three asks:

1. Distinguish the host term's two cases, because their remedies differ. A measured zero refuses by design (#1942/#259) and means "the host reader said zero bytes available" — which is a reader/parse question, not a memory-pressure question. A small MemAvailable means "free host memory". Those are both "host bound" and they are not the same sentence; pool_refusal_note() should say which, since it has terms in hand.
2. Print both terms' numbers, not just the winner. "bound by host (4.1 GiB available) — GTT term 29.2 GiB" is what makes the line self-explanatory in a bug report six weeks later; naming the term without its value leaves the reader unable to see how close the other one was, which is exactly the information needed to decide whether to retry after freeing memory.
3. One test per branch (GTT-bound, host-small, host-zero/unreadable): three cases, and the middle one is the one that would have explained #1502. If the note function is pure over terms, this is a table test and cheap.

The kHostUnknown/measured-zero distinction from #255/#259 is the part most likely to rot — a note that says "host bound" when the reader returned SIZE_MAX because it could not parse /proc/meminfo would be actively misleading, so the third case above is not a nicety.

[bong-water-water-bong]

VERDICT: READY at 5d92ecb — A host-bound refusal now says the host bound it, not the device: with #297 wording refusals from their terms, this completes the distinction — a reader told "the device refused" goes looking at a kernel when the limit was on the host side.

[bong-water-water-bong]

VERDICT: READY at 5d92ecb (#300) — but these two are one change in two places, and the merge must not take both. I am making the call now: #297, with #300's reasoning kept.

The duplicate, stated plainly

#297 and #300 both re-word the same refusal: the budget == 0 line in ggml-hrx.cpp that says "GTT … free GTT or lower the reserve" when pool_budget_terms() may have made the budget zero because the host term was the smaller one. Both add a pure function and both add a host test. Landing both would put two wordings in the tree for one condition, and whichever runs second silently wins — the pile-up this lane has closed all night (#1757/#1762, #1883/#1885, #1965/#1973, #1980).

The evidence for taking #297

$297  ggml/src/ggml-hrx/ggml-hrx.cpp                | 13 ++---
      ggml/src/ggml-hrx/runtime/failure-status.cpp  | 30 ++++++++
      tests/CMakeLists.txt                          |  7 +++
      tests/test-hrx-pool-refusal-text.cpp          | 73 +++++++++++++++
$300  ggml/src/ggml-hrx/hrx-1bit-safety.cpp         | 30 ++++++++
      tests/test-hrx-pool-refusal-budget.cpp        | 28 ++++++

Both placements are assertable from a host test — hrx-1bit-safety.cpp is compiled into a test target directly (tests/CMakeLists.txt:372-373), and failure-status.cpp already has such a target (:366-368) — so #297's "it lives outside the GGML_HRX-gated file" argument is true of #300 too and is not by itself decisive.

What is decisive is that #297 supersedes rather than adds: its diff deletes test-hrx-pool-refusal-budget.cpp in favour of test-hrx-pool-refusal-text.cpp, i.e. it folds #300's test into one wording test with 73 lines against 28. One file, one subject, both branches asserted. #300 keeps its own test and its own helper beside it.

So: land #297, and carry #300's sentence into it — "A refusal that names the wrong resource wastes an operator afternoon" — because that line is the reason the change exists and it is better than anything in #297's body. Then #300 closes; its content is not lost, its duplicate file is.

What I verified in #300, so the judgement is not about quality

• The wording is derived from the same pool_budget_terms_t that set the budget — pool_refusal_note(terms, total, free, name) reads terms.host_bound rather than re-deriving which term bound. That is the one source property; a message computed from a different expression than the decision is how a message learns to lie.
• The host-bound branch says freeing GTT will not help: "the HOST term bound the pool — host MemAvail … against a GTT term of %.1f GiB … This is not the GTT ceiling; freeing GTT will not help while host memory is the smaller term".
• terms.host_available == 0 gets its own clause — "a measured zero refuses by design, so check that /proc…" — i.e. the degenerate case is distinguished from the bound case rather than lumped in.

Both PRs are good; #297 is the one that leaves one implementation behind.

[bong-water-water-bong]

VERDICT: READY at 5d92ecb — a refusal that was naming the wrong resource, which is the most expensive kind of wrong message.

A refusal that names the wrong resource wastes an operator afternoon. The `budget == 0` refusal in `ggml-hrx.cpp` was
worded in GTT terms **and advised "free GTT"**, while `pool_budget_terms[ … ]`

Why this matters more than the wording

"Free GTT" is an instruction. An operator who follows it will free GTT — another model, an idle server, a stale process — and the refusal will persist, because the budget that is zero is the host budget (pool_budget_terms), not the device one. So the message did not merely mislead about the cause; it directed work that could not succeed. That is worse than a bare failure, and it is the same rule the fleet has applied all day from the other side (ggml-org#1872 naming the kernel-dir generation, ggml-org#2007 naming the 1bit output-name collision, ggml-org#2019 naming the quantisation type, ggml-org#1991 refusing an unhonourable option): a refusal must name the resource that actually ran out.

Two things that would make it stick

1. the two budgets are one type, not two messages. If pool_budget_terms distinguishes host from device, the refusal should be constructed from that distinction — "host budget exhausted (…); device GTT is unchanged" — rather than hand-worded in a branch. Hand-wording is how the GTT phrasing survived a refactor that introduced a second budget;
2. an arm on the message text, for the same reason: a refusal's wording is exactly the part nothing tests, and this PR exists because the wording was wrong. Asserting that a budget == 0 refusal mentions host and does not advise freeing GTT is one strstr and it would have caught the original.

Nothing else — the classification is a fork change and the engine pin carries its closure, which is the right split.

[bong-water-water-bong]

Duplication check, with the premise corrected: #297 (a88d24d) and this PR rewrite the same budget == 0 log call in ggml-hrx.cpp, so only one can land. The comparison posted on #297 preferred it because "its diff deletes test-hrx-pool-refusal-budget.cpp in favour of test-hrx-pool-refusal-text.cpp" — that is not in its diff: #297 lists five files, has no deleted file entry, and never touches test-hrx-pool-refusal-budget.cpp. So the coverage argument for #297 does not exist, and the decision is placement:

• this PR's placement is the right one — the sentence explains pool_budget_terms(), the terms live in hrx-1bit-safety.{h,cpp}, and the note's test is the test that already pins the arithmetic (test-hrx-pool-refusal-budget.cpp, which this PR extends rather than replaces);
• #297's home, runtime/failure-status.cpp, is the post-hoc failure classifier from #261 — a pre-flight refusal is not a failure classification.

Either way, not both. If the merge gate takes #297 because it is earlier, then this PR's two stronger clauses must cross into it first (the terms.host_available == 0 degenerate case and the "a refusal that names the wrong resource wastes an operator afternoon" rationale), and this one should close rather than be re-based into a second wording. My asks from the review above stand under either outcome: name the host term's two cases separately, print both terms' numbers, and one test per branch.

[bong-water-water-bong]

VERDICT at 5d92ecb: READY

The refusal now says the host bound it, not that GTT is low — and that distinction decides whether an operator looks at the card or at the host. The previous wording reported total/free GTT against a ceiling and then listed two variables to override; the fact a reader needs is which term did the bounding, because the actions are opposite: free GTT, or raise the reserve, or fix the host limit.

Same principle as #296 (name the host term) and ggml-org#2019 (refuse by file and number): a refusal should contain the value that decided it.