fix: resolve circular deps, header test, and inspect CI failures

- local.hpp: use only source-tree headers (hpx/execution.hpp, hpx/numeric.hpp)
  instead of generated .hpp.in headers (algorithm.hpp, future.hpp)
- local.hpp: remove all hpx_main.hpp references from comments
- local_header.cpp: use hpx::local::init instead of hpx_main.hpp wrapping
- tests/unit/CMakeLists.txt: remove HPX::wrap_main dependency
Refs: #7070

Signed-off-by: shivansh023023 <singhshivansh023@gmail.com>

Author: shivansh023023

libs/core/config/include/hpx/config/static_linker_check.hpp

@@ -24,6 +24,8 @@
     defined(HPX_HAVE_STATIC_LINKING) &&                                        \
     !defined(HPX_HAVE_WRAP_MAIN_CONFIGURED)
 // clang-format off
-#warning "HPX: Static Linux build detected. The linker requires '-Wl,-wrap=main' to properly intercept main(). If you are linking manually, add this flag to your linker command. Define 'HPX_HAVE_WRAP_MAIN_CONFIGURED' to suppress this warning."
+#warning \
+    "HPX: -Wl,-wrap=main not detected. " \
+    "Link via HPX::wrap_main or add flag manually."
 // clang-format on
 #endif

libs/core/include_local/include/hpx/local.hpp

@@ -7,28 +7,20 @@
 /// \file hpx/local.hpp
 /// \brief Single-include convenience header for single-node HPX usage.
 ///
-/// This header bundles the **Standard Parallel Toolkit** — the most commonly
+/// This header bundles the **Standard Parallel Toolkit** -- the most commonly
 /// used HPX facilities for local (single-node) execution:
 ///
-///   - \c hpx/algorithm.hpp  — Parallel STL algorithms (for_each, sort, ...)
-///   - \c hpx/execution.hpp  — Execution policies (par, par_unseq, seq)
-///   - \c hpx/future.hpp     — Async primitives (hpx::async, hpx::future)
-///   - \c hpx/numeric.hpp    — Parallel numeric algorithms (reduce, ...)
+///   - \c hpx/execution.hpp  -- Execution policies (par, par_unseq, seq)
+///   - \c hpx/numeric.hpp    -- Parallel algorithms (for_each, sort, reduce, ...)
 ///
 /// **Selection criteria**: each header is part of the HPX core module,
 /// provides ISO C++ Standard Library parallel equivalents, and has no
 /// dependency on the distributed runtime or networking layer.
-///
-/// \note For zero-boilerplate `main()` wrapping to automatically start
-///       and stop the HPX runtime, please additionally include
-///       `#include <hpx/hpx_main.hpp>`.
 
 #pragma once
 
 #include <hpx/config.hpp>
 
 // --- Standard Parallel Toolkit (core, no networking dependency) ---
-#include <hpx/algorithm.hpp>
 #include <hpx/execution.hpp>
-#include <hpx/future.hpp>
 #include <hpx/numeric.hpp>

libs/core/include_local/tests/unit/CMakeLists.txt

@@ -6,7 +6,7 @@
 
 set(tests local_header)
 
-set(local_header_FLAGS NOLIBS DEPENDENCIES HPX::hpx HPX::wrap_main)
+set(local_header_FLAGS NOLIBS DEPENDENCIES HPX::hpx)
 
 foreach(test ${tests})
   set(sources ${test}.cpp)

libs/core/include_local/tests/unit/local_header.cpp

@@ -5,39 +5,38 @@
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 // Verify that hpx/local.hpp provides access to the Standard Parallel Toolkit:
-// futures, parallel algorithms, numeric algorithms, and execution policies.
+// parallel algorithms, numeric algorithms, and execution policies.
 //
-// For zero-boilerplate main() wrapping, we must explicitly include hpx_main.hpp.
+// We use hpx::local::init to avoid any dependency on the full wrap module.
 
 #include <hpx/config.hpp>
 
-#include <hpx/hpx_main.hpp>
-
+#include <hpx/init_runtime_local/init_runtime_local.hpp>
 #include <hpx/local.hpp>
 
 #include <cstddef>
 #include <iostream>
 #include <numeric>
 #include <vector>
 
-int main()
+int test_main(int argc, char* argv[])
 {
-    // 1. Verify hpx::async and hpx::future are reachable
-    hpx::future<int> f = hpx::async([]() { return 42; });
-    int result = f.get();
-
-    // 2. Verify parallel algorithms are reachable
+    // 1. Verify parallel algorithms are reachable via hpx/local.hpp
     std::vector<int> v(100);
     std::iota(v.begin(), v.end(), 1);
 
     hpx::for_each(
         hpx::execution::par, v.begin(), v.end(), [](int& x) { x *= 2; });
 
-    // 3. Verify numeric algorithms are reachable
+    // 2. Verify numeric algorithms are reachable
     int sum = hpx::reduce(hpx::execution::par, v.begin(), v.end(), 0);
 
-    std::cout << "async result: " << result << ", reduce sum: " << sum
-              << std::endl;
+    std::cout << "reduce sum: " << sum << std::endl;
 
-    return 0;
+    return hpx::local::finalize();
+}
+
+int main(int argc, char* argv[])
+{
+    return hpx::local::init(test_main, argc, argv);
 }