feat(stats): Implement QuanuX-Statistics & Fix C++ Builds

- Implemented QuanuX-Statistics Node:
    - Added StatsEngine with NATS ingestion and DuckDB storage
    - Implemented Welford's Algorithm (Online Variance)
    - Implemented Pairwise Correlation tracking
    - Added Z-Score signal publishing
- Fixed Execution Node Builds:
    - Resolved StrategyContext ambiguity in ping_pong.cpp
    - Fixed cpp-httplib linker target (httplib::httplib)
    - Added missing Simulator headers (SimulatedExchange.h, DuckDBFeeder.h)
    - Fixed IDE lint errors (include paths)
- Documentation:
    - Added QuanuX-Statistics/SKILL.md
    - Updated execution-node/SKILL.md with HFT & Simulator guides
- Added scripts/test_pub.py for market data simulation

Author: quantDIY

QuanuX-Statistics/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: manage-quanux-statistics
+description: Guide for developing and operating the QuanuX Statistics & Research Node.
+---
+
+# QuanuX Statistics Node
+
+The **QuanuX Statistics Node** (`quanux_stats`) is a purpose-built service for real-time market analysis and signal generation. It bridges the gap between raw market data and high-level strategy logic by providing pre-calculated metrics.
+
+## Capabilities
+
+1.  **Online Statistics**:
+    -   Uses **Welford's Algorithm** to track Variance and Standard Deviation with $O(1)$ complexity/storage per tick.
+    -   Tracks **Z-scores** relative to a rolling window (default 100 ticks).
+    -   Calculates **Pairwise Correlation** matrices in real-time.
+
+2.  **Data Persistence**:
+    -   Ingests `MARKET.*` data from NATS (JSON format).
+    -   Writes to **DuckDB** (`market_stats.duckdb`) for offline research and backtesting.
+    -   *Future*: Will support Parquet export for S3 archival.
+
+3.  **Signal Publishing**:
+    -   Publishes derived metrics to `STATS.<SYMBOL>` on NATS.
+    -   Format: `{"symbol": "ES", "volatility": 12.5, "z_score": 1.2, ...}`
+
+## Architecture
+
+-   **Language**: C++20
+-   **Core**: `StatsEngine` class.
+-   **Storage**: `stats_map_` (Red-Black Tree) for per-symbol state.
+-   **Concurrency**: Single-threaded NATS consumer (for now) protected by `std::mutex` for future expansion.
+
+## Development Guide
+
+### Adding a New Metric
+1.  **Update `InstrumentStats`** in `include/stats_engine.h`:
+    Add a new accumulator (e.g., `double sum_log_return`).
+2.  **Update `update()`** in `src/stats_engine.cpp`:
+    Implement the online update formula.
+3.  **Publish**:
+    Add the new field to the `json derived` object in the NATS callback.
+
+### Running Locally
+```bash
+# Build
+cd QuanuX-Statistics/cpp/build
+make quanux_stats
+
+# Run (Ensure NATS is up)
+./quanux_stats
+```
+
+## Dependencies
+-   **DuckDB**: Embedded DB for storage.
+-   **NATS C Client**: High-performance messaging.
+-   **Eigen**: Linear algebra (Matrix operations).
+-   **nlohmann/json**: Serialization.

QuanuX-Statistics/cpp/CMakeLists.txt

@@ -0,0 +1,75 @@
+cmake_minimum_required(VERSION 3.20)
+project(quanux_stats CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Optimization
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+if (UNIX)
+    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -mtune=native -fno-omit-frame-pointer")
+endif()
+
+# Dependencies
+include(FetchContent)
+
+# 1. NATS (Telemetry/Data)
+set(NATS_BUILD_STREAMING OFF CACHE BOOL "" FORCE)
+FetchContent_Declare(
+  cnats
+  GIT_REPOSITORY https://github.com/nats-io/nats.c.git
+  GIT_TAG        v3.9.0
+)
+FetchContent_MakeAvailable(cnats)
+
+# 2. DuckDB (Storage/Analytics)
+FetchContent_Declare(
+    duckdb
+    GIT_REPOSITORY https://github.com/duckdb/duckdb.git
+    GIT_TAG v1.1.3
+    GIT_SHALLOW TRUE
+)
+set(BUILD_UNITTESTS OFF CACHE BOOL "" FORCE)
+set(BUILD_SHELL OFF CACHE BOOL "" FORCE)
+set(BUILD_EXTENSIONS "parquet;json" CACHE STRING "" FORCE)
+FetchContent_MakeAvailable(duckdb)
+
+# 3. Eigen (Math/Stats)
+FetchContent_Declare(
+  eigen
+  GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+  GIT_TAG 3.4.0
+)
+FetchContent_MakeAvailable(eigen)
+
+# 4. JSON
+FetchContent_Declare(
+    nlohmann_json
+    GIT_REPOSITORY https://github.com/nlohmann/json.git
+    GIT_TAG v3.11.3
+)
+FetchContent_MakeAvailable(nlohmann_json)
+
+# Includes
+include_directories(include)
+include_directories(../../QuanuX-Common/cpp/include)
+
+# Core Library
+add_library(stats_core STATIC
+    src/stats_engine.cpp
+    src/time_series_store.cpp
+)
+target_link_libraries(stats_core PUBLIC 
+    nats_static 
+    duckdb_static 
+    Eigen3::Eigen 
+    nlohmann_json::nlohmann_json
+    pthread 
+    dl
+)
+
+# Main Service
+add_executable(quanux_stats src/main.cpp)
+target_link_libraries(quanux_stats PRIVATE stats_core)

QuanuX-Statistics/cpp/include/stats_engine.h

@@ -0,0 +1,76 @@
+#pragma once
+#include <Eigen/Dense>
+#include <atomic>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+// Forward decls
+namespace duckdb {
+class Connection;
+class DuckDB;
+} // namespace duckdb
+
+class StatsEngine {
+public:
+  StatsEngine();
+  ~StatsEngine();
+
+  void connect_nats(const std::string &url);
+  void connect_db(const std::string &path);
+  void run();
+  void stop();
+
+private:
+  std::atomic<bool> running_{false};
+  std::unique_ptr<duckdb::DuckDB> db_;
+  std::unique_ptr<duckdb::Connection> conn_;
+
+  // NATS handle (void* to keep header clean of C includes if desired, but
+  // sticking to simple for now) We'll impl in cpp
+  struct NatsContext;
+  std::unique_ptr<NatsContext> nats_;
+
+  // Online Stats State (Example: Keeping a rolling window for correlation)
+  // Vector of recent prices for correlation calculation
+  struct InstrumentStats {
+    uint64_t count = 0;
+    double mean = 0.0;
+    double M2 = 0.0; // Welford's algorithm accumulator
+
+    // Z-Score window
+    std::vector<double> window;
+    size_t window_size = 100;
+
+    void update(double price);
+    double variance() const;
+    double std_dev() const;
+  };
+
+  // Online Correlation State (Pairwise)
+  struct CorrelationStats {
+    uint64_t count = 0;
+    double mean_x = 0.0;
+    double mean_y = 0.0;
+    double C_xy = 0.0; // Co-moment accumulator
+
+    void update(double x, double y);
+    double covariance() const;
+    double correlation(double std_dev_x, double std_dev_y) const;
+  };
+
+  // Map instrument_id (symbol) -> Stats
+  std::map<std::string, InstrumentStats> stats_map_;
+
+  // Map (symbolA, symbolB) -> CorrelationStats
+  // Key is sorted: pair(min(A,B), max(A,B))
+  std::map<std::pair<std::string, std::string>, CorrelationStats> corr_map_;
+  std::mutex
+      stats_mutex_; // Protect maps from NATS callbacks if multithreaded (NATS C
+                    // is usually single threaded callback context, but safer)
+
+  void update_correlation(const std::string &symbol, double price);
+};

QuanuX-Statistics/cpp/src/main.cpp

@@ -0,0 +1,27 @@
+#include "stats_engine.h"
+#include <cstdlib>
+#include <iostream>
+
+int main(int argc, char **argv) {
+  std::cout << R"(
+   ___                         _  __    __  
+  / _ \ _   _  __ _ _ __  _   | | \ \  / /  
+ | | | | | | |/ _` | '_ \| |  | |  \ \/ /   
+ | |_| | |_| | (_| | | | | |_ | |  / /\ \   
+  \__\_\\__,_|\__,_|_| |_|\__,|_| /_/  \_\  
+                                            
+      QuanuX Statistics & Research Node      
+    )" << std::endl;
+
+  StatsEngine engine;
+
+  const char *nats_url = std::getenv("QUANUX_NATS_URL");
+  const char *db_path = std::getenv("QUANUX_DB_PATH");
+
+  engine.connect_nats(nats_url ? nats_url : "nats://localhost:4222");
+  engine.connect_db(db_path ? db_path : "market_stats.duckdb");
+
+  engine.run();
+
+  return 0;
+}