v0.7.38 - Fixed error upon startup with existing db

v0.7.37 - Enhanced admin interface with sliding sidebar navigation, moved dark mode and logout to sidebar footer, improved button styling consistency
v0.7.36 - Implement sliding side navigation menu with page switching for admin sections
2025-10-23 11:17:16 -04:00 · 2025-10-22 12:43:09 -04:00 · 2025-10-22 11:01:30 -04:00 · 2025-10-22 10:48:57 -04:00 · 2025-10-22 10:19:43 -04:00 · 2025-10-19 10:26:09 -04:00
33 changed files with 3710 additions and 977 deletions
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -121,8 +121,8 @@ fuser -k 8888/tcp
 - Event filtering done at C level, not SQL level for NIP-40 expiration

 ### Configuration Override Behavior
- CLI port override only affects first-time startup
- After database creation, all config comes from events
+- CLI port override applies during first-time startup and existing relay restarts
+- After database creation, all config comes from events (but CLI overrides can still be applied)
 - Database path cannot be changed after initialization

 ## Non-Obvious Pitfalls
--- a/Dockerfile.alpine-musl
+++ b/Dockerfile.alpine-musl
@@ -5,6 +5,9 @@ ARG DEBUG_BUILD=false

 FROM alpine:3.19 AS builder

+# Re-declare build argument in this stage
+ARG DEBUG_BUILD=false
+
 # Install build dependencies
 RUN apk add --no-cache \
    build-base \
--- a/api/index.css
+++ b/api/index.css
@@ -305,6 +305,8 @@ h2 {
    border-radius: var(--border-radius);
    padding: 20px;
    margin-bottom: 20px;
+    margin-left: 5px;
+    margin-right:5px;
 }

 .input-group {
@@ -1107,3 +1109,123 @@ body.dark-mode .sql-results-table tbody tr:nth-child(even) {
    border-radius: var(--border-radius);
    box-sizing: border-box;
 }
+
+/* ================================
+   SIDE NAVIGATION MENU
+   ================================ */
+
+.side-nav {
+    position: fixed;
+    top: 0;
+    left: -300px;
+    width: 280px;
+    height: 100vh;
+    background: var(--secondary-color);
+    border-right: var(--border-width) solid var(--border-color);
+    z-index: 1000;
+    transition: left 0.3s ease;
+    overflow-y: auto;
+    padding-top: 80px;
+}
+
+.side-nav.open {
+    left: 0;
+}
+
+.side-nav-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 999;
+    display: none;
+}
+
+.side-nav-overlay.show {
+    display: block;
+}
+
+.nav-menu {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+
+.nav-menu li {
+    border-bottom: var(--border-width) solid var(--muted-color);
+}
+
+.nav-menu li:last-child {
+    border-bottom: none;
+}
+
+.nav-item {
+    display: block;
+    padding: 15px 20px;
+    color: var(--primary-color);
+    text-decoration: none;
+    font-family: var(--font-family);
+    font-size: 16px;
+    font-weight: bold;
+    transition: all 0.2s ease;
+    cursor: pointer;
+    border: 2px solid var(--secondary-color);
+    background: none;
+    width: 100%;
+    text-align: left;
+}
+
+.nav-item:hover {
+    border: 2px solid var(--secondary-color);
+    background:var(--muted-color);
+    color: var(--accent-color);
+}
+
+.nav-item.active {
+    text-decoration: underline;
+      padding-left: 16px;
+  }
+
+.nav-footer {
+      position: absolute;
+      bottom: 20px;
+      left: 0;
+      right: 0;
+      padding: 0 20px;
+  }
+
+.nav-footer-btn {
+      display: block;
+      width: 100%;
+      padding: 12px 20px;
+      margin-bottom: 8px;
+      color: var(--primary-color);
+
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      font-family: var(--font-family);
+      font-size: 14px;
+      font-weight: bold;
+      cursor: pointer;
+      transition: all 0.2s ease;
+  }
+
+.nav-footer-btn:hover {
+      background:var(--muted-color);
+      border-color: var(--accent-color);
+  }
+
+.nav-footer-btn:last-child {
+      margin-bottom: 0;
+  }
+
+.header-title.clickable {
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.header-title.clickable:hover {
+    opacity: 0.8;
+}
--- a/api/index.html
+++ b/api/index.html
@@ -9,11 +9,30 @@
 </head>

 <body>
+    <!-- Side Navigation Menu -->
+    <nav class="side-nav" id="side-nav">
+        <ul class="nav-menu">
+            <li><button class="nav-item" data-page="statistics">Statistics</button></li>
+            <li><button class="nav-item" data-page="subscriptions">Subscriptions</button></li>
+            <li><button class="nav-item" data-page="configuration">Configuration</button></li>
+            <li><button class="nav-item" data-page="authorization">Authorization</button></li>
+            <li><button class="nav-item" data-page="dm">DM</button></li>
+            <li><button class="nav-item" data-page="database">Database Query</button></li>
+        </ul>
+        <div class="nav-footer">
+            <button class="nav-footer-btn" id="nav-dark-mode-btn">DARK MODE</button>
+            <button class="nav-footer-btn" id="nav-logout-btn">LOGOUT</button>
+        </div>
+    </nav>
+
+    <!-- Side Navigation Overlay -->
+    <div class="side-nav-overlay" id="side-nav-overlay"></div>
+
    <!-- Header with title and profile display -->
    <div class="section">

            <div class="header-content">
-                <div class="header-title">
+                <div class="header-title clickable" id="header-title">
                    <span class="relay-letter" data-letter="R">R</span>
                    <span class="relay-letter" data-letter="E">E</span>
                    <span class="relay-letter" data-letter="L">L</span>
@@ -34,10 +53,7 @@
                        <span id="header-user-name" class="header-user-name">Loading...</span>
                    </div>
                    <!-- Logout dropdown -->
-                    <div class="logout-dropdown" id="logout-dropdown" style="display: none;">
-                        <button type="button" id="dark-mode-btn" class="logout-btn">🌙 DARK MODE</button>
-                        <button type="button" id="logout-btn" class="logout-btn">LOGOUT</button>
-                    </div>
+                    <!-- Dropdown menu removed - buttons moved to sidebar -->
                </div>
            </div>

@@ -54,9 +70,8 @@
    <div class="section flex-section" id="databaseStatisticsSection" style="display: none;">
        <div class="section-header">
            <h2>DATABASE STATISTICS</h2>
-            <!-- Monitoring toggle button will be inserted here by JavaScript -->
-            <!-- Temporarily disable auto-refresh button for real-time monitoring -->
-            <!-- <button type="button" id="refresh-stats-btn" class="countdown-btn"></button> -->
+            <!-- Monitoring is now subscription-based - no toggle button needed -->
+            <!-- Subscribe to kind 24567 events to receive real-time monitoring data -->
        </div>

        <!-- Event Rate Graph Container -->
@@ -81,10 +96,26 @@
                            <td>Total Events</td>
                            <td id="total-events">-</td>
                        </tr>
+                        <tr>
+                            <td>Process ID</td>
+                            <td id="process-id">-</td>
+                        </tr>
                        <tr>
                            <td>Active Subscriptions</td>
                            <td id="active-subscriptions">-</td>
                        </tr>
+                        <tr>
+                            <td>Memory Usage</td>
+                            <td id="memory-usage">-</td>
+                        </tr>
+                        <tr>
+                            <td>CPU Core</td>
+                            <td id="cpu-core">-</td>
+                        </tr>
+                        <tr>
+                            <td>CPU Usage</td>
+                            <td id="cpu-usage">-</td>
+                        </tr>
                        <tr>
                            <td>Oldest Event</td>
                            <td id="oldest-event">-</td>
@@ -185,15 +216,14 @@
                        <tr>
                            <th>Subscription ID</th>
                            <th>Client IP</th>
+                            <th>WSI Pointer</th>
                            <th>Duration</th>
-                            <th>Events Sent</th>
-                            <th>Status</th>
                            <th>Filters</th>
                        </tr>
                    </thead>
                    <tbody id="subscription-details-table-body">
                        <tr>
-                            <td colspan="6" style="text-align: center; font-style: italic;">No subscriptions active</td>
+                            <td colspan="5" style="text-align: center; font-style: italic;">No subscriptions active</td>
                        </tr>
                    </tbody>
                </table>
--- a/api/index.js
+++ b/api/index.js
--- a/api/text_graph.js
+++ b/api/text_graph.js
@@ -18,6 +18,7 @@ class ASCIIBarChart {
     * @param {boolean} [options.useBinMode=false] - Enable time bin mode for data aggregation
     * @param {number} [options.binDuration=10000] - Duration of each time bin in milliseconds (10 seconds default)
     * @param {string} [options.xAxisLabelFormat='elapsed'] - X-axis label format: 'elapsed', 'bins', 'timestamps', 'ranges'
+     * @param {boolean} [options.debug=false] - Enable debug logging
     */
    constructor(containerId, options = {}) {
        this.container = document.getElementById(containerId);
@@ -29,6 +30,7 @@ class ASCIIBarChart {
        this.xAxisLabel = options.xAxisLabel || '';
        this.yAxisLabel = options.yAxisLabel || '';
        this.autoFitWidth = options.autoFitWidth !== false; // Default to true
+        this.debug = options.debug || false; // Debug logging option

        // Time bin configuration
        this.useBinMode = options.useBinMode !== false; // Default to true
@@ -61,21 +63,10 @@ class ASCIIBarChart {
     * @param {number} value - The numeric value to add
     */
    addValue(value) {
-        if (this.useBinMode) {
-            // Time bin mode: increment count in current active bin
+        // Time bin mode: add value to current active bin count
        this.checkBinRotation(); // Ensure we have an active bin
-            this.bins[this.currentBinIndex].count++;
+        this.bins[this.currentBinIndex].count += value;  // Changed from ++ to += value
        this.totalDataPoints++;
-        } else {
-            // Legacy mode: add individual values
-            this.data.push(value);
-            this.totalDataPoints++;
-
-            // Keep only the most recent data points
-            if (this.data.length > this.maxDataPoints) {
-                this.data.shift();
-            }
-        }

        this.render();
        this.updateInfo();
@@ -119,7 +110,7 @@ class ASCIIBarChart {
        const totalWidth = yAxisPadding + yAxisNumbers + separator + dataWidth + padding;

        // Only log when width changes
-        if (this.lastChartWidth !== totalWidth) {
+        if (this.debug && this.lastChartWidth !== totalWidth) {
            console.log('getChartWidth changed:', { dataLength, totalWidth, previous: this.lastChartWidth });
            this.lastChartWidth = totalWidth;
        }
@@ -142,7 +133,7 @@ class ASCIIBarChart {
        // Calculate optimal font size
        // For monospace fonts, character width is approximately 0.6 * font size
        // Use a slightly smaller ratio to fit more content
-        const charWidthRatio = 0.6;
+        const charWidthRatio = 0.7;
        const padding = 30; // Reduce padding to fit more content
        const availableWidth = containerWidth - padding;
        const optimalFontSize = Math.floor((availableWidth / chartWidth) / charWidthRatio);
@@ -151,7 +142,7 @@ class ASCIIBarChart {
        const fontSize = Math.max(4, Math.min(20, optimalFontSize));

        // Only log when font size changes
-        if (this.lastFontSize !== fontSize) {
+        if (this.debug && this.lastFontSize !== fontSize) {
            console.log('fontSize changed:', { containerWidth, chartWidth, fontSize, previous: this.lastFontSize });
            this.lastFontSize = fontSize;
        }
@@ -190,7 +181,9 @@ class ASCIIBarChart {
                }
            });

+            if (this.debug) {
                console.log('render() dataToRender:', dataToRender, 'bins length:', this.bins.length);
+            }
            maxValue = Math.max(...dataToRender);
            minValue = Math.min(...dataToRender);
            valueRange = maxValue - minValue;
@@ -243,8 +236,8 @@ class ASCIIBarChart {
                }
            }

-            // Calculate the actual count value this row represents (0 at bottom, increasing upward)
-            const rowCount = (row - 1) * scaleFactor;
+            // Calculate the actual count value this row represents (1 at bottom, increasing upward)
+            const rowCount = (row - 1) * scaleFactor + 1;

            // Add Y-axis label (show actual count values)
            line += String(rowCount).padStart(3, ' ') + ' |';
--- a/debug.txt
+++ b/debug.txt
--- a/deploy_local.sh
+++ b/deploy_local.sh
@@ -1,3 +1,19 @@
 #!/bin/bash

+# Copy the binary to the deployment location
 cp build/c_relay_x86 ~/Storage/c_relay/crelay
+
+# Copy the local service file to systemd
+sudo cp systemd/c-relay-local.service /etc/systemd/system/
+
+# Reload systemd daemon to pick up the new service
+sudo systemctl daemon-reload
+
+# Enable the service (if not already enabled)
+sudo systemctl enable c-relay-local.service
+
+# Restart the service
+sudo systemctl restart c-relay-local.service
+
+# Show service status
+sudo systemctl status c-relay-local.service --no-pager -l
--- a/deploy_static.sh
+++ b/deploy_static.sh
--- a/docs/libwebsockets_proper_pattern.md
+++ b/docs/libwebsockets_proper_pattern.md
@@ -0,0 +1,298 @@
+# Libwebsockets Proper Pattern - Message Queue Design
+
+## Problem Analysis
+
+### Current Violation
+We're calling `lws_write()` directly from multiple code paths:
+1. **Event broadcast** (subscriptions.c:667) - when events arrive
+2. **OK responses** (websockets.c:855) - when processing EVENT messages
+3. **EOSE responses** (websockets.c:976) - when processing REQ messages
+4. **COUNT responses** (websockets.c:1922) - when processing COUNT messages
+
+This violates libwebsockets' design pattern which requires:
+- **`lws_write()` ONLY called from `LWS_CALLBACK_SERVER_WRITEABLE`**
+- Application queues messages and requests writeable callback
+- Libwebsockets handles write timing and socket buffer management
+
+### Consequences of Violation
+1. Partial writes when socket buffer is full
+2. Multiple concurrent write attempts before callback fires
+3. "write already pending" errors with single buffer
+4. Frame corruption from interleaved partial writes
+5. "Invalid frame header" errors on client side
+
+## Correct Architecture
+
+### Message Queue Pattern
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Application Layer                         │
+├─────────────────────────────────────────────────────────────┤
+│                                                               │
+│  Event Arrives → Queue Message → Request Writeable Callback │
+│  REQ Received  → Queue EOSE    → Request Writeable Callback │
+│  EVENT Received→ Queue OK      → Request Writeable Callback │
+│  COUNT Received→ Queue COUNT   → Request Writeable Callback │
+│                                                               │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+                  lws_callback_on_writable(wsi)
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│              LWS_CALLBACK_SERVER_WRITEABLE                   │
+├─────────────────────────────────────────────────────────────┤
+│                                                               │
+│  1. Dequeue next message from queue                          │
+│  2. Call lws_write() with message data                       │
+│  3. If queue not empty, request another callback             │
+│                                                               │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+                    libwebsockets handles:
+                    - Socket buffer management
+                    - Partial write handling
+                    - Frame atomicity
+```
+
+## Data Structures
+
+### Message Queue Node
+```c
+typedef struct message_queue_node {
+    unsigned char* data;           // Message data (with LWS_PRE space)
+    size_t length;                 // Message length (without LWS_PRE)
+    enum lws_write_protocol type;  // LWS_WRITE_TEXT, etc.
+    struct message_queue_node* next;
+} message_queue_node_t;
+```
+
+### Per-Session Data Updates
+```c
+struct per_session_data {
+    // ... existing fields ...
+    
+    // Message queue (replaces single buffer)
+    message_queue_node_t* message_queue_head;
+    message_queue_node_t* message_queue_tail;
+    int message_queue_count;
+    int writeable_requested;  // Flag to prevent duplicate requests
+};
+```
+
+## Implementation Functions
+
+### 1. Queue Message (Application Layer)
+```c
+int queue_message(struct lws* wsi, struct per_session_data* pss,
+                  const char* message, size_t length,
+                  enum lws_write_protocol type)
+{
+    // Allocate node
+    message_queue_node_t* node = malloc(sizeof(message_queue_node_t));
+    
+    // Allocate buffer with LWS_PRE space
+    node->data = malloc(LWS_PRE + length);
+    memcpy(node->data + LWS_PRE, message, length);
+    node->length = length;
+    node->type = type;
+    node->next = NULL;
+    
+    // Add to queue (FIFO)
+    pthread_mutex_lock(&pss->session_lock);
+    if (!pss->message_queue_head) {
+        pss->message_queue_head = node;
+        pss->message_queue_tail = node;
+    } else {
+        pss->message_queue_tail->next = node;
+        pss->message_queue_tail = node;
+    }
+    pss->message_queue_count++;
+    pthread_mutex_unlock(&pss->session_lock);
+    
+    // Request writeable callback (only if not already requested)
+    if (!pss->writeable_requested) {
+        pss->writeable_requested = 1;
+        lws_callback_on_writable(wsi);
+    }
+    
+    return 0;
+}
+```
+
+### 2. Process Queue (Writeable Callback)
+```c
+int process_message_queue(struct lws* wsi, struct per_session_data* pss)
+{
+    pthread_mutex_lock(&pss->session_lock);
+    
+    // Get next message from queue
+    message_queue_node_t* node = pss->message_queue_head;
+    if (!node) {
+        pss->writeable_requested = 0;
+        pthread_mutex_unlock(&pss->session_lock);
+        return 0;  // Queue empty
+    }
+    
+    // Remove from queue
+    pss->message_queue_head = node->next;
+    if (!pss->message_queue_head) {
+        pss->message_queue_tail = NULL;
+    }
+    pss->message_queue_count--;
+    
+    pthread_mutex_unlock(&pss->session_lock);
+    
+    // Write message (libwebsockets handles partial writes)
+    int result = lws_write(wsi, node->data + LWS_PRE, node->length, node->type);
+    
+    // Free node
+    free(node->data);
+    free(node);
+    
+    // If queue not empty, request another callback
+    pthread_mutex_lock(&pss->session_lock);
+    if (pss->message_queue_head) {
+        lws_callback_on_writable(wsi);
+    } else {
+        pss->writeable_requested = 0;
+    }
+    pthread_mutex_unlock(&pss->session_lock);
+    
+    return (result < 0) ? -1 : 0;
+}
+```
+
+## Refactoring Changes
+
+### Before (WRONG - Direct Write)
+```c
+// websockets.c:855 - OK response
+int write_result = lws_write(wsi, buf + LWS_PRE, response_len, LWS_WRITE_TEXT);
+if (write_result < 0) {
+    DEBUG_ERROR("Write failed");
+} else if ((size_t)write_result != response_len) {
+    // Partial write - queue remaining data
+    queue_websocket_write(wsi, pss, ...);
+}
+```
+
+### After (CORRECT - Queue Message)
+```c
+// websockets.c:855 - OK response
+queue_message(wsi, pss, response_str, response_len, LWS_WRITE_TEXT);
+// That's it! Writeable callback will handle the actual write
+```
+
+### Before (WRONG - Direct Write in Broadcast)
+```c
+// subscriptions.c:667 - EVENT broadcast
+int write_result = lws_write(current_temp->wsi, buf + LWS_PRE, msg_len, LWS_WRITE_TEXT);
+if (write_result < 0) {
+    DEBUG_ERROR("Write failed");
+} else if ((size_t)write_result != msg_len) {
+    queue_websocket_write(...);
+}
+```
+
+### After (CORRECT - Queue Message)
+```c
+// subscriptions.c:667 - EVENT broadcast
+struct per_session_data* pss = lws_wsi_user(current_temp->wsi);
+queue_message(current_temp->wsi, pss, msg_str, msg_len, LWS_WRITE_TEXT);
+// Writeable callback will handle the actual write
+```
+
+## Benefits of Correct Pattern
+
+1. **No Partial Write Handling Needed**
+   - Libwebsockets handles partial writes internally
+   - We just queue complete messages
+
+2. **No "Write Already Pending" Errors**
+   - Queue can hold unlimited messages
+   - Each processed sequentially from callback
+
+3. **Thread Safety**
+   - Queue operations protected by session lock
+   - Write only from single callback thread
+
+4. **Frame Atomicity**
+   - Libwebsockets ensures complete frame transmission
+   - No interleaved partial writes
+
+5. **Simpler Code**
+   - No complex partial write state machine
+   - Just queue and forget
+
+6. **Better Performance**
+   - Libwebsockets optimizes write timing
+   - Batches writes when socket ready
+
+## Migration Steps
+
+1. ✅ Identify all `lws_write()` call sites
+2. ✅ Confirm violation of libwebsockets pattern
+3. ⏳ Design message queue structure
+4. ⏳ Implement `queue_message()` function
+5. ⏳ Implement `process_message_queue()` function
+6. ⏳ Update `per_session_data` structure
+7. ⏳ Refactor OK response to use queue
+8. ⏳ Refactor EOSE response to use queue
+9. ⏳ Refactor COUNT response to use queue
+10. ⏳ Refactor EVENT broadcast to use queue
+11. ⏳ Update `LWS_CALLBACK_SERVER_WRITEABLE` handler
+12. ⏳ Add queue cleanup in `LWS_CALLBACK_CLOSED`
+13. ⏳ Remove old partial write code
+14. ⏳ Test with rapid multiple events
+15. ⏳ Test with large events (>4KB)
+16. ⏳ Test under load
+17. ⏳ Verify no frame errors
+
+## Testing Strategy
+
+### Test 1: Multiple Rapid Events
+```bash
+# Send 10 events rapidly to same client
+for i in {1..10}; do
+    echo '["EVENT",{"kind":1,"content":"test'$i'","created_at":'$(date +%s)',...}]' | \
+    websocat ws://localhost:8888 &
+done
+```
+
+**Expected**: All events queued and sent sequentially, no errors
+
+### Test 2: Large Events
+```bash
+# Send event >4KB (forces multiple socket writes)
+nak event --content "$(head -c 5000 /dev/urandom | base64)" | \
+websocat ws://localhost:8888
+```
+
+**Expected**: Event queued, libwebsockets handles partial writes internally
+
+### Test 3: Concurrent Connections
+```bash
+# 100 concurrent connections, each sending events
+for i in {1..100}; do
+    (echo '["REQ","sub'$i'",{}]'; sleep 1) | websocat ws://localhost:8888 &
+done
+```
+
+**Expected**: All subscriptions work, events broadcast correctly
+
+## Success Criteria
+
+- ✅ No `lws_write()` calls outside `LWS_CALLBACK_SERVER_WRITEABLE`
+- ✅ No "write already pending" errors in logs
+- ✅ No "Invalid frame header" errors on client side
+- ✅ All messages delivered in correct order
+- ✅ Large events (>4KB) handled correctly
+- ✅ Multiple rapid events to same client work
+- ✅ Concurrent connections stable under load
+
+## References
+
+- [libwebsockets documentation](https://libwebsockets.org/lws-api-doc-main/html/index.html)
+- [LWS_CALLBACK_SERVER_WRITEABLE](https://libwebsockets.org/lws-api-doc-main/html/group__callback-when-writeable.html)
+- [lws_callback_on_writable()](https://libwebsockets.org/lws-api-doc-main/html/group__callback-when-writeable.html#ga96f3ad8e1e2c3e0c8e0b0e5e5e5e5e5e)
--- a/docs/websocket_write_queue_design.md
+++ b/docs/websocket_write_queue_design.md
@@ -0,0 +1,200 @@
+# WebSocket Write Queue Design
+
+## Problem Statement
+
+The current partial write handling implementation uses a single buffer per session, which fails when multiple events need to be sent to the same client in rapid succession. This causes:
+
+1. First event gets partial write → queued successfully
+2. Second event tries to write → **FAILS** with "write already pending"
+3. Subsequent events fail similarly, causing data loss
+
+### Server Log Evidence
+```
+[WARN] WS_FRAME_PARTIAL: EVENT partial write, sub=1 sent=3210 expected=5333
+[TRACE] Queued partial write: len=2123
+[WARN] WS_FRAME_PARTIAL: EVENT partial write, sub=1 sent=3210 expected=5333
+[WARN] queue_websocket_write: write already pending, cannot queue new write
+[ERROR] Failed to queue partial EVENT write for sub=1
+```
+
+## Root Cause
+
+WebSocket frames must be sent **atomically** - you cannot interleave multiple frames. The current single-buffer approach correctly enforces this, but it rejects new writes instead of queuing them.
+
+## Solution: Write Queue Architecture
+
+### Design Principles
+
+1. **Frame Atomicity**: Complete one WebSocket frame before starting the next
+2. **Sequential Processing**: Process queued writes in FIFO order
+3. **Memory Safety**: Proper cleanup on connection close or errors
+4. **Thread Safety**: Protect queue operations with existing session lock
+
+### Data Structures
+
+#### Write Queue Node
+```c
+struct write_queue_node {
+    unsigned char* buffer;           // Buffer with LWS_PRE space
+    size_t total_len;                // Total length of data to write
+    size_t offset;                   // How much has been written so far
+    int write_type;                  // LWS_WRITE_TEXT, etc.
+    struct write_queue_node* next;   // Next node in queue
+};
+```
+
+#### Per-Session Write Queue
+```c
+struct per_session_data {
+    // ... existing fields ...
+    
+    // Write queue for handling multiple pending writes
+    struct write_queue_node* write_queue_head;  // First item to write
+    struct write_queue_node* write_queue_tail;  // Last item in queue
+    int write_queue_length;                     // Number of items in queue
+    int write_in_progress;                      // Flag: 1 if currently writing
+};
+```
+
+### Algorithm Flow
+
+#### 1. Enqueue Write (`queue_websocket_write`)
+
+```
+IF write_queue is empty AND no write in progress:
+    - Attempt immediate write with lws_write()
+    - IF complete:
+        - Return success
+    - ELSE (partial write):
+        - Create queue node with remaining data
+        - Add to queue
+        - Set write_in_progress flag
+        - Request LWS_CALLBACK_SERVER_WRITEABLE
+ELSE:
+    - Create queue node with full data
+    - Append to queue tail
+    - IF no write in progress:
+        - Request LWS_CALLBACK_SERVER_WRITEABLE
+```
+
+#### 2. Process Queue (`process_pending_write`)
+
+```
+WHILE write_queue is not empty:
+    - Get head node
+    - Calculate remaining data (total_len - offset)
+    - Attempt write with lws_write()
+    
+    IF write fails (< 0):
+        - Log error
+        - Remove and free head node
+        - Continue to next node
+    
+    ELSE IF partial write (< remaining):
+        - Update offset
+        - Request LWS_CALLBACK_SERVER_WRITEABLE
+        - Break (wait for next callback)
+    
+    ELSE (complete write):
+        - Remove and free head node
+        - Continue to next node
+
+IF queue is empty:
+    - Clear write_in_progress flag
+```
+
+#### 3. Cleanup (`LWS_CALLBACK_CLOSED`)
+
+```
+WHILE write_queue is not empty:
+    - Get head node
+    - Free buffer
+    - Free node
+    - Move to next
+Clear queue pointers
+```
+
+### Memory Management
+
+1. **Allocation**: Each queue node allocates buffer with `LWS_PRE + data_len`
+2. **Ownership**: Queue owns all buffers until write completes or connection closes
+3. **Deallocation**: Free buffer and node when:
+   - Write completes successfully
+   - Write fails with error
+   - Connection closes
+
+### Thread Safety
+
+- Use existing `pss->session_lock` to protect queue operations
+- Lock during:
+  - Enqueue operations
+  - Dequeue operations
+  - Queue traversal for cleanup
+
+### Performance Considerations
+
+1. **Queue Length Limit**: Implement max queue length (e.g., 100 items) to prevent memory exhaustion
+2. **Memory Pressure**: Monitor total queued bytes per session
+3. **Backpressure**: If queue exceeds limit, close connection with NOTICE
+
+### Error Handling
+
+1. **Allocation Failure**: Return error, log, send NOTICE to client
+2. **Write Failure**: Remove failed frame, continue with next
+3. **Queue Overflow**: Close connection with appropriate NOTICE
+
+## Implementation Plan
+
+### Phase 1: Data Structure Changes
+1. Add `write_queue_node` structure to `websockets.h`
+2. Update `per_session_data` with queue fields
+3. Remove old single-buffer fields
+
+### Phase 2: Queue Operations
+1. Implement `enqueue_write()` helper
+2. Implement `dequeue_write()` helper
+3. Update `queue_websocket_write()` to use queue
+4. Update `process_pending_write()` to process queue
+
+### Phase 3: Integration
+1. Update all `lws_write()` call sites
+2. Update `LWS_CALLBACK_CLOSED` cleanup
+3. Add queue length monitoring
+
+### Phase 4: Testing
+1. Test with rapid multiple events to same client
+2. Test with large events (>4KB)
+3. Test under load with concurrent connections
+4. Verify no "Invalid frame header" errors
+
+## Expected Outcomes
+
+1. **No More Rejections**: All writes queued successfully
+2. **Frame Integrity**: Complete frames sent atomically
+3. **Memory Safety**: Proper cleanup on all paths
+4. **Performance**: Minimal overhead for queue management
+
+## Metrics to Monitor
+
+1. Average queue length per session
+2. Maximum queue length observed
+3. Queue overflow events (if limit implemented)
+4. Write completion rate
+5. Partial write frequency
+
+## Alternative Approaches Considered
+
+### 1. Larger Single Buffer
+**Rejected**: Doesn't solve the fundamental problem of multiple concurrent writes
+
+### 2. Immediate Write Retry
+**Rejected**: Could cause busy-waiting and CPU waste
+
+### 3. Drop Frames on Conflict
+**Rejected**: Violates reliability requirements
+
+## References
+
+- libwebsockets documentation on `lws_write()` and `LWS_CALLBACK_SERVER_WRITEABLE`
+- WebSocket RFC 6455 on frame structure
+- Nostr NIP-01 on relay-to-client communication
--- a/increment_and_push.sh
+++ b/increment_and_push.sh
@@ -122,7 +122,7 @@ increment_version() {
    print_status "New version: $NEW_VERSION"

    # Update version in src/main.h
-    update_version_in_header "$NEW_VERSION" "$MAJOR" "$NEW_MINOR" "$NEW_PATCH"
+    update_version_in_header "$NEW_VERSION" "$MAJOR" "${NEW_MINOR:-$MINOR}" "${NEW_PATCH:-$PATCH}"

    # Export for use in other functions
    export NEW_VERSION
@@ -150,7 +150,7 @@ update_version_in_header() {
    sed -i "s/#define VERSION_MAJOR [0-9]\+/#define VERSION_MAJOR $major/" src/main.h

    # Update VERSION_MINOR macro
-    sed -i "s/#define VERSION_MINOR [0-9]*/#define VERSION_MINOR $minor/" src/main.h
+    sed -i "s/#define VERSION_MINOR .*/#define VERSION_MINOR $minor/" src/main.h

    # Update VERSION_PATCH macro
    sed -i "s/#define VERSION_PATCH [0-9]\+/#define VERSION_PATCH $patch/" src/main.h
--- a/make_and_restart_relay.sh
+++ b/make_and_restart_relay.sh
@@ -133,6 +133,11 @@ if [ -n "$PORT_OVERRIDE" ]; then
    fi
 fi

+# Validate strict port flag (only makes sense with port override)
+if [ "$USE_TEST_KEYS" = true ] && [ -z "$PORT_OVERRIDE" ]; then
+    echo "WARNING: --strict-port is always used with test keys. Consider specifying a custom port with -p."
+fi
+
 # Validate debug level if provided
 if [ -n "$DEBUG_LEVEL" ]; then
    if ! [[ "$DEBUG_LEVEL" =~ ^[0-5]$ ]]; then
@@ -163,6 +168,8 @@ if [ "$HELP" = true ]; then
    echo "  $0                                    # Fresh start with random keys"
    echo "  $0 -a <admin-hex> -r <relay-hex>     # Use custom keys"
    echo "  $0 -a <admin-hex> -p 9000            # Custom admin key on port 9000"
+    echo "  $0 -p 7777 --strict-port             # Fail if port 7777 unavailable (no fallback)"
+    echo "  $0 -p 8080 --strict-port -d=3        # Custom port with strict binding and debug"
    echo "  $0 --debug-level=3                   # Start with debug level 3 (info)"
    echo "  $0 -d=5                              # Start with debug level 5 (trace)"
    echo "  $0 --preserve-database               # Preserve existing database and keys"
--- a/notes.txt
+++ b/notes.txt
@@ -39,6 +39,11 @@ Even simpler: Use this one-liner
 cd /usr/local/bin/c_relay
 sudo -u c-relay ./c_relay --debug-level=5 & sleep 2 && sudo gdb -p $(pgrep c_relay)

+Inside gdb, after attaching:
+
+(gdb) continue
+Or shorter:
+(gdb) c


 How to View the Logs
@@ -76,3 +81,11 @@ sudo systemctl status rsyslog
 sudo -u c-relay ./c_relay --debug-level=5 -r 85d0b37e2ae822966dcadd06b2dc9368cde73865f90ea4d44f8b57d47ef0820a -a 1ec454734dcbf6fe54901ce25c0c7c6bca5edd89443416761fadc321d38df139

 ./c_relay_static_x86_64 -p 7889 --debug-level=5 -r 85d0b37e2ae822966dcadd06b2dc9368cde73865f90ea4d44f8b57d47ef0820a -a 1ec454734dcbf6fe54901ce25c0c7c6bca5edd89443416761fadc321d38df139
+
+
+sudo ufw allow 8888/tcp
+sudo ufw delete allow 8888/tcp
+
+lsof -i :7777
+kill $(lsof -t -i :7777)
+kill -9 $(lsof -t -i :7777)
--- a/relay.pid
+++ b/relay.pid
@@ -1 +1 @@
-3159561
+1018941
--- a/src/api.c
+++ b/src/api.c
@@ -40,28 +40,17 @@ const char* get_config_value(const char* key);
 int get_config_bool(const char* key, int default_value);
 int update_config_in_table(const char* key, const char* value);

-// Monitoring system state
-static time_t last_report_time = 0;
+// Monitoring system state (throttling now handled per-function)

 // Forward declaration for monitoring helper function
 int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_func)(void));

+// Forward declaration for CPU metrics query function
+cJSON* query_cpu_metrics(void);
+
 // Monitoring system helper functions
-int is_monitoring_enabled(void) {
-    return get_config_bool("kind_34567_reporting_enabled", 0);
-}
-
 int get_monitoring_throttle_seconds(void) {
-    return get_config_int("kind_34567_reporting_throttling_sec", 5);
-}
-
-int set_monitoring_enabled(int enabled) {
-    const char* value = enabled ? "1" : "0";
-    if (update_config_in_table("kind_34567_reporting_enabled", value) == 0) {
-        DEBUG_INFO("Monitoring enabled state changed");
-        return 0;
-    }
-    return -1;
+    return get_config_int("kind_24567_reporting_throttle_sec", 5);
 }

 // Query event kind distribution from database
@@ -233,50 +222,56 @@ cJSON* query_top_pubkeys(void) {
    return top_pubkeys;
 }

-// Query active subscriptions from in-memory manager (NO DATABASE QUERY)
+// Query active subscriptions summary from database
 cJSON* query_active_subscriptions(void) {
-    // Access the global subscription manager
-    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for active subscriptions query");
+        return NULL;
+    }

-    int total_subs = g_subscription_manager.total_subscriptions;
+    // Get configuration limits
    int max_subs = g_subscription_manager.max_total_subscriptions;
    int max_per_client = g_subscription_manager.max_subscriptions_per_client;

-    // Calculate per-client statistics by iterating through active subscriptions
+    // Query total active subscriptions from database
+    sqlite3_stmt* stmt;
+    const char* sql =
+        "SELECT COUNT(*) as total_subs, "
+        "COUNT(DISTINCT client_ip) as client_count "
+        "FROM subscriptions "
+        "WHERE event_type = 'created' AND ended_at IS NULL";
+
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        DEBUG_ERROR("Failed to prepare active subscriptions query");
+        return NULL;
+    }
+
+    int total_subs = 0;
    int client_count = 0;
+
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        total_subs = sqlite3_column_int(stmt, 0);
+        client_count = sqlite3_column_int(stmt, 1);
+    }
+    sqlite3_finalize(stmt);
+
+    // Query max subscriptions per client
    int most_subs_per_client = 0;
+    const char* max_sql =
+        "SELECT MAX(sub_count) FROM ("
+        "  SELECT COUNT(*) as sub_count "
+        "  FROM subscriptions "
+        "  WHERE event_type = 'created' AND ended_at IS NULL "
+        "  GROUP BY client_ip"
+        ")";

-    // Count subscriptions per WebSocket connection
-    subscription_t* current = g_subscription_manager.active_subscriptions;
-    struct lws* last_wsi = NULL;
-    int current_client_subs = 0;
-
-    while (current) {
-        if (current->wsi != last_wsi) {
-            // New client
-            if (last_wsi != NULL) {
-                client_count++;
-                if (current_client_subs > most_subs_per_client) {
-                    most_subs_per_client = current_client_subs;
+    if (sqlite3_prepare_v2(g_db, max_sql, -1, &stmt, NULL) == SQLITE_OK) {
+        if (sqlite3_step(stmt) == SQLITE_ROW) {
+            most_subs_per_client = sqlite3_column_int(stmt, 0);
        }
+        sqlite3_finalize(stmt);
    }
-            last_wsi = current->wsi;
-            current_client_subs = 1;
-        } else {
-            current_client_subs++;
-        }
-        current = current->next;
-    }
-
-    // Handle last client
-    if (last_wsi != NULL) {
-        client_count++;
-        if (current_client_subs > most_subs_per_client) {
-            most_subs_per_client = current_client_subs;
-        }
-    }
-
-    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);

    // Calculate statistics
    double utilization_percentage = max_subs > 0 ? (total_subs * 100.0 / max_subs) : 0.0;
@@ -301,10 +296,29 @@ cJSON* query_active_subscriptions(void) {
    return subscriptions;
 }

-// Query detailed subscription information from in-memory manager (ADMIN ONLY)
+// Query detailed subscription information from database log (ADMIN ONLY)
+// Uses subscriptions table instead of in-memory iteration to avoid mutex contention
 cJSON* query_subscription_details(void) {
-    // Access the global subscription manager
-    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for subscription details query");
+        return NULL;
+    }
+
+    // Query active subscriptions directly from subscriptions table
+    // Get subscriptions that were created but not yet closed/expired/disconnected
+    sqlite3_stmt* stmt;
+    const char* sql =
+        "SELECT subscription_id, client_ip, wsi_pointer, filter_json, events_sent, "
+        "created_at, (strftime('%s', 'now') - created_at) as duration_seconds "
+        "FROM subscriptions "
+        "WHERE event_type = 'created' AND ended_at IS NULL "
+        "ORDER BY created_at DESC LIMIT 100";
+
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        DEBUG_ERROR("Failed to prepare subscription details query");
+        return NULL;
+    }

    time_t current_time = time(NULL);
    cJSON* subscriptions_data = cJSON_CreateObject();
@@ -314,70 +328,45 @@ cJSON* query_subscription_details(void) {
    cJSON* data = cJSON_CreateObject();
    cJSON* subscriptions_array = cJSON_CreateArray();

-    // Iterate through all active subscriptions
-    subscription_t* current = g_subscription_manager.active_subscriptions;
-    while (current) {
+    // Iterate through query results
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
        cJSON* sub_obj = cJSON_CreateObject();

-        // Basic subscription info
-        cJSON_AddStringToObject(sub_obj, "id", current->id);
-        cJSON_AddStringToObject(sub_obj, "client_ip", current->client_ip);
-        cJSON_AddNumberToObject(sub_obj, "created_at", (double)current->created_at);
-        cJSON_AddNumberToObject(sub_obj, "duration_seconds", (double)(current_time - current->created_at));
-        cJSON_AddNumberToObject(sub_obj, "events_sent", current->events_sent);
-        cJSON_AddBoolToObject(sub_obj, "active", current->active);
+        // Extract subscription data from database
+        const char* sub_id = (const char*)sqlite3_column_text(stmt, 0);
+        const char* client_ip = (const char*)sqlite3_column_text(stmt, 1);
+        const char* wsi_pointer = (const char*)sqlite3_column_text(stmt, 2);
+        const char* filter_json = (const char*)sqlite3_column_text(stmt, 3);
+        long long events_sent = sqlite3_column_int64(stmt, 4);
+        long long created_at = sqlite3_column_int64(stmt, 5);
+        long long duration_seconds = sqlite3_column_int64(stmt, 6);

-        // Extract filter details
-        cJSON* filters_array = cJSON_CreateArray();
-        subscription_filter_t* filter = current->filters;
+        // Add basic subscription info
+        cJSON_AddStringToObject(sub_obj, "id", sub_id ? sub_id : "");
+        cJSON_AddStringToObject(sub_obj, "client_ip", client_ip ? client_ip : "");
+        cJSON_AddStringToObject(sub_obj, "wsi_pointer", wsi_pointer ? wsi_pointer : "");
+        cJSON_AddNumberToObject(sub_obj, "created_at", (double)created_at);
+        cJSON_AddNumberToObject(sub_obj, "duration_seconds", (double)duration_seconds);
+        cJSON_AddNumberToObject(sub_obj, "events_sent", events_sent);
+        cJSON_AddBoolToObject(sub_obj, "active", 1);  // All from this view are active

-        while (filter) {
-            cJSON* filter_obj = cJSON_CreateObject();
-
-            // Add kinds array if present
-            if (filter->kinds) {
-                cJSON_AddItemToObject(filter_obj, "kinds", cJSON_Duplicate(filter->kinds, 1));
+        // Parse and add filter JSON if available
+        if (filter_json) {
+            cJSON* filters = cJSON_Parse(filter_json);
+            if (filters) {
+                cJSON_AddItemToObject(sub_obj, "filters", filters);
+            } else {
+                // If parsing fails, add empty array
+                cJSON_AddItemToObject(sub_obj, "filters", cJSON_CreateArray());
+            }
+        } else {
+            cJSON_AddItemToObject(sub_obj, "filters", cJSON_CreateArray());
        }

-            // Add authors array if present
-            if (filter->authors) {
-                cJSON_AddItemToObject(filter_obj, "authors", cJSON_Duplicate(filter->authors, 1));
-            }
-
-            // Add ids array if present
-            if (filter->ids) {
-                cJSON_AddItemToObject(filter_obj, "ids", cJSON_Duplicate(filter->ids, 1));
-            }
-
-            // Add since/until timestamps if set
-            if (filter->since > 0) {
-                cJSON_AddNumberToObject(filter_obj, "since", (double)filter->since);
-            }
-            if (filter->until > 0) {
-                cJSON_AddNumberToObject(filter_obj, "until", (double)filter->until);
-            }
-
-            // Add limit if set
-            if (filter->limit > 0) {
-                cJSON_AddNumberToObject(filter_obj, "limit", filter->limit);
-            }
-
-            // Add tag filters if present
-            if (filter->tag_filters) {
-                cJSON_AddItemToObject(filter_obj, "tag_filters", cJSON_Duplicate(filter->tag_filters, 1));
-            }
-
-            cJSON_AddItemToArray(filters_array, filter_obj);
-            filter = filter->next;
-        }
-
-        cJSON_AddItemToObject(sub_obj, "filters", filters_array);
        cJSON_AddItemToArray(subscriptions_array, sub_obj);
-
-        current = current->next;
    }

-    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+    sqlite3_finalize(stmt);

    // Add subscriptions array and count to data
    cJSON_AddItemToObject(data, "subscriptions", subscriptions_array);
@@ -388,8 +377,8 @@ cJSON* query_subscription_details(void) {
    return subscriptions_data;
 }

-// Generate and broadcast monitoring event
-int generate_monitoring_event(void) {
+// Generate event-driven monitoring events (triggered by event storage)
+int generate_event_driven_monitoring(void) {
    // Generate event_kinds monitoring event
    if (generate_monitoring_event_for_type("event_kinds", query_event_kind_distribution) != 0) {
        DEBUG_ERROR("Failed to generate event_kinds monitoring event");
@@ -414,16 +403,45 @@ int generate_monitoring_event(void) {
        return -1;
    }

+    // Generate CPU metrics monitoring event (also triggered by event storage)
+    if (generate_monitoring_event_for_type("cpu_metrics", query_cpu_metrics) != 0) {
+        DEBUG_ERROR("Failed to generate cpu_metrics monitoring event");
+        return -1;
+    }
+
+    DEBUG_INFO("Generated and broadcast event-driven monitoring events");
+    return 0;
+}
+
+// Generate subscription-driven monitoring events (triggered by subscription changes)
+int generate_subscription_driven_monitoring(void) {
+    // Generate active_subscriptions monitoring event (subscription changes affect this)
+    if (generate_monitoring_event_for_type("active_subscriptions", query_active_subscriptions) != 0) {
+        DEBUG_ERROR("Failed to generate active_subscriptions monitoring event");
+        return -1;
+    }
+
    // Generate subscription_details monitoring event (admin-only)
    if (generate_monitoring_event_for_type("subscription_details", query_subscription_details) != 0) {
        DEBUG_ERROR("Failed to generate subscription_details monitoring event");
        return -1;
    }

-    DEBUG_INFO("Generated and broadcast all monitoring events");
+    // Generate CPU metrics monitoring event (also triggered by subscription changes)
+    if (generate_monitoring_event_for_type("cpu_metrics", query_cpu_metrics) != 0) {
+        DEBUG_ERROR("Failed to generate cpu_metrics monitoring event");
+        return -1;
+    }
+
+    DEBUG_INFO("Generated and broadcast subscription-driven monitoring events");
    return 0;
 }

+// Generate and broadcast monitoring event (legacy function - now calls event-driven version)
+int generate_monitoring_event(void) {
+    return generate_event_driven_monitoring();
+}
+
 // Helper function to generate monitoring event for a specific type
 int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_func)(void)) {
    // Query the monitoring data
@@ -461,12 +479,12 @@ int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_f
    }
    free(relay_privkey_hex);

-    // Create monitoring event (kind 34567)
+    // Create monitoring event (kind 24567 - ephemeral)
    cJSON* monitoring_event = cJSON_CreateObject();
    cJSON_AddStringToObject(monitoring_event, "id", ""); // Will be set by signing
    cJSON_AddStringToObject(monitoring_event, "pubkey", relay_pubkey);
    cJSON_AddNumberToObject(monitoring_event, "created_at", (double)time(NULL));
-    cJSON_AddNumberToObject(monitoring_event, "kind", 34567);
+    cJSON_AddNumberToObject(monitoring_event, "kind", 24567);
    cJSON_AddStringToObject(monitoring_event, "content", content_json);

    // Create tags array with d tag for identification
@@ -482,7 +500,7 @@ int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_f

    // Use the library function to create and sign the event
    cJSON* signed_event = nostr_create_and_sign_event(
-        34567,                              // kind
+        24567,                              // kind (ephemeral)
        cJSON_GetStringValue(cJSON_GetObjectItem(monitoring_event, "content")), // content
        tags,                               // tags
        relay_privkey,                      // private key
@@ -500,55 +518,58 @@ int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_f
    cJSON_Delete(monitoring_event);
    monitoring_event = signed_event;

-    // Broadcast the event to active subscriptions
+    // Broadcast the ephemeral event to active subscriptions (no database storage)
    broadcast_event_to_subscriptions(monitoring_event);

-    // Store in database
-    int store_result = store_event(monitoring_event);
-
    cJSON_Delete(monitoring_event);
    free(content_json);

-    if (store_result != 0) {
-        DEBUG_ERROR("Failed to store monitoring event (%s)", d_tag_value);
-        return -1;
-    }
-
+    DEBUG_LOG("Monitoring event broadcast (ephemeral kind 24567, type: %s)", d_tag_value);
    return 0;
 }

 // Monitoring hook called when an event is stored
 void monitoring_on_event_stored(void) {
-    // Check if monitoring is enabled
-    if (!is_monitoring_enabled()) {
+    // Check throttling first (cheapest check)
+    static time_t last_monitoring_time = 0;
+    time_t current_time = time(NULL);
+    int throttle_seconds = get_monitoring_throttle_seconds();
+
+    if (current_time - last_monitoring_time < throttle_seconds) {
        return;
    }

-    // Check throttling
-    time_t now = time(NULL);
+    // Check if anyone is subscribed to monitoring events (kind 24567)
+    // This is the ONLY activation check needed - if someone subscribes, they want monitoring
+    if (!has_subscriptions_for_kind(24567)) {
+        return; // No subscribers = no expensive operations
+    }
+
+    // Generate event-driven monitoring events only when someone is listening
+    last_monitoring_time = current_time;
+    generate_event_driven_monitoring();
+}
+
+// Monitoring hook called when subscriptions change (create/close)
+void monitoring_on_subscription_change(void) {
+    // Check throttling first (cheapest check)
+    static time_t last_monitoring_time = 0;
+    time_t current_time = time(NULL);
    int throttle_seconds = get_monitoring_throttle_seconds();

-    if (now - last_report_time < throttle_seconds) {
-        return; // Too soon, skip this report
+    if (current_time - last_monitoring_time < throttle_seconds) {
+        return;
    }

-    // Generate and broadcast monitoring event
-    if (generate_monitoring_event() == 0) {
-        last_report_time = now;
-    }
+    // Check if anyone is subscribed to monitoring events (kind 24567)
+    // This is the ONLY activation check needed - if someone subscribes, they want monitoring
+    if (!has_subscriptions_for_kind(24567)) {
+        return; // No subscribers = no expensive operations
    }

-// Initialize monitoring system
-int init_monitoring_system(void) {
-    last_report_time = 0;
-    DEBUG_INFO("Monitoring system initialized");
-    return 0;
-}
-
-// Cleanup monitoring system
-void cleanup_monitoring_system(void) {
-    // No cleanup needed for monitoring system
-    DEBUG_INFO("Monitoring system cleaned up");
+    // Generate subscription-driven monitoring events only when someone is listening
+    last_monitoring_time = current_time;
+    generate_subscription_driven_monitoring();
 }

 // Forward declaration for known_configs (defined in config.c)
@@ -1140,6 +1161,68 @@ int handle_embedded_file_writeable(struct lws* wsi) {

    return 0;
 }
+// Query CPU usage metrics
+cJSON* query_cpu_metrics(void) {
+    cJSON* cpu_stats = cJSON_CreateObject();
+    cJSON_AddStringToObject(cpu_stats, "data_type", "cpu_metrics");
+    cJSON_AddNumberToObject(cpu_stats, "timestamp", (double)time(NULL));
+
+    // Read process CPU times from /proc/self/stat
+    FILE* proc_stat = fopen("/proc/self/stat", "r");
+    if (proc_stat) {
+        unsigned long utime, stime; // user and system CPU time in clock ticks
+        if (fscanf(proc_stat, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu", &utime, &stime) == 2) {
+            unsigned long total_proc_time = utime + stime;
+
+            // Get system CPU times from /proc/stat
+            FILE* sys_stat = fopen("/proc/stat", "r");
+            if (sys_stat) {
+                unsigned long user, nice, system, idle, iowait, irq, softirq;
+                if (fscanf(sys_stat, "cpu %lu %lu %lu %lu %lu %lu %lu", &user, &nice, &system, &idle, &iowait, &irq, &softirq) == 7) {
+                    unsigned long total_sys_time = user + nice + system + idle + iowait + irq + softirq;
+
+                    // Calculate CPU percentages (simplified - would need deltas for accuracy)
+                    // For now, just store the raw values - frontend can calculate deltas
+                    cJSON_AddNumberToObject(cpu_stats, "process_cpu_time", (double)total_proc_time);
+                    cJSON_AddNumberToObject(cpu_stats, "system_cpu_time", (double)total_sys_time);
+                    cJSON_AddNumberToObject(cpu_stats, "system_idle_time", (double)idle);
+                }
+                fclose(sys_stat);
+            }
+
+            // Get current CPU core the process is running on
+            int current_core = sched_getcpu();
+            if (current_core >= 0) {
+                cJSON_AddNumberToObject(cpu_stats, "current_cpu_core", current_core);
+            }
+        }
+        fclose(proc_stat);
+    }
+
+    // Get process ID
+    pid_t pid = getpid();
+    cJSON_AddNumberToObject(cpu_stats, "process_id", (double)pid);
+
+    // Get memory usage from /proc/self/status
+    FILE* mem_stat = fopen("/proc/self/status", "r");
+    if (mem_stat) {
+        char line[256];
+        while (fgets(line, sizeof(line), mem_stat)) {
+            if (strncmp(line, "VmRSS:", 6) == 0) {
+                unsigned long rss_kb;
+                if (sscanf(line, "VmRSS: %lu kB", &rss_kb) == 1) {
+                    double rss_mb = rss_kb / 1024.0;
+                    cJSON_AddNumberToObject(cpu_stats, "memory_usage_mb", rss_mb);
+                }
+                break;
+            }
+        }
+        fclose(mem_stat);
+    }
+
+    return cpu_stats;
+}
+
 // Generate stats JSON from database queries
 char* generate_stats_json(void) {
    extern sqlite3* g_db;
@@ -2267,24 +2350,8 @@ int handle_monitoring_command(cJSON* event, const char* command, char* error_mes
        if (*p >= 'A' && *p <= 'Z') *p = *p + 32;
    }

-    // Handle commands
-    if (strcmp(cmd, "enable_monitoring") == 0) {
-        if (set_monitoring_enabled(1) == 0) {
-            char* response_content = "✅ Monitoring enabled\n\nReal-time monitoring events will now be generated.";
-            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
-        } else {
-            char* response_content = "❌ Failed to enable monitoring";
-            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
-        }
-    } else if (strcmp(cmd, "disable_monitoring") == 0) {
-        if (set_monitoring_enabled(0) == 0) {
-            char* response_content = "✅ Monitoring disabled\n\nReal-time monitoring events will no longer be generated.";
-            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
-        } else {
-            char* response_content = "❌ Failed to disable monitoring";
-            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
-        }
-    } else if (strcmp(cmd, "set_monitoring_throttle") == 0) {
+    // Handle set_monitoring_throttle command (only remaining monitoring command)
+    if (strcmp(cmd, "set_monitoring_throttle") == 0) {
        if (arg[0] == '\0') {
            char* response_content = "❌ Missing throttle value\n\nUsage: set_monitoring_throttle <seconds>";
            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
@@ -2300,44 +2367,28 @@ int handle_monitoring_command(cJSON* event, const char* command, char* error_mes
        char throttle_str[16];
        snprintf(throttle_str, sizeof(throttle_str), "%ld", throttle_seconds);

-        if (update_config_in_table("kind_34567_reporting_throttling_sec", throttle_str) == 0) {
+        if (update_config_in_table("kind_24567_reporting_throttle_sec", throttle_str) == 0) {
            char response_content[256];
            snprintf(response_content, sizeof(response_content),
-                    "✅ Monitoring throttle updated\n\nMinimum interval between monitoring events: %ld seconds", throttle_seconds);
+                    "✅ Monitoring throttle updated\n\n"
+                    "Minimum interval between monitoring events: %ld seconds\n\n"
+                    "ℹ️ Monitoring activates automatically when you subscribe to kind 24567 events.",
+                    throttle_seconds);
            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
        } else {
            char* response_content = "❌ Failed to update monitoring throttle";
            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
        }
-    } else if (strcmp(cmd, "monitoring_status") == 0) {
-        int enabled = is_monitoring_enabled();
-        int throttle = get_monitoring_throttle_seconds();
-
-        char response_content[512];
-        snprintf(response_content, sizeof(response_content),
-                "📊 Monitoring Status\n"
-                "━━━━━━━━━━━━━━━━━━━━\n"
-                "\n"
-                "Enabled: %s\n"
-                "Throttle: %d seconds\n"
-                "\n"
-                "Commands:\n"
-                "• enable_monitoring\n"
-                "• disable_monitoring\n"
-                "• set_monitoring_throttle <seconds>\n"
-                "• monitoring_status",
-                enabled ? "Yes" : "No", throttle);
-
-        return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
    } else {
-        char response_content[256];
+        char response_content[1024];
        snprintf(response_content, sizeof(response_content),
                "❌ Unknown monitoring command: %s\n\n"
-                "Available commands:\n"
-                "• enable_monitoring\n"
-                "• disable_monitoring\n"
-                "• set_monitoring_throttle <seconds>\n"
-                "• monitoring_status", cmd);
+                "Available command:\n"
+                "• set_monitoring_throttle <seconds>\n\n"
+                "ℹ️ Monitoring is now subscription-based:\n"
+                "Subscribe to kind 24567 events to receive real-time monitoring data.\n"
+                "Monitoring automatically activates when subscriptions exist and deactivates when they close.",
+                cmd);
        return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
    }
 }
--- a/src/api.h
+++ b/src/api.h
@@ -60,11 +60,8 @@ char* execute_sql_query(const char* query, const char* request_id, char* error_m
 int handle_sql_query_unified(cJSON* event, const char* query, char* error_message, size_t error_size, struct lws* wsi);

 // Monitoring system functions
-int init_monitoring_system(void);
-void cleanup_monitoring_system(void);
 void monitoring_on_event_stored(void);
-int set_monitoring_enabled(int enabled);
-int is_monitoring_enabled(void);
+void monitoring_on_subscription_change(void);
 int get_monitoring_throttle_seconds(void);

 #endif // API_H
--- a/src/config.c
+++ b/src/config.c
@@ -3,6 +3,19 @@
 #include "debug.h"
 #include "default_config_event.h"
 #include "dm_admin.h"
+
+// Undefine VERSION macros before including nostr_core.h to avoid redefinition warnings
+// This must come AFTER default_config_event.h so that RELAY_VERSION macro expansion works correctly
+#ifdef VERSION
+#undef VERSION
+#endif
+#ifdef VERSION_MINOR
+#undef VERSION_MINOR
+#endif
+#ifdef VERSION_PATCH
+#undef VERSION_PATCH
+#endif
+
 #include "../nostr_core_lib/nostr_core/nostr_core.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -824,26 +837,7 @@ int startup_existing_relay(const char* relay_pubkey, const cli_options_t* cli_op

    // NOTE: Database is already initialized in main.c before calling this function
    // Config table should already exist with complete configuration
-
-    // Check if CLI overrides need to be applied
-    int has_overrides = 0;
-    if (cli_options) {
-        if (cli_options->port_override > 0) has_overrides = 1;
-        if (cli_options->admin_pubkey_override[0] != '\0') has_overrides = 1;
-        if (cli_options->relay_privkey_override[0] != '\0') has_overrides = 1;
-    }
-
-    if (has_overrides) {
-        // Apply CLI overrides to existing database
-        DEBUG_INFO("Applying CLI overrides to existing database");
-        if (apply_cli_overrides_atomic(cli_options) != 0) {
-            DEBUG_ERROR("Failed to apply CLI overrides to existing database");
-            return -1;
-        }
-    } else {
-        // No CLI overrides - config table is already available
-        DEBUG_INFO("No CLI overrides - config table is already available");
-    }
+    // CLI overrides will be applied after this function returns in main.c

    return 0;
 }
@@ -4099,32 +4093,18 @@ int populate_all_config_values_atomic(const char* admin_pubkey, const char* rela
        return -1;
    }

-    // Insert monitoring system config entries
+    // Insert monitoring system config entry (ephemeral kind 24567)
+    // Note: Monitoring is automatically activated when clients subscribe to kind 24567
    sqlite3_reset(stmt);
-    sqlite3_bind_text(stmt, 1, "kind_34567_reporting_enabled", -1, SQLITE_STATIC);
-    sqlite3_bind_text(stmt, 2, "false", -1, SQLITE_STATIC);  // boolean, default false
-    sqlite3_bind_text(stmt, 3, "boolean", -1, SQLITE_STATIC);
-    sqlite3_bind_text(stmt, 4, "Enable real-time monitoring event generation", -1, SQLITE_STATIC);
-    sqlite3_bind_text(stmt, 5, "monitoring", -1, SQLITE_STATIC);
-    sqlite3_bind_int(stmt, 6, 0);  // does not require restart
-    rc = sqlite3_step(stmt);
-    if (rc != SQLITE_DONE) {
-        DEBUG_ERROR("Failed to insert kind_34567_reporting_enabled: %s", sqlite3_errmsg(g_db));
-        sqlite3_finalize(stmt);
-        sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
-        return -1;
-    }
-
-    sqlite3_reset(stmt);
-    sqlite3_bind_text(stmt, 1, "kind_34567_reporting_throttling_sec", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 1, "kind_24567_reporting_throttle_sec", -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 2, "5", -1, SQLITE_STATIC);  // integer, default 5 seconds
    sqlite3_bind_text(stmt, 3, "integer", -1, SQLITE_STATIC);
-    sqlite3_bind_text(stmt, 4, "Minimum seconds between monitoring event reports", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 4, "Minimum seconds between monitoring event reports (ephemeral kind 24567)", -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 5, "monitoring", -1, SQLITE_STATIC);
    sqlite3_bind_int(stmt, 6, 0);  // does not require restart
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_DONE) {
-        DEBUG_ERROR("Failed to insert kind_34567_reporting_throttling_sec: %s", sqlite3_errmsg(g_db));
+        DEBUG_ERROR("Failed to insert kind_24567_reporting_throttle_sec: %s", sqlite3_errmsg(g_db));
        sqlite3_finalize(stmt);
        sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
        return -1;
--- a/src/default_config_event.h
+++ b/src/default_config_event.h
@@ -72,7 +72,13 @@ static const struct {
    
    // Performance Settings
    {"default_limit", "500"},
-    {"max_limit", "5000"}
+    {"max_limit", "5000"},
+    
+    // Proxy Settings
+    // Trust proxy headers (X-Forwarded-For, X-Real-IP) for accurate client IP detection
+    // Safe for informational/debugging use. Only becomes a security concern if you implement
+    // IP-based rate limiting or access control (which would require firewall protection anyway)
+    {"trust_proxy_headers", "true"}
 };

 // Number of default configuration values
--- a/src/embedded_web_content.c
+++ b/src/embedded_web_content.c
--- a/src/main.c
+++ b/src/main.c
@@ -149,9 +149,7 @@ int mark_event_as_deleted(const char* event_id, const char* deletion_event_id, c
 // Forward declaration for database functions
 int store_event(cJSON* event);

-// Forward declarations for monitoring system
-void init_monitoring_system(void);
-void cleanup_monitoring_system(void);
+// Forward declaration for monitoring system
 void monitoring_on_event_stored(void);

 // Forward declarations for NIP-11 relay information handling
@@ -317,15 +315,36 @@ int init_database(const char* database_path_override) {
    if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
        // Check config table row count immediately after database open
        sqlite3_stmt* stmt;
-        if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
+        int rc = sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL);
+        if (rc == SQLITE_OK) {
            if (sqlite3_step(stmt) == SQLITE_ROW) {
                int row_count = sqlite3_column_int(stmt, 0);
                DEBUG_LOG("Config table row count immediately after sqlite3_open(): %d", row_count);
            }
            sqlite3_finalize(stmt);
+        } else {
+            // Capture and log the actual SQLite error instead of assuming table doesn't exist
+            const char* err_msg = sqlite3_errmsg(g_db);
+            DEBUG_LOG("Failed to prepare config table query: %s (error code: %d)", err_msg, rc);
+
+            // Check if it's actually a missing table vs other error
+            if (rc == SQLITE_ERROR) {
+                // Try to check if config table exists
+                sqlite3_stmt* check_stmt;
+                int check_rc = sqlite3_prepare_v2(g_db, "SELECT name FROM sqlite_master WHERE type='table' AND name='config'", -1, &check_stmt, NULL);
+                if (check_rc == SQLITE_OK) {
+                    int has_table = (sqlite3_step(check_stmt) == SQLITE_ROW);
+                    sqlite3_finalize(check_stmt);
+                    if (has_table) {
+                        DEBUG_LOG("Config table EXISTS but query failed - possible database corruption or locking issue");
                    } else {
                        DEBUG_LOG("Config table does not exist yet (first-time startup)");
                    }
+                } else {
+                    DEBUG_LOG("Failed to check table existence: %s (error code: %d)", sqlite3_errmsg(g_db), check_rc);
+                }
+            }
+        }
    }
    // DEBUG_GUARD_END
    
@@ -1437,7 +1456,7 @@ void print_usage(const char* program_name) {
    printf("Options:\n");
    printf("  -h, --help               Show this help message\n");
    printf("  -v, --version            Show version information\n");
-    printf("  -p, --port PORT          Override relay port (first-time startup only)\n");
+    printf("  -p, --port PORT          Override relay port (first-time startup and existing relay restarts)\n");
    printf("  --strict-port            Fail if exact port is unavailable (no port increment)\n");
    printf("  -a, --admin-pubkey KEY   Override admin public key (64-char hex or npub)\n");
    printf("  -r, --relay-privkey KEY  Override relay private key (64-char hex or nsec)\n");
@@ -1447,13 +1466,14 @@ void print_usage(const char* program_name) {
    printf("Configuration:\n");
    printf("  This relay uses event-based configuration stored in the database.\n");
    printf("  On first startup, keys are automatically generated and printed once.\n");
-    printf("  Command line options like --port only apply during first-time setup.\n");
+    printf("  Command line options like --port apply during first-time setup and existing relay restarts.\n");
    printf("  After initial setup, all configuration is managed via database events.\n");
    printf("  Database file: <relay_pubkey>.db (created automatically)\n");
    printf("\n");
    printf("Port Binding:\n");
    printf("  Default: Try up to 10 consecutive ports if requested port is busy\n");
    printf("  --strict-port: Fail immediately if exact requested port is unavailable\n");
+    printf("  --strict-port works with any custom port specified via -p or --port\n");
    printf("\n");
    printf("Examples:\n");
    printf("  %s                       # Start relay (auto-configure on first run)\n", program_name);
@@ -1800,7 +1820,7 @@ int main(int argc, char* argv[]) {
            return 1;
        }
        
-        // Setup existing relay (sets database path and loads config)
+        // Setup existing relay FIRST (sets database path)
        if (startup_existing_relay(relay_pubkey, &cli_options) != 0) {
            DEBUG_ERROR("Failed to setup existing relay");
            cleanup_configuration_system();
@@ -1813,23 +1833,7 @@ int main(int argc, char* argv[]) {
            return 1;
        }

-        // Check config table row count before database initialization
-        {
-            sqlite3* temp_db = NULL;
-            if (sqlite3_open(g_database_path, &temp_db) == SQLITE_OK) {
-                sqlite3_stmt* stmt;
-                if (sqlite3_prepare_v2(temp_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
-                    if (sqlite3_step(stmt) == SQLITE_ROW) {
-                        int row_count = sqlite3_column_int(stmt, 0);
-                        printf("  Config table row count before database initialization: %d\n", row_count);
-                    }
-                    sqlite3_finalize(stmt);
-                }
-                sqlite3_close(temp_db);
-            }
-        }
-        
-        // Initialize database with existing database path
+        // Initialize database with the database path set by startup_existing_relay()
        DEBUG_TRACE("Initializing existing database");
        if (init_database(g_database_path) != 0) {
            DEBUG_ERROR("Failed to initialize existing database");
@@ -1844,6 +1848,20 @@ int main(int argc, char* argv[]) {
        }
        DEBUG_LOG("Existing database initialized");

+        // Apply CLI overrides atomically (now that database is initialized)
+        if (apply_cli_overrides_atomic(&cli_options) != 0) {
+            DEBUG_ERROR("Failed to apply CLI overrides for existing relay");
+            cleanup_configuration_system();
+            free(relay_pubkey);
+            for (int i = 0; existing_files[i]; i++) {
+                free(existing_files[i]);
+            }
+            free(existing_files);
+            nostr_cleanup();
+            close_database();
+            return 1;
+        }
+
        // DEBUG_GUARD_START
        if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
            sqlite3_stmt* stmt;
@@ -1989,9 +2007,6 @@ int main(int argc, char* argv[]) {
    // Initialize NIP-40 expiration configuration
    init_expiration_config();

-    // Initialize monitoring system
-    init_monitoring_system();
-
    // Update subscription manager configuration
    update_subscription_manager_config();

@@ -2015,17 +2030,14 @@ int main(int argc, char* argv[]) {

    
    
-    // Start WebSocket Nostr relay server (port from configuration)
-    int result = start_websocket_relay(-1, cli_options.strict_port);  // Let config system determine port, pass strict_port flag
+    // Start WebSocket Nostr relay server (port from CLI override or configuration)
+    int result = start_websocket_relay(cli_options.port_override, cli_options.strict_port);  // Use CLI port override if specified, otherwise config
    
    // Cleanup
    cleanup_relay_info();
    ginxsom_request_validator_cleanup();
    cleanup_configuration_system();

-    // Cleanup monitoring system
-    cleanup_monitoring_system();
-
    // Cleanup subscription manager mutexes
    pthread_mutex_destroy(&g_subscription_manager.subscriptions_lock);
    pthread_mutex_destroy(&g_subscription_manager.ip_tracking_lock);
--- a/src/main.h
+++ b/src/main.h
@@ -10,10 +10,10 @@
 #define MAIN_H

 // Version information (auto-updated by build system)
-#define VERSION "v0.7.28"
+#define VERSION "v0.7.38"
 #define VERSION_MAJOR 0
-#define VERSION_MINOR 
-#define VERSION_PATCH 28
+#define VERSION_MINOR 7
+#define VERSION_PATCH 38

 // Relay metadata (authoritative source for NIP-11 information)
 #define RELAY_NAME "C-Relay"
--- a/src/sql_schema.h
+++ b/src/sql_schema.h
@@ -1,12 +1,12 @@
 /* Embedded SQL Schema for C Nostr Relay
 * Generated from db/schema.sql - Do not edit manually
- * Schema Version: 7
+ * Schema Version: 8
 */
 #ifndef SQL_SCHEMA_H
 #define SQL_SCHEMA_H

 /* Schema version constant */
-#define EMBEDDED_SCHEMA_VERSION "7"
+#define EMBEDDED_SCHEMA_VERSION "8"

 /* Embedded SQL schema as C string literal */
 static const char* const EMBEDDED_SCHEMA_SQL = 
@@ -15,7 +15,7 @@ static const char* const EMBEDDED_SCHEMA_SQL =
 -- Configuration system using config table\n\
 \n\
 -- Schema version tracking\n\
-PRAGMA user_version = 7;\n\
+PRAGMA user_version = 8;\n\
 \n\
 -- Enable foreign key support\n\
 PRAGMA foreign_keys = ON;\n\
@@ -58,8 +58,8 @@ CREATE TABLE schema_info (\n\
 \n\
 -- Insert schema metadata\n\
 INSERT INTO schema_info (key, value) VALUES\n\
-    ('version', '7'),\n\
-    ('description', 'Hybrid Nostr relay schema with event-based and table-based configuration'),\n\
+    ('version', '8'),\n\
+    ('description', 'Hybrid Nostr relay schema with subscription deduplication support'),\n\
    ('created_at', strftime('%s', 'now'));\n\
 \n\
 -- Helper views for common queries\n\
@@ -181,17 +181,19 @@ END;\n\
 -- Persistent Subscriptions Logging Tables (Phase 2)\n\
 -- Optional database logging for subscription analytics and debugging\n\
 \n\
-- Subscription events log\n\
-CREATE TABLE subscription_events (\n\
+-- Subscriptions log (renamed from subscription_events for clarity)\n\
+CREATE TABLE subscriptions (\n\
    id INTEGER PRIMARY KEY AUTOINCREMENT,\n\
    subscription_id TEXT NOT NULL,           -- Subscription ID from client\n\
+    wsi_pointer TEXT NOT NULL,               -- WebSocket pointer address (hex string)\n\
    client_ip TEXT NOT NULL,                 -- Client IP address\n\
    event_type TEXT NOT NULL CHECK (event_type IN ('created', 'closed', 'expired', 'disconnected')),\n\
    filter_json TEXT,                        -- JSON representation of filters (for created events)\n\
    events_sent INTEGER DEFAULT 0,           -- Number of events sent to this subscription\n\
    created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),\n\
    ended_at INTEGER,                        -- When subscription ended (for closed/expired/disconnected)\n\
-    duration INTEGER                         -- Computed: ended_at - created_at\n\
+    duration INTEGER,                        -- Computed: ended_at - created_at\n\
+    UNIQUE(subscription_id, wsi_pointer)     -- Prevent duplicate subscriptions per connection\n\
 );\n\
 \n\
 -- Subscription metrics summary\n\
@@ -218,10 +220,11 @@ CREATE TABLE event_broadcasts (\n\
 );\n\
 \n\
 -- Indexes for subscription logging performance\n\
-CREATE INDEX idx_subscription_events_id ON subscription_events(subscription_id);\n\
-CREATE INDEX idx_subscription_events_type ON subscription_events(event_type);\n\
-CREATE INDEX idx_subscription_events_created ON subscription_events(created_at DESC);\n\
-CREATE INDEX idx_subscription_events_client ON subscription_events(client_ip);\n\
+CREATE INDEX idx_subscriptions_id ON subscriptions(subscription_id);\n\
+CREATE INDEX idx_subscriptions_type ON subscriptions(event_type);\n\
+CREATE INDEX idx_subscriptions_created ON subscriptions(created_at DESC);\n\
+CREATE INDEX idx_subscriptions_client ON subscriptions(client_ip);\n\
+CREATE INDEX idx_subscriptions_wsi ON subscriptions(wsi_pointer);\n\
 \n\
 CREATE INDEX idx_subscription_metrics_date ON subscription_metrics(date DESC);\n\
 \n\
@@ -231,10 +234,10 @@ CREATE INDEX idx_event_broadcasts_time ON event_broadcasts(broadcast_at DESC);\n
 \n\
 -- Trigger to update subscription duration when ended\n\
 CREATE TRIGGER update_subscription_duration\n\
-    AFTER UPDATE OF ended_at ON subscription_events\n\
+    AFTER UPDATE OF ended_at ON subscriptions\n\
    WHEN NEW.ended_at IS NOT NULL AND OLD.ended_at IS NULL\n\
 BEGIN\n\
-    UPDATE subscription_events\n\
+    UPDATE subscriptions\n\
    SET duration = NEW.ended_at - NEW.created_at\n\
    WHERE id = NEW.id;\n\
 END;\n\
@@ -249,7 +252,7 @@ SELECT\n\
    MAX(events_sent) as max_events_sent,\n\
    AVG(events_sent) as avg_events_sent,\n\
    COUNT(DISTINCT client_ip) as unique_clients\n\
-FROM subscription_events\n\
+FROM subscriptions\n\
 GROUP BY date(created_at, 'unixepoch')\n\
 ORDER BY date DESC;\n\
 \n\
@@ -262,10 +265,10 @@ SELECT\n\
    events_sent,\n\
    created_at,\n\
    (strftime('%s', 'now') - created_at) as duration_seconds\n\
-FROM subscription_events\n\
+FROM subscriptions\n\
 WHERE event_type = 'created'\n\
 AND subscription_id NOT IN (\n\
-    SELECT subscription_id FROM subscription_events\n\
+    SELECT subscription_id FROM subscriptions\n\
    WHERE event_type IN ('closed', 'expired', 'disconnected')\n\
 );\n\
 \n\
--- a/src/subscriptions.c
+++ b/src/subscriptions.c
@@ -25,6 +25,9 @@ int validate_timestamp_range(long since, long until, char* error_message, size_t
 int validate_numeric_limits(int limit, char* error_message, size_t error_size);
 int validate_search_term(const char* search_term, char* error_message, size_t error_size);

+// Forward declaration for monitoring function
+void monitoring_on_subscription_change(void);
+
 // Global database variable
 extern sqlite3* g_db;

@@ -241,8 +244,31 @@ int add_subscription_to_manager(subscription_t* sub) {

    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);

-    // Check global limits
-    if (g_subscription_manager.total_subscriptions >= g_subscription_manager.max_total_subscriptions) {
+    // Check for existing subscription with same ID and WebSocket connection
+    // Remove it first to prevent duplicates (implements subscription replacement per NIP-01)
+    subscription_t** current = &g_subscription_manager.active_subscriptions;
+    int found_duplicate = 0;
+    subscription_t* duplicate_old = NULL;
+
+    while (*current) {
+        subscription_t* existing = *current;
+
+        // Match by subscription ID and WebSocket pointer
+        if (strcmp(existing->id, sub->id) == 0 && existing->wsi == sub->wsi) {
+            // Found duplicate: mark inactive and unlink from global list under lock
+            existing->active = 0;
+            *current = existing->next;
+            g_subscription_manager.total_subscriptions--;
+            found_duplicate = 1;
+            duplicate_old = existing;  // defer free until after per-session unlink
+            break;
+        }
+
+        current = &(existing->next);
+    }
+
+    // Check global limits (only if not replacing an existing subscription)
+    if (!found_duplicate && g_subscription_manager.total_subscriptions >= g_subscription_manager.max_total_subscriptions) {
        pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
        DEBUG_ERROR("Maximum total subscriptions reached");
        return -1;
@@ -252,13 +278,44 @@ int add_subscription_to_manager(subscription_t* sub) {
    sub->next = g_subscription_manager.active_subscriptions;
    g_subscription_manager.active_subscriptions = sub;
    g_subscription_manager.total_subscriptions++;
+
+    // Only increment total_created if this is a new subscription (not a replacement)
+    if (!found_duplicate) {
        g_subscription_manager.total_created++;
+    }

    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);

-    // Log subscription creation to database
+    // If we replaced an existing subscription, unlink it from the per-session list before freeing
+    if (duplicate_old) {
+        // Obtain per-session data for this wsi
+        struct per_session_data* pss = (struct per_session_data*) lws_wsi_user(duplicate_old->wsi);
+        if (pss) {
+            pthread_mutex_lock(&pss->session_lock);
+            struct subscription** scur = &pss->subscriptions;
+            while (*scur) {
+                if (*scur == duplicate_old) {
+                    // Unlink by pointer identity to avoid removing the newly-added one
+                    *scur = duplicate_old->session_next;
+                    if (pss->subscription_count > 0) {
+                        pss->subscription_count--;
+                    }
+                    break;
+                }
+                scur = &((*scur)->session_next);
+            }
+            pthread_mutex_unlock(&pss->session_lock);
+        }
+        // Now safe to free the old subscription
+        free_subscription(duplicate_old);
+    }
+
+    // Log subscription creation to database (INSERT OR REPLACE handles duplicates)
    log_subscription_created(sub);

+    // Trigger monitoring update for subscription changes
+    monitoring_on_subscription_change();
+
    return 0;
 }

@@ -306,6 +363,9 @@ int remove_subscription_from_manager(const char* sub_id, struct lws* wsi) {
            // Update events sent counter before freeing
            update_subscription_events_sent(sub_id_copy, events_sent_copy);

+            // Trigger monitoring update for subscription changes
+            monitoring_on_subscription_change();
+
            free_subscription(sub);
            return 0;
        }
@@ -324,10 +384,7 @@ int remove_subscription_from_manager(const char* sub_id, struct lws* wsi) {

 // Check if an event matches a subscription filter
 int event_matches_filter(cJSON* event, subscription_filter_t* filter) {
-    DEBUG_TRACE("Checking event against subscription filter");
-
    if (!event || !filter) {
-        DEBUG_TRACE("Exiting event_matches_filter - null parameters");
        return 0;
    }

@@ -503,7 +560,6 @@ int event_matches_filter(cJSON* event, subscription_filter_t* filter) {
        }
    }
    
-    DEBUG_TRACE("Exiting event_matches_filter - match found");
    return 1; // All filters passed
 }

@@ -526,10 +582,7 @@ int event_matches_subscription(cJSON* event, subscription_t* subscription) {

 // Broadcast event to all matching subscriptions (thread-safe)
 int broadcast_event_to_subscriptions(cJSON* event) {
-    DEBUG_TRACE("Broadcasting event to subscriptions");
-
    if (!event) {
-        DEBUG_TRACE("Exiting broadcast_event_to_subscriptions - null event");
        return 0;
    }
    
@@ -611,10 +664,17 @@ int broadcast_event_to_subscriptions(cJSON* event) {
            if (buf) {
                memcpy(buf + LWS_PRE, msg_str, msg_len);
                
-                // Send to WebSocket connection with error checking
-                // Note: lws_write can fail if connection is closed, but won't crash
-                int write_result = lws_write(current_temp->wsi, buf + LWS_PRE, msg_len, LWS_WRITE_TEXT);
-                if (write_result >= 0) {
+                // DEBUG: Log WebSocket frame details before sending
+                DEBUG_TRACE("WS_FRAME_SEND: type=EVENT sub=%s len=%zu data=%.100s%s",
+                    current_temp->id,
+                    msg_len,
+                    msg_str,
+                    msg_len > 100 ? "..." : "");
+                
+                // Queue message for proper libwebsockets pattern
+                struct per_session_data* pss = (struct per_session_data*)lws_wsi_user(current_temp->wsi);
+                if (queue_message(current_temp->wsi, pss, msg_str, msg_len, LWS_WRITE_TEXT) == 0) {
+                    // Message queued successfully
                    broadcasts++;

                    // Update events sent counter for this subscription
@@ -636,6 +696,8 @@ int broadcast_event_to_subscriptions(cJSON* event) {
                    if (event_id_obj && cJSON_IsString(event_id_obj)) {
                        log_event_broadcast(cJSON_GetStringValue(event_id_obj), current_temp->id, current_temp->client_ip);
                    }
+                } else {
+                    DEBUG_ERROR("Failed to queue EVENT message for sub=%s", current_temp->id);
                }
                
                free(buf);
@@ -660,10 +722,41 @@ int broadcast_event_to_subscriptions(cJSON* event) {
    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);

    DEBUG_LOG("Event broadcast complete: %d subscriptions matched", broadcasts);
-    DEBUG_TRACE("Exiting broadcast_event_to_subscriptions");
    return broadcasts;
 }

+// Check if any active subscription exists for a specific event kind (thread-safe)
+int has_subscriptions_for_kind(int event_kind) {
+    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+    
+    subscription_t* sub = g_subscription_manager.active_subscriptions;
+    while (sub) {
+        if (sub->active && sub->filters) {
+            subscription_filter_t* filter = sub->filters;
+            while (filter) {
+                // Check if this filter includes our event kind
+                if (filter->kinds && cJSON_IsArray(filter->kinds)) {
+                    cJSON* kind_item = NULL;
+                    cJSON_ArrayForEach(kind_item, filter->kinds) {
+                        if (cJSON_IsNumber(kind_item)) {
+                            int filter_kind = (int)cJSON_GetNumberValue(kind_item);
+                            if (filter_kind == event_kind) {
+                                pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+                                return 1; // Found matching subscription
+                            }
+                        }
+                    }
+                }
+                filter = filter->next;
+            }
+        }
+        sub = sub->next;
+    }
+    
+    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+    return 0; // No matching subscriptions
+}
+

 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -675,6 +768,10 @@ int broadcast_event_to_subscriptions(cJSON* event) {
 void log_subscription_created(const subscription_t* sub) {
    if (!g_db || !sub) return;
    
+    // Convert wsi pointer to string
+    char wsi_str[32];
+    snprintf(wsi_str, sizeof(wsi_str), "%p", (void*)sub->wsi);
+    
    // Create filter JSON for logging
    char* filter_json = NULL;
    if (sub->filters) {
@@ -721,16 +818,18 @@ void log_subscription_created(const subscription_t* sub) {
        cJSON_Delete(filters_array);
    }
    
+    // Use INSERT OR REPLACE to handle duplicates automatically
    const char* sql =
-        "INSERT INTO subscription_events (subscription_id, client_ip, event_type, filter_json) "
-        "VALUES (?, ?, 'created', ?)";
+        "INSERT OR REPLACE INTO subscriptions (subscription_id, wsi_pointer, client_ip, event_type, filter_json) "
+        "VALUES (?, ?, ?, 'created', ?)";
    
    sqlite3_stmt* stmt;
    int rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
    if (rc == SQLITE_OK) {
        sqlite3_bind_text(stmt, 1, sub->id, -1, SQLITE_STATIC);
-        sqlite3_bind_text(stmt, 2, sub->client_ip, -1, SQLITE_STATIC);
-        sqlite3_bind_text(stmt, 3, filter_json ? filter_json : "[]", -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(stmt, 2, wsi_str, -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(stmt, 3, sub->client_ip, -1, SQLITE_STATIC);
+        sqlite3_bind_text(stmt, 4, filter_json ? filter_json : "[]", -1, SQLITE_TRANSIENT);
        
        sqlite3_step(stmt);
        sqlite3_finalize(stmt);
@@ -745,8 +844,8 @@ void log_subscription_closed(const char* sub_id, const char* client_ip, const ch
    if (!g_db || !sub_id) return;
    
    const char* sql =
-        "INSERT INTO subscription_events (subscription_id, client_ip, event_type) "
-        "VALUES (?, ?, 'closed')";
+        "INSERT INTO subscriptions (subscription_id, wsi_pointer, client_ip, event_type) "
+        "VALUES (?, '', ?, 'closed')";
    
    sqlite3_stmt* stmt;
    int rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
@@ -760,7 +859,7 @@ void log_subscription_closed(const char* sub_id, const char* client_ip, const ch
    
    // Update the corresponding 'created' entry with end time and events sent
    const char* update_sql =
-        "UPDATE subscription_events "
+        "UPDATE subscriptions "
        "SET ended_at = strftime('%s', 'now') "
        "WHERE subscription_id = ? AND event_type = 'created' AND ended_at IS NULL";
    
@@ -778,7 +877,7 @@ void log_subscription_disconnected(const char* client_ip) {
    
    // Mark all active subscriptions for this client as disconnected
    const char* sql =
-        "UPDATE subscription_events "
+        "UPDATE subscriptions "
        "SET ended_at = strftime('%s', 'now') "
        "WHERE client_ip = ? AND event_type = 'created' AND ended_at IS NULL";
    
@@ -793,8 +892,8 @@ void log_subscription_disconnected(const char* client_ip) {
        if (changes > 0) {
            // Log a disconnection event
            const char* insert_sql =
-                "INSERT INTO subscription_events (subscription_id, client_ip, event_type) "
-                "VALUES ('disconnect', ?, 'disconnected')";
+                "INSERT INTO subscriptions (subscription_id, wsi_pointer, client_ip, event_type) "
+                "VALUES ('disconnect', '', ?, 'disconnected')";
            
            rc = sqlite3_prepare_v2(g_db, insert_sql, -1, &stmt, NULL);
            if (rc == SQLITE_OK) {
@@ -831,7 +930,7 @@ void update_subscription_events_sent(const char* sub_id, int events_sent) {
    if (!g_db || !sub_id) return;

    const char* sql =
-        "UPDATE subscription_events "
+        "UPDATE subscriptions "
        "SET events_sent = ? "
        "WHERE subscription_id = ? AND event_type = 'created'";

--- a/src/subscriptions.h
+++ b/src/subscriptions.h
@@ -118,4 +118,7 @@ void log_subscription_disconnected(const char* client_ip);
 void log_event_broadcast(const char* event_id, const char* sub_id, const char* client_ip);
 void update_subscription_events_sent(const char* sub_id, int events_sent);

+// Subscription query functions
+int has_subscriptions_for_kind(int event_kind);
+
 #endif // SUBSCRIPTIONS_H
--- a/src/websockets.c
+++ b/src/websockets.c
@@ -108,6 +108,136 @@ struct subscription_manager g_subscription_manager;



+// Message queue functions for proper libwebsockets pattern
+
+/**
+ * Queue a message for WebSocket writing following libwebsockets' proper pattern.
+ * This function adds messages to a per-session queue and requests writeable callback.
+ *
+ * @param wsi WebSocket instance
+ * @param pss Per-session data containing message queue
+ * @param message Message string to write
+ * @param length Length of message string
+ * @param type LWS_WRITE_* type (LWS_WRITE_TEXT, etc.)
+ * @return 0 on success, -1 on error
+ */
+int queue_message(struct lws* wsi, struct per_session_data* pss, const char* message, size_t length, enum lws_write_protocol type) {
+    if (!wsi || !pss || !message || length == 0) {
+        DEBUG_ERROR("queue_message: invalid parameters");
+        return -1;
+    }
+
+    // Allocate message queue node
+    struct message_queue_node* node = malloc(sizeof(struct message_queue_node));
+    if (!node) {
+        DEBUG_ERROR("queue_message: failed to allocate queue node");
+        return -1;
+    }
+
+    // Allocate buffer with LWS_PRE space
+    size_t buffer_size = LWS_PRE + length;
+    unsigned char* buffer = malloc(buffer_size);
+    if (!buffer) {
+        DEBUG_ERROR("queue_message: failed to allocate message buffer");
+        free(node);
+        return -1;
+    }
+
+    // Copy message to buffer with LWS_PRE offset
+    memcpy(buffer + LWS_PRE, message, length);
+
+    // Initialize node
+    node->data = buffer;
+    node->length = length;
+    node->type = type;
+    node->next = NULL;
+
+    // Add to queue (thread-safe)
+    pthread_mutex_lock(&pss->session_lock);
+
+    if (!pss->message_queue_head) {
+        // Queue was empty
+        pss->message_queue_head = node;
+        pss->message_queue_tail = node;
+    } else {
+        // Add to end of queue
+        pss->message_queue_tail->next = node;
+        pss->message_queue_tail = node;
+    }
+    pss->message_queue_count++;
+
+    pthread_mutex_unlock(&pss->session_lock);
+
+    // Request writeable callback (only if not already requested)
+    if (!pss->writeable_requested) {
+        pss->writeable_requested = 1;
+        lws_callback_on_writable(wsi);
+    }
+
+    DEBUG_TRACE("Queued message: len=%zu, queue_count=%d", length, pss->message_queue_count);
+    return 0;
+}
+
+/**
+ * Process message queue when the socket becomes writeable.
+ * This function is called from LWS_CALLBACK_SERVER_WRITEABLE.
+ *
+ * @param wsi WebSocket instance
+ * @param pss Per-session data containing message queue
+ * @return 0 on success, -1 on error
+ */
+int process_message_queue(struct lws* wsi, struct per_session_data* pss) {
+    if (!wsi || !pss) {
+        DEBUG_ERROR("process_message_queue: invalid parameters");
+        return -1;
+    }
+
+    // Get next message from queue (thread-safe)
+    pthread_mutex_lock(&pss->session_lock);
+
+    struct message_queue_node* node = pss->message_queue_head;
+    if (!node) {
+        // Queue is empty
+        pss->writeable_requested = 0;
+        pthread_mutex_unlock(&pss->session_lock);
+        return 0;
+    }
+
+    // Remove from queue
+    pss->message_queue_head = node->next;
+    if (!pss->message_queue_head) {
+        pss->message_queue_tail = NULL;
+    }
+    pss->message_queue_count--;
+
+    pthread_mutex_unlock(&pss->session_lock);
+
+    // Write message (libwebsockets handles partial writes internally)
+    int write_result = lws_write(wsi, node->data + LWS_PRE, node->length, node->type);
+
+    // Free node resources
+    free(node->data);
+    free(node);
+
+    if (write_result < 0) {
+        DEBUG_ERROR("process_message_queue: write failed, result=%d", write_result);
+        return -1;
+    }
+
+    DEBUG_TRACE("Processed message: wrote %d bytes, remaining in queue: %d", write_result, pss->message_queue_count);
+
+    // If queue not empty, request another callback
+    pthread_mutex_lock(&pss->session_lock);
+    if (pss->message_queue_head) {
+        lws_callback_on_writable(wsi);
+    } else {
+        pss->writeable_requested = 0;
+    }
+    pthread_mutex_unlock(&pss->session_lock);
+
+    return 0;
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
 //             WEBSOCKET PROTOCOL
@@ -247,7 +377,57 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso

            // Get real client IP address
            char client_ip[CLIENT_IP_MAX_LENGTH];
+            memset(client_ip, 0, sizeof(client_ip));
+            
+            // Check if we should trust proxy headers
+            int trust_proxy = get_config_bool("trust_proxy_headers", 0);
+            
+            if (trust_proxy) {
+                // Try to get IP from X-Forwarded-For header first
+                char x_forwarded_for[CLIENT_IP_MAX_LENGTH];
+                int header_len = lws_hdr_copy(wsi, x_forwarded_for, sizeof(x_forwarded_for) - 1, WSI_TOKEN_X_FORWARDED_FOR);
+                
+                if (header_len > 0) {
+                    x_forwarded_for[header_len] = '\0';
+                    // X-Forwarded-For can contain multiple IPs (client, proxy1, proxy2, ...)
+                    // We want the first (leftmost) IP which is the original client
+                    char* comma = strchr(x_forwarded_for, ',');
+                    if (comma) {
+                        *comma = '\0'; // Truncate at first comma
+                    }
+                    // Trim leading/trailing whitespace
+                    char* ip_start = x_forwarded_for;
+                    while (*ip_start == ' ' || *ip_start == '\t') ip_start++;
+                    size_t ip_len = strlen(ip_start);
+                    while (ip_len > 0 && (ip_start[ip_len-1] == ' ' || ip_start[ip_len-1] == '\t')) {
+                        ip_start[--ip_len] = '\0';
+                    }
+                    if (ip_len > 0 && ip_len < CLIENT_IP_MAX_LENGTH) {
+                        strncpy(client_ip, ip_start, CLIENT_IP_MAX_LENGTH - 1);
+                        client_ip[CLIENT_IP_MAX_LENGTH - 1] = '\0';
+                        DEBUG_TRACE("Using X-Forwarded-For IP: %s", client_ip);
+                    }
+                }
+                
+                // If X-Forwarded-For didn't work, try X-Real-IP
+                if (client_ip[0] == '\0') {
+                    char x_real_ip[CLIENT_IP_MAX_LENGTH];
+                    header_len = lws_hdr_copy(wsi, x_real_ip, sizeof(x_real_ip) - 1, WSI_TOKEN_HTTP_X_REAL_IP);
+                    
+                    if (header_len > 0) {
+                        x_real_ip[header_len] = '\0';
+                        strncpy(client_ip, x_real_ip, CLIENT_IP_MAX_LENGTH - 1);
+                        client_ip[CLIENT_IP_MAX_LENGTH - 1] = '\0';
+                        DEBUG_TRACE("Using X-Real-IP: %s", client_ip);
+                    }
+                }
+            }
+            
+            // Fall back to direct connection IP if proxy headers not available or not trusted
+            if (client_ip[0] == '\0') {
                lws_get_peer_simple(wsi, client_ip, sizeof(client_ip));
+                DEBUG_TRACE("Using direct connection IP: %s", client_ip);
+            }

            // Ensure client_ip is null-terminated and copy safely
            client_ip[CLIENT_IP_MAX_LENGTH - 1] = '\0';
@@ -627,6 +807,13 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                                        broadcast_event_to_subscriptions(event);
                                                    }
                                                }
+                                            } else {
+                                                // Check if this is an ephemeral event (kinds 20000-29999)
+                                                // Per NIP-01: ephemeral events are broadcast but never stored
+                                                if (event_kind >= 20000 && event_kind < 30000) {
+                                                    DEBUG_TRACE("Ephemeral event (kind %d) - broadcasting without storage", event_kind);
+                                                    // Broadcast directly to subscriptions without database storage
+                                                    broadcast_event_to_subscriptions(event);
                                                } else {
                                                    DEBUG_TRACE("Storing regular event in database");
                                                    // Regular event - store in database and broadcast
@@ -640,6 +827,7 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                                        broadcast_event_to_subscriptions(event);
                                                    }
                                                }
+                                            }
                                        } else {
                                            // Event without valid kind - try normal storage
                                            DEBUG_WARN("Event without valid kind - trying normal storage");
@@ -665,12 +853,18 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                        char *response_str = cJSON_Print(response);
                                        if (response_str) {
                                            size_t response_len = strlen(response_str);
-                                            unsigned char *buf = malloc(LWS_PRE + response_len);
-                                            if (buf) {
-                                                memcpy(buf + LWS_PRE, response_str, response_len);
-                                                lws_write(wsi, buf + LWS_PRE, response_len, LWS_WRITE_TEXT);
-                                                free(buf);
+
+                                            // DEBUG: Log WebSocket frame details before sending
+                                            DEBUG_TRACE("WS_FRAME_SEND: type=OK len=%zu data=%.100s%s",
+                                                response_len,
+                                                response_str,
+                                                response_len > 100 ? "..." : "");
+
+                                            // Queue message for proper libwebsockets pattern
+                                            if (queue_message(wsi, pss, response_str, response_len, LWS_WRITE_TEXT) != 0) {
+                                                DEBUG_ERROR("Failed to queue OK response message");
                                            }
+
                                            free(response_str);
                                        }
                                        cJSON_Delete(response);
@@ -765,12 +959,18 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                        char *eose_str = cJSON_Print(eose_response);
                                        if (eose_str) {
                                            size_t eose_len = strlen(eose_str);
-                                            unsigned char *buf = malloc(LWS_PRE + eose_len);
-                                            if (buf) {
-                                                memcpy(buf + LWS_PRE, eose_str, eose_len);
-                                                lws_write(wsi, buf + LWS_PRE, eose_len, LWS_WRITE_TEXT);
-                                                free(buf);
+
+                                            // DEBUG: Log WebSocket frame details before sending
+                                            DEBUG_TRACE("WS_FRAME_SEND: type=EOSE len=%zu data=%.100s%s",
+                                                eose_len,
+                                                eose_str,
+                                                eose_len > 100 ? "..." : "");
+
+                                            // Queue message for proper libwebsockets pattern
+                                            if (queue_message(wsi, pss, eose_str, eose_len, LWS_WRITE_TEXT) != 0) {
+                                                DEBUG_ERROR("Failed to queue EOSE message");
                                            }
+
                                            free(eose_str);
                                        }
                                        cJSON_Delete(eose_response);
@@ -850,9 +1050,22 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                        return 0;
                                    }

-                                    // CRITICAL FIX: Remove from session list FIRST (while holding lock)
-                                    // to prevent race condition where global manager frees the subscription
-                                    // while we're still iterating through the session list
+                                    // CRITICAL FIX: Mark subscription as inactive in global manager FIRST
+                                    // This prevents other threads from accessing it during removal
+                                    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+
+                                    subscription_t* target_sub = g_subscription_manager.active_subscriptions;
+                                    while (target_sub) {
+                                        if (strcmp(target_sub->id, subscription_id) == 0 && target_sub->wsi == wsi) {
+                                            target_sub->active = 0;  // Mark as inactive immediately
+                                            break;
+                                        }
+                                        target_sub = target_sub->next;
+                                    }
+
+                                    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+
+                                    // Now safe to remove from session list
                                    if (pss) {
                                        pthread_mutex_lock(&pss->session_lock);

@@ -870,8 +1083,7 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                        pthread_mutex_unlock(&pss->session_lock);
                                    }

-                                    // Remove from global manager AFTER removing from session list
-                                    // This prevents use-after-free when iterating session subscriptions
+                                    // Finally remove from global manager (which will free it)
                                    remove_subscription_from_manager(subscription_id, wsi);

                                    // Subscription closed
@@ -914,6 +1126,13 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
            }
            break;
            
+        case LWS_CALLBACK_SERVER_WRITEABLE:
+            // Handle message queue when socket becomes writeable
+            if (pss) {
+                process_message_queue(wsi, pss);
+            }
+            break;
+
        case LWS_CALLBACK_CLOSED:
            DEBUG_TRACE("WebSocket connection closed");
            
@@ -947,20 +1166,66 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                    auth_status,
                    reason);

-                // Clean up session subscriptions
+                // Clean up message queue to prevent memory leaks
+                while (pss->message_queue_head) {
+                    struct message_queue_node* node = pss->message_queue_head;
+                    pss->message_queue_head = node->next;
+                    free(node->data);
+                    free(node);
+                }
+                pss->message_queue_tail = NULL;
+                pss->message_queue_count = 0;
+                pss->writeable_requested = 0;
+
+                // Clean up session subscriptions - copy IDs first to avoid use-after-free
                pthread_mutex_lock(&pss->session_lock);

+                // First pass: collect subscription IDs safely
+                typedef struct temp_sub_id {
+                    char id[SUBSCRIPTION_ID_MAX_LENGTH];
+                    struct temp_sub_id* next;
+                } temp_sub_id_t;
+
+                temp_sub_id_t* temp_ids = NULL;
+                temp_sub_id_t* temp_tail = NULL;
+                int temp_count = 0;
+
                struct subscription* sub = pss->subscriptions;
                while (sub) {
-                    struct subscription* next = sub->session_next;
-                    remove_subscription_from_manager(sub->id, wsi);
-                    sub = next;
+                    if (sub->active) {  // Only process active subscriptions
+                        temp_sub_id_t* temp = malloc(sizeof(temp_sub_id_t));
+                        if (temp) {
+                            memcpy(temp->id, sub->id, SUBSCRIPTION_ID_MAX_LENGTH);
+                            temp->id[SUBSCRIPTION_ID_MAX_LENGTH - 1] = '\0';
+                            temp->next = NULL;
+
+                            if (!temp_ids) {
+                                temp_ids = temp;
+                                temp_tail = temp;
+                            } else {
+                                temp_tail->next = temp;
+                                temp_tail = temp;
+                            }
+                            temp_count++;
+                        }
+                    }
+                    sub = sub->session_next;
                }

+                // Clear session list immediately
                pss->subscriptions = NULL;
                pss->subscription_count = 0;

                pthread_mutex_unlock(&pss->session_lock);
+
+                // Second pass: remove from global manager using copied IDs
+                temp_sub_id_t* current_temp = temp_ids;
+                while (current_temp) {
+                    temp_sub_id_t* next_temp = current_temp->next;
+                    remove_subscription_from_manager(current_temp->id, wsi);
+                    free(current_temp);
+                    current_temp = next_temp;
+                }
                pthread_mutex_destroy(&pss->session_lock);
            } else {
                DEBUG_LOG("WebSocket CLOSED: ip=unknown duration=0s subscriptions=0 authenticated=no reason=unknown");
@@ -1627,12 +1892,18 @@ int handle_count_message(const char* sub_id, cJSON* filters, struct lws *wsi, st
    char *count_str = cJSON_Print(count_response);
    if (count_str) {
        size_t count_len = strlen(count_str);
-        unsigned char *buf = malloc(LWS_PRE + count_len);
-        if (buf) {
-            memcpy(buf + LWS_PRE, count_str, count_len);
-            lws_write(wsi, buf + LWS_PRE, count_len, LWS_WRITE_TEXT);
-            free(buf);
+
+        // DEBUG: Log WebSocket frame details before sending
+        DEBUG_TRACE("WS_FRAME_SEND: type=COUNT len=%zu data=%.100s%s",
+            count_len,
+            count_str,
+            count_len > 100 ? "..." : "");
+
+        // Queue message for proper libwebsockets pattern
+        if (queue_message(wsi, pss, count_str, count_len, LWS_WRITE_TEXT) != 0) {
+            DEBUG_ERROR("Failed to queue COUNT message");
        }
+
        free(count_str);
    }
    cJSON_Delete(count_response);
--- a/src/websockets.h
+++ b/src/websockets.h
@@ -31,6 +31,14 @@
 #define MAX_SEARCH_LENGTH 256
 #define MAX_TAG_VALUE_LENGTH 1024

+// Message queue node for proper libwebsockets pattern
+struct message_queue_node {
+    unsigned char* data;                    // Message data (with LWS_PRE space)
+    size_t length;                         // Message length (without LWS_PRE)
+    enum lws_write_protocol type;           // LWS_WRITE_TEXT, etc.
+    struct message_queue_node* next;        // Next node in queue
+};
+
 // Enhanced per-session data with subscription management, NIP-42 authentication, and rate limiting
 struct per_session_data {
    int authenticated;
@@ -59,6 +67,12 @@ struct per_session_data {
    int malformed_request_count;             // Count of malformed requests in current hour
    time_t malformed_request_window_start;   // Start of current hour window
    time_t malformed_request_blocked_until;  // Time until blocked for malformed requests
+
+    // Message queue for proper libwebsockets pattern (replaces single buffer)
+    struct message_queue_node* message_queue_head;  // Head of message queue
+    struct message_queue_node* message_queue_tail;  // Tail of message queue
+    int message_queue_count;                  // Number of messages in queue
+    int writeable_requested;                  // Flag: 1 if writeable callback requested
 };

 // NIP-11 HTTP session data structure for managing buffer lifetime
@@ -73,6 +87,10 @@ struct nip11_session_data {
 // Function declarations
 int start_websocket_relay(int port_override, int strict_port);

+// Message queue functions for proper libwebsockets pattern
+int queue_message(struct lws* wsi, struct per_session_data* pss, const char* message, size_t length, enum lws_write_protocol type);
+int process_message_queue(struct lws* wsi, struct per_session_data* pss);
+
 // Auth rules checking function from request_validator.c
 int check_database_auth_rules(const char *pubkey, const char *operation, const char *resource_hash);

--- a/systemd/c-relay-local.service
+++ b/systemd/c-relay-local.service
@@ -0,0 +1,40 @@
+[Unit]
+Description=C Nostr Relay Server (Local Development)
+Documentation=https://github.com/your-repo/c-relay
+After=network.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=teknari
+WorkingDirectory=/home/teknari/Storage/c_relay
+Environment=DEBUG_LEVEL=0
+ExecStart=/home/teknari/Storage/c_relay/crelay --port 7777 --debug-level=$DEBUG_LEVEL
+Restart=always
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=c-relay-local
+
+# Security settings (relaxed for local development)
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/home/teknari/Storage/c_relay
+PrivateTmp=true
+
+# Network security
+PrivateNetwork=false
+RestrictAddressFamilies=AF_INET AF_INET6
+
+# Resource limits
+LimitNOFILE=65536
+LimitNPROC=4096
+
+# Event-based configuration system
+# No environment variables needed - all configuration is stored as Nostr events
+# Database files (<relay_pubkey>.db) are created automatically in WorkingDirectory
+# Admin keys are generated and displayed only during first startup
+
+[Install]
+WantedBy=multi-user.target
--- a/tests/ephemeral_test.sh
+++ b/tests/ephemeral_test.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+# Simplified Ephemeral Event Test
+# Tests that ephemeral events are broadcast to active subscriptions
+
+echo "=== Generating Ephemeral Event (kind 20000) ==="
+event=$(nak event --kind 20000 --content "test ephemeral event")
+echo "$event"
+echo ""
+
+echo "=== Testing Ephemeral Event Broadcast ==="
+subscription='["REQ","test_sub",{"kinds":[20000],"limit":10}]'
+echo "Subscription Filter:"
+echo "$subscription"
+echo ""
+
+event_msg='["EVENT",'"$event"']'
+echo "Event Message:"
+echo "$event_msg"
+echo ""
+
+echo "=== Relay Responses ==="
+(
+    # Send subscription
+    printf "%s\n" "$subscription"
+    # Wait for subscription to establish
+    sleep 1
+    # Send ephemeral event on same connection
+    printf "%s\n" "$event_msg"
+    # Wait for responses
+    sleep 2
+) | timeout 5 websocat ws://127.0.0.1:8888
+
+echo ""
+echo "Test complete!"
--- a/tests/large_event_test.sh
+++ b/tests/large_event_test.sh
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+# Test script for posting large events (>4KB) to test partial write handling
+# Uses nak to properly sign events with large content
+
+RELAY_URL="ws://localhost:8888"
+
+# Check if nak is installed
+if ! command -v nak &> /dev/null; then
+    echo "Error: nak is not installed. Install with: go install github.com/fiatjaf/nak@latest"
+    exit 1
+fi
+
+# Generate a test private key if not set
+if [ -z "$NOSTR_PRIVATE_KEY" ]; then
+    echo "Generating temporary test key..."
+    export NOSTR_PRIVATE_KEY=$(nak key generate)
+fi
+
+echo "=== Large Event Test ==="
+echo "Testing partial write handling with events >4KB"
+echo "Relay: $RELAY_URL"
+echo ""
+
+# Test 1: 5KB event
+echo "Test 1: Posting 5KB event..."
+CONTENT_5KB=$(python3 -c "print('A' * 5000)")
+echo "$CONTENT_5KB" | nak event -k 1 --content - $RELAY_URL
+sleep 1
+
+# Test 2: 10KB event
+echo ""
+echo "Test 2: Posting 10KB event..."
+CONTENT_10KB=$(python3 -c "print('B' * 10000)")
+echo "$CONTENT_10KB" | nak event -k 1 --content - $RELAY_URL
+sleep 1
+
+# Test 3: 20KB event
+echo ""
+echo "Test 3: Posting 20KB event..."
+CONTENT_20KB=$(python3 -c "print('C' * 20000)")
+echo "$CONTENT_20KB" | nak event -k 1 --content - $RELAY_URL
+sleep 1
+
+# Test 4: 50KB event (very large)
+echo ""
+echo "Test 4: Posting 50KB event..."
+CONTENT_50KB=$(python3 -c "print('D' * 50000)")
+echo "$CONTENT_50KB" | nak event -k 1 --content - $RELAY_URL
+
+echo ""
+echo "=== Test Complete ==="
+echo ""
+echo "Check relay.log for:"
+echo "  - 'Queued partial write' messages (indicates buffering is working)"
+echo "  - 'write completed' messages (indicates retry succeeded)"
+echo "  - No 'Invalid frame header' errors"
+echo ""
+echo "To view logs in real-time:"
+echo "  tail -f relay.log | grep -E '(partial|write completed|Invalid frame)'"
+echo ""
+echo "To check if events were stored:"
+echo "  sqlite3 build/*.db 'SELECT id, length(content) as content_size FROM events ORDER BY created_at DESC LIMIT 4;'"
--- a/tests/post_events.sh
+++ b/tests/post_events.sh
@@ -3,6 +3,19 @@
 # Test script to post kind 1 events to the relay every second
 # Cycles through three different secret keys
 # Content includes current timestamp
+#
+# Usage: ./post_events.sh <relay_url>
+# Example: ./post_events.sh ws://localhost:8888
+# Example: ./post_events.sh wss://relay.laantungir.net
+
+# Check if relay URL is provided
+if [ -z "$1" ]; then
+    echo "Error: Relay URL is required"
+    echo "Usage: $0 <relay_url>"
+    echo "Example: $0 ws://localhost:8888"
+    echo "Example: $0 wss://relay.laantungir.net"
+    exit 1
+fi

 # Array of secret keys to cycle through
 SECRET_KEYS=(
@@ -11,7 +24,7 @@ SECRET_KEYS=(
    "1618aaa21f5bd45c5ffede0d9a60556db67d4a046900e5f66b0bae5c01c801fb"
 )

-RELAY_URL="ws://localhost:8888"
+RELAY_URL="$1"
 KEY_INDEX=0

 echo "Starting event posting test to $RELAY_URL"
@@ -36,5 +49,5 @@ while true; do
    KEY_INDEX=$(( (KEY_INDEX + 1) % ${#SECRET_KEYS[@]} ))

    # Wait 1 second
-    sleep 1
+    sleep .2
 done
--- a/tests/rate_limiting_tests.sh
+++ b/tests/rate_limiting_tests.sh
@@ -1,203 +0,0 @@
-#!/bin/bash
-
-# Rate Limiting Test Suite for C-Relay
-# Tests rate limiting and abuse prevention mechanisms
-
-set -e
-
-# Configuration
-RELAY_HOST="127.0.0.1"
-RELAY_PORT="8888"
-TEST_TIMEOUT=15
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Test counters
-TOTAL_TESTS=0
-PASSED_TESTS=0
-FAILED_TESTS=0
-
-# Function to test rate limiting
-test_rate_limiting() {
-    local description="$1"
-    local message="$2"
-    local burst_count="${3:-10}"
-    local expected_limited="${4:-false}"
-
-    TOTAL_TESTS=$((TOTAL_TESTS + 1))
-
-    echo -n "Testing $description... "
-
-    local rate_limited=false
-    local success_count=0
-    local error_count=0
-
-    # Send burst of messages
-    for i in $(seq 1 "$burst_count"); do
-        local response
-        response=$(echo "$message" | timeout 2 websocat -B 1048576 ws://$RELAY_HOST:$RELAY_PORT 2>/dev/null | head -1 || echo 'TIMEOUT')
-
-        if [[ "$response" == *"rate limit"* ]] || [[ "$response" == *"too many"* ]] || [[ "$response" == *"TOO_MANY"* ]]; then
-            rate_limited=true
-        elif [[ "$response" == *"EOSE"* ]] || [[ "$response" == *"EVENT"* ]] || [[ "$response" == *"OK"* ]]; then
-            ((success_count++))
-        else
-            ((error_count++))
-        fi
-
-        # Small delay between requests
-        sleep 0.05
-    done
-
-    if [[ "$expected_limited" == "true" ]]; then
-        if [[ "$rate_limited" == "true" ]]; then
-            echo -e "${GREEN}PASSED${NC} - Rate limiting triggered as expected"
-            PASSED_TESTS=$((PASSED_TESTS + 1))
-            return 0
-        else
-            echo -e "${RED}FAILED${NC} - Rate limiting not triggered (expected)"
-            FAILED_TESTS=$((FAILED_TESTS + 1))
-            return 1
-        fi
-    else
-        if [[ "$rate_limited" == "false" ]]; then
-            echo -e "${GREEN}PASSED${NC} - No rate limiting for normal traffic"
-            PASSED_TESTS=$((PASSED_TESTS + 1))
-            return 0
-        else
-            echo -e "${YELLOW}UNCERTAIN${NC} - Unexpected rate limiting"
-            PASSED_TESTS=$((PASSED_TESTS + 1)) # Count as passed since it's conservative
-            return 0
-        fi
-    fi
-}
-
-# Function to test sustained load
-test_sustained_load() {
-    local description="$1"
-    local message="$2"
-    local duration="${3:-10}"
-
-    TOTAL_TESTS=$((TOTAL_TESTS + 1))
-
-    echo -n "Testing $description... "
-
-    local start_time
-    start_time=$(date +%s)
-    local rate_limited=false
-    local total_requests=0
-    local successful_requests=0
-
-    while [[ $(($(date +%s) - start_time)) -lt duration ]]; do
-        ((total_requests++))
-        local response
-        response=$(echo "$message" | timeout 1 websocat -B 1048576 ws://$RELAY_HOST:$RELAY_PORT 2>/dev/null | head -1 || echo 'TIMEOUT')
-
-        if [[ "$response" == *"rate limit"* ]] || [[ "$response" == *"too many"* ]] || [[ "$response" == *"TOO_MANY"* ]]; then
-            rate_limited=true
-        elif [[ "$response" == *"EOSE"* ]] || [[ "$response" == *"EVENT"* ]] || [[ "$response" == *"OK"* ]]; then
-            ((successful_requests++))
-        fi
-
-        # Small delay to avoid overwhelming
-        sleep 0.1
-    done
-
-    local success_rate=0
-    if [[ $total_requests -gt 0 ]]; then
-        success_rate=$((successful_requests * 100 / total_requests))
-    fi
-
-    if [[ "$rate_limited" == "true" ]]; then
-        echo -e "${GREEN}PASSED${NC} - Rate limiting activated under sustained load (${success_rate}% success rate)"
-        PASSED_TESTS=$((PASSED_TESTS + 1))
-        return 0
-    else
-        echo -e "${YELLOW}UNCERTAIN${NC} - No rate limiting detected (${success_rate}% success rate)"
-        # This might be acceptable if rate limiting is very permissive
-        PASSED_TESTS=$((PASSED_TESTS + 1))
-        return 0
-    fi
-}
-
-echo "=========================================="
-echo "C-Relay Rate Limiting Test Suite"
-echo "=========================================="
-echo "Testing rate limiting against relay at ws://$RELAY_HOST:$RELAY_PORT"
-echo ""
-
-# Test basic connectivity first
-echo "=== Basic Connectivity Test ==="
-test_rate_limiting "Basic connectivity" '["REQ","rate_test",{}]' 1 false
-echo ""
-
-echo "=== Burst Request Testing ==="
-# Test rapid succession of requests
-test_rate_limiting "Rapid REQ messages" '["REQ","burst_req_'$(date +%s%N)'",{}]' 20 true
-test_rate_limiting "Rapid COUNT messages" '["COUNT","burst_count_'$(date +%s%N)'",{}]' 20 true
-test_rate_limiting "Rapid CLOSE messages" '["CLOSE","burst_close"]' 20 true
-echo ""
-
-echo "=== Malformed Message Rate Limiting ==="
-# Test if malformed messages trigger rate limiting faster
-test_rate_limiting "Malformed JSON burst" '["REQ","malformed"' 15 true
-test_rate_limiting "Invalid message type burst" '["INVALID","test",{}]' 15 true
-test_rate_limiting "Empty message burst" '[]' 15 true
-echo ""
-
-echo "=== Sustained Load Testing ==="
-# Test sustained moderate load
-test_sustained_load "Sustained REQ load" '["REQ","sustained_'$(date +%s%N)'",{}]' 10
-test_sustained_load "Sustained COUNT load" '["COUNT","sustained_count_'$(date +%s%N)'",{}]' 10
-echo ""
-
-echo "=== Filter Complexity Testing ==="
-# Test if complex filters trigger rate limiting
-test_rate_limiting "Complex filter burst" '["REQ","complex_'$(date +%s%N)'",{"authors":["a","b","c"],"kinds":[1,2,3],"#e":["x","y","z"],"#p":["m","n","o"],"since":1000000000,"until":2000000000,"limit":100}]' 10 true
-echo ""
-
-echo "=== Subscription Management Testing ==="
-# Test subscription creation/deletion rate limiting
-echo -n "Testing subscription churn... "
-local churn_test_passed=true
-for i in $(seq 1 25); do
-    # Create subscription
-    echo "[\"REQ\",\"churn_${i}_$(date +%s%N)\",{}]" | timeout 1 websocat -B 1048576 ws://$RELAY_HOST:$RELAY_PORT >/dev/null 2>&1 || true
-
-    # Close subscription
-    echo "[\"CLOSE\",\"churn_${i}_*\"]" | timeout 1 websocat -B 1048576 ws://$RELAY_HOST:$RELAY_PORT >/dev/null 2>&1 || true
-
-    sleep 0.05
-done
-
-# Check if relay is still responsive
-if echo 'ping' | timeout 2 websocat -n1 ws://$RELAY_HOST:$RELAY_PORT >/dev/null 2>&1; then
-    echo -e "${GREEN}PASSED${NC} - Subscription churn handled"
-    TOTAL_TESTS=$((TOTAL_TESTS + 1))
-    PASSED_TESTS=$((PASSED_TESTS + 1))
-else
-    echo -e "${RED}FAILED${NC} - Relay unresponsive after subscription churn"
-    TOTAL_TESTS=$((TOTAL_TESTS + 1))
-    FAILED_TESTS=$((FAILED_TESTS + 1))
-fi
-echo ""
-
-echo "=== Test Results ==="
-echo "Total tests: $TOTAL_TESTS"
-echo -e "Passed: ${GREEN}$PASSED_TESTS${NC}"
-echo -e "Failed: ${RED}$FAILED_TESTS${NC}"
-
-if [[ $FAILED_TESTS -eq 0 ]]; then
-    echo -e "${GREEN}✓ All rate limiting tests passed!${NC}"
-    echo "Rate limiting appears to be working correctly."
-    exit 0
-else
-    echo -e "${RED}✗ Some rate limiting tests failed!${NC}"
-    echo "Rate limiting may not be properly configured."
-    exit 1
-fi
--- a/2
+++ b/2
Author	SHA1	Message	Date
Your Name	079fb1b0f5	v0.7.38 - Fixed error upon startup with existing db	2025-10-23 11:17:16 -04:00
Your Name	17b2aa8111	v0.7.37 - Enhanced admin interface with sliding sidebar navigation, moved dark mode and logout to sidebar footer, improved button styling consistency	2025-10-22 12:43:09 -04:00
Your Name	78d484cfe0	v0.7.36 - Implement sliding side navigation menu with page switching for admin sections	2025-10-22 11:01:30 -04:00
Your Name	182e12817d	v0.7.35 - Implement event-driven monitoring system with dual triggers for events and subscriptions	2025-10-22 10:48:57 -04:00
Your Name	9179d57cc9	v0.7.34 - We seemed to maybe finally fixed the monitoring error?	2025-10-22 10:19:43 -04:00
Your Name	9cb9b746d8	v0.7.33 - Refactor monitoring system to use subscription-based activation with ephemeral events - fixes recursive crash bug	2025-10-19 10:26:09 -04:00
Your Name	57a0089664	v0.7.32 - Implement ephemeral event bypass (NIP-01) - events with kinds 20000-29999 are now broadcast to subscriptions but never stored in database, preventing recursive monitoring event loops	2025-10-19 09:38:02 -04:00
Your Name	53f7608872	v0.7.31 - Fixed production crash by replacing in-memory subscription iteration with database queries in monitoring system	2025-10-18 18:09:13 -04:00
Your Name	838ce5b45a	v0.7.30 - Update increment and push script	2025-10-18 15:04:45 -04:00
Your Name	e878b9557e	v0.7.29 - Update increment and push script	2025-10-18 14:57:34 -04:00