From 17b37c46930842afadd52ebac0572b9eccbbde42 Mon Sep 17 00:00:00 2001 From: localai-org-maint-bot <306269227+localai-org-maint-bot@users.noreply.github.com> Date: Sat, 1 Aug 2026 04:05:05 +0000 Subject: [PATCH 1/2] spike(ci): define per-commit gate cancellation repair FOLLOWING_AGENTS_PROTOCOL Assisted-by: Codex:GPT-5 [Codex] --- .agents/coordination.md | 19 +++++ .agents/roadmap_v1.md | 6 ++ .agents/specs/ci-per-commit-gates.md | 76 +++++++++++++++++++ .agents/state.md | 10 +++ docs/BENCHMARKS.md | 6 ++ docs/STATUS.md | 4 + .../plans/2026-08-01-ci-per-commit-gates.md | 58 ++++++++++++++ 7 files changed, 179 insertions(+) create mode 100644 .agents/specs/ci-per-commit-gates.md create mode 100644 docs/superpowers/plans/2026-08-01-ci-per-commit-gates.md diff --git a/.agents/coordination.md b/.agents/coordination.md index 842151c2..6ba75bdb 100644 --- a/.agents/coordination.md +++ b/.agents/coordination.md @@ -132,6 +132,25 @@ leaves. Owns only NEW `.agents/specs/cli-chat-complete.md`, the fixture, or GPU/model-download change; verification is the CPU record/doc checker suite. The row and open-PR list were unclaimed at selection time. +**Per-commit CI gate cancellation repair (`ROAD-V1-A6`, 2026-08-01, +`CLAIM-ROAD-V1-A6-CI-PER-COMMIT`).** Codex (GPT-5), isolated worktree +`.worktrees/road-v1-a6-ci-per-commit`, branch +`codex/road-v1-a6-ci-per-commit`, base `upstream/main` `1448e981`. CPU-only CI +governance bugfix: the `documentation-checkpoint` and `commit-protocol-tag` +jobs say their push ranges must never be cancelled, but both currently set +job-level `cancel-in-progress: true`; a later `main` push can therefore cancel +the only run covering the earlier push's `before..sha` range. Owns only +`.github/workflows/ci.yml`, NEW +`tests/scripts/test_ci_per_commit_gates.py`, NEW +`.agents/specs/ci-per-commit-gates.md`, this claim, the `ROAD-V1-A6` roadmap +checkpoint text, NEW +`docs/superpowers/plans/2026-08-01-ci-per-commit-gates.md`, +`docs/STATUS.md`, `docs/BENCHMARKS.md`, +`.agents/parity-ledger.md`, and append-only `.agents/state.md`. No C/C++, build, +runtime, model, kernel, fixture, README, lifecycle, support, or benchmark change; +verification is the CPU Python mutation test plus all record/document checkers. +No GPU, model download, compiler, external host, or parallel agent is required. + **Canonical DONE-owner reachability repair (`KV-PREFIX-CACHE`, `SAMPLE-LOGPROBS`, `SPEC-DFLASH`, `MODEL-SPEC-qwen3-dflash-dflash-qwen3-for-causal-lm`, diff --git a/.agents/roadmap_v1.md b/.agents/roadmap_v1.md index ee8d437e..579fb300 100644 --- a/.agents/roadmap_v1.md +++ b/.agents/roadmap_v1.md @@ -535,6 +535,12 @@ diagnostics recorded in `docs/BENCHMARKS.md`. | `SERVE-E2E-NIGHTLY` (formerly A5) | e2e suites per gates.md (server conformance nightly on dgx etc.) | ☐ next; leaf spike required | | A6 | **User-facing surface closure** (audit `CLAIM-DOCS-COVERAGE`, 2026-07-24): make what SHIPPED reachable and truthfully documented. The audit found 2 class-D overstatements, 5 stale doc lines, 4 shipped-but-unreachable features and 153 undocumented env vars | 🚧 Tier 1 (falsehood repair) DONE in the audit commit. **Tier 2 DONE 2026-07-24 (`CLAIM-DOCS-T2-FIXES`)**, 3 of its 4 items: the D1 guard (a per-connector worker-half capability predicate; the disk connector is now REFUSED at engine construction on every device instead of silently shortcutting prefill for KV nothing writes β€” **its worker half remains unimplemented and is NOT claimed**), server `--tool-call-parser`/`--reasoning-parser` (40 tool names / 7 reasoning parsers now reachable over HTTP; defaults reproduce the old hardcode exactly), and server `--kv-transfer-config` mirroring vLLM's own CLI + JSON shape. Also landed from Tier 3/4: `docs/KV-OFFLOAD.md`, the README flag rows, the three missing Gemma model rows, and the `SERVE-C-ABI` 17β†’19 record repair. **Comprehensive refresh DONE 2026-07-25 (`CLAIM-DOCS-REFRESH`)**: **Tier 4** `docs/ENVIRONMENT.md` (26 user-facing env vars documented of 153 swept, kernel-internal tail on `scripts/env-doc-allowlist.txt`) + its CI checker `scripts/check-env-doc.py` (mutation-tested, fails on a new undocumented+unallowlisted production env var); the **Tier 3** README refresh to current git history (spec-decode `--speculative-config` now documented as shipped, the "not user-visible" class-B falsehood fixed, C ABI `VLLM_ABI_VERSION 6`, CLI spec-config flag); new usage guide `docs/SPECULATIVE-DECODING.md`. STILL OPEN: `vllm-cli` structured-output/sampling flags (Tier 2 item 4, code, not docs). **C-ABI contract W0 2026-07-31 (`CLAIM-SERVE-C-ABI-SPIKE`):** accepted [c-api-library.md](specs/c-api-library.md), corrected public ABI v9 labels to v10, and named W1-W5 compatibility/no-throw/lifetime gates; `SERVE-C-ABI` honestly remains `ANCHOR-BACKFILL`. **CLI chat/complete W0 2026-08-01 (`CLAIM-SERVE-CLI-CHAT-SPIKE`):** [cli-chat-complete.md](specs/cli-chat-complete.md) corrects the inventory (the pin does ship both remote commands), selects exact OpenAI HTTP/SSE parity plus a compatibility-preserved local invocation, and decomposes CPU-only W1-W5 implementation leaves; `SERVE-CLI-CHAT` is `SPIKE`, no command code has landed. Full table: [specs/docs-coverage-audit.md](specs/docs-coverage-audit.md) | +`ROAD-V1-A6` CI-governance checkpoint (2026-08-01): +`CLAIM-ROAD-V1-A6-CI-PER-COMMIT` accepted the CPU-only +[per-commit gate cancellation spike](specs/ci-per-commit-gates.md). The two +unique-range gates remain behaviorally open until the workflow fix and mutation +test land; no runtime capability or lifecycle state changes. + ## B. Research tracks (complete) The B1-B7 parallel research block closed on 2026-07-10. Its frozen questions, diff --git a/.agents/specs/ci-per-commit-gates.md b/.agents/specs/ci-per-commit-gates.md new file mode 100644 index 00000000..f56f7dc4 --- /dev/null +++ b/.agents/specs/ci-per-commit-gates.md @@ -0,0 +1,76 @@ +# Per-commit CI gate cancellation repair + +## Scope + +This spike owns `ROAD-V1-A6` and only the two diff-scoped CI jobs +`documentation-checkpoint` and `commit-protocol-tag`. It removes their ability +to cancel an earlier run and adds a CPU static regression test. It does not +change runtime code, lifecycle states, support claims, build jobs, or the +workflow-level pull-request deduplication policy. + +## Upstream chain + +There is no vLLM runtime counterpart. This is repository governance around the +local contracts in `AGENTS.md:80-91,230-245` and the range selection in +`.github/workflows/ci.yml:73-135`. GitHub Actions evaluates job concurrency by +group and cancels an in-progress member when `cancel-in-progress` is true. The +two jobs group by `github.ref`, but each push checks only +`github.event.before..github.sha`; a replacement run therefore cannot cover a +cancelled predecessor's unique range. + +## Our baseline + +`.github/workflows/ci.yml:74-77,87-99` simultaneously says the two gates must +not be cancelled and configures both with `cancel-in-progress: true`. Existing +Python script tests validate checker semantics, but no test pins the workflow's +non-cancellation invariant. + +## Port map + +- `.github/workflows/ci.yml`: delete only the two job-level concurrency blocks. +- `tests/scripts/test_ci_per_commit_gates.py`: parse the workflow text by job + indentation and reject `concurrency` or `cancel-in-progress` inside either + protected job; mutation-test that each forbidden key is caught. + +No YAML dependency is added. Text inspection is deliberate because the test +guards the exact workflow structure and runs in the standard-library suite. + +## Tests to port + +No upstream vLLM test applies. The local executable contract has three cases: +the repository workflow passes; injecting a concurrency group under either +protected job fails; injecting `cancel-in-progress: true` under either protected +job fails. The test must be RED against the current workflow before the fix. + +## Gates + +- `python3 tests/scripts/test_ci_per_commit_gates.py` +- `python3 -m unittest discover -s tests/scripts -p 'test_*.py'` +- all repository record, documentation, structure, fusion, leakage, and env + checkers +- `git diff --check` + +Correctness is the static workflow invariant. E2E is the mutation suite. +Performance and memory are `NOT APPLICABLE`; no executable runtime path changes. +GPU/backend gates are `NOT APPLICABLE`; all verification is CPU-only. + +## Dependencies + +Depends only on Python 3, Git, and the checked-in workflow. No model, compiler, +GPU, external service, dependency source, license addition, or download is +required. The row was unclaimed at selection time and does not overlap open PRs. + +## Work breakdown + +1. `CI-PC1`: add the static test and observe RED on both protected jobs. +2. `CI-PC2`: remove their job-level cancellation blocks and observe GREEN. +3. `CI-PC3`: refresh checkpoint records, run the full CPU governance suite, + commit, push, and open the PR. + +## Risks/decisions + +The chosen design removes cancellation only from the two range-scoped jobs. +Removing all concurrency would waste build capacity; changing the push range to +recheck history would duplicate work and complicate new-branch handling. Pull +request workflow-level cancellation remains safe because the newest PR run +checks the full PR base-to-head range. diff --git a/.agents/state.md b/.agents/state.md index 173f48b6..652ce0ae 100644 --- a/.agents/state.md +++ b/.agents/state.md @@ -34505,3 +34505,13 @@ The required Slack selection notification was attempted through the bundled secret-safe sender to the only conventional target available, `#general`, but Slack returned `channel_not_found`. No channel ID/name is configured and no credential was inspected or exposed. + +## 2026-08-01 β€” `ROAD-V1-A6` per-commit CI cancellation spike + +`CLAIM-ROAD-V1-A6-CI-PER-COMMIT` selected an unclaimed CPU-only governance bug. +The documentation and commit-protocol jobs each validate one push's unique +`before..sha` range but are grouped by ref with cancellation enabled, so a later +main push can permanently suppress the earlier range. The accepted spec limits +the fix to removing those two job-level cancellation blocks and adding a +mutation-tested static invariant. No implementation, runtime, lifecycle, GPU, +model, or benchmark change is claimed at this checkpoint. diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md index fc665a30..39f4a52e 100644 --- a/docs/BENCHMARKS.md +++ b/docs/BENCHMARKS.md @@ -42,6 +42,12 @@ Two byte-exact fronts on the GB10 NVFP4 decode graph (`~/laguna-xs-nvfp4`, ids ` The 78 removed casts are ~78 Β΅s/step β€” BELOW the ~0.3 ms nsys run-to-run noise (the dominant `enable_if` projection GEMV drifts Β±0.4–0.7% between runs), so GPU-busy reads at parity; the win is the deterministic node-count drop (fewer graph nodes β†’ less ramp/drain the CUDA graph doesn't hide), reflected as a neutral-to-+0.29% `decode_hp`. Lands default-ON on the same "shrink the captured node count, byte-exact" basis as the glue/preamble/addnorm folds (`=0` is a same-binary A/B opt-out). The remaining decode tail (projection GEMV ~55%, lm_head 7.4%, we-win Marlin MoE ~12%) is at/beyond parity; the load-time Marlin repack (`TransposeToInt32`/`gptq_marlin_repack`/`ProcessScales`, 20046 inst) is a one-time cost, correctly zeroed by the 2-length diff (the nsys-aggregate trap). +## CI per-commit gate spike (2026-08-01, `CLAIM-ROAD-V1-A6-CI-PER-COMMIT`) - NOT APPLICABLE + +This records-only spike changes no runtime or performance path +(`benchmark_binding=false`). The next reproduction is +`python3 tests/scripts/test_ci_per_commit_gates.py`. + ## GCC 12 production-library portability (2026-07-31, `CLAIM-CPU-GCC12-WERROR-PORTABILITY`) - NOT APPLICABLE / all-target build PARTIAL This maintenance checkpoint changes no runtime algorithm or benchmark axis. diff --git a/docs/STATUS.md b/docs/STATUS.md index b8bfbbca..580dc8db 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -1,5 +1,9 @@ # vllm.cpp status +**CI governance checkpoint (2026-08-01):** `ROAD-V1-A6` has an accepted +CPU-only spike for the per-commit cancellation gap. Implementation is pending; +no runtime capability or support state changes. + **Roadmap-v1 reality audit (2026-07-31, `CLAIM-ROADMAP-V1-AUDIT`, `.agents/specs/roadmap-v1-audit-2026-07-31.md`):** an 8-lane code-grounded audit + adversarial DONE-verify (26 agents) vs the 18-row plan-of-record. Correctness + CPU-gated features are REAL; the dominant open gate across nearly all RI rows is **every-axis SPEED**; most GPU "DONE" proofs are DGX-recorded (not re-verifiable on the current box). **4 DONE claims refuted:** MM-video is near-tie not STRICT; Gemma-4 image is 16/18 near-tie not STRICT 18/18 (audio unbuilt); ROAD-V1-A (async code DONE but both SGLang-floor arms never ran, 27B 114/124 coin-flip not clean); C6 async-serving (SERVE-ASYNC-LLM still GATING). D5 LoRA is an unwired standalone CPU brick. Fixed `backend-matrix` BACKEND-GATE-CUDA-VLLM staleness 49/124 β†’ 114/124. (Follow-up: reworded a spec code-snippet `check-agent-record` misread as a dangling link β€” rc=0.) This is the per-capability status ledger. [README.md](../README.md) is the diff --git a/docs/superpowers/plans/2026-08-01-ci-per-commit-gates.md b/docs/superpowers/plans/2026-08-01-ci-per-commit-gates.md new file mode 100644 index 00000000..f7188134 --- /dev/null +++ b/docs/superpowers/plans/2026-08-01-ci-per-commit-gates.md @@ -0,0 +1,58 @@ +# Per-commit CI Gates Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Ensure the documentation and commit-protocol range gates can never be cancelled before validating their unique push range. + +**Architecture:** Keep the existing range computation unchanged and remove job-level cancellation from only the two protected jobs. Add a standard-library Python test that extracts those job blocks and mutation-proves both forbidden concurrency keys are rejected. + +**Tech Stack:** GitHub Actions YAML, Python 3 `unittest`, repository record checkers. + +## Global Constraints + +- CPU-only, with no GPU, model, compiler, service, or download. +- Do not change workflow-level PR deduplication or any tree-scoped job. +- Do not change runtime code, lifecycle state, support claims, or benchmarks. + +--- + +### Task 1: Pin the non-cancellation invariant + +**Files:** +- Create: `tests/scripts/test_ci_per_commit_gates.py` +- Modify: `.github/workflows/ci.yml` + +**Interfaces:** +- Consumes: the `jobs:` mapping and the two job names in `.github/workflows/ci.yml`. +- Produces: `job_block(text: str, name: str) -> str` and `gate_errors(text: str) -> list[str]` in the test module. + +- [ ] **Step 1: Write the failing test** + + Add tests asserting the checked-in workflow has no `concurrency:` or + `cancel-in-progress:` key inside either protected job, plus mutations that + inject each forbidden key and assert an error names the job and key. + +- [ ] **Step 2: Run test to verify it fails** + + Run: `python3 tests/scripts/test_ci_per_commit_gates.py` + + Expected: FAIL for both repository job blocks because each currently contains + `concurrency` and `cancel-in-progress`. + +- [ ] **Step 3: Write minimal implementation** + + Delete only the four-line job-level concurrency blocks beneath + `documentation-checkpoint` and `commit-protocol-tag`. Retain their comments, + range selection, and workflow-level concurrency unchanged. + +- [ ] **Step 4: Run test to verify it passes** + + Run: `python3 tests/scripts/test_ci_per_commit_gates.py` + + Expected: PASS, including both mutation families. + +- [ ] **Step 5: Run full verification and commit** + + Run the script unittest discovery, all repository governance checkers, and + `git diff --check`; update the owned checkpoint records; commit with + `FOLLOWING_AGENTS_PROTOCOL` and `Assisted-by: Codex:GPT-5 [Codex]`. From 72524ddbbf5c2720efd040ac1a81537952209de9 Mon Sep 17 00:00:00 2001 From: localai-org-maint-bot <306269227+localai-org-maint-bot@users.noreply.github.com> Date: Sat, 1 Aug 2026 04:07:02 +0000 Subject: [PATCH 2/2] fix(ci): keep per-commit range gates uncancellable FOLLOWING_AGENTS_PROTOCOL Assisted-by: Codex:GPT-5 [Codex] --- .agents/coordination.md | 2 + .agents/parity-ledger.md | 1 + .agents/roadmap_v1.md | 8 +-- .agents/state.md | 8 +++ .github/workflows/ci.yml | 6 -- docs/BENCHMARKS.md | 9 +-- docs/STATUS.md | 7 ++- tests/scripts/test_ci_per_commit_gates.py | 72 +++++++++++++++++++++++ 8 files changed, 96 insertions(+), 17 deletions(-) create mode 100644 tests/scripts/test_ci_per_commit_gates.py diff --git a/.agents/coordination.md b/.agents/coordination.md index 6ba75bdb..854de2e2 100644 --- a/.agents/coordination.md +++ b/.agents/coordination.md @@ -150,6 +150,8 @@ checkpoint text, NEW runtime, model, kernel, fixture, README, lifecycle, support, or benchmark change; verification is the CPU Python mutation test plus all record/document checkers. No GPU, model download, compiler, external host, or parallel agent is required. +**LANDED + CPU-GATED locally:** focused invariant 3/3 and full script suite +98/98; push/PR and hosted CI are pending. **Canonical DONE-owner reachability repair (`KV-PREFIX-CACHE`, `SAMPLE-LOGPROBS`, `SPEC-DFLASH`, diff --git a/.agents/parity-ledger.md b/.agents/parity-ledger.md index 1156d192..378709f4 100644 --- a/.agents/parity-ledger.md +++ b/.agents/parity-ledger.md @@ -886,3 +886,4 @@ Columns: | 2026-07-31 (`SERVE-C-ABI` W0 contract spike; `CLAIM-SERVE-C-ABI-SPIKE`; CPU-only records/docs) | Accepted `.agents/specs/c-api-library.md` for the already-shipped original C packaging layer: complete scope, vLLM semantic chain/deviation, ABI v10/19-symbol baseline, ownership/error/version/dispatch rules, exact code/test anchors, gates, dependencies, risks, and W1-W5 follow-ons. Also fixes the verified stale public `VLLM_ABI_VERSION 9` labels in README/USAGE to the source-of-truth v10 and adds the missing v10 usage-table entry. No production/test/CMake source changed. | Pinned vLLM `555967922` has no C ABI; behavior beneath the adapter remains owned by its vLLM-derived engine rows. The flat ABI is the recorded llama.cpp-style packaging deviation and may translate, never reimplement, policy. | **CPU/records gate only; benchmark NOT APPLICABLE.** Focused C11/C++/dlopen/export gate passed 3/3 after explicitly building `vllm_shared`; five record checkers pass. `check-agent-record` reports the base tree's same six missing closing-commit objects (`444ea9d7`, `7a3f04b2`, `164453a2`), none in this row/diff. Row stays `ANCHOR-BACKFILL` because all-symbol dlsym coverage (chat symbols currently omitted), historical-layout compatibility, allocation-failure no-throw proof, lifetime sanitizer stress, and a standalone real-model C consumer remain W1-W5. | | 2026-07-31 (`CLAIM-CPU-GCC12-WERROR-PORTABILITY`; maintenance, rows `QUANT-GGUF-KEEPQ-LOADER` + `KV-OFFLOAD`; lifecycle unchanged) | Removes two GCC 12 production-library `-Werror` blockers without suppressions: the GGUF prefault keeps the same one-byte-per-page volatile XOR but uses simple assignment, and the KV filesystem tier builds the identical `...tmp` suffix with append operations inside its thread-local initializer. No API, algorithm, default, CUDA, fixture, or golden change. | Behavior remains grounded in the accepted loader and KV-persistence leaf specs: llama.cpp mmap prefault intent and vLLM `tiering/fs/io.py` unique temporary-file publication. This is compiler portability, not a parity-surface change. | RED: GCC 12 failed first at `qwen3_5_gguf_weights.cpp:49` (`-Wvolatile`), then at `fs_io.cpp:66` (`-Wrestrict`). GREEN: production `vllm` and focused test targets build clean; focused CTest 2/2 (`test_gguf_keep_quant`, `test_kv_offload_fs`). Full all-target build is PARTIAL at 42% on unrelated test-only GCC 12 `-Wrestrict` diagnostics in `test_deepseek_v2_paged_engine.cpp` and `test_glm4_moe_lite_paged_engine.cpp`; no full-CTest claim. Benchmark NOT APPLICABLE. | | 2026-08-01 (`SERVE-CLI-CHAT` W0 contract spike; `CLAIM-SERVE-CLI-CHAT-SPIKE`; CPU-only records/spec) | Accepts `.agents/specs/cli-chat-complete.md`, corrects the inventory from β€œno direct commands” to the actual pinned `chat`/`complete` surface, and decomposes a dual-mode port: exact remote OpenAI HTTP/SSE commands plus preservation of the existing in-process invocation as a compatibility alias. No production, test, CMake, model, kernel, fixture, or generated file changes. | Pinned vLLM `5559679229`: command registration `vllm/entrypoints/cli/main.py:17-37,73-98`; model/auth resolution and stream shaping `vllm/entrypoints/cli/openai.py:30-100`; chat `:155-234`; complete `:237-312`. The local compatibility baseline is `examples/cli/main.cpp:1-207`. | CPU record/doc gates only; benchmark `NOT APPLICABLE`, `benchmark_binding=false`. Implementation remains absent and the row moves `INVENTORIED` -> `SPIKE`. W1-W5 name parse, transport, complete, chat, and packaging gates, including fake-server request/SSE transcript parity, Release `-Werror`, ASan+UBSan, and TSan. | +| 2026-08-01 (`ROAD-V1-A6` per-commit gate cancellation repair; `CLAIM-ROAD-V1-A6-CI-PER-COMMIT`) | Removes job-level cancellation from the documentation-checkpoint and commit-protocol-tag jobs so every push's unique `before..sha` range receives a verdict. Adds a standard-library static invariant and mutations for both forbidden keys on both protected jobs. No runtime, lifecycle, support, model, build, or benchmark behavior changes. | No vLLM runtime counterpart; this enforces the local `AGENTS.md` commit/checkpoint protocol and the range semantics in `.github/workflows/ci.yml`. | RED: current workflow produced four violations. GREEN: focused 3/3 and full script suite 98/98. Benchmark NOT APPLICABLE (`benchmark_binding=false`); CPU-only governance evidence. | diff --git a/.agents/roadmap_v1.md b/.agents/roadmap_v1.md index 579fb300..598cefe0 100644 --- a/.agents/roadmap_v1.md +++ b/.agents/roadmap_v1.md @@ -536,10 +536,10 @@ diagnostics recorded in `docs/BENCHMARKS.md`. | A6 | **User-facing surface closure** (audit `CLAIM-DOCS-COVERAGE`, 2026-07-24): make what SHIPPED reachable and truthfully documented. The audit found 2 class-D overstatements, 5 stale doc lines, 4 shipped-but-unreachable features and 153 undocumented env vars | 🚧 Tier 1 (falsehood repair) DONE in the audit commit. **Tier 2 DONE 2026-07-24 (`CLAIM-DOCS-T2-FIXES`)**, 3 of its 4 items: the D1 guard (a per-connector worker-half capability predicate; the disk connector is now REFUSED at engine construction on every device instead of silently shortcutting prefill for KV nothing writes β€” **its worker half remains unimplemented and is NOT claimed**), server `--tool-call-parser`/`--reasoning-parser` (40 tool names / 7 reasoning parsers now reachable over HTTP; defaults reproduce the old hardcode exactly), and server `--kv-transfer-config` mirroring vLLM's own CLI + JSON shape. Also landed from Tier 3/4: `docs/KV-OFFLOAD.md`, the README flag rows, the three missing Gemma model rows, and the `SERVE-C-ABI` 17β†’19 record repair. **Comprehensive refresh DONE 2026-07-25 (`CLAIM-DOCS-REFRESH`)**: **Tier 4** `docs/ENVIRONMENT.md` (26 user-facing env vars documented of 153 swept, kernel-internal tail on `scripts/env-doc-allowlist.txt`) + its CI checker `scripts/check-env-doc.py` (mutation-tested, fails on a new undocumented+unallowlisted production env var); the **Tier 3** README refresh to current git history (spec-decode `--speculative-config` now documented as shipped, the "not user-visible" class-B falsehood fixed, C ABI `VLLM_ABI_VERSION 6`, CLI spec-config flag); new usage guide `docs/SPECULATIVE-DECODING.md`. STILL OPEN: `vllm-cli` structured-output/sampling flags (Tier 2 item 4, code, not docs). **C-ABI contract W0 2026-07-31 (`CLAIM-SERVE-C-ABI-SPIKE`):** accepted [c-api-library.md](specs/c-api-library.md), corrected public ABI v9 labels to v10, and named W1-W5 compatibility/no-throw/lifetime gates; `SERVE-C-ABI` honestly remains `ANCHOR-BACKFILL`. **CLI chat/complete W0 2026-08-01 (`CLAIM-SERVE-CLI-CHAT-SPIKE`):** [cli-chat-complete.md](specs/cli-chat-complete.md) corrects the inventory (the pin does ship both remote commands), selects exact OpenAI HTTP/SSE parity plus a compatibility-preserved local invocation, and decomposes CPU-only W1-W5 implementation leaves; `SERVE-CLI-CHAT` is `SPIKE`, no command code has landed. Full table: [specs/docs-coverage-audit.md](specs/docs-coverage-audit.md) | `ROAD-V1-A6` CI-governance checkpoint (2026-08-01): -`CLAIM-ROAD-V1-A6-CI-PER-COMMIT` accepted the CPU-only -[per-commit gate cancellation spike](specs/ci-per-commit-gates.md). The two -unique-range gates remain behaviorally open until the workflow fix and mutation -test land; no runtime capability or lifecycle state changes. +`CLAIM-ROAD-V1-A6-CI-PER-COMMIT` completed the CPU-only +[per-commit gate cancellation repair](specs/ci-per-commit-gates.md). Both +unique-range jobs are uncancellable and mutation-gated; no runtime capability +or lifecycle state changes. ## B. Research tracks (complete) diff --git a/.agents/state.md b/.agents/state.md index 652ce0ae..968c889d 100644 --- a/.agents/state.md +++ b/.agents/state.md @@ -34515,3 +34515,11 @@ main push can permanently suppress the earlier range. The accepted spec limits the fix to removing those two job-level cancellation blocks and adding a mutation-tested static invariant. No implementation, runtime, lifecycle, GPU, model, or benchmark change is claimed at this checkpoint. + +## 2026-08-01 β€” `ROAD-V1-A6` per-commit CI cancellation repair implemented + +`CI-PC1` RED produced four violations, one `concurrency` and one +`cancel-in-progress` finding for each protected job. `CI-PC2` removed only those +two job-level blocks; workflow-level PR deduplication and every tree-scoped job +remain unchanged. Focused test is 3/3 and full script unittest discovery is +98/98. Push, PR, hosted CI inspection, and the second Slack notification remain. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c43103ab..cc435145 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -56,9 +56,6 @@ jobs: python3 scripts/check-runner-routing-consistency.py python3 tests/scripts/test_check_runner_routing_consistency.py documentation-checkpoint: - concurrency: - group: ci-doc-${{ github.ref }}-${{ github.repository }} - cancel-in-progress: true # Gate: every code/test/benchmark/spike/lifecycle iteration refreshes both # user-facing status surfaces in that same commit, including void attempts. # @@ -88,9 +85,6 @@ jobs: fi python3 scripts/check-doc-checkpoint.py --base "$base" --head "$head" commit-protocol-tag: - concurrency: - group: ci-commit-${{ github.ref }}-${{ github.repository }} - cancel-in-progress: true # Gate: every NEW commit must carry the FOLLOWING_AGENTS_PROTOCOL trailer, # asserting the contributor read AGENTS.md. See .agents/ai-coding-assistants.md. # diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md index 39f4a52e..5386fc91 100644 --- a/docs/BENCHMARKS.md +++ b/docs/BENCHMARKS.md @@ -42,11 +42,12 @@ Two byte-exact fronts on the GB10 NVFP4 decode graph (`~/laguna-xs-nvfp4`, ids ` The 78 removed casts are ~78 Β΅s/step β€” BELOW the ~0.3 ms nsys run-to-run noise (the dominant `enable_if` projection GEMV drifts Β±0.4–0.7% between runs), so GPU-busy reads at parity; the win is the deterministic node-count drop (fewer graph nodes β†’ less ramp/drain the CUDA graph doesn't hide), reflected as a neutral-to-+0.29% `decode_hp`. Lands default-ON on the same "shrink the captured node count, byte-exact" basis as the glue/preamble/addnorm folds (`=0` is a same-binary A/B opt-out). The remaining decode tail (projection GEMV ~55%, lm_head 7.4%, we-win Marlin MoE ~12%) is at/beyond parity; the load-time Marlin repack (`TransposeToInt32`/`gptq_marlin_repack`/`ProcessScales`, 20046 inst) is a one-time cost, correctly zeroed by the 2-length diff (the nsys-aggregate trap). -## CI per-commit gate spike (2026-08-01, `CLAIM-ROAD-V1-A6-CI-PER-COMMIT`) - NOT APPLICABLE +## CI per-commit gate repair (2026-08-01, `CLAIM-ROAD-V1-A6-CI-PER-COMMIT`) - NOT APPLICABLE -This records-only spike changes no runtime or performance path -(`benchmark_binding=false`). The next reproduction is -`python3 tests/scripts/test_ci_per_commit_gates.py`. +The workflow-only repair changes no runtime or performance path +(`benchmark_binding=false`). Reproduction: +`python3 tests/scripts/test_ci_per_commit_gates.py` (3/3) and the full script +suite (98/98). ## GCC 12 production-library portability (2026-07-31, `CLAIM-CPU-GCC12-WERROR-PORTABILITY`) - NOT APPLICABLE / all-target build PARTIAL diff --git a/docs/STATUS.md b/docs/STATUS.md index 580dc8db..11421012 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -1,8 +1,9 @@ # vllm.cpp status -**CI governance checkpoint (2026-08-01):** `ROAD-V1-A6` has an accepted -CPU-only spike for the per-commit cancellation gap. Implementation is pending; -no runtime capability or support state changes. +**CI governance checkpoint (2026-08-01):** `ROAD-V1-A6` per-commit cancellation +repair is implementation-complete and CPU-gated. The documentation and +commit-protocol jobs cannot cancel their unique push ranges; no runtime +capability or support state changes. **Roadmap-v1 reality audit (2026-07-31, `CLAIM-ROADMAP-V1-AUDIT`, `.agents/specs/roadmap-v1-audit-2026-07-31.md`):** an 8-lane code-grounded audit + adversarial DONE-verify (26 agents) vs the 18-row plan-of-record. Correctness + CPU-gated features are REAL; the dominant open gate across nearly all RI rows is **every-axis SPEED**; most GPU "DONE" proofs are DGX-recorded (not re-verifiable on the current box). **4 DONE claims refuted:** MM-video is near-tie not STRICT; Gemma-4 image is 16/18 near-tie not STRICT 18/18 (audio unbuilt); ROAD-V1-A (async code DONE but both SGLang-floor arms never ran, 27B 114/124 coin-flip not clean); C6 async-serving (SERVE-ASYNC-LLM still GATING). D5 LoRA is an unwired standalone CPU brick. Fixed `backend-matrix` BACKEND-GATE-CUDA-VLLM staleness 49/124 β†’ 114/124. (Follow-up: reworded a spec code-snippet `check-agent-record` misread as a dangling link β€” rc=0.) diff --git a/tests/scripts/test_ci_per_commit_gates.py b/tests/scripts/test_ci_per_commit_gates.py new file mode 100644 index 00000000..3274db21 --- /dev/null +++ b/tests/scripts/test_ci_per_commit_gates.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +"""Mutation checks for CI jobs that must validate every unique push range.""" + +from __future__ import annotations + +import unittest +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +WORKFLOW = ROOT / ".github/workflows/ci.yml" +PROTECTED_JOBS = ("documentation-checkpoint", "commit-protocol-tag") + + +def job_block(text: str, name: str) -> str: + """Return one top-level job block from a GitHub Actions workflow.""" + lines = text.splitlines() + marker = f" {name}:" + try: + start = lines.index(marker) + except ValueError as exc: + raise AssertionError(f"missing protected CI job: {name}") from exc + + end = len(lines) + for index in range(start + 1, len(lines)): + line = lines[index] + if line.startswith(" ") and not line.startswith(" ") and line.endswith(":"): + end = index + break + return "\n".join(lines[start:end]) + + +def gate_errors(text: str) -> list[str]: + """Return cancellation-policy violations for range-scoped jobs.""" + errors: list[str] = [] + for name in PROTECTED_JOBS: + block = job_block(text, name) + for key in ("concurrency:", "cancel-in-progress:"): + if any(line.strip().startswith(key) for line in block.splitlines()[1:]): + errors.append(f"{name} must not set {key[:-1]}") + return errors + + +class PerCommitGateTests(unittest.TestCase): + def test_range_scoped_jobs_cannot_be_cancelled(self) -> None: + self.assertEqual(gate_errors(WORKFLOW.read_text()), []) + + def test_mutation_catches_concurrency_group(self) -> None: + baseline = WORKFLOW.read_text() + for name in PROTECTED_JOBS: + with self.subTest(job=name): + mutated = baseline.replace( + f" {name}:\n", f" {name}:\n concurrency:\n group: mutant\n", 1 + ) + self.assertIn( + f"{name} must not set concurrency", gate_errors(mutated) + ) + + def test_mutation_catches_cancel_in_progress(self) -> None: + baseline = WORKFLOW.read_text() + for name in PROTECTED_JOBS: + with self.subTest(job=name): + mutated = baseline.replace( + f" {name}:\n", f" {name}:\n cancel-in-progress: true\n", 1 + ) + self.assertIn( + f"{name} must not set cancel-in-progress", gate_errors(mutated) + ) + + +if __name__ == "__main__": + unittest.main()