From bb8fb43464fd4631fb43b9466eaeb6e5b2af6603 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Mon, 30 Mar 2026 09:23:53 +0200
Subject: [PATCH 01/32] local: add Matomo analytics tracking

---
 public/index.html | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/public/index.html b/public/index.html
index 55f66d9b..b8cc5322 100644
--- a/public/index.html
+++ b/public/index.html
@@ -110,5 +110,19 @@
   <script src="compare.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="node-analytics.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="perf.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
+  <!-- Matomo -->
+  <script>
+    var _paq = window._paq = window._paq || [];
+    _paq.push(['trackPageView']);
+    _paq.push(['enableLinkTracking']);
+    (function() {
+      var u = "https://analytics.fiten.eu/";
+      _paq.push(['setTrackerUrl', u + 'matomo.php']);
+      _paq.push(['setSiteId', '8']);
+      var d = document, g = d.createElement('script'), s = d.getElementsByTagName('script')[0];
+      g.async = true; g.src = u + 'matomo.js'; s.parentNode.insertBefore(g, s);
+    })();
+  </script>
+  <!-- End Matomo -->
 </body>
 </html>

From f0fc9406f4611a357cd1b62dd91d658d48e51031 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Tue, 31 Mar 2026 10:24:40 +0200
Subject: [PATCH 02/32] chore: update MATOMO_COMMIT SHA after master rebase

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 deploy-live.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deploy-live.sh b/deploy-live.sh
index bc100d83..71fae575 100644
--- a/deploy-live.sh
+++ b/deploy-live.sh
@@ -2,7 +2,7 @@
 set -e
 
 DEPLOY_DIR="$(cd "$(dirname "$0")" && pwd)"
-MATOMO_COMMIT="38c30f9"
+MATOMO_COMMIT="bb8fb43"
 
 cd "$DEPLOY_DIR"
 

From a5b8e7d46b7d3020b6a37795c004eb8d9c0f9da2 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 1 Apr 2026 23:27:07 +0200
Subject: [PATCH 03/32] fix: null-guard animLayer and liveAnimCount in nextHop
 after destroy

Async timers (setInterval/setTimeout) started by animateHop() can fire
after destroy() has nulled animLayer and removed DOM elements. This
caused three console errors on the Live page when navigating away mid-
animation. Guards added at each async callback site.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/index.html        | 56 ++++++++++++++++++++--------------------
 public/live.js           |  8 +++---
 test-frontend-helpers.js | 28 ++++++++++++++++++++
 3 files changed, 61 insertions(+), 31 deletions(-)

diff --git a/public/index.html b/public/index.html
index b8cc5322..7a406cd7 100644
--- a/public/index.html
+++ b/public/index.html
@@ -22,9 +22,9 @@
   <meta name="twitter:title" content="CoreScope">
   <meta name="twitter:description" content="Real-time MeshCore LoRa mesh network analyzer — live packet visualization, node tracking, channel decryption, and route analysis.">
   <meta name="twitter:image" content="https://raw.githubusercontent.com/Kpa-clawbot/corescope/master/public/og-image.png">
-  <link rel="stylesheet" href="style.css?v=1775062162">
-  <link rel="stylesheet" href="home.css?v=1775062162">
-  <link rel="stylesheet" href="live.css?v=1775062162">
+  <link rel="stylesheet" href="style.css?v=1775078686">
+  <link rel="stylesheet" href="home.css?v=1775078686">
+  <link rel="stylesheet" href="live.css?v=1775078686">
   <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"
     integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY="
     crossorigin="anonymous">
@@ -85,31 +85,31 @@
   <main id="app" role="main"></main>
 
   <script src="vendor/qrcode.js"></script>
-  <script src="roles.js?v=1775062162"></script>
-  <script src="customize.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="region-filter.js?v=1775062162"></script>
-  <script src="hop-resolver.js?v=1775062162"></script>
-  <script src="hop-display.js?v=1775062162"></script>
-  <script src="app.js?v=1775062162"></script>
-  <script src="home.js?v=1775062162"></script>
-  <script src="packet-filter.js?v=1775062162"></script>
-  <script src="packets.js?v=1775062162"></script>
-  <script src="geo-filter-overlay.js?v=1775062162"></script>
-  <script src="map.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="channels.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="nodes.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="traces.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="analytics.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio-v1-constellation.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio-v2-constellation.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio-lab.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="live.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="observers.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="observer-detail.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="compare.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="node-analytics.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="perf.js?v=1775062162" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="roles.js?v=1775078686"></script>
+  <script src="customize.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="region-filter.js?v=1775078686"></script>
+  <script src="hop-resolver.js?v=1775078686"></script>
+  <script src="hop-display.js?v=1775078686"></script>
+  <script src="app.js?v=1775078686"></script>
+  <script src="home.js?v=1775078686"></script>
+  <script src="packet-filter.js?v=1775078686"></script>
+  <script src="packets.js?v=1775078686"></script>
+  <script src="geo-filter-overlay.js?v=1775078686"></script>
+  <script src="map.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="channels.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="nodes.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="traces.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="analytics.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio-v1-constellation.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio-v2-constellation.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio-lab.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="live.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="observers.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="observer-detail.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="compare.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="node-analytics.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="perf.js?v=1775078686" onerror="console.error('Failed to load:', this.src)"></script>
   <!-- Matomo -->
   <script>
     var _paq = window._paq = window._paq || [];
diff --git a/public/live.js b/public/live.js
index 2be005b8..50861601 100644
--- a/public/live.js
+++ b/public/live.js
@@ -1850,9 +1850,11 @@
     function nextHop() {
       if (hopIndex >= hopPositions.length) {
         activeAnims = Math.max(0, activeAnims - 1);
-        document.getElementById('liveAnimCount').textContent = activeAnims;
+        const countEl = document.getElementById('liveAnimCount');
+        if (countEl) countEl.textContent = activeAnims;
         return;
       }
+      if (!animLayer) return;
       // Audio hook: notify per-hop callback
       if (onHop) try { onHop(hopIndex, hopPositions.length, hopPositions[hopIndex]); } catch (e) {}
       const hp = hopPositions[hopIndex];
@@ -1865,11 +1867,11 @@
           }).addTo(animLayer);
           let pulseUp = true;
           const pulseTimer = setInterval(() => {
-            if (!animLayer.hasLayer(ghost)) { clearInterval(pulseTimer); return; }
+            if (!animLayer || !animLayer.hasLayer(ghost)) { clearInterval(pulseTimer); return; }
             ghost.setStyle({ fillOpacity: pulseUp ? 0.6 : 0.25, opacity: pulseUp ? 0.7 : 0.4 });
             pulseUp = !pulseUp;
           }, 600);
-          setTimeout(() => { clearInterval(pulseTimer); if (animLayer.hasLayer(ghost)) animLayer.removeLayer(ghost); }, 3000);
+          setTimeout(() => { clearInterval(pulseTimer); if (animLayer && animLayer.hasLayer(ghost)) animLayer.removeLayer(ghost); }, 3000);
         }
       } else {
         pulseNode(hp.key, hp.pos, typeName);
diff --git a/test-frontend-helpers.js b/test-frontend-helpers.js
index 6fb128d3..c75c658a 100644
--- a/test-frontend-helpers.js
+++ b/test-frontend-helpers.js
@@ -2696,6 +2696,34 @@ console.log('\n=== packets.js: savedTimeWindowMin defaults ===');
   });
 }
 
+// ===== live.js: nextHop null guards =====
+console.log('\n=== live.js: nextHop null guards ===');
+{
+  const liveSource = fs.readFileSync('public/live.js', 'utf8');
+
+  test('nextHop guards animLayer null before use', () => {
+    assert.ok(liveSource.includes('if (!animLayer) return;'),
+      'nextHop must return early when animLayer is null (post-destroy)');
+  });
+
+  test('nextHop setInterval guards animLayer null', () => {
+    assert.ok(liveSource.includes('if (!animLayer || !animLayer.hasLayer(ghost))'),
+      'setInterval in nextHop must guard animLayer null');
+  });
+
+  test('nextHop setTimeout guards animLayer null', () => {
+    assert.ok(liveSource.includes('if (animLayer && animLayer.hasLayer(ghost)) animLayer.removeLayer(ghost)'),
+      'setTimeout in nextHop must guard animLayer null');
+  });
+
+  test('nextHop guards liveAnimCount element null', () => {
+    assert.ok(liveSource.includes('const countEl = document.getElementById(\'liveAnimCount\')'),
+      'nextHop must null-check liveAnimCount element');
+    assert.ok(liveSource.includes('if (countEl) countEl.textContent = activeAnims'),
+      'nextHop must conditionally update liveAnimCount');
+  });
+}
+
 // ===== SUMMARY =====
 Promise.allSettled(pendingTests).then(() => {
   console.log(`\n${'═'.repeat(40)}`);

From b67d816c987703ecf5941eff5821ed5832f218c2 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 2 Apr 2026 10:17:57 +0200
Subject: [PATCH 04/32] fix: use packet timestamp in bufferPacket instead of
 arrival time (#475)

bufferPacket was stamping all live WS packets with Date.now() (receive
time). Packets arriving in the same batch all got identical timestamps,
making the message history show the same "Xs ago" for every entry.

Use pkt.timestamp || pkt.created_at (mirroring dbPacketToLive) so each
packet reflects its actual origination time.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/live.js           |  2 +-
 test-frontend-helpers.js | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/public/live.js b/public/live.js
index 50861601..6110e155 100644
--- a/public/live.js
+++ b/public/live.js
@@ -476,7 +476,7 @@
   });
 
   function bufferPacket(pkt) {
-    pkt._ts = Date.now();
+    pkt._ts = new Date(pkt.timestamp || pkt.created_at || Date.now()).getTime();
     const entry = { ts: pkt._ts, pkt };
     VCR.buffer.push(entry);
     // Keep buffer capped at ~2000 — adjust playhead to avoid stale indices (#63)
diff --git a/test-frontend-helpers.js b/test-frontend-helpers.js
index c75c658a..e475dcd9 100644
--- a/test-frontend-helpers.js
+++ b/test-frontend-helpers.js
@@ -2696,6 +2696,26 @@ console.log('\n=== packets.js: savedTimeWindowMin defaults ===');
   });
 }
 
+// ===== live.js: bufferPacket timestamp =====
+console.log('\n=== live.js: bufferPacket timestamp ===');
+{
+  const liveSource = fs.readFileSync('public/live.js', 'utf8');
+
+  test('bufferPacket uses packet timestamp not Date.now()', () => {
+    assert.ok(
+      liveSource.includes('pkt._ts = new Date(pkt.timestamp || pkt.created_at || Date.now()).getTime()'),
+      'bufferPacket must derive _ts from pkt.timestamp, not Date.now()'
+    );
+  });
+
+  test('bufferPacket does not unconditionally assign Date.now() to _ts', () => {
+    assert.ok(
+      !liveSource.match(/pkt\._ts\s*=\s*Date\.now\(\)\s*;/),
+      'bufferPacket must not stamp all packets with receive time'
+    );
+  });
+}
+
 // ===== live.js: nextHop null guards =====
 console.log('\n=== live.js: nextHop null guards ===');
 {

From 18c982c4fa7870b297a0e96837544fd663c1c3a0 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 2 Apr 2026 10:52:26 +0200
Subject: [PATCH 05/32] fix: stop home config drift in customize buildExport
 and autoSave (#284)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two bugs remained after prior fix attempts:

1. buildExport() diffed home fields against DEFAULTS instead of the
   server's original config (_SITE_CONFIG_ORIGINAL_HOME). If the server
   provided custom steps and the user only edited the checklist, those
   server steps were captured in localStorage — blocking future server
   updates from being visible after reload.

2. autoSave() synced branding to SITE_CONFIG but not home, so the live
   preview (hashchange re-render) read stale SITE_CONFIG.home and didn't
   reflect the user's edits until a full page reload.

Fix: diff home fields against _SITE_CONFIG_ORIGINAL_HOME in buildExport,
and sync state.home back to SITE_CONFIG.home in autoSave using the same
original snapshot as base to prevent cumulative mutations.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/customize.js      | 21 +++++++++-----
 test-frontend-helpers.js | 61 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 75 insertions(+), 7 deletions(-)

diff --git a/public/customize.js b/public/customize.js
index c879ebe2..f87d92b2 100644
--- a/public/customize.js
+++ b/public/customize.js
@@ -545,9 +545,10 @@
       try {
         var data = buildExport();
         localStorage.setItem('meshcore-user-theme', JSON.stringify(data));
-        // Sync to SITE_CONFIG so live pages (home, etc.) pick up changes
+        // Sync to SITE_CONFIG so live pages (home, branding) pick up changes
         if (window.SITE_CONFIG) {
           if (state.branding) window.SITE_CONFIG.branding = Object.assign(window.SITE_CONFIG.branding || {}, state.branding);
+          if (state.home) window.SITE_CONFIG.home = Object.assign({}, window._SITE_CONFIG_ORIGINAL_HOME || {}, state.home);
         }
         // Re-render current page to reflect home/branding changes
         window.dispatchEvent(new HashChangeEvent('hashchange'));
@@ -918,13 +919,15 @@
     }
     if (Object.keys(tc).length) out.typeColors = tc;
 
-    // Home
+    // Home — diff against server config (not DEFAULTS) so unmodified server fields
+    // are not captured in localStorage and don't block future server updates.
+    var serverHome = window._SITE_CONFIG_ORIGINAL_HOME || {};
     var hm = {};
-    if (state.home.heroTitle !== DEFAULTS.home.heroTitle) hm.heroTitle = state.home.heroTitle;
-    if (state.home.heroSubtitle !== DEFAULTS.home.heroSubtitle) hm.heroSubtitle = state.home.heroSubtitle;
-    if (JSON.stringify(state.home.steps) !== JSON.stringify(DEFAULTS.home.steps)) hm.steps = state.home.steps;
-    if (JSON.stringify(state.home.checklist) !== JSON.stringify(DEFAULTS.home.checklist)) hm.checklist = state.home.checklist;
-    if (JSON.stringify(state.home.footerLinks) !== JSON.stringify(DEFAULTS.home.footerLinks)) hm.footerLinks = state.home.footerLinks;
+    if (state.home.heroTitle !== (serverHome.heroTitle !== undefined ? serverHome.heroTitle : DEFAULTS.home.heroTitle)) hm.heroTitle = state.home.heroTitle;
+    if (state.home.heroSubtitle !== (serverHome.heroSubtitle !== undefined ? serverHome.heroSubtitle : DEFAULTS.home.heroSubtitle)) hm.heroSubtitle = state.home.heroSubtitle;
+    if (JSON.stringify(state.home.steps) !== JSON.stringify(serverHome.steps !== undefined ? serverHome.steps : DEFAULTS.home.steps)) hm.steps = state.home.steps;
+    if (JSON.stringify(state.home.checklist) !== JSON.stringify(serverHome.checklist !== undefined ? serverHome.checklist : DEFAULTS.home.checklist)) hm.checklist = state.home.checklist;
+    if (JSON.stringify(state.home.footerLinks) !== JSON.stringify(serverHome.footerLinks !== undefined ? serverHome.footerLinks : DEFAULTS.home.footerLinks)) hm.footerLinks = state.home.footerLinks;
     if (Object.keys(hm).length) out.home = hm;
 
     // UI
@@ -1428,6 +1431,10 @@
     }
   } catch {}
 
+  // Test hooks
+  window._customizeBuildExport = buildExport;
+  window._customizeInitState = initState;
+
   // Wire up toggle button (needs DOM)
   document.addEventListener('DOMContentLoaded', () => {
     const btn = document.getElementById('customizeToggle');
diff --git a/test-frontend-helpers.js b/test-frontend-helpers.js
index e475dcd9..c464d4e8 100644
--- a/test-frontend-helpers.js
+++ b/test-frontend-helpers.js
@@ -1962,6 +1962,67 @@ console.log('\n=== customize.js: initState merge behavior ===');
   });
 }
 
+// ===== customize.js: buildExport home diff against server (#284) =====
+console.log('\n=== customize.js: buildExport home diff vs server ===');
+{
+  function makeCustomizeSandbox(serverHome, localStorageHome) {
+    const ctx = makeSandbox();
+    ctx.window.SITE_CONFIG = { home: Object.assign({}, serverHome), branding: { siteName: 'Test' } };
+    ctx.window._SITE_CONFIG_ORIGINAL_HOME = JSON.parse(JSON.stringify(serverHome));
+    if (localStorageHome) {
+      ctx.localStorage.setItem('meshcore-user-theme', JSON.stringify({ home: localStorageHome }));
+    }
+    loadInCtx(ctx, 'public/roles.js');
+    loadInCtx(ctx, 'public/customize.js');
+    return ctx;
+  }
+
+  test('buildExport does not capture unmodified server steps in export', () => {
+    // Server has custom steps; user only edits checklist
+    const serverHome = {
+      heroTitle: 'Server Hero',
+      steps: [{ title: 'S1', desc: '' }, { title: 'S2', desc: '' }],
+      checklist: [],
+      footerLinks: []
+    };
+    const ctx = makeCustomizeSandbox(serverHome, null);
+    const buildExport = ctx.window._customizeBuildExport;
+    const initState = ctx.window._customizeInitState;
+    if (!buildExport || !initState) { console.log('    SKIP: test hooks not exposed'); return; }
+    initState();
+    const exp = buildExport();
+    assert.ok(!exp.home || !exp.home.steps,
+      'server-provided steps must not appear in export when user did not change them');
+  });
+
+  test('buildExport captures steps only when user actually changed them', () => {
+    const serverHome = {
+      heroTitle: 'Server Hero',
+      steps: [{ title: 'S1', desc: '' }],
+      checklist: [],
+      footerLinks: []
+    };
+    const localHome = { steps: [{ title: 'User Step', desc: 'edited' }] };
+    const ctx = makeCustomizeSandbox(serverHome, localHome);
+    const buildExport = ctx.window._customizeBuildExport;
+    const initState = ctx.window._customizeInitState;
+    if (!buildExport || !initState) { console.log('    SKIP: test hooks not exposed'); return; }
+    initState();
+    const exp = buildExport();
+    assert.ok(exp.home && exp.home.steps,
+      'user-modified steps must appear in export');
+    assert.strictEqual(exp.home.steps[0].title, 'User Step');
+  });
+
+  test('autoSave syncs state.home to SITE_CONFIG.home', () => {
+    const customizeSource = fs.readFileSync('public/customize.js', 'utf8');
+    assert.ok(
+      customizeSource.includes('window.SITE_CONFIG.home = Object.assign({}, window._SITE_CONFIG_ORIGINAL_HOME'),
+      'autoSave must sync state.home to SITE_CONFIG.home using _SITE_CONFIG_ORIGINAL_HOME as base'
+    );
+  });
+}
+
 // ===== APP.JS: home rehydration merge =====
 console.log('\n=== app.js: home rehydration merge ===');
 {

From b7a70831638cc40dd0464024f0887e0c63346d36 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 2 Apr 2026 15:11:18 +0200
Subject: [PATCH 06/32] feat: override indicators, Saved toast, full export,
 remove manual save (#288)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

P0 items from issue #288:

- Override indicators: small ⬤ dot next to any setting that differs from
  the server's configured value (not just DEFAULTS). Badge on each tab
  showing the count of overridden settings in that section.
- "Saved!" toast: brief green pill animates in the panel after every
  autoSave, replacing the removed manual save button.
- Remove "Save as my theme" button: autoSave already handles this;
  the Export tab now shows an override count summary instead.
- Full export: Download/Copy now exports all current settings (not just
  diffs), so admins get a complete theme.json. localStorage still stores
  only user overrides.
- Per-setting reset uses server values: Reset buttons for colors/branding
  restore to server config (theme.json / config.json), not DEFAULTS.
- _serverState snapshot: computed once in initState() from DEFAULTS +
  server config (no localStorage) — single source of truth for all
  override comparisons.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/customize.js | 194 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 151 insertions(+), 43 deletions(-)

diff --git a/public/customize.js b/public/customize.js
index f87d92b2..f984a4c8 100644
--- a/public/customize.js
+++ b/public/customize.js
@@ -439,6 +439,7 @@
 
   // Current state
   let state = {};
+  let _serverState = null;
 
   function deepClone(o) { return JSON.parse(JSON.stringify(o)); }
 
@@ -474,6 +475,15 @@
     mergedUi.timestampCustomFormat = (localTsCustomFormat != null)
       ? localTsCustomFormat
       : (typeof mergedUi.timestampCustomFormat === 'string' ? mergedUi.timestampCustomFormat : serverTsCustomFormat);
+    _serverState = {
+      branding: Object.assign({}, DEFAULTS.branding, cfg.branding || {}),
+      theme: Object.assign({}, DEFAULTS.theme, cfg.theme || {}),
+      themeDark: Object.assign({}, DEFAULTS.themeDark, cfg.themeDark || {}),
+      nodeColors: Object.assign({}, DEFAULTS.nodeColors, cfg.nodeColors || {}),
+      typeColors: Object.assign({}, DEFAULTS.typeColors, cfg.typeColors || {}),
+      home: Object.assign({}, DEFAULTS.home, cfg.home || {}),
+      ui: { timestampMode: serverTsMode, timestampTimezone: serverTsTimezone, timestampFormat: serverTsFormat, timestampCustomFormat: serverTsCustomFormat },
+    };
     state = {
       branding: mergeSection('branding'),
       theme: mergeSection('theme'),
@@ -545,6 +555,7 @@
       try {
         var data = buildExport();
         localStorage.setItem('meshcore-user-theme', JSON.stringify(data));
+        showSaved();
         // Sync to SITE_CONFIG so live pages (home, branding) pick up changes
         if (window.SITE_CONFIG) {
           if (state.branding) window.SITE_CONFIG.branding = Object.assign(window.SITE_CONFIG.branding || {}, state.branding);
@@ -562,6 +573,46 @@
     }
   }
 
+  function isFieldOverridden(section, key) {
+    if (!_serverState || !_serverState[section]) return false;
+    var sv = _serverState[section][key];
+    var cv = state[section] ? state[section][key] : undefined;
+    return (typeof sv === 'object' || typeof cv === 'object')
+      ? JSON.stringify(sv) !== JSON.stringify(cv)
+      : sv !== cv;
+  }
+
+  function countSectionOverrides() {
+    var n = 0;
+    for (var s = 0; s < arguments.length; s++) {
+      var sec = arguments[s];
+      if (!_serverState || !_serverState[sec]) continue;
+      for (var k in _serverState[sec]) { if (isFieldOverridden(sec, k)) n++; }
+    }
+    return n;
+  }
+
+  function overrideDot(section, key) {
+    return isFieldOverridden(section, key)
+      ? ' <span class="cust-override-dot" title="Changed from server default">⬤</span>'
+      : '';
+  }
+
+  var _savedToastTimer = null;
+  function showSaved() {
+    if (!panelEl) return;
+    var toast = panelEl.querySelector('.cust-saved-toast');
+    if (!toast) {
+      toast = document.createElement('div');
+      toast.className = 'cust-saved-toast';
+      toast.textContent = '✓ Saved';
+      panelEl.appendChild(toast);
+    }
+    toast.classList.add('visible');
+    clearTimeout(_savedToastTimer);
+    _savedToastTimer = setTimeout(function() { toast.classList.remove('visible'); }, 1500);
+  }
+
   function esc(s) { var d = document.createElement('div'); d.textContent = s || ''; return d.innerHTML; }
   function escAttr(s) { return (s || '').replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;'); }
 
@@ -645,6 +696,14 @@
         padding: 12px 16px; margin-top: 16px; font-size: 13px; color: var(--text-muted); line-height: 1.6; }
       .cust-instructions code { background: var(--surface-2); padding: 2px 6px; border-radius: 3px; font-family: var(--mono); font-size: 12px; }
       .cust-section-title { font-size: 16px; font-weight: 600; margin: 0 0 12px; }
+      .cust-override-dot { color: var(--accent); font-size: 7px; vertical-align: super; margin-left: 3px; opacity: 0.85; }
+      .cust-tab-badge { display: inline-flex; align-items: center; justify-content: center; background: var(--accent); color: #fff; font-size: 9px; font-weight: 700; border-radius: 10px; min-width: 14px; height: 14px; padding: 0 3px; margin-left: 2px; vertical-align: middle; }
+      .cust-saved-toast { position: absolute; bottom: 16px; left: 50%; transform: translateX(-50%); background: #22c55e; color: #fff; padding: 5px 18px; border-radius: 20px; font-size: 13px; font-weight: 600; pointer-events: none; opacity: 0; transition: opacity 0.25s; box-shadow: 0 2px 8px rgba(0,0,0,0.18); white-space: nowrap; z-index: 10; }
+      .cust-saved-toast.visible { opacity: 1; }
+      .cust-field-row { display: flex; align-items: center; gap: 6px; }
+      .cust-field-row input { flex: 1; }
+      .cust-field-reset { font-size: 10px; padding: 2px 7px; border: 1px solid var(--border); border-radius: 4px; background: var(--surface-2); color: var(--text-muted); cursor: pointer; white-space: nowrap; flex-shrink: 0; }
+      .cust-field-reset:hover { background: var(--surface-3); }
       @media (max-width: 600px) {
         .cust-overlay { left: 8px; right: 8px; width: auto; top: 56px; }
         .cust-tabs { gap: 0; }
@@ -662,27 +721,39 @@
 
   function renderTabs() {
     var tabs = [
-      { id: 'branding', label: '🏷️', title: 'Branding' },
-      { id: 'theme', label: '🎨', title: 'Theme Colors' },
-      { id: 'nodes', label: '🎯', title: 'Colors' },
-      { id: 'home', label: '🏠', title: 'Home Page' },
-      { id: 'display', label: '🖥️', title: 'Display' },
-      { id: 'export', label: '📤', title: 'Export / Save' }
+      { id: 'branding', label: '🏷️', title: 'Branding', count: countSectionOverrides('branding') },
+      { id: 'theme', label: '🎨', title: 'Theme Colors', count: countSectionOverrides('theme', 'themeDark') },
+      { id: 'nodes', label: '🎯', title: 'Colors', count: countSectionOverrides('nodeColors', 'typeColors') },
+      { id: 'home', label: '🏠', title: 'Home Page', count: countSectionOverrides('home') },
+      { id: 'display', label: '🖥️', title: 'Display', count: countSectionOverrides('ui') },
+      { id: 'export', label: '📤', title: 'Export / Save', count: 0 }
     ];
     return '<div class="cust-tabs">' +
       tabs.map(function (t) {
-        return '<button class="cust-tab' + (t.id === activeTab ? ' active' : '') + '" data-tab="' + t.id + '" title="' + t.title + '">' + t.label + ' <span class="cust-tab-text">' + t.title + '</span></button>';
+        var badge = t.count > 0 ? '<span class="cust-tab-badge">' + t.count + '</span>' : '';
+        return '<button class="cust-tab' + (t.id === activeTab ? ' active' : '') + '" data-tab="' + t.id + '" title="' + t.title + '">' + t.label + badge + ' <span class="cust-tab-text">' + t.title + '</span></button>';
       }).join('') + '</div>';
   }
 
+  function brandingField(id, key, label, extra) {
+    var val = state.branding[key] || '';
+    var sval = (_serverState && _serverState.branding) ? (_serverState.branding[key] || '') : val;
+    var changed = val !== sval;
+    var resetBtn = changed ? '<button class="cust-field-reset" data-reset-branding="' + key + '">Reset</button>' : '';
+    var dot = changed ? overrideDot('branding', key) : '';
+    return '<div class="cust-field"><label for="' + id + '">' + label + dot + '</label>' +
+      '<div class="cust-field-row"><input type="text" id="' + id + '" data-key="branding.' + key + '" value="' + escAttr(val) + '"' + (extra || '') + '>' + resetBtn + '</div></div>';
+  }
+
   function renderBranding() {
     var b = state.branding;
     var logoPreview = b.logoUrl ? '<img class="cust-preview-img" src="' + escAttr(b.logoUrl) + '" alt="Logo preview" onerror="this.style.display=\'none\'">' : '';
     return '<div class="cust-panel' + (activeTab === 'branding' ? ' active' : '') + '" data-panel="branding">' +
-      '<div class="cust-field"><label for="cust-siteName">Site Name</label><input type="text" id="cust-siteName" data-key="branding.siteName" value="' + escAttr(b.siteName) + '"></div>' +
-      '<div class="cust-field"><label for="cust-tagline">Tagline</label><input type="text" id="cust-tagline" data-key="branding.tagline" value="' + escAttr(b.tagline) + '"></div>' +
-      '<div class="cust-field"><label for="cust-logoUrl">Logo URL</label><input type="text" id="cust-logoUrl" data-key="branding.logoUrl" value="' + escAttr(b.logoUrl) + '" placeholder="https://...">' + logoPreview + '</div>' +
-      '<div class="cust-field"><label for="cust-faviconUrl">Favicon URL</label><input type="text" id="cust-faviconUrl" data-key="branding.faviconUrl" value="' + escAttr(b.faviconUrl) + '" placeholder="https://..."></div>' +
+      brandingField('cust-siteName', 'siteName', 'Site Name') +
+      brandingField('cust-tagline', 'tagline', 'Tagline') +
+      brandingField('cust-logoUrl', 'logoUrl', 'Logo URL', ' placeholder="https://..."') +
+      (b.logoUrl ? '<div style="margin:-8px 0 12px">' + logoPreview + '</div>' : '') +
+      brandingField('cust-faviconUrl', 'faviconUrl', 'Favicon URL', ' placeholder="https://..."') +
     '</div>';
   }
 
@@ -726,17 +797,20 @@
     '</div>';
   }
 
-  function renderColorRow(key, val, def, dataAttr) {
+  function renderColorRow(key, val, def, dataAttr, srvDef) {
+    var baseline = (srvDef !== undefined) ? srvDef : def;
+    var changed = val !== baseline;
     var isFont = key === 'font' || key === 'mono';
+    var dot = changed ? ' <span class="cust-override-dot" title="Changed from server default">⬤</span>' : '';
     var inputHtml = isFont
       ? '<input type="text" id="cust-' + dataAttr + '-' + key + '" data-' + dataAttr + '="' + key + '" value="' + escAttr(val) + '" style="width:160px;font-size:11px;font-family:var(--mono);padding:4px 6px;border:1px solid var(--border);border-radius:4px;background:var(--input-bg);color:var(--text)">'
       : '<input type="color" id="cust-' + dataAttr + '-' + key + '" data-' + dataAttr + '="' + key + '" value="' + val + '">' +
         '<span class="cust-hex" data-hex="' + key + '">' + val + '</span>';
     return '<div class="cust-color-row">' +
-      '<div><label for="cust-' + dataAttr + '-' + key + '">' + THEME_LABELS[key] + '</label>' +
+      '<div><label for="cust-' + dataAttr + '-' + key + '">' + THEME_LABELS[key] + dot + '</label>' +
       '<div class="cust-hint">' + (THEME_HINTS[key] || '') + '</div></div>' +
       inputHtml +
-      (val !== def ? '<button class="cust-reset-btn" data-reset-theme="' + key + '">Reset</button>' : '') +
+      (changed ? '<button class="cust-reset-btn" data-reset-theme="' + key + '">Reset</button>' : '') +
     '</div>';
   }
 
@@ -745,23 +819,25 @@
     var modeLabel = dark ? '🌙 Dark Mode' : '☀️ Light Mode';
     var defs = activeDefaults();
     var current = activeTheme();
+    var themeSection = dark ? 'themeDark' : 'theme';
+    var srv = (_serverState && _serverState[themeSection]) ? _serverState[themeSection] : {};
 
     var basicRows = '';
     for (var i = 0; i < BASIC_KEYS.length; i++) {
       var key = BASIC_KEYS[i];
-      basicRows += renderColorRow(key, current[key] || defs[key] || '#000000', defs[key] || '#000000', 'theme');
+      basicRows += renderColorRow(key, current[key] || defs[key] || '#000000', defs[key] || '#000000', 'theme', srv[key] || defs[key] || '#000000');
     }
 
     var advancedRows = '';
     for (var j = 0; j < ADVANCED_KEYS.length; j++) {
       var akey = ADVANCED_KEYS[j];
-      advancedRows += renderColorRow(akey, current[akey] || defs[akey] || '#000000', defs[akey] || '#000000', 'theme');
+      advancedRows += renderColorRow(akey, current[akey] || defs[akey] || '#000000', defs[akey] || '#000000', 'theme', srv[akey] || defs[akey] || '#000000');
     }
 
     var fontRows = '';
     for (var f = 0; f < FONT_KEYS.length; f++) {
       var fkey = FONT_KEYS[f];
-      fontRows += renderColorRow(fkey, current[fkey] || defs[fkey] || '', defs[fkey] || '', 'theme');
+      fontRows += renderColorRow(fkey, current[fkey] || defs[fkey] || '', defs[fkey] || '', 'theme', srv[fkey] || defs[fkey] || '');
     }
 
     return '<div class="cust-panel' + (activeTab === 'theme' ? ' active' : '') + '" data-panel="theme">' +
@@ -780,30 +856,36 @@
   }
 
   function renderNodes() {
+    var srvNode = (_serverState && _serverState.nodeColors) ? _serverState.nodeColors : {};
+    var srvType = (_serverState && _serverState.typeColors) ? _serverState.typeColors : {};
     var rows = '';
     for (var key in NODE_LABELS) {
       var val = state.nodeColors[key];
-      var def = DEFAULTS.nodeColors[key];
+      var baseline = srvNode[key] || DEFAULTS.nodeColors[key];
+      var changed = val !== baseline;
+      var dot = changed ? ' <span class="cust-override-dot" title="Changed from server default">⬤</span>' : '';
       rows += '<div class="cust-color-row">' +
-        '<div><label for="cust-node-' + key + '">' + NODE_EMOJI[key] + ' ' + NODE_LABELS[key] + '</label>' +
+        '<div><label for="cust-node-' + key + '">' + NODE_EMOJI[key] + ' ' + NODE_LABELS[key] + dot + '</label>' +
         '<div class="cust-hint">' + (NODE_HINTS[key] || '') + '</div></div>' +
         '<input type="color" id="cust-node-' + key + '" data-node="' + key + '" value="' + val + '">' +
         '<span class="cust-node-dot" style="background:' + val + '" data-dot="' + key + '"></span>' +
         '<span class="cust-hex" data-nhex="' + key + '">' + val + '</span>' +
-        (val !== def ? '<button class="cust-reset-btn" data-reset-node="' + key + '">Reset</button>' : '') +
+        (changed ? '<button class="cust-reset-btn" data-reset-node="' + key + '">Reset</button>' : '') +
       '</div>';
     }
     var typeRows = '';
     for (var tkey in TYPE_LABELS) {
       var tval = state.typeColors[tkey];
-      var tdef = DEFAULTS.typeColors[tkey];
+      var tbaseline = srvType[tkey] || DEFAULTS.typeColors[tkey];
+      var tchanged = tval !== tbaseline;
+      var tdot = tchanged ? ' <span class="cust-override-dot" title="Changed from server default">⬤</span>' : '';
       typeRows += '<div class="cust-color-row">' +
-        '<div><label for="cust-type-' + tkey + '">' + (TYPE_EMOJI[tkey] || '') + ' ' + TYPE_LABELS[tkey] + '</label>' +
+        '<div><label for="cust-type-' + tkey + '">' + (TYPE_EMOJI[tkey] || '') + ' ' + TYPE_LABELS[tkey] + tdot + '</label>' +
         '<div class="cust-hint">' + (TYPE_HINTS[tkey] || '') + '</div></div>' +
         '<input type="color" id="cust-type-' + tkey + '" data-type-color="' + tkey + '" value="' + tval + '">' +
         '<span class="cust-node-dot" style="background:' + tval + '" data-tdot="' + tkey + '"></span>' +
         '<span class="cust-hex" data-thex="' + tkey + '">' + tval + '</span>' +
-        (tval !== tdef ? '<button class="cust-reset-btn" data-reset-type="' + tkey + '">Reset</button>' : '') +
+        (tchanged ? '<button class="cust-reset-btn" data-reset-type="' + tkey + '">Reset</button>' : '') +
       '</div>';
     }
     var heatOpacity = parseFloat(localStorage.getItem('meshcore-heatmap-opacity'));
@@ -941,14 +1023,34 @@
     return out;
   }
 
+  function buildFullExport() {
+    return {
+      branding: Object.assign({}, state.branding),
+      theme: Object.assign({}, state.theme),
+      themeDark: Object.assign({}, state.themeDark),
+      nodeColors: Object.assign({}, state.nodeColors),
+      typeColors: Object.assign({}, state.typeColors),
+      home: {
+        heroTitle: state.home.heroTitle,
+        heroSubtitle: state.home.heroSubtitle,
+        steps: deepClone(state.home.steps),
+        checklist: deepClone(state.home.checklist),
+        footerLinks: deepClone(state.home.footerLinks),
+      },
+      ui: Object.assign({}, state.ui),
+    };
+  }
+
   function renderExport() {
-    var json = JSON.stringify(buildExport(), null, 2);
+    var overrideCount = countSectionOverrides('branding', 'theme', 'themeDark', 'nodeColors', 'typeColors', 'home', 'ui');
     var hasUserTheme = !!localStorage.getItem('meshcore-user-theme');
+    var json = JSON.stringify(buildFullExport(), null, 2);
     return '<div class="cust-panel' + (activeTab === 'export' ? ' active' : '') + '" data-panel="export">' +
       '<p class="cust-section-title">My Preferences</p>' +
-      '<p style="font-size:12px;color:var(--text-muted);margin-bottom:8px">Save these colors just for you — stored in your browser, works on any instance.</p>' +
+      '<p style="font-size:12px;color:var(--text-muted);margin-bottom:8px">' +
+        (overrideCount > 0 ? '<strong>' + overrideCount + ' setting' + (overrideCount !== 1 ? 's' : '') + '</strong> changed from server defaults. ' : 'No changes from server defaults. ') +
+        'Auto-saved to your browser.</p>' +
       '<div class="cust-export-btns" style="margin-bottom:16px">' +
-        '<button class="cust-save-user" id="custSaveUser">💾 Save as my theme</button>' +
         (hasUserTheme ? '<button class="cust-reset-user" id="custResetUser">🗑️ Reset my theme</button>' : '') +
       '</div>' +
       '<hr style="border:none;border-top:1px solid var(--border);margin:16px 0">' +
@@ -1086,12 +1188,23 @@
       btn.addEventListener('click', function () {
         var key = btn.dataset.resetTheme;
         var themeKey = isDarkMode() ? 'themeDark' : 'theme';
-        state[themeKey][key] = activeDefaults()[key];
+        var srvVal = (_serverState && _serverState[themeKey]) ? _serverState[themeKey][key] : undefined;
+        state[themeKey][key] = srvVal !== undefined ? srvVal : activeDefaults()[key];
         applyThemePreview(); autoSave();
         render(container);
       });
     });
 
+    container.querySelectorAll('[data-reset-branding]').forEach(function (btn) {
+      btn.addEventListener('click', function () {
+        var key = btn.dataset.resetBranding;
+        var srvVal = (_serverState && _serverState.branding) ? _serverState.branding[key] : undefined;
+        state.branding[key] = srvVal !== undefined ? srvVal : (DEFAULTS.branding[key] || '');
+        autoSave();
+        render(container);
+      });
+    });
+
     // Reset preview button
     var resetBtn = document.getElementById('custResetPreview');
     if (resetBtn) {
@@ -1123,9 +1236,11 @@
     container.querySelectorAll('[data-reset-node]').forEach(function (btn) {
       btn.addEventListener('click', function () {
         var key = btn.dataset.resetNode;
-        state.nodeColors[key] = DEFAULTS.nodeColors[key];
-        if (window.ROLE_COLORS) window.ROLE_COLORS[key] = DEFAULTS.nodeColors[key];
-        if (window.ROLE_STYLE && window.ROLE_STYLE[key]) window.ROLE_STYLE[key].color = DEFAULTS.nodeColors[key];
+        var srvVal = (_serverState && _serverState.nodeColors) ? _serverState.nodeColors[key] : undefined;
+        var resetTo = srvVal !== undefined ? srvVal : DEFAULTS.nodeColors[key];
+        state.nodeColors[key] = resetTo;
+        if (window.ROLE_COLORS) window.ROLE_COLORS[key] = resetTo;
+        if (window.ROLE_STYLE && window.ROLE_STYLE[key]) window.ROLE_STYLE[key].color = resetTo;
         render(container);
       });
     });
@@ -1147,8 +1262,10 @@
     container.querySelectorAll('[data-reset-type]').forEach(function (btn) {
       btn.addEventListener('click', function () {
         var key = btn.dataset.resetType;
-        state.typeColors[key] = DEFAULTS.typeColors[key];
-        if (window.TYPE_COLORS) window.TYPE_COLORS[key] = DEFAULTS.typeColors[key];
+        var srvVal = (_serverState && _serverState.typeColors) ? _serverState.typeColors[key] : undefined;
+        var resetTo = srvVal !== undefined ? srvVal : DEFAULTS.typeColors[key];
+        state.typeColors[key] = resetTo;
+        if (window.TYPE_COLORS) window.TYPE_COLORS[key] = resetTo;
         render(container);
       });
     });
@@ -1270,10 +1387,10 @@
       }
     });
 
-    // Export download
+    // Export download — full export including all current settings
     var dlBtn = document.getElementById('custDownload');
     if (dlBtn) dlBtn.addEventListener('click', function () {
-      var json = JSON.stringify(buildExport(), null, 2);
+      var json = JSON.stringify(buildFullExport(), null, 2);
       var blob = new Blob([json], { type: 'application/json' });
       var a = document.createElement('a');
       a.href = URL.createObjectURL(blob);
@@ -1282,15 +1399,6 @@
       URL.revokeObjectURL(a.href);
     });
 
-    // Save user theme to localStorage
-    var saveUserBtn = document.getElementById('custSaveUser');
-    if (saveUserBtn) saveUserBtn.addEventListener('click', function () {
-      var exportData = buildExport();
-      localStorage.setItem('meshcore-user-theme', JSON.stringify(exportData));
-      saveUserBtn.textContent = '✓ Saved!';
-      setTimeout(function () { saveUserBtn.textContent = '💾 Save as my theme'; }, 2000);
-    });
-
     // Reset user theme
     var resetUserBtn = document.getElementById('custResetUser');
     if (resetUserBtn) resetUserBtn.addEventListener('click', function () {

From 8c6aa0671398d8599fc95241364c6c5ef8e39b8f Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 2 Apr 2026 15:37:38 +0200
Subject: [PATCH 07/32] fix: update override dots and tab badges in real-time
 via refreshOverrideIndicators

Dots and badges were only updated on full render() (tab switch). Now
autoSave() calls refreshOverrideIndicators() which updates tab badges
and field dots in-place without a full re-render, so indicators appear
immediately when a setting is changed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/customize.js | 69 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/public/customize.js b/public/customize.js
index f984a4c8..79f8cb27 100644
--- a/public/customize.js
+++ b/public/customize.js
@@ -556,6 +556,7 @@
         var data = buildExport();
         localStorage.setItem('meshcore-user-theme', JSON.stringify(data));
         showSaved();
+        refreshOverrideIndicators(_custInner);
         // Sync to SITE_CONFIG so live pages (home, branding) pick up changes
         if (window.SITE_CONFIG) {
           if (state.branding) window.SITE_CONFIG.branding = Object.assign(window.SITE_CONFIG.branding || {}, state.branding);
@@ -613,6 +614,72 @@
     _savedToastTimer = setTimeout(function() { toast.classList.remove('visible'); }, 1500);
   }
 
+  function refreshOverrideIndicators(container) {
+    if (!container || !_initialized || !_serverState) return;
+
+    // Update tab badges
+    var tabCounts = {
+      branding: countSectionOverrides('branding'),
+      theme: countSectionOverrides('theme', 'themeDark'),
+      nodes: countSectionOverrides('nodeColors', 'typeColors'),
+      home: countSectionOverrides('home'),
+      display: countSectionOverrides('ui'),
+      export: 0
+    };
+    container.querySelectorAll('.cust-tab').forEach(function(btn) {
+      var count = tabCounts[btn.dataset.tab] || 0;
+      var badge = btn.querySelector('.cust-tab-badge');
+      if (count > 0) {
+        if (!badge) {
+          badge = document.createElement('span');
+          badge.className = 'cust-tab-badge';
+          var tabText = btn.querySelector('.cust-tab-text');
+          btn.insertBefore(badge, tabText);
+        }
+        badge.textContent = count;
+      } else if (badge) {
+        badge.remove();
+      }
+    });
+
+    // Helper: add/remove override dot on a label element
+    function setDot(label, section, key) {
+      if (!label) return;
+      var dot = label.querySelector('.cust-override-dot');
+      if (isFieldOverridden(section, key)) {
+        if (!dot) {
+          dot = document.createElement('span');
+          dot.className = 'cust-override-dot';
+          dot.title = 'Changed from server default';
+          dot.textContent = '⬤';
+          label.appendChild(dot);
+        }
+      } else if (dot) {
+        dot.remove();
+      }
+    }
+
+    // Theme color labels
+    var themeSection = isDarkMode() ? 'themeDark' : 'theme';
+    container.querySelectorAll('input[data-theme]').forEach(function(inp) {
+      setDot(container.querySelector('label[for="cust-theme-' + inp.dataset.theme + '"]'), themeSection, inp.dataset.theme);
+    });
+    // Node color labels
+    container.querySelectorAll('input[data-node]').forEach(function(inp) {
+      setDot(container.querySelector('label[for="cust-node-' + inp.dataset.node + '"]'), 'nodeColors', inp.dataset.node);
+    });
+    // Type color labels
+    container.querySelectorAll('input[data-type-color]').forEach(function(inp) {
+      setDot(container.querySelector('label[for="cust-type-' + inp.dataset.typeColor + '"]'), 'typeColors', inp.dataset.typeColor);
+    });
+    // Branding text fields
+    container.querySelectorAll('input[data-key^="branding."]').forEach(function(inp) {
+      var key = inp.dataset.key.replace('branding.', '');
+      var label = inp.closest('.cust-field') && inp.closest('.cust-field').querySelector('label');
+      setDot(label, 'branding', key);
+    });
+  }
+
   function esc(s) { var d = document.createElement('div'); d.textContent = s || ''; return d.innerHTML; }
   function escAttr(s) { return (s || '').replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;'); }
 
@@ -1069,8 +1136,10 @@
   }
 
   let panelEl = null;
+  let _custInner = null;
 
   function render(container) {
+    _custInner = container;
     container.innerHTML =
       renderTabs() +
       '<div class="cust-body">' +

From 29d68aa107d68eb660cd54b1b0ba65fa4ac19b49 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Fri, 3 Apr 2026 10:56:19 +0200
Subject: [PATCH 08/32] fix: observer filter on grouped packets screen drops
 valid groups (#464)

When groupByHash=true, each group only carries the representative observer_id.
Client-side filter was checking only that field, silently dropping groups seen
by the selected observer but with a different representative.

Fix: pass observer param to the server so filterPackets/buildGroupedWhere do
the correct "any observation matches" check. Skip the broken client-side
observer filter in grouped mode. Extend both db and store paths to support
comma-separated observer IDs (multi-select UI).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/db.go    | 11 ++++++++---
 cmd/server/store.go | 35 +++++++++++++++++++----------------
 public/packets.js   |  3 ++-
 3 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/cmd/server/db.go b/cmd/server/db.go
index 10b64d8a..4cbb797f 100644
--- a/cmd/server/db.go
+++ b/cmd/server/db.go
@@ -608,12 +608,17 @@ func (db *DB) buildTransmissionWhere(q PacketQuery) ([]string, []interface{}) {
 		args = append(args, "%"+pk+"%")
 	}
 	if q.Observer != "" {
+		ids := strings.Split(q.Observer, ",")
+		placeholders := strings.Repeat("?,", len(ids))
+		placeholders = placeholders[:len(placeholders)-1]
 		if db.isV3 {
-			where = append(where, "EXISTS (SELECT 1 FROM observations oi JOIN observers obi ON obi.rowid = oi.observer_idx WHERE oi.transmission_id = t.id AND obi.id = ?)")
+			where = append(where, "EXISTS (SELECT 1 FROM observations oi JOIN observers obi ON obi.rowid = oi.observer_idx WHERE oi.transmission_id = t.id AND obi.id IN ("+placeholders+"))")
 		} else {
-			where = append(where, "EXISTS (SELECT 1 FROM observations oi WHERE oi.transmission_id = t.id AND oi.observer_id = ?)")
+			where = append(where, "EXISTS (SELECT 1 FROM observations oi WHERE oi.transmission_id = t.id AND oi.observer_id IN ("+placeholders+"))")
+		}
+		for _, id := range ids {
+			args = append(args, id)
 		}
-		args = append(args, q.Observer)
 	}
 	if q.Region != "" {
 		if db.isV3 {
diff --git a/cmd/server/store.go b/cmd/server/store.go
index 2192c6b7..a8dd8b0f 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -1572,32 +1572,35 @@ func (s *PacketStore) filterPackets(q PacketQuery) []*StoreTx {
 }
 
 // transmissionsForObserver returns unique transmissions for an observer.
-func (s *PacketStore) transmissionsForObserver(observerID string, from []*StoreTx) []*StoreTx {
+func (s *PacketStore) transmissionsForObserver(observerIDs string, from []*StoreTx) []*StoreTx {
+	ids := strings.Split(observerIDs, ",")
+	idSet := make(map[string]bool, len(ids))
+	for _, id := range ids {
+		idSet[id] = true
+	}
 	if from != nil {
 		return filterTxSlice(from, func(tx *StoreTx) bool {
 			for _, obs := range tx.Observations {
-				if obs.ObserverID == observerID {
+				if idSet[obs.ObserverID] {
 					return true
 				}
 			}
 			return false
 		})
 	}
-	// Use byObserver index
-	observations := s.byObserver[observerID]
-	if len(observations) == 0 {
-		return nil
-	}
-	seen := make(map[int]bool, len(observations))
+	// Use byObserver index: union transmissions for all IDs
+	seen := make(map[int]bool)
 	var result []*StoreTx
-	for _, obs := range observations {
-		if seen[obs.TransmissionID] {
-			continue
-		}
-		seen[obs.TransmissionID] = true
-		tx := s.byTxID[obs.TransmissionID]
-		if tx != nil {
-			result = append(result, tx)
+	for _, id := range ids {
+		for _, obs := range s.byObserver[id] {
+			if seen[obs.TransmissionID] {
+				continue
+			}
+			seen[obs.TransmissionID] = true
+			tx := s.byTxID[obs.TransmissionID]
+			if tx != nil {
+				result = append(result, tx)
+			}
 		}
 	}
 	return result
diff --git a/public/packets.js b/public/packets.js
index 5fccb69b..b8fab5bf 100644
--- a/public/packets.js
+++ b/public/packets.js
@@ -488,6 +488,7 @@
       if (regionParam) params.set('region', regionParam);
       if (filters.hash) params.set('hash', filters.hash);
       if (filters.node) params.set('node', filters.node);
+      if (filters.observer) params.set('observer', filters.observer);
       params.set('groupByHash', 'true'); // always fetch grouped
 
       const data = await api('/packets?' + params.toString());
@@ -1289,7 +1290,7 @@
       const types = filters.type.split(',').map(Number);
       displayPackets = displayPackets.filter(p => types.includes(p.payload_type));
     }
-    if (filters.observer) {
+    if (filters.observer && !groupByHash) {
       const obsIds = new Set(filters.observer.split(','));
       displayPackets = displayPackets.filter(p => obsIds.has(p.observer_id));
     }

From 08d1ccc9f3905397d2635bde2b9e3a540c830d4d Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Fri, 3 Apr 2026 11:24:33 +0200
Subject: [PATCH 09/32] =?UTF-8?q?fix:=20observers=20incorrectly=20showing?=
 =?UTF-8?q?=20offline=20=E2=80=94=20status=20path=20+=20clock=20skew=20(#4?=
 =?UTF-8?q?63)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two complementary fixes:

1. Ingestor (cmd/ingestor/main.go): move the status topic handler BEFORE
   the JSON parse. Previously a non-JSON or malformed status payload caused
   an early return, skipping UpsertObserver entirely and leaving last_seen
   stale. Now last_seen is always updated when a status message arrives,
   regardless of payload format.

2. Frontend (public/observers.js): replace Date.now() with a server-clock-
   corrected reference in healthStatus(). The API response already includes
   server_time; we now capture it at fetch time and use it (plus elapsed ms)
   as the reference point. This eliminates client/server clock skew from
   the online/stale/offline calculation.

Adds TestHandleMessageStatusNonJSONPayload to cover the non-JSON case.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/ingestor/main.go      | 30 ++++++++++++++++++------------
 cmd/ingestor/main_test.go | 22 ++++++++++++++++++++++
 public/observers.js       | 20 ++++++++++++++------
 3 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/cmd/ingestor/main.go b/cmd/ingestor/main.go
index 238b436d..7d95ca27 100644
--- a/cmd/ingestor/main.go
+++ b/cmd/ingestor/main.go
@@ -196,22 +196,18 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 		}
 	}
 
-	var msg map[string]interface{}
-	if err := json.Unmarshal(m.Payload(), &msg); err != nil {
-		return
-	}
-
-	// Skip status/connection topics
-	if topic == "meshcore/status" || topic == "meshcore/events/connection" {
-		return
-	}
-
 	// Status topic: meshcore/<region>/<observer_id>/status
+	// Checked BEFORE JSON parse — non-JSON or malformed payloads must still update last_seen (#463)
 	if len(parts) >= 4 && parts[3] == "status" {
 		observerID := parts[2]
-		name, _ := msg["origin"].(string)
 		iata := parts[1]
-		meta := extractObserverMeta(msg)
+		var name string
+		var meta *ObserverMeta
+		var statusMsg map[string]interface{}
+		if json.Unmarshal(m.Payload(), &statusMsg) == nil {
+			name, _ = statusMsg["origin"].(string)
+			meta = extractObserverMeta(statusMsg)
+		}
 		if err := store.UpsertObserver(observerID, name, iata, meta); err != nil {
 			log.Printf("MQTT [%s] observer status error: %v", tag, err)
 		}
@@ -219,6 +215,16 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 		return
 	}
 
+	var msg map[string]interface{}
+	if err := json.Unmarshal(m.Payload(), &msg); err != nil {
+		return
+	}
+
+	// Skip global status/connection topics
+	if topic == "meshcore/status" || topic == "meshcore/events/connection" {
+		return
+	}
+
 	// Format 1: Raw packet (meshcoretomqtt / Cisien format)
 	rawHex, _ := msg["raw"].(string)
 	if rawHex != "" {
diff --git a/cmd/ingestor/main_test.go b/cmd/ingestor/main_test.go
index 9d9cec8c..922ba637 100644
--- a/cmd/ingestor/main_test.go
+++ b/cmd/ingestor/main_test.go
@@ -201,6 +201,28 @@ func TestHandleMessageStatusTopic(t *testing.T) {
 	}
 }
 
+// #463: status messages with non-JSON payloads must still update last_seen.
+// Some firmware versions may send plain-text or binary status payloads.
+func TestHandleMessageStatusNonJSONPayload(t *testing.T) {
+	store := newTestStore(t)
+	source := MQTTSource{Name: "test"}
+	msg := &mockMessage{
+		topic:   "meshcore/SJC/obs1/status",
+		payload: []byte(`not json`),
+	}
+
+	handleMessage(store, "test", source, msg, nil, nil)
+
+	var lastSeen string
+	err := store.db.QueryRow("SELECT last_seen FROM observers WHERE id = 'obs1'").Scan(&lastSeen)
+	if err != nil {
+		t.Fatalf("observer not found after non-JSON status: %v", err)
+	}
+	if lastSeen == "" {
+		t.Error("last_seen should be set even for non-JSON status payloads")
+	}
+}
+
 func TestHandleMessageSkipStatusTopics(t *testing.T) {
 	store := newTestStore(t)
 	source := MQTTSource{Name: "test"}
diff --git a/public/observers.js b/public/observers.js
index 3619eaf7..4c2e6a40 100644
--- a/public/observers.js
+++ b/public/observers.js
@@ -6,6 +6,8 @@
   let wsHandler = null;
   let refreshTimer = null;
   let regionChangeHandler = null;
+  let _serverTimeAtFetch = null;  // server clock at last API response
+  let _clientTimeAtFetch = null;  // client clock at last API response
 
   function init(app) {
     app.innerHTML = `
@@ -57,6 +59,10 @@
     try {
       const data = await api('/observers', { ttl: CLIENT_TTL.observers });
       observers = data.observers || [];
+      if (data.server_time) {
+        _serverTimeAtFetch = new Date(data.server_time).getTime();
+        _clientTimeAtFetch = Date.now();
+      }
       render();
     } catch (e) {
       document.getElementById('obsContent').innerHTML =
@@ -64,14 +70,16 @@
     }
   }
 
-  // NOTE: Comparing server timestamps to Date.now() can skew if client/server
-  // clocks differ. We add ±30s tolerance to thresholds to reduce false positives.
+  // Use server clock as reference to eliminate client/server clock skew (#463).
+  // _serverTimeAtFetch + elapsed gives a corrected "now" in server time.
   function healthStatus(lastSeen) {
     if (!lastSeen) return { cls: 'health-red', label: 'Unknown' };
-    const ago = Date.now() - new Date(lastSeen).getTime();
-    const tolerance = 30000; // 30s tolerance for clock skew
-    if (ago < 600000 + tolerance) return { cls: 'health-green', label: 'Online' };    // < 10 min + tolerance
-    if (ago < 3600000 + tolerance) return { cls: 'health-yellow', label: 'Stale' };   // < 1 hour + tolerance
+    const serverNow = (_serverTimeAtFetch !== null)
+      ? _serverTimeAtFetch + (Date.now() - _clientTimeAtFetch)
+      : Date.now();
+    const ago = serverNow - new Date(lastSeen).getTime();
+    if (ago < 600000) return { cls: 'health-green', label: 'Online' };    // < 10 min
+    if (ago < 3600000) return { cls: 'health-yellow', label: 'Stale' };   // < 1 hour
     return { cls: 'health-red', label: 'Offline' };
   }
 

From 6e259258503dc6e8af962c2692eec74a7d32ed0b Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Sat, 4 Apr 2026 11:54:07 +0200
Subject: [PATCH 10/32] fix: use runtime heap stats for memory-based eviction
 (#563)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

estimatedMemoryMB() used a hardcoded formula (packets × 5120 + obs × 500)
that ignored distHops (1.5M records), distPaths (93K records), and spIndex
(4.1M entries). This caused the formula to report ~1.2GB while actual heap
was ~5GB, so the memory-based eviction check barely fired and the process
grew until OOM-killed.

Replace estimatedMemoryMB() with runtime.ReadMemStats so all data structures
are counted. Replace the inner eviction simulation loop (which re-used the
wrong formula) with a proportional calculation: if heap is N× over budget,
evict enough packets to keep (1/N × 0.9) of the current count, with a 10%
buffer so the next ingest cycle doesn't immediately re-trigger.

Add memoryEstimator func() float64 field to PacketStore for test injection,
so eviction tests stay deterministic without spawning goroutines or relying
on process heap size.

Addresses the "Packet store estimated memory" item in epic #559.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/eviction_test.go | 38 ++++++++++++++++----
 cmd/server/store.go         | 70 ++++++++++++++++++-------------------
 2 files changed, 67 insertions(+), 41 deletions(-)

diff --git a/cmd/server/eviction_test.go b/cmd/server/eviction_test.go
index 4bba9c0b..9cb5ace6 100644
--- a/cmd/server/eviction_test.go
+++ b/cmd/server/eviction_test.go
@@ -162,24 +162,50 @@ func TestEvictStale_NoEvictionWhenDisabled(t *testing.T) {
 
 func TestEvictStale_MemoryBasedEviction(t *testing.T) {
 	now := time.Now().UTC()
-	// Create enough packets to exceed a small memory limit
-	// 1000 packets * 5KB + 2000 obs * 500B ≈ 6MB
 	store := makeTestStore(1000, now.Add(-1*time.Hour), 0)
-	// All packets are recent (1h old) so time-based won't trigger
+	// All packets are recent (1h old) so time-based won't trigger.
 	store.retentionHours = 24
-	store.maxMemoryMB = 3 // ~3MB limit, should evict roughly half
+	store.maxMemoryMB = 3
+	// Inject deterministic estimator: simulates 6MB (over 3MB limit).
+	// Uses packet count so it scales correctly after eviction.
+	store.memoryEstimator = func() float64 {
+		return float64(len(store.packets)*5120+store.totalObs*500) / 1048576.0
+	}
 
 	evicted := store.EvictStale()
 	if evicted == 0 {
 		t.Fatal("expected some evictions for memory cap")
 	}
-	// After eviction, estimated memory should be <= 3MB
 	estMB := store.estimatedMemoryMB()
-	if estMB > 3.5 { // small tolerance
+	if estMB > 3.5 {
 		t.Fatalf("expected <=3.5MB after eviction, got %.1fMB", estMB)
 	}
 }
 
+// TestEvictStale_MemoryBasedEviction_UnderestimatedHeap verifies that eviction
+// fires correctly when actual heap is much larger than a formula-based estimate
+// would report — the scenario that caused OOM kills in production.
+func TestEvictStale_MemoryBasedEviction_UnderestimatedHeap(t *testing.T) {
+	now := time.Now().UTC()
+	store := makeTestStore(1000, now.Add(-1*time.Hour), 0)
+	store.retentionHours = 24
+	store.maxMemoryMB = 500
+	// Simulate actual heap 5x over budget (like production: ~5GB actual vs ~1GB limit).
+	store.memoryEstimator = func() float64 {
+		return 2500.0 // 2500MB actual vs 500MB limit
+	}
+
+	evicted := store.EvictStale()
+	if evicted == 0 {
+		t.Fatal("expected evictions when heap is 5x over limit")
+	}
+	// Should keep roughly 500/2500 * 0.9 = 18% of packets → ~180 of 1000.
+	remaining := len(store.packets)
+	if remaining > 250 {
+		t.Fatalf("expected most packets evicted (heap 5x over), but %d of 1000 remain", remaining)
+	}
+}
+
 func TestEvictStale_CleansNodeIndexes(t *testing.T) {
 	now := time.Now().UTC()
 	store := makeTestStore(10, now.Add(-48*time.Hour), 0)
diff --git a/cmd/server/store.go b/cmd/server/store.go
index 0c5da5eb..3a78af2b 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log"
 	"math"
+	"runtime"
 	"sort"
 	"strconv"
 	"strings"
@@ -152,9 +153,10 @@ type PacketStore struct {
 	graph *NeighborGraph
 
 	// Eviction config and stats
-	retentionHours float64 // 0 = unlimited
-	maxMemoryMB    int     // 0 = unlimited
-	evicted        int64   // total packets evicted
+	retentionHours   float64        // 0 = unlimited
+	maxMemoryMB      int            // 0 = unlimited
+	evicted          int64          // total packets evicted
+	memoryEstimator  func() float64 // injectable for tests; nil = use runtime.ReadMemStats
 }
 
 // Precomputed distance records for fast analytics aggregation.
@@ -367,9 +369,8 @@ func (s *PacketStore) Load() error {
 
 	s.loaded = true
 	elapsed := time.Since(t0)
-	estMB := (len(s.packets)*5120 + s.totalObs*500) / (1024 * 1024)
-	log.Printf("[store] Loaded %d transmissions (%d observations) in %v (~%dMB est)",
-		len(s.packets), s.totalObs, elapsed, estMB)
+	log.Printf("[store] Loaded %d transmissions (%d observations) in %v (heap ~%.0fMB)",
+		len(s.packets), s.totalObs, elapsed, s.estimatedMemoryMB())
 	return nil
 }
 
@@ -677,8 +678,7 @@ func (s *PacketStore) GetPerfStoreStats() map[string]interface{} {
 	advertByObsCount := len(s.advertPubkeys)
 	s.mu.RUnlock()
 
-	// Realistic estimate: ~5KB per packet + ~500 bytes per observation
-	estimatedMB := math.Round(float64(totalLoaded*5120+totalObs*500)/1048576*10) / 10
+	estimatedMB := math.Round(s.estimatedMemoryMB()*10) / 10
 
 	evicted := atomic.LoadInt64(&s.evicted)
 
@@ -848,7 +848,7 @@ func (s *PacketStore) GetPerfStoreStatsTyped() PerfPacketStoreStats {
 	advertByObsCount := len(s.advertPubkeys)
 	s.mu.RUnlock()
 
-	estimatedMB := math.Round(float64(totalLoaded*5120+totalObs*500)/1048576*10) / 10
+	estimatedMB := math.Round(s.estimatedMemoryMB()*10) / 10
 
 	return PerfPacketStoreStats{
 		TotalLoaded:       totalLoaded,
@@ -2046,9 +2046,17 @@ func (s *PacketStore) buildDistanceIndex() {
 		len(s.distHops), len(s.distPaths))
 }
 
-// estimatedMemoryMB returns estimated memory usage of the packet store.
+// estimatedMemoryMB returns current Go heap allocation in MB.
+// Uses runtime.ReadMemStats so it accounts for all data structures
+// (distHops, distPaths, spIndex, map overhead) not just packets/observations.
+// In tests, memoryEstimator can be set to inject a deterministic value.
 func (s *PacketStore) estimatedMemoryMB() float64 {
-	return float64(len(s.packets)*5120+s.totalObs*500) / 1048576.0
+	if s.memoryEstimator != nil {
+		return s.memoryEstimator()
+	}
+	var ms runtime.MemStats
+	runtime.ReadMemStats(&ms)
+	return float64(ms.HeapAlloc) / 1048576.0
 }
 
 // EvictStale removes packets older than the retention window and/or exceeding
@@ -2069,30 +2077,24 @@ func (s *PacketStore) EvictStale() int {
 		}
 	}
 
-	// Memory-based eviction: if still over budget, trim more from head
+	// Memory-based eviction: if heap exceeds budget, trim proportionally from head.
+	// All major data structures (distHops, distPaths, spIndex) scale with packet count,
+	// so evicting a fraction of packets frees roughly the same fraction of total heap.
+	// A 10% buffer avoids immediately re-triggering on the next ingest cycle.
 	if s.maxMemoryMB > 0 {
-		for cutoffIdx < len(s.packets) && s.estimatedMemoryMB() > float64(s.maxMemoryMB) {
-			// Estimate how many more to evict: rough binary approach
-			overMB := s.estimatedMemoryMB() - float64(s.maxMemoryMB)
-			// ~5KB per packet, so overMB * 1024*1024 / 5120 packets
-			extra := int(overMB * 1048576.0 / 5120.0)
-			if extra < 100 {
-				extra = 100
-			}
-			cutoffIdx += extra
-			if cutoffIdx > len(s.packets) {
-				cutoffIdx = len(s.packets)
+		currentMB := s.estimatedMemoryMB()
+		if currentMB > float64(s.maxMemoryMB) && len(s.packets) > 0 {
+			fractionToKeep := (float64(s.maxMemoryMB) / currentMB) * 0.9
+			keepCount := int(float64(len(s.packets)) * fractionToKeep)
+			if keepCount < 0 {
+				keepCount = 0
 			}
-			// Recalculate estimated memory with fewer packets
-			// (we haven't actually removed yet, so simulate)
-			remainingPkts := len(s.packets) - cutoffIdx
-			remainingObs := s.totalObs
-			for _, tx := range s.packets[:cutoffIdx] {
-				remainingObs -= len(tx.Observations)
+			newCutoff := len(s.packets) - keepCount
+			if newCutoff > cutoffIdx {
+				cutoffIdx = newCutoff
 			}
-			estMB := float64(remainingPkts*5120+remainingObs*500) / 1048576.0
-			if estMB <= float64(s.maxMemoryMB) {
-				break
+			if cutoffIdx > len(s.packets) {
+				cutoffIdx = len(s.packets)
 			}
 		}
 	}
@@ -2207,9 +2209,7 @@ func (s *PacketStore) EvictStale() int {
 
 	evictCount := cutoffIdx
 	atomic.AddInt64(&s.evicted, int64(evictCount))
-	freedMB := float64(evictCount*5120+evictedObs*500) / 1048576.0
-	log.Printf("[store] Evicted %d packets older than %.0fh (freed ~%.1fMB estimated)",
-		evictCount, s.retentionHours, freedMB)
+	log.Printf("[store] Evicted %d packets (%d obs)", evictCount, evictedObs)
 
 	// Eviction removes data — all caches may be affected
 	s.invalidateCachesFor(cacheInvalidation{eviction: true})

From 86791dec36c60948db0314c8de23f8b0aa20b996 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Tue, 7 Apr 2026 14:45:34 +0200
Subject: [PATCH 11/32] fix: hide hash size for zero-hop direct adverts (#649)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Direct/zero-hop adverts always use pathByte=0x00 regardless of the
node's actual hash size setting. When hashCount==0, the hash size bits
are meaningless — display them as unknown rather than "1 byte".

- packets.js: suppress Hash Size card entry and Advertised Hash Size
  field row when hashCount==0; update Path Length description to say
  "direct advert" instead of showing spurious hash_size=1
- nodes.js: skip per-advert hash size badge for zero-hop packets

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/nodes.js   | 10 ++++++----
 public/packets.js |  6 +++---
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/public/nodes.js b/public/nodes.js
index 3512a3b5..6796689b 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -548,10 +548,12 @@
               let hashSizeBadge = '';
               if (n.hash_size_inconsistent && p.payload_type === 4 && p.raw_hex) {
                 const pb = parseInt(p.raw_hex.slice(2, 4), 16);
-                const hs = ((pb >> 6) & 0x3) + 1;
-                const hsColor = hs >= 3 ? '#16a34a' : hs === 2 ? '#86efac' : '#f97316';
-                const hsFg = hs === 2 ? '#064e3b' : '#fff';
-                hashSizeBadge = ` <span class="badge" style="background:${hsColor};color:${hsFg};font-size:9px;font-family:var(--mono)">${hs}B</span>`;
+                if ((pb & 0x3F) !== 0) {
+                  const hs = ((pb >> 6) & 0x3) + 1;
+                  const hsColor = hs >= 3 ? '#16a34a' : hs === 2 ? '#86efac' : '#f97316';
+                  const hsFg = hs === 2 ? '#064e3b' : '#fff';
+                  hashSizeBadge = ` <span class="badge" style="background:${hsColor};color:${hsFg};font-size:9px;font-family:var(--mono)">${hs}B</span>`;
+                }
               }
               return `<div class="node-activity-item">
                 <span class="node-activity-time">${renderNodeTimestampHtml(p.timestamp)}</span>
diff --git a/public/packets.js b/public/packets.js
index 4bbe1359..7a611102 100644
--- a/public/packets.js
+++ b/public/packets.js
@@ -1755,7 +1755,7 @@
 
     // Parse hash size from path byte
     const rawPathByte = pkt.raw_hex ? parseInt(pkt.raw_hex.slice(2, 4), 16) : NaN;
-    const hashSize = isNaN(rawPathByte) ? null : ((rawPathByte >> 6) + 1);
+    const hashSize = (isNaN(rawPathByte) || (rawPathByte & 0x3F) === 0) ? null : ((rawPathByte >> 6) + 1);
 
     const size = pkt.raw_hex ? Math.floor(pkt.raw_hex.length / 2) : 0;
     const typeName = payloadTypeName(pkt.payload_type);
@@ -1977,7 +1977,7 @@
     const pathByte0 = parseInt(buf.slice(2, 4), 16);
     const hashSizeVal = isNaN(pathByte0) ? '?' : ((pathByte0 >> 6) + 1);
     const hashCountVal = isNaN(pathByte0) ? '?' : (pathByte0 & 0x3F);
-    rows += fieldRow(1, 'Path Length', '0x' + (buf.slice(2, 4) || '??'), `hash_size=${hashSizeVal} byte${hashSizeVal !== 1 ? 's' : ''}, hash_count=${hashCountVal}`);
+    rows += fieldRow(1, 'Path Length', '0x' + (buf.slice(2, 4) || '??'), hashCountVal === 0 ? `hash_count=0 (direct advert)` : `hash_size=${hashSizeVal} byte${hashSizeVal !== 1 ? 's' : ''}, hash_count=${hashCountVal}`);
 
     // Transport codes
     let off = 2;
@@ -2005,7 +2005,7 @@
     rows += sectionRow('Payload — ' + payloadTypeName(pkt.payload_type), 'section-payload');
 
     if (decoded.type === 'ADVERT') {
-      rows += fieldRow(1, 'Advertised Hash Size', hashSizeVal + ' byte' + (hashSizeVal !== 1 ? 's' : ''), 'From path byte 0x' + (buf.slice(2, 4) || '??') + ' — bits 7-6 = ' + (hashSizeVal - 1));
+      if (hashCountVal !== 0) rows += fieldRow(1, 'Advertised Hash Size', hashSizeVal + ' byte' + (hashSizeVal !== 1 ? 's' : ''), 'From path byte 0x' + (buf.slice(2, 4) || '??') + ' — bits 7-6 = ' + (hashSizeVal - 1));
       rows += fieldRow(off, 'Public Key (32B)', truncate(decoded.pubKey || '', 24), '');
       rows += fieldRow(off + 32, 'Timestamp (4B)', decoded.timestampISO || '', 'Unix: ' + (decoded.timestamp || ''));
       rows += fieldRow(off + 36, 'Signature (64B)', truncate(decoded.signature || '', 24), '');

From 44e889b75f83732d3021cb85d1915c24c44bd45b Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 8 Apr 2026 10:37:33 +0200
Subject: [PATCH 12/32] test: add RouteTransportDirect zero-hop cases to
 ingestor decoder tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mirror the server decoder test suite — add TestZeroHopTransportDirectHashSize
and TestZeroHopTransportDirectHashSizeWithNonZeroUpperBits to the ingestor,
closing the symmetry gap flagged in PR #653 review.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/ingestor/decoder_test.go | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/cmd/ingestor/decoder_test.go b/cmd/ingestor/decoder_test.go
index 22697525..bd2929ed 100644
--- a/cmd/ingestor/decoder_test.go
+++ b/cmd/ingestor/decoder_test.go
@@ -1602,3 +1602,29 @@ func TestDirectNonZeroHopKeepsHashSize(t *testing.T) {
 		t.Errorf("DIRECT with 1 hop: want HashSize=1, got %d", pkt.Path.HashSize)
 	}
 }
+
+func TestZeroHopTransportDirectHashSize(t *testing.T) {
+	// TRANSPORT_DIRECT (RouteType=3) + REQ (PayloadType=0) → header byte = 0x03
+	// 4 bytes transport codes + pathByte=0x00 → hash_count=0 → should get HashSize=0
+	hex := "03" + "11223344" + "00" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, nil)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("TRANSPORT_DIRECT zero-hop: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestZeroHopTransportDirectHashSizeWithNonZeroUpperBits(t *testing.T) {
+	// TRANSPORT_DIRECT (RouteType=3) + REQ (PayloadType=0) → header byte = 0x03
+	// 4 bytes transport codes + pathByte=0xC0 → hash_count=0, hash_size bits=11 → should still get HashSize=0
+	hex := "03" + "11223344" + "C0" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, nil)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("TRANSPORT_DIRECT zero-hop with hash_size bits set: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}

From 073da8c70f775be41fcfb80bc718ea5e1727bcc8 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 11:24:42 +0200
Subject: [PATCH 13/32] docs: repeater liveness design spec (#662)

---
 .../2026-04-15-repeater-liveness-design.md    | 163 ++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-04-15-repeater-liveness-design.md

diff --git a/docs/superpowers/specs/2026-04-15-repeater-liveness-design.md b/docs/superpowers/specs/2026-04-15-repeater-liveness-design.md
new file mode 100644
index 00000000..d9cde1d2
--- /dev/null
+++ b/docs/superpowers/specs/2026-04-15-repeater-liveness-design.md
@@ -0,0 +1,163 @@
+# Repeater Liveness — Design Spec
+
+**Issue:** Kpa-clawbot/CoreScope#662
+**Date:** 2026-04-15
+**Status:** Approved
+
+---
+
+## Problem
+
+CoreScope conflates two distinct repeater states into "active":
+
+| State | Adverts | In paths | Meaning |
+|---|---|---|---|
+| Relaying | Recent | Yes | Up and forwarding traffic |
+| Alive but idle | Recent | No | Up, but nothing routed through it |
+| Down | None | None | Offline |
+
+An operator cannot tell whether a repeater is healthy and carrying traffic, or healthy but not actually relaying anything.
+
+---
+
+## Scope
+
+M1 (backend relay metrics) + M2 (frontend three-state indicator). M3 (repeater dashboard) is out of scope for this implementation.
+
+---
+
+## Architecture
+
+### Data Structure (Backend)
+
+Add a parallel index to `PacketStore` in `store.go`:
+
+```go
+relayTimes map[string][]int64  // lowercase pubkey → sorted []int64 unix-millis
+```
+
+- Indexed by **full pubkeys only** (from `tx.ResolvedPath`) — not raw hop prefixes, avoiding hash-collision noise
+- Maintained under the existing `s.mu` RWMutex — no new lock needed
+- Lives parallel to `byPathHop`, sharing the same add/remove call sites
+
+### Index Maintenance
+
+**On add** — called from `addTxToPathHopIndex`:
+- For each non-nil entry in `tx.ResolvedPath`
+- Parse `tx.FirstSeen` → unix millis
+- Binary-search insert into sorted slice
+
+**On remove** — called from `removeTxFromPathHopIndex`:
+- For each non-nil entry in `tx.ResolvedPath`
+- Remove the millis value from the sorted slice
+
+**On build** — called from `buildPathHopIndex`:
+- Populate `relayTimes` in the same pass
+
+### Query (O(log n))
+
+```go
+now := time.Now().UnixMilli()
+times := s.relayTimes[lowerPK]
+count1h  := len(times) - sort.Search(len(times), func(i int) bool { return times[i] >= now-3600000 })
+count24h := len(times) - sort.Search(len(times), func(i int) bool { return times[i] >= now-86400000 })
+lastRelayed := times[len(times)-1]  // free — last element of sorted slice
+```
+
+---
+
+## API
+
+No new endpoints. Relay metrics are added to existing health responses.
+
+### `GET /api/nodes/bulk-health` and `GET /api/nodes/{pubkey}/health`
+
+Added to the `stats` sub-object, **repeater nodes only** (fields absent for other roles):
+
+```json
+{
+  "stats": {
+    "lastHeard": "2026-04-15T10:00:00Z",
+    "packetsToday": 12,
+    "relay_count_1h": 3,
+    "relay_count_24h": 47,
+    "last_relayed": "2026-04-15T09:58:00Z"
+  }
+}
+```
+
+`last_relayed` is an RFC3339 string (consistent with existing timestamp fields). Omitted when `relayTimes[pk]` is empty.
+
+---
+
+## Frontend
+
+### `roles.js` — extend `getNodeStatus`
+
+```js
+// Signature change:
+// Before: getNodeStatus(role, lastSeenMs) → 'active' | 'stale'
+// After:  getNodeStatus(role, lastSeenMs, relayCount24h) → 'relaying' | 'active' | 'stale'
+```
+
+Logic:
+- Non-repeaters: `relayCount24h` ignored, returns `'active'` or `'stale'` as before — **no behaviour change**
+- Repeaters:
+  - Stale threshold exceeded → `'stale'`
+  - Within threshold + `relayCount24h > 0` → `'relaying'`
+  - Within threshold + `relayCount24h == 0` → `'active'` (alive but idle)
+
+### `nodes.js` — `getStatusInfo` and render
+
+- Extract `relay_count_24h`, `relay_count_1h`, `last_relayed` from `n.stats`
+- Pass `relay_count_24h` into `getNodeStatus`
+
+**Status labels (repeaters):**
+
+| Status | Label | Explanation |
+|---|---|---|
+| `'relaying'` | `🟢 Relaying` | `"Relayed N packets in last 24h, last X ago"` |
+| `'active'` | `🟡 Idle` | `"Alive but no relay traffic in 24h"` |
+| `'stale'` | `⚪ Stale` | existing text |
+
+**Non-repeaters:** labels unchanged (`🟢 Active` / `⚪ Stale`).
+
+**Node detail pane:** relay stats row added to the stats table for repeaters:
+- `Relay (1h)` / `Relay (24h)` / `Last Relayed`
+- Row hidden for non-repeater roles
+
+**Status filter buttons:** `'relaying'` maps to the `active` bucket — filter UI unchanged.
+
+---
+
+## Testing
+
+### Backend (Go) — new test cases in `store_test.go` or dedicated file
+
+- `addTxToRelayTimeIndex`: insert packets with known timestamps → verify sorted order
+- Count at 1h/24h boundaries: packets straddling the window edge → correct counts
+- `removeFromRelayTimeIndex`: add then remove → slice returns to original state
+- `GetBulkHealth` relay fields: repeater with relay activity → fields present; companion → fields absent
+- Eviction: add packets, evict oldest → relay_count_24h drops correctly
+- `last_relayed`: equals timestamp of most recently relayed packet
+- Empty `relayTimes`: no panic, fields omitted from response
+- Node with no pubkeys in `ResolvedPath`: `relayTimes` unchanged (raw hops ignored)
+
+### Frontend (Node.js) — `test-repeater-liveness.js`
+
+- `getNodeStatus('repeater', recentMs, 5)` → `'relaying'`
+- `getNodeStatus('repeater', recentMs, 0)` → `'active'`
+- `getNodeStatus('repeater', staleMs, 5)` → `'stale'`
+- `getNodeStatus('companion', recentMs, 0)` → `'active'` (no three-state for non-repeaters)
+- `getNodeStatus('companion', recentMs, 99)` → `'active'` (relay count ignored for non-repeaters)
+- Status label: `'relaying'` → `🟢 Relaying`
+- Status label: `'active'` on repeater → `🟡 Idle`
+
+---
+
+## Limitations
+
+1. **Observer coverage gaps**: if no observer hears traffic through a repeater, relay activity won't be recorded even if the repeater is relaying. Inherent to passive observation.
+2. **Low-traffic networks**: zero relay activity ≠ broken. The "Idle" label must be clearly worded.
+3. **Hash collisions**: mitigated by indexing full pubkeys only (resolved path), not raw hop prefixes.
+4. **Memory**: `relayTimes` adds one `int64` per relay event per node. Bounded by store packet limit — acceptable.

From 770eae6a40c1b904cfeffb618b772052470d6d07 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 11:31:49 +0200
Subject: [PATCH 14/32] docs: repeater liveness implementation plan (#662)

---
 .../plans/2026-04-15-repeater-liveness.md     | 1059 +++++++++++++++++
 1 file changed, 1059 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-04-15-repeater-liveness.md

diff --git a/docs/superpowers/plans/2026-04-15-repeater-liveness.md b/docs/superpowers/plans/2026-04-15-repeater-liveness.md
new file mode 100644
index 00000000..53badc61
--- /dev/null
+++ b/docs/superpowers/plans/2026-04-15-repeater-liveness.md
@@ -0,0 +1,1059 @@
+# Repeater Liveness Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Distinguish repeaters that are actively relaying traffic from those that are alive but idle, using a precomputed O(log n) sorted-timestamp index.
+
+**Architecture:** Add `relayTimes map[string][]int64` to `PacketStore`, maintained in lockstep with `byPathHop`. Relay counts for 1h/24h windows are computed via binary search at query time and injected into the existing `/api/nodes/bulk-health` and `/api/nodes/{pubkey}/health` responses. Frontend extends `getNodeStatus` to return a third state (`'relaying'`) for repeaters with recent relay activity.
+
+**Tech Stack:** Go (backend), vanilla JS (frontend), Node.js (frontend tests), SQLite (no schema changes needed)
+
+---
+
+## File Map
+
+| File | Action | What changes |
+|---|---|---|
+| `cmd/server/store.go` | Modify | Add `relayTimes` field; add `addTxToRelayTimeIndex`, `removeFromRelayTimeIndex`, `relayMetrics` functions; wire into `buildPathHopIndex`, `addTxToPathHopIndex`, `removeTxFromPathHopIndex`; enrich `GetBulkHealth` and `GetNodeHealth` |
+| `cmd/server/relay_liveness_test.go` | Create | Go unit + integration tests for all relay index functions and API enrichment |
+| `public/roles.js` | Modify | Extend `getNodeStatus` with optional third param `relayCount24h`; add `'relaying'` return value |
+| `public/nodes.js` | Modify | Update `getStatusInfo`, `getStatusTooltip`, node list row, node detail pane stats table |
+| `public/style.css` | Modify | Add `.last-seen-idle` CSS class |
+| `test-repeater-liveness.js` | Create | Frontend unit tests for the three-state logic |
+
+---
+
+## Task 1: Backend — `relayTimes` index field and pure functions
+
+**Files:**
+- Modify: `cmd/server/store.go`
+- Create: `cmd/server/relay_liveness_test.go`
+
+- [ ] **Step 1: Write failing tests for the pure index functions**
+
+Create `cmd/server/relay_liveness_test.go`:
+
+```go
+package main
+
+import (
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func makeRp(s string) *string { return &s }
+
+func TestAddTxToRelayTimeIndex_SingleNode(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	ts := time.Now().Add(-30 * time.Minute).UTC()
+	tx := &StoreTx{
+		FirstSeen:    ts.Format(time.RFC3339),
+		ResolvedPath: []*string{makeRp(pk)},
+	}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk]) != 1 {
+		t.Fatalf("expected 1 entry, got %d", len(idx[pk]))
+	}
+	wantMs := ts.UnixMilli()
+	// RFC3339 has second precision, so allow ±1000ms
+	if diff := idx[pk][0] - wantMs; diff < -1000 || diff > 1000 {
+		t.Errorf("timestamp mismatch: got %d, want ~%d", idx[pk][0], wantMs)
+	}
+}
+
+func TestAddTxToRelayTimeIndex_SortedOrder(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	t1 := time.Now().Add(-2 * time.Hour).UTC()
+	t2 := time.Now().Add(-30 * time.Minute).UTC()
+
+	// Insert newer first, expect sorted ascending
+	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+	addTxToRelayTimeIndex(idx, tx2)
+	addTxToRelayTimeIndex(idx, tx1)
+
+	if len(idx[pk]) != 2 {
+		t.Fatalf("expected 2 entries, got %d", len(idx[pk]))
+	}
+	if !sort.SliceIsSorted(idx[pk], func(i, j int) bool { return idx[pk][i] < idx[pk][j] }) {
+		t.Error("relayTimes slice not sorted ascending")
+	}
+}
+
+func TestAddTxToRelayTimeIndex_MultipleNodes(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk1 := "aabbccdd11223344"
+	pk2 := "eeff001122334455"
+	ts := time.Now().Add(-10 * time.Minute).UTC()
+	tx := &StoreTx{
+		FirstSeen:    ts.Format(time.RFC3339),
+		ResolvedPath: []*string{makeRp(pk1), makeRp(pk2)},
+	}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk1]) != 1 {
+		t.Errorf("pk1: expected 1 entry, got %d", len(idx[pk1]))
+	}
+	if len(idx[pk2]) != 1 {
+		t.Errorf("pk2: expected 1 entry, got %d", len(idx[pk2]))
+	}
+}
+
+func TestAddTxToRelayTimeIndex_NilResolvedPath(t *testing.T) {
+	idx := make(map[string][]int64)
+	tx := &StoreTx{FirstSeen: time.Now().UTC().Format(time.RFC3339), ResolvedPath: nil}
+	addTxToRelayTimeIndex(idx, tx) // must not panic
+	if len(idx) != 0 {
+		t.Error("expected empty index for nil ResolvedPath")
+	}
+}
+
+func TestAddTxToRelayTimeIndex_DuplicatePubkeyInPath(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	ts := time.Now().UTC()
+	tx := &StoreTx{
+		FirstSeen:    ts.Format(time.RFC3339),
+		ResolvedPath: []*string{makeRp(pk), makeRp(pk)}, // same pubkey twice
+	}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk]) != 1 {
+		t.Errorf("duplicate pubkey should produce only 1 entry, got %d", len(idx[pk]))
+	}
+}
+
+func TestRemoveFromRelayTimeIndex_RemovesEntry(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	ts := time.Now().Add(-1 * time.Hour).UTC()
+	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk]) != 1 {
+		t.Fatal("setup: expected 1 entry")
+	}
+	removeFromRelayTimeIndex(idx, tx)
+	if _, ok := idx[pk]; ok {
+		t.Error("expected key deleted after last entry removed")
+	}
+}
+
+func TestRemoveFromRelayTimeIndex_PartialRemove(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	t1 := time.Now().Add(-2 * time.Hour).UTC()
+	t2 := time.Now().Add(-30 * time.Minute).UTC()
+	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+
+	addTxToRelayTimeIndex(idx, tx1)
+	addTxToRelayTimeIndex(idx, tx2)
+	removeFromRelayTimeIndex(idx, tx1)
+
+	if len(idx[pk]) != 1 {
+		t.Errorf("expected 1 entry after removing one, got %d", len(idx[pk]))
+	}
+}
+
+func TestRelayMetrics_Counts(t *testing.T) {
+	now := time.Now().UnixMilli()
+	times := []int64{
+		now - 90*60*1000, // 90 min ago — inside 24h, outside 1h
+		now - 30*60*1000, // 30 min ago — inside both
+		now - 10*60*1000, // 10 min ago — inside both
+	}
+	c1h, c24h, lastRelayed := relayMetrics(times, now)
+	if c1h != 2 {
+		t.Errorf("relay_count_1h: expected 2, got %d", c1h)
+	}
+	if c24h != 3 {
+		t.Errorf("relay_count_24h: expected 3, got %d", c24h)
+	}
+	if lastRelayed == "" {
+		t.Error("last_relayed should not be empty")
+	}
+}
+
+func TestRelayMetrics_EmptySlice(t *testing.T) {
+	c1h, c24h, lastRelayed := relayMetrics(nil, time.Now().UnixMilli())
+	if c1h != 0 || c24h != 0 || lastRelayed != "" {
+		t.Errorf("empty slice: expected zeros and empty string, got %d %d %q", c1h, c24h, lastRelayed)
+	}
+}
+
+func TestRelayMetrics_AllOutsideWindow(t *testing.T) {
+	now := time.Now().UnixMilli()
+	times := []int64{now - 30*24*60*60*1000} // 30 days ago
+	c1h, c24h, _ := relayMetrics(times, now)
+	if c1h != 0 || c24h != 0 {
+		t.Errorf("expected 0/0 for old entry, got %d/%d", c1h, c24h)
+	}
+}
+
+func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
+	idx := make(map[string][]int64)
+	pkUpper := "AABBCCDD11223344"
+	pkLower := strings.ToLower(pkUpper)
+	ts := time.Now().UTC()
+	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pkUpper)}}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pkLower]) != 1 {
+		t.Errorf("expected index keyed by lowercase, found %d entries at lowercase key", len(idx[pkLower]))
+	}
+	if len(idx[pkUpper]) != 0 {
+		t.Errorf("expected no entry at uppercase key")
+	}
+}
+```
+
+- [ ] **Step 2: Run tests to confirm they all fail**
+
+```bash
+cd cmd/server && go test -run "TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics" ./... 2>&1
+```
+
+Expected: compile error — `addTxToRelayTimeIndex`, `removeFromRelayTimeIndex`, `relayMetrics` undefined.
+
+- [ ] **Step 3: Add `relayTimes` field to `PacketStore` struct**
+
+In `cmd/server/store.go`, find the struct field block around line 134 that has `byPathHop`:
+
+```go
+byPathHop     map[string][]*StoreTx      // lowercase hop/pubkey → transmissions with that hop in path
+```
+
+Add after it:
+
+```go
+relayTimes    map[string][]int64         // lowercase pubkey → sorted unix-millis of relay events (full pubkeys only)
+```
+
+- [ ] **Step 4: Initialize `relayTimes` in `newPacketStore`**
+
+Find the block around line 289 that initializes `byPathHop`:
+
+```go
+byPathHop:     make(map[string][]*StoreTx),
+```
+
+Add after it:
+
+```go
+relayTimes:    make(map[string][]int64),
+```
+
+- [ ] **Step 5: Implement `addTxToRelayTimeIndex`, `removeFromRelayTimeIndex`, `relayMetrics`**
+
+Add these three functions to `cmd/server/store.go` directly after the `addTxToPathHopIndex` function (around line 2452):
+
+```go
+// addTxToRelayTimeIndex records the relay timestamp for each full pubkey in
+// tx.ResolvedPath. Maintains sorted ascending order for O(log n) window queries.
+// Must be called with s.mu held (or during build before store is live).
+func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
+	if len(tx.ResolvedPath) == 0 {
+		return
+	}
+	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
+	if err != nil {
+		return
+	}
+	millis := ms.UnixMilli()
+	seen := make(map[string]bool, len(tx.ResolvedPath))
+	for _, rp := range tx.ResolvedPath {
+		if rp == nil {
+			continue
+		}
+		pk := strings.ToLower(*rp)
+		if seen[pk] {
+			continue
+		}
+		seen[pk] = true
+		slice := idx[pk]
+		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
+		slice = append(slice, 0)
+		copy(slice[i+1:], slice[i:])
+		slice[i] = millis
+		idx[pk] = slice
+	}
+}
+
+// removeFromRelayTimeIndex removes the relay timestamp for each full pubkey in
+// tx.ResolvedPath. Inverse of addTxToRelayTimeIndex.
+func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
+	if len(tx.ResolvedPath) == 0 {
+		return
+	}
+	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
+	if err != nil {
+		return
+	}
+	millis := ms.UnixMilli()
+	seen := make(map[string]bool, len(tx.ResolvedPath))
+	for _, rp := range tx.ResolvedPath {
+		if rp == nil {
+			continue
+		}
+		pk := strings.ToLower(*rp)
+		if seen[pk] {
+			continue
+		}
+		seen[pk] = true
+		slice := idx[pk]
+		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
+		if i < len(slice) && slice[i] == millis {
+			idx[pk] = append(slice[:i], slice[i+1:]...)
+			if len(idx[pk]) == 0 {
+				delete(idx, pk)
+			}
+		}
+	}
+}
+
+// relayMetrics computes relay_count_1h, relay_count_24h, and last_relayed from a
+// sorted unix-millis slice. now is time.Now().UnixMilli(). O(log n).
+func relayMetrics(times []int64, now int64) (count1h, count24h int, lastRelayed string) {
+	if len(times) == 0 {
+		return 0, 0, ""
+	}
+	i1h := sort.Search(len(times), func(i int) bool { return times[i] >= now-3600000 })
+	i24h := sort.Search(len(times), func(i int) bool { return times[i] >= now-86400000 })
+	count1h = len(times) - i1h
+	count24h = len(times) - i24h
+	lastRelayed = time.UnixMilli(times[len(times)-1]).UTC().Format(time.RFC3339)
+	return
+}
+```
+
+- [ ] **Step 6: Run tests — expect pass**
+
+```bash
+cd cmd/server && go test -run "TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics" ./... -v 2>&1
+```
+
+Expected: all 10 tests PASS.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add cmd/server/store.go cmd/server/relay_liveness_test.go
+git commit -m "feat(store): add relayTimes index and relay metrics functions (#662)"
+```
+
+---
+
+## Task 2: Backend — wire `relayTimes` into ingest/evict/build paths
+
+**Files:**
+- Modify: `cmd/server/store.go`
+
+- [ ] **Step 1: Wire into `addTxToPathHopIndex`**
+
+Find the function `addTxToPathHopIndex` (around line 2432). It ends with the closing `}`. Add a call to `addTxToRelayTimeIndex` — but `addTxToPathHopIndex` takes `idx map[string][]*StoreTx`, not the store itself. The relay index needs to be passed separately.
+
+The three call sites of `addTxToPathHopIndex` all hold `s.mu`. Change each call site instead of the function signature — add a paired call right after each `addTxToPathHopIndex`:
+
+**Site 1** — ingest (around line 1485):
+```go
+addTxToPathHopIndex(s.byPathHop, tx)
+addTxToRelayTimeIndex(s.relayTimes, tx)
+```
+
+**Site 2** — path resolution update (around line 1871):
+```go
+addTxToPathHopIndex(s.byPathHop, tx)
+addTxToRelayTimeIndex(s.relayTimes, tx)
+```
+
+- [ ] **Step 2: Wire into `removeTxFromPathHopIndex` call sites**
+
+Find `removeTxFromPathHopIndex(s.byPathHop, tx)` (two call sites — eviction around line 2793 and path-reindex around line 1862). Add paired remove call after each:
+
+**Site 1** — eviction (around line 2793):
+```go
+removeTxFromPathHopIndex(s.byPathHop, tx)
+removeFromRelayTimeIndex(s.relayTimes, tx)
+```
+
+**Site 2** — path reindex (around line 1862):
+```go
+removeTxFromPathHopIndex(s.byPathHop, tx)
+removeFromRelayTimeIndex(s.relayTimes, tx)
+```
+
+- [ ] **Step 3: Wire into `buildPathHopIndex`**
+
+Find `buildPathHopIndex` (around line 2422). It currently does:
+
+```go
+func (s *PacketStore) buildPathHopIndex() {
+	s.byPathHop = make(map[string][]*StoreTx, 4096)
+	for _, tx := range s.packets {
+		addTxToPathHopIndex(s.byPathHop, tx)
+	}
+	log.Printf("[store] Built path-hop index: %d unique keys", len(s.byPathHop))
+}
+```
+
+Replace with:
+
+```go
+func (s *PacketStore) buildPathHopIndex() {
+	s.byPathHop = make(map[string][]*StoreTx, 4096)
+	s.relayTimes = make(map[string][]int64, 4096)
+	for _, tx := range s.packets {
+		addTxToPathHopIndex(s.byPathHop, tx)
+		addTxToRelayTimeIndex(s.relayTimes, tx)
+	}
+	log.Printf("[store] Built path-hop index: %d unique keys, %d relay-time keys", len(s.byPathHop), len(s.relayTimes))
+}
+```
+
+- [ ] **Step 4: Write integration test for wired ingest**
+
+Add to `cmd/server/relay_liveness_test.go`:
+
+```go
+func TestRelayTimesWiredIntoIngest(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	srv.store.mu.RLock()
+	hopKeys := len(srv.store.byPathHop)
+	relayKeys := len(srv.store.relayTimes)
+	srv.store.mu.RUnlock()
+
+	if hopKeys == 0 {
+		t.Skip("no path-hop data in test store — skipping relay wiring test")
+	}
+	// relayTimes will only be populated if test packets have ResolvedPath entries.
+	// At minimum it must not panic and must be initialised.
+	if srv.store.relayTimes == nil {
+		t.Fatal("relayTimes map is nil after load")
+	}
+	t.Logf("byPathHop keys: %d, relayTimes keys: %d", hopKeys, relayKeys)
+}
+```
+
+- [ ] **Step 5: Run all relay tests**
+
+```bash
+cd cmd/server && go test -run "TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics|TestRelayTimesWired" ./... -v 2>&1
+```
+
+Expected: all pass.
+
+- [ ] **Step 6: Run full backend test suite**
+
+```bash
+cd cmd/server && go test ./... 2>&1
+```
+
+Expected: no regressions.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add cmd/server/store.go cmd/server/relay_liveness_test.go
+git commit -m "feat(store): wire relayTimes into ingest, evict, and build paths (#662)"
+```
+
+---
+
+## Task 3: Backend API — enrich bulk-health and node-health with relay metrics
+
+**Files:**
+- Modify: `cmd/server/store.go`
+
+- [ ] **Step 1: Write failing tests for relay fields in API responses**
+
+Add to `cmd/server/relay_liveness_test.go`:
+
+```go
+func TestGetBulkHealthRepeaterRelayFields(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	// Insert a synthetic repeater node into the DB if none exists
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('relay662test0001', 'TestRepeater662', 'repeater', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	// Inject a relay timestamp within the last hour
+	pk := "relay662test0001"
+	now := time.Now().UnixMilli()
+	recentMs := now - 10*60*1000 // 10 min ago
+	srv.store.mu.Lock()
+	srv.store.relayTimes[pk] = []int64{recentMs}
+	srv.store.mu.Unlock()
+
+	results := srv.store.GetBulkHealth(200, "")
+
+	var found map[string]interface{}
+	for _, r := range results {
+		if r["public_key"] == pk {
+			found = r
+			break
+		}
+	}
+	if found == nil {
+		t.Fatal("test repeater not found in GetBulkHealth results")
+	}
+
+	stats, ok := found["stats"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing stats map in result")
+	}
+
+	if v, ok := stats["relay_count_1h"].(int); !ok || v != 1 {
+		t.Errorf("relay_count_1h: expected 1, got %v", stats["relay_count_1h"])
+	}
+	if v, ok := stats["relay_count_24h"].(int); !ok || v != 1 {
+		t.Errorf("relay_count_24h: expected 1, got %v", stats["relay_count_24h"])
+	}
+	if _, ok := stats["last_relayed"].(string); !ok {
+		t.Errorf("last_relayed: expected string, got %T", stats["last_relayed"])
+	}
+}
+
+func TestGetBulkHealthCompanionNoRelayFields(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('comp662test0001', 'TestCompanion662', 'companion', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	// Give the companion a relay entry (should be ignored by role gate)
+	pk := "comp662test0001"
+	srv.store.mu.Lock()
+	srv.store.relayTimes[pk] = []int64{time.Now().UnixMilli() - 5*60*1000}
+	srv.store.mu.Unlock()
+
+	results := srv.store.GetBulkHealth(200, "")
+	for _, r := range results {
+		if r["public_key"] == pk {
+			stats, _ := r["stats"].(map[string]interface{})
+			if _, present := stats["relay_count_24h"]; present {
+				t.Error("relay_count_24h should be absent for companion nodes")
+			}
+			return
+		}
+	}
+	t.Fatal("test companion not found in GetBulkHealth results")
+}
+
+func TestGetBulkHealthRepeaterNoRelayActivity(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('relay662idle001', 'IdleRepeater662', 'repeater', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	// No entry in relayTimes for this node
+	results := srv.store.GetBulkHealth(200, "")
+	for _, r := range results {
+		if r["public_key"] == "relay662idle001" {
+			stats, _ := r["stats"].(map[string]interface{})
+			if v, ok := stats["relay_count_24h"].(int); !ok || v != 0 {
+				t.Errorf("relay_count_24h: expected 0, got %v", stats["relay_count_24h"])
+			}
+			if _, present := stats["last_relayed"]; present {
+				t.Error("last_relayed should be absent when no relay activity")
+			}
+			return
+		}
+	}
+	t.Fatal("idle repeater not found in results")
+}
+```
+
+- [ ] **Step 2: Run tests to confirm they fail**
+
+```bash
+cd cmd/server && go test -run "TestGetBulkHealth" ./... 2>&1
+```
+
+Expected: FAIL — relay fields missing from stats map.
+
+- [ ] **Step 3: Enrich `GetBulkHealth` with relay metrics**
+
+In `GetBulkHealth` (around line 5945), find where the `stats` map is built (around line 6099–6106):
+
+```go
+results = append(results, map[string]interface{}{
+    "public_key": n.pk,
+    "name":       nilIfEmpty(n.name),
+    "role":       nilIfEmpty(n.role),
+    "lat":        n.lat,
+    "lon":        n.lon,
+    "stats": map[string]interface{}{
+        "totalTransmissions": len(packets),
+        "totalObservations":  totalObservations,
+        "totalPackets":       len(packets),
+        "packetsToday":       packetsToday,
+        "avgSnr":             avgSnr,
+        "lastHeard":          lhVal,
+    },
+    "observers": observerRows,
+})
+```
+
+Replace the `stats` map construction with:
+
+```go
+statsMap := map[string]interface{}{
+    "totalTransmissions": len(packets),
+    "totalObservations":  totalObservations,
+    "totalPackets":       len(packets),
+    "packetsToday":       packetsToday,
+    "avgSnr":             avgSnr,
+    "lastHeard":          lhVal,
+}
+if strings.ToLower(n.role) == "repeater" {
+    c1h, c24h, lastRel := relayMetrics(s.relayTimes[n.pk], time.Now().UnixMilli())
+    statsMap["relay_count_1h"] = c1h
+    statsMap["relay_count_24h"] = c24h
+    if lastRel != "" {
+        statsMap["last_relayed"] = lastRel
+    }
+}
+results = append(results, map[string]interface{}{
+    "public_key": n.pk,
+    "name":       nilIfEmpty(n.name),
+    "role":       nilIfEmpty(n.role),
+    "lat":        n.lat,
+    "lon":        n.lon,
+    "stats":      statsMap,
+    "observers":  observerRows,
+})
+```
+
+- [ ] **Step 4: Enrich `GetNodeHealth` with relay metrics**
+
+In `GetNodeHealth` (around line 6117), find where the final result map is assembled (look for `"lastHeard"` key in the stats sub-map — it's around line 6230–6260 depending on exact file state). The stats map will have a shape like:
+
+```go
+"stats": map[string]interface{}{
+    "totalTransmissions": ...,
+    "totalObservations":  ...,
+    "totalPackets":       ...,
+    "packetsToday":       ...,
+    "avgSnr":             ...,
+    "lastHeard":          lastHeardVal,
+    "avgHops":            ...,
+},
+```
+
+After assembling that `stats` map (name it `nodeStats` if it isn't already named), add before the final `return`:
+
+```go
+role := ""
+if r, ok := node["role"].(string); ok {
+    role = strings.ToLower(r)
+}
+if role == "repeater" {
+    lowerPK := strings.ToLower(pubkey)
+    c1h, c24h, lastRel := relayMetrics(s.relayTimes[lowerPK], time.Now().UnixMilli())
+    nodeStats["relay_count_1h"] = c1h
+    nodeStats["relay_count_24h"] = c24h
+    if lastRel != "" {
+        nodeStats["last_relayed"] = lastRel
+    }
+}
+```
+
+> Note: `GetNodeHealth` releases `s.mu` via `defer s.mu.RUnlock()` at entry — relay metrics are computed inside the lock, which is correct.
+
+- [ ] **Step 5: Run all relay tests**
+
+```bash
+cd cmd/server && go test -run "TestGetBulkHealth|TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics|TestRelayTimesWired" ./... -v 2>&1
+```
+
+Expected: all pass.
+
+- [ ] **Step 6: Run full backend test suite**
+
+```bash
+cd cmd/server && go test ./... 2>&1
+```
+
+Expected: no regressions.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add cmd/server/store.go cmd/server/relay_liveness_test.go
+git commit -m "feat(api): add relay_count_1h/24h/last_relayed to node health responses (#662)"
+```
+
+---
+
+## Task 4: Frontend — extend `getNodeStatus` to three-state (TDD)
+
+**Files:**
+- Modify: `public/roles.js`
+- Create: `test-repeater-liveness.js`
+
+- [ ] **Step 1: Write the failing frontend test file**
+
+Create `test-repeater-liveness.js` at the repo root:
+
+```js
+'use strict';
+const vm = require('vm');
+const fs = require('fs');
+
+// Minimal browser environment
+const ctx = {
+  window: {},
+  console,
+  fetch: () => Promise.resolve({ json: () => Promise.resolve({}) }),
+  Date,
+};
+vm.createContext(ctx);
+vm.runInContext(fs.readFileSync('public/roles.js', 'utf8'), ctx);
+
+const { getNodeStatus, HEALTH_THRESHOLDS } = ctx.window;
+
+let pass = 0, fail = 0;
+function test(name, fn) {
+  try { fn(); pass++; console.log('  ok:', name); }
+  catch (e) { fail++; console.log('FAIL:', name, '—', e.message); }
+}
+function assert(cond, msg) { if (!cond) throw new Error(msg || 'assertion failed'); }
+
+const now = Date.now();
+const recentMs = now - 1000;                                     // 1 second ago — always active
+const staleMs  = now - (HEALTH_THRESHOLDS.infraSilentMs + 1);   // just past silent threshold
+
+// --- Repeater three-state ---
+test('repeater + recent + relay > 0 → relaying',
+  () => assert(getNodeStatus('repeater', recentMs, 5) === 'relaying'));
+
+test('repeater + recent + relay == 0 → active (idle)',
+  () => assert(getNodeStatus('repeater', recentMs, 0) === 'active'));
+
+test('repeater + stale + relay > 0 → stale (stale beats relay)',
+  () => assert(getNodeStatus('repeater', staleMs, 99) === 'stale'));
+
+test('repeater + stale + relay == 0 → stale',
+  () => assert(getNodeStatus('repeater', staleMs, 0) === 'stale'));
+
+// --- Non-repeater roles unaffected ---
+test('companion + recent + relay 0 → active',
+  () => assert(getNodeStatus('companion', recentMs, 0) === 'active'));
+
+test('companion + recent + relay > 0 → active (relay ignored)',
+  () => assert(getNodeStatus('companion', recentMs, 99) === 'active'));
+
+test('room + recent + relay 0 → active',
+  () => assert(getNodeStatus('room', recentMs, 0) === 'active'));
+
+test('sensor + recent + relay 0 → active',
+  () => assert(getNodeStatus('sensor', recentMs, 0) === 'active'));
+
+// --- Backward compatibility: omitting third arg ---
+test('getNodeStatus(repeater, recent) with no relay arg → active (not relaying)',
+  () => assert(getNodeStatus('repeater', recentMs) === 'active'));
+
+test('getNodeStatus(companion, recent) with no relay arg → active',
+  () => assert(getNodeStatus('companion', recentMs) === 'active'));
+
+console.log(`\n${pass} passed, ${fail} failed`);
+if (fail > 0) process.exit(1);
+```
+
+- [ ] **Step 2: Run tests to confirm they fail**
+
+```bash
+node test-repeater-liveness.js 2>&1
+```
+
+Expected: FAIL on `repeater + recent + relay > 0 → relaying` (returns `'active'` instead of `'relaying'`).
+
+- [ ] **Step 3: Extend `getNodeStatus` in `public/roles.js`**
+
+Find the existing function (around line 88):
+
+```js
+window.getNodeStatus = function (role, lastSeenMs) {
+    var isInfra = role === 'repeater' || role === 'room';
+    var staleMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
+    var age = typeof lastSeenMs === 'number' ? (Date.now() - lastSeenMs) : Infinity;
+    return age < staleMs ? 'active' : 'stale';
+};
+```
+
+Replace with:
+
+```js
+window.getNodeStatus = function (role, lastSeenMs, relayCount24h) {
+    var isInfra = role === 'repeater' || role === 'room';
+    var staleMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
+    var age = typeof lastSeenMs === 'number' ? (Date.now() - lastSeenMs) : Infinity;
+    if (age >= staleMs) return 'stale';
+    if (role === 'repeater') {
+      return (typeof relayCount24h === 'number' && relayCount24h > 0) ? 'relaying' : 'active';
+    }
+    return 'active';
+};
+```
+
+- [ ] **Step 4: Run tests to confirm they pass**
+
+```bash
+node test-repeater-liveness.js 2>&1
+```
+
+Expected: all 10 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add public/roles.js test-repeater-liveness.js
+git commit -m "feat(frontend): extend getNodeStatus to three-state for repeaters (#662)"
+```
+
+---
+
+## Task 5: Frontend — render three-state labels, CSS, and node detail pane
+
+**Files:**
+- Modify: `public/nodes.js`
+- Modify: `public/style.css`
+
+- [ ] **Step 1: Add `.last-seen-idle` CSS class to `public/style.css`**
+
+Find these two lines (around line 1590–1591):
+
+```css
+.last-seen-active { color: var(--status-green); }
+.last-seen-stale { color: var(--text-muted); }
+```
+
+Add after them:
+
+```css
+.last-seen-idle   { color: var(--status-yellow); }
+```
+
+- [ ] **Step 2: Update `getStatusTooltip` in `public/nodes.js`**
+
+Find the function (around line 113):
+
+```js
+function getStatusTooltip(role, status) {
+    const isInfra = role === 'repeater' || role === 'room';
+    const threshMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
+    const threshold = threshMs >= 3600000 ? Math.round(threshMs / 3600000) + 'h' : Math.round(threshMs / 60000) + 'm';
+    if (status === 'active') {
+      return 'Active \u2014 heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
+    }
+    if (role === 'companion') {
+      return 'Stale \u2014 not heard for over ' + threshold + '. Companions only advertise when the user initiates \u2014 this may be normal.';
+    }
+    if (role === 'sensor') {
+      return 'Stale \u2014 not heard for over ' + threshold + '. This sensor may be offline.';
+    }
+    return 'Stale \u2014 not heard for over ' + threshold + '. This ' + role + ' may be offline or out of range.';
+}
+```
+
+Replace with:
+
+```js
+function getStatusTooltip(role, status) {
+    const isInfra = role === 'repeater' || role === 'room';
+    const threshMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
+    const threshold = threshMs >= 3600000 ? Math.round(threshMs / 3600000) + 'h' : Math.round(threshMs / 60000) + 'm';
+    if (status === 'relaying') {
+      return 'Relaying \u2014 actively forwarding traffic within the last 24h.';
+    }
+    if (status === 'active') {
+      if (role === 'repeater') {
+        return 'Idle \u2014 alive (heard within ' + threshold + ') but no relay traffic observed in the last 24h. May be in a quiet area or have RF issues.';
+      }
+      return 'Active \u2014 heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
+    }
+    if (role === 'companion') {
+      return 'Stale \u2014 not heard for over ' + threshold + '. Companions only advertise when the user initiates \u2014 this may be normal.';
+    }
+    if (role === 'sensor') {
+      return 'Stale \u2014 not heard for over ' + threshold + '. This sensor may be offline.';
+    }
+    return 'Stale \u2014 not heard for over ' + threshold + '. This ' + role + ' may be offline or out of range.';
+}
+```
+
+- [ ] **Step 3: Update `getStatusInfo` in `public/nodes.js`**
+
+Find the function (around line 129):
+
+```js
+function getStatusInfo(n) {
+    // Single source of truth for all status-related info
+    const role = (n.role || '').toLowerCase();
+    const roleColor = ROLE_COLORS[n.role] || '#6b7280';
+    // Prefer last_heard (from in-memory packets) > _lastHeard (health API) > last_seen (DB)
+    const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
+    const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
+    const status = getNodeStatus(role, lastHeardMs);
+    const statusTooltip = getStatusTooltip(role, status);
+    const statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
+    const statusAge = lastHeardMs ? (Date.now() - lastHeardMs) : Infinity;
+
+    let explanation = '';
+    if (status === 'active') {
+      explanation = 'Last heard ' + (lastHeardTime ? renderNodeTimestampText(lastHeardTime) : 'unknown');
+    } else {
+      const ageDays = Math.floor(statusAge / 86400000);
+      const ageHours = Math.floor(statusAge / 3600000);
+      const ageStr = ageDays >= 1 ? ageDays + 'd' : ageHours + 'h';
+      const isInfra = role === 'repeater' || role === 'room';
+      const reason = isInfra
+        ? 'repeaters typically advertise every 12-24h'
+        : 'companions only advertise when user initiates, this may be normal';
+      explanation = 'Not heard for ' + ageStr + ' — ' + reason;
+    }
+
+    return { status, statusLabel, statusTooltip, statusAge, explanation, roleColor, lastHeardMs, role };
+}
+```
+
+Replace with:
+
+```js
+function getStatusInfo(n) {
+    // Single source of truth for all status-related info
+    const role = (n.role || '').toLowerCase();
+    const roleColor = ROLE_COLORS[n.role] || '#6b7280';
+    // Prefer last_heard (from in-memory packets) > _lastHeard (health API) > last_seen (DB)
+    const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
+    const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
+    const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
+    const relayCount1h  = (n.stats && typeof n.stats.relay_count_1h  === 'number') ? n.stats.relay_count_1h  : undefined;
+    const lastRelayed   = n.stats && n.stats.last_relayed;
+    const status = getNodeStatus(role, lastHeardMs, relayCount24h);
+    const statusTooltip = getStatusTooltip(role, status);
+    const statusAge = lastHeardMs ? (Date.now() - lastHeardMs) : Infinity;
+
+    let statusLabel;
+    if (role === 'repeater') {
+      statusLabel = status === 'relaying' ? '🟢 Relaying' : status === 'active' ? '🟡 Idle' : '⚪ Stale';
+    } else {
+      statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
+    }
+
+    let explanation = '';
+    if (status === 'relaying') {
+      explanation = 'Relayed ' + relayCount24h + ' packet' + (relayCount24h === 1 ? '' : 's') + ' in last 24h'
+        + (lastRelayed ? ', last ' + renderNodeTimestampText(lastRelayed) : '');
+    } else if (status === 'active' && role === 'repeater') {
+      explanation = 'Alive but no relay traffic observed in last 24h';
+    } else if (status === 'active') {
+      explanation = 'Last heard ' + (lastHeardTime ? renderNodeTimestampText(lastHeardTime) : 'unknown');
+    } else {
+      const ageDays = Math.floor(statusAge / 86400000);
+      const ageHours = Math.floor(statusAge / 3600000);
+      const ageStr = ageDays >= 1 ? ageDays + 'd' : ageHours + 'h';
+      const isInfra = role === 'repeater' || role === 'room';
+      const reason = isInfra
+        ? 'repeaters typically advertise every 12-24h'
+        : 'companions only advertise when user initiates, this may be normal';
+      explanation = 'Not heard for ' + ageStr + ' — ' + reason;
+    }
+
+    return { status, statusLabel, statusTooltip, statusAge, explanation, roleColor, lastHeardMs, role, relayCount1h, relayCount24h, lastRelayed };
+}
+```
+
+- [ ] **Step 4: Update the node list row CSS class mapping**
+
+Find the node list rendering (around line 1030–1031):
+
+```js
+const status = getNodeStatus(n.role || 'companion', lastSeenTime ? new Date(lastSeenTime).getTime() : 0);
+const lastSeenClass = status === 'active' ? 'last-seen-active' : 'last-seen-stale';
+```
+
+Replace with:
+
+```js
+const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
+const status = getNodeStatus((n.role || 'companion').toLowerCase(), lastSeenTime ? new Date(lastSeenTime).getTime() : 0, relayCount24h);
+const lastSeenClass = status === 'relaying' ? 'last-seen-active' : status === 'active' ? ((n.role || '').toLowerCase() === 'repeater' ? 'last-seen-idle' : 'last-seen-active') : 'last-seen-stale';
+```
+
+- [ ] **Step 5: Add relay stats rows to the node detail pane**
+
+Find the stats table in the detail pane (around line 490–494):
+
+```js
+${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
+${hasLoc ? `<tr><td>Location</td><td>...` : ''}
+```
+
+Add relay rows after `avgHops`:
+
+```js
+${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
+${si.role === 'repeater' ? `
+  <tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>
+  <tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>
+  ${si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}
+` : ''}
+${hasLoc ? `<tr><td>Location</td><td>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</td></tr>` : ''}
+```
+
+> Note: `si` is the return value of `getStatusInfo(n)` — already in scope in the detail render function. Verify the local variable name by checking the block around line 453.
+
+- [ ] **Step 6: Find and check the second detail panel (around line 1075)**
+
+There is a second node detail render path around line 1072. Apply the same relay rows addition there too — find the equivalent `avgHops` row and add the same relay block after it.
+
+- [ ] **Step 7: Run frontend tests**
+
+```bash
+node test-repeater-liveness.js && node test-packet-filter.js && node test-frontend-helpers.js && node test-live.js && node test-packets.js 2>&1
+```
+
+Expected: all pass.
+
+- [ ] **Step 8: Run backend tests**
+
+```bash
+cd cmd/server && go test ./... 2>&1
+```
+
+Expected: no regressions.
+
+- [ ] **Step 9: Commit**
+
+```bash
+git add public/nodes.js public/style.css
+git commit -m "feat(ui): three-state repeater liveness indicator and relay stats in detail pane (#662)"
+```
+
+---
+
+## Done
+
+All four tasks complete. Verify end-to-end:
+
+```bash
+# Backend
+cd cmd/server && go test ./... -v 2>&1 | tail -20
+
+# Frontend
+node test-repeater-liveness.js && node test-packet-filter.js && node test-frontend-helpers.js && node test-live.js && node test-packets.js
+```
+
+Then start the server and open the Nodes page. A repeater with recent relay activity should show 🟢 Relaying; one that is alive but quiet should show 🟡 Idle.

From 0a44bb9017f1ae764a1542f9ebe0a205fd2980a2 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 11:36:24 +0200
Subject: [PATCH 15/32] feat(store): add relayTimes index and relay metrics
 functions (#662)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/relay_liveness_test.go | 173 ++++++++++++++++++++++++++++++
 cmd/server/store.go               |  79 ++++++++++++++
 2 files changed, 252 insertions(+)
 create mode 100644 cmd/server/relay_liveness_test.go

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
new file mode 100644
index 00000000..860dcf36
--- /dev/null
+++ b/cmd/server/relay_liveness_test.go
@@ -0,0 +1,173 @@
+package main
+
+import (
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func makeRp(s string) *string { return &s }
+
+func TestAddTxToRelayTimeIndex_SingleNode(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	ts := time.Now().Add(-30 * time.Minute).UTC()
+	tx := &StoreTx{
+		FirstSeen:    ts.Format(time.RFC3339),
+		ResolvedPath: []*string{makeRp(pk)},
+	}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk]) != 1 {
+		t.Fatalf("expected 1 entry, got %d", len(idx[pk]))
+	}
+	wantMs := ts.UnixMilli()
+	// RFC3339 has second precision, so allow ±1000ms
+	if diff := idx[pk][0] - wantMs; diff < -1000 || diff > 1000 {
+		t.Errorf("timestamp mismatch: got %d, want ~%d", idx[pk][0], wantMs)
+	}
+}
+
+func TestAddTxToRelayTimeIndex_SortedOrder(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	t1 := time.Now().Add(-2 * time.Hour).UTC()
+	t2 := time.Now().Add(-30 * time.Minute).UTC()
+
+	// Insert newer first, expect sorted ascending
+	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+	addTxToRelayTimeIndex(idx, tx2)
+	addTxToRelayTimeIndex(idx, tx1)
+
+	if len(idx[pk]) != 2 {
+		t.Fatalf("expected 2 entries, got %d", len(idx[pk]))
+	}
+	if !sort.SliceIsSorted(idx[pk], func(i, j int) bool { return idx[pk][i] < idx[pk][j] }) {
+		t.Error("relayTimes slice not sorted ascending")
+	}
+}
+
+func TestAddTxToRelayTimeIndex_MultipleNodes(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk1 := "aabbccdd11223344"
+	pk2 := "eeff001122334455"
+	ts := time.Now().Add(-10 * time.Minute).UTC()
+	tx := &StoreTx{
+		FirstSeen:    ts.Format(time.RFC3339),
+		ResolvedPath: []*string{makeRp(pk1), makeRp(pk2)},
+	}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk1]) != 1 {
+		t.Errorf("pk1: expected 1 entry, got %d", len(idx[pk1]))
+	}
+	if len(idx[pk2]) != 1 {
+		t.Errorf("pk2: expected 1 entry, got %d", len(idx[pk2]))
+	}
+}
+
+func TestAddTxToRelayTimeIndex_NilResolvedPath(t *testing.T) {
+	idx := make(map[string][]int64)
+	tx := &StoreTx{FirstSeen: time.Now().UTC().Format(time.RFC3339), ResolvedPath: nil}
+	addTxToRelayTimeIndex(idx, tx) // must not panic
+	if len(idx) != 0 {
+		t.Error("expected empty index for nil ResolvedPath")
+	}
+}
+
+func TestAddTxToRelayTimeIndex_DuplicatePubkeyInPath(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	ts := time.Now().UTC()
+	tx := &StoreTx{
+		FirstSeen:    ts.Format(time.RFC3339),
+		ResolvedPath: []*string{makeRp(pk), makeRp(pk)}, // same pubkey twice
+	}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk]) != 1 {
+		t.Errorf("duplicate pubkey should produce only 1 entry, got %d", len(idx[pk]))
+	}
+}
+
+func TestRemoveFromRelayTimeIndex_RemovesEntry(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	ts := time.Now().Add(-1 * time.Hour).UTC()
+	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pk]) != 1 {
+		t.Fatal("setup: expected 1 entry")
+	}
+	removeFromRelayTimeIndex(idx, tx)
+	if _, ok := idx[pk]; ok {
+		t.Error("expected key deleted after last entry removed")
+	}
+}
+
+func TestRemoveFromRelayTimeIndex_PartialRemove(t *testing.T) {
+	idx := make(map[string][]int64)
+	pk := "aabbccdd11223344"
+	t1 := time.Now().Add(-2 * time.Hour).UTC()
+	t2 := time.Now().Add(-30 * time.Minute).UTC()
+	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
+
+	addTxToRelayTimeIndex(idx, tx1)
+	addTxToRelayTimeIndex(idx, tx2)
+	removeFromRelayTimeIndex(idx, tx1)
+
+	if len(idx[pk]) != 1 {
+		t.Errorf("expected 1 entry after removing one, got %d", len(idx[pk]))
+	}
+}
+
+func TestRelayMetrics_Counts(t *testing.T) {
+	now := time.Now().UnixMilli()
+	times := []int64{
+		now - 90*60*1000, // 90 min ago — inside 24h, outside 1h
+		now - 30*60*1000, // 30 min ago — inside both
+		now - 10*60*1000, // 10 min ago — inside both
+	}
+	c1h, c24h, lastRelayed := relayMetrics(times, now)
+	if c1h != 2 {
+		t.Errorf("relay_count_1h: expected 2, got %d", c1h)
+	}
+	if c24h != 3 {
+		t.Errorf("relay_count_24h: expected 3, got %d", c24h)
+	}
+	if lastRelayed == "" {
+		t.Error("last_relayed should not be empty")
+	}
+}
+
+func TestRelayMetrics_EmptySlice(t *testing.T) {
+	c1h, c24h, lastRelayed := relayMetrics(nil, time.Now().UnixMilli())
+	if c1h != 0 || c24h != 0 || lastRelayed != "" {
+		t.Errorf("empty slice: expected zeros and empty string, got %d %d %q", c1h, c24h, lastRelayed)
+	}
+}
+
+func TestRelayMetrics_AllOutsideWindow(t *testing.T) {
+	now := time.Now().UnixMilli()
+	times := []int64{now - 30*24*60*60*1000} // 30 days ago
+	c1h, c24h, _ := relayMetrics(times, now)
+	if c1h != 0 || c24h != 0 {
+		t.Errorf("expected 0/0 for old entry, got %d/%d", c1h, c24h)
+	}
+}
+
+func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
+	idx := make(map[string][]int64)
+	pkUpper := "AABBCCDD11223344"
+	pkLower := strings.ToLower(pkUpper)
+	ts := time.Now().UTC()
+	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pkUpper)}}
+	addTxToRelayTimeIndex(idx, tx)
+	if len(idx[pkLower]) != 1 {
+		t.Errorf("expected index keyed by lowercase, found %d entries at lowercase key", len(idx[pkLower]))
+	}
+	if len(idx[pkUpper]) != 0 {
+		t.Errorf("expected no entry at uppercase key")
+	}
+}
diff --git a/cmd/server/store.go b/cmd/server/store.go
index 7a33981d..aaee0579 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -132,6 +132,7 @@ type PacketStore struct {
 	byNode        map[string][]*StoreTx      // pubkey → transmissions
 	nodeHashes    map[string]map[string]bool // pubkey → Set<hash>
 	byPathHop     map[string][]*StoreTx      // lowercase hop/pubkey → transmissions with that hop in path
+	relayTimes    map[string][]int64         // lowercase pubkey → sorted unix-millis of relay events (full pubkeys only)
 	byPayloadType map[int][]*StoreTx         // payload_type → transmissions
 	loaded        bool
 	totalObs      int
@@ -290,6 +291,7 @@ func NewPacketStore(db *DB, cfg *PacketStoreConfig, cacheTTLs ...map[string]inte
 		byObserver:    make(map[string][]*StoreObs),
 		byNode:        make(map[string][]*StoreTx),
 		byPathHop:     make(map[string][]*StoreTx),
+		relayTimes:    make(map[string][]int64),
 		nodeHashes:    make(map[string]map[string]bool),
 		byPayloadType: make(map[int][]*StoreTx),
 		rfCache:       make(map[string]*cachedResult),
@@ -2462,6 +2464,83 @@ func addTxToPathHopIndex(idx map[string][]*StoreTx, tx *StoreTx) {
 	}
 }
 
+// addTxToRelayTimeIndex records the relay timestamp for each full pubkey in
+// tx.ResolvedPath. Maintains sorted ascending order for O(log n) window queries.
+// Must be called with s.mu held (or during build before store is live).
+func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
+	if len(tx.ResolvedPath) == 0 {
+		return
+	}
+	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
+	if err != nil {
+		return
+	}
+	millis := ms.UnixMilli()
+	seen := make(map[string]bool, len(tx.ResolvedPath))
+	for _, rp := range tx.ResolvedPath {
+		if rp == nil {
+			continue
+		}
+		pk := strings.ToLower(*rp)
+		if seen[pk] {
+			continue
+		}
+		seen[pk] = true
+		slice := idx[pk]
+		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
+		slice = append(slice, 0)
+		copy(slice[i+1:], slice[i:])
+		slice[i] = millis
+		idx[pk] = slice
+	}
+}
+
+// removeFromRelayTimeIndex removes the relay timestamp for each full pubkey in
+// tx.ResolvedPath. Inverse of addTxToRelayTimeIndex.
+func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
+	if len(tx.ResolvedPath) == 0 {
+		return
+	}
+	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
+	if err != nil {
+		return
+	}
+	millis := ms.UnixMilli()
+	seen := make(map[string]bool, len(tx.ResolvedPath))
+	for _, rp := range tx.ResolvedPath {
+		if rp == nil {
+			continue
+		}
+		pk := strings.ToLower(*rp)
+		if seen[pk] {
+			continue
+		}
+		seen[pk] = true
+		slice := idx[pk]
+		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
+		if i < len(slice) && slice[i] == millis {
+			idx[pk] = append(slice[:i], slice[i+1:]...)
+			if len(idx[pk]) == 0 {
+				delete(idx, pk)
+			}
+		}
+	}
+}
+
+// relayMetrics computes relay_count_1h, relay_count_24h, and last_relayed from a
+// sorted unix-millis slice. now is time.Now().UnixMilli(). O(log n).
+func relayMetrics(times []int64, now int64) (count1h, count24h int, lastRelayed string) {
+	if len(times) == 0 {
+		return 0, 0, ""
+	}
+	i1h := sort.Search(len(times), func(i int) bool { return times[i] >= now-3600000 })
+	i24h := sort.Search(len(times), func(i int) bool { return times[i] >= now-86400000 })
+	count1h = len(times) - i1h
+	count24h = len(times) - i24h
+	lastRelayed = time.UnixMilli(times[len(times)-1]).UTC().Format(time.RFC3339)
+	return
+}
+
 // removeTxFromPathHopIndex removes a transmission from all its path-hop index entries.
 func removeTxFromPathHopIndex(idx map[string][]*StoreTx, tx *StoreTx) {
 	hops := txGetParsedPath(tx)

From 98f1214b33f2b61d53027d6f2dafc760031bd9fb Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 11:49:50 +0200
Subject: [PATCH 16/32] fix(store): safe slice removal in
 removeFromRelayTimeIndex, strengthen test (#662)

---
 cmd/server/relay_liveness_test.go | 5 +++--
 cmd/server/store.go               | 7 +++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index 860dcf36..718c84c5 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -136,8 +136,9 @@ func TestRelayMetrics_Counts(t *testing.T) {
 	if c24h != 3 {
 		t.Errorf("relay_count_24h: expected 3, got %d", c24h)
 	}
-	if lastRelayed == "" {
-		t.Error("last_relayed should not be empty")
+	wantLast := time.UnixMilli(times[2]).UTC().Format(time.RFC3339)
+	if lastRelayed != wantLast {
+		t.Errorf("last_relayed: got %q, want %q", lastRelayed, wantLast)
 	}
 }
 
diff --git a/cmd/server/store.go b/cmd/server/store.go
index aaee0579..88179893 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -2519,8 +2519,11 @@ func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
 		slice := idx[pk]
 		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
 		if i < len(slice) && slice[i] == millis {
-			idx[pk] = append(slice[:i], slice[i+1:]...)
-			if len(idx[pk]) == 0 {
+			newSlice := make([]int64, 0, len(slice)-1)
+			newSlice = append(newSlice, slice[:i]...)
+			newSlice = append(newSlice, slice[i+1:]...)
+			idx[pk] = newSlice
+			if len(newSlice) == 0 {
 				delete(idx, pk)
 			}
 		}

From cdddab307011c850c2b121a58e3919165ad17fec Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 11:51:59 +0200
Subject: [PATCH 17/32] feat(store): wire relayTimes into ingest, evict, and
 build paths (#662)

---
 cmd/server/relay_liveness_test.go | 19 +++++++++++++++++++
 cmd/server/store.go               |  8 +++++++-
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index 718c84c5..81139401 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -158,6 +158,25 @@ func TestRelayMetrics_AllOutsideWindow(t *testing.T) {
 	}
 }
 
+func TestRelayTimesWiredIntoIngest(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	srv.store.mu.RLock()
+	hopKeys := len(srv.store.byPathHop)
+	relayKeys := len(srv.store.relayTimes)
+	srv.store.mu.RUnlock()
+
+	if hopKeys == 0 {
+		t.Skip("no path-hop data in test store — skipping relay wiring test")
+	}
+	// relayTimes will only be populated if test packets have ResolvedPath entries.
+	// At minimum it must not panic and must be initialised.
+	if srv.store.relayTimes == nil {
+		t.Fatal("relayTimes map is nil after load")
+	}
+	t.Logf("byPathHop keys: %d, relayTimes keys: %d", hopKeys, relayKeys)
+}
+
 func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
 	idx := make(map[string][]int64)
 	pkUpper := "AABBCCDD11223344"
diff --git a/cmd/server/store.go b/cmd/server/store.go
index 88179893..a3fbcb21 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -1495,6 +1495,7 @@ func (s *PacketStore) IngestNewFromDB(sinceID, limit int) ([]map[string]interfac
 			s.spTotalPaths++
 		}
 		addTxToPathHopIndex(s.byPathHop, tx)
+		addTxToRelayTimeIndex(s.relayTimes, tx)
 	}
 
 	// Incrementally update precomputed distance index with new transmissions
@@ -1872,6 +1873,7 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) []map[string]
 				tx.parsedPath, tx.pathParsed = oldHops, true
 				tx.ResolvedPath = oldResolvedPaths[txID]
 				removeTxFromPathHopIndex(s.byPathHop, tx)
+				removeFromRelayTimeIndex(s.relayTimes, tx)
 				tx.parsedPath, tx.pathParsed = saved, savedFlag
 				tx.ResolvedPath = savedRP
 			}
@@ -1881,6 +1883,7 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) []map[string]
 				s.spTotalPaths++
 			}
 			addTxToPathHopIndex(s.byPathHop, tx)
+			addTxToRelayTimeIndex(s.relayTimes, tx)
 		}
 	}
 
@@ -2433,10 +2436,12 @@ func (s *PacketStore) buildSubpathIndex() {
 // Must be called with s.mu held.
 func (s *PacketStore) buildPathHopIndex() {
 	s.byPathHop = make(map[string][]*StoreTx, 4096)
+	s.relayTimes = make(map[string][]int64, 4096)
 	for _, tx := range s.packets {
 		addTxToPathHopIndex(s.byPathHop, tx)
+		addTxToRelayTimeIndex(s.relayTimes, tx)
 	}
-	log.Printf("[store] Built path-hop index: %d unique keys", len(s.byPathHop))
+	log.Printf("[store] Built path-hop index: %d unique keys, %d relay-time keys", len(s.byPathHop), len(s.relayTimes))
 }
 
 // addTxToPathHopIndex indexes a transmission under each unique hop key
@@ -2924,6 +2929,7 @@ func (s *PacketStore) EvictStale() int {
 		removeTxFromSubpathIndexFull(s.spIndex, s.spTxIndex, tx)
 		// Remove from path-hop index
 		removeTxFromPathHopIndex(s.byPathHop, tx)
+		removeFromRelayTimeIndex(s.relayTimes, tx)
 	}
 
 	// Batch-remove from byObserver: single pass per affected observer slice

From b06129ab1d8669a77767dba36734f1a419e05776 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 12:23:17 +0200
Subject: [PATCH 18/32] test(store): assert relayTimes is populated in wiring
 integration test (#662)

---
 cmd/server/relay_liveness_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index 81139401..b452f3fa 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -174,6 +174,9 @@ func TestRelayTimesWiredIntoIngest(t *testing.T) {
 	if srv.store.relayTimes == nil {
 		t.Fatal("relayTimes map is nil after load")
 	}
+	if relayKeys == 0 {
+		t.Fatalf("relayTimes not populated: byPathHop has %d keys but relayTimes has 0", hopKeys)
+	}
 	t.Logf("byPathHop keys: %d, relayTimes keys: %d", hopKeys, relayKeys)
 }
 

From d93002134fe4692576fc6bc419f5bda35191c0d5 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 12:27:36 +0200
Subject: [PATCH 19/32] feat(api): add relay_count_1h/24h/last_relayed to node
 health responses (#662)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/relay_liveness_test.go | 101 ++++++++++++++++++++++++++++++
 cmd/server/store.go               |  63 +++++++++++++------
 2 files changed, 144 insertions(+), 20 deletions(-)

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index b452f3fa..673dcd9b 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -180,6 +180,107 @@ func TestRelayTimesWiredIntoIngest(t *testing.T) {
 	t.Logf("byPathHop keys: %d, relayTimes keys: %d", hopKeys, relayKeys)
 }
 
+func TestGetBulkHealthRepeaterRelayFields(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	// Insert a synthetic repeater node into the DB if none exists
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('relay662test0001', 'TestRepeater662', 'repeater', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	// Inject a relay timestamp within the last hour
+	pk := "relay662test0001"
+	now := time.Now().UnixMilli()
+	recentMs := now - 10*60*1000 // 10 min ago
+	srv.store.mu.Lock()
+	srv.store.relayTimes[pk] = []int64{recentMs}
+	srv.store.mu.Unlock()
+
+	results := srv.store.GetBulkHealth(200, "")
+
+	var found map[string]interface{}
+	for _, r := range results {
+		if r["public_key"] == pk {
+			found = r
+			break
+		}
+	}
+	if found == nil {
+		t.Fatal("test repeater not found in GetBulkHealth results")
+	}
+
+	stats, ok := found["stats"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing stats map in result")
+	}
+
+	if v, ok := stats["relay_count_1h"].(int); !ok || v != 1 {
+		t.Errorf("relay_count_1h: expected 1, got %v", stats["relay_count_1h"])
+	}
+	if v, ok := stats["relay_count_24h"].(int); !ok || v != 1 {
+		t.Errorf("relay_count_24h: expected 1, got %v", stats["relay_count_24h"])
+	}
+	if _, ok := stats["last_relayed"].(string); !ok {
+		t.Errorf("last_relayed: expected string, got %T", stats["last_relayed"])
+	}
+}
+
+func TestGetBulkHealthCompanionNoRelayFields(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('comp662test0001', 'TestCompanion662', 'companion', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	// Give the companion a relay entry (should be ignored by role gate)
+	pk := "comp662test0001"
+	srv.store.mu.Lock()
+	srv.store.relayTimes[pk] = []int64{time.Now().UnixMilli() - 5*60*1000}
+	srv.store.mu.Unlock()
+
+	results := srv.store.GetBulkHealth(200, "")
+	for _, r := range results {
+		if r["public_key"] == pk {
+			stats, _ := r["stats"].(map[string]interface{})
+			if _, present := stats["relay_count_24h"]; present {
+				t.Error("relay_count_24h should be absent for companion nodes")
+			}
+			return
+		}
+	}
+	t.Fatal("test companion not found in GetBulkHealth results")
+}
+
+func TestGetBulkHealthRepeaterNoRelayActivity(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('relay662idle001', 'IdleRepeater662', 'repeater', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	// No entry in relayTimes for this node
+	results := srv.store.GetBulkHealth(200, "")
+	for _, r := range results {
+		if r["public_key"] == "relay662idle001" {
+			stats, _ := r["stats"].(map[string]interface{})
+			if v, ok := stats["relay_count_24h"].(int); !ok || v != 0 {
+				t.Errorf("relay_count_24h: expected 0, got %v", stats["relay_count_24h"])
+			}
+			if _, present := stats["last_relayed"]; present {
+				t.Error("last_relayed should be absent when no relay activity")
+			}
+			return
+		}
+	}
+	t.Fatal("idle repeater not found in results")
+}
+
 func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
 	idx := make(map[string][]int64)
 	pkUpper := "AABBCCDD11223344"
diff --git a/cmd/server/store.go b/cmd/server/store.go
index a3fbcb21..252d000d 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -6259,21 +6259,30 @@ func (s *PacketStore) GetBulkHealth(limit int, region string) []map[string]inter
 			lhVal = lastHeard
 		}
 
+		statsMap := map[string]interface{}{
+			"totalTransmissions": len(packets),
+			"totalObservations":  totalObservations,
+			"totalPackets":       len(packets),
+			"packetsToday":       packetsToday,
+			"avgSnr":             avgSnr,
+			"lastHeard":          lhVal,
+		}
+		if strings.ToLower(n.role) == "repeater" {
+			c1h, c24h, lastRel := relayMetrics(s.relayTimes[n.pk], time.Now().UnixMilli())
+			statsMap["relay_count_1h"] = c1h
+			statsMap["relay_count_24h"] = c24h
+			if lastRel != "" {
+				statsMap["last_relayed"] = lastRel
+			}
+		}
 		results = append(results, map[string]interface{}{
 			"public_key": n.pk,
 			"name":       nilIfEmpty(n.name),
 			"role":       nilIfEmpty(n.role),
 			"lat":        n.lat,
 			"lon":        n.lon,
-			"stats": map[string]interface{}{
-				"totalTransmissions": len(packets),
-				"totalObservations":  totalObservations,
-				"totalPackets":       len(packets),
-				"packetsToday":       packetsToday,
-				"avgSnr":             avgSnr,
-				"lastHeard":          lhVal,
-			},
-			"observers": observerRows,
+			"stats":      statsMap,
+			"observers":  observerRows,
 		})
 	}
 
@@ -6410,18 +6419,32 @@ func (s *PacketStore) GetNodeHealth(pubkey string) (map[string]interface{}, erro
 		recentPackets = append(recentPackets, p)
 	}
 
+	nodeStats := map[string]interface{}{
+		"totalTransmissions": len(packets),
+		"totalObservations":  totalObservations,
+		"totalPackets":       len(packets),
+		"packetsToday":       packetsToday,
+		"avgSnr":             avgSnr,
+		"avgHops":            avgHops,
+		"lastHeard":          lhVal,
+	}
+	role := ""
+	if r, ok := node["role"].(string); ok {
+		role = strings.ToLower(r)
+	}
+	if role == "repeater" {
+		lowerPK := strings.ToLower(pubkey)
+		c1h, c24h, lastRel := relayMetrics(s.relayTimes[lowerPK], time.Now().UnixMilli())
+		nodeStats["relay_count_1h"] = c1h
+		nodeStats["relay_count_24h"] = c24h
+		if lastRel != "" {
+			nodeStats["last_relayed"] = lastRel
+		}
+	}
 	return map[string]interface{}{
-		"node":      node,
-		"observers": observerRows,
-		"stats": map[string]interface{}{
-			"totalTransmissions": len(packets),
-			"totalObservations":  totalObservations,
-			"totalPackets":       len(packets),
-			"packetsToday":       packetsToday,
-			"avgSnr":             avgSnr,
-			"avgHops":            avgHops,
-			"lastHeard":          lhVal,
-		},
+		"node":          node,
+		"observers":     observerRows,
+		"stats":         nodeStats,
 		"recentPackets": recentPackets,
 	}, nil
 }

From 59444150884c274d629d646eb167506dbe27212b Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 12:59:02 +0200
Subject: [PATCH 20/32] fix(api): lowercase pubkey for relayTimes lookup in
 GetBulkHealth, add GetNodeHealth test (#662)

---
 cmd/server/relay_liveness_test.go | 40 +++++++++++++++++++++++++++++++
 cmd/server/store.go               |  2 +-
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index 673dcd9b..b98f00d7 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -295,3 +295,43 @@ func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
 		t.Errorf("expected no entry at uppercase key")
 	}
 }
+
+func TestGetNodeHealthRepeaterRelayFields(t *testing.T) {
+	srv, _ := setupTestServer(t)
+
+	pk := "relay662node0001"
+	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('relay662node0001', 'TestRepeaterNode662', 'repeater', datetime('now'), datetime('now'), 1)`)
+	if err != nil {
+		t.Fatalf("insert test node: %v", err)
+	}
+
+	now := time.Now().UnixMilli()
+	recentMs := now - 15*60*1000 // 15 min ago
+	srv.store.mu.Lock()
+	srv.store.relayTimes[pk] = []int64{recentMs}
+	srv.store.mu.Unlock()
+
+	result, err := srv.store.GetNodeHealth(pk)
+	if err != nil {
+		t.Fatalf("GetNodeHealth error: %v", err)
+	}
+	if result == nil {
+		t.Fatal("GetNodeHealth returned nil")
+	}
+
+	stats, ok := result["stats"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing stats map in GetNodeHealth result")
+	}
+
+	if v, ok := stats["relay_count_1h"].(int); !ok || v != 1 {
+		t.Errorf("relay_count_1h: expected 1, got %v", stats["relay_count_1h"])
+	}
+	if v, ok := stats["relay_count_24h"].(int); !ok || v != 1 {
+		t.Errorf("relay_count_24h: expected 1, got %v", stats["relay_count_24h"])
+	}
+	if _, ok := stats["last_relayed"].(string); !ok {
+		t.Errorf("last_relayed: expected string, got %T", stats["last_relayed"])
+	}
+}
diff --git a/cmd/server/store.go b/cmd/server/store.go
index 252d000d..5353f5fd 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -6268,7 +6268,7 @@ func (s *PacketStore) GetBulkHealth(limit int, region string) []map[string]inter
 			"lastHeard":          lhVal,
 		}
 		if strings.ToLower(n.role) == "repeater" {
-			c1h, c24h, lastRel := relayMetrics(s.relayTimes[n.pk], time.Now().UnixMilli())
+			c1h, c24h, lastRel := relayMetrics(s.relayTimes[strings.ToLower(n.pk)], time.Now().UnixMilli())
 			statsMap["relay_count_1h"] = c1h
 			statsMap["relay_count_24h"] = c24h
 			if lastRel != "" {

From caaef4ba24da8fe0f783ef309fd6101e2394ac62 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 13:03:48 +0200
Subject: [PATCH 21/32] feat(frontend): extend getNodeStatus to three-state for
 repeaters (#662)

---
 public/roles.js           | 12 ++++---
 test-repeater-liveness.js | 76 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 4 deletions(-)
 create mode 100644 test-repeater-liveness.js

diff --git a/public/roles.js b/public/roles.js
index bbeeeb88..025617c3 100644
--- a/public/roles.js
+++ b/public/roles.js
@@ -84,12 +84,16 @@
     };
   };
 
-  // Simplified two-state helper: returns 'active' or 'stale'
-  window.getNodeStatus = function (role, lastSeenMs) {
+  // Three-state helper for repeaters: returns 'relaying', 'active', or 'stale'
+  window.getNodeStatus = function (role, lastSeenMs, relayCount24h) {
     var isInfra = role === 'repeater' || role === 'room';
-    var staleMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
+    var staleMs = isInfra ? window.HEALTH_THRESHOLDS.infraSilentMs : window.HEALTH_THRESHOLDS.nodeSilentMs;
     var age = typeof lastSeenMs === 'number' ? (Date.now() - lastSeenMs) : Infinity;
-    return age < staleMs ? 'active' : 'stale';
+    if (age >= staleMs) return 'stale';
+    if (role === 'repeater') {
+      return (typeof relayCount24h === 'number' && relayCount24h > 0) ? 'relaying' : 'active';
+    }
+    return 'active';
   };
 
   // ─── Tile URLs ───
diff --git a/test-repeater-liveness.js b/test-repeater-liveness.js
new file mode 100644
index 00000000..9b91d184
--- /dev/null
+++ b/test-repeater-liveness.js
@@ -0,0 +1,76 @@
+'use strict';
+const vm = require('vm');
+const fs = require('fs');
+
+// Minimal browser environment
+const ctx = {
+  window: {},
+  console,
+  document: {
+    readyState: 'complete',
+    documentElement: { getAttribute: () => null },
+    getElementById: () => null,
+    createElement: () => ({ textContent: '' }),
+    head: { appendChild: () => {} }
+  },
+  navigator: {},
+  fetch: () => Promise.resolve({ json: () => Promise.resolve({}) }),
+  Date,
+};
+vm.createContext(ctx);
+vm.runInContext(fs.readFileSync('public/roles.js', 'utf8'), ctx);
+
+// Run tests inside the VM context to preserve closures
+const testCode = `
+let pass = 0, fail = 0;
+function test(name, fn) {
+  try { fn(); pass++; console.log('  ok:', name); }
+  catch (e) { fail++; console.log('FAIL:', name, '—', e.message); }
+}
+function assert(cond, msg) { if (!cond) throw new Error(msg || 'assertion failed'); }
+
+const now = Date.now();
+const recentMs = now - 1000;                                     // 1 second ago — always active
+const staleMs  = now - (window.HEALTH_THRESHOLDS.infraSilentMs + 1);   // just past silent threshold
+
+// --- Repeater three-state ---
+test('repeater + recent + relay > 0 → relaying',
+  () => assert(window.getNodeStatus('repeater', recentMs, 5) === 'relaying'));
+
+test('repeater + recent + relay == 0 → active (idle)',
+  () => assert(window.getNodeStatus('repeater', recentMs, 0) === 'active'));
+
+test('repeater + stale + relay > 0 → stale (stale beats relay)',
+  () => assert(window.getNodeStatus('repeater', staleMs, 99) === 'stale'));
+
+test('repeater + stale + relay == 0 → stale',
+  () => assert(window.getNodeStatus('repeater', staleMs, 0) === 'stale'));
+
+// --- Non-repeater roles unaffected ---
+test('companion + recent + relay 0 → active',
+  () => assert(window.getNodeStatus('companion', recentMs, 0) === 'active'));
+
+test('companion + recent + relay > 0 → active (relay ignored)',
+  () => assert(window.getNodeStatus('companion', recentMs, 99) === 'active'));
+
+test('room + recent + relay 0 → active',
+  () => assert(window.getNodeStatus('room', recentMs, 0) === 'active'));
+
+test('sensor + recent + relay 0 → active',
+  () => assert(window.getNodeStatus('sensor', recentMs, 0) === 'active'));
+
+// --- Backward compatibility: omitting third arg ---
+test('getNodeStatus(repeater, recent) with no relay arg → active (not relaying)',
+  () => assert(window.getNodeStatus('repeater', recentMs) === 'active'));
+
+test('getNodeStatus(companion, recent) with no relay arg → active',
+  () => assert(window.getNodeStatus('companion', recentMs) === 'active'));
+
+window.testResults = { pass, fail };
+`;
+
+vm.runInContext(testCode, ctx);
+
+const { pass, fail } = ctx.window.testResults;
+console.log(`\n${pass} passed, ${fail} failed`);
+if (fail > 0) process.exit(1);

From 64ea5ddd49b8ec7eb4d2772c9705c5ac357ffcd0 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 13:09:08 +0200
Subject: [PATCH 22/32] feat(ui): three-state repeater liveness indicator and
 relay stats in detail pane (#662)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/nodes.js          | 43 ++++++++++++++++++++++++++++++++++------
 public/style.css         |  1 +
 test-frontend-helpers.js |  8 ++++----
 3 files changed, 42 insertions(+), 10 deletions(-)

diff --git a/public/nodes.js b/public/nodes.js
index accaf827..bdf21669 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -114,7 +114,13 @@
     const isInfra = role === 'repeater' || role === 'room';
     const threshMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
     const threshold = threshMs >= 3600000 ? Math.round(threshMs / 3600000) + 'h' : Math.round(threshMs / 60000) + 'm';
+    if (status === 'relaying') {
+      return 'Relaying \u2014 actively forwarding traffic within the last 24h.';
+    }
     if (status === 'active') {
+      if (role === 'repeater') {
+        return 'Idle \u2014 alive (heard within ' + threshold + ') but no relay traffic observed in the last 24h. May be in a quiet area or have RF issues.';
+      }
       return 'Active \u2014 heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
     }
     if (role === 'companion') {
@@ -133,13 +139,27 @@
     // Prefer last_heard (from in-memory packets) > _lastHeard (health API) > last_seen (DB)
     const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
     const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
-    const status = getNodeStatus(role, lastHeardMs);
+    const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
+    const relayCount1h  = (n.stats && typeof n.stats.relay_count_1h  === 'number') ? n.stats.relay_count_1h  : undefined;
+    const lastRelayed   = n.stats && n.stats.last_relayed;
+    const status = getNodeStatus(role, lastHeardMs, relayCount24h);
     const statusTooltip = getStatusTooltip(role, status);
-    const statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
     const statusAge = lastHeardMs ? (Date.now() - lastHeardMs) : Infinity;
 
+    let statusLabel;
+    if (role === 'repeater') {
+      statusLabel = status === 'relaying' ? '🟢 Relaying' : status === 'active' ? '🟡 Idle' : '⚪ Stale';
+    } else {
+      statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
+    }
+
     let explanation = '';
-    if (status === 'active') {
+    if (status === 'relaying') {
+      explanation = 'Relayed ' + relayCount24h + ' packet' + (relayCount24h === 1 ? '' : 's') + ' in last 24h'
+        + (lastRelayed ? ', last ' + renderNodeTimestampText(lastRelayed) : '');
+    } else if (status === 'active' && role === 'repeater') {
+      explanation = 'Alive but no relay traffic observed in last 24h';
+    } else if (status === 'active') {
       explanation = 'Last heard ' + (lastHeardTime ? renderNodeTimestampText(lastHeardTime) : 'unknown');
     } else {
       const ageDays = Math.floor(statusAge / 86400000);
@@ -152,7 +172,7 @@
       explanation = 'Not heard for ' + ageStr + ' — ' + reason;
     }
 
-    return { status, statusLabel, statusTooltip, statusAge, explanation, roleColor, lastHeardMs, role };
+    return { status, statusLabel, statusTooltip, statusAge, explanation, roleColor, lastHeardMs, role, relayCount1h, relayCount24h, lastRelayed };
   }
 
   function renderNodeBadges(n, roleColor) {
@@ -491,6 +511,11 @@
           <tr><td>Packets Today</td><td>${stats.packetsToday || 0}</td></tr>
           ${stats.avgSnr != null ? `<tr><td>Avg SNR</td><td>${Number(stats.avgSnr).toFixed(1)} dB</td></tr>` : ''}
           ${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
+          ${si.role === 'repeater' ? `
+  <tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>
+  <tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>
+  ${si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}
+` : ''}
           ${hasLoc ? `<tr><td>Location</td><td>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</td></tr>` : ''}
           <tr><td>Hash Prefix</td><td>${n.hash_size ? '<code style="font-family:var(--mono);font-weight:700">' + n.public_key.slice(0, n.hash_size * 2).toUpperCase() + '</code> (' + n.hash_size + '-byte)' : 'Unknown'}${n.hash_size_inconsistent ? ' <span style="color:var(--status-yellow);cursor:help" title="Seen: ' + (Array.isArray(n.hash_sizes_seen) ? n.hash_sizes_seen : []).join(', ') + '-byte">⚠️ varies</span>' : ''}</td></tr>
         </table>
@@ -1081,8 +1106,9 @@
       const roleColor = ROLE_COLORS[n.role] || '#6b7280';
       const isClaimed = myKeys.has(n.public_key);
       const lastSeenTime = n.last_heard || n.last_seen;
-      const status = getNodeStatus(n.role || 'companion', lastSeenTime ? new Date(lastSeenTime).getTime() : 0);
-      const lastSeenClass = status === 'active' ? 'last-seen-active' : 'last-seen-stale';
+      const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
+      const status = getNodeStatus((n.role || 'companion').toLowerCase(), lastSeenTime ? new Date(lastSeenTime).getTime() : 0, relayCount24h);
+      const lastSeenClass = status === 'relaying' ? 'last-seen-active' : status === 'active' ? ((n.role || '').toLowerCase() === 'repeater' ? 'last-seen-idle' : 'last-seen-active') : 'last-seen-stale';
       const cs = _fleetSkew && _fleetSkew[n.public_key];
       const skewBadgeHtml = cs && cs.severity && cs.severity !== 'ok' ? renderSkewBadge(cs.severity, cs.medianSkewSec) : '';
       return `<tr data-key="${n.public_key}" data-action="select" data-value="${n.public_key}" tabindex="0" role="row" class="${selectedKey === n.public_key ? 'selected' : ''}${isClaimed ? ' claimed-row' : ''}">
@@ -1166,6 +1192,11 @@
             <dt>Packets Today</dt><dd>${stats.packetsToday || 0}</dd>
             ${stats.avgSnr != null ? `<dt>Avg SNR</dt><dd>${Number(stats.avgSnr).toFixed(1)} dB</dd>` : ''}
             ${stats.avgHops ? `<dt>Avg Hops</dt><dd>${stats.avgHops}</dd>` : ''}
+            ${si.role === 'repeater' ? `
+  <dt>Relay (1h)</dt><dd>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</dd>
+  <dt>Relay (24h)</dt><dd>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</dd>
+  ${si.lastRelayed ? `<dt>Last Relayed</dt><dd>${renderNodeTimestampHtml(si.lastRelayed)}</dd>` : ''}
+` : ''}
             ${hasLoc ? `<dt>Location</dt><dd>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</dd>` : ''}
           </dl>
         </div>
diff --git a/public/style.css b/public/style.css
index 2d0db453..1722ddd0 100644
--- a/public/style.css
+++ b/public/style.css
@@ -1620,6 +1620,7 @@ tr[data-hops]:hover { background: rgba(59,130,246,0.1); }
 .marker-stale { opacity: 0.7; filter: grayscale(90%) brightness(0.8); }
 .last-seen-active { color: var(--status-green); }
 .last-seen-stale { color: var(--text-muted); }
+.last-seen-idle   { color: var(--status-yellow); }
 
 /* === Node Analytics === */
 .analytics-stats { display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; margin-bottom: 16px; }
diff --git a/test-frontend-helpers.js b/test-frontend-helpers.js
index e7df8576..ff82b47b 100644
--- a/test-frontend-helpers.js
+++ b/test-frontend-helpers.js
@@ -326,10 +326,10 @@ console.log('\n=== nodes.js: getStatusTooltip / getStatusInfo (extracted) ===');
 
   if (ex.getStatusInfo) {
     const gsi = ex.getStatusInfo;
-    test('active repeater status', () => {
+    test('active repeater status (idle — heard but no relay traffic)', () => {
       const info = gsi({ role: 'repeater', last_heard: new Date().toISOString() });
       assert.strictEqual(info.status, 'active');
-      assert.ok(info.statusLabel.includes('Active'));
+      assert.ok(info.statusLabel.includes('Idle'));
     });
     test('stale companion status (old date)', () => {
       const old = new Date(Date.now() - 48 * 3600000).toISOString();
@@ -3796,9 +3796,9 @@ console.log('\n=== nodes.js: getStatusInfo edge cases ===');
     assert.strictEqual(info.status, 'stale');
   });
 
-  test('getStatusInfo returns explanation for active node', () => {
+  test('getStatusInfo returns explanation for active repeater (idle)', () => {
     const info = gsi({ role: 'repeater', last_heard: new Date().toISOString() });
-    assert.ok(info.explanation.includes('Last heard'));
+    assert.ok(info.explanation.includes('no relay traffic'));
   });
 
   test('getStatusInfo returns explanation for stale companion', () => {

From 30771a818b948ecc7df23ca1b0543d540bf36af5 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Wed, 15 Apr 2026 13:11:55 +0200
Subject: [PATCH 23/32] test(frontend): add coverage for relaying state in
 getStatusInfo (#662)

---
 test-frontend-helpers.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/test-frontend-helpers.js b/test-frontend-helpers.js
index ff82b47b..9c653f5f 100644
--- a/test-frontend-helpers.js
+++ b/test-frontend-helpers.js
@@ -346,6 +346,19 @@ console.log('\n=== nodes.js: getStatusTooltip / getStatusInfo (extracted) ===');
       const info = gsi({ role: 'repeater', last_heard: d });
       assert.strictEqual(info.status, 'active');
     });
+    test('relaying repeater statusLabel and explanation', () => {
+      const info = gsi({ role: 'repeater', last_heard: new Date().toISOString(),
+        stats: { relay_count_24h: 42, relay_count_1h: 5, last_relayed: new Date().toISOString() } });
+      assert.strictEqual(info.status, 'relaying');
+      assert.ok(info.statusLabel.includes('Relaying'), 'statusLabel should include Relaying');
+      assert.ok(info.explanation.includes('42 packet'), 'explanation should include packet count');
+    });
+    test('relaying repeater with relay_count_24h === 1 uses singular', () => {
+      const info = gsi({ role: 'repeater', last_heard: new Date().toISOString(),
+        stats: { relay_count_24h: 1 } });
+      assert.ok(info.explanation.includes('1 packet'), 'should have singular');
+      assert.ok(!info.explanation.includes('1 packets'), 'should not have plural');
+    });
   }
 
   if (ex.renderNodeBadges) {

From 212415d480a5379fb371b3936d79bbacb30b95e8 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 16 Apr 2026 10:58:32 +0200
Subject: [PATCH 24/32] fix: address PR review remarks (#662)

- removeFromRelayTimeIndex: use in-place append instead of extra allocation
- roles.js: revert window.HEALTH_THRESHOLDS to bare HEALTH_THRESHOLDS; fix test to expose bare global in VM context
- docs: remove plan/spec process artifacts from repo
- relayMetrics: document last_relayed behavior for entries older than 24h
- addTxToRelayTimeIndex: add comment explaining FirstSeen parse rationale
- nodes.js: show last relayed time in idle repeater explanation when available
- nodes.js: fix relay stats template indentation in both detail pane blocks
- TestRelayTimesWiredIntoIngest: add relayKeys <= hopKeys bounds assertion

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/relay_liveness_test.go             |    3 +
 cmd/server/store.go                           |   11 +-
 .../plans/2026-04-15-repeater-liveness.md     | 1059 -----------------
 .../2026-04-15-repeater-liveness-design.md    |  163 ---
 public/nodes.js                               |   17 +-
 public/roles.js                               |    2 +-
 test-repeater-liveness.js                     |    3 +
 7 files changed, 21 insertions(+), 1237 deletions(-)
 delete mode 100644 docs/superpowers/plans/2026-04-15-repeater-liveness.md
 delete mode 100644 docs/superpowers/specs/2026-04-15-repeater-liveness-design.md

diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index b98f00d7..95f999d4 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -177,6 +177,9 @@ func TestRelayTimesWiredIntoIngest(t *testing.T) {
 	if relayKeys == 0 {
 		t.Fatalf("relayTimes not populated: byPathHop has %d keys but relayTimes has 0", hopKeys)
 	}
+	if relayKeys > hopKeys {
+		t.Errorf("relayTimes has more keys (%d) than byPathHop (%d) — relay index should be a subset", relayKeys, hopKeys)
+	}
 	t.Logf("byPathHop keys: %d, relayTimes keys: %d", hopKeys, relayKeys)
 }
 
diff --git a/cmd/server/store.go b/cmd/server/store.go
index 5353f5fd..1944d91e 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -2476,6 +2476,8 @@ func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
 	if len(tx.ResolvedPath) == 0 {
 		return
 	}
+	// Parse FirstSeen on each call. StoreTx has no cached millis field;
+	// RFC3339 parse is cheap relative to the binary-search insert that follows.
 	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
 	if err != nil {
 		return
@@ -2524,11 +2526,8 @@ func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
 		slice := idx[pk]
 		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
 		if i < len(slice) && slice[i] == millis {
-			newSlice := make([]int64, 0, len(slice)-1)
-			newSlice = append(newSlice, slice[:i]...)
-			newSlice = append(newSlice, slice[i+1:]...)
-			idx[pk] = newSlice
-			if len(newSlice) == 0 {
+			idx[pk] = append(slice[:i], slice[i+1:]...)
+			if len(idx[pk]) == 0 {
 				delete(idx, pk)
 			}
 		}
@@ -2537,6 +2536,8 @@ func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
 
 // relayMetrics computes relay_count_1h, relay_count_24h, and last_relayed from a
 // sorted unix-millis slice. now is time.Now().UnixMilli(). O(log n).
+// last_relayed is always the most recent entry regardless of window age — callers
+// receive it even when both counts are zero (e.g. "last relayed 3 days ago").
 func relayMetrics(times []int64, now int64) (count1h, count24h int, lastRelayed string) {
 	if len(times) == 0 {
 		return 0, 0, ""
diff --git a/docs/superpowers/plans/2026-04-15-repeater-liveness.md b/docs/superpowers/plans/2026-04-15-repeater-liveness.md
deleted file mode 100644
index 53badc61..00000000
--- a/docs/superpowers/plans/2026-04-15-repeater-liveness.md
+++ /dev/null
@@ -1,1059 +0,0 @@
-# Repeater Liveness Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Distinguish repeaters that are actively relaying traffic from those that are alive but idle, using a precomputed O(log n) sorted-timestamp index.
-
-**Architecture:** Add `relayTimes map[string][]int64` to `PacketStore`, maintained in lockstep with `byPathHop`. Relay counts for 1h/24h windows are computed via binary search at query time and injected into the existing `/api/nodes/bulk-health` and `/api/nodes/{pubkey}/health` responses. Frontend extends `getNodeStatus` to return a third state (`'relaying'`) for repeaters with recent relay activity.
-
-**Tech Stack:** Go (backend), vanilla JS (frontend), Node.js (frontend tests), SQLite (no schema changes needed)
-
----
-
-## File Map
-
-| File | Action | What changes |
-|---|---|---|
-| `cmd/server/store.go` | Modify | Add `relayTimes` field; add `addTxToRelayTimeIndex`, `removeFromRelayTimeIndex`, `relayMetrics` functions; wire into `buildPathHopIndex`, `addTxToPathHopIndex`, `removeTxFromPathHopIndex`; enrich `GetBulkHealth` and `GetNodeHealth` |
-| `cmd/server/relay_liveness_test.go` | Create | Go unit + integration tests for all relay index functions and API enrichment |
-| `public/roles.js` | Modify | Extend `getNodeStatus` with optional third param `relayCount24h`; add `'relaying'` return value |
-| `public/nodes.js` | Modify | Update `getStatusInfo`, `getStatusTooltip`, node list row, node detail pane stats table |
-| `public/style.css` | Modify | Add `.last-seen-idle` CSS class |
-| `test-repeater-liveness.js` | Create | Frontend unit tests for the three-state logic |
-
----
-
-## Task 1: Backend — `relayTimes` index field and pure functions
-
-**Files:**
-- Modify: `cmd/server/store.go`
-- Create: `cmd/server/relay_liveness_test.go`
-
-- [ ] **Step 1: Write failing tests for the pure index functions**
-
-Create `cmd/server/relay_liveness_test.go`:
-
-```go
-package main
-
-import (
-	"sort"
-	"strings"
-	"testing"
-	"time"
-)
-
-func makeRp(s string) *string { return &s }
-
-func TestAddTxToRelayTimeIndex_SingleNode(t *testing.T) {
-	idx := make(map[string][]int64)
-	pk := "aabbccdd11223344"
-	ts := time.Now().Add(-30 * time.Minute).UTC()
-	tx := &StoreTx{
-		FirstSeen:    ts.Format(time.RFC3339),
-		ResolvedPath: []*string{makeRp(pk)},
-	}
-	addTxToRelayTimeIndex(idx, tx)
-	if len(idx[pk]) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(idx[pk]))
-	}
-	wantMs := ts.UnixMilli()
-	// RFC3339 has second precision, so allow ±1000ms
-	if diff := idx[pk][0] - wantMs; diff < -1000 || diff > 1000 {
-		t.Errorf("timestamp mismatch: got %d, want ~%d", idx[pk][0], wantMs)
-	}
-}
-
-func TestAddTxToRelayTimeIndex_SortedOrder(t *testing.T) {
-	idx := make(map[string][]int64)
-	pk := "aabbccdd11223344"
-	t1 := time.Now().Add(-2 * time.Hour).UTC()
-	t2 := time.Now().Add(-30 * time.Minute).UTC()
-
-	// Insert newer first, expect sorted ascending
-	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
-	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
-	addTxToRelayTimeIndex(idx, tx2)
-	addTxToRelayTimeIndex(idx, tx1)
-
-	if len(idx[pk]) != 2 {
-		t.Fatalf("expected 2 entries, got %d", len(idx[pk]))
-	}
-	if !sort.SliceIsSorted(idx[pk], func(i, j int) bool { return idx[pk][i] < idx[pk][j] }) {
-		t.Error("relayTimes slice not sorted ascending")
-	}
-}
-
-func TestAddTxToRelayTimeIndex_MultipleNodes(t *testing.T) {
-	idx := make(map[string][]int64)
-	pk1 := "aabbccdd11223344"
-	pk2 := "eeff001122334455"
-	ts := time.Now().Add(-10 * time.Minute).UTC()
-	tx := &StoreTx{
-		FirstSeen:    ts.Format(time.RFC3339),
-		ResolvedPath: []*string{makeRp(pk1), makeRp(pk2)},
-	}
-	addTxToRelayTimeIndex(idx, tx)
-	if len(idx[pk1]) != 1 {
-		t.Errorf("pk1: expected 1 entry, got %d", len(idx[pk1]))
-	}
-	if len(idx[pk2]) != 1 {
-		t.Errorf("pk2: expected 1 entry, got %d", len(idx[pk2]))
-	}
-}
-
-func TestAddTxToRelayTimeIndex_NilResolvedPath(t *testing.T) {
-	idx := make(map[string][]int64)
-	tx := &StoreTx{FirstSeen: time.Now().UTC().Format(time.RFC3339), ResolvedPath: nil}
-	addTxToRelayTimeIndex(idx, tx) // must not panic
-	if len(idx) != 0 {
-		t.Error("expected empty index for nil ResolvedPath")
-	}
-}
-
-func TestAddTxToRelayTimeIndex_DuplicatePubkeyInPath(t *testing.T) {
-	idx := make(map[string][]int64)
-	pk := "aabbccdd11223344"
-	ts := time.Now().UTC()
-	tx := &StoreTx{
-		FirstSeen:    ts.Format(time.RFC3339),
-		ResolvedPath: []*string{makeRp(pk), makeRp(pk)}, // same pubkey twice
-	}
-	addTxToRelayTimeIndex(idx, tx)
-	if len(idx[pk]) != 1 {
-		t.Errorf("duplicate pubkey should produce only 1 entry, got %d", len(idx[pk]))
-	}
-}
-
-func TestRemoveFromRelayTimeIndex_RemovesEntry(t *testing.T) {
-	idx := make(map[string][]int64)
-	pk := "aabbccdd11223344"
-	ts := time.Now().Add(-1 * time.Hour).UTC()
-	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
-
-	addTxToRelayTimeIndex(idx, tx)
-	if len(idx[pk]) != 1 {
-		t.Fatal("setup: expected 1 entry")
-	}
-	removeFromRelayTimeIndex(idx, tx)
-	if _, ok := idx[pk]; ok {
-		t.Error("expected key deleted after last entry removed")
-	}
-}
-
-func TestRemoveFromRelayTimeIndex_PartialRemove(t *testing.T) {
-	idx := make(map[string][]int64)
-	pk := "aabbccdd11223344"
-	t1 := time.Now().Add(-2 * time.Hour).UTC()
-	t2 := time.Now().Add(-30 * time.Minute).UTC()
-	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
-	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
-
-	addTxToRelayTimeIndex(idx, tx1)
-	addTxToRelayTimeIndex(idx, tx2)
-	removeFromRelayTimeIndex(idx, tx1)
-
-	if len(idx[pk]) != 1 {
-		t.Errorf("expected 1 entry after removing one, got %d", len(idx[pk]))
-	}
-}
-
-func TestRelayMetrics_Counts(t *testing.T) {
-	now := time.Now().UnixMilli()
-	times := []int64{
-		now - 90*60*1000, // 90 min ago — inside 24h, outside 1h
-		now - 30*60*1000, // 30 min ago — inside both
-		now - 10*60*1000, // 10 min ago — inside both
-	}
-	c1h, c24h, lastRelayed := relayMetrics(times, now)
-	if c1h != 2 {
-		t.Errorf("relay_count_1h: expected 2, got %d", c1h)
-	}
-	if c24h != 3 {
-		t.Errorf("relay_count_24h: expected 3, got %d", c24h)
-	}
-	if lastRelayed == "" {
-		t.Error("last_relayed should not be empty")
-	}
-}
-
-func TestRelayMetrics_EmptySlice(t *testing.T) {
-	c1h, c24h, lastRelayed := relayMetrics(nil, time.Now().UnixMilli())
-	if c1h != 0 || c24h != 0 || lastRelayed != "" {
-		t.Errorf("empty slice: expected zeros and empty string, got %d %d %q", c1h, c24h, lastRelayed)
-	}
-}
-
-func TestRelayMetrics_AllOutsideWindow(t *testing.T) {
-	now := time.Now().UnixMilli()
-	times := []int64{now - 30*24*60*60*1000} // 30 days ago
-	c1h, c24h, _ := relayMetrics(times, now)
-	if c1h != 0 || c24h != 0 {
-		t.Errorf("expected 0/0 for old entry, got %d/%d", c1h, c24h)
-	}
-}
-
-func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
-	idx := make(map[string][]int64)
-	pkUpper := "AABBCCDD11223344"
-	pkLower := strings.ToLower(pkUpper)
-	ts := time.Now().UTC()
-	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pkUpper)}}
-	addTxToRelayTimeIndex(idx, tx)
-	if len(idx[pkLower]) != 1 {
-		t.Errorf("expected index keyed by lowercase, found %d entries at lowercase key", len(idx[pkLower]))
-	}
-	if len(idx[pkUpper]) != 0 {
-		t.Errorf("expected no entry at uppercase key")
-	}
-}
-```
-
-- [ ] **Step 2: Run tests to confirm they all fail**
-
-```bash
-cd cmd/server && go test -run "TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics" ./... 2>&1
-```
-
-Expected: compile error — `addTxToRelayTimeIndex`, `removeFromRelayTimeIndex`, `relayMetrics` undefined.
-
-- [ ] **Step 3: Add `relayTimes` field to `PacketStore` struct**
-
-In `cmd/server/store.go`, find the struct field block around line 134 that has `byPathHop`:
-
-```go
-byPathHop     map[string][]*StoreTx      // lowercase hop/pubkey → transmissions with that hop in path
-```
-
-Add after it:
-
-```go
-relayTimes    map[string][]int64         // lowercase pubkey → sorted unix-millis of relay events (full pubkeys only)
-```
-
-- [ ] **Step 4: Initialize `relayTimes` in `newPacketStore`**
-
-Find the block around line 289 that initializes `byPathHop`:
-
-```go
-byPathHop:     make(map[string][]*StoreTx),
-```
-
-Add after it:
-
-```go
-relayTimes:    make(map[string][]int64),
-```
-
-- [ ] **Step 5: Implement `addTxToRelayTimeIndex`, `removeFromRelayTimeIndex`, `relayMetrics`**
-
-Add these three functions to `cmd/server/store.go` directly after the `addTxToPathHopIndex` function (around line 2452):
-
-```go
-// addTxToRelayTimeIndex records the relay timestamp for each full pubkey in
-// tx.ResolvedPath. Maintains sorted ascending order for O(log n) window queries.
-// Must be called with s.mu held (or during build before store is live).
-func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
-	if len(tx.ResolvedPath) == 0 {
-		return
-	}
-	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
-	if err != nil {
-		return
-	}
-	millis := ms.UnixMilli()
-	seen := make(map[string]bool, len(tx.ResolvedPath))
-	for _, rp := range tx.ResolvedPath {
-		if rp == nil {
-			continue
-		}
-		pk := strings.ToLower(*rp)
-		if seen[pk] {
-			continue
-		}
-		seen[pk] = true
-		slice := idx[pk]
-		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
-		slice = append(slice, 0)
-		copy(slice[i+1:], slice[i:])
-		slice[i] = millis
-		idx[pk] = slice
-	}
-}
-
-// removeFromRelayTimeIndex removes the relay timestamp for each full pubkey in
-// tx.ResolvedPath. Inverse of addTxToRelayTimeIndex.
-func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
-	if len(tx.ResolvedPath) == 0 {
-		return
-	}
-	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
-	if err != nil {
-		return
-	}
-	millis := ms.UnixMilli()
-	seen := make(map[string]bool, len(tx.ResolvedPath))
-	for _, rp := range tx.ResolvedPath {
-		if rp == nil {
-			continue
-		}
-		pk := strings.ToLower(*rp)
-		if seen[pk] {
-			continue
-		}
-		seen[pk] = true
-		slice := idx[pk]
-		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
-		if i < len(slice) && slice[i] == millis {
-			idx[pk] = append(slice[:i], slice[i+1:]...)
-			if len(idx[pk]) == 0 {
-				delete(idx, pk)
-			}
-		}
-	}
-}
-
-// relayMetrics computes relay_count_1h, relay_count_24h, and last_relayed from a
-// sorted unix-millis slice. now is time.Now().UnixMilli(). O(log n).
-func relayMetrics(times []int64, now int64) (count1h, count24h int, lastRelayed string) {
-	if len(times) == 0 {
-		return 0, 0, ""
-	}
-	i1h := sort.Search(len(times), func(i int) bool { return times[i] >= now-3600000 })
-	i24h := sort.Search(len(times), func(i int) bool { return times[i] >= now-86400000 })
-	count1h = len(times) - i1h
-	count24h = len(times) - i24h
-	lastRelayed = time.UnixMilli(times[len(times)-1]).UTC().Format(time.RFC3339)
-	return
-}
-```
-
-- [ ] **Step 6: Run tests — expect pass**
-
-```bash
-cd cmd/server && go test -run "TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics" ./... -v 2>&1
-```
-
-Expected: all 10 tests PASS.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add cmd/server/store.go cmd/server/relay_liveness_test.go
-git commit -m "feat(store): add relayTimes index and relay metrics functions (#662)"
-```
-
----
-
-## Task 2: Backend — wire `relayTimes` into ingest/evict/build paths
-
-**Files:**
-- Modify: `cmd/server/store.go`
-
-- [ ] **Step 1: Wire into `addTxToPathHopIndex`**
-
-Find the function `addTxToPathHopIndex` (around line 2432). It ends with the closing `}`. Add a call to `addTxToRelayTimeIndex` — but `addTxToPathHopIndex` takes `idx map[string][]*StoreTx`, not the store itself. The relay index needs to be passed separately.
-
-The three call sites of `addTxToPathHopIndex` all hold `s.mu`. Change each call site instead of the function signature — add a paired call right after each `addTxToPathHopIndex`:
-
-**Site 1** — ingest (around line 1485):
-```go
-addTxToPathHopIndex(s.byPathHop, tx)
-addTxToRelayTimeIndex(s.relayTimes, tx)
-```
-
-**Site 2** — path resolution update (around line 1871):
-```go
-addTxToPathHopIndex(s.byPathHop, tx)
-addTxToRelayTimeIndex(s.relayTimes, tx)
-```
-
-- [ ] **Step 2: Wire into `removeTxFromPathHopIndex` call sites**
-
-Find `removeTxFromPathHopIndex(s.byPathHop, tx)` (two call sites — eviction around line 2793 and path-reindex around line 1862). Add paired remove call after each:
-
-**Site 1** — eviction (around line 2793):
-```go
-removeTxFromPathHopIndex(s.byPathHop, tx)
-removeFromRelayTimeIndex(s.relayTimes, tx)
-```
-
-**Site 2** — path reindex (around line 1862):
-```go
-removeTxFromPathHopIndex(s.byPathHop, tx)
-removeFromRelayTimeIndex(s.relayTimes, tx)
-```
-
-- [ ] **Step 3: Wire into `buildPathHopIndex`**
-
-Find `buildPathHopIndex` (around line 2422). It currently does:
-
-```go
-func (s *PacketStore) buildPathHopIndex() {
-	s.byPathHop = make(map[string][]*StoreTx, 4096)
-	for _, tx := range s.packets {
-		addTxToPathHopIndex(s.byPathHop, tx)
-	}
-	log.Printf("[store] Built path-hop index: %d unique keys", len(s.byPathHop))
-}
-```
-
-Replace with:
-
-```go
-func (s *PacketStore) buildPathHopIndex() {
-	s.byPathHop = make(map[string][]*StoreTx, 4096)
-	s.relayTimes = make(map[string][]int64, 4096)
-	for _, tx := range s.packets {
-		addTxToPathHopIndex(s.byPathHop, tx)
-		addTxToRelayTimeIndex(s.relayTimes, tx)
-	}
-	log.Printf("[store] Built path-hop index: %d unique keys, %d relay-time keys", len(s.byPathHop), len(s.relayTimes))
-}
-```
-
-- [ ] **Step 4: Write integration test for wired ingest**
-
-Add to `cmd/server/relay_liveness_test.go`:
-
-```go
-func TestRelayTimesWiredIntoIngest(t *testing.T) {
-	srv, _ := setupTestServer(t)
-
-	srv.store.mu.RLock()
-	hopKeys := len(srv.store.byPathHop)
-	relayKeys := len(srv.store.relayTimes)
-	srv.store.mu.RUnlock()
-
-	if hopKeys == 0 {
-		t.Skip("no path-hop data in test store — skipping relay wiring test")
-	}
-	// relayTimes will only be populated if test packets have ResolvedPath entries.
-	// At minimum it must not panic and must be initialised.
-	if srv.store.relayTimes == nil {
-		t.Fatal("relayTimes map is nil after load")
-	}
-	t.Logf("byPathHop keys: %d, relayTimes keys: %d", hopKeys, relayKeys)
-}
-```
-
-- [ ] **Step 5: Run all relay tests**
-
-```bash
-cd cmd/server && go test -run "TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics|TestRelayTimesWired" ./... -v 2>&1
-```
-
-Expected: all pass.
-
-- [ ] **Step 6: Run full backend test suite**
-
-```bash
-cd cmd/server && go test ./... 2>&1
-```
-
-Expected: no regressions.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add cmd/server/store.go cmd/server/relay_liveness_test.go
-git commit -m "feat(store): wire relayTimes into ingest, evict, and build paths (#662)"
-```
-
----
-
-## Task 3: Backend API — enrich bulk-health and node-health with relay metrics
-
-**Files:**
-- Modify: `cmd/server/store.go`
-
-- [ ] **Step 1: Write failing tests for relay fields in API responses**
-
-Add to `cmd/server/relay_liveness_test.go`:
-
-```go
-func TestGetBulkHealthRepeaterRelayFields(t *testing.T) {
-	srv, _ := setupTestServer(t)
-
-	// Insert a synthetic repeater node into the DB if none exists
-	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
-		VALUES ('relay662test0001', 'TestRepeater662', 'repeater', datetime('now'), datetime('now'), 1)`)
-	if err != nil {
-		t.Fatalf("insert test node: %v", err)
-	}
-
-	// Inject a relay timestamp within the last hour
-	pk := "relay662test0001"
-	now := time.Now().UnixMilli()
-	recentMs := now - 10*60*1000 // 10 min ago
-	srv.store.mu.Lock()
-	srv.store.relayTimes[pk] = []int64{recentMs}
-	srv.store.mu.Unlock()
-
-	results := srv.store.GetBulkHealth(200, "")
-
-	var found map[string]interface{}
-	for _, r := range results {
-		if r["public_key"] == pk {
-			found = r
-			break
-		}
-	}
-	if found == nil {
-		t.Fatal("test repeater not found in GetBulkHealth results")
-	}
-
-	stats, ok := found["stats"].(map[string]interface{})
-	if !ok {
-		t.Fatal("missing stats map in result")
-	}
-
-	if v, ok := stats["relay_count_1h"].(int); !ok || v != 1 {
-		t.Errorf("relay_count_1h: expected 1, got %v", stats["relay_count_1h"])
-	}
-	if v, ok := stats["relay_count_24h"].(int); !ok || v != 1 {
-		t.Errorf("relay_count_24h: expected 1, got %v", stats["relay_count_24h"])
-	}
-	if _, ok := stats["last_relayed"].(string); !ok {
-		t.Errorf("last_relayed: expected string, got %T", stats["last_relayed"])
-	}
-}
-
-func TestGetBulkHealthCompanionNoRelayFields(t *testing.T) {
-	srv, _ := setupTestServer(t)
-
-	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
-		VALUES ('comp662test0001', 'TestCompanion662', 'companion', datetime('now'), datetime('now'), 1)`)
-	if err != nil {
-		t.Fatalf("insert test node: %v", err)
-	}
-
-	// Give the companion a relay entry (should be ignored by role gate)
-	pk := "comp662test0001"
-	srv.store.mu.Lock()
-	srv.store.relayTimes[pk] = []int64{time.Now().UnixMilli() - 5*60*1000}
-	srv.store.mu.Unlock()
-
-	results := srv.store.GetBulkHealth(200, "")
-	for _, r := range results {
-		if r["public_key"] == pk {
-			stats, _ := r["stats"].(map[string]interface{})
-			if _, present := stats["relay_count_24h"]; present {
-				t.Error("relay_count_24h should be absent for companion nodes")
-			}
-			return
-		}
-	}
-	t.Fatal("test companion not found in GetBulkHealth results")
-}
-
-func TestGetBulkHealthRepeaterNoRelayActivity(t *testing.T) {
-	srv, _ := setupTestServer(t)
-
-	_, err := srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
-		VALUES ('relay662idle001', 'IdleRepeater662', 'repeater', datetime('now'), datetime('now'), 1)`)
-	if err != nil {
-		t.Fatalf("insert test node: %v", err)
-	}
-
-	// No entry in relayTimes for this node
-	results := srv.store.GetBulkHealth(200, "")
-	for _, r := range results {
-		if r["public_key"] == "relay662idle001" {
-			stats, _ := r["stats"].(map[string]interface{})
-			if v, ok := stats["relay_count_24h"].(int); !ok || v != 0 {
-				t.Errorf("relay_count_24h: expected 0, got %v", stats["relay_count_24h"])
-			}
-			if _, present := stats["last_relayed"]; present {
-				t.Error("last_relayed should be absent when no relay activity")
-			}
-			return
-		}
-	}
-	t.Fatal("idle repeater not found in results")
-}
-```
-
-- [ ] **Step 2: Run tests to confirm they fail**
-
-```bash
-cd cmd/server && go test -run "TestGetBulkHealth" ./... 2>&1
-```
-
-Expected: FAIL — relay fields missing from stats map.
-
-- [ ] **Step 3: Enrich `GetBulkHealth` with relay metrics**
-
-In `GetBulkHealth` (around line 5945), find where the `stats` map is built (around line 6099–6106):
-
-```go
-results = append(results, map[string]interface{}{
-    "public_key": n.pk,
-    "name":       nilIfEmpty(n.name),
-    "role":       nilIfEmpty(n.role),
-    "lat":        n.lat,
-    "lon":        n.lon,
-    "stats": map[string]interface{}{
-        "totalTransmissions": len(packets),
-        "totalObservations":  totalObservations,
-        "totalPackets":       len(packets),
-        "packetsToday":       packetsToday,
-        "avgSnr":             avgSnr,
-        "lastHeard":          lhVal,
-    },
-    "observers": observerRows,
-})
-```
-
-Replace the `stats` map construction with:
-
-```go
-statsMap := map[string]interface{}{
-    "totalTransmissions": len(packets),
-    "totalObservations":  totalObservations,
-    "totalPackets":       len(packets),
-    "packetsToday":       packetsToday,
-    "avgSnr":             avgSnr,
-    "lastHeard":          lhVal,
-}
-if strings.ToLower(n.role) == "repeater" {
-    c1h, c24h, lastRel := relayMetrics(s.relayTimes[n.pk], time.Now().UnixMilli())
-    statsMap["relay_count_1h"] = c1h
-    statsMap["relay_count_24h"] = c24h
-    if lastRel != "" {
-        statsMap["last_relayed"] = lastRel
-    }
-}
-results = append(results, map[string]interface{}{
-    "public_key": n.pk,
-    "name":       nilIfEmpty(n.name),
-    "role":       nilIfEmpty(n.role),
-    "lat":        n.lat,
-    "lon":        n.lon,
-    "stats":      statsMap,
-    "observers":  observerRows,
-})
-```
-
-- [ ] **Step 4: Enrich `GetNodeHealth` with relay metrics**
-
-In `GetNodeHealth` (around line 6117), find where the final result map is assembled (look for `"lastHeard"` key in the stats sub-map — it's around line 6230–6260 depending on exact file state). The stats map will have a shape like:
-
-```go
-"stats": map[string]interface{}{
-    "totalTransmissions": ...,
-    "totalObservations":  ...,
-    "totalPackets":       ...,
-    "packetsToday":       ...,
-    "avgSnr":             ...,
-    "lastHeard":          lastHeardVal,
-    "avgHops":            ...,
-},
-```
-
-After assembling that `stats` map (name it `nodeStats` if it isn't already named), add before the final `return`:
-
-```go
-role := ""
-if r, ok := node["role"].(string); ok {
-    role = strings.ToLower(r)
-}
-if role == "repeater" {
-    lowerPK := strings.ToLower(pubkey)
-    c1h, c24h, lastRel := relayMetrics(s.relayTimes[lowerPK], time.Now().UnixMilli())
-    nodeStats["relay_count_1h"] = c1h
-    nodeStats["relay_count_24h"] = c24h
-    if lastRel != "" {
-        nodeStats["last_relayed"] = lastRel
-    }
-}
-```
-
-> Note: `GetNodeHealth` releases `s.mu` via `defer s.mu.RUnlock()` at entry — relay metrics are computed inside the lock, which is correct.
-
-- [ ] **Step 5: Run all relay tests**
-
-```bash
-cd cmd/server && go test -run "TestGetBulkHealth|TestAddTxToRelayTimeIndex|TestRemoveFromRelayTimeIndex|TestRelayMetrics|TestRelayTimesWired" ./... -v 2>&1
-```
-
-Expected: all pass.
-
-- [ ] **Step 6: Run full backend test suite**
-
-```bash
-cd cmd/server && go test ./... 2>&1
-```
-
-Expected: no regressions.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add cmd/server/store.go cmd/server/relay_liveness_test.go
-git commit -m "feat(api): add relay_count_1h/24h/last_relayed to node health responses (#662)"
-```
-
----
-
-## Task 4: Frontend — extend `getNodeStatus` to three-state (TDD)
-
-**Files:**
-- Modify: `public/roles.js`
-- Create: `test-repeater-liveness.js`
-
-- [ ] **Step 1: Write the failing frontend test file**
-
-Create `test-repeater-liveness.js` at the repo root:
-
-```js
-'use strict';
-const vm = require('vm');
-const fs = require('fs');
-
-// Minimal browser environment
-const ctx = {
-  window: {},
-  console,
-  fetch: () => Promise.resolve({ json: () => Promise.resolve({}) }),
-  Date,
-};
-vm.createContext(ctx);
-vm.runInContext(fs.readFileSync('public/roles.js', 'utf8'), ctx);
-
-const { getNodeStatus, HEALTH_THRESHOLDS } = ctx.window;
-
-let pass = 0, fail = 0;
-function test(name, fn) {
-  try { fn(); pass++; console.log('  ok:', name); }
-  catch (e) { fail++; console.log('FAIL:', name, '—', e.message); }
-}
-function assert(cond, msg) { if (!cond) throw new Error(msg || 'assertion failed'); }
-
-const now = Date.now();
-const recentMs = now - 1000;                                     // 1 second ago — always active
-const staleMs  = now - (HEALTH_THRESHOLDS.infraSilentMs + 1);   // just past silent threshold
-
-// --- Repeater three-state ---
-test('repeater + recent + relay > 0 → relaying',
-  () => assert(getNodeStatus('repeater', recentMs, 5) === 'relaying'));
-
-test('repeater + recent + relay == 0 → active (idle)',
-  () => assert(getNodeStatus('repeater', recentMs, 0) === 'active'));
-
-test('repeater + stale + relay > 0 → stale (stale beats relay)',
-  () => assert(getNodeStatus('repeater', staleMs, 99) === 'stale'));
-
-test('repeater + stale + relay == 0 → stale',
-  () => assert(getNodeStatus('repeater', staleMs, 0) === 'stale'));
-
-// --- Non-repeater roles unaffected ---
-test('companion + recent + relay 0 → active',
-  () => assert(getNodeStatus('companion', recentMs, 0) === 'active'));
-
-test('companion + recent + relay > 0 → active (relay ignored)',
-  () => assert(getNodeStatus('companion', recentMs, 99) === 'active'));
-
-test('room + recent + relay 0 → active',
-  () => assert(getNodeStatus('room', recentMs, 0) === 'active'));
-
-test('sensor + recent + relay 0 → active',
-  () => assert(getNodeStatus('sensor', recentMs, 0) === 'active'));
-
-// --- Backward compatibility: omitting third arg ---
-test('getNodeStatus(repeater, recent) with no relay arg → active (not relaying)',
-  () => assert(getNodeStatus('repeater', recentMs) === 'active'));
-
-test('getNodeStatus(companion, recent) with no relay arg → active',
-  () => assert(getNodeStatus('companion', recentMs) === 'active'));
-
-console.log(`\n${pass} passed, ${fail} failed`);
-if (fail > 0) process.exit(1);
-```
-
-- [ ] **Step 2: Run tests to confirm they fail**
-
-```bash
-node test-repeater-liveness.js 2>&1
-```
-
-Expected: FAIL on `repeater + recent + relay > 0 → relaying` (returns `'active'` instead of `'relaying'`).
-
-- [ ] **Step 3: Extend `getNodeStatus` in `public/roles.js`**
-
-Find the existing function (around line 88):
-
-```js
-window.getNodeStatus = function (role, lastSeenMs) {
-    var isInfra = role === 'repeater' || role === 'room';
-    var staleMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
-    var age = typeof lastSeenMs === 'number' ? (Date.now() - lastSeenMs) : Infinity;
-    return age < staleMs ? 'active' : 'stale';
-};
-```
-
-Replace with:
-
-```js
-window.getNodeStatus = function (role, lastSeenMs, relayCount24h) {
-    var isInfra = role === 'repeater' || role === 'room';
-    var staleMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
-    var age = typeof lastSeenMs === 'number' ? (Date.now() - lastSeenMs) : Infinity;
-    if (age >= staleMs) return 'stale';
-    if (role === 'repeater') {
-      return (typeof relayCount24h === 'number' && relayCount24h > 0) ? 'relaying' : 'active';
-    }
-    return 'active';
-};
-```
-
-- [ ] **Step 4: Run tests to confirm they pass**
-
-```bash
-node test-repeater-liveness.js 2>&1
-```
-
-Expected: all 10 tests pass.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add public/roles.js test-repeater-liveness.js
-git commit -m "feat(frontend): extend getNodeStatus to three-state for repeaters (#662)"
-```
-
----
-
-## Task 5: Frontend — render three-state labels, CSS, and node detail pane
-
-**Files:**
-- Modify: `public/nodes.js`
-- Modify: `public/style.css`
-
-- [ ] **Step 1: Add `.last-seen-idle` CSS class to `public/style.css`**
-
-Find these two lines (around line 1590–1591):
-
-```css
-.last-seen-active { color: var(--status-green); }
-.last-seen-stale { color: var(--text-muted); }
-```
-
-Add after them:
-
-```css
-.last-seen-idle   { color: var(--status-yellow); }
-```
-
-- [ ] **Step 2: Update `getStatusTooltip` in `public/nodes.js`**
-
-Find the function (around line 113):
-
-```js
-function getStatusTooltip(role, status) {
-    const isInfra = role === 'repeater' || role === 'room';
-    const threshMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
-    const threshold = threshMs >= 3600000 ? Math.round(threshMs / 3600000) + 'h' : Math.round(threshMs / 60000) + 'm';
-    if (status === 'active') {
-      return 'Active \u2014 heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
-    }
-    if (role === 'companion') {
-      return 'Stale \u2014 not heard for over ' + threshold + '. Companions only advertise when the user initiates \u2014 this may be normal.';
-    }
-    if (role === 'sensor') {
-      return 'Stale \u2014 not heard for over ' + threshold + '. This sensor may be offline.';
-    }
-    return 'Stale \u2014 not heard for over ' + threshold + '. This ' + role + ' may be offline or out of range.';
-}
-```
-
-Replace with:
-
-```js
-function getStatusTooltip(role, status) {
-    const isInfra = role === 'repeater' || role === 'room';
-    const threshMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
-    const threshold = threshMs >= 3600000 ? Math.round(threshMs / 3600000) + 'h' : Math.round(threshMs / 60000) + 'm';
-    if (status === 'relaying') {
-      return 'Relaying \u2014 actively forwarding traffic within the last 24h.';
-    }
-    if (status === 'active') {
-      if (role === 'repeater') {
-        return 'Idle \u2014 alive (heard within ' + threshold + ') but no relay traffic observed in the last 24h. May be in a quiet area or have RF issues.';
-      }
-      return 'Active \u2014 heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
-    }
-    if (role === 'companion') {
-      return 'Stale \u2014 not heard for over ' + threshold + '. Companions only advertise when the user initiates \u2014 this may be normal.';
-    }
-    if (role === 'sensor') {
-      return 'Stale \u2014 not heard for over ' + threshold + '. This sensor may be offline.';
-    }
-    return 'Stale \u2014 not heard for over ' + threshold + '. This ' + role + ' may be offline or out of range.';
-}
-```
-
-- [ ] **Step 3: Update `getStatusInfo` in `public/nodes.js`**
-
-Find the function (around line 129):
-
-```js
-function getStatusInfo(n) {
-    // Single source of truth for all status-related info
-    const role = (n.role || '').toLowerCase();
-    const roleColor = ROLE_COLORS[n.role] || '#6b7280';
-    // Prefer last_heard (from in-memory packets) > _lastHeard (health API) > last_seen (DB)
-    const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
-    const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
-    const status = getNodeStatus(role, lastHeardMs);
-    const statusTooltip = getStatusTooltip(role, status);
-    const statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
-    const statusAge = lastHeardMs ? (Date.now() - lastHeardMs) : Infinity;
-
-    let explanation = '';
-    if (status === 'active') {
-      explanation = 'Last heard ' + (lastHeardTime ? renderNodeTimestampText(lastHeardTime) : 'unknown');
-    } else {
-      const ageDays = Math.floor(statusAge / 86400000);
-      const ageHours = Math.floor(statusAge / 3600000);
-      const ageStr = ageDays >= 1 ? ageDays + 'd' : ageHours + 'h';
-      const isInfra = role === 'repeater' || role === 'room';
-      const reason = isInfra
-        ? 'repeaters typically advertise every 12-24h'
-        : 'companions only advertise when user initiates, this may be normal';
-      explanation = 'Not heard for ' + ageStr + ' — ' + reason;
-    }
-
-    return { status, statusLabel, statusTooltip, statusAge, explanation, roleColor, lastHeardMs, role };
-}
-```
-
-Replace with:
-
-```js
-function getStatusInfo(n) {
-    // Single source of truth for all status-related info
-    const role = (n.role || '').toLowerCase();
-    const roleColor = ROLE_COLORS[n.role] || '#6b7280';
-    // Prefer last_heard (from in-memory packets) > _lastHeard (health API) > last_seen (DB)
-    const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
-    const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
-    const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
-    const relayCount1h  = (n.stats && typeof n.stats.relay_count_1h  === 'number') ? n.stats.relay_count_1h  : undefined;
-    const lastRelayed   = n.stats && n.stats.last_relayed;
-    const status = getNodeStatus(role, lastHeardMs, relayCount24h);
-    const statusTooltip = getStatusTooltip(role, status);
-    const statusAge = lastHeardMs ? (Date.now() - lastHeardMs) : Infinity;
-
-    let statusLabel;
-    if (role === 'repeater') {
-      statusLabel = status === 'relaying' ? '🟢 Relaying' : status === 'active' ? '🟡 Idle' : '⚪ Stale';
-    } else {
-      statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
-    }
-
-    let explanation = '';
-    if (status === 'relaying') {
-      explanation = 'Relayed ' + relayCount24h + ' packet' + (relayCount24h === 1 ? '' : 's') + ' in last 24h'
-        + (lastRelayed ? ', last ' + renderNodeTimestampText(lastRelayed) : '');
-    } else if (status === 'active' && role === 'repeater') {
-      explanation = 'Alive but no relay traffic observed in last 24h';
-    } else if (status === 'active') {
-      explanation = 'Last heard ' + (lastHeardTime ? renderNodeTimestampText(lastHeardTime) : 'unknown');
-    } else {
-      const ageDays = Math.floor(statusAge / 86400000);
-      const ageHours = Math.floor(statusAge / 3600000);
-      const ageStr = ageDays >= 1 ? ageDays + 'd' : ageHours + 'h';
-      const isInfra = role === 'repeater' || role === 'room';
-      const reason = isInfra
-        ? 'repeaters typically advertise every 12-24h'
-        : 'companions only advertise when user initiates, this may be normal';
-      explanation = 'Not heard for ' + ageStr + ' — ' + reason;
-    }
-
-    return { status, statusLabel, statusTooltip, statusAge, explanation, roleColor, lastHeardMs, role, relayCount1h, relayCount24h, lastRelayed };
-}
-```
-
-- [ ] **Step 4: Update the node list row CSS class mapping**
-
-Find the node list rendering (around line 1030–1031):
-
-```js
-const status = getNodeStatus(n.role || 'companion', lastSeenTime ? new Date(lastSeenTime).getTime() : 0);
-const lastSeenClass = status === 'active' ? 'last-seen-active' : 'last-seen-stale';
-```
-
-Replace with:
-
-```js
-const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
-const status = getNodeStatus((n.role || 'companion').toLowerCase(), lastSeenTime ? new Date(lastSeenTime).getTime() : 0, relayCount24h);
-const lastSeenClass = status === 'relaying' ? 'last-seen-active' : status === 'active' ? ((n.role || '').toLowerCase() === 'repeater' ? 'last-seen-idle' : 'last-seen-active') : 'last-seen-stale';
-```
-
-- [ ] **Step 5: Add relay stats rows to the node detail pane**
-
-Find the stats table in the detail pane (around line 490–494):
-
-```js
-${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
-${hasLoc ? `<tr><td>Location</td><td>...` : ''}
-```
-
-Add relay rows after `avgHops`:
-
-```js
-${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
-${si.role === 'repeater' ? `
-  <tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>
-  <tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>
-  ${si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}
-` : ''}
-${hasLoc ? `<tr><td>Location</td><td>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</td></tr>` : ''}
-```
-
-> Note: `si` is the return value of `getStatusInfo(n)` — already in scope in the detail render function. Verify the local variable name by checking the block around line 453.
-
-- [ ] **Step 6: Find and check the second detail panel (around line 1075)**
-
-There is a second node detail render path around line 1072. Apply the same relay rows addition there too — find the equivalent `avgHops` row and add the same relay block after it.
-
-- [ ] **Step 7: Run frontend tests**
-
-```bash
-node test-repeater-liveness.js && node test-packet-filter.js && node test-frontend-helpers.js && node test-live.js && node test-packets.js 2>&1
-```
-
-Expected: all pass.
-
-- [ ] **Step 8: Run backend tests**
-
-```bash
-cd cmd/server && go test ./... 2>&1
-```
-
-Expected: no regressions.
-
-- [ ] **Step 9: Commit**
-
-```bash
-git add public/nodes.js public/style.css
-git commit -m "feat(ui): three-state repeater liveness indicator and relay stats in detail pane (#662)"
-```
-
----
-
-## Done
-
-All four tasks complete. Verify end-to-end:
-
-```bash
-# Backend
-cd cmd/server && go test ./... -v 2>&1 | tail -20
-
-# Frontend
-node test-repeater-liveness.js && node test-packet-filter.js && node test-frontend-helpers.js && node test-live.js && node test-packets.js
-```
-
-Then start the server and open the Nodes page. A repeater with recent relay activity should show 🟢 Relaying; one that is alive but quiet should show 🟡 Idle.
diff --git a/docs/superpowers/specs/2026-04-15-repeater-liveness-design.md b/docs/superpowers/specs/2026-04-15-repeater-liveness-design.md
deleted file mode 100644
index d9cde1d2..00000000
--- a/docs/superpowers/specs/2026-04-15-repeater-liveness-design.md
+++ /dev/null
@@ -1,163 +0,0 @@
-# Repeater Liveness — Design Spec
-
-**Issue:** Kpa-clawbot/CoreScope#662
-**Date:** 2026-04-15
-**Status:** Approved
-
----
-
-## Problem
-
-CoreScope conflates two distinct repeater states into "active":
-
-| State | Adverts | In paths | Meaning |
-|---|---|---|---|
-| Relaying | Recent | Yes | Up and forwarding traffic |
-| Alive but idle | Recent | No | Up, but nothing routed through it |
-| Down | None | None | Offline |
-
-An operator cannot tell whether a repeater is healthy and carrying traffic, or healthy but not actually relaying anything.
-
----
-
-## Scope
-
-M1 (backend relay metrics) + M2 (frontend three-state indicator). M3 (repeater dashboard) is out of scope for this implementation.
-
----
-
-## Architecture
-
-### Data Structure (Backend)
-
-Add a parallel index to `PacketStore` in `store.go`:
-
-```go
-relayTimes map[string][]int64  // lowercase pubkey → sorted []int64 unix-millis
-```
-
-- Indexed by **full pubkeys only** (from `tx.ResolvedPath`) — not raw hop prefixes, avoiding hash-collision noise
-- Maintained under the existing `s.mu` RWMutex — no new lock needed
-- Lives parallel to `byPathHop`, sharing the same add/remove call sites
-
-### Index Maintenance
-
-**On add** — called from `addTxToPathHopIndex`:
-- For each non-nil entry in `tx.ResolvedPath`
-- Parse `tx.FirstSeen` → unix millis
-- Binary-search insert into sorted slice
-
-**On remove** — called from `removeTxFromPathHopIndex`:
-- For each non-nil entry in `tx.ResolvedPath`
-- Remove the millis value from the sorted slice
-
-**On build** — called from `buildPathHopIndex`:
-- Populate `relayTimes` in the same pass
-
-### Query (O(log n))
-
-```go
-now := time.Now().UnixMilli()
-times := s.relayTimes[lowerPK]
-count1h  := len(times) - sort.Search(len(times), func(i int) bool { return times[i] >= now-3600000 })
-count24h := len(times) - sort.Search(len(times), func(i int) bool { return times[i] >= now-86400000 })
-lastRelayed := times[len(times)-1]  // free — last element of sorted slice
-```
-
----
-
-## API
-
-No new endpoints. Relay metrics are added to existing health responses.
-
-### `GET /api/nodes/bulk-health` and `GET /api/nodes/{pubkey}/health`
-
-Added to the `stats` sub-object, **repeater nodes only** (fields absent for other roles):
-
-```json
-{
-  "stats": {
-    "lastHeard": "2026-04-15T10:00:00Z",
-    "packetsToday": 12,
-    "relay_count_1h": 3,
-    "relay_count_24h": 47,
-    "last_relayed": "2026-04-15T09:58:00Z"
-  }
-}
-```
-
-`last_relayed` is an RFC3339 string (consistent with existing timestamp fields). Omitted when `relayTimes[pk]` is empty.
-
----
-
-## Frontend
-
-### `roles.js` — extend `getNodeStatus`
-
-```js
-// Signature change:
-// Before: getNodeStatus(role, lastSeenMs) → 'active' | 'stale'
-// After:  getNodeStatus(role, lastSeenMs, relayCount24h) → 'relaying' | 'active' | 'stale'
-```
-
-Logic:
-- Non-repeaters: `relayCount24h` ignored, returns `'active'` or `'stale'` as before — **no behaviour change**
-- Repeaters:
-  - Stale threshold exceeded → `'stale'`
-  - Within threshold + `relayCount24h > 0` → `'relaying'`
-  - Within threshold + `relayCount24h == 0` → `'active'` (alive but idle)
-
-### `nodes.js` — `getStatusInfo` and render
-
-- Extract `relay_count_24h`, `relay_count_1h`, `last_relayed` from `n.stats`
-- Pass `relay_count_24h` into `getNodeStatus`
-
-**Status labels (repeaters):**
-
-| Status | Label | Explanation |
-|---|---|---|
-| `'relaying'` | `🟢 Relaying` | `"Relayed N packets in last 24h, last X ago"` |
-| `'active'` | `🟡 Idle` | `"Alive but no relay traffic in 24h"` |
-| `'stale'` | `⚪ Stale` | existing text |
-
-**Non-repeaters:** labels unchanged (`🟢 Active` / `⚪ Stale`).
-
-**Node detail pane:** relay stats row added to the stats table for repeaters:
-- `Relay (1h)` / `Relay (24h)` / `Last Relayed`
-- Row hidden for non-repeater roles
-
-**Status filter buttons:** `'relaying'` maps to the `active` bucket — filter UI unchanged.
-
----
-
-## Testing
-
-### Backend (Go) — new test cases in `store_test.go` or dedicated file
-
-- `addTxToRelayTimeIndex`: insert packets with known timestamps → verify sorted order
-- Count at 1h/24h boundaries: packets straddling the window edge → correct counts
-- `removeFromRelayTimeIndex`: add then remove → slice returns to original state
-- `GetBulkHealth` relay fields: repeater with relay activity → fields present; companion → fields absent
-- Eviction: add packets, evict oldest → relay_count_24h drops correctly
-- `last_relayed`: equals timestamp of most recently relayed packet
-- Empty `relayTimes`: no panic, fields omitted from response
-- Node with no pubkeys in `ResolvedPath`: `relayTimes` unchanged (raw hops ignored)
-
-### Frontend (Node.js) — `test-repeater-liveness.js`
-
-- `getNodeStatus('repeater', recentMs, 5)` → `'relaying'`
-- `getNodeStatus('repeater', recentMs, 0)` → `'active'`
-- `getNodeStatus('repeater', staleMs, 5)` → `'stale'`
-- `getNodeStatus('companion', recentMs, 0)` → `'active'` (no three-state for non-repeaters)
-- `getNodeStatus('companion', recentMs, 99)` → `'active'` (relay count ignored for non-repeaters)
-- Status label: `'relaying'` → `🟢 Relaying`
-- Status label: `'active'` on repeater → `🟡 Idle`
-
----
-
-## Limitations
-
-1. **Observer coverage gaps**: if no observer hears traffic through a repeater, relay activity won't be recorded even if the repeater is relaying. Inherent to passive observation.
-2. **Low-traffic networks**: zero relay activity ≠ broken. The "Idle" label must be clearly worded.
-3. **Hash collisions**: mitigated by indexing full pubkeys only (resolved path), not raw hop prefixes.
-4. **Memory**: `relayTimes` adds one `int64` per relay event per node. Bounded by store packet limit — acceptable.
diff --git a/public/nodes.js b/public/nodes.js
index bdf21669..d0534861 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -158,7 +158,8 @@
       explanation = 'Relayed ' + relayCount24h + ' packet' + (relayCount24h === 1 ? '' : 's') + ' in last 24h'
         + (lastRelayed ? ', last ' + renderNodeTimestampText(lastRelayed) : '');
     } else if (status === 'active' && role === 'repeater') {
-      explanation = 'Alive but no relay traffic observed in last 24h';
+      explanation = 'Alive but no relay traffic observed in last 24h'
+        + (lastRelayed ? ', last relayed ' + renderNodeTimestampText(lastRelayed) : '');
     } else if (status === 'active') {
       explanation = 'Last heard ' + (lastHeardTime ? renderNodeTimestampText(lastHeardTime) : 'unknown');
     } else {
@@ -512,10 +513,9 @@
           ${stats.avgSnr != null ? `<tr><td>Avg SNR</td><td>${Number(stats.avgSnr).toFixed(1)} dB</td></tr>` : ''}
           ${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
           ${si.role === 'repeater' ? `
-  <tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>
-  <tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>
-  ${si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}
-` : ''}
+          <tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>
+          <tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>
+          ${si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}` : ''}
           ${hasLoc ? `<tr><td>Location</td><td>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</td></tr>` : ''}
           <tr><td>Hash Prefix</td><td>${n.hash_size ? '<code style="font-family:var(--mono);font-weight:700">' + n.public_key.slice(0, n.hash_size * 2).toUpperCase() + '</code> (' + n.hash_size + '-byte)' : 'Unknown'}${n.hash_size_inconsistent ? ' <span style="color:var(--status-yellow);cursor:help" title="Seen: ' + (Array.isArray(n.hash_sizes_seen) ? n.hash_sizes_seen : []).join(', ') + '-byte">⚠️ varies</span>' : ''}</td></tr>
         </table>
@@ -1193,10 +1193,9 @@
             ${stats.avgSnr != null ? `<dt>Avg SNR</dt><dd>${Number(stats.avgSnr).toFixed(1)} dB</dd>` : ''}
             ${stats.avgHops ? `<dt>Avg Hops</dt><dd>${stats.avgHops}</dd>` : ''}
             ${si.role === 'repeater' ? `
-  <dt>Relay (1h)</dt><dd>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</dd>
-  <dt>Relay (24h)</dt><dd>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</dd>
-  ${si.lastRelayed ? `<dt>Last Relayed</dt><dd>${renderNodeTimestampHtml(si.lastRelayed)}</dd>` : ''}
-` : ''}
+            <dt>Relay (1h)</dt><dd>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</dd>
+            <dt>Relay (24h)</dt><dd>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</dd>
+            ${si.lastRelayed ? `<dt>Last Relayed</dt><dd>${renderNodeTimestampHtml(si.lastRelayed)}</dd>` : ''}` : ''}
             ${hasLoc ? `<dt>Location</dt><dd>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</dd>` : ''}
           </dl>
         </div>
diff --git a/public/roles.js b/public/roles.js
index 025617c3..00281c45 100644
--- a/public/roles.js
+++ b/public/roles.js
@@ -87,7 +87,7 @@
   // Three-state helper for repeaters: returns 'relaying', 'active', or 'stale'
   window.getNodeStatus = function (role, lastSeenMs, relayCount24h) {
     var isInfra = role === 'repeater' || role === 'room';
-    var staleMs = isInfra ? window.HEALTH_THRESHOLDS.infraSilentMs : window.HEALTH_THRESHOLDS.nodeSilentMs;
+    var staleMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
     var age = typeof lastSeenMs === 'number' ? (Date.now() - lastSeenMs) : Infinity;
     if (age >= staleMs) return 'stale';
     if (role === 'repeater') {
diff --git a/test-repeater-liveness.js b/test-repeater-liveness.js
index 9b91d184..4238c507 100644
--- a/test-repeater-liveness.js
+++ b/test-repeater-liveness.js
@@ -19,6 +19,9 @@ const ctx = {
 };
 vm.createContext(ctx);
 vm.runInContext(fs.readFileSync('public/roles.js', 'utf8'), ctx);
+// Mirror browser semantics: in a real browser window === globalThis, so bare
+// HEALTH_THRESHOLDS resolves the same as window.HEALTH_THRESHOLDS. Expose it here.
+ctx.HEALTH_THRESHOLDS = ctx.window.HEALTH_THRESHOLDS;
 
 // Run tests inside the VM context to preserve closures
 const testCode = `

From 3a2e55f3eb7834467410d97246f5031f324005fa Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 16 Apr 2026 11:21:12 +0200
Subject: [PATCH 25/32] fix(api): lowercase resolved pubkey in
 addTxToPathHopIndex (#662)

byPathHop was storing resolved pubkeys with original case while
relayTimes and routes.go lookups (addCandidates(lowerPK)) both use
lowercase, breaking the subset invariant and causing missed lookups for
uppercase pubkeys. Lowercase consistently in both add and remove.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/store.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/server/store.go b/cmd/server/store.go
index 1944d91e..ea4cdd6b 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -2460,7 +2460,7 @@ func addTxToPathHopIndex(idx map[string][]*StoreTx, tx *StoreTx) {
 		}
 		// Also index by resolved pubkey if available
 		if tx.ResolvedPath != nil && i < len(tx.ResolvedPath) && tx.ResolvedPath[i] != nil {
-			pk := *tx.ResolvedPath[i]
+			pk := strings.ToLower(*tx.ResolvedPath[i])
 			if !seen[pk] {
 				seen[pk] = true
 				idx[pk] = append(idx[pk], tx)
@@ -2564,7 +2564,7 @@ func removeTxFromPathHopIndex(idx map[string][]*StoreTx, tx *StoreTx) {
 			removeTxFromSlice(idx, key, tx)
 		}
 		if tx.ResolvedPath != nil && i < len(tx.ResolvedPath) && tx.ResolvedPath[i] != nil {
-			pk := *tx.ResolvedPath[i]
+			pk := strings.ToLower(*tx.ResolvedPath[i])
 			if !seen[pk] {
 				seen[pk] = true
 				removeTxFromSlice(idx, pk, tx)

From dcfa758e5489e1ed7668026e146f28be5abf61cd Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 16 Apr 2026 11:39:26 +0200
Subject: [PATCH 26/32] fix(store): update relayTimes in backfill when resolved
 paths are set (#662)

backfillResolvedPathsAsync was updating tx.ResolvedPath via
pickBestObservation but never updating relayTimes. On a fresh deploy
(or any instance where resolved_path was NULL in the DB), all repeaters
showed as Idle despite active relay traffic.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/neighbor_persist.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cmd/server/neighbor_persist.go b/cmd/server/neighbor_persist.go
index 2bce39f7..6d0fee45 100644
--- a/cmd/server/neighbor_persist.go
+++ b/cmd/server/neighbor_persist.go
@@ -496,6 +496,10 @@ func backfillResolvedPathsAsync(store *PacketStore, dbPath string, chunkSize int
 					affectedSet[r.txHash] = true
 					if tx, ok := store.byHash[r.txHash]; ok {
 						pickBestObservation(tx)
+						// tx.ResolvedPath is now updated; add newly resolved pubkeys to
+						// the relay time index. The first call during buildPathHopIndex
+						// was a no-op (ResolvedPath was nil then), so no duplicates.
+						addTxToRelayTimeIndex(store.relayTimes, tx)
 					}
 				}
 			}

From 2fd5e409cc2b870fd42b59b2dd969e9d7c926a98 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 16 Apr 2026 11:57:49 +0200
Subject: [PATCH 27/32] fix(relay): scan all observations for relay times, fix
 detail pane stats (#662)

Two bugs:

1. addTxToRelayTimeIndex only used tx.ResolvedPath (best observation).
   If the best observer received a packet directly while another observer
   received it via a repeater, that repeater's relay activity was invisible.
   Fix: scan ALL observations' resolved paths. Insert is now idempotent
   so the function can be called multiple times safely. removeFromRelayTimeIndex
   updated symmetrically to avoid orphaned entries on eviction.
   Also add an else branch in pollAndMerge so new observations on existing
   packets (path unchanged) still update relay times immediately.

2. renderDetail/loadFullNode called getStatusInfo(n) where n = data.node
   (from /api/nodes/{pubkey}, no relay stats). Relay counts and status
   were always undefined / Idle. Fix: assign n.stats = stats (from the
   health endpoint) before calling getStatusInfo.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/store.go | 63 +++++++++++++++++++++++++++++++--------------
 public/nodes.js     |  4 ++-
 2 files changed, 47 insertions(+), 20 deletions(-)

diff --git a/cmd/server/store.go b/cmd/server/store.go
index ea4cdd6b..de67937d 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -1884,6 +1884,10 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) []map[string]
 			}
 			addTxToPathHopIndex(s.byPathHop, tx)
 			addTxToRelayTimeIndex(s.relayTimes, tx)
+		} else {
+			// Path unchanged: new observation may have relay hops in its resolved
+			// path that aren't indexed yet (idempotent — safe to call repeatedly).
+			addTxToRelayTimeIndex(s.relayTimes, tx)
 		}
 	}
 
@@ -2469,58 +2473,71 @@ func addTxToPathHopIndex(idx map[string][]*StoreTx, tx *StoreTx) {
 	}
 }
 
-// addTxToRelayTimeIndex records the relay timestamp for each full pubkey in
-// tx.ResolvedPath. Maintains sorted ascending order for O(log n) window queries.
+// addTxToRelayTimeIndex records the relay timestamp for each full pubkey that
+// appears in ANY observation's resolved path. Scanning all observations (not
+// just the best one) ensures relay activity is captured even when the best
+// observer received the packet directly without a relay hop.
+// Insert is idempotent: if the same timestamp already exists for a pubkey it is
+// not duplicated, so the function may be called multiple times safely.
 // Must be called with s.mu held (or during build before store is live).
 func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
-	if len(tx.ResolvedPath) == 0 {
-		return
-	}
 	// Parse FirstSeen on each call. StoreTx has no cached millis field;
-	// RFC3339 parse is cheap relative to the binary-search insert that follows.
+	// RFC3339 parse is cheap relative to the binary-search inserts that follow.
 	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
 	if err != nil {
 		return
 	}
 	millis := ms.UnixMilli()
-	seen := make(map[string]bool, len(tx.ResolvedPath))
-	for _, rp := range tx.ResolvedPath {
+	seen := make(map[string]bool)
+	insert := func(rp *string) {
 		if rp == nil {
-			continue
+			return
 		}
 		pk := strings.ToLower(*rp)
 		if seen[pk] {
-			continue
+			return
 		}
 		seen[pk] = true
 		slice := idx[pk]
 		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
+		if i < len(slice) && slice[i] == millis {
+			return // idempotent: already present
+		}
 		slice = append(slice, 0)
 		copy(slice[i+1:], slice[i:])
 		slice[i] = millis
 		idx[pk] = slice
 	}
+	// Scan all observations — relay hops appear in any observation's path.
+	for _, obs := range tx.Observations {
+		for _, rp := range obs.ResolvedPath {
+			insert(rp)
+		}
+	}
+	// Fallback for DB-loaded packets where Observations slice may be empty
+	// but tx.ResolvedPath (best observation) is populated.
+	for _, rp := range tx.ResolvedPath {
+		insert(rp)
+	}
 }
 
-// removeFromRelayTimeIndex removes the relay timestamp for each full pubkey in
-// tx.ResolvedPath. Inverse of addTxToRelayTimeIndex.
+// removeFromRelayTimeIndex removes the relay timestamp for every full pubkey
+// that appears in any observation's resolved path. Symmetric with
+// addTxToRelayTimeIndex so eviction does not leave orphaned entries.
 func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
-	if len(tx.ResolvedPath) == 0 {
-		return
-	}
 	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
 	if err != nil {
 		return
 	}
 	millis := ms.UnixMilli()
-	seen := make(map[string]bool, len(tx.ResolvedPath))
-	for _, rp := range tx.ResolvedPath {
+	seen := make(map[string]bool)
+	remove := func(rp *string) {
 		if rp == nil {
-			continue
+			return
 		}
 		pk := strings.ToLower(*rp)
 		if seen[pk] {
-			continue
+			return
 		}
 		seen[pk] = true
 		slice := idx[pk]
@@ -2532,6 +2549,14 @@ func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
 			}
 		}
 	}
+	for _, obs := range tx.Observations {
+		for _, rp := range obs.ResolvedPath {
+			remove(rp)
+		}
+	}
+	for _, rp := range tx.ResolvedPath {
+		remove(rp)
+	}
 }
 
 // relayMetrics computes relay_count_1h, relay_count_24h, and last_relayed from a
diff --git a/public/nodes.js b/public/nodes.js
index d0534861..86a04a98 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -471,8 +471,9 @@
       const recent = h.recentPackets || [];
       const lastHeard = stats.lastHeard;
 
-      // Attach health lastHeard for shared helpers
+      // Attach health lastHeard and relay stats for shared helpers
       n._lastHeard = lastHeard || n.last_seen;
+      n.stats = stats;
       const si = getStatusInfo(n);
       const roleColor = si.roleColor;
       const statusLabel = si.statusLabel;
@@ -1157,6 +1158,7 @@
     // Status calculation via shared helper
     const lastHeard = stats.lastHeard;
     n._lastHeard = lastHeard || n.last_seen;
+    n.stats = stats;
     const si = getStatusInfo(n);
     const roleColor = si.roleColor;
     const totalPackets = stats.totalTransmissions || stats.totalPackets || n.advert_count || 0;

From 1294c97b8dee19be59f818fb735d261b495cc40f Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 16 Apr 2026 12:08:04 +0200
Subject: [PATCH 28/32] feat(ui): add status emoji column to nodes list with
 hover tooltip (#662)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New 'St.' column after Last Seen shows 🟢/🟡/⚪ for each node.
Hovering shows full context: 'Relaying — Relayed 2592 packets in
last 24h, last 26s ago' (or 'Idle — Alive but no relay traffic...',
'Stale — Not heard for...').

Also replaces the manual status/class computation in renderRows with
a single getStatusInfo() call for consistency.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 public/nodes.js | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/public/nodes.js b/public/nodes.js
index 86a04a98..f3e32241 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -997,6 +997,7 @@
           <th scope="col" class="col-pubkey" data-sort-key="public_key">Public Key</th>
           <th scope="col" data-sort-key="role">Role</th>
           <th scope="col" data-sort-key="last_seen" data-sort-default="desc">Last Seen</th>
+          <th scope="col" title="Node status">St.</th>
           <th scope="col" data-sort-key="advert_count" data-sort-default="desc">Adverts</th>
         </tr></thead>
         <tbody id="nodesBody"></tbody>
@@ -1104,19 +1105,19 @@
 
     const dupMap = buildDupNameMap(_allNodes);
     tbody.innerHTML = sorted.map(n => {
-      const roleColor = ROLE_COLORS[n.role] || '#6b7280';
       const isClaimed = myKeys.has(n.public_key);
-      const lastSeenTime = n.last_heard || n.last_seen;
-      const relayCount24h = (n.stats && typeof n.stats.relay_count_24h === 'number') ? n.stats.relay_count_24h : undefined;
-      const status = getNodeStatus((n.role || 'companion').toLowerCase(), lastSeenTime ? new Date(lastSeenTime).getTime() : 0, relayCount24h);
-      const lastSeenClass = status === 'relaying' ? 'last-seen-active' : status === 'active' ? ((n.role || '').toLowerCase() === 'repeater' ? 'last-seen-idle' : 'last-seen-active') : 'last-seen-stale';
+      const si = getStatusInfo(n);
+      const lastSeenClass = si.status === 'relaying' ? 'last-seen-active' : si.status === 'active' ? (si.role === 'repeater' ? 'last-seen-idle' : 'last-seen-active') : 'last-seen-stale';
+      const statusEmoji = si.statusLabel.split(' ')[0];
+      const statusTooltip = si.statusLabel.replace(/^.\s/, '') + (si.explanation ? ' — ' + si.explanation : '');
       const cs = _fleetSkew && _fleetSkew[n.public_key];
       const skewBadgeHtml = cs && cs.severity && cs.severity !== 'ok' ? renderSkewBadge(cs.severity, cs.medianSkewSec) : '';
       return `<tr data-key="${n.public_key}" data-action="select" data-value="${n.public_key}" tabindex="0" role="row" class="${selectedKey === n.public_key ? 'selected' : ''}${isClaimed ? ' claimed-row' : ''}">
         <td>${favStar(n.public_key, 'node-fav')}${isClaimed ? '<span class="claimed-badge" title="My Mesh">★</span> ' : ''}<strong>${n.name || '(unnamed)'}</strong>${dupNameBadge(n.name, n.public_key, dupMap)}${skewBadgeHtml}</td>
         <td class="mono col-pubkey">${truncate(n.public_key, 16)}</td>
-        <td><span class="badge" style="background:${roleColor}20;color:${roleColor}">${n.role}</span></td>
+        <td><span class="badge" style="background:${si.roleColor}20;color:${si.roleColor}">${n.role}</span></td>
         <td class="${lastSeenClass}">${renderNodeTimestampHtml(n.last_heard || n.last_seen)}</td>
+        <td style="text-align:center;font-size:15px" title="${escapeHtml(statusTooltip)}">${statusEmoji}</td>
         <td>${n.advert_count || 0}</td>
       </tr>`;
     }).join('');

From 09c1fe031e3685d551b7c3dad1bad0a96838051f Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Thu, 16 Apr 2026 12:19:32 +0200
Subject: [PATCH 29/32] fix(ui): enrich /api/nodes with relay stats so overview
 emoji is correct

The nodes list was calling getStatusInfo(n) on nodes that had no stats
(the list endpoint only returned DB data). This caused all repeaters to
show as yellow/idle in the overview even when actively relaying.

Fix: handleNodes in routes.go now enriches each repeater node with
relay_count_1h, relay_count_24h, and last_relayed from the in-memory
relayTimes index, matching exactly what the single-node health endpoint
returns. The status filter also updated to use getStatusInfo() so relay
state is considered when filtering active/stale.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/routes.go | 22 ++++++++++++++++++++--
 public/nodes.js      |  7 +++----
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/cmd/server/routes.go b/cmd/server/routes.go
index f9face01..9f1ddd90 100644
--- a/cmd/server/routes.go
+++ b/cmd/server/routes.go
@@ -1035,11 +1035,29 @@ func (s *Server) handleNodes(w http.ResponseWriter, r *http.Request) {
 	}
 	if s.store != nil {
 		hashInfo := s.store.GetNodeHashSizeInfo()
+		now := time.Now().UnixMilli()
+		s.store.mu.RLock()
 		for _, node := range nodes {
-			if pk, ok := node["public_key"].(string); ok {
-				EnrichNodeWithHashSize(node, hashInfo[pk])
+			pk, ok := node["public_key"].(string)
+			if !ok {
+				continue
+			}
+			EnrichNodeWithHashSize(node, hashInfo[pk])
+			role, _ := node["role"].(string)
+			if strings.ToLower(role) == "repeater" {
+				lk := strings.ToLower(pk)
+				c1h, c24h, lastRel := relayMetrics(s.store.relayTimes[lk], now)
+				stats := map[string]interface{}{
+					"relay_count_1h":  c1h,
+					"relay_count_24h": c24h,
+				}
+				if lastRel != "" {
+					stats["last_relayed"] = lastRel
+				}
+				node["stats"] = stats
 			}
 		}
+		s.store.mu.RUnlock()
 	}
 	if s.cfg.GeoFilter != nil {
 		filtered := nodes[:0]
diff --git a/public/nodes.js b/public/nodes.js
index f3e32241..c6b714c4 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -906,10 +906,9 @@
       // Status filter (active/stale)
       if (statusFilter === 'active' || statusFilter === 'stale') {
         filtered = filtered.filter(n => {
-          const role = (n.role || 'companion').toLowerCase();
-          const t = n.last_heard || n.last_seen;
-          const lastMs = t ? new Date(t).getTime() : 0;
-          return getNodeStatus(role, lastMs) === statusFilter;
+          const si = getStatusInfo(n);
+          if (statusFilter === 'active') return si.status === 'active' || si.status === 'relaying';
+          return si.status === statusFilter;
         });
       }
       nodes = filtered;

From ba6591bf5ae5574cd50b73a1c4978e6001cd0eab Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Fri, 17 Apr 2026 10:43:57 +0200
Subject: [PATCH 30/32] fix(store): cap relay time index to last 24h on startup
 to prevent OOM

buildPathHopIndex was indexing relay timestamps for all historical
packets. On a live instance with 2.8M observations this allocated ~14 GB
causing the OOM killer to terminate the server process.

relayMetrics only queries 1h and 24h windows so any timestamp older than
24h is useless in the index. Skip addTxToRelayTimeIndex for packets
older than 24h during the initial build.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/store.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/cmd/server/store.go b/cmd/server/store.go
index de67937d..83ecafd6 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -2441,9 +2441,12 @@ func (s *PacketStore) buildSubpathIndex() {
 func (s *PacketStore) buildPathHopIndex() {
 	s.byPathHop = make(map[string][]*StoreTx, 4096)
 	s.relayTimes = make(map[string][]int64, 4096)
+	cutoff := time.Now().Add(-24 * time.Hour)
 	for _, tx := range s.packets {
 		addTxToPathHopIndex(s.byPathHop, tx)
-		addTxToRelayTimeIndex(s.relayTimes, tx)
+		if t, err := time.Parse(time.RFC3339, tx.FirstSeen); err == nil && t.After(cutoff) {
+			addTxToRelayTimeIndex(s.relayTimes, tx)
+		}
 	}
 	log.Printf("[store] Built path-hop index: %d unique keys, %d relay-time keys", len(s.byPathHop), len(s.relayTimes))
 }

From 4ddfbdfe0b0050b24eced4187a9d9de9dc95ee3e Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Fri, 17 Apr 2026 11:58:51 +0200
Subject: [PATCH 31/32] fix(store): limit initial packet load to retentionHours
 window to prevent OOM
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Loading all 366K transmissions and 2.8M observations at startup caused
the server to consume 14+ GB and get OOM-killed on the live instance.

The Load() SQL now adds a WHERE clause filtering to the configured
retentionHours window when set. With retentionHours=168 (7 days), only
~7 days of packets are loaded into memory — sufficient for all in-memory
queries. Historical data remains in SQLite and is available via DB
queries.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/store.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/cmd/server/store.go b/cmd/server/store.go
index 83ecafd6..f7c3f535 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -343,6 +343,10 @@ func (s *PacketStore) Load() error {
 	if s.db.hasResolvedPath {
 		rpCol = ",\n\t\t\t\to.resolved_path"
 	}
+	whereClause := ""
+	if s.retentionHours > 0 {
+		whereClause = fmt.Sprintf("\n\t\t\tWHERE t.first_seen >= datetime('now', '-%.0f hours')", s.retentionHours)
+	}
 	if s.db.isV3 {
 		loadSQL = `SELECT t.id, t.raw_hex, t.hash, t.first_seen, t.route_type,
 				t.payload_type, t.payload_version, t.decoded_json,
@@ -350,7 +354,7 @@ func (s *PacketStore) Load() error {
 				o.snr, o.rssi, o.score, o.path_json, strftime('%Y-%m-%dT%H:%M:%fZ', o.timestamp, 'unixepoch')` + rpCol + `
 			FROM transmissions t
 			LEFT JOIN observations o ON o.transmission_id = t.id
-			LEFT JOIN observers obs ON obs.rowid = o.observer_idx
+			LEFT JOIN observers obs ON obs.rowid = o.observer_idx` + whereClause + `
 			ORDER BY t.first_seen ASC, o.timestamp DESC`
 	} else {
 		loadSQL = `SELECT t.id, t.raw_hex, t.hash, t.first_seen, t.route_type,
@@ -358,7 +362,7 @@ func (s *PacketStore) Load() error {
 				o.id, o.observer_id, o.observer_name, o.direction,
 				o.snr, o.rssi, o.score, o.path_json, o.timestamp` + rpCol + `
 			FROM transmissions t
-			LEFT JOIN observations o ON o.transmission_id = t.id
+			LEFT JOIN observations o ON o.transmission_id = t.id` + whereClause + `
 			ORDER BY t.first_seen ASC, o.timestamp DESC`
 	}
 

From 3b8d6881e0201f67395d191ed4f72cfd1c4a1ca4 Mon Sep 17 00:00:00 2001
From: efiten <erwin.fiten@gmail.com>
Date: Sun, 19 Apr 2026 16:35:46 +0200
Subject: [PATCH 32/32] fix(repeater-liveness): address issue #755 review
 feedback

Must-fix items:
- addTxToRelayTimeIndex now accepts pre-parsed millis to avoid 30K+ RFC3339
  re-parses during bulk startup rebuild under the write lock
- removeFromRelayTimeIndex uses copy+reslice instead of append to avoid
  per-eviction heap allocation proportional to path length
- handleNodes snapshots relay times under RLock then releases before enrichment,
  keeping the lock scope to a quick map copy rather than the full node loop
- Suppress last_relayed in API response when both counts are zero across all
  three endpoints (handleNodes, bulk health, single-node health)

Should-fix items:
- Add NOTE comment on HEALTH_THRESHOLDS mirror in test-repeater-liveness.js
- Flatten multiline repeater template block into per-row inline conditionals
  in both table and dl views to match avgSnr/avgHops style

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 cmd/server/neighbor_persist.go    |  4 +++-
 cmd/server/relay_liveness_test.go | 26 +++++++++++------------
 cmd/server/routes.go              | 25 +++++++++++++++++++---
 cmd/server/store.go               | 35 +++++++++++++++++--------------
 public/nodes.js                   | 14 ++++++-------
 test-repeater-liveness.js         |  2 +-
 6 files changed, 64 insertions(+), 42 deletions(-)

diff --git a/cmd/server/neighbor_persist.go b/cmd/server/neighbor_persist.go
index 6d0fee45..c942d99d 100644
--- a/cmd/server/neighbor_persist.go
+++ b/cmd/server/neighbor_persist.go
@@ -499,7 +499,9 @@ func backfillResolvedPathsAsync(store *PacketStore, dbPath string, chunkSize int
 						// tx.ResolvedPath is now updated; add newly resolved pubkeys to
 						// the relay time index. The first call during buildPathHopIndex
 						// was a no-op (ResolvedPath was nil then), so no duplicates.
-						addTxToRelayTimeIndex(store.relayTimes, tx)
+						if ms, err := time.Parse(time.RFC3339, tx.FirstSeen); err == nil {
+							addTxToRelayTimeIndex(store.relayTimes, tx, ms.UnixMilli())
+						}
 					}
 				}
 			}
diff --git a/cmd/server/relay_liveness_test.go b/cmd/server/relay_liveness_test.go
index 95f999d4..0190bbf1 100644
--- a/cmd/server/relay_liveness_test.go
+++ b/cmd/server/relay_liveness_test.go
@@ -17,7 +17,7 @@ func TestAddTxToRelayTimeIndex_SingleNode(t *testing.T) {
 		FirstSeen:    ts.Format(time.RFC3339),
 		ResolvedPath: []*string{makeRp(pk)},
 	}
-	addTxToRelayTimeIndex(idx, tx)
+	addTxToRelayTimeIndex(idx, tx, ts.UnixMilli())
 	if len(idx[pk]) != 1 {
 		t.Fatalf("expected 1 entry, got %d", len(idx[pk]))
 	}
@@ -37,8 +37,8 @@ func TestAddTxToRelayTimeIndex_SortedOrder(t *testing.T) {
 	// Insert newer first, expect sorted ascending
 	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
 	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
-	addTxToRelayTimeIndex(idx, tx2)
-	addTxToRelayTimeIndex(idx, tx1)
+	addTxToRelayTimeIndex(idx, tx2, t2.UnixMilli())
+	addTxToRelayTimeIndex(idx, tx1, t1.UnixMilli())
 
 	if len(idx[pk]) != 2 {
 		t.Fatalf("expected 2 entries, got %d", len(idx[pk]))
@@ -57,7 +57,7 @@ func TestAddTxToRelayTimeIndex_MultipleNodes(t *testing.T) {
 		FirstSeen:    ts.Format(time.RFC3339),
 		ResolvedPath: []*string{makeRp(pk1), makeRp(pk2)},
 	}
-	addTxToRelayTimeIndex(idx, tx)
+	addTxToRelayTimeIndex(idx, tx, ts.UnixMilli())
 	if len(idx[pk1]) != 1 {
 		t.Errorf("pk1: expected 1 entry, got %d", len(idx[pk1]))
 	}
@@ -69,7 +69,7 @@ func TestAddTxToRelayTimeIndex_MultipleNodes(t *testing.T) {
 func TestAddTxToRelayTimeIndex_NilResolvedPath(t *testing.T) {
 	idx := make(map[string][]int64)
 	tx := &StoreTx{FirstSeen: time.Now().UTC().Format(time.RFC3339), ResolvedPath: nil}
-	addTxToRelayTimeIndex(idx, tx) // must not panic
+	addTxToRelayTimeIndex(idx, tx, time.Now().UnixMilli()) // must not panic
 	if len(idx) != 0 {
 		t.Error("expected empty index for nil ResolvedPath")
 	}
@@ -83,7 +83,7 @@ func TestAddTxToRelayTimeIndex_DuplicatePubkeyInPath(t *testing.T) {
 		FirstSeen:    ts.Format(time.RFC3339),
 		ResolvedPath: []*string{makeRp(pk), makeRp(pk)}, // same pubkey twice
 	}
-	addTxToRelayTimeIndex(idx, tx)
+	addTxToRelayTimeIndex(idx, tx, ts.UnixMilli())
 	if len(idx[pk]) != 1 {
 		t.Errorf("duplicate pubkey should produce only 1 entry, got %d", len(idx[pk]))
 	}
@@ -92,10 +92,10 @@ func TestAddTxToRelayTimeIndex_DuplicatePubkeyInPath(t *testing.T) {
 func TestRemoveFromRelayTimeIndex_RemovesEntry(t *testing.T) {
 	idx := make(map[string][]int64)
 	pk := "aabbccdd11223344"
-	ts := time.Now().Add(-1 * time.Hour).UTC()
+	ts := time.Now().Add(-1 * time.Hour).Truncate(time.Second).UTC()
 	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
 
-	addTxToRelayTimeIndex(idx, tx)
+	addTxToRelayTimeIndex(idx, tx, ts.UnixMilli())
 	if len(idx[pk]) != 1 {
 		t.Fatal("setup: expected 1 entry")
 	}
@@ -108,13 +108,13 @@ func TestRemoveFromRelayTimeIndex_RemovesEntry(t *testing.T) {
 func TestRemoveFromRelayTimeIndex_PartialRemove(t *testing.T) {
 	idx := make(map[string][]int64)
 	pk := "aabbccdd11223344"
-	t1 := time.Now().Add(-2 * time.Hour).UTC()
-	t2 := time.Now().Add(-30 * time.Minute).UTC()
+	t1 := time.Now().Add(-2 * time.Hour).Truncate(time.Second).UTC()
+	t2 := time.Now().Add(-30 * time.Minute).Truncate(time.Second).UTC()
 	tx1 := &StoreTx{FirstSeen: t1.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
 	tx2 := &StoreTx{FirstSeen: t2.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pk)}}
 
-	addTxToRelayTimeIndex(idx, tx1)
-	addTxToRelayTimeIndex(idx, tx2)
+	addTxToRelayTimeIndex(idx, tx1, t1.UnixMilli())
+	addTxToRelayTimeIndex(idx, tx2, t2.UnixMilli())
 	removeFromRelayTimeIndex(idx, tx1)
 
 	if len(idx[pk]) != 1 {
@@ -290,7 +290,7 @@ func TestAddTxToRelayTimeIndex_LowercasesKey(t *testing.T) {
 	pkLower := strings.ToLower(pkUpper)
 	ts := time.Now().UTC()
 	tx := &StoreTx{FirstSeen: ts.Format(time.RFC3339), ResolvedPath: []*string{makeRp(pkUpper)}}
-	addTxToRelayTimeIndex(idx, tx)
+	addTxToRelayTimeIndex(idx, tx, ts.UnixMilli())
 	if len(idx[pkLower]) != 1 {
 		t.Errorf("expected index keyed by lowercase, found %d entries at lowercase key", len(idx[pkLower]))
 	}
diff --git a/cmd/server/routes.go b/cmd/server/routes.go
index 6a915ddc..9f841584 100644
--- a/cmd/server/routes.go
+++ b/cmd/server/routes.go
@@ -1039,7 +1039,27 @@ func (s *Server) handleNodes(w http.ResponseWriter, r *http.Request) {
 	if s.store != nil {
 		hashInfo := s.store.GetNodeHashSizeInfo()
 		now := time.Now().UnixMilli()
+
+		// Snapshot relay times for repeater nodes under the read lock, then
+		// release before enrichment so the lock isn't held for the full loop.
+		relaySnap := make(map[string][]int64)
 		s.store.mu.RLock()
+		for _, node := range nodes {
+			pk, ok := node["public_key"].(string)
+			if !ok {
+				continue
+			}
+			if role, _ := node["role"].(string); strings.ToLower(role) == "repeater" {
+				lk := strings.ToLower(pk)
+				if times := s.store.relayTimes[lk]; len(times) > 0 {
+					cp := make([]int64, len(times))
+					copy(cp, times)
+					relaySnap[lk] = cp
+				}
+			}
+		}
+		s.store.mu.RUnlock()
+
 		for _, node := range nodes {
 			pk, ok := node["public_key"].(string)
 			if !ok {
@@ -1049,18 +1069,17 @@ func (s *Server) handleNodes(w http.ResponseWriter, r *http.Request) {
 			role, _ := node["role"].(string)
 			if strings.ToLower(role) == "repeater" {
 				lk := strings.ToLower(pk)
-				c1h, c24h, lastRel := relayMetrics(s.store.relayTimes[lk], now)
+				c1h, c24h, lastRel := relayMetrics(relaySnap[lk], now)
 				stats := map[string]interface{}{
 					"relay_count_1h":  c1h,
 					"relay_count_24h": c24h,
 				}
-				if lastRel != "" {
+				if lastRel != "" && (c1h > 0 || c24h > 0) {
 					stats["last_relayed"] = lastRel
 				}
 				node["stats"] = stats
 			}
 		}
-		s.store.mu.RUnlock()
 	}
 	if s.cfg.GeoFilter != nil {
 		filtered := nodes[:0]
diff --git a/cmd/server/store.go b/cmd/server/store.go
index b9392894..4b8cda57 100644
--- a/cmd/server/store.go
+++ b/cmd/server/store.go
@@ -1548,7 +1548,9 @@ func (s *PacketStore) IngestNewFromDB(sinceID, limit int) ([]map[string]interfac
 			s.spTotalPaths++
 		}
 		addTxToPathHopIndex(s.byPathHop, tx)
-		addTxToRelayTimeIndex(s.relayTimes, tx)
+		if ms, err := time.Parse(time.RFC3339, tx.FirstSeen); err == nil {
+			addTxToRelayTimeIndex(s.relayTimes, tx, ms.UnixMilli())
+		}
 	}
 
 	// Incrementally update precomputed distance index with new transmissions
@@ -1936,11 +1938,15 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) []map[string]
 				s.spTotalPaths++
 			}
 			addTxToPathHopIndex(s.byPathHop, tx)
-			addTxToRelayTimeIndex(s.relayTimes, tx)
+			if ms, err := time.Parse(time.RFC3339, tx.FirstSeen); err == nil {
+				addTxToRelayTimeIndex(s.relayTimes, tx, ms.UnixMilli())
+			}
 		} else {
 			// Path unchanged: new observation may have relay hops in its resolved
 			// path that aren't indexed yet (idempotent — safe to call repeatedly).
-			addTxToRelayTimeIndex(s.relayTimes, tx)
+			if ms, err := time.Parse(time.RFC3339, tx.FirstSeen); err == nil {
+				addTxToRelayTimeIndex(s.relayTimes, tx, ms.UnixMilli())
+			}
 		}
 	}
 
@@ -2498,7 +2504,7 @@ func (s *PacketStore) buildPathHopIndex() {
 	for _, tx := range s.packets {
 		addTxToPathHopIndex(s.byPathHop, tx)
 		if t, err := time.Parse(time.RFC3339, tx.FirstSeen); err == nil && t.After(cutoff) {
-			addTxToRelayTimeIndex(s.relayTimes, tx)
+			addTxToRelayTimeIndex(s.relayTimes, tx, t.UnixMilli())
 		}
 	}
 	log.Printf("[store] Built path-hop index: %d unique keys, %d relay-time keys", len(s.byPathHop), len(s.relayTimes))
@@ -2535,15 +2541,9 @@ func addTxToPathHopIndex(idx map[string][]*StoreTx, tx *StoreTx) {
 // observer received the packet directly without a relay hop.
 // Insert is idempotent: if the same timestamp already exists for a pubkey it is
 // not duplicated, so the function may be called multiple times safely.
+// millis is tx.FirstSeen already parsed to unix-milliseconds by the caller.
 // Must be called with s.mu held (or during build before store is live).
-func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
-	// Parse FirstSeen on each call. StoreTx has no cached millis field;
-	// RFC3339 parse is cheap relative to the binary-search inserts that follow.
-	ms, err := time.Parse(time.RFC3339, tx.FirstSeen)
-	if err != nil {
-		return
-	}
-	millis := ms.UnixMilli()
+func addTxToRelayTimeIndex(idx map[string][]int64, tx *StoreTx, millis int64) {
 	seen := make(map[string]bool)
 	insert := func(rp *string) {
 		if rp == nil {
@@ -2599,9 +2599,12 @@ func removeFromRelayTimeIndex(idx map[string][]int64, tx *StoreTx) {
 		slice := idx[pk]
 		i := sort.Search(len(slice), func(j int) bool { return slice[j] >= millis })
 		if i < len(slice) && slice[i] == millis {
-			idx[pk] = append(slice[:i], slice[i+1:]...)
-			if len(idx[pk]) == 0 {
+			copy(slice[i:], slice[i+1:])
+			slice = slice[:len(slice)-1]
+			if len(slice) == 0 {
 				delete(idx, pk)
+			} else {
+				idx[pk] = slice
 			}
 		}
 	}
@@ -6372,7 +6375,7 @@ func (s *PacketStore) GetBulkHealth(limit int, region string) []map[string]inter
 			c1h, c24h, lastRel := relayMetrics(s.relayTimes[strings.ToLower(n.pk)], time.Now().UnixMilli())
 			statsMap["relay_count_1h"] = c1h
 			statsMap["relay_count_24h"] = c24h
-			if lastRel != "" {
+			if lastRel != "" && (c1h > 0 || c24h > 0) {
 				statsMap["last_relayed"] = lastRel
 			}
 		}
@@ -6538,7 +6541,7 @@ func (s *PacketStore) GetNodeHealth(pubkey string) (map[string]interface{}, erro
 		c1h, c24h, lastRel := relayMetrics(s.relayTimes[lowerPK], time.Now().UnixMilli())
 		nodeStats["relay_count_1h"] = c1h
 		nodeStats["relay_count_24h"] = c24h
-		if lastRel != "" {
+		if lastRel != "" && (c1h > 0 || c24h > 0) {
 			nodeStats["last_relayed"] = lastRel
 		}
 	}
diff --git a/public/nodes.js b/public/nodes.js
index f83e8a0b..169e7b6f 100644
--- a/public/nodes.js
+++ b/public/nodes.js
@@ -513,10 +513,9 @@
           <tr><td>Packets Today</td><td>${stats.packetsToday || 0}</td></tr>
           ${stats.avgSnr != null ? `<tr><td>Avg SNR</td><td>${Number(stats.avgSnr).toFixed(1)} dB</td></tr>` : ''}
           ${stats.avgHops ? `<tr><td>Avg Hops</td><td>${stats.avgHops}</td></tr>` : ''}
-          ${si.role === 'repeater' ? `
-          <tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>
-          <tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>
-          ${si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}` : ''}
+          ${si.role === 'repeater' ? `<tr><td>Relay (1h)</td><td>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</td></tr>` : ''}
+          ${si.role === 'repeater' ? `<tr><td>Relay (24h)</td><td>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</td></tr>` : ''}
+          ${si.role === 'repeater' && si.lastRelayed ? `<tr><td>Last Relayed</td><td>${renderNodeTimestampHtml(si.lastRelayed)}</td></tr>` : ''}
           ${hasLoc ? `<tr><td>Location</td><td>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</td></tr>` : ''}
           <tr><td>Hash Prefix</td><td>${n.hash_size ? '<code style="font-family:var(--mono);font-weight:700">' + n.public_key.slice(0, n.hash_size * 2).toUpperCase() + '</code> (' + n.hash_size + '-byte)' : 'Unknown'}${n.hash_size_inconsistent ? ' <span style="color:var(--status-yellow);cursor:help" title="Seen: ' + (Array.isArray(n.hash_sizes_seen) ? n.hash_sizes_seen : []).join(', ') + '-byte">⚠️ varies</span>' : ''}</td></tr>
         </table>
@@ -1218,10 +1217,9 @@
             <dt>Packets Today</dt><dd>${stats.packetsToday || 0}</dd>
             ${stats.avgSnr != null ? `<dt>Avg SNR</dt><dd>${Number(stats.avgSnr).toFixed(1)} dB</dd>` : ''}
             ${stats.avgHops ? `<dt>Avg Hops</dt><dd>${stats.avgHops}</dd>` : ''}
-            ${si.role === 'repeater' ? `
-            <dt>Relay (1h)</dt><dd>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</dd>
-            <dt>Relay (24h)</dt><dd>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</dd>
-            ${si.lastRelayed ? `<dt>Last Relayed</dt><dd>${renderNodeTimestampHtml(si.lastRelayed)}</dd>` : ''}` : ''}
+            ${si.role === 'repeater' ? `<dt>Relay (1h)</dt><dd>${typeof si.relayCount1h === 'number' ? si.relayCount1h + ' packet' + (si.relayCount1h === 1 ? '' : 's') : '—'}</dd>` : ''}
+            ${si.role === 'repeater' ? `<dt>Relay (24h)</dt><dd>${typeof si.relayCount24h === 'number' ? si.relayCount24h + ' packet' + (si.relayCount24h === 1 ? '' : 's') : '—'}</dd>` : ''}
+            ${si.role === 'repeater' && si.lastRelayed ? `<dt>Last Relayed</dt><dd>${renderNodeTimestampHtml(si.lastRelayed)}</dd>` : ''}
             ${hasLoc ? `<dt>Location</dt><dd>${Number(n.lat).toFixed(5)}, ${Number(n.lon).toFixed(5)}</dd>` : ''}
           </dl>
         </div>
diff --git a/test-repeater-liveness.js b/test-repeater-liveness.js
index 4238c507..39902ad0 100644
--- a/test-repeater-liveness.js
+++ b/test-repeater-liveness.js
@@ -20,7 +20,7 @@ const ctx = {
 vm.createContext(ctx);
 vm.runInContext(fs.readFileSync('public/roles.js', 'utf8'), ctx);
 // Mirror browser semantics: in a real browser window === globalThis, so bare
-// HEALTH_THRESHOLDS resolves the same as window.HEALTH_THRESHOLDS. Expose it here.
+// NOTE: mirrors browser global; update if HEALTH_THRESHOLDS moves out of window scope in roles.js
 ctx.HEALTH_THRESHOLDS = ctx.window.HEALTH_THRESHOLDS;
 
 // Run tests inside the VM context to preserve closures