@@ -2376,7 +2376,14 @@ def _validate_conversion_mappings(
         hf_key_set = set(hf_keys) if hf_keys is not None else None
 
         for global_name in global_param_names:
-            mapping = mapping_registry.megatron_to_hf_lookup(self._get_lora_unwrapped_name(global_name))
+            unwrapped_name = self._get_lora_unwrapped_name(global_name)
+            mapping = mapping_registry.megatron_to_hf_lookup(unwrapped_name)
+            if mapping is None and global_name.endswith(".to_wrap.weight"):
+                # A parameter-backed LoRA target (for example DeepSeek V4's
+                # replicated ``linear_o_group_proj``) is registered without a
+                # ``.weight`` leaf. The wrapper exposes it as
+                # ``.to_wrap.weight`` after PEFT promotion.
+                mapping = mapping_registry.megatron_to_hf_lookup(unwrapped_name[: -len(".weight")])
             if mapping is None:
                 missing_mappings.append(global_name)
                 continue
 
@@ -196,6 +196,10 @@ def _resolve_hf_adapter_param_name(
         )
 
         base_mapping = mapping_registry.megatron_to_hf_lookup(f"{global_base_prefix}{base_suffix}")
+        if base_mapping is None and base_suffix == ".weight":
+            # DeepSeek V4's grouped output projection is a bare replicated
+            # parameter, so its base mapping is registered without `.weight`.
+            base_mapping = mapping_registry.megatron_to_hf_lookup(global_base_prefix)
         assert base_mapping is not None, (
             f"Expected mapping for adapter base '{global_base_prefix}{base_suffix}' but none found"
         )
@@ -224,6 +228,11 @@ def _get_base_hf_param_names_for_adapter(
         """Return all HF base parameter names associated with this adapter."""
 
         base_mapping = mapping_registry.megatron_to_hf_lookup(f"{global_base_prefix}{base_suffix}")
+        if base_mapping is None and base_suffix == ".weight":
+            # See `_resolve_hf_adapter_param_name`: the grouped output
+            # projection's base is a plain parameter without a `.weight`
+            # suffix in the mapping registry.
+            base_mapping = mapping_registry.megatron_to_hf_lookup(global_base_prefix)
         if base_mapping is None:
             return []
 
 
@@ -43,6 +43,7 @@
     is_expert_linear,
     is_grouped_expert_linear,
     is_modelopt_linear,
+    wildcard_match,
 )
 
 
@@ -159,6 +160,63 @@ class LoRA(PEFT, ModuleMatcher):
     experts_shared_outer_loras: bool = False
     use_transformer_engine_op_fuser: bool = False
 
+    def __call__(self, model, training: bool = True):
+        """Apply LoRA, promoting targeted parameter-backed projections first.
+
+        Parameter-backed projections use the same explicit ``target_modules``
+        patterns as ordinary modules. Turning such a parameter into the regular
+        LoRA module only when it is targeted lets the existing LoRA wrapper and
+        adapter export path handle it without changing the base model's
+        checkpoint layout for non-LoRA runs.
+        """
+
+        self._promote_parameter_targets(model)
+        return super().__call__(model, training=training)
+
+    def _promote_parameter_targets(self, model) -> None:
+        """Expose supported bare parameters as linear modules before walking.
+
+        The promoted module keeps the original ``nn.Parameter`` object as its
+        weight, so initialization, freezing, and optimizer ownership remain
+        unchanged. Parameters that do not match ``target_modules`` retain the
+        existing PEFT behavior.
+        """
+
+        target_patterns = self.target_modules
+        if isinstance(target_patterns, str):
+            target_patterns = (target_patterns,)
+        else:
+            target_patterns = tuple(target_patterns or ())
+        if not target_patterns:
+            return
+
+        models = model if isinstance(model, list) else [model]
+        for root in models:
+            if isinstance(root, torch.nn.parallel.DistributedDataParallel):
+                root = root.module
+            for prefix, parent in list(root.named_modules()):
+                for parameter_name, parameter in list(parent.named_parameters(recurse=False)):
+                    full_name = f"{prefix}.{parameter_name}" if prefix else parameter_name
+                    if not any(
+                        parameter_name == pattern or wildcard_match(pattern, full_name) for pattern in target_patterns
+                    ):
+                        continue
+                    if parameter.ndim != 2:
+                        raise ValueError(
+                            f"{full_name} must be a 2-D matrix for LoRA, got shape {tuple(parameter.shape)}"
+                        )
+                    promoted = nn.Linear(
+                        parameter.shape[1],
+                        parameter.shape[0],
+                        bias=False,
+                        device=parameter.device,
+                        dtype=parameter.dtype,
+                    )
+                    promoted.weight = parameter
+                    delattr(parent, parameter_name)
+                    setattr(parent, parameter_name, promoted)
+                    logger.info("Promoted parameter-backed LoRA target: %s", full_name)
+
     def transform(self, module: nn.Module, name: Optional[str] = None, prefix: Optional[str] = None) -> nn.Module:
         """
         Applies LoRA to a specific module within the model architecture.
 
@@ -31,6 +31,7 @@
 from megatron.bridge.models.conversion.param_mapping import (
     AutoMapping,
     ColumnParallelMapping,
+    ReplicatedMapping,
     RowParallelMapping,
     _fuse_gdn_separate_to_grouped,
     merge_gdn_linear_weights,
@@ -754,6 +755,20 @@ def named_parameters(self):
     assert names == ["decoder.layers.0.mlp.linear_fc1.to_wrap.weight"]
 
 
+def test_conversion_mapping_falls_back_for_parameter_backed_lora_target():
+    bridge = DummyBridge()
+    base_name = "decoder.layers.0.self_attention.linear_o_group_proj"
+    mapping = ReplicatedMapping(base_name, "model.layers.0.attn.wo_a.weight")
+
+    class Registry:
+        def megatron_to_hf_lookup(self, key):
+            return mapping if key == base_name else None
+
+    names = [f"{base_name}.to_wrap.weight"]
+    resolved = bridge._validate_conversion_mappings(Registry(), names)
+    assert resolved[names[0]] is mapping
+
+
 def test_megatron_global_adapters_info_all_pp_ranks(monkeypatch):
     bridge = DummyBridge()
 
 
@@ -63,6 +63,15 @@ def __init__(self):
         self.layernorm = nn.LayerNorm(512)
 
 
+class ParameterBackedProjectionModel(nn.Module):
+    """Model fixture with an explicitly targetable bare projection weight."""
+
+    def __init__(self):
+        super().__init__()
+        self.projection_weight = nn.Parameter(torch.randn(8, 4))
+        self.unmarked_matrix = nn.Parameter(torch.randn(8, 4))
+
+
 class NestedModel(nn.Module):
     """Model with nested structure for testing pattern matching."""
 
@@ -303,6 +312,21 @@ def test_lora_transform_simple_model(self):
         assert isinstance(transformed_model.embedding, nn.Embedding)
         assert isinstance(transformed_model.layernorm, nn.LayerNorm)
 
+    def test_lora_promotes_targeted_bare_parameter(self):
+        """An explicitly targeted bare projection receives the regular LoRA wrapper."""
+        model = ParameterBackedProjectionModel()
+        base_weight = model.projection_weight
+        lora = LoRA(target_modules=["projection_weight"], dim=2, alpha=4)
+
+        transformed_model = lora(model, training=True)
+
+        assert isinstance(transformed_model.projection_weight, LoRALinear)
+        assert transformed_model.projection_weight.to_wrap.weight is base_weight
+        assert not base_weight.requires_grad
+        assert transformed_model.projection_weight.adapter.linear_in.weight.requires_grad
+        assert transformed_model.projection_weight.adapter.linear_out.weight.requires_grad
+        assert isinstance(transformed_model.unmarked_matrix, nn.Parameter)
+
     def test_lora_transform_with_exclude_modules(self):
         """Test LoRA transformation with exclude_modules parameter."""
         model = SimpleModel()