From d18a279e696655f8e2c4072c7ad0ea4aecb16fdf Mon Sep 17 00:00:00 2001
From: Kyle Knoepfel <knoepfel@fnal.gov>
Date: Fri, 31 Jul 2026 15:42:10 -0500
Subject: [PATCH 1/3] Resolve performance-unnecessary-value-param clang-tidy
 warning

---
 .clang-tidy                                   |  2 +-
 .../storage_associative_write_container.cpp   |  4 +-
 phlex/app/load_module.cpp                     |  2 +-
 phlex/core/framework_graph.cpp                | 11 ++-
 phlex/core/framework_graph.hpp                | 50 ++++++-----
 phlex/core/glue.cpp                           |  3 +-
 phlex/core/glue.hpp                           | 74 +++++++++------
 phlex/core/graph_proxy.hpp                    | 90 +++++++++++--------
 phlex/core/index_router.cpp                   | 19 ++--
 phlex/core/index_router.hpp                   |  8 +-
 phlex/core/make_computational_edges.cpp       | 10 +--
 phlex/core/registration_api.cpp               |  6 +-
 phlex/core/registration_api.hpp               | 54 +++++------
 phlex/core/store_counters.cpp                 |  2 +-
 phlex/core/store_counters.hpp                 |  2 +-
 phlex/detail/plugin_macros.hpp                | 15 ++--
 phlex/driver.hpp                              |  2 +-
 phlex/metaprogramming/delegate.hpp            | 35 ++++----
 phlex/model/data_layer_hierarchy.cpp          |  2 +-
 phlex/model/data_layer_hierarchy.hpp          |  2 +-
 phlex/model/fixed_hierarchy.cpp               | 12 ++-
 phlex/model/fixed_hierarchy.hpp               | 10 +--
 phlex/model/flush_gate.cpp                    |  5 +-
 phlex/model/flush_gate.hpp                    |  2 +-
 phlex/module.hpp                              |  2 +-
 phlex/source.hpp                              |  2 +-
 plugins/layer_generator.cpp                   |  2 +-
 plugins/layer_generator.hpp                   |  2 +-
 plugins/python/src/modulewrap.cpp             | 14 +--
 plugins/python/src/pymodule.cpp               |  4 +-
 plugins/python/src/wrap.hpp                   |  4 +-
 test/flush_gate_test.cpp                      | 13 +--
 32 files changed, 261 insertions(+), 204 deletions(-)

diff --git a/.clang-tidy b/.clang-tidy
index eaa135f08..c9894f1bc 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -98,7 +98,7 @@ CheckOptions:
   - key: performance-move-const-arg.CheckTriviallyCopyableMove
     value: '1'
   - key: performance-unnecessary-value-param.AllowedTypes
-    value: ''
+    value: 'data_cell_cursor;handle'
 
   # Modernize settings
   - key: modernize-use-override.AllowOverrideAndFinal
diff --git a/form/storage/storage_associative_write_container.cpp b/form/storage/storage_associative_write_container.cpp
index 71d9438c3..b08f0dec2 100644
--- a/form/storage/storage_associative_write_container.cpp
+++ b/form/storage/storage_associative_write_container.cpp
@@ -2,6 +2,8 @@
 
 #include "storage_associative_write_container.hpp"
 
+#include <utility>
+
 using namespace form::detail::experimental;
 
 Storage_Associative_Write_Container::Storage_Associative_Write_Container(std::string const& name) :
@@ -26,5 +28,5 @@ std::string const& Storage_Associative_Write_Container::col_name() { return m_cN
 void Storage_Associative_Write_Container::setParent(
   std::shared_ptr<IStorage_Write_Container> parent)
 {
-  m_parent = parent;
+  m_parent = std::move(parent);
 }
diff --git a/phlex/app/load_module.cpp b/phlex/app/load_module.cpp
index 2878030e6..e4d1e1ef5 100644
--- a/phlex/app/load_module.cpp
+++ b/phlex/app/load_module.cpp
@@ -50,7 +50,7 @@ namespace phlex::detail {
 
       void operator()(driver_proxy proxy, configuration const& config, driver_bundle* out) const
       {
-        fn(proxy, config, out);
+        fn(std::move(proxy), config, out);
       }
     };
 
diff --git a/phlex/core/framework_graph.cpp b/phlex/core/framework_graph.cpp
index 13106d486..6943aed7e 100644
--- a/phlex/core/framework_graph.cpp
+++ b/phlex/core/framework_graph.cpp
@@ -43,7 +43,7 @@ namespace phlex::detail {
                     tbb::flow::unlimited,
                     [this](ready_flushes_then_emit const& input) -> data_cell_index_ptr {
                       auto&& [ready_flushes, index_to_emit] = input;
-                      return index_router_.route(index_to_emit, std::move(ready_flushes));
+                      return index_router_.route(index_to_emit, ready_flushes);
                     }},
     hierarchy_node_{graph_,
                     tbb::flow::unlimited,
@@ -82,7 +82,7 @@ namespace phlex::detail {
     if (shutdown_on_error_) {
       // When in an error state, we need to sanely pop the layer stack and wait for any tasks to finish.
       auto remaining_flushes = cell_tracker_.report_and_evict_ready_flushes(nullptr);
-      index_router_.drain(std::move(remaining_flushes));
+      index_router_.drain(remaining_flushes);
       graph_.wait_for_all();
     }
   }
@@ -213,13 +213,13 @@ namespace phlex::detail {
     }
 
     // Index-router finalization makes edges between the index-set nodes and the provider nodes.
-    finalize_router(std::move(provider_input_ports), std::move(multilayer_join_index_ports));
+    finalize_router(std::move(provider_input_ports), multilayer_join_index_ports);
   }
 
   // FIXME: Much, if not all, of this logic should be moved to the index_router.
   void framework_graph::finalize_router(
     index_router::provider_input_ports_t provider_input_ports,
-    std::map<std::string, named_index_ports> multilayer_join_index_ports)
+    std::map<std::string, named_index_ports> const& multilayer_join_index_ports)
   {
     std::set<phlex::experimental::identifier> unfold_input_layer_names;
 
@@ -248,7 +248,6 @@ namespace phlex::detail {
                                                    unfold_input_layer_names.end()),
       unfold_output_layer_names);
     index_router_.register_unfold_count_per_input_layer(std::move(unfold_count_per_input_layer));
-    index_router_.finalize(
-      graph_, std::move(provider_input_ports), std::move(multilayer_join_index_ports));
+    index_router_.finalize(graph_, std::move(provider_input_ports), multilayer_join_index_ports);
   }
 }
diff --git a/phlex/core/framework_graph.hpp b/phlex/core/framework_graph.hpp
index 67369b54c..3fd6ed344 100644
--- a/phlex/core/framework_graph.hpp
+++ b/phlex/core/framework_graph.hpp
@@ -28,6 +28,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <utility>
 #include <vector>
@@ -56,7 +57,8 @@ namespace phlex::detail {
       requires requires(std::shared_ptr<Generator> generator, std::vector<source const*> sources) {
         { driver_proxy{sources}.driver(generator) } -> std::same_as<driver_bundle>;
       }
-    void add_driver(std::shared_ptr<Generator> generator)
+    void add_driver(
+      std::shared_ptr<Generator> generator) // NOLINT(performance-unnecessary-value-param)
     {
       add_driver(driver_proxy().driver(std::move(generator)));
     }
@@ -76,7 +78,7 @@ namespace phlex::detail {
       return {config, graph_, nodes_, registration_errors_};
     }
 
-    detail::driver_proxy driver_proxy(std::vector<std::string> strings = {})
+    detail::driver_proxy driver_proxy(std::vector<std::string> const& strings = {})
     {
       return detail::driver_proxy{nodes_.sources_for(strings)};
     }
@@ -87,54 +89,57 @@ namespace phlex::detail {
     //      right?
 
     template <typename... InitArgs>
-    auto fold(std::string name,
+    auto fold(std::string_view name,
               is_fold_like auto f,
               concurrency c = concurrency::serial,
               std::string partition = "job",
               InitArgs&&... init_args)
     {
-      return make_glue().fold(std::move(name),
-                              std::move(f),
-                              c,
-                              std::move(partition),
-                              std::forward<InitArgs>(init_args)...);
+      return make_glue().fold(
+        name, std::move(f), c, std::move(partition), std::forward<InitArgs>(init_args)...);
     }
 
     template <typename T>
-    auto unfold(std::string name,
+    auto unfold(std::string_view name,
                 is_predicate_like auto pred,
                 auto unf,
                 concurrency c,
                 std::string destination_data_layer)
     {
       return make_glue<T, false>().unfold(
-        std::move(name), std::move(pred), std::move(unf), c, std::move(destination_data_layer));
+        name, std::move(pred), std::move(unf), c, std::move(destination_data_layer));
     }
 
-    auto observe(std::string name, is_observer_like auto f, concurrency c = concurrency::serial)
+    auto observe(std::string_view name,
+                 is_observer_like auto f,
+                 concurrency c = concurrency::serial)
     {
-      return make_glue().observe(std::move(name), std::move(f), c);
+      return make_glue().observe(name, std::move(f), c);
     }
 
-    auto predicate(std::string name, is_predicate_like auto f, concurrency c = concurrency::serial)
+    auto predicate(std::string_view name,
+                   is_predicate_like auto f,
+                   concurrency c = concurrency::serial)
     {
-      return make_glue().predicate(std::move(name), std::move(f), c);
+      return make_glue().predicate(name, std::move(f), c);
     }
 
-    auto transform(std::string name, is_transform_like auto f, concurrency c = concurrency::serial)
+    auto transform(std::string_view name,
+                   is_transform_like auto f,
+                   concurrency c = concurrency::serial)
     {
-      return make_glue().transform(std::move(name), std::move(f), c);
+      return make_glue().transform(name, std::move(f), c);
     }
 
-    auto provide(std::string name, auto f, concurrency c = concurrency::serial)
+    auto provide(std::string_view name, auto f, concurrency c = concurrency::serial)
     {
-      return make_glue().provide(std::move(name), std::move(f), c);
+      return make_glue().provide(name, std::move(f), c);
     }
 
     template <std::derived_from<source> Source, typename... Args>
-    void add_source(std::string name, Args&&... args)
+    void add_source(std::string_view name, Args&&... args)
     {
-      return make_glue().template add_source<Source>(std::move(name), std::forward<Args>(args)...);
+      return make_glue().template add_source<Source>(name, std::forward<Args>(args)...);
     }
 
     template <typename T, typename... Args>
@@ -184,8 +189,9 @@ namespace phlex::detail {
     void throw_if_registration_errors() const;
     void make_filter_edges();
     void make_bookkeeping_edges();
-    void finalize_router(index_router::provider_input_ports_t provider_input_ports,
-                         std::map<std::string, named_index_ports> multilayer_join_index_ports);
+    void finalize_router(
+      index_router::provider_input_ports_t provider_input_ports,
+      std::map<std::string, named_index_ports> const& multilayer_join_index_ports);
 
     enum class driver_mode { default_driver, deferred_driver };
     explicit framework_graph(driver_mode mode, int max_parallelism);
diff --git a/phlex/core/glue.cpp b/phlex/core/glue.cpp
index d8d78261e..f07c9e6db 100644
--- a/phlex/core/glue.cpp
+++ b/phlex/core/glue.cpp
@@ -3,9 +3,10 @@
 
 #include <stdexcept>
 #include <string>
+#include <string_view>
 
 namespace phlex::detail::internal {
-  void verify_name(std::string const& name, configuration const* config)
+  void verify_name(std::string_view name, configuration const* config)
   {
     if (not name.empty()) {
       return;
diff --git a/phlex/core/glue.hpp b/phlex/core/glue.hpp
index b9b098368..e79e9a0f8 100644
--- a/phlex/core/glue.hpp
+++ b/phlex/core/glue.hpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <utility>
 
@@ -25,7 +26,7 @@ namespace phlex {
 namespace phlex::detail {
   struct node_catalog;
   namespace internal {
-    PHLEX_CORE_EXPORT void verify_name(std::string const& name, configuration const* config);
+    PHLEX_CORE_EXPORT void verify_name(std::string_view name, configuration const* config);
   }
 
   // ==============================================================================
@@ -52,14 +53,19 @@ namespace phlex::detail {
     {
     }
 
+    // 'f' is a by-value sink: it is moved into algorithm_bits.  The clang-tidy
+    // warning to take it by const reference is a false positive.
     template <typename... InitArgs>
-    auto fold(
-      std::string name, auto f, concurrency c, std::string partition, InitArgs&&... init_args)
+    auto fold(std::string_view name,
+              auto f, // NOLINT(performance-unnecessary-value-param)
+              concurrency c,
+              std::string partition,
+              InitArgs&&... init_args)
     {
       internal::verify_name(name, config_);
       return fold_api{config_,
-                      std::move(name),
-                      algorithm_bits(bound_obj_, std::move(f)),
+                      name,
+                      algorithm_bits(std::move(bound_obj_), std::move(f)),
                       c,
                       graph_,
                       nodes_,
@@ -68,59 +74,75 @@ namespace phlex::detail {
                       std::forward<InitArgs>(init_args)...};
     }
 
+    // 'f' is a by-value sink: it is moved into algorithm_bits.  The clang-tidy
+    // warning to take it by const reference is a false positive.
     template <typename FT>
-    auto observe(std::string name, FT f, concurrency c)
+    auto observe(std::string_view name,
+                 FT f, // NOLINT(performance-unnecessary-value-param)
+                 concurrency c)
     {
       internal::verify_name(name, config_);
       return make_registration<observer_node>(config_,
-                                              std::move(name),
-                                              algorithm_bits{bound_obj_, std::move(f)},
+                                              name,
+                                              algorithm_bits{std::move(bound_obj_), std::move(f)},
                                               c,
                                               graph_,
                                               nodes_,
                                               errors_);
     }
 
+    // 'f' is a by-value sink: it is moved into algorithm_bits.  The clang-tidy
+    // warning to take it by const reference is a false positive.
     template <typename FT>
-    auto provide(std::string name, FT f, concurrency c)
+    auto provide(std::string_view name,
+                 FT f, // NOLINT(performance-unnecessary-value-param)
+                 concurrency c)
     {
       internal::verify_name(name, config_);
       return provider_api{config_,
-                          std::move(name),
-                          algorithm_bits{bound_obj_, std::move(f)},
+                          name,
+                          algorithm_bits{std::move(bound_obj_), std::move(f)},
                           c,
                           graph_,
                           nodes_,
                           errors_};
     }
 
+    // 'f' is a by-value sink: it is moved into algorithm_bits.  The clang-tidy
+    // warning to take it by const reference is a false positive.
     template <typename FT>
-    auto transform(std::string name, FT f, concurrency c)
+    auto transform(std::string_view name,
+                   FT f, // NOLINT(performance-unnecessary-value-param)
+                   concurrency c)
     {
       internal::verify_name(name, config_);
       return make_registration<transform_node>(config_,
-                                               std::move(name),
-                                               algorithm_bits{bound_obj_, std::move(f)},
+                                               name,
+                                               algorithm_bits{std::move(bound_obj_), std::move(f)},
                                                c,
                                                graph_,
                                                nodes_,
                                                errors_);
     }
 
+    // 'f' is a by-value sink: it is moved into algorithm_bits.  The clang-tidy
+    // warning to take it by const reference is a false positive.
     template <typename FT>
-    auto predicate(std::string name, FT f, concurrency c)
+    auto predicate(std::string_view name,
+                   FT f, // NOLINT(performance-unnecessary-value-param)
+                   concurrency c)
     {
       internal::verify_name(name, config_);
       return make_registration<predicate_node>(config_,
-                                               std::move(name),
-                                               algorithm_bits{bound_obj_, std::move(f)},
+                                               name,
+                                               algorithm_bits{std::move(bound_obj_), std::move(f)},
                                                c,
                                                graph_,
                                                nodes_,
                                                errors_);
     }
 
-    auto unfold(std::string name,
+    auto unfold(std::string_view name,
                 auto predicate,
                 auto unfold,
                 concurrency c,
@@ -130,7 +152,7 @@ namespace phlex::detail {
       internal::verify_name(name, config_);
       return unfold_api<T, decltype(predicate), decltype(unfold)>{
         config_,
-        std::move(name),
+        name,
         std::move(predicate),
         std::move(unfold),
         c,
@@ -140,23 +162,23 @@ namespace phlex::detail {
         std::move(destination_data_layer)};
     }
 
-    auto output(std::string name, is_output_like auto f, concurrency c = concurrency::serial)
+    auto output(std::string_view name, is_output_like auto f, concurrency c = concurrency::serial)
     {
       return output_api{nodes_.registrar_for<declared_output_ptr>(errors_),
                         config_,
-                        std::move(name),
+                        name,
                         graph_,
-                        delegate(bound_obj_, f),
+                        delegate(std::move(bound_obj_), f),
                         c};
     }
 
     template <std::derived_from<source> Source, typename... Args>
-    void add_source(std::string name, Args&&... args)
+    void add_source(std::string_view name, Args&&... args)
     {
-      auto [_, inserted] =
-        nodes_.sources.try_emplace(name, std::make_unique<Source>(std::forward<Args>(args)...));
+      auto [_, inserted] = nodes_.sources.try_emplace(
+        std::string{name}, std::make_unique<Source>(std::forward<Args>(args)...));
       if (not inserted) {
-        internal::add_to_error_messages(errors_, "Source", name); // From registrar.hpp
+        internal::add_to_error_messages(errors_, "Source", std::string{name}); // From registrar.hpp
       }
     }
 
diff --git a/phlex/core/graph_proxy.hpp b/phlex/core/graph_proxy.hpp
index 596c488a1..e851551bd 100644
--- a/phlex/core/graph_proxy.hpp
+++ b/phlex/core/graph_proxy.hpp
@@ -13,6 +13,7 @@
 #include <concepts>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -47,48 +48,60 @@ namespace phlex::detail {
     /// Returns a new proxy through which member functions of that object may
     /// be registered as algorithm nodes.
     template <typename U, typename... Args>
-    graph_proxy<U> make(Args&&... args)
+    graph_proxy<U> make(Args&&... args) const
       requires(not is_bound_object<T>);
 
+    // In the registration methods below, 'f' is a by-value sink: it is ultimately
+    // moved into algorithm_bits.  The clang-tidy warning to take it by const
+    // reference is a false positive.
+
     /// @brief Registers a fold algorithm node.
     template <typename... InitArgs>
-    auto fold(std::string name,
-              is_fold_like auto f,
+    auto fold(std::string_view name,
+              is_fold_like auto f, // NOLINT(performance-unnecessary-value-param)
               concurrency c = concurrency::serial,
               std::string partition = "job",
-              InitArgs&&... init_args);
+              InitArgs&&... init_args) const;
 
     /// @brief Registers an observer node.
-    auto observe(std::string name, is_observer_like auto f, concurrency c = concurrency::serial);
+    auto observe(std::string_view name,
+                 is_observer_like auto f, // NOLINT(performance-unnecessary-value-param)
+                 concurrency c = concurrency::serial) const;
 
     /// @brief Registers a predicate node.
-    auto predicate(std::string name, is_predicate_like auto f, concurrency c = concurrency::serial);
+    auto predicate(std::string_view name,
+                   is_predicate_like auto f, // NOLINT(performance-unnecessary-value-param)
+                   concurrency c = concurrency::serial) const;
 
     /// @brief Registers a provider node.
-    auto provide(std::string name, is_provider_like auto f, concurrency c = concurrency::serial);
+    auto provide(std::string_view name,
+                 is_provider_like auto f, // NOLINT(performance-unnecessary-value-param)
+                 concurrency c = concurrency::serial) const;
 
     /// @brief Registers a transform node.
-    auto transform(std::string name, is_transform_like auto f, concurrency c = concurrency::serial);
+    auto transform(std::string_view name,
+                   is_transform_like auto f, // NOLINT(performance-unnecessary-value-param)
+                   concurrency c = concurrency::serial) const;
 
     /// @brief Registers an unfold node.
     template <typename Splitter>
-    auto unfold(std::string name,
+    auto unfold(std::string_view name,
                 is_predicate_like auto pred,
                 auto unf,
                 std::string destination_data_layer,
-                concurrency c = concurrency::serial);
+                concurrency c = concurrency::serial) const;
 
     /// @brief Registers a source (used by the framework to create provider nodes)
     template <std::derived_from<source> Source, typename... Args>
-    void add_source(std::string name, Args&&... args)
+    void add_source(std::string_view name, Args&&... args) const
       requires(not is_bound_object<T>);
 
     /// @brief Registers an output node.
-    auto output(std::string name, is_output_like auto f, concurrency c = concurrency::serial);
+    auto output(std::string_view name, is_output_like auto f, concurrency c = concurrency::serial);
 
   protected:
     template <template <typename> typename Proxy, typename U, typename... Args>
-    Proxy<U> bind_to(Args&&... args)
+    Proxy<U> bind_to(Args&&... args) const
       requires(not is_bound_object<T>);
 
     graph_proxy(configuration const* config,
@@ -99,7 +112,7 @@ namespace phlex::detail {
       requires(is_bound_object<T>);
 
   private:
-    glue<T> create_glue(bool use_bound_object = true);
+    glue<T> create_glue(bool use_bound_object = true) const;
 
     configuration const* config_;
     // Non-owning references to framework-owned resources; graph_proxy<T> is a
@@ -122,7 +135,7 @@ namespace phlex::detail {
 
   template <typename T>
   template <typename U, typename... Args>
-  graph_proxy<U> graph_proxy<T>::make(Args&&... args)
+  graph_proxy<U> graph_proxy<T>::make(Args&&... args) const
     requires(not is_bound_object<T>)
   {
     return bind_to<graph_proxy, U>(std::forward<Args>(args)...);
@@ -130,72 +143,75 @@ namespace phlex::detail {
 
   template <typename T>
   template <typename... InitArgs>
-  auto graph_proxy<T>::fold(std::string name,
+  auto graph_proxy<T>::fold(std::string_view name,
                             is_fold_like auto f,
                             concurrency c,
                             std::string partition,
-                            InitArgs&&... init_args)
+                            InitArgs&&... init_args) const
   {
     return create_glue().fold(
-      std::move(name), std::move(f), c, std::move(partition), std::forward<InitArgs>(init_args)...);
+      name, std::move(f), c, std::move(partition), std::forward<InitArgs>(init_args)...);
   }
 
   template <typename T>
-  auto graph_proxy<T>::observe(std::string name, is_observer_like auto f, concurrency c)
+  auto graph_proxy<T>::observe(std::string_view name, is_observer_like auto f, concurrency c) const
   {
-    return create_glue().observe(std::move(name), std::move(f), c);
+    return create_glue().observe(name, std::move(f), c);
   }
 
   template <typename T>
-  auto graph_proxy<T>::predicate(std::string name, is_predicate_like auto f, concurrency c)
+  auto graph_proxy<T>::predicate(std::string_view name,
+                                 is_predicate_like auto f,
+                                 concurrency c) const
   {
-    return create_glue().predicate(std::move(name), std::move(f), c);
+    return create_glue().predicate(name, std::move(f), c);
   }
 
   template <typename T>
-  auto graph_proxy<T>::provide(std::string name, is_provider_like auto f, concurrency c)
+  auto graph_proxy<T>::provide(std::string_view name, is_provider_like auto f, concurrency c) const
   {
-    return create_glue().provide(std::move(name), std::move(f), c);
+    return create_glue().provide(name, std::move(f), c);
   }
 
   template <typename T>
-  auto graph_proxy<T>::transform(std::string name, is_transform_like auto f, concurrency c)
+  auto graph_proxy<T>::transform(std::string_view name,
+                                 is_transform_like auto f,
+                                 concurrency c) const
   {
-    return create_glue().transform(std::move(name), std::move(f), c);
+    return create_glue().transform(name, std::move(f), c);
   }
 
   template <typename T>
   template <typename Splitter>
-  auto graph_proxy<T>::unfold(std::string name,
+  auto graph_proxy<T>::unfold(std::string_view name,
                               is_predicate_like auto pred,
                               auto unf,
                               std::string destination_data_layer,
-                              concurrency c)
+                              concurrency c) const
   {
     return glue<Splitter>{graph_, nodes_, nullptr, errors_, config_}.unfold(
-      std::move(name), std::move(pred), std::move(unf), c, std::move(destination_data_layer));
+      name, std::move(pred), std::move(unf), c, std::move(destination_data_layer));
   }
 
   template <typename T>
   template <std::derived_from<source> Source, typename... Args>
-  void graph_proxy<T>::add_source(std::string name, Args&&... args)
+  void graph_proxy<T>::add_source(std::string_view name, Args&&... args) const
     requires(not is_bound_object<T>)
   {
     // The bound object is created when invoking add_source<Source>(...), so we explicitly indicate that
     // no bound object should be used in the create_glue(...) call.
-    return create_glue(false).template add_source<Source>(std::move(name),
-                                                          std::forward<Args>(args)...);
+    return create_glue(false).template add_source<Source>(name, std::forward<Args>(args)...);
   }
 
   template <typename T>
-  auto graph_proxy<T>::output(std::string name, is_output_like auto f, concurrency c)
+  auto graph_proxy<T>::output(std::string_view name, is_output_like auto f, concurrency c)
   {
-    return create_glue().output(std::move(name), std::move(f), c);
+    return create_glue().output(name, std::move(f), c);
   }
 
   template <typename T>
   template <template <typename> typename Proxy, typename U, typename... Args>
-  Proxy<U> graph_proxy<T>::bind_to(Args&&... args)
+  Proxy<U> graph_proxy<T>::bind_to(Args&&... args) const
     requires(not is_bound_object<T>)
   {
     return Proxy<U>{
@@ -209,12 +225,12 @@ namespace phlex::detail {
                               std::shared_ptr<T> bound_obj,
                               std::vector<std::string>& errors)
     requires(is_bound_object<T>)
-    : config_{config}, graph_{g}, nodes_{nodes}, bound_obj_{bound_obj}, errors_{errors}
+    : config_{config}, graph_{g}, nodes_{nodes}, bound_obj_{std::move(bound_obj)}, errors_{errors}
   {
   }
 
   template <typename T>
-  glue<T> graph_proxy<T>::create_glue(bool use_bound_object)
+  glue<T> graph_proxy<T>::create_glue(bool use_bound_object) const
   {
     return glue{graph_, nodes_, (use_bound_object ? bound_obj_ : nullptr), errors_, config_};
   }
diff --git a/phlex/core/index_router.cpp b/phlex/core/index_router.cpp
index 542ce5672..e3be31ad4 100644
--- a/phlex/core/index_router.cpp
+++ b/phlex/core/index_router.cpp
@@ -89,8 +89,8 @@ namespace phlex::detail {
                            }},
     unfold_flush_receiver_{g,
                            tbb::flow::unlimited,
-                           [this](unfold_flush input) -> tbb::flow::continue_msg {
-                             auto&& [index, layer_hash, count] = input;
+                           [this](unfold_flush const& input) -> tbb::flow::continue_msg {
+                             auto const& [index, layer_hash, count] = input;
                              apply_expected_count(*gate_for(index), layer_hash, count);
                              flush_if_done(index);
                              return {};
@@ -123,7 +123,7 @@ namespace phlex::detail {
 
   void index_router::finalize(tbb::flow::graph& g,
                               provider_input_ports_t provider_input_ports,
-                              std::map<std::string, named_index_ports> multilayer_join_ports)
+                              std::map<std::string, named_index_ports> const& multilayer_join_ports)
   {
     // We must have at least one provider port, or there can be no data to process.
     assert(!provider_input_ports.empty());
@@ -147,9 +147,10 @@ namespace phlex::detail {
     }
   }
 
-  data_cell_index_ptr index_router::route(data_cell_index_ptr const& index, index_flushes flushes)
+  data_cell_index_ptr index_router::route(data_cell_index_ptr const& index,
+                                          index_flushes const& flushes)
   {
-    update_flush_counts(std::move(flushes));
+    update_flush_counts(flushes);
     return route(index, index_is_lowest_layer(index), received_indices_.fetch_add(1));
   }
 
@@ -189,7 +190,7 @@ namespace phlex::detail {
     return index;
   }
 
-  void index_router::drain(index_flushes flushes) { update_flush_counts(std::move(flushes)); }
+  void index_router::drain(index_flushes const& flushes) { update_flush_counts(flushes); }
 
   void index_router::register_unfold_count_per_input_layer(
     std::map<phlex::experimental::identifier, std::size_t> counts)
@@ -320,7 +321,7 @@ namespace phlex::detail {
     return {acc->second.message_slots, acc->second.end_token_slots};
   }
 
-  void index_router::update_flush_counts(index_flushes flushes)
+  void index_router::update_flush_counts(index_flushes const& flushes)
   {
     for (auto const& [index, flush_counts] : flushes) {
       auto gate = gate_for(index);
@@ -412,7 +413,9 @@ namespace phlex::detail {
 
       auto next = index->parent();
       if (next) {
-        gate_for(next)->roll_up_child(gate->committed_counts());
+        auto committed_counts = gate->committed_counts();
+        assert(committed_counts);
+        gate_for(next)->roll_up_child(*committed_counts);
       }
       index = next;
     }
diff --git a/phlex/core/index_router.hpp b/phlex/core/index_router.hpp
index 5314cafc9..ec201bd0d 100644
--- a/phlex/core/index_router.hpp
+++ b/phlex/core/index_router.hpp
@@ -54,7 +54,7 @@ namespace phlex::detail {
     using provider_input_ports_t = std::map<std::string, provider_input_port_t>;
 
     explicit index_router(tbb::flow::graph& g);
-    data_cell_index_ptr route(data_cell_index_ptr const& index, index_flushes flushes);
+    data_cell_index_ptr route(data_cell_index_ptr const& index, index_flushes const& flushes);
 
     void establish_layers(
       std::vector<phlex::experimental::layer_path> const& layer_paths_from_driver,
@@ -69,8 +69,8 @@ namespace phlex::detail {
 
     void finalize(tbb::flow::graph& g,
                   provider_input_ports_t provider_input_ports,
-                  std::map<std::string, named_index_ports> multilayer_join_ports);
-    void drain(index_flushes flushes);
+                  std::map<std::string, named_index_ports> const& multilayer_join_ports);
+    void drain(index_flushes const& flushes);
     flusher_t& flusher() { return flusher_; }
 
     tbb::flow::function_node<index_message, data_cell_index_ptr>& unfold_index_receiver()
@@ -97,7 +97,7 @@ namespace phlex::detail {
     internal::index_set_node_ptr index_set_node_for(data_cell_index_ptr const& index);
     std::pair<internal::multilayer_slots_ptr, internal::multilayer_slots_ptr> multilayer_slots_for(
       data_cell_index_ptr const& index);
-    void update_flush_counts(index_flushes flushes);
+    void update_flush_counts(index_flushes const& flushes);
     void apply_expected_count(flush_gate& gate,
                               data_cell_index::hash_type child_layer_hash,
                               std::size_t count);
diff --git a/phlex/core/make_computational_edges.cpp b/phlex/core/make_computational_edges.cpp
index 79fa2bade..b31cc192e 100644
--- a/phlex/core/make_computational_edges.cpp
+++ b/phlex/core/make_computational_edges.cpp
@@ -39,7 +39,7 @@ namespace phlex::detail {
     }
 
     std::pair<index_router::provider_input_ports_t, index_router::head_ports_t>
-    edges_from_explicit_providers(index_router::head_ports_t head_ports,
+    edges_from_explicit_providers(index_router::head_ports_t const& head_ports,
                                   provider_nodes& explicit_providers)
     {
       assert(!head_ports.empty());
@@ -68,7 +68,7 @@ namespace phlex::detail {
     }
 
     std::pair<index_router::provider_input_ports_t, index_router::head_ports_t>
-    edges_from_implicit_providers(index_router::head_ports_t head_ports,
+    edges_from_implicit_providers(index_router::head_ports_t const& head_ports,
                                   provider_nodes& providers,
                                   source_map const& sources,
                                   tbb::flow::graph& g)
@@ -202,10 +202,10 @@ namespace phlex::detail {
     }
 
     auto [explicit_provider_input_ports, unconsumed_head_ports] =
-      edges_from_explicit_providers(std::move(head_ports), nodes.providers);
+      edges_from_explicit_providers(head_ports, nodes.providers);
 
-    auto [implicit_provider_input_ports, unmatched_head_ports] = edges_from_implicit_providers(
-      std::move(unconsumed_head_ports), nodes.providers, nodes.sources, g);
+    auto [implicit_provider_input_ports, unmatched_head_ports] =
+      edges_from_implicit_providers(unconsumed_head_ports, nodes.providers, nodes.sources, g);
 
     if (not unmatched_head_ports.empty()) {
       std::string error_msg{"No provider found for the following required products:\n"};
diff --git a/phlex/core/registration_api.cpp b/phlex/core/registration_api.cpp
index ccdbe23ae..0fe11ee0a 100644
--- a/phlex/core/registration_api.cpp
+++ b/phlex/core/registration_api.cpp
@@ -4,11 +4,11 @@
 namespace phlex::detail {
   output_api::output_api(registrar<declared_output_ptr> reg,
                          configuration const* config,
-                         std::string name,
+                         std::string_view name,
                          tbb::flow::graph& g,
                          internal::output_function_t&& f,
                          concurrency c) :
-    name_{experimental::internal::make_algorithm_name(config, std::move(name))},
+    name_{experimental::internal::make_algorithm_name(config, name)},
     graph_{g},
     ft_{std::move(f)},
     concurrency_{c},
@@ -18,7 +18,7 @@ namespace phlex::detail {
     if (config) {
       reg_.set_predicates(internal::maybe_predicates(config));
     }
-    reg_.set_creator([this](auto predicates, auto) {
+    reg_.set_creator([this](auto predicates, auto const& /* output_product_suffixes */) {
       return std::make_unique<declared_output>(
         std::move(name_), concurrency_.value, std::move(predicates), graph_, std::move(ft_));
     });
diff --git a/phlex/core/registration_api.hpp b/phlex/core/registration_api.hpp
index f2346452c..790f60e2d 100644
--- a/phlex/core/registration_api.hpp
+++ b/phlex/core/registration_api.hpp
@@ -16,6 +16,7 @@
 #include <concepts>
 #include <functional>
 #include <memory>
+#include <string_view>
 
 namespace phlex {
   class configuration;
@@ -37,14 +38,14 @@ namespace phlex::detail {
 
   public:
     registration_api(configuration const* config,
-                     std::string name,
+                     std::string_view name,
                      AlgorithmBits alg,
                      concurrency c,
                      tbb::flow::graph& g,
                      node_catalog& nodes,
                      std::vector<std::string>& errors) :
       config_{config},
-      name_{phlex::experimental::internal::make_algorithm_name(config, std::move(name))},
+      name_{phlex::experimental::internal::make_algorithm_name(config, name)},
       alg_{std::move(alg)},
       concurrency_{c},
       graph_{g},
@@ -58,7 +59,7 @@ namespace phlex::detail {
 
       if constexpr (num_outputs == 0ull) {
         registrar_.set_creator([this, inputs = std::move(input_args)](
-                                 auto predicates, auto /* output_product_suffixes */) {
+                                 auto predicates, auto const& /* output_product_suffixes */) {
           return std::make_unique<hof_type>(std::move(name_),
                                             concurrency_.value,
                                             std::move(predicates),
@@ -101,15 +102,14 @@ namespace phlex::detail {
 
   template <template <typename...> typename HOF, typename AlgorithmBits>
   auto make_registration(configuration const* config,
-                         std::string name,
+                         std::string_view name,
                          AlgorithmBits alg,
                          concurrency c,
                          tbb::flow::graph& g,
                          node_catalog& nodes,
                          std::vector<std::string>& errors)
   {
-    return registration_api<HOF, AlgorithmBits>{
-      config, std::move(name), std::move(alg), c, g, nodes, errors};
+    return registration_api<HOF, AlgorithmBits>{config, name, std::move(alg), c, g, nodes, errors};
   }
 
   // ====================================================================================
@@ -119,14 +119,14 @@ namespace phlex::detail {
   class provider_api {
   public:
     provider_api(configuration const* config,
-                 std::string name,
+                 std::string_view name,
                  AlgorithmBits alg,
                  concurrency c,
                  tbb::flow::graph& g,
                  node_catalog& nodes,
                  std::vector<std::string>& errors) :
       config_{config},
-      name_{phlex::experimental::internal::make_algorithm_name(config, std::move(name))},
+      name_{phlex::experimental::internal::make_algorithm_name(config, name)},
       alg_{std::move(alg)},
       concurrency_{c},
       graph_{g},
@@ -147,20 +147,20 @@ namespace phlex::detail {
         return product_for(std::invoke(alg, index));
       };
 
-      registrar_.set_creator(
-        [this,
-         alg = std::move(type_erased_alg),
-         output_spec = std::move(output_spec),
-         output_layer = std::move(output_layer),
-         stage = std::move(stage)](auto /* predicates */, auto /* output_product_suffixes */) {
-          return std::make_unique<provider_node>(std::move(name_),
-                                                 concurrency_.value,
-                                                 graph_,
-                                                 std::move(alg),
-                                                 std::move(output_spec),
-                                                 std::move(output_layer),
-                                                 std::move(stage));
-        });
+      registrar_.set_creator([this,
+                              alg = std::move(type_erased_alg),
+                              output_spec = std::move(output_spec),
+                              output_layer = std::move(output_layer),
+                              stage = std::move(stage)](auto const& /* predicates */,
+                                                        auto const& /* output_product_suffixes */) {
+        return std::make_unique<provider_node>(std::move(name_),
+                                               concurrency_.value,
+                                               graph_,
+                                               std::move(alg),
+                                               std::move(output_spec),
+                                               std::move(output_layer),
+                                               std::move(stage));
+      });
     }
 
   private:
@@ -186,7 +186,7 @@ namespace phlex::detail {
 
   public:
     fold_api(configuration const* config,
-             std::string name,
+             std::string_view name,
              AlgorithmBits alg,
              concurrency c,
              tbb::flow::graph& g,
@@ -195,7 +195,7 @@ namespace phlex::detail {
              std::string partition,
              InitArgs&&... init_args) :
       config_{config},
-      name_{phlex::experimental::internal::make_algorithm_name(config, std::move(name))},
+      name_{phlex::experimental::internal::make_algorithm_name(config, name)},
       alg_{std::move(alg)},
       concurrency_{c},
       graph_{g},
@@ -263,7 +263,7 @@ namespace phlex::detail {
 
   public:
     unfold_api(configuration const* config,
-               std::string name,
+               std::string_view name,
                Predicate predicate,
                Unfold unfold,
                concurrency c,
@@ -273,7 +273,7 @@ namespace phlex::detail {
                std::string destination_data_layer) :
       config_{config},
       registrar_{nodes.registrar_for<declared_unfold_ptr>(errors)},
-      name_{phlex::experimental::internal::make_algorithm_name(config, std::move(name))},
+      name_{phlex::experimental::internal::make_algorithm_name(config, name)},
       concurrency_{c.value},
       graph_{g},
       predicate_{std::move(predicate)},
@@ -329,7 +329,7 @@ namespace phlex::detail {
   public:
     output_api(registrar<declared_output_ptr> reg,
                configuration const* config,
-               std::string name,
+               std::string_view name,
                tbb::flow::graph& g,
                internal::output_function_t&& f,
                concurrency c);
diff --git a/phlex/core/store_counters.cpp b/phlex/core/store_counters.cpp
index f0dbb0257..fb6cb557d 100644
--- a/phlex/core/store_counters.cpp
+++ b/phlex/core/store_counters.cpp
@@ -9,7 +9,7 @@
 
 namespace phlex::detail {
 
-  void store_counter::set_flush_value(data_cell_counts_const_ptr counts,
+  void store_counter::set_flush_value(data_cell_counts_const_ptr const& counts,
                                       std::size_t const original_message_id)
   {
     if (not counts) {
diff --git a/phlex/core/store_counters.hpp b/phlex/core/store_counters.hpp
index d3d34ccaa..61703ab81 100644
--- a/phlex/core/store_counters.hpp
+++ b/phlex/core/store_counters.hpp
@@ -17,7 +17,7 @@
 namespace phlex::detail {
   class PHLEX_CORE_EXPORT store_counter {
   public:
-    void set_flush_value(data_cell_counts_const_ptr counts, std::size_t original_message_id);
+    void set_flush_value(data_cell_counts_const_ptr const& counts, std::size_t original_message_id);
     void increment(data_cell_index::hash_type layer_hash);
     bool is_complete();
     unsigned int original_message_id() const noexcept;
diff --git a/phlex/detail/plugin_macros.hpp b/phlex/detail/plugin_macros.hpp
index f8ba540d4..b4b054a4b 100644
--- a/phlex/detail/plugin_macros.hpp
+++ b/phlex/detail/plugin_macros.hpp
@@ -13,10 +13,10 @@
 #define PHLEX_DETAIL_NARGS(...) BOOST_PP_DEC(BOOST_PP_VARIADIC_SIZE(__VA_OPT__(, ) __VA_ARGS__))
 
 #define PHLEX_DETAIL_CREATE_1ARG(token_type, func_name, m)                                         \
-  void func_name(token_type<phlex::detail::void_tag> m, phlex::configuration const&)
+  void func_name(token_type<phlex::detail::void_tag> const& m, phlex::configuration const&)
 
 #define PHLEX_DETAIL_CREATE_2ARGS(token_type, func_name, m, cfg)                                   \
-  void func_name(token_type<phlex::detail::void_tag> m, phlex::configuration const& cfg)
+  void func_name(token_type<phlex::detail::void_tag> const& m, phlex::configuration const& cfg)
 
 #define PHLEX_DETAIL_SELECT_SIGNATURE(token_type, func_name, ...)                                  \
   BOOST_PP_IF(BOOST_PP_EQUAL(PHLEX_DETAIL_NARGS(__VA_ARGS__), 1),                                  \
@@ -41,10 +41,10 @@
 //      and calls the user's implementation.
 //   3. Open the user's implementation definition for the body that follows the macro.
 #define PHLEX_DETAIL_CREATE_SOURCE_1ARG(token_type, func_name, m)                                  \
-  void func_name(token_type<phlex::detail::void_tag> m, phlex::configuration const&)
+  void func_name(token_type<phlex::detail::void_tag> const& m, phlex::configuration const&)
 
 #define PHLEX_DETAIL_CREATE_SOURCE_2ARGS(token_type, func_name, m, cfg)                            \
-  void func_name(token_type<phlex::detail::void_tag> m, phlex::configuration const& cfg)
+  void func_name(token_type<phlex::detail::void_tag> const& m, phlex::configuration const& cfg)
 
 #define PHLEX_DETAIL_SELECT_SOURCE_SIGNATURE(token_type, func_name, ...)                           \
   BOOST_PP_IF(BOOST_PP_EQUAL(PHLEX_DETAIL_NARGS(__VA_ARGS__), 1),                                  \
@@ -64,10 +64,11 @@
 // ================================================================================================
 // Driver registration plugin macros
 #define PHLEX_DETAIL_CREATE_DRIVER_1ARG(func_name, d)                                              \
-  phlex::detail::driver_bundle func_name(phlex::detail::driver_proxy d, phlex::configuration const&)
+  phlex::detail::driver_bundle func_name(phlex::detail::driver_proxy const& d,                     \
+                                         phlex::configuration const&)
 
 #define PHLEX_DETAIL_CREATE_DRIVER_2ARGS(func_name, d, cfg)                                        \
-  phlex::detail::driver_bundle func_name(phlex::detail::driver_proxy d,                            \
+  phlex::detail::driver_bundle func_name(phlex::detail::driver_proxy const& d,                     \
                                          phlex::configuration const& cfg)
 
 #define PHLEX_DETAIL_SELECT_DRIVER_SIGNATURE(func_name, ...)                                       \
@@ -82,7 +83,7 @@
 // linkage), and then open the user's implementation definition for the body that follows.
 #define PHLEX_DETAIL_REGISTER_DRIVER_PLUGIN(func_name, dll_alias, ...)                             \
   static PHLEX_DETAIL_SELECT_DRIVER_SIGNATURE(func_name, __VA_ARGS__);                             \
-  extern "C" void dll_alias(phlex::detail::driver_proxy __phlex_proxy,                             \
+  extern "C" void dll_alias(phlex::detail::driver_proxy const& __phlex_proxy,                      \
                             phlex::configuration const& __phlex_config,                            \
                             phlex::detail::driver_bundle* __phlex_out)                             \
   {                                                                                                \
diff --git a/phlex/driver.hpp b/phlex/driver.hpp
index a80d34f7e..8c2240b84 100644
--- a/phlex/driver.hpp
+++ b/phlex/driver.hpp
@@ -136,7 +136,7 @@ namespace phlex::detail {
 
     template <typename DriverBuilder>
       requires is_driver_builder_like<DriverBuilder>
-    driver_bundle driver(std::shared_ptr<DriverBuilder> driver_builder) const
+    driver_bundle driver(std::shared_ptr<DriverBuilder> const& driver_builder) const
     {
       if (!driver_builder) {
         throw std::invalid_argument("Cannot configure driver with an empty driver builder.");
diff --git a/phlex/metaprogramming/delegate.hpp b/phlex/metaprogramming/delegate.hpp
index d5ed65bb9..192568375 100644
--- a/phlex/metaprogramming/delegate.hpp
+++ b/phlex/metaprogramming/delegate.hpp
@@ -5,32 +5,28 @@
 
 #include <functional>
 #include <memory>
+#include <utility>
 
 namespace phlex::detail {
-  template <typename FT>
-  auto delegate(std::shared_ptr<void_tag>, FT f) // Used for lambda closures
-  {
-    return std::function{f};
-  }
-
-  template <typename R, typename... Args>
-  auto delegate(std::shared_ptr<void_tag>, R (*f)(Args...))
-  {
-    return std::function{f};
-  }
+  // The first overload is used for closure objects and free functions
+  // The clang-tidy warning that 'auto f' should become 'auto const& f' is a false positive.
+  // NOLINTNEXTLINE(performance-unnecessary-value-param)
+  auto delegate(std::shared_ptr<void_tag> const&, auto f) { return std::function{std::move(f)}; }
 
   template <typename R, typename T, typename... Args>
   auto delegate(std::shared_ptr<T> obj, R (T::*f)(Args...))
   {
-    return std::function{
-      [t = std::move(obj), f](Args... args) mutable -> R { return ((*t).*f)(args...); }};
+    return std::function{[t = std::move(obj), f](Args... args) mutable -> R {
+      return std::invoke(f, *t, std::forward<Args>(args)...);
+    }};
   }
 
   template <typename R, typename T, typename... Args>
   auto delegate(std::shared_ptr<T> obj, R (T::*f)(Args...) const)
   {
-    return std::function{
-      [t = std::move(obj), f](Args... args) mutable -> R { return ((*t).*f)(args...); }};
+    return std::function{[t = std::move(obj), f](Args... args) mutable -> R {
+      return std::invoke(f, *t, std::forward<Args>(args)...);
+    }};
   }
 
   template <typename Bound, typename Algorithm>
@@ -41,11 +37,18 @@ namespace phlex::detail {
     using input_parameter_types = function_parameter_types<Algorithm>;
     static constexpr auto number_inputs = std::tuple_size_v<input_parameter_types>;
 
+    // A single templated constructor handles both cases: 'object' deduces to
+    // shared_ptr<void_tag> for free functions and closures, and to shared_ptr<T>
+    // for stateful objects.  The 'delegate' overload set performs the dispatch, so
+    // no separate code paths are needed here.  Both parameters are by-value sinks
+    // (moved into 'delegate'), so the clang-tidy const-reference warning is a false
+    // positive.
     template <typename T>
-    algorithm_bits(T object, Algorithm algorithm) :
+    algorithm_bits(T object, Algorithm algorithm) : // NOLINT(performance-unnecessary-value-param)
       bound_{delegate(std::move(object), std::move(algorithm))}
     {
     }
+
     auto release_algorithm() { return std::move(bound_); }
 
   private:
diff --git a/phlex/model/data_layer_hierarchy.cpp b/phlex/model/data_layer_hierarchy.cpp
index 93ddbce4a..c2cd69df9 100644
--- a/phlex/model/data_layer_hierarchy.cpp
+++ b/phlex/model/data_layer_hierarchy.cpp
@@ -75,7 +75,7 @@ namespace phlex::detail {
   std::string data_layer_hierarchy::pretty_recurse(
     std::map<std::string, hash_name_pairs> const& tree,
     std::string const& name,
-    std::string indent) const
+    std::string const& indent) const
   {
     auto it = tree.find(name);
     if (it == cend(tree)) {
diff --git a/phlex/model/data_layer_hierarchy.hpp b/phlex/model/data_layer_hierarchy.hpp
index bcae315d5..29650c211 100644
--- a/phlex/model/data_layer_hierarchy.hpp
+++ b/phlex/model/data_layer_hierarchy.hpp
@@ -38,7 +38,7 @@ namespace phlex::detail {
     using hash_name_pairs = std::vector<hash_name_pair>;
     std::string pretty_recurse(std::map<std::string, hash_name_pairs> const& tree,
                                std::string const& parent_name,
-                               std::string indent = {}) const;
+                               std::string const& indent = {}) const;
 
     struct layer_entry {
       layer_entry(phlex::experimental::identifier n,
diff --git a/phlex/model/fixed_hierarchy.cpp b/phlex/model/fixed_hierarchy.cpp
index c40a8b2ff..876a3098a 100644
--- a/phlex/model/fixed_hierarchy.cpp
+++ b/phlex/model/fixed_hierarchy.cpp
@@ -17,6 +17,8 @@ using phlex::experimental::layer_path;
 
 namespace {
   // Removes duplicate paths from the provided list.
+  // The paths variable is moved from, so the clang-tidy warning is a false positive.
+  // NOLINTNEXTLINE(performance-unnecessary-value-param)
   std::vector<layer_path> unique_paths(std::vector<layer_path> paths)
   {
     std::set<layer_path> const unique{std::from_range, std::move(paths)};
@@ -69,7 +71,7 @@ namespace phlex {
   data_cell_cursor::data_cell_cursor(data_cell_index_ptr index,
                                      fixed_hierarchy const& h,
                                      detail::framework_driver& d) :
-    index_{std::move(index)}, hierarchy_{h}, driver_{d}
+    index_{std::move(index)}, hierarchy_{&h}, driver_{&d}
   {
   }
 
@@ -77,9 +79,9 @@ namespace phlex {
                                                  std::size_t number) const
   {
     auto child = index_->make_child(layer_name, number);
-    hierarchy_.validate(child);
-    driver_.yield(child);
-    return data_cell_cursor{child, hierarchy_, driver_};
+    hierarchy_->validate(child);
+    driver_->yield(child);
+    return data_cell_cursor{child, *hierarchy_, *driver_};
   }
 
   experimental::layer_path data_cell_cursor::layer_path() const { return index_->layer_path(); }
@@ -110,6 +112,8 @@ namespace phlex {
   {
   }
 
+  // The layer_paths variable is directly moved from when creating the merged set.
+  // NOLINTNEXTLINE(performance-unnecessary-value-param)
   void fixed_hierarchy::update(std::vector<layer_path> layer_paths)
   {
     std::set<layer_path> merged{std::from_range, std::move(layer_paths_)};
diff --git a/phlex/model/fixed_hierarchy.hpp b/phlex/model/fixed_hierarchy.hpp
index 2c82ccabe..805d773be 100644
--- a/phlex/model/fixed_hierarchy.hpp
+++ b/phlex/model/fixed_hierarchy.hpp
@@ -35,12 +35,10 @@ namespace phlex {
                      detail::framework_driver& d);
 
     data_cell_index_ptr index_;
-    // Non-owning references to the enclosing hierarchy and driver; data_cell_cursor is a
-    // short-lived view and does not manage their lifetimes.
-    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
-    fixed_hierarchy const& hierarchy_;
-    detail::framework_driver& driver_;
-    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
+    // Non-owning pointers to the enclosing hierarchy and driver; data_cell_cursor is a
+    // short-lived, freely copyable view and does not manage their lifetimes.
+    fixed_hierarchy const* hierarchy_;
+    detail::framework_driver* driver_;
   };
 
   /// @brief Callable object that yields data cells to the framework driver.
diff --git a/phlex/model/flush_gate.cpp b/phlex/model/flush_gate.cpp
index c44d457ce..1ec32b7f0 100644
--- a/phlex/model/flush_gate.cpp
+++ b/phlex/model/flush_gate.cpp
@@ -40,10 +40,9 @@ namespace phlex::detail {
     ++received_flush_count_;
   }
 
-  void flush_gate::roll_up_child(data_cell_counts_const_ptr child_committed_counts)
+  void flush_gate::roll_up_child(data_cell_counts const& child_committed_counts)
   {
-    assert(child_committed_counts);
-    for (auto const& [layer_hash, count] : *child_committed_counts) {
+    for (auto const& [layer_hash, count] : child_committed_counts) {
       committed_counts_->add_to(layer_hash, count);
     }
     --pending_child_rollups_;
diff --git a/phlex/model/flush_gate.hpp b/phlex/model/flush_gate.hpp
index 4829a2feb..0ef064ac4 100644
--- a/phlex/model/flush_gate.hpp
+++ b/phlex/model/flush_gate.hpp
@@ -66,7 +66,7 @@ namespace phlex::detail {
     // Records that a non-lowest direct child has rolled up: merges its committed_counts
     // into this gate's and decrements the pending-rollups balance.  The two steps are
     // bundled because every rollup must do both, in the same call.
-    void roll_up_child(data_cell_counts_const_ptr child_committed_counts);
+    void roll_up_child(data_cell_counts const& child_committed_counts);
 
     // Announces that n additional non-lowest direct children are expected to roll up.
     // Lowest-layer children require no such bookkeeping: their counts are fully accounted
diff --git a/phlex/module.hpp b/phlex/module.hpp
index 9dca2e292..962a800ba 100644
--- a/phlex/module.hpp
+++ b/phlex/module.hpp
@@ -22,7 +22,7 @@ namespace phlex::detail {
     using base::graph_proxy;
 
     template <typename U, typename... Args>
-    module_graph_proxy<U> make(Args&&... args)
+    module_graph_proxy<U> make(Args&&... args) const
       requires(not is_bound_object<T>)
     {
       return this->template bind_to<module_graph_proxy, U>(std::forward<Args>(args)...);
diff --git a/phlex/source.hpp b/phlex/source.hpp
index c923d35a8..75ba84507 100644
--- a/phlex/source.hpp
+++ b/phlex/source.hpp
@@ -38,7 +38,7 @@ namespace phlex::detail {
     using base::graph_proxy;
 
     template <typename U, typename... Args>
-    providers_graph_proxy<U> make(Args&&... args)
+    providers_graph_proxy<U> make(Args&&... args) const
       requires(not is_bound_object<T>)
     {
       return this->template bind_to<providers_graph_proxy, U>(std::forward<Args>(args)...);
diff --git a/plugins/layer_generator.cpp b/plugins/layer_generator.cpp
index bfb4b7dee..d9c5c38e6 100644
--- a/plugins/layer_generator.cpp
+++ b/plugins/layer_generator.cpp
@@ -36,7 +36,7 @@ namespace phlex::experimental {
                            std::ranges::to<std::vector<layer_path_t>>()};
   }
 
-  std::size_t layer_generator::emitted_cell_count(std::string layer_path) const
+  std::size_t layer_generator::emitted_cell_count(std::string const& layer_path) const
   {
     // Check if the count of all emitted cells is requested
     if (layer_path.empty()) {
diff --git a/plugins/layer_generator.hpp b/plugins/layer_generator.hpp
index e9ce8870e..f87343f2d 100644
--- a/plugins/layer_generator.hpp
+++ b/plugins/layer_generator.hpp
@@ -63,7 +63,7 @@ namespace phlex::experimental {
     std::function<void(data_cell_yielder const)> driver_function();
 
     fixed_hierarchy hierarchy() const;
-    std::size_t emitted_cell_count(std::string layer_path = {}) const;
+    std::size_t emitted_cell_count(std::string const& layer_path = {}) const;
 
   private:
     layer_generator();
diff --git a/plugins/python/src/modulewrap.cpp b/plugins/python/src/modulewrap.cpp
index 2f1d4b946..923ff5060 100644
--- a/plugins/python/src/modulewrap.cpp
+++ b/plugins/python/src/modulewrap.cpp
@@ -61,32 +61,32 @@ using phlex::product_selector;
 // clang-format off
 struct phlex::experimental::py_phlex_module {
   PyObject_HEAD
-  phlex_module_t* ph_module;
+  phlex_module_t const* ph_module;
 };
 // clang-format on
 
-PyObject* phlex::experimental::wrap_module(phlex_module_t& module_)
+PyObject const* phlex::experimental::wrap_module(phlex_module_t const& module_)
 {
   py_phlex_module* pymod = PyObject_New(py_phlex_module, &PhlexModule_Type);
   pymod->ph_module = &module_;
 
-  return reinterpret_cast<PyObject*>(pymod);
+  return reinterpret_cast<PyObject const*>(pymod);
 }
 
 // Simple phlex source wrapper
 // clang-format off
 struct phlex::experimental::py_phlex_source {
   PyObject_HEAD
-  phlex_source_t* ph_source;
+  phlex_source_t const* ph_source;
 };
 // clang-format on
 
-PyObject* phlex::experimental::wrap_source(phlex_source_t& source)
+PyObject const* phlex::experimental::wrap_source(phlex_source_t const& source)
 {
   py_phlex_source* pysrc = PyObject_New(py_phlex_source, &PhlexSource_Type);
   pysrc->ph_source = &source;
 
-  return reinterpret_cast<PyObject*>(pysrc);
+  return reinterpret_cast<PyObject const*>(pysrc);
 }
 
 namespace {
@@ -755,7 +755,7 @@ namespace {
                         concurrency nconcur)
   {
     mod->ph_module->transform(name, converter, nconcur)
-      .input_family(pq_in)
+      .input_family(std::move(pq_in))
       .output_product_suffixes(output);
   }
 
diff --git a/plugins/python/src/pymodule.cpp b/plugins/python/src/pymodule.cpp
index d83a82a1d..57c4c7a62 100644
--- a/plugins/python/src/pymodule.cpp
+++ b/plugins/python/src/pymodule.cpp
@@ -37,7 +37,7 @@ namespace pymodule_register_providers {
       // register providers using conventional callback
       PyObject* reg = PyObject_GetAttrString(mod, "PHLEX_REGISTER_PROVIDERS");
       if (reg) {
-        PyObject* pys = wrap_source(m);
+        PyObject const* pys = wrap_source(m);
         PyObject* pyconfig = wrap_configuration(config);
         if (pys && pyconfig) {
           PyObject* res = PyObject_CallFunctionObjArgs(reg, pys, pyconfig, nullptr);
@@ -77,7 +77,7 @@ namespace pymodule_register_algorithms {
       // register algorithms using conventional callback
       PyObject* reg = PyObject_GetAttrString(mod, "PHLEX_REGISTER_ALGORITHMS");
       if (reg) {
-        PyObject* pym = wrap_module(m);
+        PyObject const* pym = wrap_module(m);
         PyObject* pyconfig = wrap_configuration(config);
         if (pym && pyconfig) {
           PyObject* res = PyObject_CallFunctionObjArgs(reg, pym, pyconfig, nullptr);
diff --git a/plugins/python/src/wrap.hpp b/plugins/python/src/wrap.hpp
index 3177e7130..861951917 100644
--- a/plugins/python/src/wrap.hpp
+++ b/plugins/python/src/wrap.hpp
@@ -37,7 +37,7 @@ namespace phlex::experimental {
 
   // Phlex' module wrapper to register algorithms
   using phlex_module_t = phlex::detail::module_graph_proxy<phlex::detail::void_tag>;
-  PyObject* wrap_module(phlex_module_t& mod); // returns new reference
+  PyObject const* wrap_module(phlex_module_t const& mod); // returns new reference
   // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   extern PyTypeObject PhlexModule_Type;
@@ -45,7 +45,7 @@ namespace phlex::experimental {
 
   // Phlex' source wrapper to register providers
   using phlex_source_t = phlex::detail::providers_graph_proxy<phlex::detail::void_tag>;
-  PyObject* wrap_source(phlex_source_t& source); // returns new reference
+  PyObject const* wrap_source(phlex_source_t const& source); // returns new reference
   // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   extern PyTypeObject PhlexSource_Type;
diff --git a/test/flush_gate_test.cpp b/test/flush_gate_test.cpp
index 08042ad85..306dd73ee 100644
--- a/test/flush_gate_test.cpp
+++ b/test/flush_gate_test.cpp
@@ -25,6 +25,7 @@
 #include "oneapi/tbb/parallel_for.h"
 #include "spdlog/spdlog.h"
 
+#include <cassert>
 #include <memory>
 #include <ranges>
 
@@ -67,7 +68,9 @@ namespace {
       auto parent = index->parent();
       if (parent) {
         if (gates_t::accessor pa; gates.find(pa, parent->hash())) {
-          pa->second->roll_up_child(gate->committed_counts());
+          auto committed_counts = gate->committed_counts();
+          assert(committed_counts);
+          pa->second->roll_up_child(*committed_counts);
         }
       }
       gates.erase(a);
@@ -222,13 +225,13 @@ TEST_CASE("flush_gate: roll_up_child accumulates across multiple children", "[fl
   job_gate->update_expected_count(run_layer_hash, 2);
 
   // Simulate run 0 rolling up with 3 spills.
-  auto run0_committed = std::make_shared<data_cell_counts>();
-  run0_committed->add_to(spill_layer_hash, 3);
+  data_cell_counts run0_committed;
+  run0_committed.add_to(spill_layer_hash, 3);
   job_gate->roll_up_child(run0_committed);
 
   // Simulate run 1 rolling up with 5 spills.
-  auto run1_committed = std::make_shared<data_cell_counts>();
-  run1_committed->add_to(spill_layer_hash, 5);
+  data_cell_counts run1_committed;
+  run1_committed.add_to(spill_layer_hash, 5);
   job_gate->roll_up_child(run1_committed);
 
   REQUIRE(job_gate->all_children_accounted());

From 090f7384f09411e9fe9546e0344f370ccb214ee5 Mon Sep 17 00:00:00 2001
From: Kyle Knoepfel <knoepfel@fnal.gov>
Date: Fri, 31 Jul 2026 15:42:14 -0500
Subject: [PATCH 2/3] docs: record PR #796 for
 performance-unnecessary-value-param clang-tidy fixes

---
 docs/dev/clang-tidy-fixes-2026-04.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/dev/clang-tidy-fixes-2026-04.md b/docs/dev/clang-tidy-fixes-2026-04.md
index 2a6c2b498..512132072 100644
--- a/docs/dev/clang-tidy-fixes-2026-04.md
+++ b/docs/dev/clang-tidy-fixes-2026-04.md
@@ -150,7 +150,8 @@
   - Resolved incidentally by [PR #551](https://github.com/Framework-R-D/phlex/pull/551)
 - [x] [performance-unnecessary-copy-initialization](https://clang.llvm.org/extra/clang-tidy/checks/performance/unnecessary-copy-initialization.html) (1)
   - [PR #590](https://github.com/Framework-R-D/phlex/pull/590)
-- [ ] [performance-unnecessary-value-param](https://clang.llvm.org/extra/clang-tidy/checks/performance/unnecessary-value-param.html) (44)
+- [x] [performance-unnecessary-value-param](https://clang.llvm.org/extra/clang-tidy/checks/performance/unnecessary-value-param.html) (44)
+  - [PR #796](https://github.com/Framework-R-D/phlex/pull/796)
 - [x] [portability-template-virtual-member-function](https://clang.llvm.org/extra/clang-tidy/checks/portability/template-virtual-member-function.html) (2)
   - [PR #591](https://github.com/Framework-R-D/phlex/pull/591)
 - [x] [readability-avoid-const-params-in-decls](https://clang.llvm.org/extra/clang-tidy/checks/readability/avoid-const-params-in-decls.html) (7)

From 1d1eb6cb5c553a0498512cab906f7bfcdf457413 Mon Sep 17 00:00:00 2001
From: Kyle Knoepfel <knoepfel@fnal.gov>
Date: Fri, 31 Jul 2026 16:09:43 -0500
Subject: [PATCH 3/3] Resolve coderabbit comments

---
 phlex/app/load_module.cpp         | 10 ++++++----
 phlex/core/graph_proxy.hpp        |  6 ++++--
 phlex/driver.hpp                  |  2 +-
 phlex/module.hpp                  |  2 +-
 plugins/python/src/modulewrap.cpp |  8 ++++----
 plugins/python/src/pymodule.cpp   |  4 ++--
 plugins/python/src/wrap.hpp       |  4 ++--
 7 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/phlex/app/load_module.cpp b/phlex/app/load_module.cpp
index e4d1e1ef5..35c96e46e 100644
--- a/phlex/app/load_module.cpp
+++ b/phlex/app/load_module.cpp
@@ -28,9 +28,9 @@ namespace phlex::detail {
       boost::dll::shared_library lib;
       internal::module_creator_t* fn{};
 
-      void operator()(module_graph_proxy<void_tag> proxy, configuration const& config) const
+      void operator()(module_graph_proxy<void_tag> const& proxy, configuration const& config) const
       {
-        fn(std::move(proxy), config);
+        fn(proxy, config);
       }
     };
 
@@ -48,9 +48,11 @@ namespace phlex::detail {
       boost::dll::shared_library lib;
       internal::driver_shim_t* fn{};
 
-      void operator()(driver_proxy proxy, configuration const& config, driver_bundle* out) const
+      void operator()(driver_proxy const& proxy,
+                      configuration const& config,
+                      driver_bundle* out) const
       {
-        fn(std::move(proxy), config, out);
+        fn(proxy, config, out);
       }
     };
 
diff --git a/phlex/core/graph_proxy.hpp b/phlex/core/graph_proxy.hpp
index e851551bd..ed429def2 100644
--- a/phlex/core/graph_proxy.hpp
+++ b/phlex/core/graph_proxy.hpp
@@ -97,7 +97,9 @@ namespace phlex::detail {
       requires(not is_bound_object<T>);
 
     /// @brief Registers an output node.
-    auto output(std::string_view name, is_output_like auto f, concurrency c = concurrency::serial);
+    auto output(std::string_view name,
+                is_output_like auto f,
+                concurrency c = concurrency::serial) const;
 
   protected:
     template <template <typename> typename Proxy, typename U, typename... Args>
@@ -204,7 +206,7 @@ namespace phlex::detail {
   }
 
   template <typename T>
-  auto graph_proxy<T>::output(std::string_view name, is_output_like auto f, concurrency c)
+  auto graph_proxy<T>::output(std::string_view name, is_output_like auto f, concurrency c) const
   {
     return create_glue().output(name, std::move(f), c);
   }
diff --git a/phlex/driver.hpp b/phlex/driver.hpp
index 8c2240b84..108ecacb6 100644
--- a/phlex/driver.hpp
+++ b/phlex/driver.hpp
@@ -32,7 +32,7 @@ namespace phlex::detail {
     using next_index_t = std::function<void(framework_driver&)>;
     // Shim type for the extern "C" entry-point: out-parameter avoids returning a C++ type
     // across a C-linkage boundary.
-    using driver_shim_t = void(driver_proxy, configuration const&, driver_bundle*);
+    using driver_shim_t = void(driver_proxy const&, configuration const&, driver_bundle*);
 
     template <typename SourceType>
     std::remove_cvref_t<SourceType> const& as_driver_source(source const* src, std::size_t index)
diff --git a/phlex/module.hpp b/phlex/module.hpp
index 962a800ba..d02e26d54 100644
--- a/phlex/module.hpp
+++ b/phlex/module.hpp
@@ -37,7 +37,7 @@ namespace phlex::detail {
   };
 
   namespace internal {
-    using module_creator_t = void(module_graph_proxy<void_tag>, configuration const&);
+    using module_creator_t = void(module_graph_proxy<void_tag> const&, configuration const&);
   }
 }
 
diff --git a/plugins/python/src/modulewrap.cpp b/plugins/python/src/modulewrap.cpp
index 923ff5060..4c254c386 100644
--- a/plugins/python/src/modulewrap.cpp
+++ b/plugins/python/src/modulewrap.cpp
@@ -65,12 +65,12 @@ struct phlex::experimental::py_phlex_module {
 };
 // clang-format on
 
-PyObject const* phlex::experimental::wrap_module(phlex_module_t const& module_)
+PyObject* phlex::experimental::wrap_module(phlex_module_t const& module_)
 {
   py_phlex_module* pymod = PyObject_New(py_phlex_module, &PhlexModule_Type);
   pymod->ph_module = &module_;
 
-  return reinterpret_cast<PyObject const*>(pymod);
+  return reinterpret_cast<PyObject*>(pymod);
 }
 
 // Simple phlex source wrapper
@@ -81,12 +81,12 @@ struct phlex::experimental::py_phlex_source {
 };
 // clang-format on
 
-PyObject const* phlex::experimental::wrap_source(phlex_source_t const& source)
+PyObject* phlex::experimental::wrap_source(phlex_source_t const& source)
 {
   py_phlex_source* pysrc = PyObject_New(py_phlex_source, &PhlexSource_Type);
   pysrc->ph_source = &source;
 
-  return reinterpret_cast<PyObject const*>(pysrc);
+  return reinterpret_cast<PyObject*>(pysrc);
 }
 
 namespace {
diff --git a/plugins/python/src/pymodule.cpp b/plugins/python/src/pymodule.cpp
index 57c4c7a62..d83a82a1d 100644
--- a/plugins/python/src/pymodule.cpp
+++ b/plugins/python/src/pymodule.cpp
@@ -37,7 +37,7 @@ namespace pymodule_register_providers {
       // register providers using conventional callback
       PyObject* reg = PyObject_GetAttrString(mod, "PHLEX_REGISTER_PROVIDERS");
       if (reg) {
-        PyObject const* pys = wrap_source(m);
+        PyObject* pys = wrap_source(m);
         PyObject* pyconfig = wrap_configuration(config);
         if (pys && pyconfig) {
           PyObject* res = PyObject_CallFunctionObjArgs(reg, pys, pyconfig, nullptr);
@@ -77,7 +77,7 @@ namespace pymodule_register_algorithms {
       // register algorithms using conventional callback
       PyObject* reg = PyObject_GetAttrString(mod, "PHLEX_REGISTER_ALGORITHMS");
       if (reg) {
-        PyObject const* pym = wrap_module(m);
+        PyObject* pym = wrap_module(m);
         PyObject* pyconfig = wrap_configuration(config);
         if (pym && pyconfig) {
           PyObject* res = PyObject_CallFunctionObjArgs(reg, pym, pyconfig, nullptr);
diff --git a/plugins/python/src/wrap.hpp b/plugins/python/src/wrap.hpp
index 861951917..c65523758 100644
--- a/plugins/python/src/wrap.hpp
+++ b/plugins/python/src/wrap.hpp
@@ -37,7 +37,7 @@ namespace phlex::experimental {
 
   // Phlex' module wrapper to register algorithms
   using phlex_module_t = phlex::detail::module_graph_proxy<phlex::detail::void_tag>;
-  PyObject const* wrap_module(phlex_module_t const& mod); // returns new reference
+  PyObject* wrap_module(phlex_module_t const& mod); // returns new reference
   // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   extern PyTypeObject PhlexModule_Type;
@@ -45,7 +45,7 @@ namespace phlex::experimental {
 
   // Phlex' source wrapper to register providers
   using phlex_source_t = phlex::detail::providers_graph_proxy<phlex::detail::void_tag>;
-  PyObject const* wrap_source(phlex_source_t const& source); // returns new reference
+  PyObject* wrap_source(phlex_source_t const& source); // returns new reference
   // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   extern PyTypeObject PhlexSource_Type;