【閱讀指南：雙軌導航聲明】

/**
 * Target Language: C++20 (ISO/IEC 14882:2020 Standard)
 * Substrate: Linux x86_64 Bare-Metal / K8s Host Node / Devfs GPIO V2
 * Kernel ABI: Linux GPIO V2 ioctl, Netlink IFLA_XDP, SCHED_FIFO + mlockall, Raw clone(), POSIX SHM IPC
 * Architecture: MSO-E28 L8/15.0 Gold Master (Absolute Zero-Heap Autonomous Core)
 * Paradigm: Zero Dynamic Allocation, Raw Syscall Threading, TCP Stream Alignment
 */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <iostream>
#include <string_view>
#include <array>
#include <atomic>
#include <chrono>
#include <cstring>
#include <cstdlib>
#include <cerrno>
#include <cstdio>
#include <ctime>

#include <unistd.h>
#include <fcntl.h>
#include <sched.h>
#include <signal.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/capability.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <linux/gpio.h>
#include <linux/bpf.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>

// -----------------------------------------------------------------------------
// 1. DOMAIN ONTOLOGY CONSTANTS (Zero Dynamic Allocation)
// -----------------------------------------------------------------------------
inline constexpr std::string_view ADDR_ROOT     = "0xFF_ROOT";
inline constexpr std::string_view ADDR_BASE_VEC = "0x18_0x1A_0x1C";
inline constexpr std::string_view ADDR_DO       = "0x18_DO";
inline constexpr std::string_view ADDR_RE       = "0x1A_RE";
inline constexpr std::string_view ADDR_WORDS    = "0x08_WORDS";
inline constexpr std::string_view ADDR_BARRIER  = "0x3F_BARRIER";

// -----------------------------------------------------------------------------
// 2. IPC SHARED MEMORY & HARDWARE LATCHES
// -----------------------------------------------------------------------------
struct alignas(64) HardwareLatches {
    std::atomic<bool> caps_zero_latch{false};
    std::atomic<bool> mem_zero_latch{false};
    std::atomic<bool> pll_lock_latch{false};
    std::atomic<bool> bpf_mount_latch{false};
    std::atomic<bool> gpio_tree_latch{false};
};

struct alignas(64) ProcessSharedState {
    std::atomic<bool> global_running{true};
    std::atomic<bool> lease_held{false};
    std::atomic<uint64_t> telemetry_pass_count{0};
    std::atomic<uint32_t> scheduler_cycles{0};
    HardwareLatches boot_latches{};
};

static ProcessSharedState* g_ipc_state = nullptr;

static void sigterm_handler(int signum) {
    if (signum == SIGTERM || signum == SIGINT) {
        if (g_ipc_state) {
            g_ipc_state->global_running.store(false, std::memory_order_release);
        }
    }
}

// -----------------------------------------------------------------------------
// 3. ZERO-ALLOCATION STATIC LOGGER
// -----------------------------------------------------------------------------
class StaticLogger {
public:
    static void init() { openlog("MSO-E28-L8-CORE", LOG_PID | LOG_NDELAY, LOG_DAEMON); }
    static void info(std::string_view msg) { write_log(LOG_INFO, "[INFO] ", msg); }
    static void warning(std::string_view msg) { write_log(LOG_WARNING, "[WARN] ", msg); }
    static void error(std::string_view msg) { write_log(LOG_ERR, "[ERROR] ", msg); }
    static void critical(std::string_view msg) { write_log(LOG_CRIT, "[CRIT] ", msg); }
    static void shutdown() { closelog(); }
private:
    static void write_log(int priority, std::string_view prefix, std::string_view msg) {
        syslog(priority, "%.*s%.*s", static_cast<int>(prefix.size()), prefix.data(), static_cast<int>(msg.size()), msg.data());
        char buf[512];
        int len = std::snprintf(buf, sizeof(buf), "%.*s%.*s\n", static_cast<int>(prefix.size()), prefix.data(), static_cast<int>(msg.size()), msg.data());
        if (len > 0) {
            [[maybe_unused]] auto _ = write(priority <= LOG_WARNING ? STDERR_FILENO : STDOUT_FILENO, buf, len);
        }
    }
};

// -----------------------------------------------------------------------------
// 4. LOGIC D: CAPABILITIES & SECURITY CONTEXT
// -----------------------------------------------------------------------------
class SovereigntyController {
public:
    static void enforce_capabilities() noexcept {
        if (g_ipc_state->boot_latches.caps_zero_latch.load(std::memory_order_acquire)) return;

        cap_t caps = cap_get_proc();
        if (!caps) _exit(EXIT_FAILURE);

        cap_value_t keep_caps[] = { CAP_SYS_ADMIN, CAP_NET_ADMIN, CAP_SYS_RAWIO, CAP_BPF, CAP_SYS_NICE, CAP_SYS_RESOURCE };
        cap_clear(caps);
        cap_set_flag(caps, CAP_PERMITTED, 6, keep_caps, CAP_SET);
        cap_set_flag(caps, CAP_EFFECTIVE, 6, keep_caps, CAP_SET);

        if (cap_set_proc(caps) != 0) _exit(EXIT_FAILURE);
        cap_free(caps);

        g_ipc_state->boot_latches.caps_zero_latch.store(true, std::memory_order_release);
        StaticLogger::info("[0xFF_ROOT] 4-Stage Lock: PoLP Enforced.");
    }
};

// -----------------------------------------------------------------------------
// 5. LOGIC B: RESOURCE SCHEDULING & MEMORY LOCK
// -----------------------------------------------------------------------------
class InitialProgramLoader {
public:
    static void trigger_power_on_reset() noexcept {
        if (g_ipc_state->boot_latches.mem_zero_latch.load(std::memory_order_acquire)) return;
        if (mlockall(MCL_CURRENT | MCL_FUTURE) == 0) {
            StaticLogger::info("[LOGIC_B] Memory locked. Paging disabled.");
        }
        g_ipc_state->boot_latches.mem_zero_latch.store(true, std::memory_order_release);
    }

    static void activate_main_oscillator() noexcept {
        if (g_ipc_state->boot_latches.pll_lock_latch.load(std::memory_order_acquire)) return;
        struct sched_param param{};
        param.sched_priority = 80;
        if (sched_setscheduler(0, SCHED_FIFO, &param) == 0) {
            StaticLogger::info("[MAIN_OSC] RT Scheduler Active.");
        }
        g_ipc_state->boot_latches.pll_lock_latch.store(true, std::memory_order_release);
    }
};

// -----------------------------------------------------------------------------
// 6. HARDWARE GPIO V2 ACTUATOR
// -----------------------------------------------------------------------------
class ModernGpioV2Actuator {
private:
    int chip_fd_{-1};
    int line_fd_{-1};
public:
    ModernGpioV2Actuator() {
        constexpr std::array<const char*, 4> CHIP_PATHS = { "/dev/gpiochip0", "/dev/gpiochip1", "/dev/gpiochip2", "/dev/gpiochip3" };
        for (const char* path : CHIP_PATHS) {
            int fd = open(path, O_RDWR | O_CLOEXEC);
            if (fd >= 0) {
                struct gpiochip_info info{};
                if (ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, &info) >= 0) {
                    chip_fd_ = fd;
                    StaticLogger::info("Logic F: Bound to GPIO-V2 Hardware Line.");
                    return;
                }
                close(fd);
            }
        }
    }
    ~ModernGpioV2Actuator() {
        if (line_fd_ >= 0) { write_actuator_state(false); close(line_fd_); }
        if (chip_fd_ >= 0) close(chip_fd_);
    }
    bool configure_output_line(uint32_t offset) {
        if (chip_fd_ < 0) return false;
        struct gpio_v2_line_request req{};
        req.offsets[0] = offset; req.num_lines = 1; req.config.flags = GPIO_V2_LINE_FLAG_OUTPUT;
        std::strncpy(req.consumer, "MSO-E28-L8", sizeof(req.consumer) - 1);
        if (ioctl(chip_fd_, GPIO_V2_GET_LINE_IOCTL, &req) < 0) return false;
        line_fd_ = req.fd;
        return true;
    }
    void write_actuator_state(bool high) noexcept {
        if (line_fd_ < 0) return;
        struct gpio_v2_line_values vals{};
        vals.mask = 1ULL; vals.bits = high ? 1ULL : 0ULL;
        ioctl(line_fd_, GPIO_V2_LINE_SET_VALUES_IOCTL, &vals);
    }
};

// -----------------------------------------------------------------------------
// 7. TRUE EBPF/XDP TELEMETRY
// -----------------------------------------------------------------------------
class XDPTelemetryFilter {
private:
    int map_fd_{-1};
    int prog_fd_{-1};
    int ifindex_{1};

    static struct rtattr* rta_append(struct rtattr* parent, size_t max_len, unsigned short type, const void* data, size_t data_len) noexcept {
        size_t rta_len = RTA_LENGTH(data_len);
        size_t total_len = RTA_ALIGN(parent->rta_len) + RTA_ALIGN(rta_len);
        if (total_len > max_len) return nullptr;
        auto* sub = reinterpret_cast<struct rtattr*>(reinterpret_cast<char*>(parent) + RTA_ALIGN(parent->rta_len));
        sub->rta_type = type;
        sub->rta_len = static_cast<unsigned short>(rta_len);
        std::memcpy(RTA_DATA(sub), data, data_len);
        parent->rta_len = static_cast<unsigned short>(total_len);
        return sub;
    }

    bool attach_xdp_netlink(int ifindex, int fd) {
        int nl_sock = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
        if (nl_sock < 0) return false;

        struct timeval tv{ .tv_sec = 0, .tv_usec = 200'000 };
        setsockopt(nl_sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

        struct { struct nlmsghdr nh; struct ifinfomsg ifi; char attrbuf[256]; } req{};
        req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
        req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
        req.nh.nlmsg_type = RTM_SETLINK;
        req.ifi.ifi_index = ifindex;

        auto* rta = reinterpret_cast<struct rtattr*>(reinterpret_cast<char*>(&req) + NLMSG_ALIGN(req.nh.nlmsg_len));
        rta->rta_type = 43; rta->rta_len = RTA_LENGTH(0);

        if (!rta_append(rta, sizeof(req.attrbuf), 1, &fd, sizeof(fd))) { close(nl_sock); return false; }
        uint32_t xdp_flags = (1U << 1); 
        if (!rta_append(rta, sizeof(req.attrbuf), 3, &xdp_flags, sizeof(xdp_flags))) { close(nl_sock); return false; }

        req.nh.nlmsg_len = NLMSG_ALIGN(req.nh.nlmsg_len) + RTA_ALIGN(rta->rta_len);
        if (send(nl_sock, &req, req.nh.nlmsg_len, 0) <= 0) { close(nl_sock); return false; }

        char reply_buf[512] = {0};
        ssize_t rlen = recv(nl_sock, reply_buf, sizeof(reply_buf), 0);
        close(nl_sock);

        if (rlen < static_cast<ssize_t>(sizeof(struct nlmsghdr))) return false;
        auto* r_nh = reinterpret_cast<struct nlmsghdr*>(reply_buf);
        if (!NLMSG_OK(r_nh, static_cast<size_t>(rlen)) || r_nh->nlmsg_type != NLMSG_ERROR) return false;
        return (reinterpret_cast<struct nlmsgerr*>(NLMSG_DATA(r_nh))->error == 0);
    }

public:
    ~XDPTelemetryFilter() {
        if (prog_fd_ >= 0) { attach_xdp_netlink(ifindex_, -1); close(prog_fd_); }
        if (map_fd_ >= 0) close(map_fd_);
    }
    bool deploy_ebpf() {
        union bpf_attr map_attr{};
        map_attr.map_type = BPF_MAP_TYPE_ARRAY; map_attr.key_size = 4; map_attr.value_size = 8; map_attr.max_entries = 1;
        map_fd_ = static_cast<int>(syscall(__NR_bpf, BPF_MAP_CREATE, &map_attr, sizeof(map_attr)));
        if (map_fd_ < 0) return false;

        struct bpf_insn prog[] = {
            { 0x62, 10, 0, -4, 0 }, { 0xbf, 2, 10, 0, 0 }, { 0x07, 2, 0, 0, -4 },
            { 0x18, 1, 1, 0, map_fd_ }, { 0x00, 0, 0, 0, 0 }, { 0x85, 0, 0, 0, 1 },
            { 0x15, 0, 0, 2, 0 }, { 0xb7, 1, 0, 0, 1 }, { 0xdb, 0, 1, 0, 0 },
            { 0xb7, 0, 0, 0, 2 }, { 0x95, 0, 0, 0, 0 }
        };
        union bpf_attr prog_attr{};
        prog_attr.prog_type = BPF_PROG_TYPE_XDP; prog_attr.insns = reinterpret_cast<uint64_t>(prog);
        prog_attr.insn_cnt = sizeof(prog) / sizeof(struct bpf_insn); prog_attr.license = reinterpret_cast<uint64_t>("GPL");
        prog_fd_ = static_cast<int>(syscall(__NR_bpf, BPF_PROG_LOAD, &prog_attr, sizeof(prog_attr)));
        if (prog_fd_ < 0) return false;

        if (attach_xdp_netlink(ifindex_, prog_fd_)) {
            StaticLogger::info("Logic A: SKB-Mode XDP Filter attached.");
            return true;
        }
        return false;
    }
    uint64_t poll_packet_count() noexcept {
        if (map_fd_ < 0) return 0;
        uint32_t key = 0; uint64_t value = 0;
        union bpf_attr lookup_attr{};
        lookup_attr.map_fd = map_fd_; lookup_attr.key = reinterpret_cast<uint64_t>(&key); lookup_attr.value = reinterpret_cast<uint64_t>(&value);
        syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &lookup_attr, sizeof(lookup_attr));
        return value;
    }
};

// -----------------------------------------------------------------------------
// 8. ASYNCHRONOUS K8S LEASE COORDINATOR (Pure TCP Stream FSM & Raw clone)
// -----------------------------------------------------------------------------
struct WorkerArgs {
    const char* host;
    int port;
};

class AsynchronousLeaseWorker {
public:
    static void init_worker(const char* host, int port) {
        // Allocate isolated thread stack BEFORE mlockall via anonymous mmap
        constexpr size_t STACK_SIZE = 1024 * 1024 * 2; // 2MB
        void* stack = mmap(nullptr, STACK_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
        if (stack == MAP_FAILED) {
            StaticLogger::critical("Logic E: Failed to mmap isolated thread stack.");
            _exit(EXIT_FAILURE);
        }

        static WorkerArgs args{host, port};
        
        // Execute raw clone(), completely bypassing libpthread/glibc memory allocation
        int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM;
        pid_t tid = clone(worker_entry, static_cast<char*>(stack) + STACK_SIZE, flags, &args);
        if (tid < 0) {
            StaticLogger::critical("Logic E: Raw kernel clone() failed.");
            _exit(EXIT_FAILURE);
        }
        StaticLogger::info("Logic E: Raw clone() lease worker initialized without dynamic heap.");
    }

private:
    static int worker_entry(void* arg) {
        auto* args = static_cast<WorkerArgs*>(arg);
        
        char token[1024] = {0};
        int token_fd = open("/var/run/secrets/kubernetes.io/serviceaccount/token", O_RDONLY | O_CLOEXEC);
        if (token_fd >= 0) {
            ssize_t bytes = read(token_fd, token, sizeof(token) - 1);
            close(token_fd);
            if (bytes > 0) {
                while (bytes > 0 && (token[bytes - 1] == '\n' || token[bytes - 1] == '\r')) {
                    token[--bytes] = '\0';
                }
            }
        }

        char my_hostname[64] = {0};
        gethostname(my_hostname, sizeof(my_hostname) - 1);

        while (g_ipc_state && g_ipc_state->global_running.load(std::memory_order_acquire)) {
            bool acquired = execute_autonomous_lease_fsm(args->host, args->port, token, my_hostname);
            g_ipc_state->lease_held.store(acquired, std::memory_order_release);
            
            struct timespec ts{ .tv_sec = 5, .tv_nsec = 0 };
            clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, nullptr);
        }
        return 0;
    }

    static int open_tcp_conn(const char* host, int port) {
        int sock = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
        if (sock < 0) return -1;

        struct timeval tv{ .tv_sec = 1, .tv_usec = 0 };
        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
        setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));

        struct sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        
        // STRICT FIX: Eradicate gethostbyname and NSS library mapping
        // Direct IPv4 binary translation, fails hard if not IPv4 string
        if (inet_pton(AF_INET, host, &addr.sin_addr) <= 0) {
            close(sock);
            return -1;
        }

        if (connect(sock, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) < 0) {
            close(sock);
            return -1;
        }
        return sock;
    }

    // STRICT FIX: Deterministic TCP Stream Reading (Fragmentation Handling)
    static ssize_t read_http_stream(int sock, char* buffer, size_t buffer_size) {
        ssize_t total_bytes = 0;
        bool headers_complete = false;
        int content_length = 0;
        int body_bytes_read = 0;

        while (total_bytes < static_cast<ssize_t>(buffer_size) - 1) {
            ssize_t bytes = read(sock, buffer + total_bytes, buffer_size - 1 - total_bytes);
            if (bytes <= 0) break; 
            total_bytes += bytes;

            if (!headers_complete) {
                if (const char* end_of_headers = std::strstr(buffer, "\r\n\r\n")) {
                    headers_complete = true;
                    if (const char* cl_str = std::strstr(buffer, "Content-Length:")) {
                        content_length = std::atoi(cl_str + 15);
                    }
                    body_bytes_read = (buffer + total_bytes) - (end_of_headers + 4);
                }
            } else {
                body_bytes_read += bytes;
            }

            if (headers_complete && body_bytes_read >= content_length) {
                break; // Stream semantically closed
            }
        }
        buffer[total_bytes] = '\0';
        return total_bytes;
    }

    static bool extract_json_string(const char* json, const char* key, char* out, size_t out_max) noexcept {
        const char* p = std::strstr(json, key);
        if (!p) return false;
        p += std::strlen(key);
        while (*p == ' ' || *p == ':') ++p;
        if (*p == '\"') ++p;
        const char* p_end = std::strchr(p, '\"');
        if (!p_end) return false;
        size_t len = p_end - p;
        if (len >= out_max) return false;
        std::memcpy(out, p, len);
        out[len] = '\0';
        return true;
    }

    static int extract_json_int(const char* json, const char* key, int default_val) noexcept {
        const char* p = std::strstr(json, key);
        if (!p) return default_val;
        p += std::strlen(key);
        while (*p == ' ' || *p == ':') ++p;
        int val = 0;
        if (std::sscanf(p, "%d", &val) == 1) return val;
        return default_val;
    }

    static time_t parse_rfc3339_epoch(const char* str) noexcept {
        if (!str || !*str) return 0;
        int y = 0, m = 0, d = 0, h = 0, min = 0, s = 0;
        if (std::sscanf(str, "%04d-%02d-%02dT%02d:%02d:%02d", &y, &m, &d, &h, &min, &s) != 6) return 0;
        y -= m <= 2;
        const int era = (y >= 0 ? y : y - 399) / 400;
        const unsigned yoe = static_cast<unsigned>(y - era * 400);
        const unsigned doy = (153 * (m > 2 ? m - 3 : m + 9) + 2) / 5 + d - 1;
        const unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
        const int64_t days = era * 146097 + static_cast<int64_t>(doe) - 719468;
        return static_cast<time_t>(days * 86400 + h * 3600 + min * 60 + s);
    }

    static bool execute_autonomous_lease_fsm(const char* host, int port, const char* token, const char* my_hostname) {
        int sock = open_tcp_conn(host, port);
        if (sock < 0) return false;

        char req[1024];
        int req_len = std::snprintf(req, sizeof(req),
            "GET /apis/coordination.k8s.io/v1/namespaces/default/leases/mso-e28-cadence HTTP/1.1\r\n"
            "Host: %s:%d\r\n"
            "Authorization: Bearer %s\r\n"
            "Connection: close\r\n\r\n",
            host, port, token);

        [[maybe_unused]] auto _ = write(sock, req, req_len);

        char resp[4096] = {0};
        ssize_t bytes = read_http_stream(sock, resp, sizeof(resp));
        close(sock);

        if (bytes <= 0) return false;

        struct timespec ts{};
        clock_gettime(CLOCK_REALTIME, &ts);
        struct tm tm_buf{};
        gmtime_r(&ts.tv_sec, &tm_buf);

        char renew_time[36];
        std::snprintf(renew_time, sizeof(renew_time),
            "%04d-%02d-%02dT%02d:%02d:%02d.%06ldZ",
            tm_buf.tm_year + 1900, tm_buf.tm_mon + 1, tm_buf.tm_mday,
            tm_buf.tm_hour, tm_buf.tm_min, tm_buf.tm_sec,
            ts.tv_nsec / 1000);

        if (std::strstr(resp, "HTTP/1.1 404") != nullptr) {
            int post_sock = open_tcp_conn(host, port);
            if (post_sock < 0) return false;

            char post_body[384];
            int body_len = std::snprintf(post_body, sizeof(post_body),
                "{\"metadata\":{\"name\":\"mso-e28-cadence\"},"
                "\"spec\":{\"holderIdentity\":\"%s\",\"leaseDurationSeconds\":15,\"renewTime\":\"%s\"}}",
                my_hostname, renew_time);

            char post_req[1024];
            int p_len = std::snprintf(post_req, sizeof(post_req),
                "POST /apis/coordination.k8s.io/v1/namespaces/default/leases HTTP/1.1\r\n"
                "Host: %s:%d\r\n"
                "Content-Type: application/json\r\n"
                "Content-Length: %d\r\n"
                "Authorization: Bearer %s\r\n"
                "Connection: close\r\n\r\n%s",
                host, port, body_len, token, post_body);

            [[maybe_unused]] auto __ = write(post_sock, post_req, p_len);
            char post_resp[1024] = {0};
            ssize_t p_bytes = read_http_stream(post_sock, post_resp, sizeof(post_resp));
            close(post_sock);

            return (p_bytes > 0 && std::strstr(post_resp, "HTTP/1.1 201") != nullptr);
        }

        if (std::strstr(resp, "HTTP/1.1 200 OK") != nullptr) {
            char rv[32] = {0};
            if (!extract_json_string(resp, "\"resourceVersion\":", rv, sizeof(rv))) return false;

            char holder[64] = {0};
            bool has_holder = extract_json_string(resp, "\"holderIdentity\":", holder, sizeof(holder));
            int duration = extract_json_int(resp, "\"leaseDurationSeconds\":", 15);
            char prev_renew_time[36] = {0};
            bool has_renew = extract_json_string(resp, "\"renewTime\":", prev_renew_time, sizeof(prev_renew_time));

            bool is_self = (has_holder && std::strcmp(holder, my_hostname) == 0);
            bool is_expired = false;

            if (!has_holder || !has_renew) {
                is_expired = true;
            } else {
                time_t renew_epoch = parse_rfc3339_epoch(prev_renew_time);
                time_t now_epoch = ts.tv_sec;
                if (now_epoch >= renew_epoch && (now_epoch - renew_epoch) >= duration) {
                    is_expired = true;
                }
            }

            if (!is_self && !is_expired) return false;

            int put_sock = open_tcp_conn(host, port);
            if (put_sock < 0) return false;

            char put_body[512];
            int body_len = std::snprintf(put_body, sizeof(put_body),
                "{\"metadata\":{\"name\":\"mso-e28-cadence\",\"resourceVersion\":\"%s\"},"
                "\"spec\":{\"holderIdentity\":\"%s\",\"leaseDurationSeconds\":15,\"renewTime\":\"%s\"}}",
                rv, my_hostname, renew_time);

            char put_req[1024];
            int u_len = std::snprintf(put_req, sizeof(put_req),
                "PUT /apis/coordination.k8s.io/v1/namespaces/default/leases/mso-e28-cadence HTTP/1.1\r\n"
                "Host: %s:%d\r\n"
                "Content-Type: application/json\r\n"
                "Content-Length: %d\r\n"
                "Authorization: Bearer %s\r\n"
                "Connection: close\r\n\r\n%s",
                host, port, body_len, token, put_body);

            [[maybe_unused]] auto ___ = write(put_sock, put_req, u_len);
            char put_resp[1024] = {0};
            ssize_t u_bytes = read_http_stream(put_sock, put_resp, sizeof(put_resp));
            close(put_sock);

            return (u_bytes > 0 && std::strstr(put_resp, "HTTP/1.1 200 OK") != nullptr);
        }
        return false;
    }
};

// -----------------------------------------------------------------------------
// 9. HARVARD ARCHITECTURE SEPARATION (Data vs. Control)
// -----------------------------------------------------------------------------
class HarvardArchitectureBus {
public:
    static void mount_static_data_bus(XDPTelemetryFilter& xdp) noexcept {
        if (g_ipc_state->boot_latches.bpf_mount_latch.load(std::memory_order_acquire)) return;
        if (!xdp.deploy_ebpf()) {
            StaticLogger::warning("[HARVARD] BPF Data Plane unmountable. Running degraded telemetry.");
        }
        g_ipc_state->boot_latches.bpf_mount_latch.store(true, std::memory_order_release);
        StaticLogger::info("[DATA_PLANE] 4-Stage Lock: Harvard Data Plane (eBPF Telemetry) Locked.");
    }

    static void bootstrap_acoustic_control_plane(ModernGpioV2Actuator& gpio) noexcept {
        if (g_ipc_state->boot_latches.gpio_tree_latch.load(std::memory_order_acquire)) return;
        if (!gpio.configure_output_line(0)) {
            StaticLogger::warning("[HARVARD] GPIO Control Plane disconnected. Running mock actuator.");
        }

        struct timespec ts{};
        if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
            StaticLogger::critical("[HARVARD] Verification Failed: Monotonic clock inaccessible.");
            _exit(EXIT_FAILURE);
        }

        g_ipc_state->boot_latches.gpio_tree_latch.store(true, std::memory_order_release);
        StaticLogger::info("[CTRL_PLANE] 4-Stage Lock: V9 Acoustic Control Bus & GPIO V2 Injected.");
    }
};

// -----------------------------------------------------------------------------
// 10. REAL-TIME ORCHESTRATOR
// -----------------------------------------------------------------------------
class RTContrapuntalOrchestrator {
public:
    static void execute_rt_cadence_cycle(ModernGpioV2Actuator& actuator, struct timespec& cycle_clk) noexcept {
        constexpr long STAGE_STEP_NS = 10'000'000L; // 10ms per transition
        for (int i = 0; i < 3; ++i) {
            actuator.write_actuator_state(true);
            advance_and_sleep(cycle_clk, STAGE_STEP_NS);
            actuator.write_actuator_state(false);
            advance_and_sleep(cycle_clk, STAGE_STEP_NS);
        }
    }

private:
    static void advance_and_sleep(struct timespec& clk, long step_ns) noexcept {
        clk.tv_nsec += step_ns;
        if (clk.tv_nsec >= 1'000'000'000L) {
            clk.tv_sec += 1;
            clk.tv_nsec -= 1'000'000'000L;
        }
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &clk, nullptr);
    }
};

// -----------------------------------------------------------------------------
// 11. ENTRYPOINT PIPELINE (Bootloader Sequence)
// -----------------------------------------------------------------------------
int main() {
    void* shm = mmap(nullptr, sizeof(ProcessSharedState), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (shm == MAP_FAILED) return EXIT_FAILURE;
    g_ipc_state = new (shm) ProcessSharedState();

    struct sigaction sa{};
    sa.sa_handler = sigterm_handler;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGTERM, &sa, nullptr);
    sigaction(SIGINT,  &sa, nullptr);

    StaticLogger::init();
    StaticLogger::info("=== MSO-E28 L8/15.0 Gold Master Bootloader Initializing ===");

    // =========================================================================
    // BOOT SEQUENCE: 4-Stage Idempotent Locks
    // =========================================================================
    SovereigntyController::enforce_capabilities();
    
    // Asynchronous worker spawned early with Pre-allocated Mmap Stack (Zero-Heap Guarantee)
    AsynchronousLeaseWorker::init_worker("127.0.0.1", 18080);

    InitialProgramLoader::trigger_power_on_reset();
    InitialProgramLoader::activate_main_oscillator();

    XDPTelemetryFilter xdp;
    ModernGpioV2Actuator gpio;
    HarvardArchitectureBus::mount_static_data_bus(xdp);
    HarvardArchitectureBus::bootstrap_acoustic_control_plane(gpio);

    StaticLogger::info("====[BOOTSTRAP_COMPLETE] System 0-Entropy Achieved====");

    // =========================================================================
    // RUNTIME EXECUTION: Zero-Heap Autonomous Core
    // =========================================================================
    struct timespec cycle_clk{};
    clock_gettime(CLOCK_MONOTONIC, &cycle_clk);

    StaticLogger::info("Entering Absolute Zero-Entropy RT Critical Loop...");

    while (g_ipc_state->global_running.load(std::memory_order_acquire)) {
        RTContrapuntalOrchestrator::execute_rt_cadence_cycle(gpio, cycle_clk);

        uint64_t packets = xdp.poll_packet_count();
        g_ipc_state->telemetry_pass_count.store(packets, std::memory_order_release);
        g_ipc_state->scheduler_cycles.fetch_add(1, std::memory_order_relaxed);

        cycle_clk.tv_nsec += 40'000'000L;
        if (cycle_clk.tv_nsec >= 1'000'000'000L) {
            cycle_clk.tv_sec += 1;
            cycle_clk.tv_nsec -= 1'000'000'000L;
        }
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &cycle_clk, nullptr);
    }

    StaticLogger::info(ADDR_BARRIER);
    if (g_ipc_state->lease_held.load(std::memory_order_acquire)) {
        StaticLogger::info("Final State: Distributed Consensus Synchronized (Lease Owner Active).");
    } else {
        StaticLogger::warning("Final State: Operating under Standalone FSM Constraints.");
    }

    StaticLogger::critical("!(♮[Cadence_Sync_Pulse]🛑) System 0-Entropy reached. Atomic Halt.");
    StaticLogger::shutdown();
    
    _exit(EXIT_SUCCESS);
}