diff --git a/esphome/components/valve/__init__.py b/esphome/components/valve/__init__.py
index e072f70d1b1..f39eb4dc8d7 100644
--- a/esphome/components/valve/__init__.py
+++ b/esphome/components/valve/__init__.py
@@ -251,15 +251,12 @@ async def valve_control_to_code(config, action_id, template_arg, args):
         else:
             body_lines.append(f"call.{setter}({cg.safe_exp(value)});")
 
-    # Match ControlAction::ApplyFn signature: `const std::remove_reference_t<T> &`
-    # for each trigger arg so non-reference Ts stay no-copy (`const T &`) and
-    # reference Ts collapse correctly without producing `const T & &`.
+    # Match ControlAction::ApplyFn signature: forward trigger args as Ts...
+    # so the apply lambda's parameter types match both ApplyFn and the
+    # inner field lambdas (which are generated from `args` directly).
     apply_args = [
         (ValveCall.operator("ref"), "call"),
-        *(
-            (cg.RawExpression(f"const std::remove_reference_t<{cg.safe_exp(t)}> &"), n)
-            for t, n in args
-        ),
+        *args,
     ]
     apply_lambda = LambdaExpression(
         ["\n".join(body_lines)],
diff --git a/esphome/components/valve/automation.h b/esphome/components/valve/automation.h
index cc71999c359..88c4ed760df 100644
--- a/esphome/components/valve/automation.h
+++ b/esphome/components/valve/automation.h
@@ -53,13 +53,16 @@ template<typename... Ts> class ToggleAction : public Action<Ts...> {
 // Trigger args are forwarded to the apply function so user lambdas
 // (e.g. `position: !lambda "return x;"`) keep working.
 //
-// Trigger args are forwarded as `const std::remove_reference_t<Ts> &...`
-// (instead of `const Ts &...`) so codegen can emit the same form in the
-// apply lambda's parameter list without producing `const T & &` for
-// triggers whose Ts already carries a reference (e.g. `std::string &`).
+// Trigger args are forwarded as `Ts...`. The previous `const Ts &...`
+// form caused codegen to emit `const T &` for each arg in the apply
+// lambda's parameter list, which is invalid C++ source text when T is
+// already a reference (e.g. `const std::string & &` for triggers that
+// pass `std::string &`). Forwarding `Ts...` lets the codegen reuse the
+// trigger's `args` types unchanged for both the apply lambda and any
+// inner field lambdas, so they always type-match.
 template<typename... Ts> class ControlAction : public Action<Ts...> {
  public:
-  using ApplyFn = void (*)(ValveCall &, const std::remove_reference_t<Ts> &...);
+  using ApplyFn = void (*)(ValveCall &, Ts...);
   ControlAction(Valve *valve, ApplyFn apply) : valve_(valve), apply_(apply) {}
 
   void play(const Ts &...x) override {