test

        std::vector<uint8_t> data;

        if (pclient_) {

            try {

                std::unique_lock<std::timed_mutex> lock(client_mutex_, std::chrono::seconds(5)); if (!lock.owns_lock()) throw std::runtime_error("cluster client lock timeout");

                std::unique_lock<std::timed_mutex> lock(client_mutex_, std::chrono::seconds(2)); if (!lock.owns_lock()) throw std::runtime_error("cluster client lock timeout");

                data = pclient_->retrieve(sgid);

                if (!data.empty()) {

                    uuid::uuid d_uid, d_did;

#include <string>

#include <vector>

#include <deque>

#include <memory>

#include <mutex>

#include <condition_variable>

        std::atomic<bool> degraded_{false};

        std::thread server_thread_;

        std::thread health_monitor_thread_;

        std::thread push_worker_thread_;

        std::mutex monitor_mutex_;

        std::condition_variable monitor_cv_;

        std::mutex push_mutex_;

        std::condition_variable push_cv_;

        struct PendingPush {

            std::vector<uint8_t> data;

            uint64_t sgid;

            uint64_t sid_gid;

            int retries{0};

        };

        std::deque<PendingPush> push_queue_;

        std::shared_ptr<paritypp::block_store> store_;

        std::shared_ptr<paritypp::memory_block_store> session_store_; // sessions only

        void server_loop();

        void health_monitor_loop();

        void push_worker_loop();

    };

    // Global cluster instance

        }

    }

    // Check cluster for existing session

    if (g_Cluster && g_Cluster->isRunning()) {

    // Check cluster for existing session (skip when degraded to avoid blocking)

    if (g_Cluster && g_Cluster->isRunning() && !g_Cluster->isDegraded()) {

        uuid::uuid cluster_sid;

        std::vector<uuid::uuid> cluster_members;

        std::string cluster_username;