Skip to content

models(vela): integrate encoder and decoder native carriers - #215

Draft
psv666 wants to merge 33 commits into
codex/vela152-coexist-basefrom
codex/vela152-coexist-20261120
Draft

psv666 wants to merge 33 commits into
codex/vela152-coexist-basefrom
codex/vela152-coexist-20261120

Conversation

@psv666

@psv666 psv666 commented Nov 20, 2026

Copy link
Copy Markdown
Collaborator

Summary

Integrate the delivered encoder #207 and decoder #213 into one CPU-buildable workspace while preserving both original histories.

omni-modernbert ← omni-laya
                ← omni-vela-encoder-native  (vela/encoder_native)
omni-qwen3-5-native ← omni-vela-native       (vela/native; 0.8B/4B/9B)

The decoder keeps its existing package/path/API. The 0.3B encoder moves mechanically to omni-vela-encoder-native / src/models/vela/encoder_native, reusing the single ModernBERT core. Root members/lock retain both dependency sets; encoder test imports and necessary links follow the move. Related: #137 / #152.

Stacked base: delivered decoder 422e74f8b3030d5cf766cf3ce4ee281d44691d58; encoder input a11335aeed99d30ebdef123d673b569eb8a1c299. Both original MrDongsls histories, #207, #213/#210, #195/#177, #208/#205 and main f1e674f2 remain ancestors. Original branches are unchanged. Retarget and revalidate after the underlying stacks land.

Required human contributor answers

The contributor explicitly confirmed the model acceptance objective, this CPU coexistence stage, the single root-registration owner and necessary draft integration PR. Those answers remain applicable:

  1. Outcome: reproducible, reviewable model acceptance so supported models can be used reliably.
  2. Highest-leverage variable: reliable model coverage and numerical consistency.
  3. How this moves it: reuse delivered implementations, resolve their concrete registration/API collision, and retain meaningful contract and regression evidence.
  4. User and need: model, application and agent developers needing stable interfaces, reliable outputs and reproducible deployments.

Is a PR needed? Yes; the contributor authorized necessary focused draft supplements/integration while preserving other authors' commits.

Evidence

  • Before: a direct merge of the two delivered heads exits 1 with seven conflicting paths: Cargo.toml/lock, model README, reference recipe, and native Cargo.toml/executor.rs/lib.rs.
  • After: renaming the encoder first removes the source/API collisions. Only four registration/documentation conflicts remain and are resolved by retaining both contracts. Compared with Git's automatic merge tree, final manual differences are the two root files and five necessary Markdown files.
  • 97 byte/import checks preserve decoder source/fixtures, relocated encoder implementation and mathematical fixtures; the four encoder test imports change crate identity only. All 255 registry records retain their input versions/checksums. One ModernBERT package remains.
  • Both packages are discovered with 11 root integration-test targets; their binaries were invoked, with ignored/device checks distinguished below. Fifteen critical profile/census/YaRN/Laya/zero-head contracts are explicitly found and passed.

Purpose

This resolves the native carrier collision. It retains #152's existing Laya/ModernBERT and Qwen structure/gate split, and the decoder's delivered row ownership, finite-value and 16,384-token row-cap safeguards. No new production forward, numerical kernel, runtime or fixture change is authored here. Shared files retain the automatic merge of the delivered inputs.

Test Plan

Head: 6e1584a3928e58722bac61175114ae859f89b6b9

Tree: f839cf0965141c014ec7c28f6c8d1ea0720b2e9e

From repository root, Rust1.100.0 / Python3.12.13 on L20, private target/cache/venvs, CUDA_VISIBLE_DEVICES= and all model/library pins unset, Cargo/HF offline:

cargo test --locked --offline -p omni-modernbert -p omni-vela-encoder-native -p omni-vela-native -p omni-laya -p omni-qwen3-5-native --features omni-laya/serve -- --list
cargo test --locked --offline -p omni-modernbert -p omni-vela-encoder-native -p omni-vela-native -p omni-laya -p omni-qwen3-5-native --features omni-laya/serve
cargo test --locked --offline -p omni-vela-encoder-native --features cuda -- --list
cargo test --locked --offline -p omni-vela-encoder-native --features cuda -- --nocapture
cargo test --locked --offline -p omni-vela-native --lib processing::row_limit_tests
cargo test --release --locked --offline -p omni-vela-native --lib processing::row_limit_tests
cargo fmt --all --check
cargo clippy --workspace --locked --offline --all-targets --features omni-laya/serve -- -D warnings
cargo test --workspace --locked --offline --features omni-laya/serve
cargo build --workspace --release --locked --offline --features omni-laya/serve
PYTHONPATH=src python -m pytest tests/vela -q
python recipe/vela/test_compare_reference.py
python -m pytest tests/benchmarks -q
python src/backends/cuda/check_contract.py --repo-root .
python -m unittest discover -s tests/cuda -p 'test_*.py' -v
python -m mkdocs build --strict

Test Result

Personally executed at the exact head/tree:

Check Result
Components 210 passed /0 failed /79 ignored
Encoder cuda-feature suite 12 actual CPU tests; device test returns early without pins (Cargo reports 13 ok)
Encoder contracts exact 134 encoder +18 head census; geometry/storage/dtype negative cases; original YaRN gates
Laya sibling two byte-equal golden plans; 20 configurations ×242 original/prepared mock launches equal
Decoder cap 9 debug +9 release passed; original root contracts/guards retained
Workspace initial unchanged JEV-VL concurrency timeout; one full serialized follow-up 550 passed /0 failed /126 ignored
CI Rust commands fmt, strict all-target Clippy and release build pass
Vela Python 190 passed
Benchmark Python 133 passed +185 subtests
CUDA contract/Python 0 errors /1 inherited ABI-define warning; 27 tests pass
Docs strict build passes; 38 local links across five model/carrier/recipe documents exist

The first configured workspace run failed at stats_and_prefix_publication_finish_concurrently after its 10-second timeout (235/1/27 before fail-fast). Owning JEV-VL source/test match main. The protocol allowed one cargo test --workspace --locked --offline --features omni-laya/serve -- --test-threads=1 follow-up; it passed. The cause remains unclassified; serialization does not establish that the cache cannot deadlock. Original logs/results/exit101 are retained. No assertion or timeout was changed.

Demo / evidence

The reproducible source bundle, commands/exits, original failure, separate follow-up, metadata/discovery, source/fixture/root hashes, review map and 147 final logged executable hashes are retained off-repository in vela152-coexist-evidence.tar.gz, SHA256 56b334e85ab153a90209f343de87e4e8ae6edb82ccf0c3db815994a56b8219a6 (37,446,061 bytes; 110 members /109 payload files). The contributor retains local and L20 copies. Source bundle SHA256 92eaf717c1787a24634ad4d32497be6dbd9e3813fdf976d3c89cf154dd1c7e36. No run dump or new generated fixture enters product Git.

This qualifies CPU carrier coexistence only. No weights were downloaded and no model GPU, HTTP or performance run was started. The encoder remains Hopper-only (sm_90a), unsupported by this backend on L20 sm_89. Decoder production source and Qwen Model execution suffix are unchanged, but the inherited Qwen Config-loading extraction is part of this tree. Prior GPU evidence stays pinned to #177/#210/#213; it is not current-head GPU qualification. Complete GPU typed responses, native HTTP/readiness/frontend/lifecycle and positive-window GPU remain separate. Performance A/B/video: N/A for this mechanical integration.

Review map and self-review

The stacked diff is 75 files, +7,661/-538 =8,199 text lines, with 5,413 source/test changed lines (including comments/blank lines; excluding manifests/lock/docs/static fixtures). It imports #152 into a decoder-only base; newly authored source edits are four import substitutions. The large inherited stack still requires full human contributor/maintainer and device review.

Suggested order:

  1. 1c9e4cc: encoder carrier rename, root membership/lock, root test imports.
  2. 10d94f6: four root/docs conflict resolutions; inherited ModernBERT/Laya/Qwen components from models: make encoder structure configurable, ModernBERT core, Vela 0.3B profile #152/modernbert: reject zero attention heads before deriving geometry #207.
  3. Confirm decoder native files/tests/fixtures remain exactly test(vela): require attributed member replays and qualify 9B on L20 #213, including fix(vela): enforce the 16384-token native row limit #208/fix(vela): preserve row ownership in decoder executor replay #210 safeguards.
  4. 9298359 / 6e1584a: carrier entry-point docs and moved ModernBERT link.
  5. CPU discovery, original Laya/YaRN/census gates and retained concurrency failure/follow-up.

New mechanical changes, complete resolutions, callers, scope, ownership and artifact hygiene were self-reviewed with no remaining blocking finding in this phase. The unresolved concurrent-test risk and device gaps remain explicit. This is evidence for a draft integration, not maintainer approval or a candidate CI pass; the workflows filter PR bases to main.

Merge Danger

Door: two-way.

Blast Radius: workspace.

The encoder package/import path changes. Both native APIs and existing hardware gates remain separate; the inherited shared stack needs normal full review and device acceptance before readiness.

  • I have reviewed the full diff and addressed the issues I found.
  • I have checked architecture and scope.
  • I have run appropriate checks and reported unverified checks.
  • I have checked that claims match implementation and evidence.

Mr.Dong and others added 30 commits October 21, 2026 00:23
The implementation series for docs/rfc/model-parameter-configuration.md,
charter step 3 of the Vela 2.0 order (the 0.3B reference worker landed
as 2812144; every native Vela slice waits on this). Five specs on
branch model/configurable-base-model:

- 01 ModernBERT family IR, source adapters, capability gate (pure
  Rust crate omni-modernbert, provenance, StructureIdentity)
- 02 Laya native migrated onto the core, zero behavior change,
  plan-fixture bit-identity, task head stays Laya-side
- 03 Vela 0.3B as the second ModernBERT profile: model-local weight
  mapping, YaRN rope tables fixture-grounded, kernel bundle
  regeneration with the laya ABI 1->2 decision, parity harness vs
  the pinned package
- 04 task-head ownership boundary: final-hidden-at-positions
  contract, heads stay in the vela crate
- 05 Qwen hybrid config/capability migration: shadow-normalizing
  facade, QwenAbi6 gate as data, PrefixLayout derivation, loader
  seams (prefix candidates + per-tensor dtype policy) for the hybrid
  consumer; ABI 6 untouched

Stances recorded on the RFC's open items: Rust-internal IR only,
explicit adapter selection, frozen ABI-6 schedule set, bundle fields
in spec 03. Evidence base: laya/qwen source at 2812144, the pinned
0.3B package copy, research 017/019, the locked charter.
A pure-Rust family layer for ModernBERT encoders with no device
dependencies, the first half of the model-parameter RFC's phase 2:

- structure: one ModernBertStructure with family invariants (heads *
  head_dim == hidden, schedule length, bias-free gelu, rope/yarn
  bounds) and per-field provenance; canonical sorted-key JSON for
  identity digests
- adapters: the Laya two-file bundle (explicit layer_types, per-kind
  rope_parameters) and any single-object HF ModernBERT config
  (schedule from global_attn_every_n_layers or explicit layer_types,
  global/local thetas, yarn rope_scaling, optional type vocab);
  unknown top-level keys are recorded, never guessed
- geometry: derived tensor shapes (the 2*intermediate up-projection
  is derived, not semantic), the canonical encoder tensor inventory,
  rotary table sizing, and the (batch, len) encoder scratch formula
- gate: backend limits and the registered laya-0.3.20 profile
  admitting structures with field-diff errors, plus StructureIdentity
  (sha256 over schema version, family, structure, backend, ABI) for
  future cache keys
- plan: the named-kernel encoder plan (embed, per-layer qkv/rope/
  attn/out/addln/geglu/down, final norm fused into the last layer,
  optional type add) with sequence anchors; symbol resolution stays
  with consuming model crates

Fifteen CPU tests: adapter provenance and rejection matrices for both
sources, invariant failures naming the field, profile admit/reject
with actual-vs-expected diffs, request-envelope bounds, identity
stability and sensitivity, inventory counts for the two known
profiles (Laya 1024/28-layer and the pinned Vela-2.0-0.3B
encoder_config 768/22-layer with yarn factor 4), and plan fixtures
for both schedules. No consumer changes; Laya migrates in the next
step.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The encoder-plus-head plan moves from prepare_encoder into
plan::plan_encoder, a pure function of the original_rope flag that
emits kernel names and buffer roles with no CUDA or weight pointers.
prepare_encoder becomes a resolver that maps each planned step to a
loaded kernel symbol and device pointer, preserving the exact step
sequence.

The full sequence for both rope variants is recorded as golden
fixtures (251 steps: embed, 28 layers with full attention every third
layer, type add, two head layers, and the debug dumps) and pinned by
a CPU test, so any later change to the plan construction has to
survive a byte comparison against today's behavior. No execution
change: same kernels, same order, same arguments.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The native executor consumes the family layer added two commits ago;
behavior is unchanged and every existing suite stays green.

- config: Config::load becomes a facade over the Laya bundle adapter
  and the registered laya-0.3.20 profile, projecting the admitted
  structure onto the public EncoderConfig fields; the agent bundle
  checks stay in the Laya crate. Config carries the admitted structure
  for everything downstream.
- plan: plan_encoder now generates the encoder half from the family
  core (structure-driven layer count, schedule and widths), hooks this
  bundle's debug dumps to the sequence anchors, and appends the
  Laya-owned task-head plan. The recorded golden fixtures still match
  byte for byte, so the executed sequence is provably identical.
- weights: the encoder tensor inventory comes from the family
  geometry; the task head keeps its own inventory (head layers,
  scorer, action head, legacy temperature buffer).
- model: workspace scratch sizes derive from the structure (ids, lens,
  x, y, qkv, o, geglu gate) with the task-side buffers appended; the
  rotary table size check and the vocab bound in infer come from the
  admitted structure instead of literals.
- packing: the vocabulary bound is a pack() argument supplied by the
  processor from the admitted structure; the pad token stays a
  tokenizer constant.

The 1024 hidden width now survives only where it is task geometry
(head ffn widths, scorer and action-head dims) or the task inventory.
The CUDA bundle, its ABI and the storage-dtype policy are untouched.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The family crate gains a structure layer that separates what a
checkpoint declares from what the kernels can run, the qwen-side half
of the model-parameter RFC's phase 5. No gate constant, kernel, or ABI
changes; the accepted structure set is frozen and fixture-proven
identical.

- structure::read_structure parses config.json (root or text_config)
  into QwenHybridStructure with per-field provenance, including the
  source-declared behavior fields the gate pins (hidden_act, output
  gate, attention bias, rope type, conv kernel, mrope interleave);
  parsing judges nothing
- structure::check_abi6 is the frozen kernel capability set as typed
  checks with the original error surface: silu, output gate, no bias,
  default rope, conv kernel 4, head dims 256/128/128, 32 rotary dims,
  interleaved mrope summing to 32, position bounds, head divisibility,
  hidden % 8
- Config::load becomes a facade over adapter plus gate and projects
  the admitted structure onto its unchanged public fields; the new
  Config::from_structure is the seam a consumer with its own bundle
  layout (a Vela hybrid member whose Qwen fields live at
  backbone_config) uses instead of reading a directory
- structure::PrefixLayout derives the per-layer prefix-state byte
  sizes (full-attention K/V rows, GDN float32 [H,K,V] states, conv
  tails) from the structure, CPU-checkable against recorded numbers
- structure::structure_identity digests schema version, family,
  backend, ABI 6 and the canonical structure; prefix-cache records
  must carry it and re-capture on any change

Tests: adapter provenance and broken-source rejections, the frozen
reject matrix (15 single-field violations), the three Vela hybrid
backbone geometries (1024/3584/24, 2560/9216/32, 4096/12288/32)
passing the gate as pure CPU fixtures, the open-jev 27B checkpoint
passing unchanged through the facade, prefix-layout numbers, and
identity stability. The weight-loader dtype/prefix seams for the Vela
consumer stay with that consumer's slice; nothing here changes the
arena or the ABI.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The 0.3B becomes the second ModernBERT profile on the family core,
the CPU-verifiable half of the RFC's phase 3. The checkpoint's own
files are the evidence base throughout.

- config: reads the pinned vela2-unified bundle root and parses its
  encoder_config through the family adapter; foreign roots or encoder
  model types are rejected before any structure exists
- profile: the registered vela-2.0-0.3b structure (768/1152, 22
  layers with full attention every third, 12 heads, both rope thetas
  160000, yarn factor 4 from 8192, vocab 256008, no type embedding,
  32768 positions) against the regenerated-bundle target limits —
  hidden 768, yarn tables, batches to 4, lengths to 8192
- weights: whole-checkpoint accounting against the structure — the
  encoder inventory comes from the family geometry and the 18
  head-side tensors (readout projections, classifier MLP, calibration
  scalars) are recorded from the pinned safetensors header census,
  which is committed as a fixture; missing, extra, shape and dtype
  drift all fail naming both sides. Storage classes mirror the
  serving conventions (embedding f16, norms f32, projections bf16)
- rope: the YaRN inverse frequencies and attention scaling exactly as
  the reference runtime computes them (transformers 5.19.0 yarn
  initialization, f64 internally, narrowed to f32), with the mscale
  baked into the cos/sin tables the way the reference does. A fixture
  dumped from the pinned transformers over the pinned encoder_config
  gates the generator: inverse frequencies to 1e-7, the scaling to
  1e-12, cos/sin to 1e-4 inside the served 8192 window and 5e-4 over
  the full 32768-extension (f32-power ulp noise amplified by
  position; measured, not assumed)

Census equality is asserted against the family geometry: the pinned
checkpoint's 152 tensors are exactly the 134 derived encoder tensors
plus the 18 recorded head tensors, names and shapes matching one for
one. The encoder execution, kernel bundle regeneration and the laya
ABI bump stay fenced until a TileLang toolchain can build the bundle;
no kernel or ABI change is in this commit.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The regenerated bundle serves two profiles of the encoder family in
one library: the existing 1024-hidden Laya kernels under their
unchanged names, and the Vela 2.0 0.3B geometry under _h768-suffixed
symbols (qkv 2304x768, out 768x768, geglu 1152, down 768x1152, addln,
full and sliding attention at 12 heads, rope at 12 heads). The 768
entries carry their own wrapper length bound of 8192 tokens; the
Laya symbols keep their 512 bound exactly, so the existing profile's
acceptance surface does not move.

- model_ops.cu: the embedding LayerNorm becomes a width template with
  1024 and 768 instantiations; the 1024 lowering keeps the pinned
  PyTorch-matching reduction order. laya_embed_h768 joins laya_embed
- export.py: per-entry wrapper guards and the vela instantiation set;
  the GEGLU register patch stays sha-pinned for the Laya shape and
  removes the calls only when the 768 lowering emits them in the same
  accepted shape
- abi_version 2 across laya.backend.json, build.py and export_tables
  (new symbols and a regenerated library); the Rust-side bundle
  validation and artifacts fixtures follow
- omni-cuda: the Rust launch envelope widens to 8192 tokens; the
  per-symbol C guards remain the real capability check

Verified locally without a Hopper device (this machine is sm_120 and
cannot execute sm_90a code): TileLang lowering of all 22 kernels with
the strict lowering checks passing, nvcc sm_90a compilation and
linking of the full library, both embed_norm instantiations present in
SASS, every _h768 symbol exported, the contract checker clean, and
the CPU test suites green. Execution on Hopper and the Laya
bit-identity regression run when the bundle is rebuilt there; the
export must run with TILELANG_DEFAULT_TARGET set to cuda sm_90a on
any non-Hopper host until the in-flight target pinning lands.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The executor (cuda feature) completes the profile slice: it admits
the structure, loads the pinned checkpoint with the whole-file
inventory check, uploads every encoder tensor under the serving
storage classes (embedding f16, norms f32, projections bf16), uploads
the zero-bias buffers and the YaRN cos/sin tables the rope generator
produces, and resolves the family core plan against the bundle's
_h768 symbols with the per-request encoder scratch from the family
geometry. One sequence per call; the final hidden of the last layer
is read from the post-final-norm working buffer in the bundle's bf16
precision, gathered at the caller's requested positions.

A device-gated test runs the encoder end to end only when
VELA_NATIVE_CHECKPOINT and VELA_NATIVE_LIBRARY point at a bundle and
checkpoint on hardware the sm_90a library can execute on; it skips
with a note everywhere else. Parity against the pinned CPU-FP32
reference, with the tolerance anchored to the upstream noise floor,
runs with that same harness on a Hopper host.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The durable record is the code, its tests and the commit messages;
the local planning docs stay out of the repository.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The package gate now refuses any directory carrying importable code,
not just stray .py files, closing the namespace-package shadowing
path into the pinned runtime. compare_reference.py compares the
worker's verbatim /health, /ready, /v1/models and 401 bodies against
the live reference app, runs an eight-case default comparison (the
three recipe examples plus five synthetic rejections), and --export
freezes a passing run's request, response and predict-level answers
with provenance as the oracle fixture for the later native slices.
Worker tests, the recipe docs and the support-matrix row follow.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The family crate keeps only the generic single-object config adapter;
the Laya two-file dialect and its registered laya-0.3.20 profile move
into omni-laya, matching the model-owned loading rule. HF-side keys
the Laya worker never consumed (max_position_embeddings, head_dim)
are recorded as unrecognized instead of silently gated. The vela
crate keeps its registered profile beside its census inventory,
narrows the storage classes so the learned scalars and head biases
stay f32 (rounding them to bf16 would surface as unexplained parity
drift), and shares one pinned config fixture across its tests. Crate
READMEs and the workspace member list follow.

Signed-off-by: Mr.Dong <1042542469@qq.com>
cuda.rs pins its ABI_VERSION to structure::ABI_VERSION at compile
time, so the identity records written from the structure side cannot
silently disagree with the bundle the loader accepts.

Signed-off-by: Mr.Dong <1042542469@qq.com>
Signed-off-by: Mr.Dong <1042542469@qq.com>
The rebase onto model/vela2-reference-serving kept this branch's side of
the divergence (the every-importable-suffix package gate with namespace
directories, and the endpoint-parity comparison); this commit restores
what the reference worker's own review fixes added so nothing from that
head is silently reverted: put_first_on_sys_path returns as the
resolve-based sys.path promotion that drops equivalent entries, the
token_budget executor option comes back, the manifest tests stand in
for the 1.2 GB weights with sparse files again, the forced-to-front
sys.path test returns, and the score example the #151 head added
(four recipe examples, nine default comparison cases) is wired into
the oracle fixture test and the support-matrix row.

Signed-off-by: Mr.Dong <1042542469@qq.com>
A stock HF ModernBERT config may carry its theta only as the generic
rope_theta; the adapter listed that key as consumed but never read it,
so such a config parsed as the 10000.0 default while provenance
claimed a default, and the profile gate then rejected the structure
with a misleading diff. The generic key now fills both kinds when the
per-kind key is absent, with source provenance naming rope_theta; the
per-kind keys keep precedence.

Signed-off-by: Mr.Dong <1042542469@qq.com>
The executor mapped the Types scratch slot onto the token-id buffer.
No admitted profile emits the type step today (the 0.3B profile pins
type_embedding_rows to None), but a future type-carrying member on
this executor would have silently fed token ids where type ids
belong; the slot now fails loudly as a plan/profile mismatch.

Signed-off-by: Mr.Dong <1042542469@qq.com>
Main moved the qwen3_5 CUDA ABI 6->8 with the JEMM stack: take main's
ABI_VERSION and follow it on the structure side (ABI_VERSION 8,
check_abi6 -> check_abi), keeping the compile-time binding between the
loader and the identity records. Workspace members, qwen3_5 deps and
test targets are unions of both sides; nothing else is touched.
Main moved the qwen3_5 CUDA ABI 8->9 with the fixed-algorithm GEMM
handle: take main's ABI_VERSION and follow it on the structure side
(ABI_VERSION 9), keeping the compile-time binding between the loader
and the identity records. A pure version re-pin: the checked
capability set is unchanged, so the gate admits and rejects exactly
what it did at ABI 8. Identity digests change with the recorded
abi_version, so prefix-cache records are re-captured, per the
identity contract. Nothing else is touched.
Main advanced 216 commits with the pplx-decider reference worker, the
StartLux Instant 4B native worker, the OmniJev native worker, D3 media
state and more. Conflict resolution:

- Cargo.toml and Cargo.lock: union of the workspace members and package
  entries; keep this branch's omni-modernbert and omni-vela-native and
  take main's omni-startlux-native.
- README.md, docs/supported-models.md, recipe/README.md, mkdocs.yml:
  take main's refreshed OmniJev-4B and D3 rows and the new
  pplx-decider and StartLux entries, keep this branch's Vela 2.0 0.3B
  entries untouched.
- src/models/qwen3_5/native/src/model.rs (the one edit beyond the
  automatic merge): main's GDN/FP32 parameter code calls bail!, so the
  anyhow import takes main's spelling (Context, Result, bail, ensure).

Verified at the merge head on this host (cargo 1.98.1, CUDA 13.1
toolchain, Python 3.12.3): cargo fmt --all --check, cargo clippy
--workspace --locked --all-targets --features omni-laya/serve
-- -D warnings, cargo test --workspace --locked --features
omni-laya/serve (405 passed, 0 failed), PYTHONPATH=src pytest
tests/vela (122 passed), PYTHONPATH=. pytest tests/benchmarks
(103 passed; 65 of them predate this merge, the rest arrive from
main), recipe/vela/test_compare_reference.py ok, mkdocs build
--strict ok.
Resolve the overlap with the landed Vela rows and the Clef reference
worker. README.md, docs/supported-models.md, mkdocs.yml and
recipe/README.md keep main's tables and entry lists. engine.py,
test_engine_manifest.py and the gate wording in the Vela docs take
main's reviewed package gate (sourceless-package bypass, bearer crash,
directory symlinks). compare_reference.py keeps the endpoint-parity
comparison on main's bytecode-window variable name.
Third main sync for this branch, resolved per file against merge-base
05075d0 and disclosed here:

- Cargo.toml: union of the workspace members; this branch adds
  modernbert and vela/native, main adds clef/native.
- src/models/qwen3_5/native/src/lib.rs: union of the module lists;
  this branch adds structure, main adds prefix and prefix_cache.
- recipe/vela/compare_reference.py: main's member-agnostic refactor
  (served member detection, oracle-hybrid prefix, model rewriting)
  combined with this branch's endpoint parity and oracle provenance;
  the probe body and the oracle source now record the served member.
- src/models/vela/postprocess.py: both sides' finishing checks; this
  branch's per-kind answer field validation plus main's hybrid
  span_heads validation behind the hybrid flag.
- src/models/vela/README.md: main's two-member tables and intro with
  this branch's ModernBERT native route paragraph; the requirements
  link keeps the working ../../../ path.
- recipe/vela/reference.md and test_compare_reference.py: main's
  wording with this branch's provenance and out-of-scope updates.

The follow-up commit restores the file-less runtime module guard the
previous merge dropped; nothing else in this branch's own series
changed.
Merge b023c7f silently took main's unguarded form of
verify_no_foreign_runtime: a runtime module whose __file__ is None
(a namespace package or a builtin) crashed the gate with a TypeError
from Path(None) instead of the designed ValueError refusal. This
restores the branch's reviewed guard from 0139cb1 and its
dedicated test, test_a_runtime_module_without_a_file_is_refused.

PYTHONPATH=src pytest tests/vela (157 passed) at this head.
Preserve the original #152 series and main ancestry. Resolve the sole Cargo.toml conflict by retaining ModernBERT, Vela 0.3B and Kev workspace members. Cargo.lock and all other files use Git auto-merge; Qwen ABI remains 9. No new numerical or device changes.
A CPU loader regression test on the synced #152 tree reproduced a division-by-zero panic for num_attention_heads=0 without head_dim. Return a field-specific error before division; cover the 1024 family and Vela 0.3B HF layouts with derived and explicit head dimensions. Preserve all positive-profile geometry and numerical assertions.
Preserve decoder omni-vela-native/path and the renamed encoder carrier with one shared omni-modernbert core. Root manifest and lock retain both dependency sets. Resolve only four remaining registration/documentation conflicts; all numerical/backend/runtime files retain automatic merge results. Preserve #207, #213/#210, #195/#177, #208/#205 and main ancestry.

@hsliuustc0106 hsliuustc0106 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Review draft — #215 "models(vela): integrate encoder and decoder native carriers"

Verdict: COMMENTED. The PR is OPEN and explicitly DRAFT; first review of a draft integration, not approval, not device qualification, and not a completed validation. Contributor checklist left unchecked, correctly.

Provenance and pins

  • This PR is not part of the OmniJev stack. GitHub metadata and git ancestry agree: base branch codex/vela152-coexist-base @ 422e74f8b3030d5cf766cf3ce4ee281d44691d58 (matches baseRefOid), head 6e1584a3928e58722bac61175114ae859f89b6b9 in InferMatrixLab/system1-omni (branch codex/vela152-coexist-20261120). git merge-base origin/pr/212 origin/pr/215 is f1e674f2 (#204): none of 209/211/212 is an ancestor of #215. The four-PR "superset" framing does not hold; this is a separate Vela family. The body itself pins the true base ("Stacked base: delivered decoder 422e74f8") and head — those pins verified, including tree f839cf0965141c014ec7c28f6c8d1ea0720b2e9e via git rev-parse 6e1584a39^{tree}.
  • Diff against its true base: 75 files, +7661/−538 = 8199 — matches GitHub and the body exactly. The relevant diff for review is 422e74f8..6e1584a39 (not the merge-base with main).
  • Own-series commits (first-parent from base, three total): 1c9e4cc5 "refactor(vela): give the ModernBERT encoder its own carrier" (the delivered encoder rename, authored by psv666 as part of the #207 input), merge 10d94f6a "merge: integrate delivered Vela encoder and decoder carriers" (the integration commit), then docs 92983594 and 6e1584a3. Inherited history beneath 1c9e4cc5 is the delivered #152/#207/#213/#210/#195/#177/#208/#205 work (Mr.Dong commits verified in the ancestry).
  • Main pointer: main @ f1e674f2 is an ancestor of both base and head; canonical main tip (614b0abc, #214) is not in this branch — the body's "Retarget and revalidate after the underlying stacks land" is required.

Merge hygiene (integration commit) — verified by simulation

  • Before claim verified exactly: git merge-tree --write-tree 422e74f8 a11335ae (pre-rename encoder head) produces exactly the seven claimed conflicting paths: Cargo.lock, Cargo.toml, recipe/vela/reference.md, src/models/vela/README.md, plus add/add in src/models/vela/native/Cargo.toml, src/executor.rs, src/lib.rs.
  • After claim verified: with the rename applied (422e74f8 + 1c9e4cc5), exactly four content conflicts remain (Cargo.lock, Cargo.toml, recipe/vela/reference.md, src/models/vela/README.md) — matching "Only four registration/documentation conflicts remain".
  • The actual merge tree a6c9d063 differs from the simulated auto-merge tree ff2cc43b in exactly those four files; no conflict markers anywhere in the merged tree (git grep '<<<<<<<'). The Cargo.toml resolution retains both dependency sets (adds src/models/modernbert and src/models/vela/encoder_native members while keeping src/models/vela/native). The body's "two root files and five necessary Markdown files" reconciles as 2 root resolutions + 5 hand-touched markdown (2 resolved in the merge + 3 authored by 92983594/6e1584a3: recipe/vela/native.md, encoder_native/README.md, modernbert/README.md); the strict final-vs-auto-merge comparison is 4 files. Recorded as verified-with-interpretation; no content concern.
  • 1c9e4cc5 is a pure mechanical carrier move: 15 files, 9+/9− (renames src/models/vela/native → src/models/vela/encoder_native with identical payload plus the four test import substitutions) — matches "newly authored source edits are four import substitutions".

Template gates and large-change accounting

  • Four contributor answers + necessity present; draft state explicit ("CPU carrier coexistence only"; "the workflows filter PR bases to main").
  • Checklist: unchecked, correct.
  • Large-change contract (>3,000 authored changed lines ⇒ full self-review, split rationale, component map/review order, per-area validation): satisfied in the body — component map (crate diagram), five-step review order, per-component validation table, explicit unresolved-risk disclosure (the workspace concurrency timeout), and honest authored-vs-total accounting (8,199 total; 5,413 source/test changed lines excluding manifests/lock/docs/static fixtures — consistent with the numstat mix I computed: src/models +3113/−463, tests +4296/−24, recipe +157/−19, src/backends +56/−27, frontend +9/−3, root/lock +30/−1). Provenance note: the CONTRIBUTING "Large code changes" section exists at the local checkout used for skill loading (ca5f69b5) but not at canonical main's CONTRIBUTING; the requirement itself is in .agents/skills/self-review/SKILL.md at main, which the body satisfies. Split rationale (integration must be atomic to resolve the registration/API collision) is stated and plausible.

Contracts

  • ABI impact: src/backends/cuda/qwen3_5/ops.h is not touched — the qwen3_5 ABI-9 surface is untouched, as expected. The Laya backend: model_ops.cu templates embed_norm on hidden width (existing 1024 instantiation bit-identical: same loop bounds, float(D) exact for 1024; new additive laya_embed_h768); tools/export.py adds *_h768 symbols (suffix-isolated, both profiles coexist in one library) and defaults new wrappers via l_max while the original geglu keeps its exact SHA-256 pin (patch_geglu_static_registers(pinned=…) fails closed on unexpected register-call counts for the new kernel). Two compatibility consequences, deliberate but load-bearing: (1) laya.backend.json/build-manifest abi 1 → 2, enforced by validate_bundle (src/models/laya/src/artifacts.rs:35-44 requires tables["abi"] == 2 && build["abi"] == 2 && arch == "sm_90a") — every existing exported Laya bundle must be regenerated; (2) the shared launch guard in src/backends/cuda/src/lib.rs widens l ≤ 512 → l ≤ 8192 (per-symbol wrappers retain 512 by default; only _h768 wrappers accept 8192). P3 finding (trigger: loading an abi-1 bundle or an un-regenerated deployment; consequence: hard "unsupported CUDA bundle" rejection — fail-closed, experimental status mitigates): regeneration must be called out in the landing notes of whatever PR carries this to main.
  • Carrier ownership vs architecture contract: matches the contract's split. omni-modernbert owns the family structure/geometry/gate/plan (pure, CPU-side); omni-vela-encoder-native owns the pinned vela-2.0-0.3b profile (structure cross-checked against the recorded tensor census; BackendLimits hidden 768 / len ≤ 8192 / abi 2) and the plan→*_h768 symbol mapping; omni-laya/shared CUDA supplies device ops only; omni-vela-native (decoder) keeps its package/path/API unchanged; src/frontend/vela.py change is a byte-identical constant extraction. Model-specific processors preserve semantics; CUDA supplies device ops — no ownership violations found in the diff.
  • Registration: root Cargo.toml adds both members (verified); README.md component table updated; carrier entry points documented (92983594, 6e1584a3); docs/supported-models.md is unchanged by this PR (the base already carries the Vela rows, and the 0.3B row still claims CPU-FP32-only validation — consistent with "no model support claim in this PR"); mkdocs.yml needed no new nav entries — mkdocs build --strict passes locally at this exact head (verified below).

Local validation (commands personally run in a worktree at origin/pr/215, since removed)

With /Users/hsliu/miniconda3/bin/python (3.12.8, pytest 8.4.1, mkdocs 1.6.1; no cargo/GPU):

  • PYTHONPATH=. python -m pytest tests/benchmarks -q → 133 passed in 28.1s.
  • PYTHONPATH=src python -m pytest tests/vela -q → 190 passed in 9.8s (matches the body's "Vela Python 190 passed").
  • python -m pytest tests/omnijev -q → no Python tests collected in tests/omnijev (Rust-only suite; the weight-free OmniJev checks are cargo test -p omni-omnijev-native, blocked by no cargo here — the OmniJev stack is also not part of this PR).
  • python -m mkdocs build --strict → exit 0 (INFO-only nav listings).
  • These reproduce the body's Python/docs rows at the exact head/tree. The Rust rows (component suites, clippy, release build, workspace run incl. the disclosed 10s concurrency failure + serialized follow-up) are author-reported.

Artifact hygiene

  • No binaries and no non-source files in the PR diff (numstat scan). All five committed data fixtures are maintained test inputs with consumers at this head: tests/vela/native/data/yarn-reference.json → tests/vela/native/rope.rs; pinned-checkpoint-census.json → tests/vela/native/weights.rs; vela-config.json → tests/vela/native/common/mod.rs; tests/laya/data/encoder-plan.txt and encoder-plan-original-rope.txt → tests/laya/plan.rs (the "two byte-equal golden plans"). No run dumps committed; the evidence bundle (vela152-coexist-evidence.tar.gz, SHA256 56b334e8…) is off-repository.
  • Note for the landing sequence (not a defect of this diff): the base branch codex/vela152-coexist-base itself carries multi-MB binary fixtures outside this PR (e.g., tests/vela/fixtures/head-input-Vela-2.0-0.8B-long-span-windowed.safetensors ≈ 15.2 MB, head-input-Vela-2.0-9B-… ≈ 8.0 MB, plus 4B/9B oracle JSON), which enter main with the decoder PR, not this one. Their hygiene review belongs to the base stack's PRs; the body's instruction to "confirm decoder files/tests/fixtures remain exactly #213" is the right mechanism.

Evidence provenance

  • Source inspected: full 75-file diff 422e74f8..6e1584a39; the three own commits in depth; merge simulation both with and without the rename; model_ops.cu, lib.rs, build.py, export.py, artifacts.rs, encoder_native/profile.rs, frontend/vela.py, root Cargo.toml, mkdocs nav, supported-models rows.
  • Commands run (personally): ancestry/merge-base checks; merge-tree simulations (before/after); conflict-marker scan; diff/numstat accounting; fixture-consumer mapping; the four local validation runs above; worktree added and removed.
  • Observed CI (both repo hostnames — they are the same renamed repository — and psv666/system1-omni, exact head_sha 6e1584a39…): 0 runs anywhere. Both ci.yml and docs.yml filter pull_request: branches: [main], and this PR's base is codex/vela152-coexist-base; the body discloses this. Consequence: for #215 there is no observed CI at all; every check row in its body is author-reported.
  • Author-reported: the entire Test Result table (component suites 210/79, encoder cuda-feature run, contracts, Laya golden plans, decoder cap 9+9, workspace 550-pass serialized follow-up after the disclosed concurrency failure, benchmark 133+185, CUDA contract, 38-link docs check), the 97 byte/import checks, the 255-registry-record retention, and the off-repo evidence bundle contents.

Findings summary

  • P3 — Laya bundle ABI 1→2 invalidates existing bundles (src/backends/cuda/laya.backend.json, tools/build.py, enforced by src/models/laya/src/artifacts.rs:35-44). Trigger: any deployment loading a previously exported abi-1 bundle after this lands. Consequence: hard rejection with "unsupported CUDA bundle"; regeneration required. Fail-closed and consistent with experimental status; must be stated in landing/release notes.
  • P3 — zero CI at head; head sits on an unmerged base branch. Trigger: attempting to merge or evaluating readiness today. Consequence: no independent CI signal; the inherited 7.4k lines are only covered by author-reported runs and the delivered branches' own (separate) review evidence. The body discloses both; the landing sequence must retarget to a main-based branch and revalidate.
  • Informational: shared launch-guard widening (lib.rs 512→8192) is intentional and per-symbol guarded; validate_bundle still pins hidden_size == 1024/max_len == 512 for the original Laya path while the 768 profile validates through omni-modernbert gate limits — two validation paths, each self-consistent; the disclosed unresolved concurrency-test risk (stats_and_prefix_publication_finish_concurrently 10s timeout, one serialized pass) remains unclassified and is inherited, not authored here.

Unverified checks / evidence gaps

  • No cargo/GPU here: all Rust suites, the CUDA contract checker, and every device claim are author-reported; the encoder remains sm_90a-only and untested on any GPU in this review. Prior GPU evidence stays pinned to #177/#210/#213 per the body — correctly not claimed as current-head qualification.
  • The delivered branches' own review records (#152/#207/#213/#210/#195/#177/#208/#205) were not re-reviewed here; this review covers the integration deltas, merge hygiene, ownership, registration, and the CPU-reproducible rows.

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants