freesolo-flash-dev 1.2.70__tar.gz → 1.2.87__tar.gz

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/Dockerfile.worker

@@ -59,15 +59,15 @@ RUN pip install --no-cache-dir \
     "wandb>=0.17" \
     "flash-linear-attention @ git+https://github.com/fla-org/flash-linear-attention.git@9c8e42e762fce087c27b673af4922795d9edb85e" \
     "flash-qla==0.1.2" \
-    "tilelang==0.1.11" \
-    "apache-tvm-ffi==0.1.11" \
+    "tilelang==0.1.9" \
+    "apache-tvm-ffi==0.1.9" \
     "hf_transfer" \
     "freesolo>=0.4.1" \
     "runpod"
 # Gated-DeltaNet (Qwen3.5/3.6) runs on flash-linear-attention's Triton kernels. On consumer cards
 # (Ampere/Ada/Blackwell) the Triton path is correct. On Hopper (sm90) fla's GDN chunk_bwd is
 # miscomputed with Triton>=3.4 (fla #640) — the fix is fla's TILELANG backend (correct there), so
-# we bake the pinned tilelang==0.1.11 + apache-tvm-ffi==0.1.11 (0.1.12 double-registers TVM-FFI ->
+# we bake the pinned tilelang==0.1.9 + apache-tvm-ffi==0.1.9 (0.1.12 double-registers TVM-FFI ->
 # `import tilelang` aborts) and KEEP fla on every arch; flash.engine.worker.perf._ensure_fla_fastpath_on_hopper
 # ensures the tilelang backend is live on sm90 before any model import. The INVERSE holds on
 # B200/sm100: THERE the tilelang chunk_bwd_dqkwg miscomputes gradients while the Triton path is
@@ -79,6 +79,13 @@ RUN pip install --no-cache-dir \
 # seq16384 12.6x / 1.9x, loss matches to 1.8e-4. fla is from git: the PyPI wheel is a broken stub
 # (no fla.modules). The git URL is PINNED to a commit (not the moving default branch) for
 # reproducible image builds; keep this sha in lockstep with the worker dependencies in flash/providers/_lifecycle/worker.py.
+# tilelang is 0.1.9, not the newest release: flash-qla (added for the sm90 GDN backend) hard-requires
+# tilelang==0.1.9 AND apache-tvm-ffi==0.1.9, so 0.1.11 made this layer unsatisfiable and every image
+# build failed from 2026-08-12 until the downgrade. 0.1.11 was only ever "latest stable at the time"
+# (the pin exists for determinism, not to dodge a 0.1.9 defect), and the version predates flash-qla.
+# Keep all four sites in lockstep -- both installs here, capabilities.py, and perf's TILELANG_PIN --
+# because perf fails CLOSED: a resolved version != TILELANG_PIN deletes fla and drops sm90 to the
+# pure-PyTorch fallback, which is correct but far slower.
 
 # FlashAttention: PREFER a prebuilt wheel. There is no OFFICIAL Dao-AILab wheel for torch 2.10 yet,
 # but community CI publishes matching wheels (cu128/torch2.10/cp312); CI passes one as FLASH_ATTN_SPEC
@@ -334,8 +341,8 @@ RUN printf '%s\n' "numpy==2.2.6" "xgrammar==0.1.25" "vllm==0.19.1" "transformers
         cachetools uvicorn fastapi torchvision tqdm pyarrow \
         "flash-linear-attention @ git+https://github.com/fla-org/flash-linear-attention.git@9c8e42e762fce087c27b673af4922795d9edb85e" \
         "flash-qla==0.1.2" \
-        "tilelang==0.1.11" \
-        "apache-tvm-ffi==0.1.11" \
+        "tilelang==0.1.9" \
+        "apache-tvm-ffi==0.1.9" \
     && rm -f /tmp/verl-overrides.txt \
     && uv cache clean
 

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.70
+Version: 1.2.87
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/adapters/fused_experts.py

@@ -14,6 +14,8 @@ from flash.adapters.lora_rank import (
 )
 from flash.core.catalog import get_model
 
+_LORA_FACTOR_PATTERN = re.compile(r"\.lora_[AB]\.")
+_LORA_PARAMETER = "weight"
 _QWEN36_MODEL_ID = "Qwen/Qwen3.6-35B-A3B"
 _QWEN36_EXPERT_TARGET_PARAMETERS = (
     "mlp.experts.gate_up_proj",
@@ -31,7 +33,7 @@ _FUSED_EXPERT_SYNTHETIC_MODULES = frozenset({"experts", "base_layer"})
 _FUSED_EXPERT_WRAPPER_MODULES = ("mlp.experts", "mlp.experts.base_layer")
 _INVALID_FUSED_LOCATION = object()
 
-_LoraTensor = tuple[str, str, str, str, tuple[int, ...]]
+_LoraTensor = tuple[str, str, str, tuple[int, ...]]
 _LoraPair = tuple[tuple[int, ...], tuple[int, ...]]
 
 
@@ -166,12 +168,13 @@ def has_complete_fused_expert_tensors(
     expected = _expected_fused_expert_rungs(config, model_id)
     if expected is None:
         return False
+    lora_keys = {key: shape for key, shape in tensors.items() if _LORA_FACTOR_PATTERN.search(key)}
     parsed = [
         tensor
-        for key, shape in tensors.items()
+        for key, shape in lora_keys.items()
         if (tensor := _parse_lora_tensor(key, shape)) is not None
     ]
-    if len({adapter_name for _, _, adapter_name, _, _ in parsed}) != 1:
+    if len(parsed) != len(lora_keys):
         return False
     return _has_complete_fused_rungs(parsed, expected, model_id) and _has_ordinary_evidence(
         parsed, config, expected
@@ -179,7 +182,17 @@ def has_complete_fused_expert_tensors(
 
 
 def _parse_lora_tensor(key: str, shape: tuple[int, ...]) -> _LoraTensor | None:
-    """Parse one canonical PEFT LoRA tensor key."""
+    """Parse one canonical PEFT LoRA tensor key.
+
+    Accept exactly the grammar PEFT writes: a bare ``lora_A.weight`` leaf with no adapter
+    namespace. ``get_peft_model_state_dict`` documents stripping the namespace on save, verl's
+    merger reproduces that strip, and ``_insert_adapter_name_into_state_dict`` re-inserts it on
+    load, so the stripped form is the only spelling that round-trips. Verified against peft 0.19.1:
+    ``...lora_A.weight`` loads as ``...lora_A.default.weight`` and matches the live module, while a
+    file that already carries the namespace loads as ``...lora_A.default.default.weight`` and
+    matches nothing. Since one grammar is accepted, the adapter namespace is no longer part of the
+    parsed identity.
+    """
     matches = [
         (factor, infix) for factor, infix in (("A", ".lora_A."), ("B", ".lora_B.")) if infix in key
     ]
@@ -187,13 +200,9 @@ def _parse_lora_tensor(key: str, shape: tuple[int, ...]) -> _LoraTensor | None:
         return None
     factor, infix = matches[0]
     module_path, _, leaf = key.partition(infix)
-    leaf_parts = leaf.split(".")
-    if not module_path or len(leaf_parts) != 2:
+    if not module_path or module_path.endswith(".") or leaf != _LORA_PARAMETER:
         return None
-    adapter_name, parameter = leaf_parts
-    if not adapter_name or parameter != "weight":
-        return None
-    return module_path, factor, adapter_name, key, shape
+    return module_path, factor, key, shape
 
 
 def _expected_fused_expert_rungs(
@@ -237,31 +246,25 @@ def _expected_fused_expert_rungs(
 def _has_complete_fused_rungs(
     tensors: list[_LoraTensor], expected: Mapping[str, Mapping[str, _LoraPair]], model_id: str
 ) -> bool:
-    """Validate every concrete fused owner, rung, namespace, and factor shape."""
+    """Validate every concrete fused owner, rung, and factor shape."""
     model = get_model(model_id)
     for owner, expected_rungs in expected.items():
-        factors: dict[str, dict[str, dict[str, dict[str, tuple[int, ...]]]]] = {}
-        for module_path, factor, adapter_name, _key, shape in tensors:
+        factors: dict[str, dict[str, dict[str, tuple[int, ...]]]] = {}
+        for module_path, factor, _key, shape in tensors:
             location = _fused_tensor_location(module_path, owner, frozenset(expected_rungs))
             if location is _INVALID_FUSED_LOCATION:
                 return False
             if location is None:
                 continue
             instance, rung = location
-            factors.setdefault(instance, {}).setdefault(rung, {}).setdefault(adapter_name, {})[
-                factor
-            ] = shape
+            factors.setdefault(instance, {}).setdefault(rung, {})[factor] = shape
         if not factors:
             return False
         for seen_rungs in factors.values():
             if set(seen_rungs) != set(expected_rungs):
                 return False
             for rung, expected_pair in expected_rungs.items():
-                namespaces = seen_rungs[rung]
-                if len(namespaces) != 1:
-                    return False
-                seen_factors = next(iter(namespaces.values()))
-                if _lora_pair_shapes(seen_factors) != expected_pair:
+                if _lora_pair_shapes(seen_rungs[rung]) != expected_pair:
                     return False
         expert_layers = {
             prefix
@@ -303,28 +306,27 @@ def _has_ordinary_evidence(
     config: Mapping[str, Any],
     fused_rungs: Mapping[str, Mapping[str, _LoraPair]],
 ) -> bool:
-    """Validate concrete ordinary target evidence with per-module ranks and namespaces."""
+    """Validate concrete ordinary target evidence with per-module ranks."""
     modules = config.get("target_modules")
     all_linear = modules == "all-linear"
     targets = () if all_linear else tuple(modules) if isinstance(modules, list) else ()
-    groups: dict[str, dict[str, dict[str, tuple[str, tuple[int, ...]]]]] = {}
+    groups: dict[str, dict[str, tuple[str, tuple[int, ...]]]] = {}
     evidence: set[str] = set()
-    for module_path, factor, adapter_name, key, shape in tensors:
+    for module_path, factor, key, shape in tensors:
         if _is_fused_rung(module_path, fused_rungs):
             continue
         matched = tuple(target for target in targets if _anchored_suffix_match(module_path, target))
         if not all_linear and not matched:
             continue
         evidence.update(matched)
-        groups.setdefault(module_path, {}).setdefault(adapter_name, {})[factor] = (key, shape)
+        groups.setdefault(module_path, {})[factor] = (key, shape)
     if not groups or (not all_linear and evidence != set(targets)):
         return False
 
     declared = declared_lora_ranks(config)
-    for module_path, namespaces in groups.items():
-        if len(namespaces) != 1 or _rank_for_module(module_path, declared) is None:
+    for module_path, factors in groups.items():
+        if _rank_for_module(module_path, declared) is None:
             return False
-        factors = next(iter(namespaces.values()))
         if set(factors) != {"A", "B"}:
             return False
         for key, shape in factors.values():

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/engine/plan/vram.py

@@ -249,10 +249,31 @@ def grpo_kv_floor_gb(
     return upper
 
 
+def _rollout_stays_resident(model_info, model_id: str = "") -> bool:
+    """True when the rollout engine is pinned resident and never sleeps.
+
+    Named for the property sizing actually depends on rather than the catalog flag that currently
+    implies it: ``sleep_unsupported`` records that a model HANGS on wake, and
+    ``rollout_resident_overrides`` turns that into ``free_cache_engine=false``. Sizing cares only
+    about the second fact, so it reads through this predicate -- the worker gate
+    (``rollout_fp8_kv``) answers the same question, and the two must not drift.
+    """
+    if getattr(model_info, "sleep_unsupported", False):
+        return True
+    if not model_id:
+        return False
+    from flash.core.catalog import MODELS
+
+    info = MODELS.get(model_id)
+    return bool(info is not None and getattr(info, "sleep_unsupported", False))
+
+
 def _declares_linear_attention(model_info, model_id: str = "") -> bool:
     """True for a GDN hybrid, using the catalog rather than a network config fetch.
 
-    GDN workers reject fp8 KV, so sizing must not apply that discount. Fall back to catalog lookup
+    A GDN worker rejects fp8 KV only when its rollout engine sleeps, because the crash is vllm's
+    ``init_fp8_kv_scales`` on wake; a model the catalog pins resident keeps fp8. Callers that size a
+    KV pool must therefore pair this with ``_rollout_stays_resident``. Fall back to catalog lookup
     by model id for pinned revisions because attention family is revision-independent.
     """
     if int(getattr(model_info, "num_linear_attention_layers", 0) or 0) > 0:
@@ -661,7 +682,12 @@ def _opd_fp8_adjust(
     """Re-size an OPD requirement with fp8 KV on modern cards when sufficient."""
     from flash.providers.base import max_non_fp8_kv_vram_gb
 
-    if _declares_linear_attention(model_info, model_id):
+    # a gdn hybrid keeps the bf16 reservation only while its engine sleeps. once the catalog pins
+    # it resident the worker sends fp8 (rollout_fp8_kv), so sizing must price the same cache or it
+    # reserves a full-width pool nobody allocates.
+    if _declares_linear_attention(model_info, model_id) and not _rollout_stays_resident(
+        model_info, model_id
+    ):
         return need
     ceiling = max_non_fp8_kv_vram_gb()
     if need <= ceiling:

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/engine/worker/backend_common.py

@@ -935,6 +935,7 @@ from flash.engine.worker.verl.capabilities import (  # noqa: E402,F401
     resolve_rollout_enforce_eager,
     resolve_verl_loggers,
     resolve_verl_python,
+    rollout_fp8_kv,
     rollout_mm_processor_cache_overrides,
     rollout_resident_overrides,
     rollout_sleep_unsupported,

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/engine/worker/opd_train.py

@@ -35,6 +35,7 @@ from flash.engine.worker.backend_common import (  # noqa: F401
     resolve_rollout_enforce_eager,
     resolve_verl_loggers,
     resolve_verl_python,
+    rollout_fp8_kv,
     rollout_sleep_unsupported,
     run_verl_training,
     shim_marker_file,
@@ -321,7 +322,7 @@ def run_opd_train(spec=None) -> None:
         gdn_module = gdn_probe_module(model_id, model_revision) if gdn_hybrid else ""
         # ONE child answers every independent capability question. each used to cost its own interpreter, and the torch/verl import -- not the question -- was the price.
         caps = probe_verl_capabilities(python_bin, gdn_module)
-    # enable fp8 kv on cc >= 8.9 only for non-gdn models; gdn sleep/wake crashes on hybrid caches. keep this aligned with vram.py, and keep the device probe separate from gdn classification.
+    # enable fp8 kv on cc >= 8.9. a gdn hybrid qualifies only when the catalog pins its rollout engine resident: it is sleep/WAKE that crashes on the hybrid cache, not gdn itself. see rollout_fp8_kv. keep this aligned with vram.py, and keep the device probe separate from gdn classification.
     try:
         import torch as _torch_cc
 
@@ -330,7 +331,7 @@ def run_opd_train(spec=None) -> None:
         )
     except Exception:  # no cuda / probe failure -> conservative bf16 kv
         _cc_ok = False
-    fp8_kv = _cc_ok and not gdn_hybrid
+    fp8_kv = rollout_fp8_kv(_cc_ok, gdn_hybrid, model_id)
     # gdn packing requires child support for seq_idx and cu_seqlens; fallbacks discard both and silently bleed state across examples. record whether the child can reset gdn state because successful runs upload no console and failure here is silent contamination; none means non-gdn. see require_gdn_boundary_resets.
     gdn_reset_arch = require_gdn_boundary_resets(caps, gdn_module)
     # run sm86 eagerly because vllm 0.19.1 graph capture degenerates there. sm89 capture is empirically acceptable; enforce_eager overrides async cudagraph settings last at config/vllm.py:1024.

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/engine/worker/perf/__init__.py

@@ -315,9 +315,10 @@ def _ensure_fla_fastpath_on_hopper() -> None:
             return False
         return rc == 0
 
-    # 0.1.12 double-registers the TVM-FFI runtime -> `import tilelang` aborts; keep in lockstep with Dockerfile.worker.
-    TVM_FFI_PIN = "0.1.11"
-    TILELANG_PIN = "0.1.11"
+    # flash-qla requires exactly these two, and 0.1.12 double-registers the TVM-FFI runtime ->
+    # `import tilelang` aborts; keep in lockstep with Dockerfile.worker and capabilities.py.
+    TVM_FFI_PIN = "0.1.9"
+    TILELANG_PIN = "0.1.9"
 
     try:
         tilelang_ok = True

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/engine/worker/rl_train.py

@@ -41,6 +41,7 @@ from flash.engine.worker.backend_common import (  # noqa: F401
     resolve_rollout_enforce_eager,
     resolve_verl_loggers,
     resolve_verl_python,
+    rollout_fp8_kv,
     stamp_adapter_dir_provenance,
     verl_declares_rollout_field,
     verl_device_capability,
@@ -266,8 +267,10 @@ def _configure_rl_child(
         gdn_reset_arch=gdn_reset_arch,
         loggers=loggers,
     )
-    # reuse the gdn answer resolved above rather than re-probing; see gdn_hybrid.
-    fp8_kv = cc_ok and not gdn_hybrid
+    # reuse the gdn answer resolved above rather than re-probing; see gdn_hybrid. a gdn hybrid keeps
+    # fp8 only when the catalog pins its engine resident -- see rollout_fp8_kv for why sleep is the
+    # thing that actually crashes, not gdn.
+    fp8_kv = rollout_fp8_kv(cc_ok, gdn_hybrid, inp["model_id"])
     # one capability probe, both rollout decisions below. asked of the verl interpreter, whose
     # torch/vllm stack is the one that has to run the rollout.
     verl_cc = verl_device_capability(caps)

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/flash/engine/worker/verl/capabilities.py

@@ -479,15 +479,15 @@ def resolve_verl_python(workdir: str, *, install_wandb: bool = False) -> str:
                 # binds chunk_gated_delta_rule to the pure-torch fallback that
                 # takes **kwargs and discards cu_seqlens, and packed gdn runs
                 # train across example boundaries while looking patched.
-                # apache-tvm-ffi is pinned to 0.1.11 because 0.1.12
-                # double-registers TVM-FFI and aborts `import tilelang`.
+                # apache-tvm-ffi is pinned to 0.1.9 because flash-qla requires exactly that, and
+                # 0.1.12 double-registers TVM-FFI and aborts `import tilelang`.
                 FLA_REQUIREMENT,
                 # the flashqla GDN backend fla 0.5.2 dispatches to. same lockstep requirement:
                 # the shim binds it in THIS interpreter, so a wheel present only in the worker's
                 # env would leave the child on the old kernel while the marker still printed.
                 FLASH_QLA_REQUIREMENT,
-                "tilelang==0.1.11",
-                "apache-tvm-ffi==0.1.11",
+                "tilelang==0.1.9",
+                "apache-tvm-ffi==0.1.9",
             ],
             check=True,
         )
@@ -742,6 +742,37 @@ def rollout_sleep_unsupported(model_id: str) -> bool:
     return bool(info is not None and getattr(info, "sleep_unsupported", False))
 
 
+def rollout_fp8_kv(cc_ok: bool, gdn_hybrid: bool, model_id: str) -> bool:
+    """whether the rollout engine may cache KV in fp8. shared by grpo and opd.
+
+    ``cc_ok`` (cc>=8.9) is the hardware floor. the gdn exclusion on top of it is narrower than it
+    looks: the crash it avoids is vllm's ``init_fp8_kv_scales``, which zeroes each cache tensor and
+    hits ``'list' object has no attribute 'zero_'`` on a hybrid cache. that function is reachable
+    from exactly ONE place -- ``gpu_worker.wake_up`` (``v1/worker/gpu_worker.py:198-203``) -- and
+    verl only ever wakes an engine it put to sleep: both training-path callers are gated on
+    ``rollout.free_cache_engine`` (``engine_workers.py:706,741`` -> ``vllm_rollout.py:161``). a model
+    the catalog flags ``sleep_unsupported`` runs with that flag pinned false by
+    ``rollout_resident_overrides``, so it never sleeps, never wakes, and never reaches the crash.
+
+    the resident engine still gets fp8 for its ordinary attention layers: the recurrent state is a
+    separate ``MambaSpec`` carrying its own dtypes, so fp8 never applies to it. vram sizing already
+    prices this exact combination -- ``mamba_block_size=1072`` is the fp8-derived attention-token
+    page (the 1,097,728-byte gdn state over a 1024-byte fp8 attention token, rounded to vllm's
+    16-token alignment) and ``kv_sizing`` applies it only when ``fp8_kv`` is set.
+
+    this also closes a planner/worker disagreement rather than merely freeing memory: the grpo
+    resident wall in ``vram.py`` sizes a ``sleep_unsupported`` model with ``fp8_kv=True`` already,
+    so a worker that sent bf16 needed ~6-7 GB MORE than the planner had reserved for it (measured
+    at 4096x8 and 8192x4). the two halves now assume the same cache dtype.
+    """
+    if not cc_ok:
+        return False
+    if not gdn_hybrid:
+        return True
+    # gdn + sleeping engine is the combination that crashes on wake; gdn + resident is not.
+    return rollout_sleep_unsupported(model_id)
+
+
 def rollout_resident_overrides(sleep_unsupported: bool) -> list[str]:
     """verl overrides that pin the rollout engine resident, or ``[]`` to keep verl's default.
 

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.2.70"
+version = "1.2.87"
 description ="Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -137,7 +137,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "1.2.70"
+version = "1.2.87"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.87}/tests/test_fused_expert_warmstart.py

@@ -28,7 +28,10 @@ def _import_worker(monkeypatch):
     return worker
 
 
-def _wrapper_tensors(prefix, pair, factor_leaves=("default.weight", "default.weight")):
+_SERIALIZED_LEAVES = ("weight", "weight")
+
+
+def _wrapper_tensors(prefix, pair, factor_leaves=_SERIALIZED_LEAVES):
     shape_a, shape_b = pair
     leaf_a, leaf_b = factor_leaves
     return {
@@ -40,7 +43,7 @@ def _wrapper_tensors(prefix, pair, factor_leaves=("default.weight", "default.wei
 def _ordinary_tensors(
     target="q_proj",
     pair=((32, 2048), (2048, 32)),
-    factor_leaves=("default.weight", "default.weight"),
+    factor_leaves=_SERIALIZED_LEAVES,
 ):
     prefix = f"base_model.model.layers.0.self_attn.{target}"
     return _wrapper_tensors(prefix, pair, factor_leaves)
@@ -51,7 +54,7 @@ def _complete_expert_tensors(
     owner_segment="mlp.experts",
     pairs=_EXPECTED_PAIRS,
     swap_rungs=False,
-    factor_leaves=("default.weight", "default.weight"),
+    factor_leaves=_SERIALIZED_LEAVES,
     include_ordinary=True,
 ):
     tensors = {}
@@ -356,20 +359,19 @@ def test_tensor_analyzer_rejects_swapped_qwen36_rungs():
     )
 
 
-def test_tensor_analyzer_requires_matching_adapter_namespaces_across_all_exact_owners():
+def test_tensor_analyzer_rejects_every_adapter_namespace_on_disk():
+    """No namespaced spelling is a real serialized artifact, uniform or not.
+
+    PEFT strips the namespace on save and re-inserts it on load, so a file that still carries one
+    loads with the namespace doubled and matches no module.
+    """
     from flash.adapters.fused_experts import has_complete_fused_expert_tensors
 
     config = _valid_config()
-    assert has_complete_fused_expert_tensors(
-        _complete_expert_tensors(factor_leaves=("foo.weight", "foo.weight")),
-        config,
-        _MODEL_ID,
-    )
-    assert not has_complete_fused_expert_tensors(
-        _complete_expert_tensors(factor_leaves=("foo.weight", "bar.weight")),
-        config,
-        _MODEL_ID,
-    )
+    for leaves in (("foo.weight", "foo.weight"), ("foo.weight", "bar.weight")):
+        assert not has_complete_fused_expert_tensors(
+            _complete_expert_tensors(factor_leaves=leaves), config, _MODEL_ID
+        )
 
 
 def test_tensor_analyzer_rejects_namespace_changes_across_wrapper_rungs():
@@ -426,11 +428,7 @@ def test_tensor_analyzer_requires_every_catalog_layer_and_both_lora_factors():
         _MODEL_ID,
     )
     assert not has_complete_fused_expert_tensors(
-        {
-            key: shape
-            for key, shape in complete.items()
-            if not key.endswith("lora_B.default.weight")
-        },
+        {key: shape for key, shape in complete.items() if not key.endswith("lora_B.weight")},
         config,
         _MODEL_ID,
     )
@@ -463,8 +461,7 @@ def _expert_namespace_mismatch(rung):
     tensors = _complete_expert_tensors()
     suffix = "" if rung == "outer" else ".base_layer"
     prefix = f"base_model.model.layers.0.mlp.experts{suffix}"
-    default_key = f"{prefix}.lora_B.default.weight"
-    tensors[f"{prefix}.lora_B.other.weight"] = tensors.pop(default_key)
+    tensors[f"{prefix}.lora_B.other.weight"] = tensors.pop(f"{prefix}.lora_B.weight")
     return tensors
 
 
@@ -649,3 +646,133 @@ def test_tensor_analyzer_rejects_non_peft_fused_shapes(tensors, config):
     from flash.adapters.fused_experts import has_complete_fused_expert_tensors
 
     assert not has_complete_fused_expert_tensors(tensors, config, _MODEL_ID)
+
+
+def test_tensor_analyzer_accepts_the_grammar_peft_and_verl_actually_write():
+    from flash.adapters.fused_experts import has_complete_fused_expert_tensors
+
+    stripped = _complete_expert_tensors()
+
+    assert not any(".default." in key for key in stripped)
+    assert has_complete_fused_expert_tensors(stripped, _valid_config(), _MODEL_ID)
+
+
+def test_export_stamps_an_adapter_serialized_without_the_adapter_namespace(monkeypatch, tmp_path):
+    import flash.engine.worker.verl.checkpoints as checkpoints
+
+    tensors = _complete_expert_tensors()
+    tensors.update(_ordinary_tensors(target="v_proj"))
+    monkeypatch.setattr(checkpoints, "_read_adapter_tensor_metadata", lambda _path: tensors)
+    config = {
+        "peft_type": "LORA",
+        "r": 32,
+        "target_modules": ["v_proj", "experts", "base_layer"],
+        "target_parameters": None,
+    }
+    _write_expert_adapter(tmp_path, config=config)
+
+    checkpoints.stamp_adapter_dir_provenance(str(tmp_path), _MODEL_ID, "e" * 40)
+
+    saved = json.loads((tmp_path / "adapter_config.json").read_text(encoding="utf-8"))
+    assert saved["target_parameters"] == _TARGETS
+    assert saved["base_model_name_or_path"] == _MODEL_ID
+
+
+def test_warmstart_accepts_an_adapter_serialized_without_the_adapter_namespace(
+    monkeypatch, tmp_path
+):
+    import flash.engine.worker.model.adapter as adapter
+
+    worker = _import_worker(monkeypatch)
+    tensors = _complete_expert_tensors()
+    monkeypatch.setattr(adapter, "_read_adapter_tensor_metadata", lambda _path: tensors)
+
+    worker.validate_warmstart_adapter(_valid_config(), _MODEL_ID, str(tmp_path))
+
+
+@pytest.mark.parametrize("rung", ["outer", "nested"])
+def test_tensor_analyzer_still_rejects_cross_namespace_pairs_when_serialized(rung):
+    from flash.adapters.fused_experts import has_complete_fused_expert_tensors
+
+    tensors = _complete_expert_tensors()
+    suffix = "" if rung == "outer" else ".base_layer"
+    prefix = f"base_model.model.layers.0.mlp.experts{suffix}"
+    tensors[f"{prefix}.lora_B.other.weight"] = tensors.pop(f"{prefix}.lora_B.weight")
+
+    assert not has_complete_fused_expert_tensors(tensors, _valid_config(), _MODEL_ID)
+
+
+@pytest.mark.parametrize(
+    ("leaf", "expected"),
+    [
+        pytest.param("weight", "module", id="serialized-bare-leaf"),
+        pytest.param("default.weight", None, id="explicit-default-does-not-roundtrip"),
+        pytest.param("other.weight", None, id="explicit-namespace-does-not-roundtrip"),
+        pytest.param("not_peft", None, id="wrong-parameter-name"),
+        pytest.param("default.not_peft", None, id="namespaced-wrong-parameter-name"),
+        pytest.param("default.weight.extra", None, id="extra-segment"),
+        pytest.param(".weight", None, id="empty-adapter-name"),
+        pytest.param("", None, id="empty-leaf"),
+    ],
+)
+def test_parse_lora_tensor_pins_the_exact_accepted_leaf_grammar(leaf, expected):
+    """Pin the grammar directly.
+
+    Routing these through the whole-artifact analyzer used to be inert: a malformed key merely
+    failed to parse, and the surviving tensors still satisfied every downstream check, so the
+    assertion passed for the wrong reason. Sabotaging the parser to accept an empty adapter name
+    left the artifact-level version green.
+    """
+    from flash.adapters.fused_experts import _parse_lora_tensor
+
+    parsed = _parse_lora_tensor(f"module.lora_A.{leaf}", (8, 16))
+
+    if expected is None:
+        assert parsed is None
+    else:
+        module_path, factor, key, shape = parsed
+        assert (module_path, factor) == (expected, "A")
+        assert (key, shape) == (f"module.lora_A.{leaf}", (8, 16))
+
+
+def test_parse_lora_tensor_requires_exactly_one_factor_infix():
+    from flash.adapters.fused_experts import _parse_lora_tensor
+
+    assert _parse_lora_tensor("m.lora_A.lora_B.weight", (8, 16)) is None
+    assert _parse_lora_tensor("lora_A.weight", (8, 16)) is None
+
+
+def test_tensor_analyzer_rejects_an_artifact_carrying_the_adapter_namespace():
+    """Only the stripped grammar round-trips through PEFT, so a namespaced file must not validate.
+
+    Verified against the locked peft 0.19.1 ``_insert_adapter_name_into_state_dict``: a stripped
+    ``...lora_A.weight`` loads as ``...lora_A.default.weight`` and matches the live module, while
+    ``...lora_A.default.weight`` loads as ``...lora_A.default.default.weight`` and matches nothing.
+    """
+    from flash.adapters.fused_experts import has_complete_fused_expert_tensors
+
+    for leaves in (("default.weight", "default.weight"), ("other.weight", "other.weight")):
+        tensors = _complete_expert_tensors(factor_leaves=leaves)
+
+        assert not has_complete_fused_expert_tensors(tensors, _valid_config(), _MODEL_ID)
+
+
+def test_tensor_analyzer_rejects_an_unparseable_lora_key():
+    """An unrecognized lora key must fail the artifact rather than be skipped.
+
+    Dropping it would let a malformed tensor ride along beside a complete canonical set, and a
+    trailing-dot module alias would then collapse onto the outer rung and make the verdict depend
+    on mapping iteration order.
+    """
+    from flash.adapters.fused_experts import has_complete_fused_expert_tensors
+
+    owner = "base_model.model.layers.0.mlp.experts"
+    for alias in (f"{owner}..lora_A.weight", f"{owner}.lora_A.not_peft"):
+        for alias_first in (True, False):
+            tensors = _complete_expert_tensors()
+            if alias_first:
+                tensors = {alias: (1, 1), **tensors}
+            else:
+                tensors[alias] = (1, 1)
+
+            assert not has_complete_fused_expert_tensors(tensors, _valid_config(), _MODEL_ID)