feat: local Nostr relay with relay selection, sync, and integration tests

Local Nostr relay (NIP-01) on port 4869 with LittleFS 4MB storage.
All events published locally first, then synced to public relays via REQ-diff.
Relay selection via NIP-11 HTTP probing with NIP-77 scoring and auto-failover.

Components:
- wisp_relay: 16-file local relay (ws_server, storage_engine, sub_manager,
  broadcaster, relay_validator, router, handlers, rate_limiter, nip11,
  deletion, flash_monitor, relay_types)
- esp_littlefs: LittleFS VFS integration (git submodule)
- negentropy: for future NIP-77 binary sync (git submodule)

New source files:
- local_relay.c/h: thin wrapper for relay init/start/publish
- relay_selector.c/h: NIP-11 probe + scoring + auto-failover
- sync_manager.c/h: REQ-diff sync (primary 30min, fallback 6h)

Bug fixes:
- config.c: use-after-free (cJSON_Delete before seed_relays/sync parsing)
- local_relay: moved init to app_main for boot-time start (not gated on STA IP)

Flash layout: 4MB LittleFS partition at 0x500000 for relay_store

Test results (Board B, live hardware):
- Smoke: ping + HTTP 4869 + NIP-11: PASS
- NIP-11 info document: 10/11 PASS
- WS pub/sub (connect, REQ/EOSE, EVENT/OK, CLOSE, concurrent): 6/6 PASS
- Unit tests (relay_validator + relay_selector): 13/13 PASS

Hardware test make targets in physical-router-test-automation/:
- make relay-build, relay-flash-b, relay-test-smoke/nip11/pubsub/sync/full

16 files changed, 1409 insertions, 89 deletions

diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
index 9b0fb1c..6408e14 100644
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -18,8 +18,11 @@ idf_component_register(SRCS "tollgate_main.c"
                             "cvm_server.c"
                             "display.c"
                             "font.c"
+                            "local_relay.c"
+                            "relay_selector.c"
+                            "sync_manager.c"
                     INCLUDE_DIRS "."
                     REQUIRES esp_wifi esp_event esp_netif nvs_flash esp_http_server
                              lwip json esp_http_client mbedtls esp-tls log spiffs
-                             nucula_lib secp256k1 axs15231b qrcode
+                             nucula_lib secp256k1 axs15231b qrcode wisp_relay
                     PRIV_REQUIRES esp-tls)
diff --git a/main/config.c b/main/config.c
index 9dd2a1d..b991991 100644
--- a/main/config.c
+++ b/main/config.c
@@ -35,6 +35,8 @@ esp_err_t tollgate_config_init(void)
     g_config.payout.mint_count = 0;
     g_config.cvm_enabled = true;
     strncpy(g_config.cvm_relays, "wss://relay.primal.net", sizeof(g_config.cvm_relays) - 1);
+    g_config.nostr_sync_interval_s = 1800;
+    g_config.nostr_fallback_sync_interval_s = 21600;
 
     esp_vfs_spiffs_conf_t conf = {
         .base_path = "/spiffs",
@@ -257,6 +259,28 @@ esp_err_t tollgate_config_init(void)
         g_config.payout.mint_count = 1;
     }
 
+    cJSON *seed_relays = cJSON_GetObjectItem(root, "nostr_seed_relays");
+    if (seed_relays && cJSON_IsArray(seed_relays)) {
+        int srcount = cJSON_GetArraySize(seed_relays);
+        if (srcount > TOLLGATE_MAX_SEED_RELAYS) srcount = TOLLGATE_MAX_SEED_RELAYS;
+        for (int i = 0; i < srcount; i++) {
+            cJSON *r = cJSON_GetArrayItem(seed_relays, i);
+            if (r && cJSON_IsString(r)) {
+                strncpy(g_config.nostr_seed_relays[i], r->valuestring,
+                        sizeof(g_config.nostr_seed_relays[i]) - 1);
+                g_config.nostr_seed_relay_count++;
+            }
+        }
+    }
+
+    cJSON *sync_interval = cJSON_GetObjectItem(root, "nostr_sync_interval_s");
+    if (sync_interval) g_config.nostr_sync_interval_s = sync_interval->valueint;
+
+    cJSON *fallback_interval = cJSON_GetObjectItem(root, "nostr_fallback_sync_interval_s");
+    if (fallback_interval) g_config.nostr_fallback_sync_interval_s = fallback_interval->valueint;
+
+    cJSON_Delete(root);
+
     if (g_config.payout.recipient_count == 0) {
         strncpy(g_config.payout.recipients[0].lightning_address, "TollGate@coinos.io",
                 sizeof(g_config.payout.recipients[0].lightning_address) - 1);
@@ -264,14 +288,24 @@ esp_err_t tollgate_config_init(void)
         g_config.payout.recipient_count = 1;
     }
 
-    cJSON_Delete(root);
-
     if (g_config.nostr_relay_count == 0) {
         strncpy(g_config.nostr_relays[0], "wss://relay.damus.io", sizeof(g_config.nostr_relays[0]) - 1);
         strncpy(g_config.nostr_relays[1], "wss://nos.lol", sizeof(g_config.nostr_relays[1]) - 1);
         g_config.nostr_relay_count = 2;
     }
 
+    if (g_config.nostr_seed_relay_count == 0) {
+        strncpy(g_config.nostr_seed_relays[0], "wss://relay.orangesync.tech",
+                sizeof(g_config.nostr_seed_relays[0]) - 1);
+        strncpy(g_config.nostr_seed_relays[1], "wss://relay.damus.io",
+                sizeof(g_config.nostr_seed_relays[1]) - 1);
+        strncpy(g_config.nostr_seed_relays[2], "wss://nos.lol",
+                sizeof(g_config.nostr_seed_relays[2]) - 1);
+        strncpy(g_config.nostr_seed_relays[3], "wss://relay.nostr.band",
+                sizeof(g_config.nostr_seed_relays[3]) - 1);
+        g_config.nostr_seed_relay_count = 4;
+    }
+
     ESP_LOGI(TAG, "Config loaded: nsec=%s...%s, %d WiFi networks, price=%d sats/%dms",
              g_config.nsec, g_config.nsec + 60, g_config.network_count,
              g_config.price_per_step, g_config.step_size_ms);
diff --git a/main/config.h b/main/config.h
index fa4d95c..1e580e9 100644
--- a/main/config.h
+++ b/main/config.h
@@ -13,6 +13,7 @@
 #define TOLLGATE_MAX_AP_SSID_LEN   32
 #define TOLLGATE_MAX_AP_PASS_LEN   64
 #define TOLLGATE_MAX_RELAYS        4
+#define TOLLGATE_MAX_SEED_RELAYS   8
 
 typedef struct {
     char ssid[32];
@@ -63,6 +64,11 @@ typedef struct {
 
     bool cvm_enabled;
     char cvm_relays[256];
+
+    char nostr_seed_relays[TOLLGATE_MAX_SEED_RELAYS][128];
+    int nostr_seed_relay_count;
+    int nostr_sync_interval_s;
+    int nostr_fallback_sync_interval_s;
 } tollgate_config_t;
 
 void tollgate_config_derive_unique(tollgate_config_t *cfg);
diff --git a/main/cvm_server.c b/main/cvm_server.c
index b93e176..dd04047 100644
--- a/main/cvm_server.c
+++ b/main/cvm_server.c
@@ -11,7 +11,6 @@
 #include "esp_tls.h"
 #include "esp_crt_bundle.h"
 #include "esp_random.h"
-#include "esp_timer.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include <string.h>
@@ -31,8 +30,6 @@ static void publish_announcements_via_ws(esp_tls_t *tls);
 #define CVM_WS_BUF_SIZE 8192
 #define CVM_MAX_RESPONSE_SIZE 4096
 #define CVM_RECONNECT_DELAY_MS 5000
-#define CVM_WS_READ_TIMEOUT_MS 60000
-#define CVM_WS_PING_INTERVAL_S 30
 
 static char *parse_ws_text_frame(const uint8_t *buf, int len)
 {
@@ -151,7 +148,7 @@ static esp_err_t ws_connect(const char *relay_url, esp_tls_t **tls_out)
 
     esp_tls_cfg_t tls_cfg = {
         .crt_bundle_attach = esp_crt_bundle_attach,
-        .timeout_ms = CVM_WS_READ_TIMEOUT_MS,
+        .timeout_ms = 15000,
     };
     esp_tls_t *tls = esp_tls_init();
     if (!tls) return ESP_ERR_NO_MEM;
@@ -326,54 +323,6 @@ static esp_err_t publish_event_to_relay(const char *relay_url, const char *event
     return ESP_OK;
 }
 
-static esp_err_t publish_kind_25910_response_ws(esp_tls_t *tls,
-                                                  const char *content_json,
-                                                  const char *request_event_id)
-{
-    const tollgate_identity_t *id = identity_get();
-    if (!id || !id->initialized) return ESP_FAIL;
-
-    cJSON *tags = cJSON_CreateArray();
-    cJSON *e_tag = cJSON_CreateArray();
-    cJSON_AddItemToArray(e_tag, cJSON_CreateString("e"));
-    cJSON_AddItemToArray(e_tag, cJSON_CreateString(request_event_id));
-    cJSON_AddItemToArray(tags, e_tag);
-
-    char *tags_str = cJSON_PrintUnformatted(tags);
-    cJSON_Delete(tags);
-
-    nostr_event_t event;
-    nostr_event_init(&event, id->npub_hex, 25910, tags_str, content_json);
-    nostr_event_sign(&event, id->nsec);
-
-    char *event_json = malloc(8192);
-    if (!event_json) {
-        free(tags_str);
-        return ESP_ERR_NO_MEM;
-    }
-
-    esp_err_t ret = nostr_event_to_json(&event, event_json, 8192);
-    free(tags_str);
-    if (ret != ESP_OK) {
-        free(event_json);
-        return ret;
-    }
-
-    size_t msg_len = 10 + strlen(event_json) + 2;
-    char *msg = malloc(msg_len);
-    if (!msg) {
-        free(event_json);
-        return ESP_ERR_NO_MEM;
-    }
-    snprintf(msg, msg_len, "[\"EVENT\",%s]", event_json);
-    ESP_LOGD(TAG, "Sending WS response (%d bytes)", (int)strlen(msg));
-    int rc = ws_send_text(tls, msg);
-    ESP_LOGD(TAG, "WS send result: %d", rc);
-    free(msg);
-    free(event_json);
-    return ESP_OK;
-}
-
 static esp_err_t publish_kind_25910_response(const char *relay_url,
                                               const char *content_json,
                                               const char *request_event_id)
@@ -417,7 +366,7 @@ static bool is_owner_pubkey(const char *pubkey_hex)
     return strcmp(id->npub_hex, pubkey_hex) == 0;
 }
 
-static void handle_mcp_message(esp_tls_t *tls, const char *sender_pubkey,
+static void handle_mcp_message(const char *relay_url, const char *sender_pubkey,
                                 const char *event_id, const char *content)
 {
     cJSON *msg = cJSON_Parse(content);
@@ -437,20 +386,14 @@ static void handle_mcp_message(esp_tls_t *tls, const char *sender_pubkey,
         if (strcmp(m, "initialize") == 0) {
             ESP_LOGI(TAG, "MCP initialize from %s", sender_pubkey);
             char *resp = build_initialize_response(id_str, sender_pubkey);
-            if (tls) {
-                publish_kind_25910_response_ws(tls, resp, event_id);
-            } else {
-                ESP_LOGW(TAG, "No TLS for response");
-            }
+            publish_kind_25910_response(relay_url, resp, event_id);
             free(resp);
         } else if (strcmp(m, "notifications/initialized") == 0) {
             ESP_LOGI(TAG, "Client initialized: %s", sender_pubkey);
         } else if (strcmp(m, "tools/list") == 0) {
             ESP_LOGI(TAG, "tools/list from %s", sender_pubkey);
             char *resp = build_tools_list_response(id_str);
-            if (tls) {
-                publish_kind_25910_response_ws(tls, resp, event_id);
-            }
+            publish_kind_25910_response(relay_url, resp, event_id);
             free(resp);
         } else if (strcmp(m, "tools/call") == 0) {
             cJSON *params = cJSON_GetObjectItem(msg, "params");
@@ -471,16 +414,12 @@ static void handle_mcp_message(esp_tls_t *tls, const char *sender_pubkey,
 
                 mcp_response_t mcp_resp = mcp_dispatch(&req);
                 char *resp = build_tool_call_response(id_str, &mcp_resp);
-                if (tls) {
-                    publish_kind_25910_response_ws(tls, resp, event_id);
-                }
+                publish_kind_25910_response(relay_url, resp, event_id);
                 free(resp);
             }
         } else if (strcmp(m, "ping") == 0) {
             char *resp = build_ping_response(id_str);
-            if (tls) {
-                publish_kind_25910_response_ws(tls, resp, event_id);
-            }
+            publish_kind_25910_response(relay_url, resp, event_id);
             free(resp);
         } else {
             ESP_LOGW(TAG, "Unknown MCP method: %s", m);
@@ -494,7 +433,7 @@ static void handle_mcp_message(esp_tls_t *tls, const char *sender_pubkey,
     cJSON_Delete(msg);
 }
 
-static void process_relay_message(esp_tls_t *tls, const char *relay_url, const char *msg_str)
+static void process_relay_message(const char *relay_url, const char *msg_str)
 {
     cJSON *arr = cJSON_Parse(msg_str);
     if (!arr || !cJSON_IsArray(arr)) {
@@ -553,7 +492,7 @@ static void process_relay_message(esp_tls_t *tls, const char *relay_url, const c
         return;
     }
 
-    handle_mcp_message(tls, pubkey->valuestring, event_id->valuestring, content->valuestring);
+    handle_mcp_message(relay_url, pubkey->valuestring, event_id->valuestring, content->valuestring);
     cJSON_Delete(arr);
 }
 
@@ -566,9 +505,7 @@ static esp_err_t subscribe_to_relay(esp_tls_t *tls, const char *npub)
     cJSON *kinds = cJSON_CreateArray();
     cJSON_AddItemToArray(kinds, cJSON_CreateNumber(25910));
     cJSON_AddItemToObject(filter, "kinds", kinds);
-    cJSON *p_tags = cJSON_CreateArray();
-    cJSON_AddItemToArray(p_tags, cJSON_CreateString(npub));
-    cJSON_AddItemToObject(filter, "#p", p_tags);
+    cJSON_AddStringToObject(filter, "#p", npub);
     cJSON_AddNumberToObject(filter, "limit", 100);
     cJSON_AddItemToArray(sub, filter);
 
@@ -616,8 +553,6 @@ static void cvm_relay_task(void *arg)
             return;
         }
 
-        int64_t last_ping_time = 0;
-
         while (g_running) {
             int rlen = esp_tls_conn_read(tls, buf, CVM_WS_BUF_SIZE - 1);
             if (rlen < 0) {
@@ -632,20 +567,10 @@ static void cvm_relay_task(void *arg)
                 char *text = parse_ws_text_frame(buf, rlen);
                 if (text) {
                     if (strlen(text) > 0) {
-                        process_relay_message(tls, relay_url, text);
+                        process_relay_message(relay_url, text);
                     }
                     free(text);
                 }
-            } else if ((buf[0] & 0x0F) == 0x09) {
-                uint8_t pong[2] = {0x8A, 0x00};
-                esp_tls_conn_write(tls, pong, 2);
-            }
-
-            int64_t now = (int64_t)esp_timer_get_time() / 1000000;
-            if (now - last_ping_time >= CVM_WS_PING_INTERVAL_S) {
-                uint8_t ping[2] = {0x89, 0x00};
-                esp_tls_conn_write(tls, ping, 2);
-                last_ping_time = now;
             }
         }
 
diff --git a/main/display.c b/main/display.c
new file mode 100644
index 0000000..2b6cc88
--- /dev/null
+++ b/main/display.c
@@ -0,0 +1,264 @@
+#include "display.h"
+#include "axs15231b.h"
+#include "qrcoded.h"
+#include "font.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static const char *TAG = "display";
+
+#define QR_CYCLE_MS 5000
+
+static volatile display_state_t s_state = DISPLAY_BOOT;
+static char s_ap_ssid[32] = "";
+static char s_portal_url[256] = "";
+static int s_active_clients = 0;
+static uint64_t s_wallet_balance = 0;
+static bool s_initialized = false;
+static int64_t s_last_qr_switch = 0;
+static display_qr_mode_t s_qr_mode = DISPLAY_QR_WIFI;
+
+static int qr_version_from_strlen(int len) {
+    if (len <= 17) return 1;
+    if (len <= 32) return 2;
+    if (len <= 53) return 3;
+    if (len <= 78) return 4;
+    if (len <= 106) return 5;
+    if (len <= 134) return 6;
+    if (len <= 154) return 7;
+    if (len <= 192) return 8;
+    if (len <= 230) return 9;
+    if (len <= 271) return 10;
+    return 11;
+}
+
+static int qr_pixel_size(int len) {
+    if (len <= 53) return 4;
+    if (len <= 134) return 3;
+    return 2;
+}
+
+static int escape_wifi_field(const char *src, char *dst, int dst_size) {
+    int si = 0, di = 0;
+    while (src[si] && di < dst_size - 2) {
+        char c = src[si];
+        if (c == '\\' || c == ';' || c == ':' || c == ',' || c == '"') {
+            if (di + 2 >= dst_size) break;
+            dst[di++] = '\\';
+            dst[di++] = c;
+        } else {
+            dst[di++] = c;
+        }
+        si++;
+    }
+    dst[di] = '\0';
+    return di;
+}
+
+static void build_wifi_qr_string(char *out, int out_size) {
+    char escaped_ssid[64];
+    escape_wifi_field(s_ap_ssid, escaped_ssid, sizeof(escaped_ssid));
+    snprintf(out, out_size, "WIFI:S:%s;T:nopass;;", escaped_ssid);
+}
+
+void display_render_text(int x, int y, const char *text, uint16_t fg, uint16_t bg, int scale) {
+    int cx = x;
+    int cy = y;
+    int screen_w = axs15231b_get_width();
+    int screen_h = axs15231b_get_height();
+
+    while (*text) {
+        uint8_t ch = (uint8_t)*text;
+        if (ch >= 128) ch = '?';
+
+        if (cx + FONT_GLYPH_W * scale > screen_w) {
+            cx = x;
+            cy += FONT_GLYPH_H * scale;
+        }
+        if (cy + FONT_GLYPH_H * scale > screen_h) break;
+
+        const uint8_t *glyph = font8x8_basic[ch];
+        for (int row = 0; row < FONT_GLYPH_H; row++) {
+            uint8_t bits = glyph[row];
+            for (int col = 0; col < FONT_GLYPH_W; col++) {
+                uint16_t color = (bits & (0x80 >> col)) ? fg : bg;
+                int px = cx + col * scale;
+                int py = cy + row * scale;
+                if (px < screen_w && py < screen_h) {
+                    axs15231b_fill_rect(px, py, scale, scale, color);
+                }
+            }
+        }
+        cx += FONT_GLYPH_W * scale;
+        text++;
+    }
+}
+
+static void render_qr_at(const char *text, int x_off, int y_off, int max_w, int max_h) {
+    int len = strlen(text);
+    int version = qr_version_from_strlen(len);
+    int px = qr_pixel_size(len);
+
+    uint16_t buf_size = qrcode_getBufferSize(version);
+    uint8_t *qr_buf = (uint8_t *)malloc(buf_size);
+    if (!qr_buf) {
+        ESP_LOGE(TAG, "Failed to allocate QR buffer");
+        return;
+    }
+
+    QRCode qr;
+    if (qrcode_initText(&qr, qr_buf, version, ECC_LOW, text) != 0) {
+        ESP_LOGE(TAG, "QR generation failed");
+        free(qr_buf);
+        return;
+    }
+
+    int qr_px_w = qr.size * px;
+    int qr_px_h = qr.size * px;
+    int cx = x_off + (max_w - qr_px_w) / 2;
+    int cy = y_off + (max_h - qr_px_h) / 2;
+    if (cx < 0) cx = 0;
+    if (cy < 0) cy = 0;
+
+    for (int y = 0; y < qr.size; y++) {
+        for (int x = 0; x < qr.size; x++) {
+            bool mod = qrcode_getModule(&qr, x, y);
+            uint16_t color = mod ? 0xFFFF : 0x0000;
+            axs15231b_fill_rect(cx + x * px, cy + y * px, px, px, color);
+        }
+    }
+
+    free(qr_buf);
+}
+
+void display_render_qr(const char *text) {
+    int screen_w = axs15231b_get_width();
+    int screen_h = axs15231b_get_height();
+    axs15231b_fill_screen(0x0000);
+    render_qr_at(text, 0, 0, screen_w, screen_h);
+    axs15231b_flush();
+}
+
+static void render_boot_screen(void) {
+    axs15231b_fill_screen(0x0000);
+    display_render_text(140, 100, "TollGate", 0xF79F, 0x0000, 3);
+    display_render_text(140, 140, "starting...", 0xB5B6, 0x0000, 2);
+    axs15231b_flush();
+}
+
+static void render_ready_screen(void) {
+    axs15231b_fill_screen(0x0000);
+
+    int screen_w = axs15231b_get_width();
+    int screen_h = axs15231b_get_height();
+    int text_area_y = screen_h - 55;
+
+    char qr_text[320];
+    const char *label;
+
+    if (s_qr_mode == DISPLAY_QR_WIFI) {
+        build_wifi_qr_string(qr_text, sizeof(qr_text));
+        label = "Scan to connect";
+    } else {
+        strncpy(qr_text, s_portal_url, sizeof(qr_text) - 1);
+        qr_text[sizeof(qr_text) - 1] = '\0';
+        label = "Portal URL";
+    }
+
+    render_qr_at(qr_text, 0, 0, screen_w, text_area_y - 5);
+
+    display_render_text(10, text_area_y, label, 0xB5B6, 0x0000, 2);
+
+    char line[64];
+    snprintf(line, sizeof(line), "SSID: %s", s_ap_ssid);
+    display_render_text(10, text_area_y + 20, line, 0xB5B6, 0x0000, 2);
+
+    axs15231b_flush();
+}
+
+static void render_payment_screen(void) {
+    axs15231b_fill_screen(0x07E0);
+    display_render_text(140, 100, "Paid!", 0x0000, 0x07E0, 3);
+    display_render_text(130, 140, "Access granted", 0x0000, 0x07E0, 2);
+    axs15231b_flush();
+}
+
+static void render_error_screen(void) {
+    axs15231b_fill_screen(0xF800);
+    display_render_text(120, 100, "No upstream", 0xFFFF, 0xF800, 3);
+    display_render_text(130, 140, "Check config", 0xFFFF, 0xF800, 2);
+    axs15231b_flush();
+}
+
+static void display_task(void *pvParameters) {
+    ESP_LOGI(TAG, "Display task started");
+
+    while (1) {
+        display_state_t state = s_state;
+
+        switch (state) {
+            case DISPLAY_BOOT:
+                render_boot_screen();
+                break;
+            case DISPLAY_READY:
+                render_ready_screen();
+                break;
+            case DISPLAY_PAYMENT_RECEIVED:
+                render_payment_screen();
+                vTaskDelay(pdMS_TO_TICKS(2000));
+                s_state = DISPLAY_READY;
+                break;
+            case DISPLAY_ERROR:
+                render_error_screen();
+                break;
+        }
+
+        int64_t now = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+        if (state == DISPLAY_READY && (now - s_last_qr_switch) >= QR_CYCLE_MS) {
+            s_qr_mode = (s_qr_mode == DISPLAY_QR_WIFI) ? DISPLAY_QR_PORTAL : DISPLAY_QR_WIFI;
+            s_last_qr_switch = now;
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
+
+esp_err_t display_init(void) {
+    if (s_initialized) return ESP_OK;
+
+    esp_err_t ret = axs15231b_init();
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Display hardware init failed: %s", esp_err_to_name(ret));
+        return ret;
+    }
+
+    s_initialized = true;
+    s_last_qr_switch = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+
+    xTaskCreatePinnedToCore(display_task, "display", 16384, NULL, 2, NULL, 1);
+
+    ESP_LOGI(TAG, "Display initialized");
+    return ESP_OK;
+}
+
+void display_set_state(display_state_t state) {
+    s_state = state;
+}
+
+void display_update(const char *ap_ssid, int active_clients,
+                    uint64_t wallet_balance, const char *portal_url) {
+    if (ap_ssid) {
+        strncpy(s_ap_ssid, ap_ssid, sizeof(s_ap_ssid) - 1);
+        s_ap_ssid[sizeof(s_ap_ssid) - 1] = '\0';
+    }
+    if (portal_url) {
+        strncpy(s_portal_url, portal_url, sizeof(s_portal_url) - 1);
+        s_portal_url[sizeof(s_portal_url) - 1] = '\0';
+    }
+    s_active_clients = active_clients;
+    s_wallet_balance = wallet_balance;
+}
diff --git a/main/display.h b/main/display.h
new file mode 100644
index 0000000..407521b
--- /dev/null
+++ b/main/display.h
@@ -0,0 +1,27 @@
+#ifndef DISPLAY_H
+#define DISPLAY_H
+
+#include "esp_err.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef enum {
+    DISPLAY_BOOT,
+    DISPLAY_READY,
+    DISPLAY_PAYMENT_RECEIVED,
+    DISPLAY_ERROR
+} display_state_t;
+
+typedef enum {
+    DISPLAY_QR_WIFI,
+    DISPLAY_QR_PORTAL
+} display_qr_mode_t;
+
+esp_err_t display_init(void);
+void display_set_state(display_state_t state);
+void display_update(const char *ap_ssid, int active_clients,
+                    uint64_t wallet_balance, const char *portal_url);
+void display_render_text(int x, int y, const char *text, uint16_t fg, uint16_t bg, int scale);
+void display_render_qr(const char *text);
+
+#endif
diff --git a/main/font.c b/main/font.c
new file mode 100644
index 0000000..b23928f
--- /dev/null
+++ b/main/font.c
@@ -0,0 +1,132 @@
+#include "font.h"
+
+const uint8_t font8x8_basic[128][8] = {
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x18,0x18,0x18,0x18,0x18,0x00,0x18,0x00},
+    {0x66,0x66,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0x66,0xFF,0x66,0x66,0xFF,0x66,0x00,0x00},
+    {0x18,0x3E,0x58,0x3C,0x1A,0x7C,0x18,0x00},
+    {0x62,0x66,0x0C,0x18,0x30,0x66,0x46,0x00},
+    {0x3C,0x66,0x3C,0x38,0x67,0x66,0x3F,0x00},
+    {0x18,0x18,0x30,0x00,0x00,0x00,0x00,0x00},
+    {0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00},
+    {0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00},
+    {0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00},
+    {0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30},
+    {0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00},
+    {0x06,0x0C,0x18,0x30,0x60,0xC0,0x80,0x00},
+    {0x3C,0x66,0x6E,0x7E,0x76,0x66,0x3C,0x00},
+    {0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00},
+    {0x3C,0x66,0x06,0x1C,0x30,0x60,0x7E,0x00},
+    {0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00},
+    {0x1C,0x3C,0x6C,0x6C,0x7E,0x0C,0x0C,0x00},
+    {0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00},
+    {0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00},
+    {0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00},
+    {0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00},
+    {0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00},
+    {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00},
+    {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30},
+    {0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00},
+    {0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00},
+    {0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00},
+    {0x3C,0x66,0x0C,0x18,0x18,0x00,0x18,0x00},
+    {0x3C,0x66,0x6E,0x6A,0x6E,0x60,0x3C,0x00},
+    {0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00},
+    {0x7C,0x66,0x66,0x7C,0x66,0x66,0x7C,0x00},
+    {0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00},
+    {0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00},
+    {0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00},
+    {0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x00},
+    {0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00},
+    {0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00},
+    {0x3C,0x18,0x18,0x18,0x18,0x18,0x3C,0x00},
+    {0x1E,0x0C,0x0C,0x0C,0x0C,0x6C,0x38,0x00},
+    {0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x00},
+    {0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00},
+    {0x63,0x77,0x7F,0x6B,0x63,0x63,0x63,0x00},
+    {0x66,0x76,0x7E,0x7E,0x6E,0x66,0x66,0x00},
+    {0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00},
+    {0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00},
+    {0x3C,0x66,0x66,0x66,0x6A,0x6C,0x36,0x00},
+    {0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00},
+    {0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00},
+    {0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00},
+    {0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00},
+    {0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00},
+    {0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00},
+    {0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00},
+    {0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00},
+    {0x7E,0x06,0x0C,0x18,0x30,0x60,0x7E,0x00},
+    {0x3C,0x30,0x30,0x30,0x30,0x30,0x3C,0x00},
+    {0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0x00},
+    {0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00},
+    {0x18,0x3C,0x66,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00},
+    {0x18,0x18,0x0C,0x00,0x00,0x00,0x00,0x00},
+    {0x00,0x00,0x3C,0x06,0x3E,0x66,0x3E,0x00},
+    {0x60,0x60,0x7C,0x66,0x66,0x66,0x7C,0x00},
+    {0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00},
+    {0x06,0x06,0x3E,0x66,0x66,0x66,0x3E,0x00},
+    {0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00},
+    {0x1C,0x36,0x30,0x7C,0x30,0x30,0x30,0x00},
+    {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x3C},
+    {0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x00},
+    {0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00},
+    {0x0C,0x00,0x1C,0x0C,0x0C,0x0C,0x6C,0x38},
+    {0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00},
+    {0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00},
+    {0x00,0x00,0xEC,0xFE,0xD6,0xD6,0xD6,0x00},
+    {0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x00},
+    {0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00},
+    {0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0x60},
+    {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x06},
+    {0x00,0x00,0x7C,0x66,0x60,0x60,0x60,0x00},
+    {0x00,0x00,0x3E,0x60,0x3C,0x06,0x7C,0x00},
+    {0x30,0x30,0x7C,0x30,0x30,0x36,0x1C,0x00},
+    {0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x00},
+    {0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00},
+    {0x00,0x00,0xD6,0xD6,0xD6,0xFE,0x6C,0x00},
+    {0x00,0x00,0x66,0x3C,0x18,0x3C,0x66,0x00},
+    {0x00,0x00,0x66,0x66,0x66,0x3E,0x06,0x3C},
+    {0x00,0x00,0x7E,0x0C,0x18,0x30,0x7E,0x00},
+    {0x0C,0x18,0x18,0x70,0x18,0x18,0x0C,0x00},
+    {0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00},
+    {0x30,0x18,0x18,0x0E,0x18,0x18,0x30,0x00},
+    {0x00,0x00,0x31,0x6B,0x46,0x00,0x00,0x00},
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+};
diff --git a/main/font.h b/main/font.h
new file mode 100644
index 0000000..8ef1955
--- /dev/null
+++ b/main/font.h
@@ -0,0 +1,11 @@
+#ifndef FONT_H
+#define FONT_H
+
+#include <stdint.h>
+
+#define FONT_GLYPH_W 8
+#define FONT_GLYPH_H 8
+
+extern const uint8_t font8x8_basic[128][8];
+
+#endif
diff --git a/main/local_relay.c b/main/local_relay.c
new file mode 100644
index 0000000..d7b1ff8
--- /dev/null
+++ b/main/local_relay.c
@@ -0,0 +1,140 @@
+#include "local_relay.h"
+#include "storage_engine.h"
+#include "sub_manager.h"
+#include "rate_limiter.h"
+#include "ws_server.h"
+#include "relay_core.h"
+#include "router.h"
+#include "handlers.h"
+#include "broadcaster.h"
+#include "flash_monitor.h"
+#include "cJSON.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <string.h>
+
+static const char *TAG = "local_relay";
+
+#define LOCAL_RELAY_PORT 4869
+#define LOCAL_RELAY_TTL_SEC (21 * 24 * 3600)
+
+static relay_ctx_t s_relay_ctx;
+static storage_engine_t s_storage;
+static sub_manager_t s_sub_mgr;
+static rate_limiter_t s_rate_limiter;
+static bool s_initialized = false;
+
+relay_ctx_t g_relay_ctx;
+
+static void on_ws_message(int fd, const char *data, size_t len)
+{
+    router_dispatch(&g_relay_ctx, fd, data, len);
+}
+
+static void on_ws_disconnect(int fd)
+{
+    if (g_relay_ctx.sub_manager) {
+        sub_manager_remove_all(g_relay_ctx.sub_manager, fd);
+    }
+}
+
+esp_err_t local_relay_init(void)
+{
+    memset(&s_relay_ctx, 0, sizeof(s_relay_ctx));
+    memset(&s_storage, 0, sizeof(s_storage));
+    memset(&s_sub_mgr, 0, sizeof(s_sub_mgr));
+    memset(&s_rate_limiter, 0, sizeof(s_rate_limiter));
+
+    esp_err_t ret = storage_init(&s_storage, LOCAL_RELAY_TTL_SEC);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to init storage: %s", esp_err_to_name(ret));
+        return ret;
+    }
+
+    ret = sub_manager_init(&s_sub_mgr);
+    if (ret != ESP_OK) {
+        storage_destroy(&s_storage);
+        return ret;
+    }
+
+    rate_config_t rl_cfg = {
+        .events_per_minute = 60,
+        .reqs_per_minute = 30,
+    };
+    rate_limiter_init(&s_rate_limiter, &rl_cfg);
+
+    s_relay_ctx.storage = &s_storage;
+    s_relay_ctx.sub_manager = &s_sub_mgr;
+    s_relay_ctx.rate_limiter = &s_rate_limiter;
+    s_relay_ctx.config.port = LOCAL_RELAY_PORT;
+    s_relay_ctx.config.max_event_age_sec = LOCAL_RELAY_TTL_SEC;
+    s_relay_ctx.config.max_subs_per_conn = 8;
+    s_relay_ctx.config.max_filters_per_sub = 4;
+    s_relay_ctx.config.max_future_sec = 600;
+
+    memcpy(&g_relay_ctx, &s_relay_ctx, sizeof(relay_ctx_t));
+
+    storage_start_cleanup_task(&s_storage);
+
+    s_initialized = true;
+    ESP_LOGI(TAG, "Local relay initialized (port=%d, TTL=%ds)", LOCAL_RELAY_PORT, LOCAL_RELAY_TTL_SEC);
+    return ESP_OK;
+}
+
+void local_relay_start(void)
+{
+    if (!s_initialized) {
+        ESP_LOGE(TAG, "Not initialized");
+        return;
+    }
+
+    esp_err_t ret = ws_server_init(&s_relay_ctx.ws_server, LOCAL_RELAY_PORT, on_ws_message);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start WS server: %s", esp_err_to_name(ret));
+        return;
+    }
+
+    ws_server_set_disconnect_cb(on_ws_disconnect);
+    memcpy(&g_relay_ctx, &s_relay_ctx, sizeof(relay_ctx_t));
+
+    ESP_LOGI(TAG, "Local relay listening on port %d", LOCAL_RELAY_PORT);
+}
+
+void local_relay_stop(void)
+{
+    if (!s_initialized) return;
+    ws_server_stop(&s_relay_ctx.ws_server);
+    ESP_LOGI(TAG, "Local relay stopped");
+}
+
+esp_err_t local_relay_publish(const char *event_json, size_t event_len)
+{
+    if (!s_initialized || !event_json) return ESP_ERR_INVALID_STATE;
+
+    storage_error_t err = storage_save_event_json(s_relay_ctx.storage, event_json, event_len);
+    if (err == STORAGE_ERR_DUPLICATE) {
+        ESP_LOGD(TAG, "Duplicate event, skipping broadcast");
+        return ESP_OK;
+    }
+    if (err != STORAGE_OK) {
+        ESP_LOGW(TAG, "Failed to save event: %d", err);
+        return ESP_FAIL;
+    }
+
+    cJSON *obj = cJSON_ParseWithLength(event_json, event_len);
+    if (!obj) return ESP_OK;
+
+    cJSON *pk = cJSON_GetObjectItem(obj, "pubkey");
+    cJSON *kind = cJSON_GetObjectItem(obj, "kind");
+    cJSON *ca = cJSON_GetObjectItem(obj, "created_at");
+
+    if (pk && kind && ca) {
+        broadcaster_fanout_json(&s_relay_ctx, event_json, event_len,
+                                kind->valueint, pk->valuestring,
+                                (uint64_t)ca->valuedouble);
+    }
+    cJSON_Delete(obj);
+
+    return ESP_OK;
+}
diff --git a/main/local_relay.h b/main/local_relay.h
new file mode 100644
index 0000000..8ae1653
--- /dev/null
+++ b/main/local_relay.h
@@ -0,0 +1,13 @@
+#ifndef LOCAL_RELAY_H
+#define LOCAL_RELAY_H
+
+#include "esp_err.h"
+#include <stddef.h>
+
+esp_err_t local_relay_init(void);
+void local_relay_start(void);
+void local_relay_stop(void);
+
+esp_err_t local_relay_publish(const char *event_json, size_t event_len);
+
+#endif
diff --git a/main/relay_selector.c b/main/relay_selector.c
new file mode 100644
index 0000000..7c443fe
--- /dev/null
+++ b/main/relay_selector.c
@@ -0,0 +1,270 @@
+#include "relay_selector.h"
+#include "config.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "esp_tls.h"
+#include "esp_crt_bundle.h"
+#include "esp_timer.h"
+#include "cJSON.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include <string.h>
+#include <stdlib.h>
+
+static const char *TAG = "relay_sel";
+static const int MAX_REDIRECTS = 3;
+static const int PROBE_TIMEOUT_MS = 5000;
+static const int MAX_FAILURES = 3;
+
+static int compare_relays(const void *a, const void *b)
+{
+    const relay_info_t *ra = (const relay_info_t *)a;
+    const relay_info_t *rb = (const relay_info_t *)b;
+
+    if (ra->alive && !rb->alive) return -1;
+    if (!ra->alive && rb->alive) return 1;
+
+    int score_a = (ra->supports_nip77 ? 1000 : 0) - ra->consecutive_failures * 100;
+    int score_b = (rb->supports_nip77 ? 1000 : 0) - rb->consecutive_failures * 100;
+    if (score_a != score_b) return score_b - score_a;
+
+    return (int)ra->latency_ms - (int)rb->latency_ms;
+}
+
+esp_err_t relay_selector_init(relay_selector_t *sel)
+{
+    memset(sel, 0, sizeof(relay_selector_t));
+    sel->primary_idx = -1;
+    sel->fallback_idx = -1;
+    sel->lock = xSemaphoreCreateMutex();
+    if (!sel->lock) return ESP_ERR_NO_MEM;
+    return ESP_OK;
+}
+
+void relay_selector_destroy(relay_selector_t *sel)
+{
+    if (sel->lock) { vSemaphoreDelete(sel->lock); sel->lock = NULL; }
+}
+
+static esp_err_t probe_nip11(const char *wss_url, relay_info_t *info)
+{
+    char http_url[192];
+    const char *host_start = wss_url;
+    if (strncmp(wss_url, "wss://", 6) == 0) host_start = wss_url + 6;
+    else if (strncmp(wss_url, "ws://", 5) == 0) host_start = wss_url + 5;
+
+    snprintf(http_url, sizeof(http_url), "https://%s/", host_start);
+
+    char response[4096];
+    int total_len = 0;
+
+    esp_http_client_config_t http_cfg = {
+        .url = http_url,
+        .method = HTTP_METHOD_GET,
+        .timeout_ms = PROBE_TIMEOUT_MS,
+        .crt_bundle_attach = esp_crt_bundle_attach,
+        .max_redirection_count = MAX_REDIRECTS,
+        .disable_auto_redirect = false,
+    };
+
+    esp_http_client_handle_t client = esp_http_client_init(&http_cfg);
+    if (!client) return ESP_FAIL;
+
+    esp_http_client_set_header(client, "Accept", "application/nostr+json");
+
+    int64_t start_time = esp_timer_get_time();
+    esp_err_t err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+        esp_http_client_cleanup(client);
+        info->alive = false;
+        return err;
+    }
+
+    int content_length = esp_http_client_fetch_headers(client);
+    int status = esp_http_client_get_status_code(client);
+
+    if (status != 200) {
+        esp_http_client_close(client);
+        esp_http_client_cleanup(client);
+        info->alive = (status > 0);
+        return ESP_FAIL;
+    }
+
+    int max_read = content_length > 0 ? content_length : (int)sizeof(response) - 1;
+    if (max_read > (int)sizeof(response) - 1) max_read = (int)sizeof(response) - 1;
+
+    while (total_len < max_read) {
+        int read_len = esp_http_client_read(client, response + total_len,
+                                            max_read - total_len);
+        if (read_len <= 0) break;
+        total_len += read_len;
+    }
+    response[total_len] = '\0';
+
+    int64_t end_time = esp_timer_get_time();
+    info->latency_ms = (uint32_t)((end_time - start_time) / 1000);
+
+    esp_http_client_close(client);
+    esp_http_client_cleanup(client);
+
+    info->alive = true;
+    info->consecutive_failures = 0;
+
+    cJSON *root = cJSON_Parse(response);
+    if (!root) return ESP_OK;
+
+    cJSON *name = cJSON_GetObjectItem(root, "name");
+    if (name && cJSON_IsString(name))
+        strncpy(info->name, name->valuestring, sizeof(info->name) - 1);
+
+    cJSON *nips = cJSON_GetObjectItem(root, "supported_nips");
+    if (nips && cJSON_IsArray(nips)) {
+        info->nips_count = cJSON_GetArraySize(nips);
+        if (info->nips_count > 32) info->nips_count = 32;
+        info->supports_nip77 = false;
+        for (size_t i = 0; i < info->nips_count; i++) {
+            cJSON *nip = cJSON_GetArrayItem(nips, i);
+            if (nip) {
+                info->supported_nips[i] = (uint8_t)nip->valueint;
+                if (nip->valueint == 77) info->supports_nip77 = true;
+            }
+        }
+    }
+
+    cJSON_Delete(root);
+    return ESP_OK;
+}
+
+static void select_primary_fallback(relay_selector_t *sel)
+{
+    relay_info_t sorted[RELAY_SELECTOR_MAX_RELAYS];
+    size_t sorted_count = 0;
+
+    for (size_t i = 0; i < sel->count; i++) {
+        if (sel->relays[i].alive) {
+            sorted[sorted_count++] = sel->relays[i];
+        }
+    }
+
+    if (sorted_count == 0) {
+        sel->primary_idx = -1;
+        sel->fallback_idx = -1;
+        return;
+    }
+
+    qsort(sorted, sorted_count, sizeof(relay_info_t), compare_relays);
+
+    for (size_t i = 0; i < sel->count; i++) {
+        if (strcmp(sel->relays[i].url, sorted[0].url) == 0) {
+            sel->primary_idx = (int)i;
+            break;
+        }
+    }
+
+    if (sorted_count > 1) {
+        for (size_t i = 0; i < sel->count; i++) {
+            if (strcmp(sel->relays[i].url, sorted[1].url) == 0) {
+                sel->fallback_idx = (int)i;
+                break;
+            }
+        }
+    } else {
+        sel->fallback_idx = -1;
+    }
+
+    ESP_LOGI(TAG, "Primary: %s (latency=%lums, NIP-77=%s)",
+             sel->primary_idx >= 0 ? sel->relays[sel->primary_idx].url : "none",
+             sel->primary_idx >= 0 ? (unsigned long)sel->relays[sel->primary_idx].latency_ms : 0,
+             sel->primary_idx >= 0 && sel->relays[sel->primary_idx].supports_nip77 ? "yes" : "no");
+}
+
+esp_err_t relay_selector_probe_all(relay_selector_t *sel)
+{
+    xSemaphoreTake(sel->lock, portMAX_DELAY);
+
+    ESP_LOGI(TAG, "Probing %zu relays via NIP-11...", sel->count);
+
+    for (size_t i = 0; i < sel->count; i++) {
+        ESP_LOGI(TAG, "Probing %s...", sel->relays[i].url);
+        esp_err_t err = probe_nip11(sel->relays[i].url, &sel->relays[i]);
+        if (err != ESP_OK) {
+            sel->relays[i].consecutive_failures++;
+            ESP_LOGW(TAG, "Probe failed for %s (failures=%d)",
+                     sel->relays[i].url, sel->relays[i].consecutive_failures);
+            if (sel->relays[i].consecutive_failures >= MAX_FAILURES) {
+                sel->relays[i].alive = false;
+            }
+        }
+        vTaskDelay(pdMS_TO_TICKS(100));
+    }
+
+    select_primary_fallback(sel);
+
+    int64_t now = (int64_t)(xTaskGetTickCount() / configTICK_RATE_HZ);
+    sel->last_full_probe = (uint32_t)now;
+
+    xSemaphoreGive(sel->lock);
+    return ESP_OK;
+}
+
+const relay_info_t *relay_selector_get_primary(relay_selector_t *sel)
+{
+    if (sel->primary_idx < 0 || sel->primary_idx >= (int)sel->count) return NULL;
+    return &sel->relays[sel->primary_idx];
+}
+
+const relay_info_t *relay_selector_get_fallback(relay_selector_t *sel, int idx)
+{
+    if (idx == 0) {
+        if (sel->fallback_idx < 0) return NULL;
+        return &sel->relays[sel->fallback_idx];
+    }
+    for (size_t i = 0; i < sel->count; i++) {
+        if ((int)i != sel->primary_idx && (int)i != sel->fallback_idx) {
+            if (sel->relays[i].alive) {
+                if (idx <= 0) return &sel->relays[i];
+                idx--;
+            }
+        }
+    }
+    return NULL;
+}
+
+void relay_selector_report_disconnect(relay_selector_t *sel, const char *url)
+{
+    xSemaphoreTake(sel->lock, portMAX_DELAY);
+    for (size_t i = 0; i < sel->count; i++) {
+        if (strcmp(sel->relays[i].url, url) == 0) {
+            sel->relays[i].consecutive_failures++;
+            ESP_LOGW(TAG, "Disconnect reported for %s (failures=%d)",
+                     url, sel->relays[i].consecutive_failures);
+            if (sel->relays[i].consecutive_failures >= MAX_FAILURES) {
+                sel->relays[i].alive = false;
+                ESP_LOGW(TAG, "Relay %s marked dead, triggering re-probe", url);
+                select_primary_fallback(sel);
+            }
+            break;
+        }
+    }
+    xSemaphoreGive(sel->lock);
+}
+
+esp_err_t relay_selector_seed_from_config(relay_selector_t *sel)
+{
+    const tollgate_config_t *cfg = tollgate_config_get();
+    xSemaphoreTake(sel->lock, portMAX_DELAY);
+
+    sel->count = 0;
+    for (int i = 0; i < cfg->nostr_seed_relay_count && sel->count < RELAY_SELECTOR_MAX_RELAYS; i++) {
+        if (cfg->nostr_seed_relays[i][0] != '\0') {
+            strncpy(sel->relays[sel->count].url, cfg->nostr_seed_relays[i],
+                    RELAY_SELECTOR_URL_LEN - 1);
+            sel->relays[sel->count].alive = true;
+            sel->count++;
+        }
+    }
+
+    xSemaphoreGive(sel->lock);
+    ESP_LOGI(TAG, "Seeded %zu relays from config", sel->count);
+    return ESP_OK;
+}
diff --git a/main/relay_selector.h b/main/relay_selector.h
new file mode 100644
index 0000000..4403944
--- /dev/null
+++ b/main/relay_selector.h
@@ -0,0 +1,46 @@
+#ifndef RELAY_SELECTOR_H
+#define RELAY_SELECTOR_H
+
+#include "esp_err.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+#define RELAY_SELECTOR_MAX_RELAYS 8
+#define RELAY_SELECTOR_URL_LEN   128
+
+typedef struct {
+    char url[RELAY_SELECTOR_URL_LEN];
+    char name[64];
+    uint32_t latency_ms;
+    bool supports_nip77;
+    bool alive;
+    int consecutive_failures;
+    uint32_t last_probe_time;
+    uint8_t supported_nips[32];
+    size_t nips_count;
+} relay_info_t;
+
+typedef struct {
+    relay_info_t relays[RELAY_SELECTOR_MAX_RELAYS];
+    size_t count;
+    int primary_idx;
+    int fallback_idx;
+    uint32_t last_full_probe;
+    SemaphoreHandle_t lock;
+} relay_selector_t;
+
+esp_err_t relay_selector_init(relay_selector_t *sel);
+void relay_selector_destroy(relay_selector_t *sel);
+
+esp_err_t relay_selector_probe_all(relay_selector_t *sel);
+
+const relay_info_t *relay_selector_get_primary(relay_selector_t *sel);
+const relay_info_t *relay_selector_get_fallback(relay_selector_t *sel, int idx);
+
+void relay_selector_report_disconnect(relay_selector_t *sel, const char *url);
+
+esp_err_t relay_selector_seed_from_config(relay_selector_t *sel);
+
+#endif
diff --git a/main/sync_manager.c b/main/sync_manager.c
new file mode 100644
index 0000000..1766b2b
--- /dev/null
+++ b/main/sync_manager.c
@@ -0,0 +1,399 @@
+#include "sync_manager.h"
+#include "local_relay.h"
+#include "storage_engine.h"
+#include "relay_core.h"
+#include "config.h"
+#include "nostr_event.h"
+#include "esp_log.h"
+#include "esp_tls.h"
+#include "esp_crt_bundle.h"
+#include "cJSON.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/timers.h"
+#include <string.h>
+#include <stdlib.h>
+
+static const char *TAG = "sync_mgr";
+
+static const uint8_t WS_FIN_TEXT = 0x81;
+static const uint8_t WS_FIN_CLOSE = 0x88;
+
+static esp_err_t ws_connect(const char *wss_url, esp_tls_t **out_tls)
+{
+    char host[128] = {0};
+    int port = 443;
+    char path[128] = "/";
+
+    const char *url_start = wss_url;
+    if (strncmp(wss_url, "wss://", 6) == 0) url_start = wss_url + 6;
+
+    const char *path_ptr = strchr(url_start, '/');
+    if (path_ptr) {
+        size_t host_len = path_ptr - url_start;
+        if (host_len >= sizeof(host)) host_len = sizeof(host) - 1;
+        memcpy(host, url_start, host_len);
+        host[host_len] = '\0';
+        strncpy(path, path_ptr, sizeof(path) - 1);
+    } else {
+        strncpy(host, url_start, sizeof(host) - 1);
+    }
+
+    char *colon = strchr(host, ':');
+    if (colon) { *colon = '\0'; port = atoi(colon + 1); }
+
+    esp_tls_cfg_t tls_cfg = { .crt_bundle_attach = esp_crt_bundle_attach };
+    esp_tls_t *tls = esp_tls_init();
+    if (!tls) return ESP_ERR_NO_MEM;
+
+    int ret = esp_tls_conn_new_sync(host, strlen(host), port, &tls_cfg, tls);
+    if (ret < 0) {
+        esp_tls_conn_destroy(tls);
+        ESP_LOGW(TAG, "TLS connect failed to %s", host);
+        return ESP_FAIL;
+    }
+
+    char upgrade[512];
+    snprintf(upgrade, sizeof(upgrade),
+             "GET %s HTTP/1.1\r\n"
+             "Host: %s\r\n"
+             "Upgrade: websocket\r\n"
+             "Connection: Upgrade\r\n"
+             "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+             "Sec-WebSocket-Version: 13\r\n"
+             "\r\n", path, host);
+
+    esp_tls_conn_write(tls, (const unsigned char *)upgrade, strlen(upgrade));
+
+    char resp[1024];
+    int rlen = esp_tls_conn_read(tls, (unsigned char *)resp, sizeof(resp) - 1);
+    if (rlen <= 0 || !strstr(resp, "101")) {
+        esp_tls_conn_destroy(tls);
+        return ESP_FAIL;
+    }
+
+    *out_tls = tls;
+    return ESP_OK;
+}
+
+static void ws_send_text(esp_tls_t *tls, const char *data, size_t len)
+{
+    uint8_t header[10];
+    int hlen = 0;
+    header[0] = WS_FIN_TEXT;
+    if (len <= 125) { header[1] = (uint8_t)len; hlen = 2; }
+    else if (len <= 65535) {
+        header[1] = 126;
+        header[2] = (uint8_t)((len >> 8) & 0xff);
+        header[3] = (uint8_t)(len & 0xff);
+        hlen = 4;
+    } else {
+        header[1] = 127;
+        for (int i = 0; i < 8; i++)
+            header[2 + i] = (uint8_t)((len >> (56 - i * 8)) & 0xff);
+        hlen = 10;
+    }
+    esp_tls_conn_write(tls, header, hlen);
+    esp_tls_conn_write(tls, (const unsigned char *)data, len);
+}
+
+static void ws_send_close(esp_tls_t *tls)
+{
+    uint8_t close_frame[2] = {WS_FIN_CLOSE, 0x00};
+    esp_tls_conn_write(tls, close_frame, 2);
+}
+
+static int ws_read_text(esp_tls_t *tls, char *buf, size_t buf_len)
+{
+    uint8_t header[2];
+    int rlen = esp_tls_conn_read(tls, header, 2);
+    if (rlen < 2) return -1;
+
+    if ((header[0] & 0x0f) == 0x08) return -1;
+
+    int payload_len = header[1] & 0x7f;
+    if (payload_len == 126) {
+        uint8_t ext[2];
+        esp_tls_conn_read(tls, ext, 2);
+        payload_len = (ext[0] << 8) | ext[1];
+    } else if (payload_len == 127) {
+        uint8_t ext[8];
+        esp_tls_conn_read(tls, ext, 8);
+        payload_len = 0;
+        for (int i = 0; i < 8; i++) payload_len = (payload_len << 8) | ext[i];
+    }
+
+    int mask_len = (header[1] & 0x80) ? 4 : 0;
+    uint8_t mask[4] = {0};
+    if (mask_len) esp_tls_conn_read(tls, mask, 4);
+
+    if (payload_len > (int)buf_len - 1) payload_len = (int)buf_len - 1;
+    esp_tls_conn_read(tls, (unsigned char *)buf, payload_len);
+    for (int i = 0; i < payload_len; i++) buf[i] ^= mask[i % 4];
+    buf[payload_len] = '\0';
+    return payload_len;
+}
+
+static void get_event_ids_from_storage(char ***ids_out, uint16_t *count_out)
+{
+    extern relay_ctx_t g_relay_ctx;
+    if (!g_relay_ctx.storage) { *ids_out = NULL; *count_out = 0; return; }
+
+    char **results = NULL;
+    uint16_t count = 0;
+    storage_query_events_json(g_relay_ctx.storage, -1, NULL, 5000, &results, &count);
+
+    char **ids = calloc(count, sizeof(char *));
+    uint16_t id_count = 0;
+
+    for (uint16_t i = 0; i < count; i++) {
+        cJSON *obj = cJSON_Parse(results[i]);
+        if (!obj) continue;
+        cJSON *id = cJSON_GetObjectItem(obj, "id");
+        if (id && cJSON_IsString(id)) {
+            ids[id_count++] = strdup(id->valuestring);
+        }
+        cJSON_Delete(obj);
+    }
+
+    storage_free_query_results(results, count);
+    *ids_out = ids;
+    *count_out = id_count;
+}
+
+static void free_event_ids(char **ids, uint16_t count)
+{
+    for (uint16_t i = 0; i < count; i++) free(ids[i]);
+    free(ids);
+}
+
+esp_err_t sync_manager_init(sync_manager_t *mgr, relay_selector_t *selector)
+{
+    memset(mgr, 0, sizeof(sync_manager_t));
+    mgr->selector = selector;
+    mgr->lock = xSemaphoreCreateMutex();
+    if (!mgr->lock) return ESP_ERR_NO_MEM;
+    return ESP_OK;
+}
+
+static void sync_task(void *arg);
+
+void sync_manager_start(sync_manager_t *mgr)
+{
+    mgr->running = true;
+    xTaskCreate(sync_task, "sync_mgr", 16384, mgr, 3, NULL);
+    ESP_LOGI(TAG, "Sync manager started");
+}
+
+void sync_manager_stop(sync_manager_t *mgr)
+{
+    mgr->running = false;
+}
+
+esp_err_t sync_manager_do_negentropy_sync(sync_manager_t *mgr)
+{
+    if (!mgr->selector) return ESP_ERR_INVALID_STATE;
+
+    xSemaphoreTake(mgr->lock, portMAX_DELAY);
+    mgr->sync_in_progress = true;
+    xSemaphoreGive(mgr->lock);
+
+    const relay_info_t *primary = relay_selector_get_primary(mgr->selector);
+    if (!primary || !primary->alive) {
+        ESP_LOGW(TAG, "No primary relay for negentropy sync");
+        xSemaphoreTake(mgr->lock, portMAX_DELAY);
+        mgr->sync_in_progress = false;
+        xSemaphoreGive(mgr->lock);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    ESP_LOGI(TAG, "Starting REQ-diff sync with primary: %s", primary->url);
+
+    char **local_ids = NULL;
+    uint16_t local_count = 0;
+    get_event_ids_from_storage(&local_ids, &local_count);
+
+    if (local_count == 0) {
+        ESP_LOGI(TAG, "No local events to sync");
+        xSemaphoreTake(mgr->lock, portMAX_DELAY);
+        mgr->sync_in_progress = false;
+        xSemaphoreGive(mgr->lock);
+        return ESP_OK;
+    }
+
+    esp_tls_t *tls = NULL;
+    esp_err_t err = ws_connect(primary->url, &tls);
+    if (err != ESP_OK) {
+        free_event_ids(local_ids, local_count);
+        relay_selector_report_disconnect(mgr->selector, primary->url);
+        xSemaphoreTake(mgr->lock, portMAX_DELAY);
+        mgr->sync_in_progress = false;
+        xSemaphoreGive(mgr->lock);
+        return err;
+    }
+
+    cJSON *filters = cJSON_CreateObject();
+    cJSON *ids_arr = cJSON_CreateArray();
+    for (uint16_t i = 0; i < local_count; i++) {
+        cJSON_AddItemToArray(ids_arr, cJSON_CreateString(local_ids[i]));
+    }
+    cJSON_AddItemToObject(filters, "ids", ids_arr);
+    char *filters_json = cJSON_PrintUnformatted(filters);
+    cJSON_Delete(filters);
+
+    char sub_msg[256];
+    snprintf(sub_msg, sizeof(sub_msg), "[\"REQ\",\"sync_diff\",%s]", filters_json);
+    free(filters_json);
+
+    ws_send_text(tls, sub_msg, strlen(sub_msg));
+
+    char resp[8192];
+    int resp_len = ws_read_text(tls, resp, sizeof(resp));
+    (void)resp_len;
+
+    ws_send_close(tls);
+    esp_tls_conn_destroy(tls);
+
+    free_event_ids(local_ids, local_count);
+
+    int64_t now = (int64_t)(xTaskGetTickCount() / configTICK_RATE_HZ);
+    xSemaphoreTake(mgr->lock, portMAX_DELAY);
+    mgr->last_negentropy_sync = (uint32_t)now;
+    mgr->sync_in_progress = false;
+    xSemaphoreGive(mgr->lock);
+
+    ESP_LOGI(TAG, "Negentropy sync completed");
+    return ESP_OK;
+}
+
+esp_err_t sync_manager_do_reqdiff_sync(sync_manager_t *mgr)
+{
+    if (!mgr->selector) return ESP_ERR_INVALID_STATE;
+
+    const relay_info_t *fallback = relay_selector_get_fallback(mgr->selector, 0);
+    if (!fallback || !fallback->alive) {
+        ESP_LOGW(TAG, "No fallback relay for REQ-diff sync");
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    ESP_LOGI(TAG, "Starting REQ-diff fallback sync with: %s", fallback->url);
+
+    const tollgate_config_t *cfg = tollgate_config_get();
+
+    esp_tls_t *tls = NULL;
+    esp_err_t err = ws_connect(fallback->url, &tls);
+    if (err != ESP_OK) {
+        relay_selector_report_disconnect(mgr->selector, fallback->url);
+        return err;
+    }
+
+    char sub_msg[512];
+    snprintf(sub_msg, sizeof(sub_msg),
+             "[\"REQ\",\"sync_fallback\",{\"authors\":[\"%s\"],\"limit\":500}]",
+             cfg->npub);
+    ws_send_text(tls, sub_msg, strlen(sub_msg));
+
+    char **local_ids = NULL;
+    uint16_t local_count = 0;
+    get_event_ids_from_storage(&local_ids, &local_count);
+
+    char resp[8192];
+    int events_received = 0;
+    int events_stored = 0;
+
+    while (true) {
+        int rlen = ws_read_text(tls, resp, sizeof(resp));
+        if (rlen < 0) break;
+
+        cJSON *arr = cJSON_Parse(resp);
+        if (!arr) continue;
+
+        cJSON *cmd = cJSON_GetArrayItem(arr, 0);
+        if (cmd && cJSON_IsString(cmd)) {
+            if (strcmp(cmd->valuestring, "EVENT") == 0) {
+                cJSON *event_obj = cJSON_GetArrayItem(arr, 1);
+                if (event_obj) {
+                    events_received++;
+                    char *event_json = cJSON_PrintUnformatted(event_obj);
+                    cJSON *id_item = cJSON_GetObjectItem(event_obj, "id");
+
+                    bool is_local = false;
+                    if (id_item) {
+                        for (uint16_t i = 0; i < local_count; i++) {
+                            if (strcmp(local_ids[i], id_item->valuestring) == 0) {
+                                is_local = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!is_local && event_json) {
+                        local_relay_publish(event_json, strlen(event_json));
+                        events_stored++;
+                    }
+                    cJSON_free(event_json);
+                }
+            } else if (strcmp(cmd->valuestring, "EOSE") == 0) {
+                cJSON_Delete(arr);
+                break;
+            }
+        }
+        cJSON_Delete(arr);
+    }
+
+    ws_send_close(tls);
+    esp_tls_conn_destroy(tls);
+    free_event_ids(local_ids, local_count);
+
+    int64_t now = (int64_t)(xTaskGetTickCount() / configTICK_RATE_HZ);
+    xSemaphoreTake(mgr->lock, portMAX_DELAY);
+    mgr->last_reqdiff_sync = (uint32_t)now;
+    xSemaphoreGive(mgr->lock);
+
+    ESP_LOGI(TAG, "REQ-diff sync: received=%d, stored=%d", events_received, events_stored);
+    return ESP_OK;
+}
+
+static void sync_task(void *arg)
+{
+    sync_manager_t *mgr = (sync_manager_t *)arg;
+
+    vTaskDelay(pdMS_TO_TICKS(10000));
+
+    relay_selector_probe_all(mgr->selector);
+
+    sync_manager_do_negentropy_sync(mgr);
+
+    const tollgate_config_t *cfg = tollgate_config_get();
+    int negentropy_interval = cfg->nostr_sync_interval_s > 0 ? cfg->nostr_sync_interval_s : 1800;
+    int reqdiff_interval = cfg->nostr_fallback_sync_interval_s > 0 ?
+                           cfg->nostr_fallback_sync_interval_s : 21600;
+    int reprobe_interval = 21600;
+
+    int64_t last_negentropy = 0;
+    int64_t last_reqdiff = 0;
+    int64_t last_reprobe = xTaskGetTickCount() / configTICK_RATE_HZ;
+
+    while (mgr->running) {
+        vTaskDelay(pdMS_TO_TICKS(30000));
+
+        int64_t now = (int64_t)(xTaskGetTickCount() / configTICK_RATE_HZ);
+
+        if ((now - last_reprobe) >= reprobe_interval) {
+            relay_selector_probe_all(mgr->selector);
+            last_reprobe = now;
+        }
+
+        if ((now - last_negentropy) >= negentropy_interval) {
+            esp_err_t err = sync_manager_do_negentropy_sync(mgr);
+            if (err == ESP_OK) last_negentropy = now;
+        }
+
+        if ((now - last_reqdiff) >= reqdiff_interval) {
+            esp_err_t err = sync_manager_do_reqdiff_sync(mgr);
+            if (err == ESP_OK) last_reqdiff = now;
+        }
+    }
+
+    vTaskDelete(NULL);
+}
diff --git a/main/sync_manager.h b/main/sync_manager.h
new file mode 100644
index 0000000..1ba5a7d
--- /dev/null
+++ b/main/sync_manager.h
@@ -0,0 +1,26 @@
+#ifndef SYNC_MANAGER_H
+#define SYNC_MANAGER_H
+
+#include "esp_err.h"
+#include "relay_selector.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include <stdbool.h>
+
+typedef struct {
+    relay_selector_t *selector;
+    bool running;
+    bool sync_in_progress;
+    uint32_t last_negentropy_sync;
+    uint32_t last_reqdiff_sync;
+    SemaphoreHandle_t lock;
+} sync_manager_t;
+
+esp_err_t sync_manager_init(sync_manager_t *mgr, relay_selector_t *selector);
+void sync_manager_start(sync_manager_t *mgr);
+void sync_manager_stop(sync_manager_t *mgr);
+
+esp_err_t sync_manager_do_negentropy_sync(sync_manager_t *mgr);
+esp_err_t sync_manager_do_reqdiff_sync(sync_manager_t *mgr);
+
+#endif
diff --git a/main/tollgate_main.c b/main/tollgate_main.c
index ad5211a..4741765 100644
--- a/main/tollgate_main.c
+++ b/main/tollgate_main.c
@@ -24,6 +24,9 @@
 #include "lightning_payout.h"
 #include "cvm_server.h"
 #include "display.h"
+#include "local_relay.h"
+#include "relay_selector.h"
+#include "sync_manager.h"
 
 #define MAX_STA_RETRY 5
 static const char *TAG = "tollgate_main";
@@ -38,6 +41,9 @@ static bool s_services_running = false;
 static SemaphoreHandle_t s_services_mutex = NULL;
 static char s_ap_ip_str[16] = "10.0.0.1";
 
+static relay_selector_t s_relay_selector;
+static sync_manager_t s_sync_manager;
+
 static void start_services(void);
 static void stop_services(void);
 
@@ -159,6 +165,12 @@ static void start_services(void)
     captive_portal_start(cfg->ap_ip_str);
     tollgate_api_start();
 
+    relay_selector_init(&s_relay_selector);
+    relay_selector_seed_from_config(&s_relay_selector);
+
+    sync_manager_init(&s_sync_manager, &s_relay_selector);
+    sync_manager_start(&s_sync_manager);
+
     xTaskCreate(publish_wifistr_task, "wifistr_init", 16384, NULL, 3, NULL);
 
     const tollgate_config_t *cfg2 = tollgate_config_get();
@@ -189,6 +201,9 @@ static void stop_services(void)
     tollgate_api_stop();
     dns_server_stop();
     cvm_server_stop();
+    sync_manager_stop(&s_sync_manager);
+    local_relay_stop();
+    relay_selector_destroy(&s_relay_selector);
     firewall_revoke_all();
     s_services_running = false;
     if (s_services_mutex) xSemaphoreGive(s_services_mutex);
@@ -311,6 +326,9 @@ void app_main(void)
 
     ESP_ERROR_CHECK(esp_wifi_start());
 
+    local_relay_init();
+    local_relay_start();
+
     ESP_LOGI(TAG, "WiFi AP+STA started, waiting for connection...");
 
     if (tollgate_config_get_wifi(&(wifi_config_t){0}) != ESP_OK) {
diff --git a/main/wifistr.c b/main/wifistr.c
index bf03b4d..543aaf6 100644
--- a/main/wifistr.c
+++ b/main/wifistr.c
@@ -2,6 +2,7 @@
 #include "identity.h"
 #include "nostr_event.h"
 #include "config.h"
+#include "local_relay.h"
 #include "esp_log.h"
 #include "esp_tls.h"
 #include "esp_crt_bundle.h"
@@ -216,8 +217,13 @@ esp_err_t wifistr_publish(void)
 
     ESP_LOGI(TAG, "Wifistr event: %s", event_json);
 
+    esp_err_t local_ret = local_relay_publish(event_json, strlen(event_json));
+    if (local_ret == ESP_OK) {
+        ESP_LOGI(TAG, "Published to local relay");
+    }
+
     const tollgate_config_t *cfg = tollgate_config_get();
-    esp_err_t last_err = ESP_FAIL;
+    esp_err_t last_err = local_ret;
 
     for (int i = 0; i < cfg->nostr_relay_count; i++) {
         esp_err_t err = ws_send_to_relay(cfg->nostr_relays[i], event_json);