diff --git a/.agents/NOW.md b/.agents/NOW.md index 809223e9b..8780a3850 100644 --- a/.agents/NOW.md +++ b/.agents/NOW.md @@ -39,8 +39,8 @@ bf16/legacy/pipeline-gemv, `ds4-hc-expand-fuse`. Unchanged: token-exact (or the ratified distributional gate) against the pinned vLLM oracle, AND ≥ vLLM on every throughput axis / ≤ on latency and memory, on -both gate models, reproduced 2–3x on an idle box. See [gates.md](gates.md) and -[benchmark-protocol.md](benchmark-protocol.md). Parity pin: vLLM `555967922` +both gate models, reproduced 2–3x on an idle box. See the +[verification procedure](verification.md). Parity pin: vLLM `555967922` (0.26.0.dev0). @@ -63,7 +63,7 @@ both gate models, reproduced 2–3x on an idle box. See [gates.md](gates.md) and `parity-ledger.md` LINE anchors (re-anchor by ROW ID). **Operator/helper protocol** -([spec](specs/operator-helper-protocol.md)): roles DECLARED then MATERIALIZED +([spec](workflow.md)): roles DECLARED then MATERIALIZED into a lock or worktree+PR; operator merges PRs first and does features only via sub-agents; helpers use worktrees on `row/` and open a DRAFT PR at the START, which IS the claim. **W0-W5 LANDED**; role discipline ENFORCING, diff --git a/.agents/backend-matrix.md b/.agents/backend-matrix.md index ab80c0420..d44970fb2 100644 --- a/.agents/backend-matrix.md +++ b/.agents/backend-matrix.md @@ -11,7 +11,7 @@ Upstream references are pinned to vLLM `555967922` (0.26.0.dev0 + transformers Build availability is not runtime support. A target remains `INVENTORIED` until it has a native build, ported tests, hardware execution, and a trace showing the intended dispatch. Performance claims additionally require same-workload runs -under [benchmark-protocol.md](benchmark-protocol.md). +under [verification.md](verification.md). **How an architecture is added (the additive contract, `BACKEND-CUDA-ARCH-ADDITIVITY`).** Since [arch-additivity](specs/cuda-arch-additivity.md) landed, arch support is @@ -241,7 +241,7 @@ memory. Floating competitor versions do not count. | ID | Item | Upstream/reference | Our code | Tests/evidence | Spike/spec | State | Owner | |---|---|---|---|---|---|---|---| -| `BACKEND-GATE-CUDA-VLLM` | CUDA correctness and every-axis parity vs vLLM v0.25.0 | current pin `e24d1b24`; oracle `702f481`; async default `vllm/config/vllm.py:952-1043`; depth-2 engine path `vllm/v1/engine/core.py:519-607`; async output `vllm/v1/worker/gpu/async_utils.py:12-70`; [benchmark protocol](benchmark-protocol.md) | Existing schema-v5 validator/summary remain. The production [packed component driver](../scripts/dgx-gdn-packed-component.sh#L1) and fail-closed [component finalizer](../tools/bench/gdn_packed_component.py#L1) enforce exact corpus/build/oracle provenance, exact and bounded raw-metric validation, duration consistency, exact commands, pairwise stability, one-lock correctness, thermal/memory health, symlink-safe sealing and marker-last provenance | [Component/summary tests](../tests/tools/test_gdn_packed_component.py#L1) pass and the [2026-07-15 new-binding ledger row](parity-ledger.md) records the sealed evidence. **NEW BINDING `9ecd9d0`: 114/124** (full production default set = async + Triton GDN cubin + bit-identical fast RMSNorm + bit-identical fast gated-RMSNorm; supersedes `246a23c`'s 49/124, `3f256ab`'s 55/124, all retained immutable in the ledger). Mem **4/4**, c1 **20/20**, c2 **20/20**, c16 19/20, c4 & c32 18/20, c8 15/20. The bit-identical (0-ulp) fast decode-kernel stack (`348d12d`+`9ecd9d0`) closed **+62 axes** — confirming the decode deficit was norm/quant/act kernel glue. Ratified as "effective parity" via two-grid totality (114+111→115/124; 110 pass-in-both + 5 coin-flip), NOT a clean 124/124. Remaining gate: 10 axes (35B every-axis closure c1/c2 low-conc residual). 35B performance blocked until 27B reaches a clean 124/124. (2026-07-31 audit `CLAIM-ROADMAP-V1-AUDIT`: this row previously lagged the roadmap by two bindings; now synced) | [CUDA inventory](specs/cuda-architecture-inventory.md); [online gate](specs/cuda-online-serving-gate.md); [packed decode](specs/gdn-packed-decode.md); [W3-I](specs/nvfp4-fused-silu-producer.md) | `PARTIAL` | - | +| `BACKEND-GATE-CUDA-VLLM` | CUDA correctness and every-axis parity vs vLLM v0.25.0 | current pin `e24d1b24`; oracle `702f481`; async default `vllm/config/vllm.py:952-1043`; depth-2 engine path `vllm/v1/engine/core.py:519-607`; async output `vllm/v1/worker/gpu/async_utils.py:12-70`; [benchmark protocol](verification.md) | Existing schema-v5 validator/summary remain. The production [packed component driver](../scripts/dgx-gdn-packed-component.sh#L1) and fail-closed [component finalizer](../tools/bench/gdn_packed_component.py#L1) enforce exact corpus/build/oracle provenance, exact and bounded raw-metric validation, duration consistency, exact commands, pairwise stability, one-lock correctness, thermal/memory health, symlink-safe sealing and marker-last provenance | [Component/summary tests](../tests/tools/test_gdn_packed_component.py#L1) pass and the [2026-07-15 new-binding ledger row](parity-ledger.md) records the sealed evidence. **NEW BINDING `9ecd9d0`: 114/124** (full production default set = async + Triton GDN cubin + bit-identical fast RMSNorm + bit-identical fast gated-RMSNorm; supersedes `246a23c`'s 49/124, `3f256ab`'s 55/124, all retained immutable in the ledger). Mem **4/4**, c1 **20/20**, c2 **20/20**, c16 19/20, c4 & c32 18/20, c8 15/20. The bit-identical (0-ulp) fast decode-kernel stack (`348d12d`+`9ecd9d0`) closed **+62 axes** — confirming the decode deficit was norm/quant/act kernel glue. Ratified as "effective parity" via two-grid totality (114+111→115/124; 110 pass-in-both + 5 coin-flip), NOT a clean 124/124. Remaining gate: 10 axes (35B every-axis closure c1/c2 low-conc residual). 35B performance blocked until 27B reaches a clean 124/124. (2026-07-31 audit `CLAIM-ROADMAP-V1-AUDIT`: this row previously lagged the roadmap by two bindings; now synced) | [CUDA inventory](specs/cuda-architecture-inventory.md); [online gate](specs/cuda-online-serving-gate.md); [packed decode](specs/gdn-packed-decode.md); [W3-I](specs/nvfp4-fused-silu-producer.md) | `PARTIAL` | - | | `BACKEND-BENCH-CUDA-SGLANG-PREFLIGHT` | SGLang corpus, harness, image and exact-checkpoint/token-ID preflights; P1 CPU harness is implemented/gated while P2 image/model/GPU classification remains | [SGLang v0.5.13](https://github.com/sgl-project/sglang/releases/tag/v0.5.13), commit `28b095c`; digest-pinned CUDA 13 image | [corpus](../tools/bench/make_serve_low_corpus.py#L143); [client/preflights](../tools/bench/run_serve_low.py#L124); [summary](../tools/bench/summarize_serve_low.py#L238); [memory](../tools/bench/sample_process_memory.py#L198); [driver](../scripts/dgx-sglang-low-concurrency.sh#L1) | [16 CPU contract cases](../tests/tools/test_serve_low_client.py#L103); [CTest registration](../tests/CMakeLists.txt#L12); dry-run manifest green; no image/model/GPU evidence or performance result | [SGLang low-concurrency spike](specs/cuda-sglang-low-concurrency.md) | `GATING` | - | | `BACKEND-GATE-CUDA-SGLANG` | Binding CUDA low-concurrency serving vs SGLang | same pinned SGLang/checkpoints as `BACKEND-BENCH-CUDA-SGLANG-PREFLIGHT` | [bench main:1](../examples/bench/main.cpp#L1), [server main:1](../examples/server/main.cpp#L1) | no binding run; HTTP TTFT/ITL cannot be measured honestly yet | [SGLang low-concurrency spike](specs/cuda-sglang-low-concurrency.md) | `BLOCKED` on `SERVE-ASYNC-LLM` and successful exact-equivalence preflight | - | | `BACKEND-GATE-CUDA-SGLANG-PREFIX` | Binding deterministic shared-prefix cache-on serving vs the faster equivalent vLLM/SGLang floor, separate from cache-neutral serving | SGLang v0.5.15 `f63458b`; digest `d0a667e`; [DGX recipe correction/results](https://github.com/Weschera/qwen-sglang-dgx-spark/tree/03253ef98c01de59a21c85b9a5cc6a27a871c383); vLLM v0.25.0 explicit Qwen hybrid `mamba_cache_mode=align` | current prefix hashes/managers [kv_cache_utils.cpp:259](../src/vllm/v1/core/kv_cache_utils.cpp#L259), [kv_cache_manager.cpp:124](../src/vllm/v1/core/kv_cache_manager.cpp#L124); no local GDN/Mamba aligned-state retention or binding long-prefix harness yet | Source/config audit rejects the original cache-asymmetric 10--40x claim and treats the reported residual 25--45% SGLang lead as unproven: cache-on vLLM is 0.23.1, KV dtypes/memory differ, MTP is enabled, only 35B is measured, and full axes/hits/memory/traces/repetitions are absent. PX1/PX2 implementation, exact 27B equivalence/hit proof and all performance evidence remain pending | [SGLang shared-prefix extension](specs/cuda-sglang-low-concurrency.md#shared-prefix-extension-2026-07-12) | `READY` for PX1 harness/counter work; PX2 begins with the `KV-MAMBA-ALIGN` leaf spike, and binding execution also needs exact v0.5.15 equivalence plus `SERVE-ASYNC-LLM` | - | diff --git a/.agents/backends.md b/.agents/backends.md index 953242b92..2bff50157 100644 --- a/.agents/backends.md +++ b/.agents/backends.md @@ -107,12 +107,12 @@ upstream platform PR ports mechanically. ## Non-negotiables -- The NVIDIA gate (see [gates.md](gates.md)) is not delayed by portability +- The NVIDIA gate (see [verification.md](verification.md)) is not delayed by portability work: M0.2 bakes the interface requirements above (cheap now, unpayable later); backend implementations are post-MVP. - A new backend lands like any port: parity harness (same golden dumps — they are backend-independent), behavioral suites unchanged, benchmark - honesty per [benchmark-protocol.md](benchmark-protocol.md). `DONE` additionally + honesty per [verification.md](verification.md). `DONE` additionally requires match-or-beat against the applicable native floor: llama.cpp for CPU/GGUF and Vulkan, oMLX/MLX-LM for Apple MLX, production vLLM for its native platforms, plus the SGLang low-concurrency CUDA sweep. The canonical status diff --git a/.agents/benchmark-record.md b/.agents/benchmark-record.md index 7f5b9b04b..f9021f2d1 100644 --- a/.agents/benchmark-record.md +++ b/.agents/benchmark-record.md @@ -10688,7 +10688,7 @@ scripts/dgx-online-serving.sh --execute --model 27 \ performance or broader roadmap execution. The complete contract is in the -[benchmark protocol](benchmark-protocol.md) and +[benchmark protocol](verification.md) and [online serving gate spec](specs/cuda-online-serving-gate.md). **Breadth sweep note (2026-07-21):** the active phase is model-architecture breadth (recent-first), each held to token-exact + vLLM-speed on every axis. Ranked queue + CUDA-arch additivity audit: [.agents/specs/breadth-sweep-plan.md](specs/breadth-sweep-plan.md). CUDA archs beyond same-family sm_120 are HW-blocked (only GB10 testable). @@ -15124,7 +15124,6 @@ llama.cpp's Vulkan" when it is really "our CPU tier vs llama.cpp's Vulkan". The comparison becomes meaningful when native coverage closes — the progress metric is `vt::GetReferenceTierHits()` reaching 0, and the ops that matter for this model are the RoPE table build, the sampler tail, and the remaining norm/glue set. ->>>>>>> 814230a0 (bench(vulkan): VK-E unblocked with identical weights; ours quoted as NO RATIO) #### CORRECTION (2026-08-07, same session): the vllm.cpp Vulkan arm is GPU-BOUND, not CPU-bound diff --git a/.agents/ai-coding-assistants.md b/.agents/completed/ai-coding-assistants-legacy.md similarity index 96% rename from .agents/ai-coding-assistants.md rename to .agents/completed/ai-coding-assistants-legacy.md index 7dea8a44a..d00e17d85 100644 --- a/.agents/ai-coding-assistants.md +++ b/.agents/completed/ai-coding-assistants-legacy.md @@ -38,7 +38,7 @@ an unreviewed change. If you cannot explain and defend a line, do not submit it. Every commit MUST carry the trailer `FOLLOWING_AGENTS_PROTOCOL`. This is a deliberate speed-bump: it asserts the contributor has **read -[AGENTS.md](../AGENTS.md)** and follows this project's protocol (mirror vLLM, +[AGENTS.md](../../AGENTS.md)** and follows this project's protocol (mirror vLLM, ground every check in vLLM source, compare vs the vLLM oracle on the identical workload, keep the parity ledger updated, etc.). CI (`commit-protocol-tag` in `.github/workflows/ci.yml`) rejects any commit lacking it, so a contributor who diff --git a/.agents/benchmark-protocol.md b/.agents/completed/benchmark-protocol-legacy.md similarity index 94% rename from .agents/benchmark-protocol.md rename to .agents/completed/benchmark-protocol-legacy.md index f62ad3d19..4d76e9540 100644 --- a/.agents/benchmark-protocol.md +++ b/.agents/completed/benchmark-protocol-legacy.md @@ -27,7 +27,7 @@ it becomes binding once the spike proves the workload/features are equivalent. output lengths, sampling, cache/prefix state, concurrency and serving features. If conversion is necessary, record it and do not turn the converted result into a binding floor until correctness/quality equivalence is established. Full -matrix: [specs/competitive-benchmarks.md](specs/competitive-benchmarks.md). +matrix: [specs/competitive-benchmarks.md](../specs/competitive-benchmarks.md). **Cache policy is part of the workload, never an incidental default.** CUDA serving has at least two independent gates: a cache-neutral/cache-off workload @@ -87,8 +87,8 @@ measured separately. Missing hardware leaves the row in `GATING` with an exact handoff recipe; it never converts an unmeasured milestone into `DONE`. Every feature/iteration checkpoint also updates the public -[`README.md`](../README.md) stage and -[`docs/BENCHMARKS.md`](../docs/BENCHMARKS.md) disposition **in the same +[`README.md`](../../README.md) stage and +[`docs/BENCHMARKS.md`](../../docs/BENCHMARKS.md) disposition **in the same change**. This includes an attempted benchmark that fails closed: record it as `FAILED` or `VOID`, name why no ratio is binding, and retain the exact next reproduction command. A CPU-only/non-performance feature records @@ -110,10 +110,10 @@ checkpoint. serving, include the low-concurrency sweep when latency/scheduling could change. For new backends, the area spike fixes representative models that fit the hardware without pretending a small-model gate proves 27B/35B scale. -5. **Record every axis + every ratio** in [parity-ledger.md](parity-ledger.md), +5. **Record every axis + every ratio** in [parity-ledger.md](../parity-ledger.md), then refresh the concise accepted/pending/failed/void summary in - [`docs/BENCHMARKS.md`](../docs/BENCHMARKS.md) and the current stage in - [`README.md`](../README.md). A ledger row that leaves ANY axis below an + [`docs/BENCHMARKS.md`](../../docs/BENCHMARKS.md) and the current stage in + [`README.md`](../../README.md). A ledger row that leaves ANY axis below an applicable floor is an open gap. ## Reproduction is a GATE @@ -162,7 +162,7 @@ rumor; a reproducible run is evidence. server files may instead be evicted with `POSIX_FADV_DONTNEED` only when a retained report hashes that inventory and `mincore(2)` proves **zero resident pages** afterward; an unverified/best-effort advisory call does not qualify. - See [specs/competitive-benchmarks.md](specs/competitive-benchmarks.md) + See [specs/competitive-benchmarks.md](../specs/competitive-benchmarks.md) § "Folded: spark-bench". If a result cannot be reproduced on demand under these rules, it does not count @@ -181,5 +181,5 @@ toward the gate. every axis, both models**. Post-MVP backend rows additionally remain open while below their applicable native floor. -See also: [gates.md](gates.md) (the MVP gates), [parity-lever-protocol.md](parity-lever-protocol.md) +See also: [gates.md](mvp-gates-legacy.md) (the MVP gates), [parity-lever-protocol.md](../parity-lever-protocol.md) (how to find the levers to close a below-vLLM axis). diff --git a/.agents/gates.md b/.agents/completed/mvp-gates-legacy.md similarity index 97% rename from .agents/gates.md rename to .agents/completed/mvp-gates-legacy.md index bd0e91621..da5bd4ffc 100644 --- a/.agents/gates.md +++ b/.agents/completed/mvp-gates-legacy.md @@ -11,7 +11,7 @@ 1. **Throughput parity vs vLLM and every equivalent faster floor** on the release-gate environment (`${GATE_HOST}`; currently the DGX Spark GB10 - profile in [environment.md](environment.md)): serve + profile in [environment.md](../environment.md)): serve **Qwen3.6-35B-A3B (NVFP4)** and **Qwen3.6-27B (NVFP4)** with prefill AND decode throughput matching vLLM at large concurrency (request-rate sweeps, measured with our `bench serve` equivalent, same box, same models). @@ -50,7 +50,7 @@ vLLM is the parity oracle for BOTH correctness and performance. Every change that could affect either MUST be compared against vLLM, apples-to-apples, and -BOTH numbers recorded in the [parity ledger](parity-ledger.md): +BOTH numbers recorded in the [parity ledger](../parity-ledger.md): - **Correctness:** op dumps + model logits/greedy vs the pinned pip-vLLM oracle (`${VLLM_ORACLE}`, forward-math-identical to the pin). A new diff --git a/.agents/specs/operator-helper-protocol.md b/.agents/completed/operator-helper-protocol-legacy.md similarity index 100% rename from .agents/specs/operator-helper-protocol.md rename to .agents/completed/operator-helper-protocol-legacy.md diff --git a/.agents/directives.md b/.agents/completed/policy-directives-legacy.md similarity index 97% rename from .agents/directives.md rename to .agents/completed/policy-directives-legacy.md index e15d5c59d..ebfd52b5a 100644 --- a/.agents/directives.md +++ b/.agents/completed/policy-directives-legacy.md @@ -28,7 +28,7 @@ library / C ABI, as the CLI, and as the OpenAI server, with a runnable example each). Every argument, flag, and endpoint documented MUST be grounded in actual source, never invented. -**Keep [`docs/STATUS.md`](../docs/STATUS.md) CURRENT at EVERY feature/iteration +**Keep [`docs/STATUS.md`](../../docs/STATUS.md) CURRENT at EVERY feature/iteration checkpoint. THAT is the per-capability status surface, NOT `README.md`.** In the SAME change that shifts a feature's lifecycle state, update its ONE binding current-state line in the matching `docs/STATUS.md` section or table (typically @@ -60,7 +60,7 @@ user-facing sections exist, that `docs/STATUS.md` exists and carries the capability ledger, and that the README stays inside its length, paragraph, and table-cell budgets; do not weaken the checker to bypass the obligation. -**Keep [`docs/BENCHMARKS.md`](../docs/BENCHMARKS.md) CURRENT at the SAME +**Keep [`docs/BENCHMARKS.md`](../../docs/BENCHMARKS.md) CURRENT at the SAME checkpoint.** Every feature/iteration records its benchmark disposition there in the same change: accepted numbers with exact workload/reference/evidence, or an explicit `PENDING`, `NOT APPLICABLE`, `FAILED`, or `VOID` reason and the @@ -77,7 +77,7 @@ not a style preference: that is exactly how the page reached 11,405 lines and 171 claim-titled sections and stopped being readable by users (converted 2026-08-04). Per-attempt narrative, refuted hypotheses, profiler tables and superseded numbers go to the append-only -[`.agents/benchmark-record.md`](benchmark-record.md) **in the same +[`.agents/benchmark-record.md`](../benchmark-record.md) **in the same change** (move it, never delete evidence). If sections have accumulated anyway, `scripts/roll-benchmark-record.py --apply` moves every non-canonical section into the record verbatim. `scripts/check-public-doc-tables.py` (CI-gated, with @@ -87,7 +87,7 @@ the house no-em-dash rule, and that the page still points at the record; do not weaken the checker to bypass the obligation. When a DENOMINATOR turns out to be wrong, correct every ratio built on it, never keep the flattering one. -**Keep [`docs/FEATURES.md`](../docs/FEATURES.md) CURRENT — same-change +**Keep [`docs/FEATURES.md`](../../docs/FEATURES.md) CURRENT — same-change obligation.** It is the PUBLIC feature surface: what we support, next to vLLM, SGLang and llama.cpp. It is a KEYED TABLE under the same rules as `docs/BENCHMARKS.md` above (one row per feature, updated in place, no appended @@ -130,7 +130,7 @@ target — a new `VLLM_CPP_CUDA_ARCHITECTURES` value or a new configure-time pipeline (`-DVLLM_CPP_TRITON=ON -DVLLM_CPP_TRITON_REGEN=ON -DVLLM_CPP_TRITON_VENDORED_ARCH=sm_XX`; cross-compiled, no target board needed; 57 artifacts + MANIFEST matching the `sm_121a` fileset — see -[.agents/specs/triton-aot-per-arch.md](specs/triton-aot-per-arch.md) and +[.agents/specs/triton-aot-per-arch.md](../specs/triton-aot-per-arch.md) and `cmake/TritonAOT.cmake`), with `scripts/check-triton-aot-drift.sh` rc=0; or (b) if regen is not yet possible on that arch, record the GDN-decode gap HONESTLY in `backend-matrix.md`/`kernel-matrix.md` (that arch runs the hand @@ -252,7 +252,7 @@ norm+quant, MoE, sm_121 "blackwell_sm12x" kernels), **cutlass**, **cuBLASLt** (nvjet), **DeepGEMM**, and **torch/Inductor** (the fused Triton it codegens). Read the actual pinned vLLM code (`${VLLM_SOURCE}` @ pin `555967922`, vLLM 0.26.0.dev0 — advanced 2026-07-26 from the prior `e24d1b24`/0.25.0 pin; see -[.agents/specs/pin-advance.md](specs/pin-advance.md)) AND, as +[.agents/specs/pin-advance.md](../specs/pin-advance.md)) AND, as needed, the installed dependency source (`${DEPENDENCY_SOURCE}`, for example `flashinfer/cute_dsl/*.py` and `flashinfer/gemm/`), cite `file:line` on every side, and mirror what you find. **NEVER declare a lever "build-specific", @@ -386,7 +386,7 @@ child kernels. Verify the export has graph-node kernel rows whenever graph launc occur; a whole-graph-only report is attribution-incomplete and cannot select a lever.** This applies to every subagent and every parity check. Full method: -[.agents/parity-lever-protocol.md](parity-lever-protocol.md) § Verify the +[.agents/parity-lever-protocol.md](../parity-lever-protocol.md) § Verify the whole chain. ## STANDING DIRECTIVE — port the TESTS with the code (upstream tests = the spec) @@ -399,7 +399,7 @@ cases, with the upstream test file cited in the header. Specs test that can't pass yet is checked in SKIPPED with a tracked reason, never dropped. This ground-rules our work against what vLLM actually guarantees and turns the suite into the regression net. Full protocol: -[.agents/test-porting.md](test-porting.md). +[.agents/test-porting.md](test-porting-legacy.md). ## STANDING DIRECTIVE — always compare vs vLLM (the oracle), same workload @@ -408,7 +408,7 @@ apples-to-apples against vLLM and both numbers + the ratio recorded in the ledger: **correctness** vs the pinned pip-vLLM oracle (`${VLLM_ORACLE}`), **performance** vs `vllm bench throughput` on the *identical* workload. Never re-base the bench config without re-running vLLM on it. This is non-negotiable -and applies to subagents. Full rule: [.agents/gates.md](gates.md) +and applies to subagents. Full rule: [.agents/gates.md](mvp-gates-legacy.md) § PROTOCOL DIRECTIVE. **Acceptance rule — match or beat vLLM on EVERY axis, never below.** Benchmark @@ -421,7 +421,7 @@ any axis = an open gap, not a done change; "near parity" is NOT met. seed, build, vLLM oracle cmd), re-run ≥2–3× to confirm within run-noise, use a same-binary A/B, and run only on an idle box (contended runs are void). A number that doesn't reproduce does not count. Full protocol: -[.agents/benchmark-protocol.md](benchmark-protocol.md). +[.agents/benchmark-protocol.md](benchmark-protocol-legacy.md). **Additional competitor floor — equivalent SGLang binds wherever it is faster.** vLLM remains mandatory on every workload, but an exact SGLang arm is @@ -460,7 +460,7 @@ unchanged. Each participating agent reads BOTH the pinned vLLM `file:line` on both sides, and reports what vLLM does DIFFERENTLY that makes it faster. Then verify each diff adversarially (real? on the gate hot path?), rank by gain÷effort, drive the top lever, re-measure vs vLLM, repeat. Full protocol: -[.agents/parity-lever-protocol.md](parity-lever-protocol.md). Caveat: a +[.agents/parity-lever-protocol.md](../parity-lever-protocol.md). Caveat: a real per-op comparison needs a CLEAN slice of OURS (not inferred proportions). A vLLM edge that is an Inductor/DeepGEMM/flashinfer FUSION is NOT a ceiling: only *eager* op-by-op dispatch can't fuse, and our engine is not limited to eager — we @@ -504,7 +504,7 @@ So: same-kernel-different-throughput is a real RED FLAG worth the structural sca declaring a "ceiling" prematurely — but confirm the anomaly PER-SHAPE (never on an aggregate derived metric), and verify the reference's rationale actually applies to YOUR measured situation before you build the fix. Full method: -[.agents/parity-lever-protocol.md](parity-lever-protocol.md) § The STRUCTURAL lens. +[.agents/parity-lever-protocol.md](../parity-lever-protocol.md) § The STRUCTURAL lens. ## Standing directive — ONE SURFACE: every capability ships through the C ABI diff --git a/.agents/discipline.md b/.agents/completed/porting-discipline-legacy.md similarity index 99% rename from .agents/discipline.md rename to .agents/completed/porting-discipline-legacy.md index 1f8e132f1..397d390c6 100644 --- a/.agents/discipline.md +++ b/.agents/completed/porting-discipline-legacy.md @@ -91,4 +91,4 @@ vs logits/greedy-decode, server vs OpenAI conformance. Upstream vLLM (Python) is a test-time oracle only — never a runtime dependency. - **We port Model Runner V2** (`vllm/v1/worker/gpu/`), not the legacy runner — - see [vllm-v1-v2.md](vllm-v1-v2.md). + see [vllm-v1-v2.md](../vllm-v1-v2.md). diff --git a/.agents/completed/pre-cutover-claim-protocol.md b/.agents/completed/pre-cutover-claim-protocol.md new file mode 100644 index 000000000..0d216a4b5 --- /dev/null +++ b/.agents/completed/pre-cutover-claim-protocol.md @@ -0,0 +1,26 @@ +# Pre-cutover claim snapshot protocol + +This is the evidence-preserving archive of the claim-view procedure retired by +the live-claim cutover. Feature lifecycle rows and claim narratives remain in +`.agents/coordination.md`; only this obsolete procedure and its empty generated +snapshot moved. + +## Retired procedure + +The former `scripts/claim-view.py --apply` queried open pull requests and wrote +a generated table into `.agents/coordination.md`. Offline `--check` accepted the +committed table for up to 14 days. An open `row/` PR rendered as a +reservation; merging or closing it removed the row only after another apply. + +The last committed snapshot was generated on 2026-08-04 and contained no rows: + +| Row | PR | State | Agent | Updated | +|---|---|---|---|---| +| _none_ | | | | | + +## Why it was retired + +The timestamp and TTL made remote state look locally authoritative between +refreshes. The replacement separates network-independent `--check-local` from +remote-authoritative `--check-live`; a failed query is `REMOTE_UNVERIFIED` and +cannot be interpreted as an unclaimed task. diff --git a/.agents/completed/roadmap_mvp_v0.md b/.agents/completed/roadmap_mvp_v0.md index 903f15917..95ef65ed2 100644 --- a/.agents/completed/roadmap_mvp_v0.md +++ b/.agents/completed/roadmap_mvp_v0.md @@ -9,7 +9,7 @@ Milestones decompose into **workable units** (one unit ≈ one focused PR an agent can pick up, implement, test, and ledger in a session or few). Order within a milestone is roughly dependency order. Every unit's Definition of Done (DoD) includes: mirrored-structure sources with upstream-commit headers, -tests per [discipline.md](../discipline.md), inventory markers flipped, ledger +tests per [discipline.md](porting-discipline-legacy.md), inventory markers flipped, ledger row appended, state log updated. Status: ☐ open · 🚧 in progress · ✅ done. Keep this current. diff --git a/.agents/completed/roadmap_v1_inventory_spikes_2026-07-10.md b/.agents/completed/roadmap_v1_inventory_spikes_2026-07-10.md index 4b9203a72..a6824e83c 100644 --- a/.agents/completed/roadmap_v1_inventory_spikes_2026-07-10.md +++ b/.agents/completed/roadmap_v1_inventory_spikes_2026-07-10.md @@ -12,7 +12,7 @@ finished coverage work and its handoff. | `INV-QUANT` | 76 rows across GGUF/llama.cpp, vLLM-native NVIDIA formats and MLX-native formats; recognition, materialization, quant compute, e2e and performance tracked separately | [quantization matrix](../quantization-matrix.md), [coverage spike](../specs/quantization-coverage.md) | spike GGUF compute-in-quant storage and dispatch | | `INV-KERNEL` | 30 practical families grounded through vLLM and its execution dependencies | [kernel matrix](../kernel-matrix.md), [family spike](../specs/kernel-family-inventory.md) | spike raw-pointer/shape/stride/stream adapter ABI | | `INV-BACKEND` | 13 CUDA targets, 18 component target rules, 8 platform/ABI rows and 9 native competitor gates | [backend matrix](../backend-matrix.md), [CUDA/backend spike](../specs/cuda-architecture-inventory.md) | spike the common architecture spine, then parallel target ports | -| `INV-COMPETITORS` | vLLM remains universal CUDA oracle; SGLang low-concurrency, llama.cpp CPU/Vulkan/Metal, and oMLX/MLX-LM Apple floors added | [benchmark spike](../specs/competitive-benchmarks.md), [benchmark protocol](../benchmark-protocol.md) | run the isolated DGX SGLang series after the active PR #3 GPU claim | +| `INV-COMPETITORS` | vLLM remains universal CUDA oracle; SGLang low-concurrency, llama.cpp CPU/Vulkan/Metal, and oMLX/MLX-LM Apple floors added | [benchmark spike](../specs/competitive-benchmarks.md), [benchmark protocol](benchmark-protocol-legacy.md) | run the isolated DGX SGLang series after the active PR #3 GPU claim | | `INV-FEATURE-ANCHORS` | legacy cross-cutting feature surface migrated to stable engine/serving rows; 26 code-bearing claims narrowed to their evidenced slices | [engine matrix](../engine-matrix.md), [anchor-backfill spike](../specs/feature-anchor-backfill.md) | agents write the missing leaf spikes before implementation or `DONE` claims | ## Corrections made by the coverage pass diff --git a/.agents/test-porting.md b/.agents/completed/test-porting-legacy.md similarity index 95% rename from .agents/test-porting.md rename to .agents/completed/test-porting-legacy.md index d52c5fc05..b75ecddee 100644 --- a/.agents/test-porting.md +++ b/.agents/completed/test-porting-legacy.md @@ -28,9 +28,9 @@ So test porting is part of the mirror obligation, not an optional extra. 3. **Traceability is 1:1 and named**: keep our test case names derived from upstream ones (`test_schedule_spec_decode` → `TEST_CASE("schedule_spec_decode …")`) and record the upstream→ours test-file mapping in - [porting-inventory.md](porting-inventory.md) alongside the code mapping, so + [porting-inventory.md](../porting-inventory.md) alongside the code mapping, so the upstream sync cycle can diff TEST deltas mechanically. -4. **Upstream sync ports test deltas too** ([upstream-sync.md](upstream-sync.md)): +4. **Upstream sync ports test deltas too** ([upstream-sync.md](../upstream-sync.md)): when a synced vLLM PR touches `tests/`, the port includes the test delta. A PR that only changes tests still gets synced — it's a spec change. 5. **Specs must inventory their tests**: every `.agents/specs/.md` diff --git a/.agents/coordination.md b/.agents/coordination.md index 335539aef..1d6ae194d 100644 --- a/.agents/coordination.md +++ b/.agents/coordination.md @@ -1622,18 +1622,31 @@ items a-runner/b stay with the async/GDN `runner.cpp` owners. | `CLAIM-EMBEDDINGS-ONE-SURFACE` | `ENG-POOLING-RUNNER` (live engine-step invocation), `SERVE-POOLING-ENDPOINTS` (SPIKE→ACTIVE, `/v1/embeddings`), `MODEL-EMBED-llama-llama-for-causal-lm` (INVENTORIED→ACTIVE; PARTIAL on merge — only the `LlamaModel` membership registered); cross-refs `ENG-POOLER-SEQ` (stays `CLAIM-POOLING`, ops untouched) | Claude Code (fable-5) helper, task #285 | isolated worktree `/home/mudler/_git/vllm.cpp-embeddings-one-surface` (CPU-only; lean per-target builds under disk pressure) | branch `row/EMBEDDINGS-ONE-SURFACE`, base `main` `b44ad337`, DRAFT PR #137 (the reservation) | ARCH-ONE-SURFACE fold ROW 6: embeddings/pooling through the ONE surface. Owns: NEW `src/vllm/model_executor/models/llama_embedding_registry.cpp` + `LoadLlamaModelEmbeddingWeights` (llama_weights.cpp) + `Qwen3DenseModel::ForwardHidden` (qwen3.{h,cpp} additive tail); the ADDITIVE task-gated pooling plumb (`LoadedModel::pooler()`, runner `pooling_runner_`+`pool_tokens`, `Request/EngineCoreRequest::pooling_params`, `ModelRunnerOutput::pooler_output`, scheduler pooling stop, `EngineCoreOutput/RequestOutput::pooling_output`, `LLMEngine::add_pooling_request/embed`, `ResolveAsyncEnabled(is_pooling_model)`); `vllm_embed`/`vllm_embedding_result_free` ABI v15 (vllm.h + vllm_c.cpp incl. the refuse-both-directions guards + the v13 `vllm_complete_tokens` missing-guard fix); `handle_embeddings` + `set_embedder` + task-conditional route (api_server.{h,cpp}) + server main pooling dispatch; NEW fixture `tests/vllm/models/fixtures/llama_embed_e2e` + `scripts/mm/llama_embed_fixture_gen.py` + `tests/vllm/models/test_llama_embedding_fold.cpp`; test/guard updates (test_capi v15 section + floor pin >= 15, test_dlopen symbols, c_header_compile.c, test_api_server embeddings section, test_model_registry/gguf arch pins, check-supported-models ARCH_TOKEN_RE); allowlist row removal + FEATURES/STATUS/BENCHMARKS rows + matrices + specs. **NON-COLLISION:** every engine hook is task-gated on `is_pooling_model`/`pooling_params` (nullopt/false = byte-identical text path); no SACRED path rewritten; no example added. | `ACTIVE` | 2026-08-08 — CPU-LANDED on the branch: fold gate `test_llama_embedding_fold` 4/4-231 (engine path == direct registry path + f64 LAST+normalize ref + chunked is_valid arm), `test_capi` 48/48-462, `test_dlopen` 30/30, server suite 50/50, registry 24/24-820, engine suites green (scheduler 423, llm_engine 204, engine_core 44, output_processor 77, qwen3_forward 1557, async_llm 342, llama_forward 509); 9 mutation kills (floor pin, refuse both directions, route gating both ways, engine-step invocation, scheduler stop, registry info pin, async-off wire). RESIDUAL: real embedding checkpoint + `LLM(task="embed")` oracle cosine. | - - - -GENERATED from open pull requests by `scripts/claim-view.py --apply`. -Do not hand-edit: an open `row/` PR IS the reservation, and it -is released by merging or closing it. - -| Row | PR | State | Agent | Updated | -|---|---|---|---|---| -| _none_ | | | | | - - +## Live claim authority + +Claims are not snapshotted in this record. `scripts/claim-view.py --check-live` +validates current pull requests; `--check-local` proves that no stale snapshot +was recommitted. Remote failure is `REMOTE_UNVERIFIED`, never an empty claim +set. The retired timestamp/TTL procedure is preserved in +[completed/pre-cutover-claim-protocol.md](completed/pre-cutover-claim-protocol.md). + +A `READY` row is advertised to helpers only after its base-committed spec +contains exactly one closed execution contract: + +```text + +``` + +Both values are argv arrays, never shell strings. `ready-for-helper.py` reads +the spec and referenced executables from the configured base commit, expands +that exact commit into a disposable checkout, and runs both commands with no +shell, a sanitized environment, bounded diagnostics, and a timeout. The gate +must exit zero and the mutation command must exit nonzero. A mutable worktree +file, prose assertion, missing/nonregular program, or unsafe argv cannot prove +readiness. CPU or exact gate hardware, satisfied dependencies, `READY` +lifecycle, and the absence of a repository-matching live claim remain required. **16-bit CPU GEMM: wide x86 ISA tiers + tiled sgemm (`KERNEL-GEMM-CPU-ELEM-X86WIDE` + `KERNEL-GEMM-CPU-TILED`, 2026-08-06, `CLAIM-KERNEL-CPU-ELEM-WIDE-1`).** Claude diff --git a/.agents/parity-ledger.md b/.agents/parity-ledger.md index 282396c4e..5d9682661 100644 --- a/.agents/parity-ledger.md +++ b/.agents/parity-ledger.md @@ -300,9 +300,9 @@ Columns: | 2026-07-10 (Triton-AOT follow-up: bf16 `chunk_o` source path + per-stream GDN scratch pools; GPU validation pending) | Adds the missing bf16-output AOT `chunk_o` specs (`gdn_chunko_bf16_h48/h32`) and source-wires `TryTritonChunkO` for f32 output plus bf16 output when `VLLM_CPP_TRITON_CHUNKO_BF16` is compiled. The bf16 path is deliberately artifact-gated so today's vendored Triton build keeps working until regenerated artifacts are added. Adds per-stream grow-only pools for GDN chunk scratch/metadata (`gcum/u/w/v_new/hstate/tok0/len/boh/cidx`) and the Triton WU A/Ai intermediates, with `VT_GDN_TRITON_CHUNK_POOL=0` and `VT_GDN_TRITON_WU_POOL=0` as same-binary A/B escapes. Integrates with main's vendored AOT workflow (`VLLM_CPP_TRITON_REGEN=ON` refreshes `src/vt/cuda/triton_aot_vendored//`; normal builds consume vendored artifacts without Python). README status rows updated to reflect the post-MVP throughput gate; the GGUF full-engine acceptance golden is routed out of generic op parity and owned by `test_qwen36_gguf_engine`. | FLA/vLLM `chunk_o.py` stores the recurrence output in bf16 when the model dtype is bf16; vLLM gets allocation reuse through PyTorch's caching allocator rather than raw per-layer `cudaMallocAsync` churn. Vendored AOT artifacts are a vllm.cpp build-system deviation, preserving the same generated CUDA driver ABI. | **Verified locally:** `git diff --check`; `cmake -S . -B build-cpu -DVLLM_CPP_CUDA=OFF -DVLLM_CPP_SERVER=OFF`; `cmake --build build-cpu -j$(nproc)`; `ctest --test-dir build-cpu --output-on-failure` = 90/90. **GPU validation pending:** this environment did not provide a CUDA-capable build/run path, so no throughput claim and no default flip for `VT_GDN_OUT_BF16`. Next CUDA pass must regenerate/check in the bf16 `chunk_o` AOT artifacts, run `VLLM_CPP_TRITON=ON` `test_ops_gdn`, and do same-binary A/B for pools + bf16 output vs fresh vLLM denominators. | | 2026-07-10 (B4 CPU DECISION MEASUREMENT — llama.cpp CPU vs our CPU path, same GGUF/same box: llama.cpp decode **54–75×** faster, prefill **≈1,480×** faster, peak RSS **2.7×** smaller; the roadmap "vendor IF proven faster" criterion is MET, `QUANT-GGUF-COMPUTE` threadpool→compute-in-quant confirmed as the structural route) | ROAD-V1-C4 / `BENCH-CPU-LLAMA` evidence: same-file CPU A/B on `Qwen3.5-2B-UD-Q8_K_XL.gguf` (`qwen35` dense, 1.94B, 2.68 GiB) on the idle x86 box (AMD Ryzen 9 9950X3D VM, 20 cores / 1 thread-per-core, 84 GB). Arms: (a) llama.cpp local fork `237ad9b96` (b9892 — the `QUANT-GGUF-COMPUTE` upstream pin), CPU build, 20 threads: `llama-bench -m -p 512,128 -n 128,32` (r=5) plus isolated `-p 0 -n 32 -r 2` under `/usr/bin/time -v`; (b) ours at `7c91a42` (branch `bench/quant-gguf-compute-b4-cpu-floor` = `83010c7` + measurement-enabling dense-`qwen35` GGUF loader path, gguf ctest 4/4 green): `vllm-bench --model --num-prompts 1 --input-len 128 --output-len 32 --concurrency 1` plus in16/out8 smoke ×3, greedy seed 0. Our CPU path is the known floor: single-threaded scalar ops (`src/vt/cpu/cpu_ops.cpp`, zero threading — 99–100% of one core observed for the whole run) over load-time bf16 expansion (`gguf_dequant.cpp` `DequantGgufRowToBf16`); llama.cpp runs 20-thread vectorized compute-in-quant. | llama.cpp `ggml/src/ggml*.c` tensor traits + `tools/llama-bench` at `237ad9b96` (own measurement per benchmark-protocol repro rules; llama.cpp is the CPU-GGUF perf oracle per specs/quantization-coverage.md §Gates and specs/competitive-benchmarks.md `BENCH-CPU-LLAMA`) | **llama.cpp: pp512 372.65±39.94 t/s, pp128 339.63±17.16, tg128 9.28±0.32, tg32 9.19±2.15 (combined run) and tg32 12.75±0.32 isolated; peak RSS 2.80 GiB. Ours: prefill 128 tok TTFT 559,724 ms = 0.229 t/s; decode TPOT 5,848 ms = 0.171 t/s; smoke ×3 TTFT 76,038/75,083/74,666 ms, TPOT 5,845/5,734/5,704 ms (spread <2% — reproduces); peak RSS 7.43 GiB. Ratios at the matched pp128/tg32 point: decode 54–75×, prefill ≈1,480×, memory 2.65× — all three axes decisively behind. DECISION: B4 "vendor IF proven faster" criterion MET — port/vendor llama.cpp's CPU compute path per the pinned upstream: threadpool first (~N_core× on every op, ~1 wk), then compute-in-quant ggml tensor-traits GEMM (research estimate ~3.3× decode / ~10× prefill on top); keep dequant-to-bf16 as the `VT_CPU_REF` parity oracle (compute-in-quant is not bit-identical). No lifecycle state shifts: `QUANT-GGUF-COMPUTE` and `BACKEND-GATE-CPU-LLAMACPP` stay `INVENTORIED` pending claim-sized leaf specs — this row is their measured perf-floor evidence. Caveat: single-request bench (concurrency 1) on one x86 box; the GB10 Arm-core rerun and a server-endpoint series belong to the gate row once the compute path lands.** | | 2026-07-10 (`ENG-CORE-BUSY-LOOP` W1: EngineCoreProc busy loop + input/output queue split + in-proc client — async-serving block leaf 1) | New `EngineCoreProc : EngineCore` (`include/vllm/v1/engine/core_proc.h` + `src/vllm/v1/engine/core_proc.cpp`): mutex+condvar `BlockingQueue` input/output queues with queue.Queue blocking-get/put_nowait semantics, `run_busy_loop` (`_process_input_queue` block-for-work + drain, `_process_engine_step` step_fn→output_queue), `EngineShutdownState` with abort-mode (finish-all-as-ABORTED + abort outputs) and drain-mode shutdown, ADD-rejected-during-shutdown, WAKEUP + ENGINE_CORE_DEAD sentinels, `EngineCoreRequestType` values kept; step_fn selection mirrored with `max_concurrent_batches > 1` rejected until `step_with_batch_queue` (W3 `ENG-ASYNC-SCHED`). New `InprocClient` (`core_client.{h,cpp}`): owns the proc + the dedicated engine `std::thread` under the run_engine_core fatal-error guard; blocking `get_output` raising `EngineDeadError` on the dead sentinel; `add_request_async`/`abort_requests_async` (empty/dead-guarded). Sync `LLMEngine` path untouched (additive files; only `EngineCore` members private→protected for the upstream subclass shape). Deferred per spec: UTILITY/START_DP_WAVE, DP waves, aborts_queue, idle-state callbacks, post_step, multi-client index. | `vllm/v1/engine/core.py:915-916,1259-1480` + `vllm/v1/engine/core_client.py:779-893`, exceptions.py:9 @ e24d1b24 (recorded deviation D2, async-serving spec: in-proc std::thread + direct queue sharing instead of forked process + ZMQ; client API shapes kept so a multiproc client is a drop-in) | **G2: clean full CPU build zero warnings; ctest 93/93 incl. new `test_engine_core_proc` (9 cases / 82 asserts — normal cycle, abort cycle, abort-after-finish ported from upstream `tests/v1/engine/test_engine_core_client.py:266,523`; WAKEUP idle shutdown, abort-mode + drain-mode shutdown, shutdown ADD-reject, EngineDeadError, batch-queue reject); 25/25 stability reruns of the threaded suite. G1 (both greedy engine gates re-run) + G4 (offline throughput A/B vs pre-change binary) DEFERRED to the gating handoff: GPU held by the `SERVE-GATE-ONLINE` campaign (flock holder + queued waiter verified) — W1 is additive host-side code not wired into the sync path, but the gates run before the row may claim DONE.** | -| 2026-07-10 (`ENG-PRIORITY-SCHED` W4: priority request queue + policy + priority preemption + `priority` plumbing — async-serving block leaf 4) | New `PriorityRequestQueue` (`src/vllm/v1/core/sched/request_queue.cpp:101` + header): a binary heap over `Request*` ordered by `RequestPriorityLess` (`Request.__lt__`: (priority, arrival_time, request_id, identity)) built with the std::*_heap algorithms; `create_request_queue(kPriority)` no longer throws (`request_queue.cpp:186`). Scheduler priority preemption (`scheduler.cpp:178`): when the policy is priority, the OOM victim is `max(running, key=(priority, arrival_time))` with the scheduled-this-step undo (restore token_budget, drop block reservation, `req_index -= 1`), mirroring `scheduler.py:546-572`; FCFS tail-pop unchanged and stays the default. `Request.priority` field + `RequestPriorityLess` (`request.h`/`request.cpp:92`), `EngineCoreRequest.priority`, and the OpenAI `priority` request field are plumbed end to end (protocol → serving → `LLMEngine::add_request`/`generate` → `InputProcessor::process_inputs` → `EngineCoreRequest` → `Request`); `SchedulerPolicyFromString` (`config/scheduler.cpp:21`) rejects unknown policy strings (upstream `SchedulingPolicy(value)` ValueError), and `EngineParams.policy`/`MakeSchedulerConfig` expose the policy config surface. Default behavior is byte-identical FCFS. | `vllm/v1/core/sched/request_queue.py:131-208` (PriorityRequestQueue, create_request_queue); `vllm/v1/core/sched/scheduler.py:546-572` (priority preemption victim); `vllm/v1/request.py:309-320` (`__lt__`), `:83` (priority); `vllm/config/scheduler.py:109-117,175-178` (policy field + SchedulingPolicy validation) @ e24d1b24 | **G2: clean full CPU build zero warnings; ctest 93/93. Ported tests (test-porting.md): 12 priority-scheduler cases in `tests/vllm/v1/test_scheduler.cpp:674` — basic/arrival/mixed ordering, preempts-lowest-priority-running, no-preempt-when-space, victim-selection, equal-priority tiebreak, waiting-queue-order, fcfs-fallback, limited-slots, ascending-priority (heap_property), and preemption-then-resumption-out-of-KV (V2 no-connector variant) — from `tests/v1/core/test_scheduler.py:2382-2856,2978`; 14 priority-queue cases + the seeded random ordering/heap-property property test in `tests/vllm/v1/test_request_queue.cpp:238,429` — from `test_priority_scheduler_random.py`. DEVIATION recorded: our M1.3 KVCacheManager forces caching ON (enable_caching=false deferred), so the ported block-math cases give each request a DISTINCT prompt to keep caching-ON behaviorally equal to upstream's caching-OFF (they test priority order/victim selection, not the prefix cache); the EC/KV-connector `test_scheduler.py:3769` variant is not ported (no connectors). G1 (both greedy engine gates re-run priority-vs-fcfs token-exactness) DEFERRED to the gating handoff: GPU held by the `SERVE-GATE-ONLINE` campaign — the priority policy is not the default so the greedy gates run FCFS unchanged, but the priority-vs-fcfs token-exact A/B runs before the row may claim DONE.** | +| 2026-07-10 (`ENG-PRIORITY-SCHED` W4: priority request queue + policy + priority preemption + `priority` plumbing — async-serving block leaf 4) | New `PriorityRequestQueue` (`src/vllm/v1/core/sched/request_queue.cpp:101` + header): a binary heap over `Request*` ordered by `RequestPriorityLess` (`Request.__lt__`: (priority, arrival_time, request_id, identity)) built with the std::*_heap algorithms; `create_request_queue(kPriority)` no longer throws (`request_queue.cpp:186`). Scheduler priority preemption (`scheduler.cpp:178`): when the policy is priority, the OOM victim is `max(running, key=(priority, arrival_time))` with the scheduled-this-step undo (restore token_budget, drop block reservation, `req_index -= 1`), mirroring `scheduler.py:546-572`; FCFS tail-pop unchanged and stays the default. `Request.priority` field + `RequestPriorityLess` (`request.h`/`request.cpp:92`), `EngineCoreRequest.priority`, and the OpenAI `priority` request field are plumbed end to end (protocol → serving → `LLMEngine::add_request`/`generate` → `InputProcessor::process_inputs` → `EngineCoreRequest` → `Request`); `SchedulerPolicyFromString` (`config/scheduler.cpp:21`) rejects unknown policy strings (upstream `SchedulingPolicy(value)` ValueError), and `EngineParams.policy`/`MakeSchedulerConfig` expose the policy config surface. Default behavior is byte-identical FCFS. | `vllm/v1/core/sched/request_queue.py:131-208` (PriorityRequestQueue, create_request_queue); `vllm/v1/core/sched/scheduler.py:546-572` (priority preemption victim); `vllm/v1/request.py:309-320` (`__lt__`), `:83` (priority); `vllm/config/scheduler.py:109-117,175-178` (policy field + SchedulingPolicy validation) @ e24d1b24 | **G2: clean full CPU build zero warnings; ctest 93/93. Ported tests (porting.md): 12 priority-scheduler cases in `tests/vllm/v1/test_scheduler.cpp:674` — basic/arrival/mixed ordering, preempts-lowest-priority-running, no-preempt-when-space, victim-selection, equal-priority tiebreak, waiting-queue-order, fcfs-fallback, limited-slots, ascending-priority (heap_property), and preemption-then-resumption-out-of-KV (V2 no-connector variant) — from `tests/v1/core/test_scheduler.py:2382-2856,2978`; 14 priority-queue cases + the seeded random ordering/heap-property property test in `tests/vllm/v1/test_request_queue.cpp:238,429` — from `test_priority_scheduler_random.py`. DEVIATION recorded: our M1.3 KVCacheManager forces caching ON (enable_caching=false deferred), so the ported block-math cases give each request a DISTINCT prompt to keep caching-ON behaviorally equal to upstream's caching-OFF (they test priority order/victim selection, not the prefix cache); the EC/KV-connector `test_scheduler.py:3769` variant is not ported (no connectors). G1 (both greedy engine gates re-run priority-vs-fcfs token-exactness) DEFERRED to the gating handoff: GPU held by the `SERVE-GATE-ONLINE` campaign — the priority policy is not the default so the greedy gates run FCFS unchanged, but the priority-vs-fcfs token-exact A/B runs before the row may claim DONE.** | | 2026-07-10 (`MODEL-FACTORY-registry` spike accepted after C2 handoff recovery) | Claim-sized contract for replacing the live `num_experts==0` model dispatch with an ordered architecture-to-type-erased-factory registry, registering both existing Qwen3.5 paths through it, mirroring vLLM's reject-unknown branches and capability metadata, and preserving the full two-model token/performance gate. The recovered draft was corrected against the pin: 32 previously-supported entries (not 36), subset-registry formatting for the default supported-list message, a central ordered table rather than cross-TU static registration, and the include/src header split. | Pinned vLLM `model_executor/models/registry.py:701-796,998-1082,1166-1190,1244-1296,1396-1404` plus `tests/models/test_registry.py` and `test_initialization.py`; no runtime behavior changes in this docs-only spike. | Nine-section spike contract and exact local/upstream anchors reviewed; record checker and 13-test mutation suite pass. Implementation remains `READY`, not supported/DONE. | -| 2026-07-10 (user-directed per-feature performance checkpoints) | Clarify the already-mandatory performance protocol: every feature or milestone that can affect speed/latency/memory is benchmarked as its own checkpoint before another speed-sensitive change is stacked. Each checkpoint requires an attributable same-binary pre/post A/B, a fresh same-box applicable floor, correctness first, all axes, 2–3 uncontended reproductions, and exact ledger commands; unavailable hardware leaves the row `GATING`. | Process-only clarification; vLLM remains the CUDA floor, same-file llama.cpp the CPU+GGUF floor, and backend-native floors remain as tabulated in `benchmark-protocol.md`. | `workflow.md` Definition of Done and `benchmark-protocol.md` acceptance rules now state the checkpoint/no-stacking invariant explicitly; no runtime behavior or support state changed. | +| 2026-07-10 (user-directed per-feature performance checkpoints) | Clarify the already-mandatory performance protocol: every feature or milestone that can affect speed/latency/memory is benchmarked as its own checkpoint before another speed-sensitive change is stacked. Each checkpoint requires an attributable same-binary pre/post A/B, a fresh same-box applicable floor, correctness first, all axes, 2–3 uncontended reproductions, and exact ledger commands; unavailable hardware leaves the row `GATING`. | Process-only clarification; vLLM remains the CUDA floor, same-file llama.cpp the CPU+GGUF floor, and backend-native floors remain as tabulated in `verification.md`. | `workflow.md` Definition of Done and `verification.md` acceptance rules now state the checkpoint/no-stacking invariant explicitly; no runtime behavior or support state changed. | | 2026-07-10 (`ENG-EXPERT-STREAM` spike grounding repair) | Recovered the stopped workflow writer and rewrote the expert-streaming implementation contract against the live 35B Marlin/loader path. Capacity/NVMe math remains, but implementation now requires a bank-only loader (no 16.88 GiB host expert copies), versioned pre-repacked bank with layer-wide scale factors, fixed contiguous C-slot Marlin arrays, device-router-ID readback, logical→slot rewrite before `moe_align`, and exact chunk sweeps for C