From 664fae93fd654bbfe8f0657cd9320f0b67970811 Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Fri, 4 Sep 2026 08:09:06 +0000 Subject: [PATCH 1/3] spec(MODEL-TEXT-GLM4-MOE-LITE-GATE-2839): the SACRED GLM-4.7-Flash gate asserts a bar its own oracle capture does not license MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three defects, each measured at `3e246b34f`. The only vs-vLLM assertion reads `neartie_gap_mnats.npy`, which is `min 0 max 0` at all 128 positions, against a 500-mnat band, so it has no failure mode. The gate computes vLLM's own self-determinism, prints DETERMINISTIC, and then applies the distributional band that `CLAUDE.md` §Gates licenses only on a NON-deterministic oracle; under the bar that is licensed the committed ids match 69 of 128 positions and 1 of 8 prompts. And the case returns early when the checkpoint is absent, which doctest reports as a passed case with zero assertions, so on every host without a 31.2B snapshot the SACRED gate reported a pass having measured nothing. The spec also records, without gating on it, why the gap artifact is probably not a measurement at all: at a first divergence our prefix equals the oracle's, so vLLM's teacher-forced argmax there is the golden token by construction and the gap must be positive. It is 0 at all seven first divergences, with none of the script's outside-top-20 sentinels present. FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [claude-code] --- .agents/specs/glm4-moe-lite-gate-2839.md | 126 +++++++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 .agents/specs/glm4-moe-lite-gate-2839.md diff --git a/.agents/specs/glm4-moe-lite-gate-2839.md b/.agents/specs/glm4-moe-lite-gate-2839.md new file mode 100644 index 000000000..57d2fcf1f --- /dev/null +++ b/.agents/specs/glm4-moe-lite-gate-2839.md @@ -0,0 +1,126 @@ +# GLM-4.7-Flash — the only vs-vLLM assertion cannot fail, and the licensed bar is not the one asserted + +**Row:** `MODEL-TEXT-GLM4-MOE-LITE-GATE-2839` — new row, `ACTIVE`. +**Issue:** [#2839](https://github.com/mudler/vllm.cpp/issues/2839). +**Date:** 2026-09-04. **Base:** `3e246b34f`. +**Predecessor row:** `MODEL-TEXT-glm4-moe-lite-glm4-moe-lite-for-causal-lm`. + +## Scope + +`tests/vllm/models/test_glm4_moe_lite_paged_engine.cpp` is the SACRED +correctness gate for `Glm4MoeLiteForCausalLM`. This row makes it assert the bar +`CLAUDE.md` §Gates licenses, and makes the committed artifacts gateable without +the 31.2B checkpoint. + +Out of scope: the forward itself, regenerating any golden (both need a GPU and a +`zai-org/GLM-4.7-Flash` snapshot, and neither is present on this host), and the +`Glm4MoeLiteForCausalLM` speed axis. + +## What is true at `3e246b34f` + +Three defects, all measured rather than argued. + +**D1 — the only vs-vLLM assertion has no failure mode.** The gate reads +`neartie_gap_mnats.npy` and tests `mn > kNearTieMnats` with +`kNearTieMnats = 500`. The committed array is `(8,16) int32`, `min 0 max 0`, all +128 values exactly `0`, so `prompt_ok` is true for all eight prompts +unconditionally and `CHECK_MESSAGE(prompt_ok, ...)` cannot trip. + +**D2 — the licensed bar is STRICT, and nothing asserts it.** The gate computes +vLLM's own self-determinism from `greedy_dist.npy` over K=5 and `CHECK`s that it +is zero, then prints `DETERMINISTIC -> the STRICT bar is well-posed` — and +proceeds to apply the near-tie band anyway. `CLAUDE.md` §Gates permits a +distributional gate "only when the oracle's greedy decode is non-deterministic". +Against the committed `greedy_ids.npy`, `our_ids.npy` matches **69 of 128 +positions (53.9%)** and **1 of 8 prompts exactly**, per-prompt mismatches +`[2, 6, 6, 12, 12, 11, 10, 0]`. + +**D3 — the case is a skip wearing a pass.** With no checkpoint under +`~/.cache/huggingface/hub/`, the body emits `MESSAGE("SKIP ...")` and `return`s. +doctest counts that as a **passed** test case with zero assertions, so on every +host without a 31.2B snapshot — which is every CI runner — the SACRED gate +reports a pass having measured nothing. The same shape hides the second early +`return` (goldens absent) and the third (teacher-forced goldens absent), and both +of those conditions are now impossible: all five artifacts are committed. + +The header's own definition of a near-tie has a second conjunct, "AND our token +is inside vLLM's top-K", which is not implemented anywhere: `greedy_dist.npy` is +read only for the self-determinism count. + +## The artifact is very likely not a measurement, and this row does not gate on that + +At a prompt's FIRST divergent position our prefix is identical to the oracle's, +so vLLM's teacher-forced argmax there IS `greedy_ids[i,j]` by construction and +our token is a different one. The gap +`max(0, arg_lp - our_lp)` must then be strictly positive. It is `0` at all seven +first divergences (prompts 0..6, positions 14, 6, 6, 4, 4, 4, 6). The script also +writes a `99_999_000` sentinel when our token falls outside vLLM's top-20, and +there is not one. So every one of our divergent tokens was inside vLLM's top-20 +AND within 0.0005 nats of its argmax, seven times out of seven at the one +position where the prefixes provably agree. + +This is recorded as a finding, not gated. A gate that asserts "the gap at a first +divergence is positive" could in principle be defeated by genuine sub-millinat +ties, and the STRICT bar below settles the same question without that risk. + +## Design + +**A — the skip becomes a skip.** The checkpoint predicate moves into +`doctest::skip(...)`, so an absent snapshot is reported as `skipped` rather than +`passed`. The two golden-absence `return`s become `REQUIRE`s, because those +artifacts are committed and their absence is a defect rather than an +environment. The `VT_GLM_DUMP_IDS` bootstrap arm stays, because it is an explicit +opt-in that writes an artifact rather than a silent pass. + +**B — the bar follows the measurement that selects it.** `greedy_dist.npy` +becomes REQUIRED, and its verdict decides the bar in code rather than in a +`MESSAGE`. Zero multi-valued cells means STRICT: every token must equal the +oracle's. A non-zero count is the only thing that admits the near-tie band, and +that arm now implements BOTH conjuncts the file's own header states — within +`kNearTieMnats`, AND our token inside vLLM's top-K from `greedy_dist.npy`. + +**C — the committed artifacts become gateable with no checkpoint.** A new case +reads only `tests/parity/goldens/glm4_moe_lite_greedy/`, re-derives the +self-determinism verdict, and applies the licensed bar to `our_ids.npy`, which +the engine case already REQUIREs the live engine to reproduce token for token +(`:283-287`). It needs no 31.2B snapshot and no GPU, so it runs everywhere the +suite runs. + +## Tests and expected verdicts + +- **T1** (checkpoint-free) the committed `greedy_dist.npy` has zero multi-valued + cells. Expected GREEN — this is what licenses STRICT. +- **T2** (checkpoint-free) under STRICT, `our_ids.npy` equals `greedy_ids.npy` at + every position. **Expected RED at 69/128.** This is the row's result: the gate + fails because it finally measures something. +- **T3** (checkpoint-gated) the engine case applies the same bar. Not runnable + here; no `zai-org/GLM-4.7-Flash` snapshot exists on this host and none is on + the NAS. + +## Gates + +```sh +cmake --build build -j 3 --target test_glm4_moe_lite_paged_engine +./build/tests/test_glm4_moe_lite_paged_engine +scripts/agent-preflight.sh +``` + +## Stop conditions + +Stop and report `NEEDS_DECISION` before weakening T2. The two admissible exits +are a forward repair that makes 128/128 true, or a re-capture of +`neartie_gap_mnats.npy` on the checkpoint plus an explicit ratification argument +for a distributional bar over a deterministic oracle. Neither is available to a +host with no GPU and no snapshot, and neither is this row's work. + +## Owed + +- O1. T2 is RED as landed, and it must stay red until one of the two exits + above. It is the honest state of `Glm4MoeLiteForCausalLM` and it is why + `docs/FEATURES.md` already carries `the shipped 8/8 is not a measurement`. +- O2. The engine case (T3) is unrun. It compiles here; nothing on this host can + execute it. Owed to whoever next holds a GPU and the snapshot. +- O3. `docs/USAGE.md` carries no checkpoint row for `Glm4MoeLiteForCausalLM` — + no revision and no sha256 — which `CLAUDE.md` §"Say which weights, and from + where" requires. Not repaired here because the values must be read off the + artifact this host does not have. From f3f8f71d8dec1a6c3dbe56f866e570a83768edea Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Fri, 4 Sep 2026 08:09:22 +0000 Subject: [PATCH 2/3] test(MODEL-TEXT-GLM4-MOE-LITE-GATE-2839): apply the bar the oracle capture licenses, and gate the committed artifacts with no checkpoint THIS CHANGE MAKES A GATE FAIL. That is the result, not a regression. Do not soften the new case; the two admissible exits are named in the spec. Three repairs. The checkpoint predicate moves into `doctest::skip`, so an absent snapshot is reported as skipped instead of as a passed case with zero assertions, and the two golden-absence early returns become REQUIREs because those artifacts are committed. `greedy_dist.npy` becomes required, and its verdict now selects the bar in code rather than in a MESSAGE: zero multi-valued cells means STRICT token-exact, and only a non-zero count admits the near-tie band, which now also applies the second conjunct this file's own header states and nothing implemented -- our token inside vLLM's top-K. The third repair is what makes any of it observable. Everything the SACRED case compares is committed: the oracle's ids, the oracle's K-run distribution, and this engine's own ids, which the SACRED case already REQUIREs the live engine to reproduce token for token before comparing anything. So a new case applies the licensed bar to those artifacts with no 31.2B checkpoint and no GPU, and runs wherever the suite runs. Before, on this host: 1 test case, 1 PASSED, 0 failed, 0 skipped, and 0 assertions. After: 1 skipped, 1 failed, 10 assertions with 2 failed -- `positions 69/128, prompts exact 1/8, per-prompt mismatch [2,6,6,12,12,11,10,0]`, and `committed teacher-forced gap max = 0 mnats against a 500 mnat band`. Two artifact mutations, both restored and verified by sha256. Replacing `our_ids.npy` with `greedy_ids.npy` turns the case green at 10 of 10, so the failure is data-driven rather than an unconditional assertion. Perturbing one cell of `greedy_dist.npy` makes the bar-selection REQUIRE fire and abort before the comparison, so the bar really is chosen by the oracle's own capture. The engine case itself is UNRUN: no `zai-org/GLM-4.7-Flash` snapshot exists on this host and none is on the NAS. It compiles; nothing here can execute it. Closes #2839. FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [claude-code] --- .../test_glm4_moe_lite_paged_engine.cpp | 217 ++++++++++++++---- 1 file changed, 170 insertions(+), 47 deletions(-) diff --git a/tests/vllm/models/test_glm4_moe_lite_paged_engine.cpp b/tests/vllm/models/test_glm4_moe_lite_paged_engine.cpp index 13cf02ecc..32994e91e 100644 --- a/tests/vllm/models/test_glm4_moe_lite_paged_engine.cpp +++ b/tests/vllm/models/test_glm4_moe_lite_paged_engine.cpp @@ -37,6 +37,7 @@ // body emits a loud SKIP and returns. #include +#include #include #include #include @@ -118,49 +119,152 @@ std::vector LoadI32File(const fs::path& p) { return out; } +// #2839 — the bar SELECTION, derived from the oracle's own capture rather than +// asserted in prose. `greedy_dist.npy` is [N,T,K]: K independent batch=1 greedy +// runs of the pinned vLLM. A (prompt,position) cell holding more than one id is +// a cell vLLM cannot reproduce against itself. Zero such cells means the oracle's +// greedy decode is DETERMINISTIC, and `CLAUDE.md` §Gates then licenses exactly +// one bar: STRICT token-exact. A distributional bar is licensed "only when the +// oracle's greedy decode is non-deterministic", so on this capture it is not. +int64_t OracleMultiValuedCells(const parity::NpyArray& d) { + REQUIRE(d.shape.size() == 3); + const int64_t DN = d.shape[0], DT = d.shape[1], DK = d.shape[2]; + const auto* dd = AsI32(d); + int64_t multi = 0; + for (int64_t i = 0; i < DN; ++i) + for (int64_t j = 0; j < DT; ++j) { + std::set s; + for (int64_t k = 0; k < DK; ++k) s.insert(dd[(i * DT + j) * DK + k]); + if (s.size() > 1) ++multi; + } + return multi; +} + +// Is `tid` among the K ids the oracle's own runs produced at (i,j)? This is the +// SECOND conjunct of the near-tie definition in this file's header, which was +// stated there and implemented nowhere: `greedy_dist.npy` was read only for the +// self-determinism count. It is only ever consulted on the non-deterministic +// arm, because the deterministic arm has no near-tie band to qualify. +bool InsideOracleTopK(const parity::NpyArray& d, int64_t i, int64_t j, int32_t tid) { + const int64_t DT = d.shape[1], DK = d.shape[2]; + const auto* dd = AsI32(d); + for (int64_t k = 0; k < DK; ++k) + if (dd[(i * DT + j) * DK + k] == tid) return true; + return false; +} + } // namespace -// GLM-4.7-Flash (`Glm4MoeLiteForCausalLM`) — the GLM/DSA G1 SACRED gate. -TEST_CASE("glm4-moe-lite paged-engine greedy token-exact gate (dgx-only, SACRED)") { - const std::string snap = FindGlm47Snapshot(); - if (snap.empty()) { - MESSAGE( - "SKIP (dgx-only): GLM-4.7-Flash checkpoint absent — " - "zai-org/GLM-4.7-Flash snapshot not present under " - "~/.cache/huggingface/hub/"); - return; - } +// #2839 — THE COMMITTED ARTIFACTS, GATED WITH NO CHECKPOINT. +// +// The SACRED case below needs a 31.2B snapshot, so on every host without one it +// measured nothing while reporting a pass. Everything it compares, however, is +// committed: the oracle's ids, the oracle's K-run distribution, and this +// engine's own ids, which the SACRED case REQUIREs the live engine to reproduce +// token for token before it compares anything. So the comparison itself needs no +// checkpoint and runs wherever the suite runs. +// +// THIS CASE IS EXPECTED TO FAIL, and that is the point. Do not soften it. The +// two admissible exits are a forward repair that makes it 128/128, or a +// re-capture of the teacher-forced artifact plus an explicit ratification of a +// distributional bar over a deterministic oracle. Weakening the assertion is +// neither. See `.agents/specs/glm4-moe-lite-gate-2839.md`. +TEST_CASE("glm4-moe-lite committed goldens: the oracle is deterministic, so the bar is STRICT") { const fs::path gdir = fs::path(PARITY_GOLDENS_DIR) / "glm4_moe_lite_greedy"; - if (!fs::exists(gdir / "greedy_ids.npy")) { - MESSAGE("SKIP: GLM-4.7-Flash greedy golden absent — capture on dgx: " - "scripts/glm4-moe-lite-oracle-capture.py --runs 5"); - return; - } + REQUIRE_MESSAGE(fs::exists(gdir / "greedy_dist.npy"), + "glm4-moe-lite: greedy_dist.npy is committed and selects the " + "bar; without it no bar is licensed at all"); + const parity::NpyArray d = parity::LoadNpy((gdir / "greedy_dist.npy").string()); + const int64_t multi_cells = OracleMultiValuedCells(d); + MESSAGE("glm4-moe-lite: vLLM self-determinism over K=" << d.shape[2] + << " batch=1 runs — multi-valued (prompt,pos) cells = " << multi_cells); + REQUIRE_MESSAGE(multi_cells == 0, + "glm4-moe-lite: the oracle is NOT self-deterministic on this " + "capture; re-derive the bar, do not loosen it"); + + const parity::NpyArray g = parity::LoadNpy((gdir / "greedy_ids.npy").string()); + const parity::NpyArray o = parity::LoadNpy((gdir / "our_ids.npy").string()); + REQUIRE(g.dtype == " s; - for (int64_t k = 0; k < DK; ++k) s.insert(dd[(i * DT + j) * DK + k]); - if (s.size() > 1) ++multi_cells; + // The near-tie band this file has been applying instead. It is reported so the + // failure below is not mistaken for a regression: the band never rejected + // anything, because the artifact it reads is identically zero. + const parity::NpyArray gap = + parity::LoadNpy((gdir / "neartie_gap_mnats.npy").string()); + REQUIRE(gap.shape == g.shape); + const int32_t* gpd = AsI32(gap); + int32_t gap_max = 0; + for (int64_t k = 0; k < N * T; ++k) gap_max = std::max(gap_max, gpd[k]); + MESSAGE("glm4-moe-lite: committed teacher-forced gap max = " << gap_max + << " mnats against a " << kNearTieMnats + << " mnat band, so `gap > band` has no failure mode on this artifact"); + + int64_t exact_positions = 0; + int64_t exact_prompts = 0; + std::string per_prompt; + for (int64_t i = 0; i < N; ++i) { + int64_t bad = 0; + for (int64_t j = 0; j < T; ++j) { + if (od[i * T + j] == gd[i * T + j]) { + ++exact_positions; + } else { + ++bad; } - const std::string verdict = - multi_cells == 0 - ? std::string(" (DETERMINISTIC -> the STRICT bar is well-posed)") - : std::string(" (NON-DET: RE-DERIVE the bar via teacher-forcing, do " - "not loosen it)"); - MESSAGE("glm4-moe-lite: vLLM self-determinism over K=" << DK - << " runs (batch=1 capture) — multi-valued (prompt,pos) cells = " - << multi_cells << verdict); - CHECK(multi_cells == 0); + } + if (bad == 0) ++exact_prompts; + per_prompt += (i == 0 ? "" : ",") + std::to_string(bad); } + MESSAGE("glm4-moe-lite STRICT vs vLLM 0.25.0: positions " << exact_positions + << "/" << (N * T) << ", prompts exact " << exact_prompts << "/" << N + << ", per-prompt mismatch [" << per_prompt << "]"); + CHECK_MESSAGE(exact_positions == N * T, + "glm4-moe-lite FAILS the STRICT bar its own oracle capture " + "licenses: " << exact_positions << " of " << (N * T) + << " positions match. Repair the forward or re-derive the bar " + "with a ratification; do not widen this assertion."); + CHECK_MESSAGE(exact_prompts == N, + "glm4-moe-lite: " << exact_prompts << " of " << N + << " prompts are token-exact against the pinned oracle"); +} + +// GLM-4.7-Flash (`Glm4MoeLiteForCausalLM`) — the GLM/DSA G1 SACRED gate. +// +// #2839: the checkpoint predicate is a doctest::skip rather than an early +// `return`. An early return makes doctest report a PASSED case with zero +// assertions, so on every host without a 31.2B snapshot this gate reported a +// pass having measured nothing. +TEST_CASE("glm4-moe-lite paged-engine greedy token-exact gate (dgx-only, SACRED)" * + doctest::skip(FindGlm47Snapshot().empty())) { + const std::string snap = FindGlm47Snapshot(); + REQUIRE(!snap.empty()); + const fs::path gdir = fs::path(PARITY_GOLDENS_DIR) / "glm4_moe_lite_greedy"; + // The goldens are COMMITTED. Their absence is a broken checkout, not an + // environment, so it is a hard failure and no longer an early return. + REQUIRE_MESSAGE(fs::exists(gdir / "greedy_ids.npy"), + "glm4-moe-lite: committed greedy golden missing — re-capture " + "on dgx: scripts/glm4-moe-lite-oracle-capture.py --runs 5"); + + // ---- GATE SELECTION: the oracle's own self-determinism picks the bar ------ + REQUIRE_MESSAGE(fs::exists(gdir / "greedy_dist.npy"), + "glm4-moe-lite: greedy_dist.npy is what SELECTS the bar; " + "without it neither STRICT nor the near-tie band is licensed"); + const parity::NpyArray dist = + parity::LoadNpy((gdir / "greedy_dist.npy").string()); + const int64_t multi_cells = OracleMultiValuedCells(dist); + const bool oracle_deterministic = multi_cells == 0; + MESSAGE("glm4-moe-lite: vLLM self-determinism over K=" << dist.shape[2] + << " runs (batch=1 capture) — multi-valued (prompt,pos) cells = " + << multi_cells + << (oracle_deterministic + ? " (DETERMINISTIC -> STRICT token-exact is the bar, and it is " + "the bar this case applies)" + : " (NON-DET -> the near-tie band applies, both conjuncts)")); const parity::NpyArray g = parity::LoadNpy((gdir / "greedy_ids.npy").string()); REQUIRE(g.dtype == "(i); worst_j = static_cast(j); } - if (mn > kNearTieMnats) { + // #2839 — THE BAR. `oracle_deterministic` is measured above from the + // oracle's own K-run capture, and `CLAUDE.md` §Gates licenses the + // distributional band ONLY on a non-deterministic oracle. On this capture + // the oracle reproduces itself exactly, so a divergence is a divergence. + // + // What stood here was the band alone, read off `neartie_gap_mnats.npy`, + // which is identically zero at all 128 positions — so `mn > 500` was false + // everywhere and `prompt_ok` could not become false. The near-tie arm also + // now applies BOTH conjuncts this file's own header states: within the + // band AND our token inside vLLM's top-K. + const bool position_ok = + oracle_deterministic + ? got[static_cast(j)] == gd[i * T + j] + : (mn <= kNearTieMnats && + InsideOracleTopK(dist, i, j, got[static_cast(j)])); + if (!position_ok) { prompt_ok = false; if (first_bad < 0) first_bad = static_cast(j); } @@ -320,8 +439,10 @@ TEST_CASE("glm4-moe-lite paged-engine greedy token-exact gate (dgx-only, SACRED) MESSAGE("glm4-moe-lite FORWARD DIVERGENCE prompt[" << i << "] tok=" << first_bad << " our=" << got[static_cast(first_bad)] << " vLLM_greedy=" << gd[i * T + first_bad] - << " gap=" << (gapd[i * T + first_bad] / 1000.0) << " nats (> " - << (kNearTieMnats / 1000.0) << ") \"" << out.outputs[0].text << "\""); + << " bar=" << (oracle_deterministic ? "STRICT" : "near-tie") + << " committed gap=" << (gapd[i * T + first_bad] / 1000.0) + << " nats (band " << (kNearTieMnats / 1000.0) << ") \"" + << out.outputs[0].text << "\""); } else if (exact) { ++strict_exact; } else { @@ -339,7 +460,9 @@ TEST_CASE("glm4-moe-lite paged-engine greedy token-exact gate (dgx-only, SACRED) } const vllm::MlaBatchSplitStats serial_stats = vllm::GetMlaBatchSplitStats(); - MESSAGE("glm4-moe-lite correctness gate: " << (strict_exact + neartie_only) << "/" + MESSAGE("glm4-moe-lite correctness gate (bar=" + << (oracle_deterministic ? "STRICT" : "near-tie") + << "): " << (strict_exact + neartie_only) << "/" << N << " prompts PASS (STRICT token-exact " << strict_exact << "/" << N << "; near-tie-band only " << neartie_only << "/" << N << "; tokens strictly exact " << exact_tokens << "/" << total_tokens From dadd918f3f2543ccc3dd0cbc2886b8a58f8105e2 Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Fri, 4 Sep 2026 21:29:58 +0000 Subject: [PATCH 3/3] spec(MODEL-TEXT-GLM4-MOE-LITE-GATE-2839): own the repository-wide zero-assertion skip that hid this defect This row's D3 is one instance of a shape that occurs at 228 sites in 72 files: `MESSAGE(...SKIP...); return;` inside a TEST_CASE, which doctest counts as a passed case with zero assertions. Measured at `3f12c617d`, `test_deepseek_v2_paged_engine` -- the SACRED DeepSeek-V2 gate -- reports `1 passed | 0 failed`, `assertions: 0`, `Status: SUCCESS!` on a host with no checkpoints. Repairing 228 sites is a campaign rather than an in-flow fix, so it is filed as #2918 and listed here under `## Owed` O4, which is the ownership `CLAUDE.md` requires for an issue a change references without closing. FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [claude-code] --- .agents/specs/glm4-moe-lite-gate-2839.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.agents/specs/glm4-moe-lite-gate-2839.md b/.agents/specs/glm4-moe-lite-gate-2839.md index 57d2fcf1f..1a189a487 100644 --- a/.agents/specs/glm4-moe-lite-gate-2839.md +++ b/.agents/specs/glm4-moe-lite-gate-2839.md @@ -120,6 +120,13 @@ host with no GPU and no snapshot, and neither is this row's work. `docs/FEATURES.md` already carries `the shipped 8/8 is not a measurement`. - O2. The engine case (T3) is unrun. It compiles here; nothing on this host can execute it. Owed to whoever next holds a GPU and the snapshot. +- O4. The zero-assertion skip is a REPOSITORY-WIDE shape, not this file's. + `MESSAGE(...SKIP...); return;` occurs at 228 sites in 72 files under `tests/`, + and `test_deepseek_v2_paged_engine` — the SACRED DeepSeek-V2 gate — reports + `1 passed | 0 failed`, `assertions: 0`, `Status: SUCCESS!` on this host at + `3f12c617d`. Repairing 228 sites is a campaign, so it is filed as + [#2918](https://github.com/mudler/vllm.cpp/issues/2918) and owned here rather + than fixed in this flow. This row repairs the one instance it touches. - O3. `docs/USAGE.md` carries no checkpoint row for `Glm4MoeLiteForCausalLM` — no revision and no sha256 — which `CLAUDE.md` §"Say which weights, and from where" requires. Not repaired here because the values must be read off the