fix: Details button opens full-screen node detail on desktop (#778)

The previous fix (#779) used hash navigation for the Details button,
which only re-selected the node in the side panel on desktop. Now the
Details button calls showFullScreenNode() to render the same full-screen
detail view that mobile users see, regardless of screen width.

- Extract showFullScreenNode() from mobile-only init code
- Reuse it for both mobile init and desktop Details button click
- Analytics links still navigate via hash as before
- Update Playwright test to verify full-screen view renders

.badges/e2e-tests.json

@@ -1 +1 @@
-{"schemaVersion":1,"label":"e2e tests","message":"83 passed","color":"brightgreen"}
+{"schemaVersion":1,"label":"e2e tests","message":"45 passed","color":"brightgreen"}

.badges/frontend-coverage.json

@@ -1 +1 @@
-{"schemaVersion":1,"label":"frontend coverage","message":"37.74%","color":"red"}
+{"schemaVersion":1,"label":"frontend coverage","message":"39.68%","color":"red"}

.github/workflows/deploy.yml

@@ -135,7 +135,7 @@ jobs:
   e2e-test:
     name: "🎭 Playwright E2E Tests"
     needs: [go-test]
-    runs-on: ubuntu-latest
+    runs-on: [self-hosted, Linux]
     defaults:
       run:
         shell: bash
@@ -145,6 +145,13 @@ jobs:
         with:
           fetch-depth: 0
 
+      - name: Free disk space
+        run: |
+          # Prune old runner diagnostic logs (can accumulate 50MB+)
+          find ~/actions-runner/_diag/ -name '*.log' -mtime +3 -delete 2>/dev/null || true
+          # Show available disk space
+          df -h / | tail -1
+
       - name: Set up Node.js 22
         uses: actions/setup-node@v5
         with:
@@ -245,11 +252,17 @@ jobs:
   build-and-publish:
     name: "🏗️ Build & Publish Docker Image"
     needs: [e2e-test]
-    runs-on: ubuntu-latest
+    runs-on: [self-hosted, meshcore-runner-2]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
 
+      - name: Free disk space
+        run: |
+          docker system prune -af 2>/dev/null || true
+          docker builder prune -af 2>/dev/null || true
+          df -h /
+
       - name: Compute build metadata
         id: meta
         run: |
@@ -277,10 +290,6 @@ jobs:
         if: github.event_name == 'push'
         uses: docker/setup-buildx-action@v3
 
-      - name: Set up QEMU (arm64 runtime stage)
-        if: github.event_name == 'push'
-        uses: docker/setup-qemu-action@v3
-
       - name: Log in to GHCR
         if: github.event_name == 'push'
         uses: docker/login-action@v3
@@ -308,7 +317,7 @@ jobs:
         with:
           context: .
           push: true
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64
           tags: ${{ steps.docker-meta.outputs.tags }}
           labels: ${{ steps.docker-meta.outputs.labels }}
           build-args: |
@@ -423,11 +432,10 @@ jobs:
 
       - name: Smoke test staging API
         run: |
-          PORT="${STAGING_GO_HTTP_PORT:-80}"
-          if curl -sf "http://localhost:${PORT}/api/stats" | grep -q engine; then
+          if curl -sf http://localhost:82/api/stats | grep -q engine; then
             echo "Staging verified — engine field present ✅"
           else
-            echo "Staging /api/stats did not return engine field (port ${PORT})"
+            echo "Staging /api/stats did not return engine field"
             exit 1
           fi
 
@@ -449,7 +457,7 @@ jobs:
     name: "📝 Publish Badges & Summary"
     if: github.event_name == 'push'
     needs: [deploy]
-    runs-on: ubuntu-latest
+    runs-on: [self-hosted, Linux]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5

Dockerfile

@@ -1,35 +1,28 @@
-# Build stage always runs natively on the builder's arch ($BUILDPLATFORM)
-# and cross-compiles to $TARGETOS/$TARGETARCH via Go toolchain. No QEMU.
-FROM --platform=$BUILDPLATFORM golang:1.22-alpine AS builder
+FROM golang:1.22-alpine AS builder
+
+RUN apk add --no-cache build-base
 
 ARG APP_VERSION=unknown
 ARG GIT_COMMIT=unknown
 ARG BUILD_TIME=unknown
-# Provided by buildx for multi-arch builds
-ARG TARGETOS
-ARG TARGETARCH
 
-# Build server (pure-Go sqlite — no CGO needed, cross-compiles cleanly)
+# Build server
 WORKDIR /build/server
 COPY cmd/server/go.mod cmd/server/go.sum ./
 COPY internal/geofilter/ ../../internal/geofilter/
 COPY internal/sigvalidate/ ../../internal/sigvalidate/
-COPY internal/packetpath/ ../../internal/packetpath/
 RUN go mod download
 COPY cmd/server/ ./
-RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
-    go build -ldflags "-X main.Version=${APP_VERSION} -X main.Commit=${GIT_COMMIT} -X main.BuildTime=${BUILD_TIME}" -o /corescope-server .
+RUN go build -ldflags "-X main.Version=${APP_VERSION} -X main.Commit=${GIT_COMMIT} -X main.BuildTime=${BUILD_TIME}" -o /corescope-server .
 
 # Build ingestor
 WORKDIR /build/ingestor
 COPY cmd/ingestor/go.mod cmd/ingestor/go.sum ./
 COPY internal/geofilter/ ../../internal/geofilter/
 COPY internal/sigvalidate/ ../../internal/sigvalidate/
-COPY internal/packetpath/ ../../internal/packetpath/
 RUN go mod download
 COPY cmd/ingestor/ ./
-RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
-    go build -o /corescope-ingestor .
+RUN go build -o /corescope-ingestor .
 
 # Build decrypt CLI
 WORKDIR /build/decrypt
@@ -37,8 +30,7 @@ COPY cmd/decrypt/go.mod cmd/decrypt/go.sum ./
 COPY internal/channel/ ../../internal/channel/
 RUN go mod download
 COPY cmd/decrypt/ ./
-RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
-    go build -ldflags="-s -w" -o /corescope-decrypt .
+RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /corescope-decrypt .
 
 # Runtime image
 FROM alpine:3.20

cmd/ingestor/config.go

@@ -39,9 +39,7 @@ type Config struct {
 	HashChannels    []string          `json:"hashChannels,omitempty"`
 	Retention       *RetentionConfig  `json:"retention,omitempty"`
 	Metrics         *MetricsConfig    `json:"metrics,omitempty"`
-	GeoFilter            *GeoFilterConfig  `json:"geo_filter,omitempty"`
-	ValidateSignatures   *bool             `json:"validateSignatures,omitempty"`
-	DB                   *DBConfig         `json:"db,omitempty"`
+	GeoFilter       *GeoFilterConfig  `json:"geo_filter,omitempty"`
 }
 
 // GeoFilterConfig is an alias for the shared geofilter.Config type.
@@ -49,9 +47,8 @@ type GeoFilterConfig = geofilter.Config
 
 // RetentionConfig controls how long stale nodes are kept before being moved to inactive_nodes.
 type RetentionConfig struct {
-	NodeDays      int `json:"nodeDays"`
-	ObserverDays  int `json:"observerDays"`
-	MetricsDays   int `json:"metricsDays"`
+	NodeDays    int `json:"nodeDays"`
+	MetricsDays int `json:"metricsDays"`
 }
 
 // MetricsConfig controls observer metrics collection.
@@ -59,28 +56,6 @@ type MetricsConfig struct {
 	SampleIntervalSec int `json:"sampleIntervalSec"`
 }
 
-// DBConfig controls SQLite vacuum and maintenance behavior (#919).
-type DBConfig struct {
-	VacuumOnStartup        bool `json:"vacuumOnStartup"`        // one-time full VACUUM on startup if auto_vacuum is not INCREMENTAL
-	IncrementalVacuumPages int  `json:"incrementalVacuumPages"` // pages returned to OS per reaper cycle (default 1024)
-}
-
-// IncrementalVacuumPages returns the configured pages per vacuum or 1024 default.
-func (c *Config) IncrementalVacuumPages() int {
-	if c.DB != nil && c.DB.IncrementalVacuumPages > 0 {
-		return c.DB.IncrementalVacuumPages
-	}
-	return 1024
-}
-
-// ShouldValidateSignatures returns true (default) unless explicitly disabled.
-func (c *Config) ShouldValidateSignatures() bool {
-	if c.ValidateSignatures != nil {
-		return *c.ValidateSignatures
-	}
-	return true
-}
-
 // MetricsSampleInterval returns the configured sample interval or 300s default.
 func (c *Config) MetricsSampleInterval() int {
 	if c.Metrics != nil && c.Metrics.SampleIntervalSec > 0 {
@@ -105,15 +80,6 @@ func (c *Config) NodeDaysOrDefault() int {
 	return 7
 }
 
-// ObserverDaysOrDefault returns the configured retention.observerDays or 14 if not set.
-// A value of -1 means observers are never removed.
-func (c *Config) ObserverDaysOrDefault() int {
-	if c.Retention != nil && c.Retention.ObserverDays != 0 {
-		return c.Retention.ObserverDays
-	}
-	return 14
-}
-
 // LoadConfig reads configuration from a JSON file, with env var overrides.
 // If the config file does not exist, sensible defaults are used (zero-config startup).
 func LoadConfig(path string) (*Config, error) {

cmd/ingestor/coverage_boost_test.go

@@ -6,7 +6,6 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"testing"
-	"time"
 )
 
 // hmacSHA256 computes HMAC-SHA256 for test use.
@@ -158,7 +157,7 @@ func TestHandleMessageChannelMessage(t *testing.T) {
 	payload := []byte(`{"text":"Alice: Hello everyone","channel_idx":3,"SNR":5.0,"RSSI":-95,"score":10,"direction":"rx","sender_timestamp":1700000000}`)
 	msg := &mockMessage{topic: "meshcore/message/channel/2", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -218,7 +217,7 @@ func TestHandleMessageChannelMessageEmptyText(t *testing.T) {
 	store, source := newTestContext(t)
 
 	msg := &mockMessage{topic: "meshcore/message/channel/1", payload: []byte(`{"text":""}`)}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -233,7 +232,7 @@ func TestHandleMessageChannelNoSender(t *testing.T) {
 	store, source := newTestContext(t)
 
 	msg := &mockMessage{topic: "meshcore/message/channel/1", payload: []byte(`{"text":"no sender here"}`)}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM nodes").Scan(&count); err != nil {
@@ -250,7 +249,7 @@ func TestHandleMessageDirectMessage(t *testing.T) {
 	payload := []byte(`{"text":"Bob: Hey there","sender_timestamp":1700000000,"SNR":3.0,"rssi":-100,"Score":8,"Direction":"tx"}`)
 	msg := &mockMessage{topic: "meshcore/message/direct/abc123", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -294,7 +293,7 @@ func TestHandleMessageDirectMessageEmptyText(t *testing.T) {
 	store, source := newTestContext(t)
 
 	msg := &mockMessage{topic: "meshcore/message/direct/abc", payload: []byte(`{"text":""}`)}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -309,7 +308,7 @@ func TestHandleMessageDirectNoSender(t *testing.T) {
 	store, source := newTestContext(t)
 
 	msg := &mockMessage{topic: "meshcore/message/direct/xyz", payload: []byte(`{"text":"message with no colon"}`)}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -328,7 +327,7 @@ func TestHandleMessageUppercaseScoreDirection(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `","Score":9.0,"Direction":"tx"}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var score *float64
 	var direction *string
@@ -349,7 +348,7 @@ func TestHandleMessageChannelLowercaseFields(t *testing.T) {
 
 	payload := []byte(`{"text":"Test: msg","snr":3.0,"rssi":-90,"Score":5,"Direction":"rx"}`)
 	msg := &mockMessage{topic: "meshcore/message/channel/0", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -365,7 +364,7 @@ func TestHandleMessageDirectLowercaseFields(t *testing.T) {
 
 	payload := []byte(`{"text":"Test: msg","snr":2.0,"rssi":-85,"score":7,"direction":"tx"}`)
 	msg := &mockMessage{topic: "meshcore/message/direct/xyz", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -388,7 +387,7 @@ func TestHandleMessageAdvertWithTelemetry(t *testing.T) {
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	// Should have created transmission, node, and observer
 	var txCount, nodeCount, obsCount int
@@ -428,7 +427,7 @@ func TestHandleMessageAdvertGeoFiltered(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{GeoFilter: gf})
+	handleMessage(store, "test", source, msg, nil, gf)
 
 	// Geo-filtered adverts should not create nodes
 	var nodeCount int
@@ -665,7 +664,7 @@ func TestHandleMessageCorruptedAdvertNoNode(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM nodes").Scan(&count); err != nil {
@@ -687,7 +686,7 @@ func TestHandleMessageNonAdvertPacket(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -864,7 +863,7 @@ func TestHandleMessageChannelLongSender(t *testing.T) {
 	longText := "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA: msg"
 	payload := []byte(`{"text":"` + longText + `"}`)
 	msg := &mockMessage{topic: "meshcore/message/channel/1", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM nodes").Scan(&count); err != nil {
@@ -883,7 +882,7 @@ func TestHandleMessageDirectLongSender(t *testing.T) {
 	longText := "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB: msg"
 	payload := []byte(`{"text":"` + longText + `"}`)
 	msg := &mockMessage{topic: "meshcore/message/direct/abc", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -900,7 +899,7 @@ func TestHandleMessageDirectUppercaseScoreDirection(t *testing.T) {
 
 	payload := []byte(`{"text":"X: hi","Score":6,"Direction":"rx"}`)
 	msg := &mockMessage{topic: "meshcore/message/direct/d1", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -930,7 +929,7 @@ func TestHandleMessageChannelUppercaseScoreDirection(t *testing.T) {
 
 	payload := []byte(`{"text":"Y: hi","Score":4,"Direction":"tx"}`)
 	msg := &mockMessage{topic: "meshcore/message/channel/5", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count); err != nil {
@@ -961,7 +960,7 @@ func TestHandleMessageRawLowercaseScore(t *testing.T) {
 	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
 	payload := []byte(`{"raw":"` + rawHex + `","score":3.5}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var score *float64
 	if err := store.db.QueryRow("SELECT score FROM observations LIMIT 1").Scan(&score); err != nil {
@@ -980,7 +979,7 @@ func TestHandleMessageStatusNoOrigin(t *testing.T) {
 		topic:   "meshcore/LAX/obs5/status",
 		payload: []byte(`{"model":"L1"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	if err := store.db.QueryRow("SELECT COUNT(*) FROM observers WHERE id = 'obs5'").Scan(&count); err != nil {
@@ -1139,182 +1138,3 @@ func TestDecodeTraceWithPath(t *testing.T) {
 		t.Errorf("flags=%v, want 3", p.TraceFlags)
 	}
 }
-
-// --- db.go: RemoveStaleObservers (soft-delete) ---
-
-func TestRemoveStaleObservers(t *testing.T) {
-	store := newTestStore(t)
-
-	// Insert an observer with last_seen 30 days ago
-	err := store.UpsertObserver("obs-old", "OldObserver", "LAX", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Override last_seen to 30 days ago
-	cutoff := time.Now().UTC().AddDate(0, 0, -30).Format(time.RFC3339)
-	_, err = store.db.Exec("UPDATE observers SET last_seen = ? WHERE id = ?", cutoff, "obs-old")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Insert a recent observer
-	err = store.UpsertObserver("obs-new", "NewObserver", "NYC", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	removed, err := store.RemoveStaleObservers(14)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if removed != 1 {
-		t.Errorf("removed=%d, want 1", removed)
-	}
-
-	// Observer should still be in the table (soft-delete), but marked inactive
-	var count int
-	if err := store.db.QueryRow("SELECT COUNT(*) FROM observers").Scan(&count); err != nil {
-		t.Fatal(err)
-	}
-	if count != 2 {
-		t.Errorf("observers count=%d, want 2 (soft-delete preserves row)", count)
-	}
-
-	// Check that the old observer is marked inactive
-	var inactive int
-	if err := store.db.QueryRow("SELECT inactive FROM observers WHERE id = ?", "obs-old").Scan(&inactive); err != nil {
-		t.Fatal(err)
-	}
-	if inactive != 1 {
-		t.Errorf("obs-old inactive=%d, want 1", inactive)
-	}
-
-	// Check that the recent observer is still active
-	var newInactive int
-	if err := store.db.QueryRow("SELECT inactive FROM observers WHERE id = ?", "obs-new").Scan(&newInactive); err != nil {
-		t.Fatal(err)
-	}
-	if newInactive != 0 {
-		t.Errorf("obs-new inactive=%d, want 0", newInactive)
-	}
-}
-
-func TestRemoveStaleObserversNone(t *testing.T) {
-	store := newTestStore(t)
-
-	removed, err := store.RemoveStaleObservers(14)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if removed != 0 {
-		t.Errorf("removed=%d, want 0", removed)
-	}
-}
-
-func TestRemoveStaleObserversKeepForever(t *testing.T) {
-	store := newTestStore(t)
-
-	// Insert an old observer
-	err := store.UpsertObserver("obs-ancient", "AncientObserver", "LAX", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cutoff := time.Now().UTC().AddDate(0, 0, -365).Format(time.RFC3339)
-	_, err = store.db.Exec("UPDATE observers SET last_seen = ? WHERE id = ?", cutoff, "obs-ancient")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// observerDays = -1 means keep forever
-	removed, err := store.RemoveStaleObservers(-1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if removed != 0 {
-		t.Errorf("removed=%d, want 0 (keep forever)", removed)
-	}
-
-	var count int
-	if err := store.db.QueryRow("SELECT COUNT(*) FROM observers").Scan(&count); err != nil {
-		t.Fatal(err)
-	}
-	if count != 1 {
-		t.Errorf("observers count=%d, want 1 (keep forever)", count)
-	}
-
-	// Observer should NOT be marked inactive
-	var inactive int
-	if err := store.db.QueryRow("SELECT inactive FROM observers WHERE id = ?", "obs-ancient").Scan(&inactive); err != nil {
-		t.Fatal(err)
-	}
-	if inactive != 0 {
-		t.Errorf("obs-ancient inactive=%d, want 0 (keep forever)", inactive)
-	}
-}
-
-func TestRemoveStaleObserversReactivation(t *testing.T) {
-	store := newTestStore(t)
-
-	// Insert and stale-mark an observer
-	err := store.UpsertObserver("obs-test", "TestObserver", "LAX", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cutoff := time.Now().UTC().AddDate(0, 0, -30).Format(time.RFC3339)
-	_, err = store.db.Exec("UPDATE observers SET last_seen = ? WHERE id = ?", cutoff, "obs-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	removed, err := store.RemoveStaleObservers(14)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if removed != 1 {
-		t.Errorf("removed=%d, want 1", removed)
-	}
-
-	// Verify it's inactive
-	var inactive int
-	if err := store.db.QueryRow("SELECT inactive FROM observers WHERE id = ?", "obs-test").Scan(&inactive); err != nil {
-		t.Fatal(err)
-	}
-	if inactive != 1 {
-		t.Errorf("inactive=%d, want 1 after soft-delete", inactive)
-	}
-
-	// Now UpsertObserver should reactivate it
-	err = store.UpsertObserver("obs-test", "TestObserver", "LAX", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := store.db.QueryRow("SELECT inactive FROM observers WHERE id = ?", "obs-test").Scan(&inactive); err != nil {
-		t.Fatal(err)
-	}
-	if inactive != 0 {
-		t.Errorf("inactive=%d, want 0 after reactivation", inactive)
-	}
-}
-
-func TestObserverDaysOrDefault(t *testing.T) {
-	tests := []struct {
-		name string
-		cfg  *Config
-		want int
-	}{
-		{"nil retention", &Config{}, 14},
-		{"zero observer days", &Config{Retention: &RetentionConfig{ObserverDays: 0}}, 14},
-		{"positive value", &Config{Retention: &RetentionConfig{ObserverDays: 30}}, 30},
-		{"keep forever", &Config{Retention: &RetentionConfig{ObserverDays: -1}}, -1},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := tt.cfg.ObserverDaysOrDefault()
-			if got != tt.want {
-				t.Errorf("ObserverDaysOrDefault() = %d, want %d", got, tt.want)
-			}
-		})
-	}
-}

cmd/ingestor/db.go

@@ -11,7 +11,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/meshcore-analyzer/packetpath"
 	_ "modernc.org/sqlite"
 )
 
@@ -23,7 +22,6 @@ type DBStats struct {
 	NodeUpserts            atomic.Int64
 	ObserverUpserts        atomic.Int64
 	WriteErrors            atomic.Int64
-	SignatureDrops         atomic.Int64
 }
 
 // Store wraps the SQLite database for packet ingestion.
@@ -59,7 +57,7 @@ func OpenStoreWithInterval(dbPath string, sampleIntervalSec int) (*Store, error)
 		return nil, fmt.Errorf("creating data dir: %w", err)
 	}
 
-	db, err := sql.Open("sqlite", dbPath+"?_pragma=auto_vacuum(INCREMENTAL)&_pragma=journal_mode(WAL)&_pragma=foreign_keys(ON)&_pragma=busy_timeout(5000)")
+	db, err := sql.Open("sqlite", dbPath+"?_pragma=journal_mode(WAL)&_pragma=foreign_keys(ON)&_pragma=busy_timeout(5000)")
 	if err != nil {
 		return nil, fmt.Errorf("opening db: %w", err)
 	}
@@ -85,9 +83,6 @@ func OpenStoreWithInterval(dbPath string, sampleIntervalSec int) (*Store, error)
 }
 
 func applySchema(db *sql.DB) error {
-	// auto_vacuum=INCREMENTAL is set via DSN pragma (must be before journal_mode).
-	// Logging of current mode is handled by CheckAutoVacuum — no duplicate log here.
-
 	schema := `
 		CREATE TABLE IF NOT EXISTS nodes (
 			public_key TEXT PRIMARY KEY,
@@ -115,8 +110,7 @@ func applySchema(db *sql.DB) error {
 			radio TEXT,
 			battery_mv INTEGER,
 			uptime_secs INTEGER,
-			noise_floor REAL,
-			inactive INTEGER DEFAULT 0
+			noise_floor REAL
 		);
 
 		CREATE INDEX IF NOT EXISTS idx_nodes_last_seen ON nodes(last_seen);
@@ -193,7 +187,7 @@ func applySchema(db *sql.DB) error {
 	db.Exec(`DROP VIEW IF EXISTS packets_v`)
 	_, vErr := db.Exec(`
 		CREATE VIEW packets_v AS
-			SELECT o.id, COALESCE(o.raw_hex, t.raw_hex) AS raw_hex,
+			SELECT o.id, t.raw_hex,
 				   datetime(o.timestamp, 'unixepoch') AS timestamp,
 				   obs.id AS observer_id, obs.name AS observer_name,
 				   o.direction, o.snr, o.rssi, o.score, t.hash, t.route_type,
@@ -201,7 +195,7 @@ func applySchema(db *sql.DB) error {
 				   t.created_at
 			FROM observations o
 			JOIN transmissions t ON t.id = o.transmission_id
-			LEFT JOIN observers obs ON obs.rowid = o.observer_idx AND (obs.inactive IS NULL OR obs.inactive = 0)
+			LEFT JOIN observers obs ON obs.rowid = o.observer_idx
 	`)
 	if vErr != nil {
 		return fmt.Errorf("packets_v view: %w", vErr)
@@ -341,19 +335,6 @@ func applySchema(db *sql.DB) error {
 		log.Println("[migration] observer_metrics timestamp index created")
 	}
 
-	// Migration: add inactive column to observers for soft-delete retention
-	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observers_inactive_v1'")
-	if row.Scan(&migDone) != nil {
-		log.Println("[migration] Adding inactive column to observers...")
-		_, err := db.Exec(`ALTER TABLE observers ADD COLUMN inactive INTEGER DEFAULT 0`)
-		if err != nil {
-			// Column may already exist (e.g. fresh install with schema above)
-			log.Printf("[migration] observers.inactive: %v (may already exist)", err)
-		}
-		db.Exec(`INSERT INTO _migrations (name) VALUES ('observers_inactive_v1')`)
-		log.Println("[migration] observers.inactive column added")
-	}
-
 	// Migration: add packets_sent and packets_recv columns to observer_metrics
 	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observer_metrics_packets_v1'")
 	if row.Scan(&migDone) != nil {
@@ -386,41 +367,6 @@ func applySchema(db *sql.DB) error {
 		log.Println("[migration] channel_hash column added and backfilled")
 	}
 
-	// Migration: dropped_packets table for signature validation failures (#793)
-	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'dropped_packets_v1'")
-	if row.Scan(&migDone) != nil {
-		log.Println("[migration] Creating dropped_packets table...")
-		_, err := db.Exec(`
-			CREATE TABLE IF NOT EXISTS dropped_packets (
-				id INTEGER PRIMARY KEY AUTOINCREMENT,
-				hash TEXT,
-				raw_hex TEXT,
-				reason TEXT NOT NULL,
-				observer_id TEXT,
-				observer_name TEXT,
-				node_pubkey TEXT,
-				node_name TEXT,
-				dropped_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			);
-			CREATE INDEX IF NOT EXISTS idx_dropped_observer ON dropped_packets(observer_id);
-			CREATE INDEX IF NOT EXISTS idx_dropped_node ON dropped_packets(node_pubkey);
-		`)
-		if err != nil {
-			return fmt.Errorf("dropped_packets schema: %w", err)
-		}
-		db.Exec(`INSERT INTO _migrations (name) VALUES ('dropped_packets_v1')`)
-		log.Println("[migration] dropped_packets table created")
-	}
-
-	// Migration: add raw_hex column to observations (#881)
-	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observations_raw_hex_v1'")
-	if row.Scan(&migDone) != nil {
-		log.Println("[migration] Adding raw_hex column to observations...")
-		db.Exec(`ALTER TABLE observations ADD COLUMN raw_hex TEXT`)
-		db.Exec(`INSERT INTO _migrations (name) VALUES ('observations_raw_hex_v1')`)
-		log.Println("[migration] observations.raw_hex column added")
-	}
-
 	return nil
 }
 
@@ -446,13 +392,8 @@ func (s *Store) prepareStatements() error {
 	}
 
 	s.stmtInsertObservation, err = s.db.Prepare(`
-		INSERT INTO observations (transmission_id, observer_idx, direction, snr, rssi, score, path_json, timestamp, raw_hex)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-		ON CONFLICT(transmission_id, observer_idx, COALESCE(path_json, '')) DO UPDATE SET
-			snr     = COALESCE(excluded.snr,     snr),
-			rssi    = COALESCE(excluded.rssi,    rssi),
-			score   = COALESCE(excluded.score,   score),
-			raw_hex = COALESCE(excluded.raw_hex, raw_hex)
+		INSERT OR IGNORE INTO observations (transmission_id, observer_idx, direction, snr, rssi, score, path_json, timestamp)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
 	`)
 	if err != nil {
 		return err
@@ -598,7 +539,7 @@ func (s *Store) InsertTransmission(data *PacketData) (bool, error) {
 	_, err = s.stmtInsertObservation.Exec(
 		txID, observerIdx, data.Direction,
 		data.SNR, data.RSSI, data.Score,
-		data.PathJSON, epochTs, nilIfEmpty(data.RawHex),
+		data.PathJSON, epochTs,
 	)
 	if err != nil {
 		s.Stats.WriteErrors.Add(1)
@@ -703,13 +644,10 @@ func (s *Store) UpsertObserver(id, name, iata string, meta *ObserverMeta) error
 	)
 	if err != nil {
 		s.Stats.WriteErrors.Add(1)
-		return err
+	} else {
+		s.Stats.ObserverUpserts.Add(1)
 	}
-	s.Stats.ObserverUpserts.Add(1)
-
-	// Reactivate if this observer was previously marked inactive
-	s.db.Exec(`UPDATE observers SET inactive = 0 WHERE id = ? AND inactive = 1`, id)
-	return nil
+	return err
 }
 
 // Close checkpoints the WAL and closes the database.
@@ -791,58 +729,6 @@ func (s *Store) PruneOldMetrics(retentionDays int) (int64, error) {
 	return n, nil
 }
 
-// CheckAutoVacuum inspects the current auto_vacuum mode and logs a warning
-// if not INCREMENTAL. Performs opt-in full VACUUM if db.vacuumOnStartup is set (#919).
-func (s *Store) CheckAutoVacuum(cfg *Config) {
-	var autoVacuum int
-	if err := s.db.QueryRow("PRAGMA auto_vacuum").Scan(&autoVacuum); err != nil {
-		log.Printf("[db] warning: could not read auto_vacuum: %v", err)
-		return
-	}
-
-	if autoVacuum == 2 {
-		log.Printf("[db] auto_vacuum=INCREMENTAL")
-		return
-	}
-
-	modes := map[int]string{0: "NONE", 1: "FULL", 2: "INCREMENTAL"}
-	mode := modes[autoVacuum]
-	if mode == "" {
-		mode = fmt.Sprintf("UNKNOWN(%d)", autoVacuum)
-	}
-
-	log.Printf("[db] auto_vacuum=%s — DB needs one-time VACUUM to enable incremental auto-vacuum. "+
-		"Set db.vacuumOnStartup: true in config to migrate (will block startup for several minutes on large DBs). "+
-		"See https://github.com/Kpa-clawbot/CoreScope/issues/919", mode)
-
-	if cfg.DB != nil && cfg.DB.VacuumOnStartup {
-		// WARNING: Full VACUUM creates a temporary copy of the entire DB file.
-		// Requires ~2× the DB file size in free disk space or it will fail.
-		log.Printf("[db] vacuumOnStartup=true — starting one-time full VACUUM (ensure 2x DB size free disk space)...")
-		start := time.Now()
-
-		if _, err := s.db.Exec("PRAGMA auto_vacuum = INCREMENTAL"); err != nil {
-			log.Printf("[db] VACUUM failed: could not set auto_vacuum: %v", err)
-			return
-		}
-		if _, err := s.db.Exec("VACUUM"); err != nil {
-			log.Printf("[db] VACUUM failed: %v", err)
-			return
-		}
-
-		elapsed := time.Since(start)
-		log.Printf("[db] VACUUM complete in %v — auto_vacuum is now INCREMENTAL", elapsed.Round(time.Millisecond))
-	}
-}
-
-// RunIncrementalVacuum returns free pages to the OS (#919).
-// Safe to call on auto_vacuum=NONE databases (noop).
-func (s *Store) RunIncrementalVacuum(pages int) {
-	if _, err := s.db.Exec(fmt.Sprintf("PRAGMA incremental_vacuum(%d)", pages)); err != nil {
-		log.Printf("[vacuum] incremental_vacuum error: %v", err)
-	}
-}
-
 // Checkpoint forces a WAL checkpoint to release the WAL lock file,
 // preventing lock contention with a new process starting up.
 func (s *Store) Checkpoint() {
@@ -855,14 +741,13 @@ func (s *Store) Checkpoint() {
 
 // LogStats logs current operational metrics.
 func (s *Store) LogStats() {
-	log.Printf("[stats] tx_inserted=%d tx_dupes=%d obs_inserted=%d node_upserts=%d observer_upserts=%d write_errors=%d sig_drops=%d",
+	log.Printf("[stats] tx_inserted=%d tx_dupes=%d obs_inserted=%d node_upserts=%d observer_upserts=%d write_errors=%d",
 		s.Stats.TransmissionsInserted.Load(),
 		s.Stats.DuplicateTransmissions.Load(),
 		s.Stats.ObservationsInserted.Load(),
 		s.Stats.NodeUpserts.Load(),
 		s.Stats.ObserverUpserts.Load(),
 		s.Stats.WriteErrors.Load(),
-		s.Stats.SignatureDrops.Load(),
 	)
 }
 
@@ -894,71 +779,6 @@ func (s *Store) MoveStaleNodes(nodeDays int) (int64, error) {
 	return moved, nil
 }
 
-// RemoveStaleObservers marks observers that have not actively sent data in observerDays
-// as inactive (soft-delete). This preserves JOIN integrity for observations.observer_idx
-// and observer_metrics.observer_id — historical data still references the correct observer.
-// An observer must actively send data to stay listed — being seen by another node does not count.
-// observerDays <= -1 means never remove (keep forever).
-func (s *Store) RemoveStaleObservers(observerDays int) (int64, error) {
-	if observerDays <= -1 {
-		return 0, nil // keep forever
-	}
-	cutoff := time.Now().UTC().AddDate(0, 0, -observerDays).Format(time.RFC3339)
-	result, err := s.db.Exec(`UPDATE observers SET inactive = 1 WHERE last_seen < ? AND (inactive IS NULL OR inactive = 0)`, cutoff)
-	if err != nil {
-		return 0, fmt.Errorf("mark stale observers inactive: %w", err)
-	}
-	removed, _ := result.RowsAffected()
-	if removed > 0 {
-		// Clean up orphaned metrics for now-inactive observers
-		s.db.Exec(`DELETE FROM observer_metrics WHERE observer_id IN (SELECT id FROM observers WHERE inactive = 1)`)
-		log.Printf("Marked %d observer(s) as inactive (not seen in %d days)", removed, observerDays)
-	}
-	return removed, nil
-}
-
-// DroppedPacket holds data for a packet rejected during ingest.
-type DroppedPacket struct {
-	Hash         string
-	RawHex       string
-	Reason       string
-	ObserverID   string
-	ObserverName string
-	NodePubKey   string
-	NodeName     string
-}
-
-// InsertDroppedPacket records a rejected packet in the dropped_packets table.
-func (s *Store) InsertDroppedPacket(dp *DroppedPacket) error {
-	_, err := s.db.Exec(
-		`INSERT INTO dropped_packets (hash, raw_hex, reason, observer_id, observer_name, node_pubkey, node_name) VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		dp.Hash, dp.RawHex, dp.Reason, dp.ObserverID, dp.ObserverName, dp.NodePubKey, dp.NodeName,
-	)
-	if err != nil {
-		s.Stats.WriteErrors.Add(1)
-		return fmt.Errorf("insert dropped packet: %w", err)
-	}
-	s.Stats.SignatureDrops.Add(1)
-	return nil
-}
-
-// PruneDroppedPackets removes dropped_packets older than retentionDays.
-func (s *Store) PruneDroppedPackets(retentionDays int) (int64, error) {
-	if retentionDays <= 0 {
-		return 0, nil
-	}
-	cutoff := time.Now().UTC().AddDate(0, 0, -retentionDays).Format(time.RFC3339)
-	result, err := s.db.Exec(`DELETE FROM dropped_packets WHERE dropped_at < ?`, cutoff)
-	if err != nil {
-		return 0, fmt.Errorf("prune dropped packets: %w", err)
-	}
-	n, _ := result.RowsAffected()
-	if n > 0 {
-		log.Printf("Pruned %d dropped packet(s) older than %d days", n, retentionDays)
-	}
-	return n, nil
-}
-
 // PacketData holds the data needed to insert a packet into the DB.
 type PacketData struct {
 	RawHex         string
@@ -997,22 +817,11 @@ type MQTTPacketMessage struct {
 }
 
 // BuildPacketData constructs a PacketData from a decoded packet and MQTT message.
-// path_json is derived directly from raw_hex header bytes (not decoded.Path.Hops)
-// to guarantee the stored path always matches the raw bytes. This matters for
-// TRACE packets where decoded.Path.Hops is overwritten with payload hops (#886).
 func BuildPacketData(msg *MQTTPacketMessage, decoded *DecodedPacket, observerID, region string) *PacketData {
 	now := time.Now().UTC().Format(time.RFC3339)
 	pathJSON := "[]"
-	// For TRACE packets, path_json must be the payload-decoded route hops
-	// (decoded.Path.Hops), NOT the raw_hex header bytes which are SNR values.
-	// For all other packet types, derive path from raw_hex (#886).
-	if !packetpath.PathBytesAreHops(byte(decoded.Header.PayloadType)) {
-		if len(decoded.Path.Hops) > 0 {
-			b, _ := json.Marshal(decoded.Path.Hops)
-			pathJSON = string(b)
-		}
-	} else if hops, err := packetpath.DecodePathFromRawHex(msg.Raw); err == nil && len(hops) > 0 {
-		b, _ := json.Marshal(hops)
+	if len(decoded.Path.Hops) > 0 {
+		b, _ := json.Marshal(decoded.Path.Hops)
 		pathJSON = string(b)
 	}
 

cmd/ingestor/db_test.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"database/sql"
-	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -11,8 +10,6 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
-
-	"github.com/meshcore-analyzer/packetpath"
 )
 
 func tempDBPath(t *testing.T) string {
@@ -1885,241 +1882,3 @@ func TestExtractObserverMetaNewFields(t *testing.T) {
 		t.Errorf("RecvErrors = %v, want 3", meta.RecvErrors)
 	}
 }
-
-// TestInsertObservationSNRFillIn verifies that when the same observation is
-// received twice — first without SNR, then with SNR — the SNR is filled in
-// rather than silently discarded. The unique dedup index is
-// (transmission_id, observer_idx, COALESCE(path_json, '')); observer_idx must
-// be non-NULL for the conflict to fire (SQLite treats NULL != NULL).
-func TestInsertObservationSNRFillIn(t *testing.T) {
-	s, err := OpenStore(tempDBPath(t))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer s.Close()
-
-	// Register the observer so observer_idx is non-NULL (required for dedup).
-	if err := s.UpsertObserver("pymc-obs1", "PyMC Observer", "SJC", nil); err != nil {
-		t.Fatal(err)
-	}
-
-	// First arrival: same observer, no SNR/RSSI (e.g. broker replay without RF fields).
-	data1 := &PacketData{
-		RawHex:     "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976",
-		Timestamp:  "2026-04-20T00:00:00Z",
-		Hash:       "snrfillin0001hash",
-		RouteType:  1,
-		ObserverID: "pymc-obs1",
-		SNR:        nil,
-		RSSI:       nil,
-	}
-	if _, err := s.InsertTransmission(data1); err != nil {
-		t.Fatal(err)
-	}
-
-	var snr1, rssi1 *float64
-	s.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr1, &rssi1)
-	if snr1 != nil || rssi1 != nil {
-		t.Fatalf("precondition: first insert should have nil SNR/RSSI, got snr=%v rssi=%v", snr1, rssi1)
-	}
-
-	// Second arrival: same packet, same observer, now WITH SNR/RSSI.
-	snr := 10.5
-	rssi := -88.0
-	data2 := &PacketData{
-		RawHex:     data1.RawHex,
-		Timestamp:  data1.Timestamp,
-		Hash:       data1.Hash,
-		RouteType:  data1.RouteType,
-		ObserverID: "pymc-obs1",
-		SNR:        &snr,
-		RSSI:       &rssi,
-	}
-	if _, err := s.InsertTransmission(data2); err != nil {
-		t.Fatal(err)
-	}
-
-	var snr2, rssi2 *float64
-	s.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr2, &rssi2)
-	if snr2 == nil || *snr2 != snr {
-		t.Errorf("SNR not filled in by second arrival: got %v, want %v", snr2, snr)
-	}
-	if rssi2 == nil || *rssi2 != rssi {
-		t.Errorf("RSSI not filled in by second arrival: got %v, want %v", rssi2, rssi)
-	}
-
-	// Third arrival: same packet again, SNR absent — must NOT overwrite existing SNR.
-	data3 := &PacketData{
-		RawHex:     data1.RawHex,
-		Timestamp:  data1.Timestamp,
-		Hash:       data1.Hash,
-		RouteType:  data1.RouteType,
-		ObserverID: "pymc-obs1",
-		SNR:        nil,
-		RSSI:       nil,
-	}
-	if _, err := s.InsertTransmission(data3); err != nil {
-		t.Fatal(err)
-	}
-
-	var snr3, rssi3 *float64
-	s.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr3, &rssi3)
-	if snr3 == nil || *snr3 != snr {
-		t.Errorf("SNR overwritten by null arrival: got %v, want %v", snr3, snr)
-	}
-	if rssi3 == nil || *rssi3 != rssi {
-		t.Errorf("RSSI overwritten by null arrival: got %v, want %v", rssi3, rssi)
-	}
-}
-
-// TestPerObservationRawHex verifies that two MQTT packets for the same hash
-// from different observers store distinct raw_hex per observation (#881).
-func TestPerObservationRawHex(t *testing.T) {
-	store, err := OpenStore(tempDBPath(t))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	// Register two observers
-	store.UpsertObserver("obs-A", "Observer A", "", nil)
-	store.UpsertObserver("obs-B", "Observer B", "", nil)
-
-	hash := "abc123def456"
-	rawA := "c0ffee01"
-	rawB := "c0ffee0201aa"
-	dir := "RX"
-
-	// First observation from observer A
-	pdA := &PacketData{
-		RawHex:    rawA,
-		Hash:      hash,
-		Timestamp: "2026-04-21T10:00:00Z",
-		ObserverID: "obs-A",
-		Direction:  &dir,
-		PathJSON:   "[]",
-	}
-	isNew, err := store.InsertTransmission(pdA)
-	if err != nil {
-		t.Fatalf("insert A: %v", err)
-	}
-	if !isNew {
-		t.Fatal("expected new transmission")
-	}
-
-	// Second observation from observer B (same hash, different raw bytes)
-	pdB := &PacketData{
-		RawHex:    rawB,
-		Hash:      hash,
-		Timestamp: "2026-04-21T10:00:01Z",
-		ObserverID: "obs-B",
-		Direction:  &dir,
-		PathJSON:   `["aabb"]`,
-	}
-	isNew2, err := store.InsertTransmission(pdB)
-	if err != nil {
-		t.Fatalf("insert B: %v", err)
-	}
-	if isNew2 {
-		t.Fatal("expected duplicate transmission")
-	}
-
-	// Query observations and verify per-observation raw_hex
-	rows, err := store.db.Query(`
-		SELECT o.raw_hex, obs.id
-		FROM observations o
-		LEFT JOIN observers obs ON obs.rowid = o.observer_idx
-		ORDER BY o.id ASC
-	`)
-	if err != nil {
-		t.Fatalf("query: %v", err)
-	}
-	defer rows.Close()
-
-	type obsResult struct {
-		rawHex     string
-		observerID string
-	}
-	var results []obsResult
-	for rows.Next() {
-		var rh, oid sql.NullString
-		if err := rows.Scan(&rh, &oid); err != nil {
-			t.Fatal(err)
-		}
-		results = append(results, obsResult{
-			rawHex:     rh.String,
-			observerID: oid.String,
-		})
-	}
-
-	if len(results) != 2 {
-		t.Fatalf("expected 2 observations, got %d", len(results))
-	}
-	if results[0].rawHex != rawA {
-		t.Errorf("obs A raw_hex: got %q, want %q", results[0].rawHex, rawA)
-	}
-	if results[1].rawHex != rawB {
-		t.Errorf("obs B raw_hex: got %q, want %q", results[1].rawHex, rawB)
-	}
-	if results[0].rawHex == results[1].rawHex {
-		t.Error("both observations have same raw_hex — should differ")
-	}
-}
-
-// TestBuildPacketData_TraceUsesPayloadHops verifies that TRACE packets use
-// payload-decoded route hops in path_json (NOT the raw_hex header SNR bytes).
-// Issue #886 / #887.
-func TestBuildPacketData_TraceUsesPayloadHops(t *testing.T) {
-	// TRACE packet: header path has SNR bytes [30,2D,0D,23], but decoded.Path.Hops
-	// is overwritten to payload hops [67,33,D6,33,67].
-	rawHex := "2604302D0D2359FEE7B100000000006733D63367"
-	decoded, err := DecodePacket(rawHex, nil, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// decoded.Path.Hops should be the TRACE-replaced hops (payload hops)
-	if len(decoded.Path.Hops) != 5 {
-		t.Fatalf("expected 5 decoded hops, got %d", len(decoded.Path.Hops))
-	}
-
-	msg := &MQTTPacketMessage{Raw: rawHex}
-	pd := BuildPacketData(msg, decoded, "test-obs", "TST")
-
-	// For TRACE: path_json MUST be the payload-decoded route hops, NOT the SNR bytes
-	expectedPathJSON := `["67","33","D6","33","67"]`
-	if pd.PathJSON != expectedPathJSON {
-		t.Errorf("path_json = %s, want %s (TRACE must use payload hops)", pd.PathJSON, expectedPathJSON)
-	}
-
-	// Verify that DecodePathFromRawHex returns the SNR bytes (header path) which differ
-	headerHops, herr := packetpath.DecodePathFromRawHex(rawHex)
-	if herr != nil {
-		t.Fatal(herr)
-	}
-	headerJSON, _ := json.Marshal(headerHops)
-	if string(headerJSON) == expectedPathJSON {
-		t.Error("header path (SNR) should differ from payload hops for TRACE")
-	}
-}
-
-// TestBuildPacketData_NonTracePathJSON verifies non-TRACE packets also derive path from raw_hex.
-func TestBuildPacketData_NonTracePathJSON(t *testing.T) {
-	// A simple ADVERT packet (payload type 0) with 2 hops, hash_size 1
-	// Header 0x09 = FLOOD(1), ADVERT(2), version 0
-	// Path byte 0x02 = hash_size 1, hash_count 2
-	// Path bytes: AA BB
-	rawHex := "0902AABB" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-	decoded, err := DecodePacket(rawHex, nil, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg := &MQTTPacketMessage{Raw: rawHex}
-	pd := BuildPacketData(msg, decoded, "obs1", "TST")
-
-	expectedPathJSON := `["AA","BB"]`
-	if pd.PathJSON != expectedPathJSON {
-		t.Errorf("path_json = %s, want %s", pd.PathJSON, expectedPathJSON)
-	}
-}

cmd/ingestor/decoder.go

@@ -12,7 +12,6 @@ import (
 	"strings"
 	"unicode/utf8"
 
-	"github.com/meshcore-analyzer/packetpath"
 	"github.com/meshcore-analyzer/sigvalidate"
 )
 
@@ -193,9 +192,8 @@ func decodePath(pathByte byte, buf []byte, offset int) (Path, int) {
 	}, totalBytes
 }
 
-// isTransportRoute delegates to packetpath.IsTransportRoute.
 func isTransportRoute(routeType int) bool {
-	return packetpath.IsTransportRoute(routeType)
+	return routeType == RouteTransportFlood || routeType == RouteTransportDirect
 }
 
 func decodeEncryptedPayload(typeName string, buf []byte) Payload {
@@ -643,9 +641,8 @@ func DecodePacket(hexString string, channelKeys map[string]string, validateSigna
 }
 
 // ComputeContentHash computes the SHA-256-based content hash (first 16 hex chars).
-// It hashes the payload-type nibble + payload (skipping path bytes) to produce a
-// route-independent identifier for the same logical packet. For TRACE packets,
-// path_len is included in the hash to match firmware behavior.
+// It hashes the header byte + payload (skipping path bytes) to produce a
+// path-independent identifier for the same transmission.
 func ComputeContentHash(rawHex string) string {
 	buf, err := hex.DecodeString(rawHex)
 	if err != nil || len(buf) < 2 {
@@ -681,18 +678,7 @@ func ComputeContentHash(rawHex string) string {
 	}
 
 	payload := buf[payloadStart:]
-
-	// Hash payload-type byte only (bits 2-5 of header), not the full header.
-	// Firmware: SHA256(payload_type + [path_len for TRACE] + payload)
-	// Using the full header caused different hashes for the same logical packet
-	// when route type or version bits differed. See issue #786.
-	payloadType := (headerByte >> 2) & 0x0F
-	toHash := []byte{payloadType}
-	if int(payloadType) == PayloadTRACE {
-		// Firmware uses uint16_t path_len (2 bytes, little-endian)
-		toHash = append(toHash, pathByte, 0x00)
-	}
-	toHash = append(toHash, payload...)
+	toHash := append([]byte{headerByte}, payload...)
 
 	h := sha256.Sum256(toHash)
 	return hex.EncodeToString(h[:])[:16]

cmd/ingestor/decoder_test.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/meshcore-analyzer/packetpath"
 	"github.com/meshcore-analyzer/sigvalidate"
 )
 
@@ -927,93 +926,6 @@ func TestComputeContentHashLongFallback(t *testing.T) {
 	}
 }
 
-// TestComputeContentHashRouteTypeIndependence verifies that the same logical
-// packet produces the same content hash regardless of route type (issue #786).
-func TestComputeContentHashRouteTypeIndependence(t *testing.T) {
-	// Same payload type (TXT_MSG=2, bits 2-5) with different route types.
-	// Header 0x08 = route_type 0 (TRANSPORT_FLOOD), payload_type 2
-	// Header 0x0A = route_type 2 (DIRECT), payload_type 2
-	// Header 0x09 = route_type 1 (FLOOD), payload_type 2
-	// pathByte=0x00, payload=D69FD7A5A7
-	payloadHex := "D69FD7A5A7"
-
-	// FLOOD: header=0x09 (route_type 1), pathByte=0x00
-	floodHex := "09" + "00" + payloadHex
-	// DIRECT: header=0x0A (route_type 2), pathByte=0x00
-	directHex := "0A" + "00" + payloadHex
-
-	hashFlood := ComputeContentHash(floodHex)
-	hashDirect := ComputeContentHash(directHex)
-	if hashFlood != hashDirect {
-		t.Errorf("same payload with different route types produced different hashes: flood=%s direct=%s", hashFlood, hashDirect)
-	}
-}
-
-// TestComputeContentHashTraceIncludesPathLen verifies TRACE packets include
-// path_len in the hash (matching firmware behavior).
-func TestComputeContentHashTraceIncludesPathLen(t *testing.T) {
-	// TRACE = payload_type 0x09, so header bits 2-5 = 0x09 → header = 0x09<<2 | route=2 = 0x26
-	// pathByte=0x01 (1 hop, 1-byte hash) → 1 path byte
-	traceHeader1 := "26" // route=2, payload_type=9
-	pathByte1 := "01"
-	pathData1 := "AA"
-	payload := "DEADBEEF"
-	hex1 := traceHeader1 + pathByte1 + pathData1 + payload
-
-	// Same but pathByte=0x02 (2 hops) → 2 path bytes
-	pathByte2 := "02"
-	pathData2 := "AABB"
-	hex2 := traceHeader1 + pathByte2 + pathData2 + payload
-
-	hash1 := ComputeContentHash(hex1)
-	hash2 := ComputeContentHash(hex2)
-	if hash1 == hash2 {
-		t.Error("TRACE packets with different path_len should produce different hashes (path_len is part of hash input)")
-	}
-}
-
-// TestComputeContentHashMatchesFirmware verifies hash output matches what the
-// firmware would compute: SHA256(payload_type_byte + payload)[:16hex].
-func TestComputeContentHashMatchesFirmware(t *testing.T) {
-	// header=0x0A → payload_type = (0x0A >> 2) & 0x0F = 2
-	// pathByte=0x00, payload = D69FD7A5A7475DB07337749AE61FA53A4788E976
-	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
-	hash := ComputeContentHash(rawHex)
-
-	// Manually compute expected: SHA256(0x02 + payload_bytes)
-	payloadBytes, _ := hex.DecodeString("D69FD7A5A7475DB07337749AE61FA53A4788E976")
-	toHash := append([]byte{0x02}, payloadBytes...)
-	expected := sha256.Sum256(toHash)
-	expectedHex := hex.EncodeToString(expected[:])[:16]
-	if hash != expectedHex {
-		t.Errorf("hash=%s, want %s (firmware-compatible)", hash, expectedHex)
-	}
-}
-
-// TestComputeContentHashTraceGoldenValue is a golden-value test that locks down
-// the 2-byte path_len (uint16 LE) behavior for TRACE hashing. If anyone removes
-// the 0x00 byte from the hash input, this test breaks.
-//
-// Packet: header=0x25 (FLOOD route=1, payload_type=TRACE=0x09), pathByte=0x02
-// (2 hops, 1-byte hash), path=[AA,BB], payload=[DE,AD,BE,EF].
-// Hash input: [0x09, 0x02, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]
-//   → SHA256 = b1baaf3bf0d0726c2672b1ec9e2665dc...
-//   → first 16 hex chars = "b1baaf3bf0d0726c"
-func TestComputeContentHashTraceGoldenValue(t *testing.T) {
-	// TRACE packet: header byte 0x25 = payload_type 9 (TRACE), route_type 1 (FLOOD)
-	// pathByte 0x02 = hash_size 1, hash_count 2
-	// 2 path bytes (AA, BB), then payload DEADBEEF
-	rawHex := "2502AABBDEADBEEF"
-	hash := ComputeContentHash(rawHex)
-
-	// Pre-computed: SHA256(0x09 0x02 0x00 0xDE 0xAD 0xBE 0xEF)[:16hex]
-	// The 0x00 is the high byte of uint16_t path_len (little-endian).
-	const golden = "b1baaf3bf0d0726c"
-	if hash != golden {
-		t.Errorf("TRACE golden hash = %s, want %s (2-byte path_len encoding)", hash, golden)
-	}
-}
-
 func TestDecodePacketWithWhitespace(t *testing.T) {
 	raw := "0A 00 D6 9F D7 A5 A7 47 5D B0 73 37 74 9A E6 1F A5 3A 47 88 E9 76"
 	pkt, err := DecodePacket(raw, nil, false)
@@ -1823,106 +1735,3 @@ func TestDecodeAdvertWithSignatureValidation(t *testing.T) {
 		t.Error("SignatureValid should be nil when validation disabled")
 	}
 }
-
-// === Tests for DecodePathFromRawHex (issue #886) ===
-
-func TestDecodePathFromRawHex_HashSize1(t *testing.T) {
-	// Header byte 0x26 = route_type DIRECT, payload TRACE
-	// Path byte 0x04 = hash_size 1 (bits 7-6 = 00 → 0+1=1), hash_count 4
-	// Path bytes: 30 2D 0D 23
-	raw := "2604302D0D2359FEE7B100000000006733D63367"
-	hops, err := packetpath.DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"30", "2D", "0D", "23"}
-	if len(hops) != len(expected) {
-		t.Fatalf("got %d hops, want %d", len(hops), len(expected))
-	}
-	for i, h := range hops {
-		if h != expected[i] {
-			t.Errorf("hop[%d] = %s, want %s", i, h, expected[i])
-		}
-	}
-}
-
-func TestDecodePathFromRawHex_HashSize2(t *testing.T) {
-	// Path byte 0x42 = hash_size 2 (bits 7-6 = 01 → 1+1=2), hash_count 2
-	// Header 0x09 = FLOOD route (rt=1), payload ADVERT (pt=2)
-	// Path bytes: AABB CCDD (4 bytes = 2 hops * 2 bytes)
-	raw := "0942AABBCCDD" + "00000000000000"
-	hops, err := packetpath.DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"AABB", "CCDD"}
-	if len(hops) != len(expected) {
-		t.Fatalf("got %d hops, want %d", len(hops), len(expected))
-	}
-	for i, h := range hops {
-		if h != expected[i] {
-			t.Errorf("hop[%d] = %s, want %s", i, h, expected[i])
-		}
-	}
-}
-
-func TestDecodePathFromRawHex_HashSize3(t *testing.T) {
-	// Path byte 0x81 = hash_size 3 (bits 7-6 = 10 → 2+1=3), hash_count 1
-	// Header 0x09 = FLOOD route (rt=1), payload ADVERT
-	raw := "0981AABBCC" + "0000000000"
-	hops, err := packetpath.DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(hops) != 1 || hops[0] != "AABBCC" {
-		t.Fatalf("got %v, want [AABBCC]", hops)
-	}
-}
-
-func TestDecodePathFromRawHex_HashSize4(t *testing.T) {
-	// Path byte 0xC1 = hash_size 4 (bits 7-6 = 11 → 3+1=4), hash_count 1
-	// Header 0x09 = FLOOD route (rt=1)
-	raw := "09C1AABBCCDD" + "0000000000"
-	hops, err := packetpath.DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(hops) != 1 || hops[0] != "AABBCCDD" {
-		t.Fatalf("got %v, want [AABBCCDD]", hops)
-	}
-}
-
-func TestDecodePathFromRawHex_DirectZeroHops(t *testing.T) {
-	// Path byte 0x00 = hash_size 1, hash_count 0
-	// Header 0x0A = DIRECT route (rt=2), payload ADVERT
-	raw := "0A00" + "0000000000"
-	hops, err := packetpath.DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(hops) != 0 {
-		t.Fatalf("got %d hops, want 0", len(hops))
-	}
-}
-
-func TestDecodePathFromRawHex_Transport(t *testing.T) {
-	// Route type 3 = TRANSPORT_DIRECT → 4 transport code bytes before path byte
-	// Header 0x27 = route_type 3, payload TRACE
-	// Transport codes: 1122 3344
-	// Path byte 0x02 = hash_size 1, hash_count 2
-	// Path bytes: AA BB
-	raw := "2711223344" + "02AABB" + "0000000000"
-	hops, err := packetpath.DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"AA", "BB"}
-	if len(hops) != len(expected) {
-		t.Fatalf("got %d hops, want %d", len(hops), len(expected))
-	}
-	for i, h := range hops {
-		if h != expected[i] {
-			t.Errorf("hop[%d] = %s, want %s", i, h, expected[i])
-		}
-	}
-}

cmd/ingestor/go.mod

@@ -13,10 +13,6 @@ replace github.com/meshcore-analyzer/geofilter => ../../internal/geofilter
 
 replace github.com/meshcore-analyzer/sigvalidate => ../../internal/sigvalidate
 
-require github.com/meshcore-analyzer/packetpath v0.0.0
-
-replace github.com/meshcore-analyzer/packetpath => ../../internal/packetpath
-
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect

cmd/ingestor/main.go

@@ -57,42 +57,19 @@ func main() {
 	defer store.Close()
 	log.Printf("SQLite opened: %s", cfg.DBPath)
 
-	// Check auto_vacuum mode and optionally migrate (#919)
-	store.CheckAutoVacuum(cfg)
-
 	// Node retention: move stale nodes to inactive_nodes on startup
 	nodeDays := cfg.NodeDaysOrDefault()
 	store.MoveStaleNodes(nodeDays)
 
-	// Observer retention: remove stale observers on startup
-	observerDays := cfg.ObserverDaysOrDefault()
-	store.RemoveStaleObservers(observerDays)
-
 	// Metrics retention: prune old metrics on startup
 	metricsDays := cfg.MetricsRetentionDays()
 	store.PruneOldMetrics(metricsDays)
-	store.PruneDroppedPackets(metricsDays)
-	vacuumPages := cfg.IncrementalVacuumPages()
-	store.RunIncrementalVacuum(vacuumPages)
 
 	// Daily ticker for node retention
 	retentionTicker := time.NewTicker(1 * time.Hour)
 	go func() {
 		for range retentionTicker.C {
 			store.MoveStaleNodes(nodeDays)
-			store.RunIncrementalVacuum(vacuumPages)
-		}
-	}()
-
-	// Daily ticker for observer retention (every 24h, staggered 90s after startup)
-	observerRetentionTicker := time.NewTicker(24 * time.Hour)
-	go func() {
-		time.Sleep(90 * time.Second) // stagger after metrics prune
-		store.RemoveStaleObservers(observerDays)
-		store.RunIncrementalVacuum(vacuumPages)
-		for range observerRetentionTicker.C {
-			store.RemoveStaleObservers(observerDays)
-			store.RunIncrementalVacuum(vacuumPages)
 		}
 	}()
 
@@ -101,8 +78,6 @@ func main() {
 	go func() {
 		for range metricsRetentionTicker.C {
 			store.PruneOldMetrics(metricsDays)
-			store.PruneDroppedPackets(metricsDays)
-			store.RunIncrementalVacuum(vacuumPages)
 		}
 	}()
 
@@ -171,7 +146,7 @@ func main() {
 		// Capture source for closure
 		src := source
 		opts.SetDefaultPublishHandler(func(c mqtt.Client, m mqtt.Message) {
-			handleMessage(store, tag, src, m, channelKeys, cfg)
+			handleMessage(store, tag, src, m, channelKeys, cfg.GeoFilter)
 		})
 
 		client := mqtt.NewClient(opts)
@@ -206,7 +181,7 @@ func main() {
 	log.Println("Done.")
 }
 
-func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message, channelKeys map[string]string, cfg *Config) {
+func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message, channelKeys map[string]string, geoFilter *GeoFilterConfig) {
 	defer func() {
 		if r := recover(); r != nil {
 			log.Printf("MQTT [%s] panic in handler: %v", tag, r)
@@ -216,6 +191,21 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 	topic := m.Topic()
 	parts := strings.Split(topic, "/")
 
+	// IATA filter
+	if len(source.IATAFilter) > 0 && len(parts) > 1 {
+		region := parts[1]
+		matched := false
+		for _, f := range source.IATAFilter {
+			if f == region {
+				matched = true
+				break
+			}
+		}
+		if !matched {
+			return
+		}
+	}
+
 	var msg map[string]interface{}
 	if err := json.Unmarshal(m.Payload(), &msg); err != nil {
 		return
@@ -227,9 +217,6 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 	}
 
 	// Status topic: meshcore/<region>/<observer_id>/status
-	// IATA filter does NOT apply here — observer metadata (noise_floor, battery, etc.)
-	// is region-independent and should be accepted from all observers regardless of
-	// which IATA regions are configured for packet ingestion.
 	if len(parts) >= 4 && parts[3] == "status" {
 		observerID := parts[2]
 		name, _ := msg["origin"].(string)
@@ -258,26 +245,10 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 		return
 	}
 
-	// IATA filter applies to packet messages only — not status messages above.
-	if len(source.IATAFilter) > 0 && len(parts) > 1 {
-		region := parts[1]
-		matched := false
-		for _, f := range source.IATAFilter {
-			if f == region {
-				matched = true
-				break
-			}
-		}
-		if !matched {
-			return
-		}
-	}
-
 	// Format 1: Raw packet (meshcoretomqtt / Cisien format)
 	rawHex, _ := msg["raw"].(string)
 	if rawHex != "" {
-		validateSigs := cfg.ShouldValidateSignatures()
-		decoded, err := DecodePacket(rawHex, channelKeys, validateSigs)
+		decoded, err := DecodePacket(rawHex, channelKeys, false)
 		if err != nil {
 			log.Printf("MQTT [%s] decode error: %v", tag, err)
 			return
@@ -337,27 +308,7 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 				log.Printf("MQTT [%s] skipping corrupted ADVERT: %s", tag, reason)
 				return
 			}
-			// Signature validation: drop adverts with invalid ed25519 signatures
-			if validateSigs && decoded.Payload.SignatureValid != nil && !*decoded.Payload.SignatureValid {
-				hash := ComputeContentHash(rawHex)
-				truncPK := decoded.Payload.PubKey
-				if len(truncPK) > 16 {
-					truncPK = truncPK[:16]
-				}
-				log.Printf("MQTT [%s] DROPPED invalid signature: hash=%s name=%s observer=%s pubkey=%s",
-					tag, hash, decoded.Payload.Name, firstNonEmpty(mqttMsg.Origin, observerID), truncPK)
-				store.InsertDroppedPacket(&DroppedPacket{
-					Hash:         hash,
-					RawHex:       rawHex,
-					Reason:       "invalid signature",
-					ObserverID:   observerID,
-					ObserverName: mqttMsg.Origin,
-					NodePubKey:   decoded.Payload.PubKey,
-					NodeName:     decoded.Payload.Name,
-				})
-				return
-			}
-			if !NodePassesGeoFilter(decoded.Payload.Lat, decoded.Payload.Lon, cfg.GeoFilter) {
+			if !NodePassesGeoFilter(decoded.Payload.Lat, decoded.Payload.Lon, geoFilter) {
 				return
 			}
 			pktData := BuildPacketData(mqttMsg, decoded, observerID, region)

cmd/ingestor/main_test.go

@@ -130,7 +130,7 @@ func TestHandleMessageRawPacket(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `","SNR":5.5,"RSSI":-100.0,"origin":"myobs"}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -147,7 +147,7 @@ func TestHandleMessageRawPacketAdvert(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `"}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	// Should create a node from the ADVERT
 	var count int
@@ -169,7 +169,7 @@ func TestHandleMessageInvalidJSON(t *testing.T) {
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: []byte(`not json`)}
 
 	// Should not panic
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -186,7 +186,7 @@ func TestHandleMessageStatusTopic(t *testing.T) {
 		payload: []byte(`{"origin":"MyObserver"}`),
 	}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var name, iata string
 	err := store.db.QueryRow("SELECT name, iata FROM observers WHERE id = 'obs1'").Scan(&name, &iata)
@@ -207,11 +207,11 @@ func TestHandleMessageSkipStatusTopics(t *testing.T) {
 
 	// meshcore/status should be skipped
 	msg1 := &mockMessage{topic: "meshcore/status", payload: []byte(`{"raw":"0A00"}`)}
-	handleMessage(store, "test", source, msg1, nil, &Config{})
+	handleMessage(store, "test", source, msg1, nil, nil)
 
 	// meshcore/events/connection should be skipped
 	msg2 := &mockMessage{topic: "meshcore/events/connection", payload: []byte(`{"raw":"0A00"}`)}
-	handleMessage(store, "test", source, msg2, nil, &Config{})
+	handleMessage(store, "test", source, msg2, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -230,7 +230,7 @@ func TestHandleMessageIATAFilter(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -243,7 +243,7 @@ func TestHandleMessageIATAFilter(t *testing.T) {
 		topic:   "meshcore/LAX/obs2/packets",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg2, nil, &Config{})
+	handleMessage(store, "test", source, msg2, nil, nil)
 
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
 	if count != 1 {
@@ -261,7 +261,7 @@ func TestHandleMessageIATAFilterNoRegion(t *testing.T) {
 		topic:   "meshcore",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	// No region part → filter doesn't apply, message goes through
 	// Actually the code checks len(parts) > 1 for IATA filter
@@ -277,7 +277,7 @@ func TestHandleMessageNoRawHex(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"type":"companion","data":"something"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -295,7 +295,7 @@ func TestHandleMessageBadRawHex(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"raw":"ZZZZ"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -312,7 +312,7 @@ func TestHandleMessageWithSNRRSSIAsNumbers(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `","SNR":7.2,"RSSI":-95}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var snr, rssi *float64
 	store.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr, &rssi)
@@ -331,7 +331,7 @@ func TestHandleMessageMinimalTopic(t *testing.T) {
 		topic:   "meshcore/SJC",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -352,7 +352,7 @@ func TestHandleMessageCorruptedAdvert(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/packets",
 		payload: []byte(`{"raw":"` + rawHex + `"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	// Transmission should be inserted (even if advert is invalid)
 	var count int
@@ -378,7 +378,7 @@ func TestHandleMessageNoObserverID(t *testing.T) {
 		topic:   "packets",
 		payload: []byte(`{"raw":"` + rawHex + `","origin":"obs1"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -400,7 +400,7 @@ func TestHandleMessageSNRNotFloat(t *testing.T) {
 	// SNR as a string value — should not parse as float
 	payload := []byte(`{"raw":"` + rawHex + `","SNR":"bad","RSSI":"bad"}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var count int
 	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
@@ -416,7 +416,7 @@ func TestHandleMessageOriginExtraction(t *testing.T) {
 	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
 	payload := []byte(`{"raw":"` + rawHex + `","origin":"MyOrigin"}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	// Verify origin was extracted to observer name
 	var name string
@@ -439,7 +439,7 @@ func TestHandleMessagePanicRecovery(t *testing.T) {
 	}
 
 	// Should not panic — the defer/recover should catch it
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 }
 
 func TestHandleMessageStatusOriginFallback(t *testing.T) {
@@ -451,7 +451,7 @@ func TestHandleMessageStatusOriginFallback(t *testing.T) {
 		topic:   "meshcore/SJC/obs1/status",
 		payload: []byte(`{"type":"status"}`),
 	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var name string
 	err := store.db.QueryRow("SELECT name FROM observers WHERE id = 'obs1'").Scan(&name)
@@ -640,7 +640,7 @@ func TestHandleMessageWithLowercaseSNRRSSI(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `","snr":5.5,"rssi":-102}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var snr, rssi *float64
 	store.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr, &rssi)
@@ -661,7 +661,7 @@ func TestHandleMessageSNRRSSIUppercaseWins(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `","SNR":7.2,"snr":1.0,"RSSI":-95,"rssi":-50}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var snr, rssi *float64
 	store.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr, &rssi)
@@ -681,7 +681,7 @@ func TestHandleMessageNoSNRRSSI(t *testing.T) {
 	payload := []byte(`{"raw":"` + rawHex + `"}`)
 	msg := &mockMessage{topic: "meshcore/SJC/obs1/packets", payload: payload}
 
-	handleMessage(store, "test", source, msg, nil, &Config{})
+	handleMessage(store, "test", source, msg, nil, nil)
 
 	var snr, rssi *float64
 	store.db.QueryRow("SELECT snr, rssi FROM observations LIMIT 1").Scan(&snr, &rssi)
@@ -739,44 +739,3 @@ func TestToFloat64WithUnits(t *testing.T) {
 		}
 	}
 }
-
-// TestIATAFilterDoesNotDropStatusMessages verifies that status messages from
-// out-of-region observers are still processed (noise_floor, battery, etc.)
-// even when an IATA filter is configured for packet data.
-func TestIATAFilterDoesNotDropStatusMessages(t *testing.T) {
-	store := newTestStore(t)
-	source := MQTTSource{Name: "test", IATAFilter: []string{"SJC"}}
-
-	// BFL observer sends a status message with noise_floor — outside the IATA filter.
-	msg := &mockMessage{
-		topic:   "meshcore/BFL/bfl-obs1/status",
-		payload: []byte(`{"origin":"BFLObserver","stats":{"noise_floor":-105.0}}`),
-	}
-	handleMessage(store, "test", source, msg, nil, &Config{})
-
-	var name string
-	var noiseFloor *float64
-	err := store.db.QueryRow("SELECT name, noise_floor FROM observers WHERE id = 'bfl-obs1'").Scan(&name, &noiseFloor)
-	if err != nil {
-		t.Fatalf("observer not found after status from out-of-region observer: %v", err)
-	}
-	if name != "BFLObserver" {
-		t.Errorf("name=%q, want BFLObserver", name)
-	}
-	if noiseFloor == nil || *noiseFloor != -105.0 {
-		t.Errorf("noise_floor=%v, want -105.0 — status message was dropped by IATA filter when it should not be", noiseFloor)
-	}
-
-	// Verify that a packet from BFL is still filtered.
-	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
-	pktMsg := &mockMessage{
-		topic:   "meshcore/BFL/bfl-obs1/packets",
-		payload: []byte(`{"raw":"` + rawHex + `"}`),
-	}
-	handleMessage(store, "test", source, pktMsg, nil, &Config{})
-	var count int
-	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
-	if count != 0 {
-		t.Error("packet from out-of-region BFL should still be filtered by IATA")
-	}
-}

cmd/ingestor/sig_validate_ingest_test.go

@@ -1,339 +0,0 @@
-package main
-
-import (
-	"crypto/ed25519"
-	"encoding/binary"
-	"encoding/hex"
-	"strings"
-	"testing"
-)
-
-// buildAdvertHex constructs a full ADVERT packet hex string.
-// header(1) + pathByte(1) + pubkey(32) + timestamp(4) + signature(64) + appdata
-func buildAdvertHex(pubKey ed25519.PublicKey, privKey ed25519.PrivateKey, timestamp uint32, appdata []byte) string {
-	// Build signed message: pubkey(32) + timestamp(4 LE) + appdata
-	msg := make([]byte, 32+4+len(appdata))
-	copy(msg[0:32], pubKey)
-	binary.LittleEndian.PutUint32(msg[32:36], timestamp)
-	copy(msg[36:], appdata)
-
-	sig := ed25519.Sign(privKey, msg)
-
-	// Payload: pubkey(32) + timestamp(4) + signature(64) + appdata
-	payload := make([]byte, 0, 100+len(appdata))
-	payload = append(payload, pubKey...)
-	ts := make([]byte, 4)
-	binary.LittleEndian.PutUint32(ts, timestamp)
-	payload = append(payload, ts...)
-	payload = append(payload, sig...)
-	payload = append(payload, appdata...)
-
-	// Header: ADVERT (0x04 << 2) | FLOOD (1) = 0x11, pathByte=0 (no hops)
-	header := byte(0x11)
-	pathByte := byte(0x00)
-
-	pkt := append([]byte{header, pathByte}, payload...)
-	return hex.EncodeToString(pkt)
-}
-
-// makeAppdata builds minimal appdata: flags(1) + name
-func makeAppdata(name string) []byte {
-	flags := byte(0x81) // hasName=true, type=companion(1)
-	data := []byte{flags}
-	data = append(data, []byte(name)...)
-	data = append(data, 0x00) // null terminator
-	return data
-}
-
-func TestSigValidation_ValidAdvertStored(t *testing.T) {
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	pub, priv, _ := ed25519.GenerateKey(nil)
-	appdata := makeAppdata("TestNode")
-	rawHex := buildAdvertHex(pub, priv, 1700000000, appdata)
-
-	source := MQTTSource{Name: "test"}
-	msg := newMockMsg("meshcore/US/obs1/packet", `{"raw":"`+rawHex+`","origin":"TestObs"}`)
-	cfg := &Config{}
-
-	handleMessage(store, "test", source, msg, nil, cfg)
-
-	// Verify packet was stored
-	var count int
-	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&count)
-	if count == 0 {
-		t.Fatal("valid advert should be stored, got 0 transmissions")
-	}
-}
-
-func TestSigValidation_TamperedSignatureDropped(t *testing.T) {
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	pub, priv, _ := ed25519.GenerateKey(nil)
-	appdata := makeAppdata("BadNode")
-	rawHex := buildAdvertHex(pub, priv, 1700000000, appdata)
-
-	// Tamper with signature (flip a byte in the signature area)
-	// Signature starts at offset 2 (header+path) + 32 (pubkey) + 4 (timestamp) = 38
-	// That's byte 38 in the packet, hex chars 76-77
-	rawBytes := []byte(rawHex)
-	if rawBytes[76] == '0' {
-		rawBytes[76] = 'f'
-	} else {
-		rawBytes[76] = '0'
-	}
-	tamperedHex := string(rawBytes)
-
-	source := MQTTSource{Name: "test"}
-	msg := newMockMsg("meshcore/US/obs1/packet", `{"raw":"`+tamperedHex+`","origin":"TestObs"}`)
-	cfg := &Config{}
-
-	handleMessage(store, "test", source, msg, nil, cfg)
-
-	// Verify packet was NOT stored in transmissions
-	var txCount int
-	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&txCount)
-	if txCount != 0 {
-		t.Fatalf("tampered advert should be dropped, got %d transmissions", txCount)
-	}
-
-	// Verify it was recorded in dropped_packets
-	var dropCount int
-	store.db.QueryRow("SELECT COUNT(*) FROM dropped_packets").Scan(&dropCount)
-	if dropCount == 0 {
-		t.Fatal("tampered advert should be recorded in dropped_packets")
-	}
-
-	// Verify drop counter incremented
-	if store.Stats.SignatureDrops.Load() != 1 {
-		t.Fatalf("expected 1 signature drop, got %d", store.Stats.SignatureDrops.Load())
-	}
-
-	// Verify dropped_packets has correct fields
-	var reason, nodeKey, nodeName, obsID string
-	store.db.QueryRow("SELECT reason, node_pubkey, node_name, observer_id FROM dropped_packets LIMIT 1").Scan(&reason, &nodeKey, &nodeName, &obsID)
-	if reason != "invalid signature" {
-		t.Fatalf("expected reason 'invalid signature', got %q", reason)
-	}
-	if nodeKey == "" {
-		t.Fatal("dropped packet should have node_pubkey")
-	}
-	if !strings.Contains(nodeName, "BadNode") {
-		t.Fatalf("expected node_name to contain 'BadNode', got %q", nodeName)
-	}
-	if obsID != "obs1" {
-		t.Fatalf("expected observer_id 'obs1', got %q", obsID)
-	}
-}
-
-func TestSigValidation_TruncatedAppdataDropped(t *testing.T) {
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	pub, priv, _ := ed25519.GenerateKey(nil)
-	appdata := makeAppdata("TruncNode")
-	rawHex := buildAdvertHex(pub, priv, 1700000000, appdata)
-
-	// Sign was computed with full appdata. Now truncate the raw hex to remove
-	// some appdata bytes, making the signature invalid.
-	// Truncate last 4 hex chars (2 bytes of appdata)
-	truncatedHex := rawHex[:len(rawHex)-4]
-
-	source := MQTTSource{Name: "test"}
-	msg := newMockMsg("meshcore/US/obs1/packet", `{"raw":"`+truncatedHex+`","origin":"TestObs"}`)
-	cfg := &Config{}
-
-	handleMessage(store, "test", source, msg, nil, cfg)
-
-	var txCount int
-	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&txCount)
-	if txCount != 0 {
-		t.Fatalf("truncated advert should be dropped, got %d transmissions", txCount)
-	}
-}
-
-func TestSigValidation_DisabledByConfig(t *testing.T) {
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	pub, priv, _ := ed25519.GenerateKey(nil)
-	appdata := makeAppdata("NoValNode")
-	rawHex := buildAdvertHex(pub, priv, 1700000000, appdata)
-
-	// Tamper with signature
-	rawBytes := []byte(rawHex)
-	if rawBytes[76] == '0' {
-		rawBytes[76] = 'f'
-	} else {
-		rawBytes[76] = '0'
-	}
-	tamperedHex := string(rawBytes)
-
-	source := MQTTSource{Name: "test"}
-	msg := newMockMsg("meshcore/US/obs1/packet", `{"raw":"`+tamperedHex+`","origin":"TestObs"}`)
-	falseVal := false
-	cfg := &Config{ValidateSignatures: &falseVal}
-
-	handleMessage(store, "test", source, msg, nil, cfg)
-
-	// With validation disabled, tampered packet should be stored
-	var txCount int
-	store.db.QueryRow("SELECT COUNT(*) FROM transmissions").Scan(&txCount)
-	if txCount == 0 {
-		t.Fatal("with validateSignatures=false, tampered advert should be stored")
-	}
-}
-
-func TestSigValidation_DropCounterIncrements(t *testing.T) {
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	pub, priv, _ := ed25519.GenerateKey(nil)
-	source := MQTTSource{Name: "test"}
-	cfg := &Config{}
-
-	for i := 0; i < 3; i++ {
-		appdata := makeAppdata("Node")
-		rawHex := buildAdvertHex(pub, priv, uint32(1700000000+i), appdata)
-		// Tamper
-		rawBytes := []byte(rawHex)
-		if rawBytes[76] == '0' {
-			rawBytes[76] = 'f'
-		} else {
-			rawBytes[76] = '0'
-		}
-		msg := newMockMsg("meshcore/US/obs1/packet", `{"raw":"`+string(rawBytes)+`","origin":"Obs"}`)
-		handleMessage(store, "test", source, msg, nil, cfg)
-	}
-
-	if store.Stats.SignatureDrops.Load() != 3 {
-		t.Fatalf("expected 3 signature drops, got %d", store.Stats.SignatureDrops.Load())
-	}
-}
-
-func TestSigValidation_LogContainsFields(t *testing.T) {
-	// This test verifies the dropped_packets row has all required fields
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	pub, priv, _ := ed25519.GenerateKey(nil)
-	appdata := makeAppdata("LogTestNode")
-	rawHex := buildAdvertHex(pub, priv, 1700000000, appdata)
-
-	// Tamper
-	rawBytes := []byte(rawHex)
-	if rawBytes[76] == '0' {
-		rawBytes[76] = 'f'
-	} else {
-		rawBytes[76] = '0'
-	}
-
-	source := MQTTSource{Name: "test"}
-	msg := newMockMsg("meshcore/US/obs1/packet", `{"raw":"`+string(rawBytes)+`","origin":"MyObserver"}`)
-	cfg := &Config{}
-
-	handleMessage(store, "test", source, msg, nil, cfg)
-
-	var hash, reason, obsID, obsName, pubkey, nodeName string
-	err = store.db.QueryRow("SELECT hash, reason, observer_id, observer_name, node_pubkey, node_name FROM dropped_packets LIMIT 1").
-		Scan(&hash, &reason, &obsID, &obsName, &pubkey, &nodeName)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if hash == "" {
-		t.Error("dropped packet should have hash")
-	}
-	if reason != "invalid signature" {
-		t.Errorf("expected reason 'invalid signature', got %q", reason)
-	}
-	if obsID != "obs1" {
-		t.Errorf("expected observer_id 'obs1', got %q", obsID)
-	}
-	if obsName != "MyObserver" {
-		t.Errorf("expected observer_name 'MyObserver', got %q", obsName)
-	}
-	if pubkey == "" {
-		t.Error("dropped packet should have node_pubkey")
-	}
-	if !strings.Contains(nodeName, "LogTestNode") {
-		t.Errorf("expected node_name containing 'LogTestNode', got %q", nodeName)
-	}
-}
-
-func TestPruneDroppedPackets(t *testing.T) {
-	dbPath := t.TempDir() + "/test.db"
-	store, err := OpenStoreWithInterval(dbPath, 300)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer store.Close()
-
-	// Insert an old dropped packet
-	store.db.Exec(`INSERT INTO dropped_packets (hash, reason, dropped_at) VALUES ('old', 'test', datetime('now', '-60 days'))`)
-	store.db.Exec(`INSERT INTO dropped_packets (hash, reason, dropped_at) VALUES ('new', 'test', datetime('now'))`)
-
-	n, err := store.PruneDroppedPackets(30)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if n != 1 {
-		t.Fatalf("expected 1 pruned, got %d", n)
-	}
-
-	var count int
-	store.db.QueryRow("SELECT COUNT(*) FROM dropped_packets").Scan(&count)
-	if count != 1 {
-		t.Fatalf("expected 1 remaining, got %d", count)
-	}
-}
-
-func TestShouldValidateSignatures_Default(t *testing.T) {
-	cfg := &Config{}
-	if !cfg.ShouldValidateSignatures() {
-		t.Fatal("default should be true")
-	}
-
-	falseVal := false
-	cfg2 := &Config{ValidateSignatures: &falseVal}
-	if cfg2.ShouldValidateSignatures() {
-		t.Fatal("explicit false should be false")
-	}
-
-	trueVal := true
-	cfg3 := &Config{ValidateSignatures: &trueVal}
-	if !cfg3.ShouldValidateSignatures() {
-		t.Fatal("explicit true should be true")
-	}
-}
-
-// newMockMsg creates a minimal mqtt.Message for testing.
-func newMockMsg(topic, payload string) *mockMessage {
-	return &mockMessage{topic: topic, payload: []byte(payload)}
-}

cmd/server/bounded_load_test.go

@@ -1,407 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	_ "modernc.org/sqlite"
-)
-
-// createTestDB creates a temporary SQLite database with N transmissions (1 obs each).
-func createTestDB(t *testing.T, numTx int) string {
-	t.Helper()
-	dir := t.TempDir()
-	dbPath := filepath.Join(dir, "test.db")
-	createTestDBAt(t, dbPath, numTx)
-	return dbPath
-}
-
-// loadStore creates a PacketStore from a test DB with given maxMemoryMB.
-func loadStore(t *testing.T, dbPath string, maxMemMB int) *PacketStore {
-	t.Helper()
-	db, err := OpenDB(dbPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cfg := &PacketStoreConfig{MaxMemoryMB: maxMemMB}
-	store := NewPacketStore(db, cfg)
-	if err := store.Load(); err != nil {
-		t.Fatal(err)
-	}
-	return store
-}
-
-func TestBoundedLoad_LimitedMemory(t *testing.T) {
-	dbPath := createTestDB(t, 5000)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	// Use 1MB budget — should load far fewer than 5000 packets
-	store := loadStore(t, dbPath, 1)
-	defer store.db.conn.Close()
-
-	loaded := len(store.packets)
-	if loaded >= 5000 {
-		t.Errorf("expected bounded load to limit packets, got %d/5000", loaded)
-	}
-	if loaded < 1000 {
-		t.Errorf("expected at least 1000 packets (minimum), got %d", loaded)
-	}
-	t.Logf("Loaded %d/5000 packets with 1MB budget", loaded)
-}
-
-func TestBoundedLoad_NewestFirst(t *testing.T) {
-	dbPath := createTestDB(t, 5000)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	store := loadStore(t, dbPath, 1)
-	defer store.db.conn.Close()
-
-	loaded := len(store.packets)
-	if loaded >= 5000 {
-		t.Skip("all packets loaded, can't verify newest-first")
-	}
-
-	// The newest packet in DB has first_seen based on minute 5000.
-	// The loaded packets should be the newest ones.
-	// Last packet in store (sorted ASC) should be the newest in DB.
-	last := store.packets[loaded-1]
-	base := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
-	newestExpected := base.Add(5000 * time.Minute).Format(time.RFC3339)
-	if last.FirstSeen != newestExpected {
-		t.Errorf("expected last packet to be newest (%s), got %s", newestExpected, last.FirstSeen)
-	}
-
-	// First packet should NOT be the oldest in the DB (minute 1)
-	first := store.packets[0]
-	oldestAll := base.Add(1 * time.Minute).Format(time.RFC3339)
-	if first.FirstSeen == oldestAll {
-		t.Errorf("first loaded packet should not be the absolute oldest when bounded")
-	}
-}
-
-func TestBoundedLoad_OldestLoadedSet(t *testing.T) {
-	dbPath := createTestDB(t, 5000)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	store := loadStore(t, dbPath, 1)
-	defer store.db.conn.Close()
-
-	if store.oldestLoaded == "" {
-		t.Fatal("oldestLoaded should be set after bounded load")
-	}
-	if len(store.packets) > 0 && store.oldestLoaded != store.packets[0].FirstSeen {
-		t.Errorf("oldestLoaded (%s) should match first packet (%s)", store.oldestLoaded, store.packets[0].FirstSeen)
-	}
-	t.Logf("oldestLoaded = %s", store.oldestLoaded)
-}
-
-func TestBoundedLoad_UnlimitedWithZero(t *testing.T) {
-	dbPath := createTestDB(t, 200)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	store := loadStore(t, dbPath, 0)
-	defer store.db.conn.Close()
-
-	if len(store.packets) != 200 {
-		t.Errorf("expected all 200 packets with maxMemoryMB=0, got %d", len(store.packets))
-	}
-}
-
-func TestBoundedLoad_AscendingOrder(t *testing.T) {
-	dbPath := createTestDB(t, 3000)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	store := loadStore(t, dbPath, 1)
-	defer store.db.conn.Close()
-
-	// Verify packets are in ascending first_seen order
-	for i := 1; i < len(store.packets); i++ {
-		if store.packets[i].FirstSeen < store.packets[i-1].FirstSeen {
-			t.Fatalf("packets not in ascending order at index %d: %s < %s",
-				i, store.packets[i].FirstSeen, store.packets[i-1].FirstSeen)
-		}
-	}
-}
-
-// loadStoreWithRetention creates a PacketStore with retentionHours set.
-func loadStoreWithRetention(t *testing.T, dbPath string, retentionHours float64) *PacketStore {
-	t.Helper()
-	db, err := OpenDB(dbPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cfg := &PacketStoreConfig{RetentionHours: retentionHours}
-	store := NewPacketStore(db, cfg)
-	if err := store.Load(); err != nil {
-		t.Fatal(err)
-	}
-	return store
-}
-
-// createTestDBWithAgedPackets inserts numRecent packets with timestamps within
-// the last hour and numOld packets with timestamps 48 hours ago.
-func createTestDBWithAgedPackets(t *testing.T, numRecent, numOld int) string {
-	t.Helper()
-	dir := t.TempDir()
-	dbPath := filepath.Join(dir, "test.db")
-
-	conn, err := sql.Open("sqlite", dbPath+"?_journal_mode=WAL")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	execOrFail := func(s string) {
-		if _, err := conn.Exec(s); err != nil {
-			t.Fatalf("setup: %v\nSQL: %s", err, s)
-		}
-	}
-	execOrFail(`CREATE TABLE transmissions (id INTEGER PRIMARY KEY, raw_hex TEXT, hash TEXT, first_seen TEXT, route_type INTEGER, payload_type INTEGER, payload_version INTEGER, decoded_json TEXT)`)
-	execOrFail(`CREATE TABLE observations (id INTEGER PRIMARY KEY, transmission_id INTEGER, observer_id TEXT, observer_name TEXT, direction TEXT, snr REAL, rssi REAL, score INTEGER, path_json TEXT, timestamp TEXT, raw_hex TEXT)`)
-	execOrFail(`CREATE TABLE observers (rowid INTEGER PRIMARY KEY, id TEXT, name TEXT)`)
-	execOrFail(`CREATE TABLE nodes (pubkey TEXT PRIMARY KEY, name TEXT, role TEXT, lat REAL, lon REAL, last_seen TEXT, first_seen TEXT, frequency REAL)`)
-	execOrFail(`CREATE TABLE schema_version (version INTEGER)`)
-	execOrFail(`INSERT INTO schema_version (version) VALUES (1)`)
-	execOrFail(`CREATE INDEX idx_tx_first_seen ON transmissions(first_seen)`)
-
-	now := time.Now().UTC()
-	id := 1
-	// Insert old packets (48 hours ago)
-	for i := 0; i < numOld; i++ {
-		ts := now.Add(-48 * time.Hour).Add(time.Duration(i) * time.Second).Format(time.RFC3339)
-		conn.Exec("INSERT INTO transmissions VALUES (?,?,?,?,0,4,1,?)", id, "aa", fmt.Sprintf("old%d", i), ts, `{}`)
-		conn.Exec("INSERT INTO observations VALUES (?,?,?,?,?,?,?,?,?,?,?)", id, id, "obs1", "Obs1", "RX", -10.0, -80.0, 5, `[]`, ts, "")
-		id++
-	}
-	// Insert recent packets (within last hour)
-	for i := 0; i < numRecent; i++ {
-		ts := now.Add(-30 * time.Minute).Add(time.Duration(i) * time.Second).Format(time.RFC3339)
-		conn.Exec("INSERT INTO transmissions VALUES (?,?,?,?,0,4,1,?)", id, "bb", fmt.Sprintf("new%d", i), ts, `{}`)
-		conn.Exec("INSERT INTO observations VALUES (?,?,?,?,?,?,?,?,?,?,?)", id, id, "obs1", "Obs1", "RX", -10.0, -80.0, 5, `[]`, ts, "")
-		id++
-	}
-	return dbPath
-}
-
-func TestRetentionLoad_OnlyLoadsRecentPackets(t *testing.T) {
-	dbPath := createTestDBWithAgedPackets(t, 50, 100)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	// retention = 2 hours — should load only the 50 recent packets, not the 100 old ones
-	store := loadStoreWithRetention(t, dbPath, 2)
-	defer store.db.conn.Close()
-
-	if len(store.packets) != 50 {
-		t.Errorf("expected 50 recent packets, got %d (old packets should be excluded by retentionHours)", len(store.packets))
-	}
-}
-
-func TestRetentionLoad_ZeroRetentionLoadsAll(t *testing.T) {
-	dbPath := createTestDBWithAgedPackets(t, 50, 100)
-	defer os.RemoveAll(filepath.Dir(dbPath))
-
-	// retention = 0 (unlimited) — should load all 150 packets
-	store := loadStoreWithRetention(t, dbPath, 0)
-	defer store.db.conn.Close()
-
-	if len(store.packets) != 150 {
-		t.Errorf("expected all 150 packets with retentionHours=0, got %d", len(store.packets))
-	}
-}
-
-func TestEstimateStoreTxBytesTypical(t *testing.T) {
-	est := estimateStoreTxBytesTypical(10)
-	if est < 1000 {
-		t.Errorf("typical estimate too low: %d", est)
-	}
-	// Should be roughly proportional to observation count
-	est1 := estimateStoreTxBytesTypical(1)
-	est20 := estimateStoreTxBytesTypical(20)
-	if est20 <= est1 {
-		t.Errorf("estimate should grow with observations: 1obs=%d, 20obs=%d", est1, est20)
-	}
-	t.Logf("Typical estimate: 1obs=%d, 10obs=%d, 20obs=%d bytes", est1, est, est20)
-}
-
-func BenchmarkLoad_Bounded(b *testing.B) {
-	dir := b.TempDir()
-	dbPath := filepath.Join(dir, "bench.db")
-	createTestDBAt(b, dbPath, 5000)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		db, _ := OpenDB(dbPath)
-		cfg := &PacketStoreConfig{MaxMemoryMB: 1}
-		store := NewPacketStore(db, cfg)
-		store.Load()
-		db.conn.Close()
-	}
-}
-
-func BenchmarkLoad_Unlimited(b *testing.B) {
-	dir := b.TempDir()
-	dbPath := filepath.Join(dir, "bench.db")
-	createTestDBAt(b, dbPath, 5000)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		db, _ := OpenDB(dbPath)
-		cfg := &PacketStoreConfig{MaxMemoryMB: 0}
-		store := NewPacketStore(db, cfg)
-		store.Load()
-		db.conn.Close()
-	}
-}
-
-// BenchmarkLoad_30K_Bounded benchmarks bounded Load() with 30K transmissions
-// and realistic observation counts (1–5 per transmission).
-func BenchmarkLoad_30K_Bounded(b *testing.B) {
-	dir := b.TempDir()
-	dbPath := filepath.Join(dir, "bench30k.db")
-	createTestDBWithObs(b, dbPath, 30000)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		db, _ := OpenDB(dbPath)
-		cfg := &PacketStoreConfig{MaxMemoryMB: 50}
-		store := NewPacketStore(db, cfg)
-		store.Load()
-		db.conn.Close()
-	}
-}
-
-// BenchmarkLoad_30K_Unlimited benchmarks unlimited Load() with 30K transmissions
-// and realistic observation counts (1–5 per transmission).
-func BenchmarkLoad_30K_Unlimited(b *testing.B) {
-	dir := b.TempDir()
-	dbPath := filepath.Join(dir, "bench30k.db")
-	createTestDBWithObs(b, dbPath, 30000)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		db, _ := OpenDB(dbPath)
-		cfg := &PacketStoreConfig{MaxMemoryMB: 0}
-		store := NewPacketStore(db, cfg)
-		store.Load()
-		db.conn.Close()
-	}
-}
-
-// createTestDBAt is like createTestDB but writes to a specific path.
-func createTestDBAt(tb testing.TB, dbPath string, numTx int) {
-	tb.Helper()
-	conn, err := sql.Open("sqlite", dbPath+"?_journal_mode=WAL")
-	if err != nil {
-		tb.Fatal(err)
-	}
-	defer conn.Close()
-
-	execOrFail := func(sql string) {
-		if _, err := conn.Exec(sql); err != nil {
-			tb.Fatalf("test DB setup exec failed: %v\nSQL: %s", err, sql)
-		}
-	}
-	execOrFail(`CREATE TABLE IF NOT EXISTS transmissions (
-		id INTEGER PRIMARY KEY,
-		raw_hex TEXT, hash TEXT, first_seen TEXT,
-		route_type INTEGER, payload_type INTEGER,
-		payload_version INTEGER, decoded_json TEXT
-	)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS observations (
-		id INTEGER PRIMARY KEY,
-		transmission_id INTEGER, observer_id TEXT, observer_name TEXT,
-		direction TEXT, snr REAL, rssi REAL, score INTEGER,
-		path_json TEXT, timestamp TEXT, raw_hex TEXT
-	)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS observers (rowid INTEGER PRIMARY KEY, id TEXT, name TEXT)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS nodes (
-		pubkey TEXT PRIMARY KEY, name TEXT, role TEXT, lat REAL, lon REAL,
-		last_seen TEXT, first_seen TEXT, frequency REAL
-	)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER)`)
-	execOrFail(`INSERT INTO schema_version (version) VALUES (1)`)
-	execOrFail(`CREATE INDEX IF NOT EXISTS idx_tx_first_seen ON transmissions(first_seen)`)
-
-	txStmt, err := conn.Prepare("INSERT INTO transmissions (id, raw_hex, hash, first_seen, route_type, payload_type, payload_version, decoded_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
-	if err != nil {
-		tb.Fatalf("test DB prepare transmissions insert: %v", err)
-	}
-	obsStmt, err := conn.Prepare("INSERT INTO observations (id, transmission_id, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
-	if err != nil {
-		tb.Fatalf("test DB prepare observations insert: %v", err)
-	}
-	defer txStmt.Close()
-	defer obsStmt.Close()
-
-	base := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
-	for i := 1; i <= numTx; i++ {
-		ts := base.Add(time.Duration(i) * time.Minute).Format(time.RFC3339)
-		hash := fmt.Sprintf("h%04d", i)
-		txStmt.Exec(i, "aabb", hash, ts, 0, 4, 1, fmt.Sprintf(`{"pubKey":"pk%04d"}`, i))
-		obsStmt.Exec(i, i, "obs1", "Obs1", "RX", -10.0, -80.0, 5, `["aa","bb"]`, ts)
-	}
-}
-
-// createTestDBWithObs creates a test DB with realistic observation counts (1–5 per tx).
-func createTestDBWithObs(tb testing.TB, dbPath string, numTx int) {
-	tb.Helper()
-	conn, err := sql.Open("sqlite", dbPath+"?_journal_mode=WAL")
-	if err != nil {
-		tb.Fatal(err)
-	}
-	defer conn.Close()
-
-	execOrFail := func(sqlStr string) {
-		if _, err := conn.Exec(sqlStr); err != nil {
-			tb.Fatalf("test DB setup exec failed: %v\nSQL: %s", err, sqlStr)
-		}
-	}
-	execOrFail(`CREATE TABLE IF NOT EXISTS transmissions (
-		id INTEGER PRIMARY KEY, raw_hex TEXT, hash TEXT, first_seen TEXT,
-		route_type INTEGER, payload_type INTEGER, payload_version INTEGER, decoded_json TEXT
-	)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS observations (
-		id INTEGER PRIMARY KEY, transmission_id INTEGER, observer_id TEXT, observer_name TEXT,
-		direction TEXT, snr REAL, rssi REAL, score INTEGER, path_json TEXT, timestamp TEXT, raw_hex TEXT
-	)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS observers (rowid INTEGER PRIMARY KEY, id TEXT, name TEXT)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS nodes (
-		pubkey TEXT PRIMARY KEY, name TEXT, role TEXT, lat REAL, lon REAL,
-		last_seen TEXT, first_seen TEXT, frequency REAL
-	)`)
-	execOrFail(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER)`)
-	execOrFail(`INSERT INTO schema_version (version) VALUES (1)`)
-	execOrFail(`CREATE INDEX IF NOT EXISTS idx_tx_first_seen ON transmissions(first_seen)`)
-
-	txStmt, err := conn.Prepare("INSERT INTO transmissions (id, raw_hex, hash, first_seen, route_type, payload_type, payload_version, decoded_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
-	if err != nil {
-		tb.Fatalf("test DB prepare transmissions: %v", err)
-	}
-	obsStmt, err := conn.Prepare("INSERT INTO observations (id, transmission_id, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
-	if err != nil {
-		tb.Fatalf("test DB prepare observations: %v", err)
-	}
-	defer txStmt.Close()
-	defer obsStmt.Close()
-
-	observers := []string{"obs1", "obs2", "obs3", "obs4", "obs5"}
-	obsNames := []string{"Alpha", "Bravo", "Charlie", "Delta", "Echo"}
-	obsID := 1
-	base := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
-	for i := 1; i <= numTx; i++ {
-		ts := base.Add(time.Duration(i) * time.Minute).Format(time.RFC3339)
-		hash := fmt.Sprintf("h%06d", i)
-		txStmt.Exec(i, "aabb", hash, ts, 0, 4, 1, fmt.Sprintf(`{"pubKey":"pk%06d"}`, i))
-		nObs := (i % 5) + 1 // 1–5 observations per transmission
-		for j := 0; j < nObs; j++ {
-			snr := -5.0 + float64(j)*2.5
-			rssi := -90.0 + float64(j)*5.0
-			obsStmt.Exec(obsID, i, observers[j], obsNames[j], "RX", snr, rssi, 5-j, `["aa","bb"]`, ts)
-			obsID++
-		}
-	}
-}

cmd/server/channel_filter_test.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// TestPacketsChannelFilter verifies /api/packets?channel=... actually filters
-// (regression test for #812).
-func TestPacketsChannelFilter(t *testing.T) {
-	_, router := setupTestServer(t)
-
-	get := func(url string) map[string]interface{} {
-		req := httptest.NewRequest("GET", url, nil)
-		w := httptest.NewRecorder()
-		router.ServeHTTP(w, req)
-		if w.Code != http.StatusOK {
-			t.Fatalf("GET %s: expected 200, got %d", url, w.Code)
-		}
-		var body map[string]interface{}
-		if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-			t.Fatalf("decode %s: %v", url, err)
-		}
-		return body
-	}
-
-	all := get("/api/packets?limit=50")
-	allTotal := int(all["total"].(float64))
-	if allTotal < 2 {
-		t.Fatalf("expected baseline >= 2 packets, got %d", allTotal)
-	}
-
-	test := get("/api/packets?limit=50&channel=%23test")
-	testTotal := int(test["total"].(float64))
-	if testTotal == 0 {
-		t.Fatalf("channel=#test: expected >= 1 match, got 0 (filter ignored?)")
-	}
-	if testTotal >= allTotal {
-		t.Fatalf("channel=#test: expected fewer packets than baseline (%d), got %d", allTotal, testTotal)
-	}
-
-	// Every returned packet must be a CHAN/GRP_TXT (payload_type=5) on #test.
-	pkts, _ := test["packets"].([]interface{})
-	for _, p := range pkts {
-		m := p.(map[string]interface{})
-		if pt, _ := m["payload_type"].(float64); int(pt) != 5 {
-			t.Errorf("channel=#test: returned non-GRP_TXT packet (payload_type=%v)", m["payload_type"])
-		}
-	}
-
-	none := get("/api/packets?limit=50&channel=nonexistentchannel")
-	if int(none["total"].(float64)) != 0 {
-		t.Fatalf("channel=nonexistentchannel: expected total=0, got %v", none["total"])
-	}
-}

cmd/server/clock_skew.go

@@ -12,28 +12,19 @@ import (
 type SkewSeverity string
 
 const (
-	SkewDefault   SkewSeverity = "default"   // firmware-default epoch + uptime
-	SkewOK        SkewSeverity = "ok"        // |skew| <= 15s
-	SkewDegrading SkewSeverity = "degrading" // 15s < |skew| <= 60s
-	SkewDegraded  SkewSeverity = "degraded"  // 60s < |skew| <= 600s
-	SkewWrong     SkewSeverity = "wrong"     // |skew| > 600s and not default
+	SkewOK       SkewSeverity = "ok"       // < 5 min
+	SkewWarning  SkewSeverity = "warning"  // 5 min – 1 hour
+	SkewCritical SkewSeverity = "critical" // 1 hour – 30 days
+	SkewAbsurd   SkewSeverity = "absurd"   // > 30 days
+	SkewNoClock  SkewSeverity = "no_clock" // > 365 days — uninitialized RTC
 )
 
-// Known firmware default epochs. Nodes with advert_ts in
-// [epoch, epoch + maxPlausibleUptimeSec] are classified as "default".
-// See docs/clock-skew-redesign.md for provenance of each value.
-var defaultEpochs = []int64{0, 1609459200, 1672531200, 1715770351}
-
 // Default thresholds in seconds.
 const (
-	// maxPlausibleUptimeSec caps how far past a default epoch we still
-	// consider "default + uptime ticking". 730 days ≈ 2 years.
-	maxPlausibleUptimeSec = 1095 * 86400 // 3 years — covers solar repeater deployment lifetimes at firmware default
-
-	// Severity band boundaries (absolute skew in seconds).
-	skewThresholdOKSec        = 15
-	skewThresholdDegradingSec = 60
-	skewThresholdDegradedSec  = 600
+	skewThresholdWarnSec     = 5 * 60          // 5 minutes
+	skewThresholdCriticalSec = 60 * 60         // 1 hour
+	skewThresholdAbsurdSec   = 30 * 24 * 3600  // 30 days
+	skewThresholdNoClockSec  = 365 * 24 * 3600 // 365 days — uninitialized RTC
 
 	// minDriftSamples is the minimum number of advert transmissions needed
 	// to compute a meaningful linear drift rate.
@@ -42,53 +33,23 @@ const (
 	// maxReasonableDriftPerDay caps drift display. Physically impossible
 	// drift rates (> 1 day/day) indicate insufficient or outlier samples.
 	maxReasonableDriftPerDay = 86400.0
-
-	// maxPlausibleSkewJumpSec is the largest skew change between
-	// consecutive samples that we treat as physical drift.
-	maxPlausibleSkewJumpSec = 60.0
-
-	// theilSenMaxPoints caps the number of points fed to Theil-Sen
-	// regression (O(n²) in pairs).
-	theilSenMaxPoints = 200
 )
 
-// isDefaultEpoch returns true if the raw advert timestamp falls within
-// [epoch, epoch + maxPlausibleUptimeSec] for any known firmware default.
-// If matched, returns the matched epoch; otherwise returns 0.
-func isDefaultEpoch(advertTS int64) (bool, int64) {
-	// Find the largest epoch <= advertTS (closest match). Since ranges
-	// overlap, picking the closest avoids attributing a 2023-firmware
-	// node's timestamp to the 2024 epoch.
-	bestEpoch := int64(-1)
-	for _, epoch := range defaultEpochs {
-		if epoch <= advertTS && epoch > bestEpoch {
-			bestEpoch = epoch
-		}
-	}
-	if bestEpoch >= 0 && advertTS <= bestEpoch+maxPlausibleUptimeSec {
-		return true, bestEpoch
-	}
-	return false, 0
-}
-
-// classifySkew maps a raw advert timestamp and corrected skew (signed)
-// to a severity level. Takes math.Abs internally so callers may pass
-// signed values. Default detection runs on the raw advert_ts
-// (independent of observer calibration).
-func classifySkew(advertTS int64, skewSec float64) (SkewSeverity, int64) {
-	if ok, epoch := isDefaultEpoch(advertTS); ok {
-		return SkewDefault, epoch
-	}
-	abs := math.Abs(skewSec)
+// classifySkew maps absolute skew (seconds) to a severity level.
+// Float64 comparison is safe: inputs are rounded to 1 decimal via round(),
+// and thresholds are integer multiples of 60 — no rounding artifacts.
+func classifySkew(absSkewSec float64) SkewSeverity {
 	switch {
-	case abs <= skewThresholdOKSec:
-		return SkewOK, 0
-	case abs <= skewThresholdDegradingSec:
-		return SkewDegrading, 0
-	case abs <= skewThresholdDegradedSec:
-		return SkewDegraded, 0
+	case absSkewSec >= skewThresholdNoClockSec:
+		return SkewNoClock
+	case absSkewSec >= skewThresholdAbsurdSec:
+		return SkewAbsurd
+	case absSkewSec >= skewThresholdCriticalSec:
+		return SkewCritical
+	case absSkewSec >= skewThresholdWarnSec:
+		return SkewWarning
 	default:
-		return SkewWrong, 0
+		return SkewOK
 	}
 }
 
@@ -96,35 +57,34 @@ func classifySkew(advertTS int64, skewSec float64) (SkewSeverity, int64) {
 
 // skewSample is a single raw skew measurement from one advert observation.
 type skewSample struct {
-	advertTS   int64  // node's advert Unix timestamp
-	observedTS int64  // observation Unix timestamp
-	observerID string // which observer saw this
-	hash       string // transmission hash (for multi-observer grouping)
+	advertTS    int64  // node's advert Unix timestamp
+	observedTS  int64  // observation Unix timestamp
+	observerID  string // which observer saw this
+	hash        string // transmission hash (for multi-observer grouping)
 }
 
 // ObserverCalibration holds the computed clock offset for an observer.
 type ObserverCalibration struct {
 	ObserverID string  `json:"observerID"`
-	OffsetSec  float64 `json:"offsetSec"` // positive = observer clock ahead
-	Samples    int     `json:"samples"`   // number of multi-observer packets used
+	OffsetSec  float64 `json:"offsetSec"`  // positive = observer clock ahead
+	Samples    int     `json:"samples"`    // number of multi-observer packets used
 }
 
 // NodeClockSkew is the API response for a single node's clock skew data.
 type NodeClockSkew struct {
-	Pubkey         string       `json:"pubkey"`
-	MeanSkewSec    float64      `json:"meanSkewSec"`    // corrected mean skew (positive = node ahead)
-	MedianSkewSec  float64      `json:"medianSkewSec"`  // corrected median skew
-	LastSkewSec    float64      `json:"lastSkewSec"`    // most recent corrected skew
-	DriftPerDaySec float64      `json:"driftPerDaySec"` // linear drift rate (sec/day)
-	Severity       SkewSeverity `json:"severity"`
-	SampleCount    int          `json:"sampleCount"`
-	Calibrated     bool         `json:"calibrated"`     // true if observer calibration was applied
-	LastAdvertTS   int64        `json:"lastAdvertTS"`    // most recent advert timestamp
-	LastObservedTS int64        `json:"lastObservedTS"`  // most recent observation timestamp
-	DefaultEpoch   *int64       `json:"defaultEpoch,omitempty"` // matched epoch when severity=default
-	Samples        []SkewSample `json:"samples,omitempty"` // time-series for sparklines
-	NodeName       string       `json:"nodeName,omitempty"` // populated in fleet responses
-	NodeRole       string       `json:"nodeRole,omitempty"` // populated in fleet responses
+	Pubkey          string       `json:"pubkey"`
+	MeanSkewSec     float64      `json:"meanSkewSec"`     // corrected mean skew (positive = node ahead)
+	MedianSkewSec   float64      `json:"medianSkewSec"`   // corrected median skew
+	LastSkewSec     float64      `json:"lastSkewSec"`     // most recent corrected skew
+	DriftPerDaySec  float64      `json:"driftPerDaySec"`  // linear drift rate (sec/day)
+	Severity        SkewSeverity `json:"severity"`
+	SampleCount     int          `json:"sampleCount"`
+	Calibrated      bool         `json:"calibrated"`      // true if observer calibration was applied
+	LastAdvertTS    int64        `json:"lastAdvertTS"`     // most recent advert timestamp
+	LastObservedTS  int64        `json:"lastObservedTS"`   // most recent observation timestamp
+	Samples         []SkewSample `json:"samples,omitempty"` // time-series for sparklines
+	NodeName        string       `json:"nodeName,omitempty"` // populated in fleet responses
+	NodeRole        string       `json:"nodeRole,omitempty"` // populated in fleet responses
 }
 
 // SkewSample is a single (timestamp, skew) point for sparkline rendering.
@@ -133,26 +93,28 @@ type SkewSample struct {
 	SkewSec   float64 `json:"skew"` // corrected skew in seconds
 }
 
-// txSkewResult maps tx hash → per-transmission skew stats.
+// txSkewResult maps tx hash → per-transmission skew stats. This is an
+// intermediate result keyed by hash (not pubkey); the store maps hash → pubkey
+// when building the final per-node view.
 type txSkewResult = map[string]*NodeClockSkew
 
 // ── Clock Skew Engine ──────────────────────────────────────────────────────────
 
 // ClockSkewEngine computes and caches clock skew data for nodes and observers.
 type ClockSkewEngine struct {
-	mu              sync.RWMutex
-	observerOffsets map[string]float64 // observerID → calibrated offset (seconds)
-	observerSamples map[string]int     // observerID → number of multi-observer packets used
-	nodeSkew        txSkewResult
-	lastComputed    time.Time
-	computeInterval time.Duration
+	mu               sync.RWMutex
+	observerOffsets  map[string]float64 // observerID → calibrated offset (seconds)
+	observerSamples  map[string]int     // observerID → number of multi-observer packets used
+	nodeSkew         txSkewResult
+	lastComputed     time.Time
+	computeInterval  time.Duration
 }
 
 func NewClockSkewEngine() *ClockSkewEngine {
 	return &ClockSkewEngine{
-		observerOffsets: make(map[string]float64),
+		observerOffsets:  make(map[string]float64),
 		observerSamples: make(map[string]int),
-		nodeSkew:        make(txSkewResult),
+		nodeSkew:       make(txSkewResult),
 		computeInterval: 30 * time.Second,
 	}
 }
@@ -189,6 +151,7 @@ func (e *ClockSkewEngine) Recompute(store *PacketStore) {
 
 	// Swap results under brief write lock.
 	e.mu.Lock()
+	// Re-check: another goroutine may have computed while we were working.
 	if time.Since(e.lastComputed) < e.computeInterval {
 		e.mu.Unlock()
 		return
@@ -214,13 +177,13 @@ func collectSamples(store *PacketStore) []skewSample {
 		if decoded == nil {
 			continue
 		}
+		// Extract advert timestamp from decoded JSON.
 		advertTS := extractTimestamp(decoded)
-		if advertTS < 0 {
+		if advertTS <= 0 {
 			continue
 		}
-		// Allow epoch 0 and above (needed for default-epoch detection).
-		// Upper bound: year 2100.
-		if advertTS > 4102444800 {
+		// Sanity: skip timestamps before year 2020 or after year 2100.
+		if advertTS < 1577836800 || advertTS > 4102444800 {
 			continue
 		}
 
@@ -240,43 +203,21 @@ func collectSamples(store *PacketStore) []skewSample {
 	return samples
 }
 
-// timestampMissing is the sentinel returned by extractTimestamp when no
-// timestamp field is present in the decoded advert. Using -1 lets us
-// distinguish "field absent" from a real epoch-0 timestamp (ts == 0).
-const timestampMissing int64 = -1
-
 // extractTimestamp gets the Unix timestamp from a decoded ADVERT payload.
-// Returns timestampMissing (-1) if no timestamp field is found.
 func extractTimestamp(decoded map[string]interface{}) int64 {
+	// Try payload.timestamp first (nested in "payload" key).
 	if payload, ok := decoded["payload"]; ok {
 		if pm, ok := payload.(map[string]interface{}); ok {
-			if ts, ok := jsonNumberOk(pm, "timestamp"); ok {
+			if ts := jsonNumber(pm, "timestamp"); ts > 0 {
 				return ts
 			}
 		}
 	}
-	if ts, ok := jsonNumberOk(decoded, "timestamp"); ok {
+	// Fallback: top-level timestamp.
+	if ts := jsonNumber(decoded, "timestamp"); ts > 0 {
 		return ts
 	}
-	return timestampMissing
-}
-
-// jsonNumberOk extracts an int64 from a JSON-parsed map, returning (value, true)
-// if the key exists and is numeric, or (0, false) otherwise.
-func jsonNumberOk(m map[string]interface{}, key string) (int64, bool) {
-	v, ok := m[key]
-	if !ok || v == nil {
-		return 0, false
-	}
-	switch n := v.(type) {
-	case float64:
-		return int64(n), true
-	case int64:
-		return n, true
-	case int:
-		return int64(n), true
-	}
-	return 0, false
+	return 0
 }
 
 // jsonNumber extracts an int64 from a JSON-parsed map (handles float64 and json.Number).
@@ -303,6 +244,7 @@ func parseISO(s string) int64 {
 	}
 	t, err := time.Parse(time.RFC3339, s)
 	if err != nil {
+		// Try with fractional seconds.
 		t, err = time.Parse("2006-01-02T15:04:05.999999999Z07:00", s)
 		if err != nil {
 			return 0
@@ -316,16 +258,19 @@ func parseISO(s string) int64 {
 // calibrateObservers computes each observer's clock offset using multi-observer
 // packets. Returns offset map and sample count map.
 func calibrateObservers(samples []skewSample) (map[string]float64, map[string]int) {
+	// Group observations by packet hash.
 	byHash := make(map[string][]skewSample)
 	for _, s := range samples {
 		byHash[s.hash] = append(byHash[s.hash], s)
 	}
 
-	deviations := make(map[string][]float64)
+	// For each multi-observer packet, compute per-observer deviation from median.
+	deviations := make(map[string][]float64) // observerID → list of deviations
 	for _, group := range byHash {
 		if len(group) < 2 {
-			continue
+			continue // single-observer packet, can't calibrate
 		}
+		// Compute median observation timestamp for this packet.
 		obsTimes := make([]float64, len(group))
 		for i, s := range group {
 			obsTimes[i] = float64(s.observedTS)
@@ -337,6 +282,7 @@ func calibrateObservers(samples []skewSample) (map[string]float64, map[string]in
 		}
 	}
 
+	// Each observer's offset = median of its deviations.
 	offsets := make(map[string]float64, len(deviations))
 	counts := make(map[string]int, len(deviations))
 	for obsID, devs := range deviations {
@@ -350,6 +296,8 @@ func calibrateObservers(samples []skewSample) (map[string]float64, map[string]in
 
 // computeNodeSkew calculates corrected skew statistics for each node.
 func computeNodeSkew(samples []skewSample, obsOffsets map[string]float64) txSkewResult {
+	// Compute corrected skew per sample, grouped by hash (each hash = one
+	// node's advert transmission). The caller maps hash → pubkey via byNode.
 	type correctedSample struct {
 		skew       float64
 		observedTS int64
@@ -364,6 +312,8 @@ func computeNodeSkew(samples []skewSample, obsOffsets map[string]float64) txSkew
 		rawSkew := float64(s.advertTS - s.observedTS)
 		corrected := rawSkew
 		if hasCal {
+			// Observer offset = obs_ts - median(all_obs_ts). If observer is ahead,
+			// its obs_ts is inflated, making raw_skew too low. Add offset to correct.
 			corrected = rawSkew + obsOffset
 		}
 		byHash[s.hash] = append(byHash[s.hash], correctedSample{
@@ -374,7 +324,10 @@ func computeNodeSkew(samples []skewSample, obsOffsets map[string]float64) txSkew
 		hashAdvertTS[s.hash] = s.advertTS
 	}
 
-	result := make(map[string]*NodeClockSkew)
+	// Each hash represents one advert from one node. Compute median corrected
+	// skew per hash (across multiple observers).
+
+	result := make(map[string]*NodeClockSkew) // keyed by hash for now
 	for hash, cs := range byHash {
 		skews := make([]float64, len(cs))
 		for i, c := range cs {
@@ -383,37 +336,29 @@ func computeNodeSkew(samples []skewSample, obsOffsets map[string]float64) txSkew
 		medSkew := median(skews)
 		meanSkew := mean(skews)
 
-		// Pick the skew from the most recent observation (max observedTS),
-		// not the last-appended sample which may be non-chronological.
-		var latest correctedSample
+		// Find latest observation.
+		var latestObsTS int64
 		var anyCal bool
 		for _, c := range cs {
-			if c.observedTS > latest.observedTS {
-				latest = c
+			if c.observedTS > latestObsTS {
+				latestObsTS = c.observedTS
 			}
 			if c.calibrated {
 				anyCal = true
 			}
 		}
-		lastCorrectedSkew := latest.skew
-		advTS := hashAdvertTS[hash]
-		severity, matchedEpoch := classifySkew(advTS, lastCorrectedSkew)
 
-		ncs := &NodeClockSkew{
+		absMedian := math.Abs(medSkew)
+		result[hash] = &NodeClockSkew{
 			MeanSkewSec:    round(meanSkew, 1),
 			MedianSkewSec:  round(medSkew, 1),
-			LastSkewSec:    round(lastCorrectedSkew, 1),
-			Severity:       severity,
+			LastSkewSec:    round(cs[len(cs)-1].skew, 1),
+			Severity:       classifySkew(absMedian),
 			SampleCount:    len(cs),
 			Calibrated:     anyCal,
-			LastAdvertTS:   advTS,
-			LastObservedTS: latest.observedTS,
+			LastAdvertTS:   hashAdvertTS[hash],
+			LastObservedTS: latestObsTS,
 		}
-		if severity == SkewDefault {
-			ep := matchedEpoch
-			ncs.DefaultEpoch = &ep
-		}
-		result[hash] = ncs
 	}
 	return result
 }
@@ -474,29 +419,27 @@ func (s *PacketStore) getNodeClockSkewLocked(pubkey string) *NodeClockSkew {
 
 	medSkew := median(allSkews)
 	meanSkew := mean(allSkews)
+	absMedian := math.Abs(medSkew)
+	severity := classifySkew(absMedian)
 
-	// Classify using the most recent advert's raw timestamp and
-	// the most recent corrected skew. No windowing or median-driven
-	// severity — per-advert classification per the spec.
-	severity, matchedEpoch := classifySkew(lastAdvTS, lastSkew)
-
-	// Drift: display only, not a classifier input.
+	// For no_clock nodes (uninitialized RTC), skip drift — data is meaningless.
 	var drift float64
-	if severity != SkewDefault && len(tsSkews) >= minDriftSamples {
+	if severity != SkewNoClock && len(tsSkews) >= minDriftSamples {
 		drift = computeDrift(tsSkews)
+		// Cap physically impossible drift rates.
 		if math.Abs(drift) > maxReasonableDriftPerDay {
 			drift = 0
 		}
 	}
 
-	// Build sparkline samples.
+	// Build sparkline samples from tsSkews (sorted by time).
 	sort.Slice(tsSkews, func(i, j int) bool { return tsSkews[i].ts < tsSkews[j].ts })
 	samples := make([]SkewSample, len(tsSkews))
 	for i, p := range tsSkews {
 		samples[i] = SkewSample{Timestamp: p.ts, SkewSec: round(p.skew, 1)}
 	}
 
-	result := &NodeClockSkew{
+	return &NodeClockSkew{
 		Pubkey:         pubkey,
 		MeanSkewSec:    round(meanSkew, 1),
 		MedianSkewSec:  round(medSkew, 1),
@@ -509,11 +452,6 @@ func (s *PacketStore) getNodeClockSkewLocked(pubkey string) *NodeClockSkew {
 		LastObservedTS: lastObsTS,
 		Samples:        samples,
 	}
-	if severity == SkewDefault {
-		ep := matchedEpoch
-		result.DefaultEpoch = &ep
-	}
-	return result
 }
 
 // GetFleetClockSkew returns clock skew data for all nodes that have skew data.
@@ -522,6 +460,7 @@ func (s *PacketStore) GetFleetClockSkew() []*NodeClockSkew {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
+	// Build name/role lookup from DB cache (requires s.mu held).
 	allNodes, _ := s.getCachedNodesAndPM()
 	nameMap := make(map[string]nodeInfo, len(allNodes))
 	for _, ni := range allNodes {
@@ -534,10 +473,12 @@ func (s *PacketStore) GetFleetClockSkew() []*NodeClockSkew {
 		if cs == nil {
 			continue
 		}
+		// Enrich with node name/role.
 		if ni, ok := nameMap[pubkey]; ok {
 			cs.NodeName = ni.Name
 			cs.NodeRole = ni.Role
 		}
+		// Omit samples in fleet response (too much data).
 		cs.Samples = nil
 		results = append(results, cs)
 	}
@@ -562,6 +503,7 @@ func (s *PacketStore) GetObserverCalibrations() []ObserverCalibration {
 			Samples:    s.clockSkew.observerSamples[obsID],
 		})
 	}
+	// Sort by absolute offset descending.
 	sort.Slice(result, func(i, j int) bool {
 		return math.Abs(result[i].OffsetSec) > math.Abs(result[j].OffsetSec)
 	})
@@ -602,57 +544,37 @@ type tsSkewPair struct {
 }
 
 // computeDrift estimates linear drift in seconds per day from time-ordered
-// (timestamp, skew) pairs using Theil-Sen regression with outlier filtering.
+// (timestamp, skew) pairs using simple linear regression.
 func computeDrift(pairs []tsSkewPair) float64 {
 	if len(pairs) < 2 {
 		return 0
 	}
+	// Sort by timestamp.
 	sort.Slice(pairs, func(i, j int) bool {
 		return pairs[i].ts < pairs[j].ts
 	})
 
+	// Time span too short? Skip.
 	spanSec := float64(pairs[len(pairs)-1].ts - pairs[0].ts)
-	if spanSec < 3600 {
+	if spanSec < 3600 { // need at least 1 hour of data
 		return 0
 	}
 
-	filtered := make([]tsSkewPair, 0, len(pairs))
-	filtered = append(filtered, pairs[0])
-	for i := 1; i < len(pairs); i++ {
-		prev := filtered[len(filtered)-1]
-		if math.Abs(pairs[i].skew-prev.skew) <= maxPlausibleSkewJumpSec {
-			filtered = append(filtered, pairs[i])
-		}
+	// Simple linear regression: skew = a + b*t
+	n := float64(len(pairs))
+	var sumX, sumY, sumXY, sumX2 float64
+	for _, p := range pairs {
+		x := float64(p.ts - pairs[0].ts) // normalize to avoid large numbers
+		y := p.skew
+		sumX += x
+		sumY += y
+		sumXY += x * y
+		sumX2 += x * x
 	}
-	if len(filtered) < 2 || float64(filtered[len(filtered)-1].ts-filtered[0].ts) < 3600 {
-		filtered = pairs
+	denom := n*sumX2 - sumX*sumX
+	if denom == 0 {
+		return 0
 	}
-
-	if len(filtered) > theilSenMaxPoints {
-		filtered = filtered[len(filtered)-theilSenMaxPoints:]
-	}
-
-	return theilSenSlope(filtered) * 86400
-}
-
-// theilSenSlope returns the Theil-Sen estimator: median of all pairwise slopes.
-func theilSenSlope(pairs []tsSkewPair) float64 {
-	n := len(pairs)
-	if n < 2 {
-		return 0
-	}
-	slopes := make([]float64, 0, n*(n-1)/2)
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			dt := float64(pairs[j].ts - pairs[i].ts)
-			if dt <= 0 {
-				continue
-			}
-			slopes = append(slopes, (pairs[j].skew-pairs[i].skew)/dt)
-		}
-	}
-	if len(slopes) == 0 {
-		return 0
-	}
-	return median(slopes)
+	slope := (n*sumXY - sumX*sumY) / denom // seconds of drift per second
+	return slope * 86400                     // convert to seconds per day
 }

cmd/server/clock_skew_test.go

@@ -9,182 +9,34 @@ import (
 
 // ── classifySkew ───────────────────────────────────────────────────────────────
 
-func TestClassify_Default_AllKnownEpochs(t *testing.T) {
-	// Each known default epoch at +0s, +1d uptime → default.
-	for _, epoch := range defaultEpochs {
-		for _, uptimeSec := range []int64{0, 86400} {
-			advTS := epoch + uptimeSec
-			sev, _ := classifySkew(advTS, 999999) // skew irrelevant for default
-			if sev != SkewDefault {
-				t.Errorf("classifySkew(epoch=%d + %ds) = %v, want default", epoch, uptimeSec, sev)
-			}
-		}
-	}
-	// Also test at 1094d for the most recent epoch (no overlap issue).
-	advTS := defaultEpochs[len(defaultEpochs)-1] + 1094*86400
-	sev, matched := classifySkew(advTS, 999999)
-	if sev != SkewDefault {
-		t.Errorf("classifySkew(latest epoch + 1094d) = %v, want default", sev)
-	}
-	if matched != defaultEpochs[len(defaultEpochs)-1] {
-		t.Errorf("matched = %d, want %d", matched, defaultEpochs[len(defaultEpochs)-1])
-	}
-}
-
-func TestClassify_Default_BeyondUptimeCap(t *testing.T) {
-	// 1096 days past the LATEST epoch → NOT default.
-	latestEpoch := defaultEpochs[len(defaultEpochs)-1]
-	advTS := latestEpoch + 1096*86400
-	sev, _ := classifySkew(advTS, 5)
-	if sev == SkewDefault {
-		t.Errorf("classifySkew(latestEpoch + 1096d) = default, should fall through")
-	}
-}
-
-func TestMaxPlausibleUptime_CoversSolarRepeaterLifetimes(t *testing.T) {
-	// A solar repeater running for 3 years at firmware default 1715770351
-	// should still classify as "default".
-	epoch := int64(1715770351)
-	advTS := epoch + 1095*86400 // exactly 3 years
-	sev, _ := classifySkew(advTS, 5)
-	if sev != SkewDefault {
-		t.Errorf("classifySkew(firmware default + 3y) = %v, want default", sev)
-	}
-}
-
-func TestClassify_OK(t *testing.T) {
-	// Use a timestamp outside all default-epoch ranges.
-	advTS := int64(1900000000) // 2030-03 — well past any default+1095d
+func TestClassifySkew(t *testing.T) {
 	tests := []struct {
-		skew float64
-		want SkewSeverity
+		absSkew  float64
+		expected SkewSeverity
 	}{
 		{0, SkewOK},
-		{15, SkewOK},
-		{15.0, SkewOK},
+		{60, SkewOK},           // 1 min
+		{299, SkewOK},          // just under 5 min
+		{300, SkewWarning},     // exactly 5 min
+		{1800, SkewWarning},    // 30 min
+		{3599, SkewWarning},    // just under 1 hour
+		{3600, SkewCritical},   // exactly 1 hour
+		{86400, SkewCritical},  // 1 day
+		{2592000 - 1, SkewCritical}, // just under 30 days
+		{2592000, SkewAbsurd},  // exactly 30 days
+		{86400 * 365 - 1, SkewAbsurd}, // just under 365 days
+		{86400 * 365, SkewNoClock}, // exactly 365 days
+		{86400 * 365 * 10, SkewNoClock}, // 10 years (epoch-0 style)
 	}
 	for _, tc := range tests {
-		sev, _ := classifySkew(advTS, tc.skew)
-		if sev != tc.want {
-			t.Errorf("classifySkew(advTS, %v) = %v, want %v", tc.skew, sev, tc.want)
+		got := classifySkew(tc.absSkew)
+		if got != tc.expected {
+			t.Errorf("classifySkew(%v) = %v, want %v", tc.absSkew, got, tc.expected)
 		}
 	}
 }
 
-func TestClassify_Degrading(t *testing.T) {
-	advTS := int64(1900000000)
-	tests := []float64{16, 30, 60}
-	for _, skew := range tests {
-		sev, _ := classifySkew(advTS, skew)
-		if sev != SkewDegrading {
-			t.Errorf("classifySkew(advTS, %v) = %v, want degrading", skew, sev)
-		}
-	}
-}
-
-func TestClassify_Degraded(t *testing.T) {
-	advTS := int64(1900000000)
-	tests := []float64{61, 300, 600}
-	for _, skew := range tests {
-		sev, _ := classifySkew(advTS, skew)
-		if sev != SkewDegraded {
-			t.Errorf("classifySkew(advTS, %v) = %v, want degraded", skew, sev)
-		}
-	}
-}
-
-func TestClassify_Wrong(t *testing.T) {
-	advTS := int64(1900000000)
-	tests := []float64{601, 3600, 86400 * 365}
-	for _, skew := range tests {
-		sev, _ := classifySkew(advTS, skew)
-		if sev != SkewWrong {
-			t.Errorf("classifySkew(advTS, %v) = %v, want wrong", skew, sev)
-		}
-	}
-}
-
-func TestClassify_FutureWrong(t *testing.T) {
-	// Advert_ts in 2030 + 700s offset — not a default epoch.
-	advTS := int64(1900000700)
-	sev, _ := classifySkew(advTS, 700)
-	if sev != SkewWrong {
-		t.Errorf("classifySkew(future, 700) = %v, want wrong", sev)
-	}
-}
-
-func TestClassify_NegativeSkewUsesAbsoluteValue(t *testing.T) {
-	advTS := int64(1900000000) // outside default-epoch ranges
-	cases := []struct {
-		skew float64
-		want SkewSeverity
-	}{
-		{-10, SkewOK},
-		{-30, SkewDegrading},
-		{-300, SkewDegraded},
-		{-1000, SkewWrong},
-		{10, SkewOK},
-		{30, SkewDegrading},
-		{300, SkewDegraded},
-		{1000, SkewWrong},
-	}
-	for _, c := range cases {
-		if got, _ := classifySkew(advTS, c.skew); got != c.want {
-			t.Errorf("classifySkew(advTS, %v) = %v, want %v", c.skew, got, c.want)
-		}
-	}
-}
-
-// ── isDefaultEpoch ─────────────────────────────────────────────────────────────
-
-func TestIsDefaultEpoch_Boundaries(t *testing.T) {
-	// Exactly at epoch → true.
-	ok, ep := isDefaultEpoch(1715770351)
-	if !ok || ep != 1715770351 {
-		t.Errorf("isDefaultEpoch(1715770351) = %v, %d", ok, ep)
-	}
-	// At epoch + maxPlausibleUptimeSec → true.
-	ok, ep = isDefaultEpoch(1715770351 + maxPlausibleUptimeSec)
-	if !ok {
-		t.Error("expected true at epoch + maxPlausibleUptimeSec")
-	}
-	// Just past → false.
-	ok, _ = isDefaultEpoch(1715770351 + maxPlausibleUptimeSec + 1)
-	if ok {
-		t.Error("expected false past max uptime")
-	}
-	// Epoch 0 → true.
-	ok, ep = isDefaultEpoch(0)
-	if !ok || ep != 0 {
-		t.Errorf("isDefaultEpoch(0) = %v, %d", ok, ep)
-	}
-}
-
-func TestIsDefault_OverlappingWindowsPicksLargest(t *testing.T) {
-	// 1715770351 (2024-05-15) falls in the range of BOTH epoch 1672531200
-	// (2023-01-01, +1095d covers through 2026) AND epoch 1715770351 itself.
-	// The classifier must pick the largest epoch ≤ advertTS.
-	ok, ep := isDefaultEpoch(1715770351)
-	if !ok || ep != 1715770351 {
-		t.Errorf("isDefaultEpoch(1715770351) = %v, epoch %d; want true, 1715770351", ok, ep)
-	}
-
-	// 1672531200 + 100 days — only falls in epoch 1672531200's range.
-	ts100d := int64(1672531200 + 100*86400)
-	ok, ep = isDefaultEpoch(ts100d)
-	if !ok || ep != 1672531200 {
-		t.Errorf("isDefaultEpoch(%d) = %v, epoch %d; want true, 1672531200", ts100d, ok, ep)
-	}
-
-	// Timestamp between 1672531200 and 1715770351 but closer to 1715770351
-	// — e.g. 1715770350 (1 second before the 2024 epoch). Should match 1672531200.
-	ok, ep = isDefaultEpoch(1715770350)
-	if !ok || ep != 1672531200 {
-		t.Errorf("isDefaultEpoch(1715770350) = %v, epoch %d; want true, 1672531200", ok, ep)
-	}
-}
-
-// ── median / mean ──────────────────────────────────────────────────────────────
+// ── median ─────────────────────────────────────────────────────────────────────
 
 func TestMedian(t *testing.T) {
 	tests := []struct {
@@ -247,6 +99,7 @@ func TestParseISO(t *testing.T) {
 // ── extractTimestamp ────────────────────────────────────────────────────────────
 
 func TestExtractTimestamp(t *testing.T) {
+	// Nested payload.timestamp
 	decoded := map[string]interface{}{
 		"payload": map[string]interface{}{
 			"timestamp": float64(1776340800),
@@ -257,6 +110,7 @@ func TestExtractTimestamp(t *testing.T) {
 		t.Errorf("extractTimestamp (nested) = %v, want 1776340800", got)
 	}
 
+	// Top-level timestamp
 	decoded2 := map[string]interface{}{
 		"timestamp": float64(1776340900),
 	}
@@ -265,27 +119,18 @@ func TestExtractTimestamp(t *testing.T) {
 		t.Errorf("extractTimestamp (top-level) = %v, want 1776340900", got2)
 	}
 
+	// No timestamp
 	decoded3 := map[string]interface{}{"foo": "bar"}
 	got3 := extractTimestamp(decoded3)
-	if got3 != timestampMissing {
-		t.Errorf("extractTimestamp (missing) = %v, want %v", got3, timestampMissing)
-	}
-
-	// Epoch-0 timestamp is a valid value, not "missing".
-	decoded4 := map[string]interface{}{
-		"payload": map[string]interface{}{
-			"timestamp": float64(0),
-		},
-	}
-	got4 := extractTimestamp(decoded4)
-	if got4 != 0 {
-		t.Errorf("extractTimestamp (epoch-0) = %v, want 0", got4)
+	if got3 != 0 {
+		t.Errorf("extractTimestamp (missing) = %v, want 0", got3)
 	}
 }
 
 // ── calibrateObservers ─────────────────────────────────────────────────────────
 
 func TestCalibrateObservers_SingleObserver(t *testing.T) {
+	// Single-observer packets can't calibrate — should return empty.
 	samples := []skewSample{
 		{advertTS: 1000, observedTS: 1000, observerID: "obs1", hash: "h1"},
 		{advertTS: 2000, observedTS: 2000, observerID: "obs1", hash: "h2"},
@@ -297,6 +142,10 @@ func TestCalibrateObservers_SingleObserver(t *testing.T) {
 }
 
 func TestCalibrateObservers_MultiObserver(t *testing.T) {
+	// Packet h1 seen by 3 observers: obs1 at t=100, obs2 at t=110, obs3 at t=100.
+	// Median observation = 100. obs1=0, obs2=+10, obs3=0
+	// Packet h2 seen by 3 observers: obs1 at t=200, obs2 at t=210, obs3 at t=200.
+	// Median observation = 200. obs1=0, obs2=+10, obs3=0
 	samples := []skewSample{
 		{advertTS: 100, observedTS: 100, observerID: "obs1", hash: "h1"},
 		{advertTS: 100, observedTS: 110, observerID: "obs2", hash: "h1"},
@@ -320,41 +169,75 @@ func TestCalibrateObservers_MultiObserver(t *testing.T) {
 // ── computeNodeSkew ────────────────────────────────────────────────────────────
 
 func TestComputeNodeSkew_BasicCorrection(t *testing.T) {
+	// Validates observer offset correction direction.
+	//
+	// Setup: node is 60s ahead, obs1 accurate, obs2 is 10s ahead.
+	// With 2 observers, median obs_ts = 1005.
+	//   obs1 offset = 1000 - 1005 = -5
+	//   obs2 offset = 1010 - 1005 = +5
+	// Correction: corrected = raw_skew + obsOffset
+	//   obs1: raw=60, corrected = 60 + (-5) = 55
+	//   obs2: raw=50, corrected = 50 + 5 = 55
+	// Both converge to 55 (not exact 60 because with only 2 observers,
+	// the median can't fully distinguish which observer is drifted).
+
 	samples := []skewSample{
+		// Same packet seen by accurate obs1 and obs2 (+10s ahead)
 		{advertTS: 1060, observedTS: 1000, observerID: "obs1", hash: "h1"},
 		{advertTS: 1060, observedTS: 1010, observerID: "obs2", hash: "h1"},
 	}
 	offsets, _ := calibrateObservers(samples)
+	// median obs = 1005, obs1 offset = -5, obs2 offset = +5
+	// So the median approach finds obs2 is +5 ahead (relative to median)
+
+	// Now compute node skew with those offsets:
 	nodeSkew := computeNodeSkew(samples, offsets)
 	cs, ok := nodeSkew["h1"]
 	if !ok {
 		t.Fatal("expected skew data for hash h1")
 	}
+	// With only 2 observers, median obs_ts = 1005.
+	// obs1 offset = 1000-1005 = -5, obs2 offset = 1010-1005 = +5
+	// raw from obs1 = 60, corrected = 60 + (-5) = 55
+	// raw from obs2 = 50, corrected = 50 + 5 = 55
+	// median = 55
 	if cs.MedianSkewSec != 55 {
 		t.Errorf("median skew = %v, want 55", cs.MedianSkewSec)
 	}
 }
 
 func TestComputeNodeSkew_ThreeObservers(t *testing.T) {
+	// Node is exactly 60s ahead. obs1 accurate, obs2 accurate, obs3 +30s ahead.
+	// advertTS = 1060, real time = 1000
 	samples := []skewSample{
 		{advertTS: 1060, observedTS: 1000, observerID: "obs1", hash: "h1"},
 		{advertTS: 1060, observedTS: 1000, observerID: "obs2", hash: "h1"},
 		{advertTS: 1060, observedTS: 1030, observerID: "obs3", hash: "h1"},
 	}
 	offsets, _ := calibrateObservers(samples)
+	// median obs_ts = 1000. obs1=0, obs2=0, obs3=+30
+	if offsets["obs3"] != 30 {
+		t.Errorf("obs3 offset = %v, want 30", offsets["obs3"])
+	}
+
 	nodeSkew := computeNodeSkew(samples, offsets)
 	cs := nodeSkew["h1"]
 	if cs == nil {
 		t.Fatal("expected skew data for h1")
 	}
+	// raw from obs1 = 60, corrected = 60 + 0 = 60
+	// raw from obs2 = 60, corrected = 60 + 0 = 60
+	// raw from obs3 = 30, corrected = 30 + 30 = 60
+	// All three converge to 60. 
 	if cs.MedianSkewSec != 60 {
-		t.Errorf("median skew = %v, want 60", cs.MedianSkewSec)
+		t.Errorf("median skew = %v, want 60 (node is 60s ahead)", cs.MedianSkewSec)
 	}
 }
 
 // ── computeDrift ───────────────────────────────────────────────────────────────
 
 func TestComputeDrift_Stable(t *testing.T) {
+	// Constant skew = no drift.
 	pairs := []tsSkewPair{
 		{ts: 0, skew: 60},
 		{ts: 7200, skew: 60},
@@ -362,19 +245,21 @@ func TestComputeDrift_Stable(t *testing.T) {
 	}
 	drift := computeDrift(pairs)
 	if drift != 0 {
-		t.Errorf("drift = %v, want 0", drift)
+		t.Errorf("drift = %v, want 0 for stable skew", drift)
 	}
 }
 
 func TestComputeDrift_LinearDrift(t *testing.T) {
+	// 1 second drift per hour = 24 sec/day.
 	pairs := []tsSkewPair{
 		{ts: 0, skew: 0},
 		{ts: 3600, skew: 1},
 		{ts: 7200, skew: 2},
 	}
 	drift := computeDrift(pairs)
-	if math.Abs(drift-24.0) > 0.1 {
-		t.Errorf("drift = %v, want ~24", drift)
+	expected := 24.0
+	if math.Abs(drift-expected) > 0.1 {
+		t.Errorf("drift = %v, want ~%v", drift, expected)
 	}
 }
 
@@ -386,6 +271,7 @@ func TestComputeDrift_TooFewSamples(t *testing.T) {
 }
 
 func TestComputeDrift_TooShortSpan(t *testing.T) {
+	// Less than 1 hour apart.
 	pairs := []tsSkewPair{
 		{ts: 0, skew: 0},
 		{ts: 1800, skew: 10},
@@ -395,34 +281,6 @@ func TestComputeDrift_TooShortSpan(t *testing.T) {
 	}
 }
 
-func TestDriftRejectsCorrectionJump(t *testing.T) {
-	pairs := []tsSkewPair{}
-	for i := 0; i < 12; i++ {
-		ts := int64(i) * 300
-		skew := float64(i) * (1.0 / 24.0)
-		pairs = append(pairs, tsSkewPair{ts: ts, skew: skew})
-	}
-	pairs = append(pairs, tsSkewPair{ts: 3600 + 12*300, skew: 1000})
-	drift := computeDrift(pairs)
-	if math.Abs(drift) > 100 {
-		t.Errorf("drift = %v, expected small", drift)
-	}
-}
-
-func TestTheilSenMatchesOLSWhenClean(t *testing.T) {
-	pairs := []tsSkewPair{}
-	for i := 0; i < 20; i++ {
-		pairs = append(pairs, tsSkewPair{
-			ts:   int64(i) * 600,
-			skew: float64(i) * (600.0 / 3600.0),
-		})
-	}
-	drift := computeDrift(pairs)
-	if math.Abs(drift-24.0) > 0.25 {
-		t.Errorf("drift = %v, want ~24", drift)
-	}
-}
-
 // ── jsonNumber ─────────────────────────────────────────────────────────────────
 
 func TestJsonNumber(t *testing.T) {
@@ -451,39 +309,35 @@ func TestJsonNumber(t *testing.T) {
 
 // ── Integration: GetNodeClockSkew via PacketStore ──────────────────────────────
 
-// formatInt64 is a test helper to format int64 as string for JSON embedding.
-func formatInt64(n int64) string {
-	return fmt.Sprintf("%d", n)
-}
-
 func TestGetNodeClockSkew_Integration(t *testing.T) {
 	ps := NewPacketStore(nil, nil)
 
+	// Simulate two ADVERT transmissions for the same node, seen by 2 observers each.
+	// Node "AABB" has clock 120s ahead.
 	pt := 4 // ADVERT
-	// Use a base time outside all default-epoch ranges.
-	base := int64(1900000000) // 2030
 	tx1 := &StoreTx{
 		Hash:        "hash1",
 		PayloadType: &pt,
-		DecodedJSON: `{"payload":{"timestamp":` + formatInt64(base+10) + `}}`,
+		DecodedJSON: `{"payload":{"timestamp":1700002320}}`, // obs=1700002200, node ahead by 120s
 		Observations: []*StoreObs{
-			{ObserverID: "obs1", Timestamp: time.Unix(base, 0).UTC().Format(time.RFC3339)},
-			{ObserverID: "obs2", Timestamp: time.Unix(base, 0).UTC().Format(time.RFC3339)},
+			{ObserverID: "obs1", Timestamp: "2023-11-14T22:50:00Z"}, // 1700002200
+			{ObserverID: "obs2", Timestamp: "2023-11-14T22:50:00Z"}, // 1700002200
 		},
 	}
 	tx2 := &StoreTx{
 		Hash:        "hash2",
 		PayloadType: &pt,
-		DecodedJSON: `{"payload":{"timestamp":` + formatInt64(base+3610) + `}}`,
+		DecodedJSON: `{"payload":{"timestamp":1700005920}}`, // obs=1700005800, node ahead by 120s
 		Observations: []*StoreObs{
-			{ObserverID: "obs1", Timestamp: time.Unix(base+3600, 0).UTC().Format(time.RFC3339)},
-			{ObserverID: "obs2", Timestamp: time.Unix(base+3600, 0).UTC().Format(time.RFC3339)},
+			{ObserverID: "obs1", Timestamp: "2023-11-14T23:50:00Z"}, // 1700005800
+			{ObserverID: "obs2", Timestamp: "2023-11-14T23:50:00Z"}, // 1700005800
 		},
 	}
 
 	ps.mu.Lock()
 	ps.byNode["AABB"] = []*StoreTx{tx1, tx2}
 	ps.byPayloadType[4] = []*StoreTx{tx1, tx2}
+	// Force recompute by setting interval to 0.
 	ps.clockSkew.computeInterval = 0
 	ps.mu.Unlock()
 
@@ -494,9 +348,19 @@ func TestGetNodeClockSkew_Integration(t *testing.T) {
 	if result.Pubkey != "AABB" {
 		t.Errorf("pubkey = %q, want AABB", result.Pubkey)
 	}
-	// Both transmissions show ~10s skew → ok.
+	// Both transmissions show 120s skew, so median should be 120.
+	if result.MedianSkewSec != 120 {
+		t.Errorf("median skew = %v, want 120", result.MedianSkewSec)
+	}
+	if result.SampleCount < 2 {
+		t.Errorf("sample count = %v, want >= 2", result.SampleCount)
+	}
 	if result.Severity != SkewOK {
-		t.Errorf("severity = %v, want ok", result.Severity)
+		t.Errorf("severity = %v, want ok (120s < 5min)", result.Severity)
+	}
+	// Drift should be ~0 since skew is constant.
+	if math.Abs(result.DriftPerDaySec) > 1 {
+		t.Errorf("drift = %v, want ~0 for constant skew", result.DriftPerDaySec)
 	}
 }
 
@@ -508,80 +372,59 @@ func TestGetNodeClockSkew_NoData(t *testing.T) {
 	}
 }
 
-func TestGetNodeClockSkew_DefaultEpochNode(t *testing.T) {
-	// Node with advert_ts at the current firmware default epoch → default severity.
-	ps := NewPacketStore(nil, nil)
-	pt := 4
+// ── Sanity check tests (#XXX — clock skew crazy stats) ────────────────────────
 
-	now := time.Now().Unix()
-	advTS := int64(1715770351 + 86400) // default + 1 day uptime
-	tx := &StoreTx{
-		Hash:        "default-h1",
-		PayloadType: &pt,
-		DecodedJSON: `{"payload":{"timestamp":` + formatInt64(advTS) + `}}`,
-		Observations: []*StoreObs{
-			{ObserverID: "obs1", Timestamp: time.Unix(now, 0).UTC().Format(time.RFC3339)},
-		},
+func TestGetNodeClockSkew_NoClock_EpochZero(t *testing.T) {
+	// Node with epoch-0 timestamp produces huge skew → no_clock severity, drift=0.
+	ps := NewPacketStore(nil, nil)
+	pt := 4 // ADVERT
+
+	// Epoch-ish advert: advertTS near start of 2020, observed in 2023 → |skew| > 365 days
+	var txs []*StoreTx
+	baseObs := int64(1700000000) // ~Nov 2023
+	for i := 0; i < 6; i++ {
+		obsTS := baseObs + int64(i)*7200
+		tx := &StoreTx{
+			Hash:        "epoch-h" + string(rune('0'+i)),
+			PayloadType: &pt,
+			DecodedJSON: `{"payload":{"timestamp":1577836800}}`, // Jan 1 2020 — valid but way off
+			Observations: []*StoreObs{
+				{ObserverID: "obs1", Timestamp: time.Unix(obsTS, 0).UTC().Format(time.RFC3339)},
+			},
+		}
+		txs = append(txs, tx)
 	}
 
 	ps.mu.Lock()
-	ps.byNode["DEFNODE"] = []*StoreTx{tx}
-	ps.byPayloadType[4] = []*StoreTx{tx}
+	ps.byNode["EPOCH"] = txs
+	for _, tx := range txs {
+		ps.byPayloadType[4] = append(ps.byPayloadType[4], tx)
+	}
 	ps.clockSkew.computeInterval = 0
 	ps.mu.Unlock()
 
-	r := ps.GetNodeClockSkew("DEFNODE")
-	if r == nil {
-		t.Fatal("expected result")
+	result := ps.GetNodeClockSkew("EPOCH")
+	if result == nil {
+		t.Fatal("expected clock skew result for epoch-0 node")
 	}
-	if r.Severity != SkewDefault {
-		t.Errorf("severity = %v, want default", r.Severity)
+	if result.Severity != SkewNoClock {
+		t.Errorf("severity = %v, want no_clock", result.Severity)
 	}
-	if r.DefaultEpoch == nil || *r.DefaultEpoch != 1715770351 {
-		t.Errorf("defaultEpoch = %v, want 1715770351", r.DefaultEpoch)
-	}
-}
-
-func TestGetNodeClockSkew_WrongNode(t *testing.T) {
-	// Node with advert_ts far from any default and large skew → wrong.
-	ps := NewPacketStore(nil, nil)
-	pt := 4
-
-	now := int64(1900000000) // 2030, outside default ranges
-	advTS := now + 86400     // 1 day ahead
-	tx := &StoreTx{
-		Hash:        "wrong-h1",
-		PayloadType: &pt,
-		DecodedJSON: `{"payload":{"timestamp":` + formatInt64(advTS) + `}}`,
-		Observations: []*StoreObs{
-			{ObserverID: "obs1", Timestamp: time.Unix(now, 0).UTC().Format(time.RFC3339)},
-		},
-	}
-
-	ps.mu.Lock()
-	ps.byNode["WRONGNODE"] = []*StoreTx{tx}
-	ps.byPayloadType[4] = []*StoreTx{tx}
-	ps.clockSkew.computeInterval = 0
-	ps.mu.Unlock()
-
-	r := ps.GetNodeClockSkew("WRONGNODE")
-	if r == nil {
-		t.Fatal("expected result")
-	}
-	if r.Severity != SkewWrong {
-		t.Errorf("severity = %v, want wrong", r.Severity)
+	if result.DriftPerDaySec != 0 {
+		t.Errorf("drift = %v, want 0 for no_clock node", result.DriftPerDaySec)
 	}
 }
 
 func TestGetNodeClockSkew_TooFewSamplesForDrift(t *testing.T) {
+	// Node with only 2 advert samples → drift should not be computed.
 	ps := NewPacketStore(nil, nil)
 	pt := 4
 
-	now := int64(1900000000) // 2030, outside default ranges
+	baseObs := int64(1700000000)
 	var txs []*StoreTx
 	for i := 0; i < 2; i++ {
-		obsTS := now + int64(i)*7200
-		advTS := obsTS + 10
+		obsTS := baseObs + int64(i)*7200
+		advTS := obsTS + 120 // 120s ahead
 		tx := &StoreTx{
 			Hash:        "few-h" + string(rune('0'+i)),
 			PayloadType: &pt,
@@ -606,69 +449,98 @@ func TestGetNodeClockSkew_TooFewSamplesForDrift(t *testing.T) {
 		t.Fatal("expected clock skew result")
 	}
 	if result.DriftPerDaySec != 0 {
-		t.Errorf("drift = %v, want 0 for 2-sample node", result.DriftPerDaySec)
+		t.Errorf("drift = %v, want 0 for 2-sample node (minimum is %d)", result.DriftPerDaySec, minDriftSamples)
 	}
 }
 
-func TestGetNodeClockSkew_EpochZeroAdvert(t *testing.T) {
-	// An advert with timestamp == 0 (epoch-0 firmware boot) should classify
-	// as "default" with DefaultEpoch == 0.
+func TestGetNodeClockSkew_AbsurdDriftCapped(t *testing.T) {
+	// Node with wildly varying skew producing |drift| > 86400 s/day → drift capped to 0.
 	ps := NewPacketStore(nil, nil)
 	pt := 4
 
-	now := time.Now().Unix()
-	tx := &StoreTx{
-		Hash:        "epoch0-h1",
-		PayloadType: &pt,
-		DecodedJSON: `{"payload":{"timestamp":0}}`,
-		Observations: []*StoreObs{
-			{ObserverID: "obs1", Timestamp: time.Unix(now, 0).UTC().Format(time.RFC3339)},
-		},
+	// Create 6 samples with extreme skew variation to produce absurd drift.
+	baseObs := int64(1700000000)
+	var txs []*StoreTx
+	for i := 0; i < 6; i++ {
+		obsTS := baseObs + int64(i)*3600
+		// Alternate between huge positive and negative skew offsets
+		skewOffset := int64(50000 * (1 - 2*(i%2))) // +50000 or -50000
+		advTS := obsTS + skewOffset
+		tx := &StoreTx{
+			Hash:        "wild-h" + string(rune('0'+i)),
+			PayloadType: &pt,
+			DecodedJSON: `{"payload":{"timestamp":` + formatInt64(advTS) + `}}`,
+			Observations: []*StoreObs{
+				{ObserverID: "obs1", Timestamp: time.Unix(obsTS, 0).UTC().Format(time.RFC3339)},
+			},
+		}
+		txs = append(txs, tx)
 	}
 
 	ps.mu.Lock()
-	ps.byNode["EPOCH0"] = []*StoreTx{tx}
-	ps.byPayloadType[4] = []*StoreTx{tx}
+	ps.byNode["WILD"] = txs
+	for _, tx := range txs {
+		ps.byPayloadType[4] = append(ps.byPayloadType[4], tx)
+	}
 	ps.clockSkew.computeInterval = 0
 	ps.mu.Unlock()
 
-	r := ps.GetNodeClockSkew("EPOCH0")
-	if r == nil {
-		t.Fatal("expected result for epoch-0 node")
+	result := ps.GetNodeClockSkew("WILD")
+	if result == nil {
+		t.Fatal("expected clock skew result")
 	}
-	if r.Severity != SkewDefault {
-		t.Errorf("severity = %v, want default", r.Severity)
-	}
-	if r.DefaultEpoch == nil || *r.DefaultEpoch != 0 {
-		t.Errorf("defaultEpoch = %v, want &0", r.DefaultEpoch)
+	if math.Abs(result.DriftPerDaySec) > maxReasonableDriftPerDay {
+		t.Errorf("drift = %v, should be capped (|drift| > %v)", result.DriftPerDaySec, maxReasonableDriftPerDay)
 	}
 }
 
-func TestGetNodeClockSkew_MissingTimestamp(t *testing.T) {
-	// An advert with NO timestamp field should be skipped entirely —
-	// extractTimestamp returns timestampMissing (-1), collectSamples
-	// filters it out, so GetNodeClockSkew returns nil.
+func TestGetNodeClockSkew_NormalNodeWithDrift(t *testing.T) {
+	// Normal node with 6 samples and consistent linear drift → drift computed correctly.
 	ps := NewPacketStore(nil, nil)
 	pt := 4
 
-	now := time.Now().Unix()
-	tx := &StoreTx{
-		Hash:        "nots-h1",
-		PayloadType: &pt,
-		DecodedJSON: `{"payload":{"name":"test-node"}}`,
-		Observations: []*StoreObs{
-			{ObserverID: "obs1", Timestamp: time.Unix(now, 0).UTC().Format(time.RFC3339)},
-		},
+	baseObs := int64(1700000000)
+	var txs []*StoreTx
+	for i := 0; i < 6; i++ {
+		obsTS := baseObs + int64(i)*7200 // every 2 hours
+		// Drift: 1 sec/hour = 24 sec/day
+		advTS := obsTS + 120 + int64(i) // skew grows by 1s per sample (2h apart)
+		tx := &StoreTx{
+			Hash:        "norm-h" + string(rune('0'+i)),
+			PayloadType: &pt,
+			DecodedJSON: `{"payload":{"timestamp":` + formatInt64(advTS) + `}}`,
+			Observations: []*StoreObs{
+				{ObserverID: "obs1", Timestamp: time.Unix(obsTS, 0).UTC().Format(time.RFC3339)},
+			},
+		}
+		txs = append(txs, tx)
 	}
 
 	ps.mu.Lock()
-	ps.byNode["NOTS"] = []*StoreTx{tx}
-	ps.byPayloadType[4] = []*StoreTx{tx}
+	ps.byNode["NORMAL"] = txs
+	for _, tx := range txs {
+		ps.byPayloadType[4] = append(ps.byPayloadType[4], tx)
+	}
 	ps.clockSkew.computeInterval = 0
 	ps.mu.Unlock()
 
-	r := ps.GetNodeClockSkew("NOTS")
-	if r != nil {
-		t.Errorf("expected nil for node with missing timestamp, got severity=%v", r.Severity)
+	result := ps.GetNodeClockSkew("NORMAL")
+	if result == nil {
+		t.Fatal("expected clock skew result")
+	}
+	if result.Severity != SkewOK {
+		t.Errorf("severity = %v, want ok", result.Severity)
+	}
+	// 1s per 7200s = 12 s/day
+	if result.DriftPerDaySec == 0 {
+		t.Error("expected non-zero drift for linearly drifting node")
+	}
+	if math.Abs(result.DriftPerDaySec) > maxReasonableDriftPerDay {
+		t.Errorf("drift = %v, should be reasonable", result.DriftPerDaySec)
 	}
 }
+
+// formatInt64 is a test helper to format int64 as string for JSON embedding.
+func formatInt64(n int64) string {
+	return fmt.Sprintf("%d", n)
+}

cmd/server/config.go

@@ -6,7 +6,6 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"sync"
 
 	"github.com/meshcore-analyzer/geofilter"
 )
@@ -17,17 +16,6 @@ type Config struct {
 	APIKey  string `json:"apiKey"`
 	DBPath  string `json:"dbPath"`
 
-	// NodeBlacklist is a list of public keys to exclude from all API responses.
-	// Blacklisted nodes are hidden from node lists, search, detail, map, and stats.
-	// Use this to filter out trolls, nodes with offensive names, or nodes
-	// reporting deliberately false data (e.g. wrong GPS position) that the
-	// operator refuses to fix.
-	NodeBlacklist []string `json:"nodeBlacklist"`
-
-	// blacklistSetCached is the lazily-built set version of NodeBlacklist.
-	blacklistSetCached map[string]bool
-	blacklistOnce      sync.Once
-
 	Branding   map[string]interface{} `json:"branding"`
 	Theme      map[string]interface{} `json:"theme"`
 	ThemeDark  map[string]interface{} `json:"themeDark"`
@@ -62,8 +50,6 @@ type Config struct {
 
 	Retention *RetentionConfig `json:"retention,omitempty"`
 
-	DB *DBConfig `json:"db,omitempty"`
-
 	PacketStore *PacketStoreConfig `json:"packetStore,omitempty"`
 
 	GeoFilter *GeoFilterConfig `json:"geo_filter,omitempty"`
@@ -117,32 +103,16 @@ type NeighborGraphConfig struct {
 // PacketStoreConfig controls in-memory packet store limits.
 type PacketStoreConfig struct {
 	RetentionHours float64 `json:"retentionHours"` // max age of packets in hours (0 = unlimited)
-	MaxMemoryMB                    int `json:"maxMemoryMB"`                    // hard memory ceiling in MB (0 = unlimited)
-	MaxResolvedPubkeyIndexEntries  int `json:"maxResolvedPubkeyIndexEntries"`  // warning threshold for index size (0 = 5M default)
+	MaxMemoryMB    int     `json:"maxMemoryMB"`     // hard memory ceiling in MB (0 = unlimited)
 }
 
 // GeoFilterConfig is an alias for the shared geofilter.Config type.
 type GeoFilterConfig = geofilter.Config
 
 type RetentionConfig struct {
-	NodeDays      int `json:"nodeDays"`
-	ObserverDays  int `json:"observerDays"`
-	PacketDays    int `json:"packetDays"`
-	MetricsDays   int `json:"metricsDays"`
-}
-
-// DBConfig controls SQLite vacuum and maintenance behavior (#919).
-type DBConfig struct {
-	VacuumOnStartup        bool `json:"vacuumOnStartup"`        // one-time full VACUUM on startup if auto_vacuum is not INCREMENTAL
-	IncrementalVacuumPages int  `json:"incrementalVacuumPages"` // pages returned to OS per reaper cycle (default 1024)
-}
-
-// IncrementalVacuumPages returns the configured pages per vacuum or 1024 default.
-func (c *Config) IncrementalVacuumPages() int {
-	if c.DB != nil && c.DB.IncrementalVacuumPages > 0 {
-		return c.DB.IncrementalVacuumPages
-	}
-	return 1024
+	NodeDays    int `json:"nodeDays"`
+	PacketDays  int `json:"packetDays"`
+	MetricsDays int `json:"metricsDays"`
 }
 
 // MetricsRetentionDays returns configured metrics retention or 30 days default.
@@ -195,15 +165,6 @@ func (c *Config) NodeDaysOrDefault() int {
 	return 7
 }
 
-// ObserverDaysOrDefault returns the configured retention.observerDays or 14 if not set.
-// A value of -1 means observers are never removed.
-func (c *Config) ObserverDaysOrDefault() int {
-	if c.Retention != nil && c.Retention.ObserverDays != 0 {
-		return c.Retention.ObserverDays
-	}
-	return 14
-}
-
 type HealthThresholds struct {
 	InfraDegradedHours float64 `json:"infraDegradedHours"`
 	InfraSilentHours   float64 `json:"infraSilentHours"`
@@ -377,30 +338,3 @@ func (c *Config) PropagationBufferMs() int {
 	}
 	return 5000
 }
-
-// blacklistSet lazily builds and caches the nodeBlacklist as a set for O(1) lookups.
-// Uses sync.Once to eliminate the data race on first concurrent access.
-func (c *Config) blacklistSet() map[string]bool {
-	c.blacklistOnce.Do(func() {
-		if len(c.NodeBlacklist) == 0 {
-			return
-		}
-		m := make(map[string]bool, len(c.NodeBlacklist))
-		for _, pk := range c.NodeBlacklist {
-			trimmed := strings.ToLower(strings.TrimSpace(pk))
-			if trimmed != "" {
-				m[trimmed] = true
-			}
-		}
-		c.blacklistSetCached = m
-	})
-	return c.blacklistSetCached
-}
-
-// IsBlacklisted returns true if the given public key is in the nodeBlacklist.
-func (c *Config) IsBlacklisted(pubkey string) bool {
-	if c == nil || len(c.NodeBlacklist) == 0 {
-		return false
-	}
-	return c.blacklistSet()[strings.ToLower(strings.TrimSpace(pubkey))]
-}

cmd/server/config_test.go

@@ -365,25 +365,3 @@ func TestPropagationBufferMs(t *testing.T) {
 		}
 	})
 }
-
-func TestObserverDaysOrDefault(t *testing.T) {
-	tests := []struct {
-		name string
-		cfg  *Config
-		want int
-	}{
-		{"nil retention", &Config{}, 14},
-		{"zero observer days", &Config{Retention: &RetentionConfig{ObserverDays: 0}}, 14},
-		{"positive value", &Config{Retention: &RetentionConfig{ObserverDays: 30}}, 30},
-		{"keep forever", &Config{Retention: &RetentionConfig{ObserverDays: -1}}, -1},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := tt.cfg.ObserverDaysOrDefault()
-			if got != tt.want {
-				t.Errorf("ObserverDaysOrDefault() = %d, want %d", got, tt.want)
-			}
-		})
-	}
-}

cmd/server/coverage_test.go

@@ -47,7 +47,7 @@ func setupTestDBv2(t *testing.T) *DB {
 			id INTEGER PRIMARY KEY AUTOINCREMENT,
 			transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
 			observer_id TEXT, observer_name TEXT, direction TEXT,
-			snr REAL, rssi REAL, score INTEGER, path_json TEXT, timestamp INTEGER NOT NULL, raw_hex TEXT
+			snr REAL, rssi REAL, score INTEGER, path_json TEXT, timestamp INTEGER NOT NULL
 		);
 	`
 	if _, err := conn.Exec(schema); err != nil {
@@ -585,15 +585,12 @@ func TestHandlePacketsMultiNodeWithStore(t *testing.T) {
 func TestHandlePacketDetailNoStore(t *testing.T) {
 	_, router := setupNoStoreServer(t)
 
-	// With no in-memory store, handlePacketDetail now falls back to the DB
-	// (#827). The seeded transmissions are present in the DB, so by-hash and
-	// by-ID lookups succeed; only truly absent IDs return 404.
 	t.Run("by hash", func(t *testing.T) {
 		req := httptest.NewRequest("GET", "/api/packets/abc123def4567890", nil)
 		w := httptest.NewRecorder()
 		router.ServeHTTP(w, req)
-		if w.Code != 200 {
-			t.Fatalf("expected 200 (DB fallback), got %d: %s", w.Code, w.Body.String())
+		if w.Code != 404 {
+			t.Fatalf("expected 404 (no store), got %d: %s", w.Code, w.Body.String())
 		}
 	})
 
@@ -601,8 +598,8 @@ func TestHandlePacketDetailNoStore(t *testing.T) {
 		req := httptest.NewRequest("GET", "/api/packets/1", nil)
 		w := httptest.NewRecorder()
 		router.ServeHTTP(w, req)
-		if w.Code != 200 {
-			t.Fatalf("expected 200 (DB fallback), got %d: %s", w.Code, w.Body.String())
+		if w.Code != 404 {
+			t.Fatalf("expected 404 (no store), got %d: %s", w.Code, w.Body.String())
 		}
 	})
 
@@ -763,9 +760,9 @@ func TestGetChannelsFromStore(t *testing.T) {
 
 func TestPrefixMapResolve(t *testing.T) {
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aabbccdd11223344", Name: "NodeA", HasGPS: true, Lat: 37.5, Lon: -122.0},
-		{Role: "repeater", PublicKey: "aabbccdd55667788", Name: "NodeB", HasGPS: false},
-		{Role: "repeater", PublicKey: "eeff0011aabbccdd", Name: "NodeC", HasGPS: true, Lat: 38.0, Lon: -121.0},
+		{PublicKey: "aabbccdd11223344", Name: "NodeA", HasGPS: true, Lat: 37.5, Lon: -122.0},
+		{PublicKey: "aabbccdd55667788", Name: "NodeB", HasGPS: false},
+		{PublicKey: "eeff0011aabbccdd", Name: "NodeC", HasGPS: true, Lat: 38.0, Lon: -121.0},
 	}
 	pm := buildPrefixMap(nodes)
 
@@ -805,8 +802,8 @@ func TestPrefixMapResolve(t *testing.T) {
 
 	t.Run("multiple candidates no GPS", func(t *testing.T) {
 		noGPSNodes := []nodeInfo{
-			{Role: "repeater", PublicKey: "aa11bb22", Name: "X", HasGPS: false},
-			{Role: "repeater", PublicKey: "aa11cc33", Name: "Y", HasGPS: false},
+			{PublicKey: "aa11bb22", Name: "X", HasGPS: false},
+			{PublicKey: "aa11cc33", Name: "Y", HasGPS: false},
 		}
 		pm2 := buildPrefixMap(noGPSNodes)
 		n := pm2.resolve("aa11")
@@ -820,8 +817,8 @@ func TestPrefixMapResolve(t *testing.T) {
 func TestPrefixMapCap(t *testing.T) {
 	// 16-char pubkey — longer than maxPrefixLen
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aabbccdd11223344", Name: "LongKey"},
-		{Role: "repeater", PublicKey: "eeff0011", Name: "ShortKey"}, // exactly 8 chars
+		{PublicKey: "aabbccdd11223344", Name: "LongKey"},
+		{PublicKey: "eeff0011", Name: "ShortKey"}, // exactly 8 chars
 	}
 	pm := buildPrefixMap(nodes)
 
@@ -4319,48 +4316,88 @@ func TestIndexByNodePreCheck(t *testing.T) {
 	})
 }
 
-// TestIndexByNodeResolvedPath tests that indexByNode only indexes decoded JSON pubkeys.
-// After #800, resolved_path entries are handled via the decode-window, not indexByNode.
+// TestIndexByNodeResolvedPath tests that resolved_path entries are indexed in byNode.
 func TestIndexByNodeResolvedPath(t *testing.T) {
 	store := &PacketStore{
 		byNode:     make(map[string][]*StoreTx),
 		nodeHashes: make(map[string]map[string]bool),
 	}
 
-	t.Run("decoded JSON pubkeys still indexed", func(t *testing.T) {
-		pk := "aabb1122334455ff"
+	t.Run("indexes resolved path pubkeys from observations", func(t *testing.T) {
+		relayPK := "aabb1122334455ff"
 		tx := &StoreTx{
 			Hash:        "rp1",
-			DecodedJSON: `{"pubKey":"` + pk + `"}`,
+			DecodedJSON: `{"type":"CHAN","text":"hello"}`, // no pubKey fields
+			Observations: []*StoreObs{
+				{ResolvedPath: []*string{&relayPK}},
+			},
+		}
+		store.indexByNode(tx)
+		if len(store.byNode[relayPK]) != 1 {
+			t.Errorf("expected relay pubkey indexed, got %d", len(store.byNode[relayPK]))
+		}
+	})
+
+	t.Run("skips null entries in resolved path", func(t *testing.T) {
+		pk := "cc11dd22ee33ff44"
+		tx := &StoreTx{
+			Hash: "rp2",
+			Observations: []*StoreObs{
+				{ResolvedPath: []*string{nil, &pk, nil}},
+			},
 		}
 		store.indexByNode(tx)
 		if len(store.byNode[pk]) != 1 {
-			t.Errorf("expected decoded pubkey indexed, got %d", len(store.byNode[pk]))
+			t.Errorf("expected resolved pubkey indexed, got %d", len(store.byNode[pk]))
+		}
+		// Verify nil entries didn't create empty-string keys
+		if _, exists := store.byNode[""]; exists {
+			t.Error("nil/empty resolved path entries should not create byNode entries")
 		}
 	})
 
-	t.Run("resolved path pubkeys NOT indexed by indexByNode", func(t *testing.T) {
-		// After #800, indexByNode only handles decoded JSON fields.
-		// Resolved path pubkeys are handled by the decode-window.
+	t.Run("relay-only node appears in byNode", func(t *testing.T) {
+		// A packet with no decoded pubkey fields, only a relay in resolved path
+		relayOnly := "relay0only0pubkey"
 		tx := &StoreTx{
-			Hash:        "rp2",
-			DecodedJSON: `{"type":"CHAN","text":"hello"}`, // no pubKey fields
+			Hash: "rp3",
+			// No DecodedJSON at all — pure relay
+			Observations: []*StoreObs{
+				{ResolvedPath: []*string{&relayOnly}},
+			},
 		}
 		store.indexByNode(tx)
-		// No new entries expected since there are no decoded pubkeys
+		if len(store.byNode[relayOnly]) != 1 {
+			t.Errorf("expected relay-only node indexed, got %d", len(store.byNode[relayOnly]))
+		}
 	})
 
-	t.Run("dedup within decoded JSON", func(t *testing.T) {
+	t.Run("dedup between decoded JSON and resolved path", func(t *testing.T) {
 		pk := "dedup0test0pk1234"
 		tx := &StoreTx{
 			Hash:        "rp4",
-			DecodedJSON: `{"pubKey":"` + pk + `","destPubKey":"` + pk + `"}`,
+			DecodedJSON: `{"pubKey":"` + pk + `"}`,
+			Observations: []*StoreObs{
+				{ResolvedPath: []*string{&pk}},
+			},
 		}
 		store.indexByNode(tx)
 		if len(store.byNode[pk]) != 1 {
 			t.Errorf("expected dedup to keep 1 entry, got %d", len(store.byNode[pk]))
 		}
 	})
+
+	t.Run("indexes tx.ResolvedPath when observations empty", func(t *testing.T) {
+		rpPK := "txlevel0resolved1"
+		tx := &StoreTx{
+			Hash:         "rp5",
+			ResolvedPath: []*string{&rpPK},
+		}
+		store.indexByNode(tx)
+		if len(store.byNode[rpPK]) != 1 {
+			t.Errorf("expected tx-level resolved path indexed, got %d", len(store.byNode[rpPK]))
+		}
+	})
 }
 
 // BenchmarkIndexByNode measures indexByNode performance with and without pubkey

cmd/server/db.go

@@ -20,7 +20,6 @@ type DB struct {
 	path             string // filesystem path to the database file
 	isV3             bool   // v3 schema: observer_idx in observations (vs observer_id in v2)
 	hasResolvedPath  bool   // observations table has resolved_path column
-	hasObsRawHex     bool   // observations table has raw_hex column (#881)
 
 	// Channel list cache (60s TTL) — avoids repeated GROUP BY scans (#762)
 	channelsCacheMu  sync.Mutex
@@ -77,9 +76,6 @@ func (db *DB) detectSchema() {
 			if colName == "resolved_path" {
 				db.hasResolvedPath = true
 			}
-			if colName == "raw_hex" {
-				db.hasObsRawHex = true
-			}
 		}
 	}
 }
@@ -388,7 +384,6 @@ type PacketQuery struct {
 	Until    string
 	Region   string
 	Node     string
-	Channel  string // channel_hash filter (#812). Plain names like "#test"/"public" or "enc_<HEX>" for encrypted
 	Order               string // ASC or DESC
 	ExpandObservations  bool   // when true, include observation sub-maps in txToMap output
 }
@@ -625,11 +620,6 @@ func (db *DB) buildTransmissionWhere(q PacketQuery) ([]string, []interface{}) {
 		where = append(where, "t.decoded_json LIKE ?")
 		args = append(args, "%"+pk+"%")
 	}
-	if q.Channel != "" {
-		// channel_hash column is indexed for payload_type = 5; filter is exact match.
-		where = append(where, "t.channel_hash = ?")
-		args = append(args, q.Channel)
-	}
 	if q.Observer != "" {
 		ids := strings.Split(q.Observer, ",")
 		placeholders := strings.Repeat("?,", len(ids))
@@ -696,20 +686,6 @@ func (db *DB) GetPacketByHash(hash string) (map[string]interface{}, error) {
 	return nil, nil
 }
 
-// GetObservationsForHash returns all observations for the transmission with
-// the given content hash. Used as a fallback by the packet-detail handler
-// when the in-memory PacketStore has pruned the entry but the DB still has it.
-func (db *DB) GetObservationsForHash(hash string) []map[string]interface{} {
-	var txID int
-	err := db.conn.QueryRow("SELECT id FROM transmissions WHERE hash = ?",
-		strings.ToLower(hash)).Scan(&txID)
-	if err != nil {
-		return nil
-	}
-	obsByTx := db.getObservationsForTransmissions([]int{txID})
-	return obsByTx[txID]
-}
-
 
 // GetNodes returns filtered, paginated node list.
 func (db *DB) GetNodes(limit, offset int, role, search, before, lastHeard, sortBy, region string) ([]map[string]interface{}, int, map[string]int, error) {
@@ -2237,35 +2213,6 @@ func (db *DB) PruneOldMetrics(retentionDays int) (int64, error) {
 	return n, nil
 }
 
-// RemoveStaleObservers marks observers that have not actively sent data in observerDays
-// as inactive (soft-delete). This preserves JOIN integrity for observations.observer_idx
-// and observer_metrics.observer_id — historical data still references the correct observer.
-// An observer must actively send data to stay listed — being seen by another node does not count.
-// observerDays <= -1 means never remove (keep forever).
-func (db *DB) RemoveStaleObservers(observerDays int) (int64, error) {
-	if observerDays <= -1 {
-		return 0, nil // keep forever
-	}
-	rw, err := openRW(db.path)
-	if err != nil {
-		return 0, err
-	}
-	defer rw.Close()
-
-	cutoff := time.Now().UTC().AddDate(0, 0, -observerDays).Format(time.RFC3339)
-	res, err := rw.Exec(`UPDATE observers SET inactive = 1 WHERE last_seen < ? AND (inactive IS NULL OR inactive = 0)`, cutoff)
-	if err != nil {
-		return 0, err
-	}
-	n, _ := res.RowsAffected()
-	if n > 0 {
-		// Clean up orphaned metrics for now-inactive observers
-		rw.Exec(`DELETE FROM observer_metrics WHERE observer_id IN (SELECT id FROM observers WHERE inactive = 1)`)
-		log.Printf("[observers] Marked %d observer(s) as inactive (not seen in %d days)", n, observerDays)
-	}
-	return n, nil
-}
-
 // TouchNodeLastSeen updates last_seen for a node identified by full public key.
 // Only updates if the new timestamp is newer than the existing value (or NULL).
 // Returns nil even if no rows are affected (node doesn't exist).
@@ -2276,71 +2223,3 @@ func (db *DB) TouchNodeLastSeen(pubkey string, timestamp string) error {
 	)
 	return err
 }
-
-// GetDroppedPackets returns recently dropped packets, newest first.
-func (db *DB) GetDroppedPackets(limit int, observerID, nodePubkey string) ([]map[string]interface{}, error) {
-	if limit <= 0 || limit > 500 {
-		limit = 100
-	}
-	query := `SELECT id, hash, raw_hex, reason, observer_id, observer_name, node_pubkey, node_name, dropped_at FROM dropped_packets`
-	var conditions []string
-	var args []interface{}
-	if observerID != "" {
-		conditions = append(conditions, "observer_id = ?")
-		args = append(args, observerID)
-	}
-	if nodePubkey != "" {
-		conditions = append(conditions, "node_pubkey = ?")
-		args = append(args, nodePubkey)
-	}
-	if len(conditions) > 0 {
-		query += " WHERE " + strings.Join(conditions, " AND ")
-	}
-	query += " ORDER BY dropped_at DESC LIMIT ?"
-	args = append(args, limit)
-
-	rows, err := db.conn.Query(query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var results []map[string]interface{}
-	for rows.Next() {
-		var id int
-		var hash, rawHex, reason, obsID, obsName, pubkey, name, droppedAt sql.NullString
-		if err := rows.Scan(&id, &hash, &rawHex, &reason, &obsID, &obsName, &pubkey, &name, &droppedAt); err != nil {
-			continue
-		}
-		row := map[string]interface{}{
-			"id":            id,
-			"hash":          nullStr(hash),
-			"reason":        nullStr(reason),
-			"observer_id":   nullStr(obsID),
-			"observer_name": nullStr(obsName),
-			"node_pubkey":   nullStr(pubkey),
-			"node_name":     nullStr(name),
-			"dropped_at":    nullStr(droppedAt),
-		}
-		// Only include raw_hex if explicitly requested (it's large)
-		if rawHex.Valid {
-			row["raw_hex"] = rawHex.String
-		}
-		results = append(results, row)
-	}
-	if results == nil {
-		results = []map[string]interface{}{}
-	}
-	return results, nil
-}
-
-// GetSignatureDropCount returns the total number of dropped packets.
-func (db *DB) GetSignatureDropCount() int64 {
-	var count int64
-	// Table may not exist yet if ingestor hasn't run the migration
-	err := db.conn.QueryRow("SELECT COUNT(*) FROM dropped_packets").Scan(&count)
-	if err != nil {
-		return 0
-	}
-	return count
-}

cmd/server/db_test.go

@@ -74,8 +74,7 @@ func setupTestDB(t *testing.T) *DB {
 			score INTEGER,
 			path_json TEXT,
 			timestamp INTEGER NOT NULL,
-			resolved_path TEXT,
-			raw_hex TEXT
+			resolved_path TEXT
 		);
 
 		CREATE TABLE IF NOT EXISTS observer_metrics (
@@ -1135,8 +1134,7 @@ func setupTestDBV2(t *testing.T) *DB {
 			rssi REAL,
 			score INTEGER,
 			path_json TEXT,
-			timestamp INTEGER NOT NULL,
-			raw_hex TEXT
+			timestamp INTEGER NOT NULL
 		);
 	`
 	if _, err := conn.Exec(schema); err != nil {
@@ -1977,59 +1975,3 @@ func TestParseWindowDuration(t *testing.T) {
 		}
 	}
 }
-
-// TestPerObservationRawHexEnrich verifies enrichObs returns per-observation raw_hex
-// when available, falling back to transmission raw_hex when NULL (#881).
-func TestPerObservationRawHexEnrich(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-
-	// Insert observers
-	db.conn.Exec(`INSERT INTO observers (id, name) VALUES ('obs-a', 'Observer A')`)
-	db.conn.Exec(`INSERT INTO observers (id, name) VALUES ('obs-b', 'Observer B')`)
-
-	var rowA, rowB int64
-	db.conn.QueryRow(`SELECT rowid FROM observers WHERE id='obs-a'`).Scan(&rowA)
-	db.conn.QueryRow(`SELECT rowid FROM observers WHERE id='obs-b'`).Scan(&rowB)
-
-	// Insert transmission with raw_hex
-	txHex := "deadbeef"
-	db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen) VALUES (?, 'hash1', '2026-04-21T10:00:00Z')`, txHex)
-
-	// Insert two observations: A has its own raw_hex, B has NULL (historical)
-	obsAHex := "c0ffee01"
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp, raw_hex)
-		VALUES (1, ?, -5.0, -90.0, '[]', 1745236800, ?)`, rowA, obsAHex)
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
-		VALUES (1, ?, -3.0, -85.0, '["aabb"]', 1745236801)`, rowB)
-
-	store := NewPacketStore(db, nil)
-	if err := store.Load(); err != nil {
-		t.Fatalf("store load: %v", err)
-	}
-
-	tx := store.byHash["hash1"]
-	if tx == nil {
-		t.Fatal("transmission not loaded")
-	}
-	if len(tx.Observations) < 2 {
-		t.Fatalf("expected 2 observations, got %d", len(tx.Observations))
-	}
-
-	// Check enriched observations
-	for _, obs := range tx.Observations {
-		m := store.enrichObs(obs)
-		rh, _ := m["raw_hex"].(string)
-		if obs.RawHex != "" {
-			// Observer A: should get per-observation raw_hex
-			if rh != obsAHex {
-				t.Errorf("obs with own raw_hex: got %q, want %q", rh, obsAHex)
-			}
-		} else {
-			// Observer B: should fall back to transmission raw_hex
-			if rh != txHex {
-				t.Errorf("obs without raw_hex: got %q, want %q (tx fallback)", rh, txHex)
-			}
-		}
-	}
-}

cmd/server/db_vacuum_test.go

@@ -1,262 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	_ "modernc.org/sqlite"
-)
-
-// createFreshIngestorDB creates a SQLite DB using the ingestor's applySchema logic
-// (simulated here) with auto_vacuum=INCREMENTAL set before tables.
-func createFreshDBWithAutoVacuum(t *testing.T, path string) *sql.DB {
-	t.Helper()
-	// auto_vacuum must be set via DSN before journal_mode creates the DB file
-	db, err := sql.Open("sqlite", path+"?_pragma=auto_vacuum(INCREMENTAL)&_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	db.SetMaxOpenConns(1)
-
-	// Create minimal schema
-	_, err = db.Exec(`
-		CREATE TABLE transmissions (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			raw_hex TEXT NOT NULL,
-			hash TEXT NOT NULL UNIQUE,
-			first_seen TEXT NOT NULL,
-			route_type INTEGER,
-			payload_type INTEGER,
-			payload_version INTEGER,
-			decoded_json TEXT,
-			created_at TEXT DEFAULT (datetime('now')),
-			channel_hash TEXT
-		);
-		CREATE TABLE observations (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
-			observer_idx INTEGER,
-			direction TEXT,
-			snr REAL,
-			rssi REAL,
-			score INTEGER,
-			path_json TEXT,
-			timestamp INTEGER NOT NULL
-		);
-	`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return db
-}
-
-func TestNewDBHasIncrementalAutoVacuum(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.db")
-
-	db := createFreshDBWithAutoVacuum(t, path)
-	defer db.Close()
-
-	var autoVacuum int
-	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&autoVacuum); err != nil {
-		t.Fatal(err)
-	}
-	if autoVacuum != 2 {
-		t.Fatalf("expected auto_vacuum=2 (INCREMENTAL), got %d", autoVacuum)
-	}
-}
-
-func TestExistingDBHasAutoVacuumNone(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.db")
-
-	// Create DB WITHOUT setting auto_vacuum (simulates old DB)
-	db, err := sql.Open("sqlite", path+"?_pragma=journal_mode(WAL)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	db.SetMaxOpenConns(1)
-	_, err = db.Exec("CREATE TABLE dummy (id INTEGER PRIMARY KEY)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var autoVacuum int
-	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&autoVacuum); err != nil {
-		t.Fatal(err)
-	}
-	db.Close()
-
-	if autoVacuum != 0 {
-		t.Fatalf("expected auto_vacuum=0 (NONE) for old DB, got %d", autoVacuum)
-	}
-}
-
-func TestVacuumOnStartupMigratesDB(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.db")
-
-	// Create DB without auto_vacuum (old DB)
-	db, err := sql.Open("sqlite", path+"?_pragma=journal_mode(WAL)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	db.SetMaxOpenConns(1)
-	_, err = db.Exec("CREATE TABLE dummy (id INTEGER PRIMARY KEY)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var before int
-	db.QueryRow("PRAGMA auto_vacuum").Scan(&before)
-	if before != 0 {
-		t.Fatalf("precondition: expected auto_vacuum=0, got %d", before)
-	}
-	db.Close()
-
-	// Simulate vacuumOnStartup migration using openRW
-	rw, err := openRW(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := rw.Exec("PRAGMA auto_vacuum = INCREMENTAL"); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := rw.Exec("VACUUM"); err != nil {
-		t.Fatal(err)
-	}
-	rw.Close()
-
-	// Verify migration
-	db2, err := sql.Open("sqlite", path+"?mode=ro")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db2.Close()
-
-	var after int
-	if err := db2.QueryRow("PRAGMA auto_vacuum").Scan(&after); err != nil {
-		t.Fatal(err)
-	}
-	if after != 2 {
-		t.Fatalf("expected auto_vacuum=2 after VACUUM migration, got %d", after)
-	}
-}
-
-func TestIncrementalVacuumReducesFreelist(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.db")
-
-	db := createFreshDBWithAutoVacuum(t, path)
-
-	// Insert a bunch of data
-	now := time.Now().UTC().Format(time.RFC3339)
-	for i := 0; i < 500; i++ {
-		_, err := db.Exec(
-			"INSERT INTO transmissions (raw_hex, hash, first_seen) VALUES (?, ?, ?)",
-			strings.Repeat("AA", 200), // ~400 bytes each
-			"hash_"+string(rune('A'+i%26))+string(rune('0'+i/26)),
-			now,
-		)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	// Get file size before delete
-	db.Close()
-	infoBefore, _ := os.Stat(path)
-	sizeBefore := infoBefore.Size()
-
-	// Reopen and delete all
-	db, err := sql.Open("sqlite", path+"?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	db.SetMaxOpenConns(1)
-	defer db.Close()
-
-	_, err = db.Exec("DELETE FROM transmissions")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Check freelist before vacuum
-	var freelistBefore int64
-	db.QueryRow("PRAGMA freelist_count").Scan(&freelistBefore)
-	if freelistBefore == 0 {
-		t.Fatal("expected non-zero freelist after DELETE")
-	}
-
-	// Run incremental vacuum
-	_, err = db.Exec("PRAGMA incremental_vacuum(10000)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Check freelist after vacuum
-	var freelistAfter int64
-	db.QueryRow("PRAGMA freelist_count").Scan(&freelistAfter)
-	if freelistAfter >= freelistBefore {
-		t.Fatalf("expected freelist to shrink: before=%d after=%d", freelistBefore, freelistAfter)
-	}
-
-	// Checkpoint WAL and check file size shrunk
-	db.Exec("PRAGMA wal_checkpoint(TRUNCATE)")
-	db.Close()
-	infoAfter, _ := os.Stat(path)
-	sizeAfter := infoAfter.Size()
-	if sizeAfter >= sizeBefore {
-		t.Logf("warning: file did not shrink (before=%d after=%d) — may depend on page reuse", sizeBefore, sizeAfter)
-	}
-}
-
-func TestCheckAutoVacuumLogs(t *testing.T) {
-	// This test verifies checkAutoVacuum doesn't panic on various configs
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.db")
-
-	// Create a fresh DB with auto_vacuum=INCREMENTAL
-	dbConn := createFreshDBWithAutoVacuum(t, path)
-	db := &DB{conn: dbConn, path: path}
-	cfg := &Config{}
-
-	// Should not panic
-	checkAutoVacuum(db, cfg, path)
-	dbConn.Close()
-
-	// Create a DB without auto_vacuum
-	path2 := filepath.Join(dir, "test2.db")
-	dbConn2, _ := sql.Open("sqlite", path2+"?_pragma=journal_mode(WAL)")
-	dbConn2.SetMaxOpenConns(1)
-	dbConn2.Exec("CREATE TABLE dummy (id INTEGER PRIMARY KEY)")
-	db2 := &DB{conn: dbConn2, path: path2}
-
-	// Should log warning but not panic
-	checkAutoVacuum(db2, cfg, path2)
-	dbConn2.Close()
-}
-
-func TestConfigIncrementalVacuumPages(t *testing.T) {
-	// Default
-	cfg := &Config{}
-	if cfg.IncrementalVacuumPages() != 1024 {
-		t.Fatalf("expected default 1024, got %d", cfg.IncrementalVacuumPages())
-	}
-
-	// Custom
-	cfg.DB = &DBConfig{IncrementalVacuumPages: 512}
-	if cfg.IncrementalVacuumPages() != 512 {
-		t.Fatalf("expected 512, got %d", cfg.IncrementalVacuumPages())
-	}
-
-	// Zero should return default
-	cfg.DB.IncrementalVacuumPages = 0
-	if cfg.IncrementalVacuumPages() != 1024 {
-		t.Fatalf("expected default 1024 for zero, got %d", cfg.IncrementalVacuumPages())
-	}
-}

cmd/server/decoder.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/meshcore-analyzer/packetpath"
 	"github.com/meshcore-analyzer/sigvalidate"
 )
 
@@ -165,9 +164,8 @@ func decodePath(pathByte byte, buf []byte, offset int) (Path, int) {
 	}, totalBytes
 }
 
-// isTransportRoute delegates to packetpath.IsTransportRoute.
 func isTransportRoute(routeType int) bool {
-	return packetpath.IsTransportRoute(routeType)
+	return routeType == RouteTransportFlood || routeType == RouteTransportDirect
 }
 
 func decodeEncryptedPayload(typeName string, buf []byte) Payload {
@@ -443,10 +441,107 @@ func DecodePacket(hexString string, validateSignatures bool) (*DecodedPacket, er
 	}, nil
 }
 
+// HexRange represents a labeled byte range for the hex breakdown visualization.
+type HexRange struct {
+	Start int    `json:"start"`
+	End   int    `json:"end"`
+	Label string `json:"label"`
+}
+
+// Breakdown holds colored byte ranges returned by the packet detail endpoint.
+type Breakdown struct {
+	Ranges []HexRange `json:"ranges"`
+}
+
+// BuildBreakdown computes labeled byte ranges for each section of a MeshCore packet.
+// The returned ranges are consumed by createColoredHexDump() and buildHexLegend()
+// in the frontend (public/app.js).
+func BuildBreakdown(hexString string) *Breakdown {
+	hexString = strings.ReplaceAll(hexString, " ", "")
+	hexString = strings.ReplaceAll(hexString, "\n", "")
+	hexString = strings.ReplaceAll(hexString, "\r", "")
+	buf, err := hex.DecodeString(hexString)
+	if err != nil || len(buf) < 2 {
+		return &Breakdown{Ranges: []HexRange{}}
+	}
+
+	var ranges []HexRange
+	offset := 0
+
+	// Byte 0: Header
+	ranges = append(ranges, HexRange{Start: 0, End: 0, Label: "Header"})
+	offset = 1
+
+	header := decodeHeader(buf[0])
+
+	// Bytes 1-4: Transport Codes (TRANSPORT_FLOOD / TRANSPORT_DIRECT only)
+	if isTransportRoute(header.RouteType) {
+		if len(buf) < offset+4 {
+			return &Breakdown{Ranges: ranges}
+		}
+		ranges = append(ranges, HexRange{Start: offset, End: offset + 3, Label: "Transport Codes"})
+		offset += 4
+	}
+
+	if offset >= len(buf) {
+		return &Breakdown{Ranges: ranges}
+	}
+
+	// Next byte: Path Length (bits 7-6 = hashSize-1, bits 5-0 = hashCount)
+	ranges = append(ranges, HexRange{Start: offset, End: offset, Label: "Path Length"})
+	pathByte := buf[offset]
+	offset++
+
+	hashSize := int(pathByte>>6) + 1
+	hashCount := int(pathByte & 0x3F)
+	pathBytes := hashSize * hashCount
+
+	// Path hops
+	if hashCount > 0 && offset+pathBytes <= len(buf) {
+		ranges = append(ranges, HexRange{Start: offset, End: offset + pathBytes - 1, Label: "Path"})
+	}
+	offset += pathBytes
+
+	if offset >= len(buf) {
+		return &Breakdown{Ranges: ranges}
+	}
+
+	payloadStart := offset
+
+	// Payload — break ADVERT into named sub-fields; everything else is one Payload range
+	if header.PayloadType == PayloadADVERT && len(buf)-payloadStart >= 100 {
+		ranges = append(ranges, HexRange{Start: payloadStart, End: payloadStart + 31, Label: "PubKey"})
+		ranges = append(ranges, HexRange{Start: payloadStart + 32, End: payloadStart + 35, Label: "Timestamp"})
+		ranges = append(ranges, HexRange{Start: payloadStart + 36, End: payloadStart + 99, Label: "Signature"})
+
+		appStart := payloadStart + 100
+		if appStart < len(buf) {
+			ranges = append(ranges, HexRange{Start: appStart, End: appStart, Label: "Flags"})
+			appFlags := buf[appStart]
+			fOff := appStart + 1
+			if appFlags&0x10 != 0 && fOff+8 <= len(buf) {
+				ranges = append(ranges, HexRange{Start: fOff, End: fOff + 3, Label: "Latitude"})
+				ranges = append(ranges, HexRange{Start: fOff + 4, End: fOff + 7, Label: "Longitude"})
+				fOff += 8
+			}
+			if appFlags&0x20 != 0 && fOff+2 <= len(buf) {
+				fOff += 2
+			}
+			if appFlags&0x40 != 0 && fOff+2 <= len(buf) {
+				fOff += 2
+			}
+			if appFlags&0x80 != 0 && fOff < len(buf) {
+				ranges = append(ranges, HexRange{Start: fOff, End: len(buf) - 1, Label: "Name"})
+			}
+		}
+	} else {
+		ranges = append(ranges, HexRange{Start: payloadStart, End: len(buf) - 1, Label: "Payload"})
+	}
+
+	return &Breakdown{Ranges: ranges}
+}
+
 // ComputeContentHash computes the SHA-256-based content hash (first 16 hex chars).
-// It hashes the payload-type nibble + payload (skipping path bytes) to produce a
-// route-independent identifier for the same logical packet. For TRACE packets,
-// path_len is included in the hash to match firmware behavior.
 func ComputeContentHash(rawHex string) string {
 	buf, err := hex.DecodeString(rawHex)
 	if err != nil || len(buf) < 2 {
@@ -482,18 +577,7 @@ func ComputeContentHash(rawHex string) string {
 	}
 
 	payload := buf[payloadStart:]
-
-	// Hash payload-type byte only (bits 2-5 of header), not the full header.
-	// Firmware: SHA256(payload_type + [path_len for TRACE] + payload)
-	// Using the full header caused different hashes for the same logical packet
-	// when route type or version bits differed. See issue #786.
-	payloadType := (headerByte >> 2) & 0x0F
-	toHash := []byte{payloadType}
-	if int(payloadType) == PayloadTRACE {
-		// Firmware uses uint16_t path_len (2 bytes, little-endian)
-		toHash = append(toHash, pathByte, 0x00)
-	}
-	toHash = append(toHash, payload...)
+	toHash := append([]byte{headerByte}, payload...)
 
 	h := sha256.Sum256(toHash)
 	return hex.EncodeToString(h[:])[:16]

cmd/server/decoder_test.go

@@ -97,6 +97,146 @@ func TestDecodePacket_FloodHasNoCodes(t *testing.T) {
 	}
 }
 
+func TestBuildBreakdown_InvalidHex(t *testing.T) {
+	b := BuildBreakdown("not-hex!")
+	if len(b.Ranges) != 0 {
+		t.Errorf("expected empty ranges for invalid hex, got %d", len(b.Ranges))
+	}
+}
+
+func TestBuildBreakdown_TooShort(t *testing.T) {
+	b := BuildBreakdown("11") // 1 byte — no path byte
+	if len(b.Ranges) != 0 {
+		t.Errorf("expected empty ranges for too-short packet, got %d", len(b.Ranges))
+	}
+}
+
+func TestBuildBreakdown_FloodNonAdvert(t *testing.T) {
+	// Header 0x15: route=1/FLOOD, payload=5/GRP_TXT
+	// PathByte 0x01: 1 hop, 1-byte hash
+	// PathHop: AA
+	// Payload: FF0011
+	b := BuildBreakdown("1501AAFFFF00")
+	labels := rangeLabels(b.Ranges)
+	expect := []string{"Header", "Path Length", "Path", "Payload"}
+	if !equalLabels(labels, expect) {
+		t.Errorf("expected labels %v, got %v", expect, labels)
+	}
+	// Verify byte positions
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Path Length", 1, 1)
+	assertRange(t, b.Ranges, "Path", 2, 2)
+	assertRange(t, b.Ranges, "Payload", 3, 5)
+}
+
+func TestBuildBreakdown_TransportFlood(t *testing.T) {
+	// Header 0x14: route=0/TRANSPORT_FLOOD, payload=5/GRP_TXT
+	// TransportCodes: AABBCCDD (4 bytes)
+	// PathByte 0x01: 1 hop, 1-byte hash
+	// PathHop: EE
+	// Payload: FF00
+	b := BuildBreakdown("14AABBCCDD01EEFF00")
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Transport Codes", 1, 4)
+	assertRange(t, b.Ranges, "Path Length", 5, 5)
+	assertRange(t, b.Ranges, "Path", 6, 6)
+	assertRange(t, b.Ranges, "Payload", 7, 8)
+}
+
+func TestBuildBreakdown_FloodNoHops(t *testing.T) {
+	// Header 0x15: FLOOD/GRP_TXT; PathByte 0x00: 0 hops; Payload: AABB
+	b := BuildBreakdown("150000AABB")
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Path Length", 1, 1)
+	// No Path range since hashCount=0
+	for _, r := range b.Ranges {
+		if r.Label == "Path" {
+			t.Error("expected no Path range for zero-hop packet")
+		}
+	}
+	assertRange(t, b.Ranges, "Payload", 2, 4)
+}
+
+func TestBuildBreakdown_AdvertBasic(t *testing.T) {
+	// Header 0x11: FLOOD/ADVERT
+	// PathByte 0x01: 1 hop, 1-byte hash
+	// PathHop: AA
+	// Payload: 100 bytes (PubKey32 + Timestamp4 + Signature64) + Flags=0x02 (repeater, no extras)
+	pubkey := repeatHex("AB", 32)
+	ts := "00000000" // 4 bytes
+	sig := repeatHex("CD", 64)
+	flags := "02"
+	hex := "1101AA" + pubkey + ts + sig + flags
+	b := BuildBreakdown(hex)
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Path Length", 1, 1)
+	assertRange(t, b.Ranges, "Path", 2, 2)
+	assertRange(t, b.Ranges, "PubKey", 3, 34)
+	assertRange(t, b.Ranges, "Timestamp", 35, 38)
+	assertRange(t, b.Ranges, "Signature", 39, 102)
+	assertRange(t, b.Ranges, "Flags", 103, 103)
+}
+
+func TestBuildBreakdown_AdvertWithLocation(t *testing.T) {
+	// flags=0x12: hasLocation bit set
+	pubkey := repeatHex("00", 32)
+	ts := "00000000"
+	sig := repeatHex("00", 64)
+	flags := "12" // 0x10 = hasLocation
+	latBytes := "00000000"
+	lonBytes := "00000000"
+	hex := "1101AA" + pubkey + ts + sig + flags + latBytes + lonBytes
+	b := BuildBreakdown(hex)
+	assertRange(t, b.Ranges, "Latitude", 104, 107)
+	assertRange(t, b.Ranges, "Longitude", 108, 111)
+}
+
+func TestBuildBreakdown_AdvertWithName(t *testing.T) {
+	// flags=0x82: hasName bit set
+	pubkey := repeatHex("00", 32)
+	ts := "00000000"
+	sig := repeatHex("00", 64)
+	flags := "82" // 0x80 = hasName
+	name := "4E6F6465" // "Node" in hex
+	hex := "1101AA" + pubkey + ts + sig + flags + name
+	b := BuildBreakdown(hex)
+	assertRange(t, b.Ranges, "Name", 104, 107)
+}
+
+// helpers
+
+func rangeLabels(ranges []HexRange) []string {
+	out := make([]string, len(ranges))
+	for i, r := range ranges {
+		out[i] = r.Label
+	}
+	return out
+}
+
+func equalLabels(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func assertRange(t *testing.T, ranges []HexRange, label string, wantStart, wantEnd int) {
+	t.Helper()
+	for _, r := range ranges {
+		if r.Label == label {
+			if r.Start != wantStart || r.End != wantEnd {
+				t.Errorf("range %q: want [%d,%d], got [%d,%d]", label, wantStart, wantEnd, r.Start, r.End)
+			}
+			return
+		}
+	}
+	t.Errorf("range %q not found in %v", label, rangeLabels(ranges))
+}
 
 func TestZeroHopDirectHashSize(t *testing.T) {
 	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02

cmd/server/eviction_test.go

@@ -247,11 +247,6 @@ func TestEvictStale_CleansNodeIndexes(t *testing.T) {
 
 func TestEvictStale_CleansResolvedPathNodeIndexes(t *testing.T) {
 	now := time.Now().UTC()
-
-	// Create a temp DB for on-demand SQL fetch during eviction
-	db := setupTestDB(t)
-	defer db.Close()
-
 	store := &PacketStore{
 		packets:       make([]*StoreTx, 0),
 		byHash:        make(map[string]*StoreTx),
@@ -272,33 +267,25 @@ func TestEvictStale_CleansResolvedPathNodeIndexes(t *testing.T) {
 		subpathCache:  make(map[string]*cachedResult),
 		rfCacheTTL:    15 * time.Second,
 		retentionHours: 24,
-		db:             db,
-		useResolvedPathIndex: true,
 	}
-	store.initResolvedPathIndex()
 
-	// Create a packet indexed via resolved_path pubkeys
+	// Create a packet indexed only via resolved_path (no decoded JSON pubkeys)
 	relayPK := "relay0001abcdef"
-	txID := 1
-	obsID := 100
 	tx := &StoreTx{
-		ID:        txID,
+		ID:        1,
 		Hash:      "hash_rp_001",
 		FirstSeen: now.Add(-48 * time.Hour).UTC().Format(time.RFC3339),
 	}
+	rpPtr := &relayPK
 	obs := &StoreObs{
-		ID:             obsID,
-		TransmissionID: txID,
+		ID:             100,
+		TransmissionID: 1,
 		ObserverID:     "obs0",
 		Timestamp:      tx.FirstSeen,
+		ResolvedPath:   []*string{rpPtr},
 	}
 	tx.Observations = append(tx.Observations, obs)
-
-	// Insert into DB so on-demand SQL fetch works during eviction
-	db.conn.Exec("INSERT INTO transmissions (id, raw_hex, hash, first_seen) VALUES (?, '', ?, ?)",
-		txID, tx.Hash, tx.FirstSeen)
-	db.conn.Exec("INSERT INTO observations (id, transmission_id, observer_idx, path_json, timestamp, resolved_path) VALUES (?, ?, 1, ?, ?, ?)",
-		obsID, txID, `["aa"]`, now.Add(-48*time.Hour).Unix(), `["`+relayPK+`"]`)
+	tx.ResolvedPath = []*string{rpPtr}
 
 	store.packets = append(store.packets, tx)
 	store.byHash[tx.Hash] = tx
@@ -306,9 +293,8 @@ func TestEvictStale_CleansResolvedPathNodeIndexes(t *testing.T) {
 	store.byObsID[obs.ID] = obs
 	store.byObserver["obs0"] = append(store.byObserver["obs0"], obs)
 
-	// Index relay via decode-window simulation
-	store.addToByNode(tx, relayPK)
-	store.addToResolvedPubkeyIndex(txID, []string{relayPK})
+	// Index via resolved_path
+	store.indexByNode(tx)
 
 	// Verify indexed
 	if len(store.byNode[relayPK]) != 1 {
@@ -318,7 +304,7 @@ func TestEvictStale_CleansResolvedPathNodeIndexes(t *testing.T) {
 		t.Fatalf("expected nodeHashes[%s] to contain %s", relayPK, tx.Hash)
 	}
 
-	evicted := store.RunEviction()
+	evicted := store.EvictStale()
 	if evicted != 1 {
 		t.Fatalf("expected 1 evicted, got %d", evicted)
 	}
@@ -330,14 +316,6 @@ func TestEvictStale_CleansResolvedPathNodeIndexes(t *testing.T) {
 	if _, exists := store.nodeHashes[relayPK]; exists {
 		t.Fatalf("expected nodeHashes[%s] to be deleted after eviction", relayPK)
 	}
-	// Verify resolved pubkey index is cleaned up
-	h := resolvedPubkeyHash(relayPK)
-	if len(store.resolvedPubkeyIndex[h]) != 0 {
-		t.Fatalf("expected resolvedPubkeyIndex to be empty after eviction")
-	}
-	if _, exists := store.resolvedPubkeyReverse[txID]; exists {
-		t.Fatalf("expected resolvedPubkeyReverse to be empty after eviction")
-	}
 }
 
 func TestEvictStale_RunEvictionThreadSafe(t *testing.T) {

cmd/server/go.mod

@@ -14,10 +14,6 @@ replace github.com/meshcore-analyzer/geofilter => ../../internal/geofilter
 
 replace github.com/meshcore-analyzer/sigvalidate => ../../internal/sigvalidate
 
-require github.com/meshcore-analyzer/packetpath v0.0.0
-
-replace github.com/meshcore-analyzer/packetpath => ../../internal/packetpath
-
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect

cmd/server/hash_migrate.go

@@ -1,119 +0,0 @@
-package main
-
-import (
-	"log"
-	"time"
-)
-
-// migrateContentHashesAsync recomputes content hashes in batches after the
-// server is already serving HTTP.  Packets whose hash changes are updated in
-// both the DB and the in-memory byHash index.  The migration is idempotent:
-// once all hashes match the current formula it completes instantly.
-func migrateContentHashesAsync(store *PacketStore, batchSize int, yieldDuration time.Duration) {
-	defer func() {
-		if r := recover(); r != nil {
-			log.Printf("[hash-migrate] panic recovered: %v", r)
-		}
-		store.hashMigrationComplete.Store(true)
-	}()
-
-	// Snapshot the packet slice length under lock (packets only grow).
-	store.mu.RLock()
-	total := len(store.packets)
-	store.mu.RUnlock()
-
-	migrated := 0
-	for offset := 0; offset < total; offset += batchSize {
-		end := offset + batchSize
-		if end > total {
-			end = total
-		}
-
-		// Collect stale hashes in this batch under RLock.
-		type hashUpdate struct {
-			tx      *StoreTx
-			oldHash string
-			newHash string
-		}
-		var updates []hashUpdate
-
-		store.mu.RLock()
-		for _, tx := range store.packets[offset:end] {
-			if tx.RawHex == "" {
-				continue
-			}
-			newHash := ComputeContentHash(tx.RawHex)
-			if newHash != tx.Hash {
-				updates = append(updates, hashUpdate{tx: tx, oldHash: tx.Hash, newHash: newHash})
-			}
-		}
-		store.mu.RUnlock()
-
-		if len(updates) == 0 {
-			continue
-		}
-
-		// Write batch to DB in a single transaction.
-		dbTx, err := store.db.conn.Begin()
-		if err != nil {
-			log.Printf("[hash-migrate] begin tx: %v", err)
-			continue
-		}
-		stmt, err := dbTx.Prepare("UPDATE transmissions SET hash = ? WHERE id = ?")
-		if err != nil {
-			log.Printf("[hash-migrate] prepare: %v", err)
-			dbTx.Rollback()
-			continue
-		}
-
-		for _, u := range updates {
-			if _, err := stmt.Exec(u.newHash, u.tx.ID); err != nil {
-				// UNIQUE constraint = two old hashes map to the same new hash (duplicate).
-				// Merge observations to the surviving tx, delete the duplicate.
-				log.Printf("[hash-migrate] tx %d collides — merging duplicate", u.tx.ID)
-				var survID int
-				if err2 := dbTx.QueryRow("SELECT id FROM transmissions WHERE hash = ?", u.newHash).Scan(&survID); err2 == nil {
-					dbTx.Exec("UPDATE observations SET transmission_id = ? WHERE transmission_id = ?", survID, u.tx.ID)
-					dbTx.Exec("DELETE FROM transmissions WHERE id = ?", u.tx.ID)
-					u.newHash = "" // mark for in-memory removal only
-				}
-			}
-		}
-		stmt.Close()
-
-		if err := dbTx.Commit(); err != nil {
-			log.Printf("[hash-migrate] commit: %v", err)
-			continue
-		}
-
-		// Update in-memory index under write lock.
-		store.mu.Lock()
-		for _, u := range updates {
-			delete(store.byHash, u.oldHash)
-			if u.newHash == "" {
-				// Merged duplicate — remove from packets slice and indexes.
-				delete(store.byTxID, u.tx.ID)
-				// Move observations to survivor if present.
-				if surv := store.byHash[ComputeContentHash(u.tx.RawHex)]; surv != nil {
-					for _, obs := range u.tx.Observations {
-						surv.Observations = append(surv.Observations, obs)
-						surv.ObservationCount++
-					}
-				}
-			} else {
-				u.tx.Hash = u.newHash
-				store.byHash[u.newHash] = u.tx
-			}
-		}
-		store.mu.Unlock()
-
-		migrated += len(updates)
-
-		// Yield to let HTTP handlers run.
-		time.Sleep(yieldDuration)
-	}
-
-	if migrated > 0 {
-		log.Printf("[hash-migrate] Migrated %d content hashes to new formula", migrated)
-	}
-}

cmd/server/hash_migrate_test.go

@@ -1,78 +0,0 @@
-package main
-
-import (
-	"testing"
-	"time"
-)
-
-func TestMigrateContentHashesAsync(t *testing.T) {
-	db := setupTestDBv2(t)
-	store := NewPacketStore(db, nil)
-
-	// Insert a packet with a manually wrong hash (simulating old formula).
-	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
-	correctHash := ComputeContentHash(rawHex)
-	wrongHash := "deadbeef12345678"
-
-	_, err := db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type)
-		VALUES (?, ?, datetime('now'), 0, 2)`, rawHex, wrongHash)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := store.Load(); err != nil {
-		t.Fatal(err)
-	}
-
-	if store.byHash[wrongHash] == nil {
-		t.Fatal("expected packet under wrong hash before migration")
-	}
-
-	migrateContentHashesAsync(store, 100, time.Millisecond)
-
-	if !store.hashMigrationComplete.Load() {
-		t.Error("expected hashMigrationComplete to be true")
-	}
-	if store.byHash[wrongHash] != nil {
-		t.Error("old hash should be removed from index")
-	}
-	if store.byHash[correctHash] == nil {
-		t.Error("new hash should be in index")
-	}
-
-	var dbHash string
-	err = db.conn.QueryRow("SELECT hash FROM transmissions WHERE raw_hex = ?", rawHex).Scan(&dbHash)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if dbHash != correctHash {
-		t.Errorf("DB hash = %s, want %s", dbHash, correctHash)
-	}
-}
-
-func TestMigrateContentHashesAsync_NoOp(t *testing.T) {
-	db := setupTestDBv2(t)
-	store := NewPacketStore(db, nil)
-
-	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
-	correctHash := ComputeContentHash(rawHex)
-
-	_, err := db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type)
-		VALUES (?, ?, datetime('now'), 0, 2)`, rawHex, correctHash)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := store.Load(); err != nil {
-		t.Fatal(err)
-	}
-
-	migrateContentHashesAsync(store, 100, time.Millisecond)
-
-	if !store.hashMigrationComplete.Load() {
-		t.Error("expected hashMigrationComplete to be true")
-	}
-	if store.byHash[correctHash] == nil {
-		t.Error("hash should remain in index")
-	}
-}

cmd/server/issue673_test.go

@@ -1,107 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-
-	_ "modernc.org/sqlite"
-)
-
-const issue673NodePK = "7502f19f44cad6d7b626e1d811c00a914af452636182ccded3fd019803395ec9"
-
-// setupIssue673Store builds an in-memory store with one repeater node having:
-//   - one ADVERT packet (legitimately indexed in byNode)
-//   - one GRP_TXT packet whose decoded text contains the node's pubkey (false-positive candidate)
-func setupIssue673Store(t *testing.T) (*PacketStore, *DB) {
-	t.Helper()
-	db := setupTestDB(t)
-
-	_, err := db.conn.Exec(
-		"INSERT INTO nodes (public_key, name, role) VALUES (?, ?, ?)",
-		issue673NodePK, "Quail Hollow Park", "repeater",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ps := NewPacketStore(db, nil)
-	now := time.Now().UTC().Format(time.RFC3339)
-
-	pt4 := 4 // ADVERT
-	pt5 := 5 // GRP_TXT
-
-	advertDecoded, _ := json.Marshal(map[string]interface{}{"pubKey": issue673NodePK})
-	advert := &StoreTx{
-		ID:          1,
-		Hash:        "advert_hash_673",
-		PayloadType: &pt4,
-		DecodedJSON: string(advertDecoded),
-		FirstSeen:   now,
-	}
-
-	otherPK := "aabbccddaabbccddaabbccddaabbccddaabbccddaabbccddaabbccddaabbccdd"
-	chatDecoded, _ := json.Marshal(map[string]interface{}{
-		"srcPubKey": otherPK,
-		"text":      "Check out node " + issue673NodePK + " on the analyzer",
-	})
-	chat := &StoreTx{
-		ID:          2,
-		Hash:        "chat_hash_673",
-		PayloadType: &pt5,
-		DecodedJSON: string(chatDecoded),
-		FirstSeen:   now,
-	}
-
-	ps.mu.Lock()
-	ps.packets = append(ps.packets, advert, chat)
-	ps.byHash[advert.Hash] = advert
-	ps.byHash[chat.Hash] = chat
-	ps.byTxID[advert.ID] = advert
-	ps.byTxID[chat.ID] = chat
-	ps.byNode[issue673NodePK] = []*StoreTx{advert}
-	ps.mu.Unlock()
-
-	return ps, db
-}
-
-// TestGetNodeAnalytics_ExcludesGRPTXTWithPubkeyInText verifies that a GRP_TXT packet
-// whose message text contains a node's pubkey is not counted in that node's analytics.
-func TestGetNodeAnalytics_ExcludesGRPTXTWithPubkeyInText(t *testing.T) {
-	ps, db := setupIssue673Store(t)
-	defer db.Close()
-
-	analytics, err := ps.GetNodeAnalytics(issue673NodePK, 30)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if analytics == nil {
-		t.Fatal("expected analytics, got nil")
-	}
-
-	for _, ptc := range analytics.PacketTypeBreakdown {
-		if ptc.PayloadType == 5 {
-			t.Errorf("GRP_TXT (type 5) should not appear in analytics for repeater node, got count=%d", ptc.Count)
-		}
-	}
-}
-
-// TestFilterPackets_NodeQueryDoesNotMatchChatText verifies that the slow path of
-// filterPackets (node filter combined with Since) does not return a GRP_TXT packet
-// whose pubkey appears only in message text, not in a structured pubkey field.
-func TestFilterPackets_NodeQueryDoesNotMatchChatText(t *testing.T) {
-	ps, db := setupIssue673Store(t)
-	defer db.Close()
-
-	yesterday := time.Now().Add(-24 * time.Hour).UTC().Format(time.RFC3339)
-	result := ps.QueryPackets(PacketQuery{Node: issue673NodePK, Since: yesterday, Limit: 50})
-
-	if result.Total != 1 {
-		t.Errorf("expected 1 packet for node (ADVERT only), got %d", result.Total)
-	}
-	for _, pkt := range result.Packets {
-		if pkt["hash"] == "chat_hash_673" {
-			t.Errorf("GRP_TXT with pubkey in message text was incorrectly returned for node query")
-		}
-	}
-}

cmd/server/issue810_repro_test.go

@@ -1,78 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/gorilla/mux"
-)
-
-// TestRepro810 reproduces #810: when the longest-path observation has NULL
-// resolved_path but a shorter-path observation has one, fetchResolvedPathForTxBest
-// returns nil → /api/nodes/{pk}/health.recentPackets[].resolved_path is missing
-// while /api/packets shows it.
-func TestRepro810(t *testing.T) {
-	db := setupTestDB(t)
-	now := time.Now().UTC()
-	recent := now.Add(-1 * time.Hour).Format(time.RFC3339)
-	recentEpoch := now.Add(-1 * time.Hour).Unix()
-	db.conn.Exec(`INSERT INTO observers (id, name, last_seen, first_seen, packet_count) VALUES ('obs1','O1',?, '2026-01-01T00:00:00Z', 100)`, recent)
-	db.conn.Exec(`INSERT INTO observers (id, name, last_seen, first_seen, packet_count) VALUES ('obs2','O2',?, '2026-01-01T00:00:00Z', 100)`, recent)
-	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, last_seen, first_seen, advert_count) VALUES ('aabbccdd11223344','R','repeater',?, '2026-01-01T00:00:00Z', 1)`, recent)
-	db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json) VALUES ('AABB','testhash00000001',?,1,4,'{"pubKey":"aabbccdd11223344","type":"ADVERT"}')`, recent)
-	// Longest-path obs WITHOUT resolved_path
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp) VALUES (1,1,12.5,-90,'["aa","bb","cc"]',?)`, recentEpoch)
-	// Shorter-path obs WITH resolved_path
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp, resolved_path) VALUES (1,2,8.0,-95,'["aa","bb"]',?,'["aabbccdd11223344","eeff00112233aabb"]')`, recentEpoch-100)
-
-	cfg := &Config{Port: 3000}
-	hub := NewHub()
-	srv := NewServer(db, cfg, hub)
-	store := NewPacketStore(db, nil)
-	if err := store.Load(); err != nil {
-		t.Fatal(err)
-	}
-	srv.store = store
-	router := mux.NewRouter()
-	srv.RegisterRoutes(router)
-
-	// Sanity: /api/packets should show resolved_path for this tx.
-	reqP := httptest.NewRequest("GET", "/api/packets?limit=10", nil)
-	wP := httptest.NewRecorder()
-	router.ServeHTTP(wP, reqP)
-	var pktsBody map[string]interface{}
-	json.Unmarshal(wP.Body.Bytes(), &pktsBody)
-	pkts, _ := pktsBody["packets"].([]interface{})
-	hasOnPackets := false
-	for _, p := range pkts {
-		pm := p.(map[string]interface{})
-		if pm["hash"] == "testhash00000001" && pm["resolved_path"] != nil {
-			hasOnPackets = true
-		}
-	}
-	if !hasOnPackets {
-		t.Fatal("precondition: /api/packets must report resolved_path for tx")
-	}
-
-	req := httptest.NewRequest("GET", "/api/nodes/aabbccdd11223344/health", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-	var body map[string]interface{}
-	json.Unmarshal(w.Body.Bytes(), &body)
-	rp, _ := body["recentPackets"].([]interface{})
-	if len(rp) == 0 {
-		t.Fatal("no recentPackets")
-	}
-	for _, p := range rp {
-		pm := p.(map[string]interface{})
-		if pm["hash"] == "testhash00000001" {
-			if pm["resolved_path"] == nil {
-				t.Fatal("BUG #810: /health.recentPackets resolved_path is nil despite /api/packets reporting it")
-			}
-			return
-		}
-	}
-	t.Fatal("tx not found in recentPackets")
-}

cmd/server/main.go

@@ -111,14 +111,6 @@ func main() {
 	// Resolve DB path
 	resolvedDB := cfg.ResolveDBPath(configDir)
 	log.Printf("[config] port=%d db=%s public=%s", cfg.Port, resolvedDB, publicDir)
-	if len(cfg.NodeBlacklist) > 0 {
-		log.Printf("[config] nodeBlacklist: %d node(s) will be hidden from API", len(cfg.NodeBlacklist))
-		for _, pk := range cfg.NodeBlacklist {
-			if trimmed := strings.ToLower(strings.TrimSpace(pk)); trimmed != "" {
-				log.Printf("[config]   blacklisted: %s", trimmed)
-			}
-		}
-	}
 
 	// Open database
 	database, err := OpenDB(resolvedDB)
@@ -148,9 +140,6 @@ func main() {
 			stats.TotalTransmissions, stats.TotalObservations, stats.TotalNodes, stats.TotalObservers)
 	}
 
-	// Check auto_vacuum mode and optionally migrate (#919)
-	checkAutoVacuum(database, cfg, resolvedDB)
-
 	// In-memory packet store
 	store := NewPacketStore(database, cfg.PacketStore, cfg.CacheTTL)
 	if err := store.Load(); err != nil {
@@ -269,7 +258,6 @@ func main() {
 	defer stopEviction()
 
 	// Auto-prune old packets if retention.packetDays is configured
-	vacuumPages := cfg.IncrementalVacuumPages()
 	var stopPrune func()
 	if cfg.Retention != nil && cfg.Retention.PacketDays > 0 {
 		days := cfg.Retention.PacketDays
@@ -290,9 +278,6 @@ func main() {
 				log.Printf("[prune] error: %v", err)
 			} else {
 				log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
-				if n > 0 {
-					runIncrementalVacuum(resolvedDB, vacuumPages)
-				}
 			}
 			for {
 				select {
@@ -301,9 +286,6 @@ func main() {
 						log.Printf("[prune] error: %v", err)
 					} else {
 						log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
-						if n > 0 {
-							runIncrementalVacuum(resolvedDB, vacuumPages)
-						}
 					}
 				case <-pruneDone:
 					return
@@ -331,12 +313,10 @@ func main() {
 			}()
 			time.Sleep(2 * time.Minute) // stagger after packet prune
 			database.PruneOldMetrics(metricsDays)
-			runIncrementalVacuum(resolvedDB, vacuumPages)
 			for {
 				select {
 				case <-metricsPruneTicker.C:
 					database.PruneOldMetrics(metricsDays)
-					runIncrementalVacuum(resolvedDB, vacuumPages)
 				case <-metricsPruneDone:
 					return
 				}
@@ -345,42 +325,6 @@ func main() {
 		log.Printf("[metrics-prune] auto-prune enabled: metrics older than %d days", metricsDays)
 	}
 
-	// Auto-prune stale observers
-	var stopObserverPrune func()
-	{
-		observerDays := cfg.ObserverDaysOrDefault()
-		if observerDays <= -1 {
-			// -1 means keep forever, skip
-		} else {
-			observerPruneTicker := time.NewTicker(24 * time.Hour)
-			observerPruneDone := make(chan struct{})
-			stopObserverPrune = func() {
-				observerPruneTicker.Stop()
-				close(observerPruneDone)
-			}
-			go func() {
-				defer func() {
-					if r := recover(); r != nil {
-						log.Printf("[observer-prune] panic recovered: %v", r)
-					}
-				}()
-				time.Sleep(3 * time.Minute) // stagger after metrics prune
-				database.RemoveStaleObservers(observerDays)
-				runIncrementalVacuum(resolvedDB, vacuumPages)
-				for {
-					select {
-					case <-observerPruneTicker.C:
-						database.RemoveStaleObservers(observerDays)
-						runIncrementalVacuum(resolvedDB, vacuumPages)
-					case <-observerPruneDone:
-						return
-					}
-				}
-			}()
-			log.Printf("[observer-prune] auto-prune enabled: observers not seen in %d days will be removed", observerDays)
-		}
-	}
-
 	// Auto-prune old neighbor edges
 	var stopEdgePrune func()
 	{
@@ -402,7 +346,6 @@ func main() {
 			g := store.graph
 			store.mu.RUnlock()
 			PruneNeighborEdges(dbPath, g, maxAgeDays)
-			runIncrementalVacuum(resolvedDB, vacuumPages)
 			for {
 				select {
 				case <-edgePruneTicker.C:
@@ -410,7 +353,6 @@ func main() {
 					g := store.graph
 					store.mu.RUnlock()
 					PruneNeighborEdges(dbPath, g, maxAgeDays)
-					runIncrementalVacuum(resolvedDB, vacuumPages)
 				case <-edgePruneDone:
 					return
 				}
@@ -444,9 +386,6 @@ func main() {
 		if stopMetricsPrune != nil {
 			stopMetricsPrune()
 		}
-		if stopObserverPrune != nil {
-			stopObserverPrune()
-		}
 		if stopEdgePrune != nil {
 			stopEdgePrune()
 		}
@@ -473,9 +412,6 @@ func main() {
 	// Start async backfill in background — HTTP is now available.
 	go backfillResolvedPathsAsync(store, dbPath, 5000, 100*time.Millisecond, cfg.BackfillHours())
 
-	// Migrate old content hashes in background (one-time, idempotent).
-	go migrateContentHashesAsync(store, 5000, 100*time.Millisecond)
-
 	if err := httpServer.ListenAndServe(); err != http.ErrServerClosed {
 		log.Fatalf("[server] %v", err)
 	}

cmd/server/memory.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-)
-
-// MemorySnapshot is a point-in-time view of process memory across several
-// vantage points. Values are in MB (1024*1024 bytes), rounded to one decimal.
-//
-// Field invariants (typical, not guaranteed under exotic conditions):
-//
-//	processRSSMB  >=  goSysMB  >=  goHeapInuseMB  >=  storeDataMB
-//
-//   - processRSSMB is what the kernel charges the process (resident set).
-//     Read from /proc/self/status `VmRSS:` on Linux; falls back to goSysMB
-//     on other platforms or when /proc is unavailable.
-//   - goSysMB is the total memory obtained from the OS by the Go runtime
-//     (heap, stacks, GC metadata, mspans, mcache, etc.). Includes
-//     fragmentation and unused-but-mapped span overhead.
-//   - goHeapInuseMB is the live, in-use Go heap (HeapInuse). Excludes
-//     idle spans and runtime overhead.
-//   - storeDataMB is the in-store packet byte estimate (transmissions +
-//     observations). Subset of HeapInuse. Does not include index maps,
-//     analytics caches, broadcast queues, or runtime overhead. Used as
-//     the input to the eviction watermark.
-//
-// processRSSMB and storeDataMB are monotonic only relative to ingest +
-// eviction; both can shrink when packets age out. goHeapInuseMB and goSysMB
-// fluctuate with GC.
-//
-// cgoBytesMB intentionally absent: this build uses the pure-Go
-// modernc.org/sqlite driver, so there is no cgo allocator to measure.
-// Reintroduce only if we ever switch back to mattn/go-sqlite3.
-type MemorySnapshot struct {
-	ProcessRSSMB  float64 `json:"processRSSMB"`
-	GoHeapInuseMB float64 `json:"goHeapInuseMB"`
-	GoSysMB       float64 `json:"goSysMB"`
-	StoreDataMB   float64 `json:"storeDataMB"`
-}
-
-// rssCache rate-limits the /proc/self/status read. Go memory stats are
-// already cached by Server.getMemStats (5s TTL). We use a tighter 1s TTL
-// here so processRSSMB stays reasonably fresh during ops debugging
-// without paying the syscall cost on every /api/stats hit.
-var (
-	rssCacheMu       sync.Mutex
-	rssCacheValueMB  float64
-	rssCacheCachedAt time.Time
-)
-
-const rssCacheTTL = 1 * time.Second
-
-// getMemorySnapshot composes a MemorySnapshot using the Server's existing
-// runtime.MemStats cache (5s TTL, used by /api/health and /api/perf too)
-// plus a rate-limited /proc RSS read. storeDataMB is supplied by the
-// caller because the packet store is the source of truth.
-func (s *Server) getMemorySnapshot(storeDataMB float64) MemorySnapshot {
-	ms := s.getMemStats()
-
-	rssCacheMu.Lock()
-	if time.Since(rssCacheCachedAt) > rssCacheTTL {
-		rssCacheValueMB = readProcRSSMB()
-		rssCacheCachedAt = time.Now()
-	}
-	rssMB := rssCacheValueMB
-	rssCacheMu.Unlock()
-
-	if rssMB <= 0 {
-		// Fallback when /proc is unavailable (non-Linux, sandboxes, etc.).
-		// runtime.Sys is an upper bound on Go-attributable memory and a
-		// reasonable proxy for pure-Go builds.
-		rssMB = float64(ms.Sys) / 1048576.0
-	}
-
-	return MemorySnapshot{
-		ProcessRSSMB:  roundMB(rssMB),
-		GoHeapInuseMB: roundMB(float64(ms.HeapInuse) / 1048576.0),
-		GoSysMB:       roundMB(float64(ms.Sys) / 1048576.0),
-		StoreDataMB:   roundMB(storeDataMB),
-	}
-}
-
-// readProcRSSMB parses /proc/self/status for the VmRSS line. Returns 0 on
-// any failure (file missing, malformed line, parse error) — the caller
-// then uses a runtime fallback. Linux only; macOS/Windows return 0.
-//
-// Safety notes (djb): the file path is hard-coded, no untrusted input is
-// concatenated. We bound the read at 8 KiB (the whole status file is
-// well under 4 KiB on modern kernels) so a corrupt /proc can't OOM us.
-// We only parse digits with strconv; no shell, no exec, no format strings.
-func readProcRSSMB() float64 {
-	const maxStatusBytes = 8 * 1024
-	f, err := os.Open("/proc/self/status")
-	if err != nil {
-		return 0
-	}
-	defer f.Close()
-
-	buf := make([]byte, maxStatusBytes)
-	n, err := f.Read(buf)
-	if err != nil && n == 0 {
-		return 0
-	}
-	for _, line := range strings.Split(string(buf[:n]), "\n") {
-		if !strings.HasPrefix(line, "VmRSS:") {
-			continue
-		}
-		// Format: "VmRSS:\t   123456 kB"
-		fields := strings.Fields(line[len("VmRSS:"):])
-		if len(fields) < 2 {
-			return 0
-		}
-		kb, err := strconv.ParseFloat(fields[0], 64)
-		if err != nil || kb < 0 {
-			return 0
-		}
-		// Unit is kB per kernel convention; convert to MB.
-		return kb / 1024.0
-	}
-	return 0
-}
-
-func roundMB(v float64) float64 {
-	if v < 0 {
-		return 0
-	}
-	return float64(int64(v*10+0.5)) / 10.0
-}

cmd/server/multibyte_capability_test.go

@@ -6,17 +6,10 @@ import (
 	"fmt"
 	"strings"
 	"testing"
-	"time"
 
 	_ "modernc.org/sqlite"
 )
 
-// recentTS returns a timestamp string N hours ago, ensuring test data
-// stays within the 7-day advert window used by computeNodeHashSizeInfo.
-func recentTS(hoursAgo int) string {
-	return time.Now().UTC().Add(-time.Duration(hoursAgo) * time.Hour).Format("2006-01-02T15:04:05.000Z")
-}
-
 // setupCapabilityTestDB creates a minimal in-memory DB with nodes table.
 func setupCapabilityTestDB(t *testing.T) *DB {
 	t.Helper()
@@ -76,7 +69,7 @@ func makeTestAdvert(pubkey string, hashSize int) *StoreTx {
 		PayloadType: &pt,
 		DecodedJSON: string(decoded),
 		PathJSON:    `["` + prefix + `"]`,
-		FirstSeen:   recentTS(24),
+		FirstSeen:   "2026-04-11T00:00:00.000Z",
 	}
 }
 
@@ -87,7 +80,7 @@ func TestMultiByteCapability_Confirmed(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepA", "repeater", recentTS(24))
+		"aabbccdd11223344", "RepA", "repeater", "2026-04-11T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 	addTestPacket(store, makeTestAdvert("aabbccdd11223344", 2))
@@ -114,7 +107,7 @@ func TestMultiByteCapability_Suspected(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepB", "repeater", recentTS(48))
+		"aabbccdd11223344", "RepB", "repeater", "2026-04-10T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -126,7 +119,7 @@ func TestMultiByteCapability_Suspected(t *testing.T) {
 		RawHex:      rawHex,
 		PayloadType: &pt,
 		PathJSON:    `["aabb"]`,
-		FirstSeen:   recentTS(48),
+		FirstSeen:   "2026-04-10T00:00:00.000Z",
 	}
 	addTestPacket(store, pkt)
 
@@ -152,7 +145,7 @@ func TestMultiByteCapability_Unknown(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepC", "repeater", recentTS(72))
+		"aabbccdd11223344", "RepC", "repeater", "2026-04-08T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -180,9 +173,9 @@ func TestMultiByteCapability_PrefixCollision(t *testing.T) {
 
 	// Two repeaters sharing 1-byte prefix "aa"
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabb000000000001", "RepConfirmed", "repeater", recentTS(24))
+		"aabb000000000001", "RepConfirmed", "repeater", "2026-04-11T00:00:00Z")
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aacc000000000002", "RepOther", "repeater", recentTS(24))
+		"aacc000000000002", "RepOther", "repeater", "2026-04-11T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -197,7 +190,7 @@ func TestMultiByteCapability_PrefixCollision(t *testing.T) {
 		RawHex:      rawHex,
 		PayloadType: &pt,
 		PathJSON:    `["aa"]`,
-		FirstSeen:   recentTS(48),
+		FirstSeen:   "2026-04-10T00:00:00.000Z",
 	}
 	addTestPacket(store, pkt)
 
@@ -228,7 +221,7 @@ func TestMultiByteCapability_TraceExcluded(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepTrace", "repeater", recentTS(48))
+		"aabbccdd11223344", "RepTrace", "repeater", "2026-04-10T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -240,7 +233,7 @@ func TestMultiByteCapability_TraceExcluded(t *testing.T) {
 		RawHex:      rawHex,
 		PayloadType: &pt,
 		PathJSON:    `["aabb"]`,
-		FirstSeen:   recentTS(48),
+		FirstSeen:   "2026-04-10T00:00:00.000Z",
 	}
 	addTestPacket(store, pkt)
 
@@ -260,7 +253,7 @@ func TestMultiByteCapability_NonTraceStillSuspected(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepNonTrace", "repeater", recentTS(48))
+		"aabbccdd11223344", "RepNonTrace", "repeater", "2026-04-10T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -272,7 +265,7 @@ func TestMultiByteCapability_NonTraceStillSuspected(t *testing.T) {
 		RawHex:      rawHex,
 		PayloadType: &pt,
 		PathJSON:    `["aabb"]`,
-		FirstSeen:   recentTS(48),
+		FirstSeen:   "2026-04-10T00:00:00.000Z",
 	}
 	addTestPacket(store, pkt)
 
@@ -292,7 +285,7 @@ func TestMultiByteCapability_ConfirmedUnaffectedByTraceExclusion(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepConfirmedTrace", "repeater", recentTS(24))
+		"aabbccdd11223344", "RepConfirmedTrace", "repeater", "2026-04-11T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -307,7 +300,7 @@ func TestMultiByteCapability_ConfirmedUnaffectedByTraceExclusion(t *testing.T) {
 		RawHex:      rawHex,
 		PayloadType: &pt,
 		PathJSON:    `["aabb"]`,
-		FirstSeen:   recentTS(48),
+		FirstSeen:   "2026-04-10T00:00:00.000Z",
 	}
 	addTestPacket(store, pkt)
 
@@ -327,7 +320,7 @@ func TestMultiByteCapability_CompanionConfirmed(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "CompA", "companion", recentTS(24))
+		"aabbccdd11223344", "CompA", "companion", "2026-04-11T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 	addTestPacket(store, makeTestAdvert("aabbccdd11223344", 2))
@@ -354,11 +347,11 @@ func TestMultiByteCapability_RoleColumnPopulated(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabb000000000001", "Rep1", "repeater", recentTS(24))
+		"aabb000000000001", "Rep1", "repeater", "2026-04-11T00:00:00Z")
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"ccdd000000000002", "Comp1", "companion", recentTS(24))
+		"ccdd000000000002", "Comp1", "companion", "2026-04-11T00:00:00Z")
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"eeff000000000003", "Room1", "room_server", recentTS(24))
+		"eeff000000000003", "Room1", "room_server", "2026-04-11T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 	addTestPacket(store, makeTestAdvert("aabb000000000001", 2))
@@ -393,7 +386,7 @@ func TestMultiByteCapability_AdopterEvidenceTakesPrecedence(t *testing.T) {
 	defer db.conn.Close()
 
 	db.conn.Exec("INSERT INTO nodes (public_key, name, role, last_seen) VALUES (?, ?, ?, ?)",
-		"aabbccdd11223344", "RepAdopter", "repeater", recentTS(24))
+		"aabbccdd11223344", "RepAdopter", "repeater", "2026-04-11T00:00:00Z")
 
 	store := NewPacketStore(db, nil)
 
@@ -405,7 +398,7 @@ func TestMultiByteCapability_AdopterEvidenceTakesPrecedence(t *testing.T) {
 		RawHex:      rawHex,
 		PayloadType: &pt,
 		PathJSON:    `["aabb"]`,
-		FirstSeen:   recentTS(48),
+		FirstSeen:   "2026-04-10T00:00:00.000Z",
 	}
 	addTestPacket(store, pkt)
 

cmd/server/neighbor_api.go

@@ -94,10 +94,6 @@ func (s *Server) getNeighborGraph() *NeighborGraph {
 
 func (s *Server) handleNodeNeighbors(w http.ResponseWriter, r *http.Request) {
 	pubkey := strings.ToLower(mux.Vars(r)["pubkey"])
-	if s.cfg.IsBlacklisted(pubkey) {
-		writeError(w, 404, "Not found")
-		return
-	}
 
 	minCount := 1
 	if v := r.URL.Query().Get("min_count"); v != "" {
@@ -276,11 +272,6 @@ func (s *Server) handleNeighborGraph(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 
-		// Filter blacklisted nodes from graph.
-		if s.cfg != nil && (s.cfg.IsBlacklisted(e.NodeA) || s.cfg.IsBlacklisted(e.NodeB)) {
-			continue
-		}
-
 		ge := GraphEdge{
 			Source:        e.NodeA,
 			Target:        e.NodeB,

cmd/server/neighbor_dedup_test.go

@@ -12,9 +12,9 @@ import (
 func TestResolveAmbiguousEdges_GeoProximity(t *testing.T) {
 	// Node A at lat=45, lon=-122. Candidate B1 at lat=45.1, lon=-122.1 (close).
 	// Candidate B2 at lat=10, lon=10 (far away). Prefix "b0" matches both.
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
-	nodeB1 := nodeInfo{Role: "repeater", PublicKey: "b0b1eeee", Name: "CloseNode", HasGPS: true, Lat: 45.1, Lon: -122.1}
-	nodeB2 := nodeInfo{Role: "repeater", PublicKey: "b0c2ffff", Name: "FarNode", HasGPS: true, Lat: 10.0, Lon: 10.0}
+	nodeA := nodeInfo{PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
+	nodeB1 := nodeInfo{PublicKey: "b0b1eeee", Name: "CloseNode", HasGPS: true, Lat: 45.1, Lon: -122.1}
+	nodeB2 := nodeInfo{PublicKey: "b0c2ffff", Name: "FarNode", HasGPS: true, Lat: 10.0, Lon: 10.0}
 
 	pm := buildPrefixMap([]nodeInfo{nodeA, nodeB1, nodeB2})
 
@@ -62,8 +62,8 @@ func TestResolveAmbiguousEdges_GeoProximity(t *testing.T) {
 
 // Test 2: Ambiguous edge merged with existing resolved edge (count accumulation).
 func TestResolveAmbiguousEdges_MergeWithExisting(t *testing.T) {
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
-	nodeB := nodeInfo{Role: "repeater", PublicKey: "b0b1eeee", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
+	nodeA := nodeInfo{PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
+	nodeB := nodeInfo{PublicKey: "b0b1eeee", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
 
 	pm := buildPrefixMap([]nodeInfo{nodeA, nodeB})
 
@@ -133,9 +133,9 @@ func TestResolveAmbiguousEdges_MergeWithExisting(t *testing.T) {
 // Test 3: Ambiguous edge left as-is when resolution fails.
 func TestResolveAmbiguousEdges_FailsNoChange(t *testing.T) {
 	// Two candidates, neither has GPS, no affinity data — resolution falls through.
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA"}
-	nodeB1 := nodeInfo{Role: "repeater", PublicKey: "b0b1eeee", Name: "B1"}
-	nodeB2 := nodeInfo{Role: "repeater", PublicKey: "b0c2ffff", Name: "B2"}
+	nodeA := nodeInfo{PublicKey: "aaaa1111", Name: "NodeA"}
+	nodeB1 := nodeInfo{PublicKey: "b0b1eeee", Name: "B1"}
+	nodeB2 := nodeInfo{PublicKey: "b0c2ffff", Name: "B2"}
 
 	pm := buildPrefixMap([]nodeInfo{nodeA, nodeB1, nodeB2})
 
@@ -175,7 +175,7 @@ func TestResolveAmbiguousEdges_FailsNoChange(t *testing.T) {
 
 // Test 3 (corrected): Resolution fails when prefix has no candidates in prefix map.
 func TestResolveAmbiguousEdges_NoMatch(t *testing.T) {
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA"}
+	nodeA := nodeInfo{PublicKey: "aaaa1111", Name: "NodeA"}
 	// pm has no entries matching prefix "zz"
 	pm := buildPrefixMap([]nodeInfo{nodeA})
 
@@ -215,8 +215,8 @@ func TestResolveAmbiguousEdges_NoMatch(t *testing.T) {
 // Test 6: Phase 1 edge collection unchanged (no regression).
 func TestPhase1EdgeCollection_Unchanged(t *testing.T) {
 	// Build a simple graph and verify non-ambiguous edges are not touched.
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
-	nodeB := nodeInfo{Role: "repeater", PublicKey: "bbbb2222", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
+	nodeA := nodeInfo{PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
+	nodeB := nodeInfo{PublicKey: "bbbb2222", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
 
 	ts := time.Now().UTC().Format(time.RFC3339)
 	payloadType := 4
@@ -232,7 +232,7 @@ func TestPhase1EdgeCollection_Unchanged(t *testing.T) {
 		Observations: obs,
 	}
 
-	store := ngTestStore([]nodeInfo{nodeA, nodeB, {Role: "repeater", PublicKey: "cccc3333", Name: "Observer"}}, []*StoreTx{tx})
+	store := ngTestStore([]nodeInfo{nodeA, nodeB, {PublicKey: "cccc3333", Name: "Observer"}}, []*StoreTx{tx})
 	graph := BuildFromStore(store)
 
 	edges := graph.Neighbors("aaaa1111")
@@ -255,8 +255,8 @@ func TestPhase1EdgeCollection_Unchanged(t *testing.T) {
 
 // Test 7: Merge preserves higher LastSeen timestamp.
 func TestResolveAmbiguousEdges_PreservesHigherLastSeen(t *testing.T) {
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
-	nodeB := nodeInfo{Role: "repeater", PublicKey: "b0b1eeee", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
+	nodeA := nodeInfo{PublicKey: "aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
+	nodeB := nodeInfo{PublicKey: "b0b1eeee", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
 	pm := buildPrefixMap([]nodeInfo{nodeA, nodeB})
 
 	graph := NewNeighborGraph()
@@ -307,10 +307,10 @@ func TestResolveAmbiguousEdges_PreservesHigherLastSeen(t *testing.T) {
 
 // Test 5: Integration — node with both 1-byte and 2-byte prefix observations shows single entry.
 func TestIntegration_DualPrefixSingleNeighbor(t *testing.T) {
-	nodeA := nodeInfo{Role: "repeater", PublicKey: "aaaa1111aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
-	nodeB := nodeInfo{Role: "repeater", PublicKey: "b0b1eeeeb0b1eeee", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
-	nodeB2 := nodeInfo{Role: "repeater", PublicKey: "b0c2ffffb0c2ffff", Name: "NodeB2", HasGPS: true, Lat: 10.0, Lon: 10.0}
-	observer := nodeInfo{Role: "repeater", PublicKey: "cccc3333cccc3333", Name: "Observer"}
+	nodeA := nodeInfo{PublicKey: "aaaa1111aaaa1111", Name: "NodeA", HasGPS: true, Lat: 45.0, Lon: -122.0}
+	nodeB := nodeInfo{PublicKey: "b0b1eeeeb0b1eeee", Name: "NodeB", HasGPS: true, Lat: 45.1, Lon: -122.1}
+	nodeB2 := nodeInfo{PublicKey: "b0c2ffffb0c2ffff", Name: "NodeB2", HasGPS: true, Lat: 10.0, Lon: 10.0}
+	observer := nodeInfo{PublicKey: "cccc3333cccc3333", Name: "Observer"}
 
 	ts := time.Now().UTC().Format(time.RFC3339)
 	pt := 4

cmd/server/neighbor_graph_test.go

@@ -86,9 +86,9 @@ func TestBuildNeighborGraph_EmptyStore(t *testing.T) {
 func TestBuildNeighborGraph_AdvertSingleHopPath(t *testing.T) {
 	// ADVERT from X, path=["R1_prefix"] → edges: X↔R1 and Observer↔R1
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["r1aa"]`, nowStr, ngFloatPtr(-10)),
@@ -132,10 +132,10 @@ func TestBuildNeighborGraph_AdvertSingleHopPath(t *testing.T) {
 func TestBuildNeighborGraph_AdvertMultiHopPath(t *testing.T) {
 	// ADVERT from X, path=["R1","R2"] → X↔R1 and Observer↔R2
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "r2ddeeff", Name: "R2"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "r2ddeeff", Name: "R2"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["r1aa","r2dd"]`, nowStr, nil),
@@ -170,8 +170,8 @@ func TestBuildNeighborGraph_AdvertMultiHopPath(t *testing.T) {
 func TestBuildNeighborGraph_AdvertZeroHop(t *testing.T) {
 	// ADVERT from X, path=[] → X↔Observer direct edge
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `[]`, nowStr, nil),
@@ -195,8 +195,8 @@ func TestBuildNeighborGraph_AdvertZeroHop(t *testing.T) {
 func TestBuildNeighborGraph_NonAdvertEmptyPath(t *testing.T) {
 	// Non-ADVERT, path=[] → no edges
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `[]`, nowStr, nil),
@@ -212,10 +212,10 @@ func TestBuildNeighborGraph_NonAdvertEmptyPath(t *testing.T) {
 func TestBuildNeighborGraph_NonAdvertOnlyObserverEdge(t *testing.T) {
 	// Non-ADVERT with path=["R1","R2"] → only Observer↔R2, NO originator edge
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "r2ddeeff", Name: "R2"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "r2ddeeff", Name: "R2"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["r1aa","r2dd"]`, nowStr, nil),
@@ -236,9 +236,9 @@ func TestBuildNeighborGraph_NonAdvertOnlyObserverEdge(t *testing.T) {
 func TestBuildNeighborGraph_NonAdvertSingleHop(t *testing.T) {
 	// Non-ADVERT with path=["R1"] → Observer↔R1 only
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["r1aa"]`, nowStr, nil),
@@ -259,10 +259,10 @@ func TestBuildNeighborGraph_NonAdvertSingleHop(t *testing.T) {
 func TestBuildNeighborGraph_HashCollision(t *testing.T) {
 	// Two nodes share prefix "a3" → ambiguous edge
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "a3bb1111", Name: "CandidateA"},
-		{Role: "repeater", PublicKey: "a3bb2222", Name: "CandidateB"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "a3bb1111", Name: "CandidateA"},
+		{PublicKey: "a3bb2222", Name: "CandidateB"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["a3bb"]`, nowStr, nil),
@@ -308,13 +308,13 @@ func TestBuildNeighborGraph_ConfidenceAutoResolve(t *testing.T) {
 	// CandidateB has no known neighbors (Jaccard = 0).
 	// An ambiguous edge X↔prefix "a3" with candidates [A, B] should auto-resolve to A.
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "n1111111", Name: "N1"},
-		{Role: "repeater", PublicKey: "n2222222", Name: "N2"},
-		{Role: "repeater", PublicKey: "n3333333", Name: "N3"},
-		{Role: "repeater", PublicKey: "a3001111", Name: "CandidateA"},
-		{Role: "repeater", PublicKey: "a3002222", Name: "CandidateB"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "n1111111", Name: "N1"},
+		{PublicKey: "n2222222", Name: "N2"},
+		{PublicKey: "n3333333", Name: "N3"},
+		{PublicKey: "a3001111", Name: "CandidateA"},
+		{PublicKey: "a3002222", Name: "CandidateB"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 
 	// Create resolved edges: X↔N1, X↔N2, X↔N3, A↔N1, A↔N2, A↔N3
@@ -373,11 +373,11 @@ func TestBuildNeighborGraph_ConfidenceAutoResolve(t *testing.T) {
 func TestBuildNeighborGraph_EqualScoresAmbiguous(t *testing.T) {
 	// Two candidates with identical neighbor sets → should NOT auto-resolve.
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "n1111111", Name: "N1"},
-		{Role: "repeater", PublicKey: "a3001111", Name: "CandidateA"},
-		{Role: "repeater", PublicKey: "a3002222", Name: "CandidateB"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "n1111111", Name: "N1"},
+		{PublicKey: "a3001111", Name: "CandidateA"},
+		{PublicKey: "a3002222", Name: "CandidateB"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 
 	var txs []*StoreTx
@@ -425,8 +425,8 @@ func TestBuildNeighborGraph_EqualScoresAmbiguous(t *testing.T) {
 func TestBuildNeighborGraph_ObserverSelfEdgeGuard(t *testing.T) {
 	// Observer's own prefix in path → should NOT create self-edge.
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["obs0"]`, nowStr, nil),
@@ -445,8 +445,8 @@ func TestBuildNeighborGraph_ObserverSelfEdgeGuard(t *testing.T) {
 func TestBuildNeighborGraph_OrphanPrefix(t *testing.T) {
 	// Path contains prefix matching zero nodes → edge recorded as unresolved.
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["ff99"]`, nowStr, nil),
@@ -506,9 +506,9 @@ func TestAffinityScore_StaleAndLow(t *testing.T) {
 
 func TestBuildNeighborGraph_CountAccumulation(t *testing.T) {
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 
 	var txs []*StoreTx
@@ -535,10 +535,10 @@ func TestBuildNeighborGraph_CountAccumulation(t *testing.T) {
 
 func TestBuildNeighborGraph_MultipleObservers(t *testing.T) {
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Obs1"},
-		{Role: "repeater", PublicKey: "obs00002", Name: "Obs2"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Obs1"},
+		{PublicKey: "obs00002", Name: "Obs2"},
 	}
 
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
@@ -565,9 +565,9 @@ func TestBuildNeighborGraph_MultipleObservers(t *testing.T) {
 
 func TestBuildNeighborGraph_TimeDecayOldObservations(t *testing.T) {
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 
 	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
@@ -592,10 +592,10 @@ func TestBuildNeighborGraph_TimeDecayOldObservations(t *testing.T) {
 func TestBuildNeighborGraph_ADVERTOnlyConstraint(t *testing.T) {
 	// Non-ADVERT: should NOT create originator↔path[0] edge, only observer↔path[last].
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeX"},
-		{Role: "repeater", PublicKey: "r1aabbcc", Name: "R1"},
-		{Role: "repeater", PublicKey: "r2ddeeff", Name: "R2"},
-		{Role: "repeater", PublicKey: "obs00001", Name: "Observer"},
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "r2ddeeff", Name: "R2"},
+		{PublicKey: "obs00001", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
 		ngMakeObs("obs00001", `["r1aa","r2dd"]`, nowStr, nil),
@@ -631,9 +631,9 @@ func ngPubKeyJSON(pubkey string) string {
 func TestBuildNeighborGraph_AdvertPubKeyField(t *testing.T) {
 	// Real ADVERTs use "pubKey", not "from_node". Verify the builder handles it.
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234", Name: "Originator"},
-		{Role: "repeater", PublicKey: "r1aabbccdd001122334455667788990011223344556677889900112233445566", Name: "R1"},
-		{Role: "repeater", PublicKey: "obs0000100112233445566778899001122334455667788990011223344556677", Name: "Observer"},
+		{PublicKey: "99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234", Name: "Originator"},
+		{PublicKey: "r1aabbccdd001122334455667788990011223344556677889900112233445566", Name: "R1"},
+		{PublicKey: "obs0000100112233445566778899001122334455667788990011223344556677", Name: "Observer"},
 	}
 	tx := ngMakeTx(1, 4, ngPubKeyJSON("99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234"), []*StoreObs{
 		ngMakeObs("obs0000100112233445566778899001122334455667788990011223344556677", `["r1"]`, nowStr, ngFloatPtr(-8.5)),
@@ -666,10 +666,10 @@ func TestBuildNeighborGraph_OneByteHashPrefixes(t *testing.T) {
 	// Real-world scenario: 1-byte hash prefixes with multiple candidates.
 	// Should create edges (possibly ambiguous) rather than empty graph.
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "c0dedad400000000000000000000000000000000000000000000000000000001", Name: "NodeC0-1"},
-		{Role: "repeater", PublicKey: "c0dedad900000000000000000000000000000000000000000000000000000002", Name: "NodeC0-2"},
-		{Role: "repeater", PublicKey: "a3bbccdd00000000000000000000000000000000000000000000000000000003", Name: "Originator"},
-		{Role: "repeater", PublicKey: "obs1234500000000000000000000000000000000000000000000000000000004", Name: "Observer"},
+		{PublicKey: "c0dedad400000000000000000000000000000000000000000000000000000001", Name: "NodeC0-1"},
+		{PublicKey: "c0dedad900000000000000000000000000000000000000000000000000000002", Name: "NodeC0-2"},
+		{PublicKey: "a3bbccdd00000000000000000000000000000000000000000000000000000003", Name: "Originator"},
+		{PublicKey: "obs1234500000000000000000000000000000000000000000000000000000004", Name: "Observer"},
 	}
 	// ADVERT from Originator with 1-byte path hop "c0"
 	tx := ngMakeTx(1, 4, ngPubKeyJSON("a3bbccdd00000000000000000000000000000000000000000000000000000003"), []*StoreObs{
@@ -809,10 +809,10 @@ func TestExtractFromNode_UsesCachedParse(t *testing.T) {
 func BenchmarkBuildFromStore(b *testing.B) {
 	// Simulate a dataset with many packets and repeated pubkeys
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aaaa1111", Name: "NodeA"},
-		{Role: "repeater", PublicKey: "bbbb2222", Name: "NodeB"},
-		{Role: "repeater", PublicKey: "cccc3333", Name: "NodeC"},
-		{Role: "repeater", PublicKey: "dddd4444", Name: "NodeD"},
+		{PublicKey: "aaaa1111", Name: "NodeA"},
+		{PublicKey: "bbbb2222", Name: "NodeB"},
+		{PublicKey: "cccc3333", Name: "NodeC"},
+		{PublicKey: "dddd4444", Name: "NodeD"},
 	}
 	const numPackets = 1000
 	packets := make([]*StoreTx, 0, numPackets)

cmd/server/neighbor_persist.go

@@ -381,13 +381,7 @@ func backfillResolvedPathsAsync(store *PacketStore, dbPath string, chunkSize int
 			}
 		}
 		for _, obs := range tx.Observations {
-			// Check if this observation has been resolved: look up in the index.
-			// If the tx has no reverse-map entries AND path is non-empty, it needs backfill.
-			hasRP := false
-			if _, ok := store.resolvedPubkeyReverse[tx.ID]; ok {
-				hasRP = true
-			}
-			if !hasRP && obs.PathJSON != "" && obs.PathJSON != "[]" {
+			if obs.ResolvedPath == nil && obs.PathJSON != "" && obs.PathJSON != "[]" {
 				allPending = append(allPending, obsRef{
 					obsID:       obs.ID,
 					pathJSON:    obs.PathJSON,
@@ -488,61 +482,24 @@ func backfillResolvedPathsAsync(store *PacketStore, dbPath string, chunkSize int
 				}
 			}
 
-			// Update in-memory state: update resolved pubkey index, re-pick best observation,
-			// and invalidate LRU cache entries for backfilled observations (#800).
-			//
-			// Lock ordering: always take s.mu BEFORE lruMu. The read path
-			// (fetchResolvedPathForObs) takes lruMu independently of s.mu,
-			// so we must NOT hold s.mu while taking lruMu. Instead, collect
-			// obsIDs to invalidate under s.mu, release it, then take lruMu.
+			// Update in-memory state and re-pick best observation under a single
+			// write lock. The per-tx pickBestObservation is O(observations) which is
+			// typically <10 per tx — negligible cost vs. the race risk of splitting
+			// the lock (pollAndMerge can append to tx.Observations concurrently).
 			store.mu.Lock()
 			affectedSet := make(map[string]bool)
-			lruInvalidate := make([]int, 0, len(results))
 			for _, r := range results {
-				// Remove old index entries for this tx, then re-add with new pubkeys
+				if obs, ok := store.byObsID[r.obsID]; ok {
+					obs.ResolvedPath = r.rp
+				}
 				if !affectedSet[r.txHash] {
 					affectedSet[r.txHash] = true
 					if tx, ok := store.byHash[r.txHash]; ok {
-						store.removeFromResolvedPubkeyIndex(tx.ID)
+						pickBestObservation(tx)
 					}
 				}
-				// Add new resolved pubkeys to index
-				if tx, ok := store.byHash[r.txHash]; ok {
-					pks := extractResolvedPubkeys(r.rp)
-					store.addToResolvedPubkeyIndex(tx.ID, pks)
-					// Update byNode for relay nodes
-					for _, pk := range pks {
-						store.addToByNode(tx, pk)
-					}
-					// Update byPathHop resolved-key entries
-					hopsSeen := make(map[string]bool)
-					for _, hop := range txGetParsedPath(tx) {
-						hopsSeen[strings.ToLower(hop)] = true
-					}
-					for _, pk := range pks {
-						if !hopsSeen[pk] {
-							hopsSeen[pk] = true
-							store.byPathHop[pk] = append(store.byPathHop[pk], tx)
-						}
-					}
-				}
-				lruInvalidate = append(lruInvalidate, r.obsID)
-			}
-			// Re-pick best observation for affected transmissions
-			for txHash := range affectedSet {
-				if tx, ok := store.byHash[txHash]; ok {
-					pickBestObservation(tx)
-				}
 			}
 			store.mu.Unlock()
-
-			// Invalidate LRU entries AFTER releasing s.mu to maintain lock
-			// ordering (lruMu must never be taken while s.mu is held).
-			store.lruMu.Lock()
-			for _, obsID := range lruInvalidate {
-				store.lruDelete(obsID)
-			}
-			store.lruMu.Unlock()
 		}
 
 		totalProcessed += len(chunk)

cmd/server/neighbor_persist_test.go

@@ -38,7 +38,7 @@ func createTestDBWithSchema(t *testing.T) (*DB, string) {
 		observer_id TEXT, observer_name TEXT, direction TEXT,
 		snr REAL, rssi REAL, score INTEGER,
 		path_json TEXT, timestamp TEXT,
-		resolved_path TEXT, raw_hex TEXT
+		resolved_path TEXT
 	)`)
 	conn.Exec(`CREATE TABLE nodes (
 		public_key TEXT PRIMARY KEY, name TEXT, role TEXT,
@@ -58,8 +58,8 @@ func createTestDBWithSchema(t *testing.T) (*DB, string) {
 func TestResolvePathForObs(t *testing.T) {
 	// Build a prefix map with known nodes
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
-		{Role: "repeater", PublicKey: "bbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb11", Name: "Node-BB"},
+		{PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
+		{PublicKey: "bbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb11", Name: "Node-BB"},
 	}
 	pm := buildPrefixMap(nodes)
 	graph := NewNeighborGraph()
@@ -97,7 +97,7 @@ func TestResolvePathForObs_EmptyPath(t *testing.T) {
 
 func TestResolvePathForObs_Unresolvable(t *testing.T) {
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
+		{PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
 	}
 	pm := buildPrefixMap(nodes)
 
@@ -203,14 +203,14 @@ func TestLoadNeighborEdgesFromDB(t *testing.T) {
 }
 
 func TestStoreObsResolvedPathInBroadcast(t *testing.T) {
-	// After #800 refactor, resolved_path is no longer stored on StoreTx/StoreObs structs.
-	// Broadcast maps carry resolved_path from the decode-window, not from struct fields.
-	// This test verifies pickBestObservation no longer sets ResolvedPath on tx.
+	// Verify resolved_path appears in broadcast maps
+	pk := "aabbccdd"
 	obs := &StoreObs{
 		ID:           1,
 		ObserverID:   "obs1",
 		ObserverName: "Observer 1",
 		PathJSON:     `["aa"]`,
+		ResolvedPath: []*string{&pk},
 		Timestamp:    "2024-01-01T00:00:00Z",
 	}
 
@@ -221,26 +221,32 @@ func TestStoreObsResolvedPathInBroadcast(t *testing.T) {
 	}
 	pickBestObservation(tx)
 
-	// tx should NOT have a ResolvedPath field anymore (compile-time guard)
-	// Verify the best observation's fields are propagated correctly
-	if tx.ObserverID != "obs1" {
-		t.Errorf("expected ObserverID=obs1, got %s", tx.ObserverID)
+	if tx.ResolvedPath == nil {
+		t.Fatal("expected ResolvedPath to be set on tx after pickBestObservation")
+	}
+	if *tx.ResolvedPath[0] != "aabbccdd" {
+		t.Errorf("expected resolved path to be aabbccdd, got %s", *tx.ResolvedPath[0])
 	}
 }
 
 func TestResolvedPathInTxToMap(t *testing.T) {
-	// After #800, txToMap no longer includes resolved_path from the struct.
-	// resolved_path is only available via on-demand SQL fetch (txToMapWithRP).
+	pk := "aabbccdd"
 	tx := &StoreTx{
-		ID:       1,
-		Hash:     "abc123",
-		PathJSON: `["aa"]`,
-		obsKeys:  make(map[string]bool),
+		ID:           1,
+		Hash:         "abc123",
+		PathJSON:     `["aa"]`,
+		ResolvedPath: []*string{&pk},
+		obsKeys:      make(map[string]bool),
 	}
 
 	m := txToMap(tx)
-	if _, ok := m["resolved_path"]; ok {
-		t.Error("resolved_path should not be in txToMap output (removed in #800)")
+	rp, ok := m["resolved_path"]
+	if !ok {
+		t.Fatal("resolved_path not in txToMap output")
+	}
+	rpSlice, ok := rp.([]*string)
+	if !ok || len(rpSlice) != 1 || *rpSlice[0] != "aabbccdd" {
+		t.Errorf("unexpected resolved_path: %v", rp)
 	}
 }
 
@@ -264,7 +270,7 @@ func TestEnsureResolvedPathColumn(t *testing.T) {
 	conn, _ := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
 	conn.Exec(`CREATE TABLE observations (
 		id INTEGER PRIMARY KEY, transmission_id INTEGER,
-		observer_id TEXT, path_json TEXT, timestamp TEXT, raw_hex TEXT
+		observer_id TEXT, path_json TEXT, timestamp TEXT
 	)`)
 	conn.Close()
 
@@ -359,21 +365,27 @@ func TestLoadWithResolvedPath(t *testing.T) {
 		t.Fatalf("expected 1 observation, got %d", len(tx.Observations))
 	}
 
-	// After #800, ResolvedPath is not stored on StoreObs struct.
-	// Instead, resolved pubkeys are in the membership index.
-	_ = tx.Observations[0] // obs exists
-	h := resolvedPubkeyHash("aabbccdd")
-	if len(store.resolvedPubkeyIndex[h]) != 1 {
-		t.Fatal("expected resolved pubkey to be indexed")
+	obs := tx.Observations[0]
+	if obs.ResolvedPath == nil {
+		t.Fatal("expected ResolvedPath to be loaded")
+	}
+	if len(obs.ResolvedPath) != 1 || *obs.ResolvedPath[0] != "aabbccdd" {
+		t.Errorf("unexpected ResolvedPath: %v", obs.ResolvedPath)
+	}
+
+	// Check that pickBestObservation propagated resolved_path to tx
+	if tx.ResolvedPath == nil || len(tx.ResolvedPath) != 1 {
+		t.Error("expected ResolvedPath to be propagated to tx")
 	}
 }
 
 func TestResolvedPathInAPIResponse(t *testing.T) {
-	// After #800, TransmissionResp no longer has ResolvedPath field.
-	// resolved_path is included dynamically in map-based API responses.
+	// Test that TransmissionResp properly marshals resolved_path
+	pk := "aabbccddee"
 	resp := TransmissionResp{
-		ID:   1,
-		Hash: "test",
+		ID:           1,
+		Hash:         "test",
+		ResolvedPath: []*string{&pk, nil},
 	}
 
 	data, err := json.Marshal(resp)
@@ -384,9 +396,19 @@ func TestResolvedPathInAPIResponse(t *testing.T) {
 	var m map[string]interface{}
 	json.Unmarshal(data, &m)
 
-	// resolved_path should NOT be in the marshaled JSON
-	if _, ok := m["resolved_path"]; ok {
-		t.Error("resolved_path should not be in TransmissionResp JSON (#800)")
+	rp, ok := m["resolved_path"]
+	if !ok {
+		t.Fatal("resolved_path missing from JSON")
+	}
+	rpArr, ok := rp.([]interface{})
+	if !ok || len(rpArr) != 2 {
+		t.Fatalf("unexpected resolved_path shape: %v", rp)
+	}
+	if rpArr[0] != "aabbccddee" {
+		t.Errorf("first element wrong: %v", rpArr[0])
+	}
+	if rpArr[1] != nil {
+		t.Errorf("second element should be null: %v", rpArr[1])
 	}
 }
 
@@ -437,8 +459,8 @@ func TestExtractEdgesFromObs_NonAdvertNoPath(t *testing.T) {
 
 func TestExtractEdgesFromObs_WithPath(t *testing.T) {
 	nodes := []nodeInfo{
-		{Role: "repeater", PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
-		{Role: "repeater", PublicKey: "ffgghhii1234567890aabbccddee1234567890aabbccddee1234567890aabb11", Name: "Node-FF"},
+		{PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
+		{PublicKey: "ffgghhii1234567890aabbccddee1234567890aabbccddee1234567890aabb11", Name: "Node-FF"},
 	}
 	pm := buildPrefixMap(nodes)
 

cmd/server/node_blacklist_test.go

@@ -1,311 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/gorilla/mux"
-)
-
-func TestConfigIsBlacklisted(t *testing.T) {
-	cfg := &Config{
-		NodeBlacklist: []string{"AA", "BB", "cc"},
-	}
-
-	tests := []struct {
-		pubkey    string
-		want      bool
-	}{
-		{"AA", true},
-		{"aa", true},   // case-insensitive
-		{"BB", true},
-		{"CC", true},   // lowercase "cc" matches uppercase
-		{"DD", false},
-		{"", false},
-		{"AAB", false},
-	}
-
-	for _, tt := range tests {
-		got := cfg.IsBlacklisted(tt.pubkey)
-		if got != tt.want {
-			t.Errorf("IsBlacklisted(%q) = %v, want %v", tt.pubkey, got, tt.want)
-		}
-	}
-}
-
-func TestConfigIsBlacklistedEmpty(t *testing.T) {
-	cfg := &Config{}
-	if cfg.IsBlacklisted("anything") {
-		t.Error("empty blacklist should not match anything")
-	}
-	if cfg.IsBlacklisted("") {
-		t.Error("empty blacklist should not match empty string")
-	}
-}
-
-func TestConfigBlacklistWhitespace(t *testing.T) {
-	cfg := &Config{
-		NodeBlacklist: []string{"  AA  ", "BB"},
-	}
-	if !cfg.IsBlacklisted("AA") {
-		t.Error("trimmed key should match")
-	}
-	if !cfg.IsBlacklisted("  AA  ") {
-		t.Error("whitespace-padded key should match after trimming")
-	}
-}
-
-func TestConfigBlacklistEmptyEntries(t *testing.T) {
-	cfg := &Config{
-		NodeBlacklist: []string{"", "  ", "AA"},
-	}
-	if !cfg.IsBlacklisted("AA") {
-		t.Error("non-empty entry should match")
-	}
-	if cfg.IsBlacklisted("") {
-		t.Error("empty blacklist entry should not match empty pubkey")
-	}
-}
-
-func TestBlacklistFiltersHandleNodes(t *testing.T) {
-	db := setupTestDB(t)
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('goodnode', 'GoodNode', 'companion', datetime('now'))")
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('badnode', 'BadNode', 'companion', datetime('now'))")
-
-	cfg := &Config{
-		NodeBlacklist: []string{"badnode"},
-	}
-	srv := NewServer(db, cfg, NewHub())
-
-	req := httptest.NewRequest("GET", "/api/nodes?limit=50", nil)
-	w := httptest.NewRecorder()
-	srv.RegisterRoutes(setupTestRouter(srv))
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	var resp NodeListResponse
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse response: %v", err)
-	}
-
-	for _, node := range resp.Nodes {
-		if pk, _ := node["public_key"].(string); pk == "badnode" {
-			t.Error("blacklisted node should not appear in nodes list")
-		}
-	}
-	if resp.Total == 0 {
-		t.Error("expected at least one non-blacklisted node")
-	}
-}
-
-func TestBlacklistFiltersNodeDetail(t *testing.T) {
-	db := setupTestDB(t)
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('badnode', 'BadNode', 'companion', datetime('now'))")
-
-	cfg := &Config{
-		NodeBlacklist: []string{"badnode"},
-	}
-	srv := NewServer(db, cfg, NewHub())
-
-	req := httptest.NewRequest("GET", "/api/nodes/badnode", nil)
-	w := httptest.NewRecorder()
-	srv.RegisterRoutes(setupTestRouter(srv))
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404 for blacklisted node, got %d", w.Code)
-	}
-}
-
-func TestBlacklistFiltersNodeSearch(t *testing.T) {
-	db := setupTestDB(t)
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('badnode', 'TrollNode', 'companion', datetime('now'))")
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('goodnode', 'GoodNode', 'companion', datetime('now'))")
-
-	cfg := &Config{
-		NodeBlacklist: []string{"badnode"},
-	}
-	srv := NewServer(db, cfg, NewHub())
-
-	req := httptest.NewRequest("GET", "/api/nodes/search?q=Troll", nil)
-	w := httptest.NewRecorder()
-	srv.RegisterRoutes(setupTestRouter(srv))
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-
-	var resp NodeSearchResponse
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse response: %v", err)
-	}
-
-	for _, node := range resp.Nodes {
-		if pk, _ := node["public_key"].(string); pk == "badnode" {
-			t.Error("blacklisted node should not appear in search results")
-		}
-	}
-}
-
-func TestNoBlacklistPassesAll(t *testing.T) {
-	db := setupTestDB(t)
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('somenode', 'SomeNode', 'companion', datetime('now'))")
-
-	cfg := &Config{}
-	srv := NewServer(db, cfg, NewHub())
-
-	req := httptest.NewRequest("GET", "/api/nodes?limit=50", nil)
-	w := httptest.NewRecorder()
-	srv.RegisterRoutes(setupTestRouter(srv))
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-
-	var resp NodeListResponse
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse response: %v", err)
-	}
-	if resp.Total == 0 {
-		t.Error("without blacklist, node should appear")
-	}
-}
-
-// setupTestRouter creates a mux.Router and registers server routes.
-func setupTestRouter(srv *Server) *mux.Router {
-	r := mux.NewRouter()
-	srv.RegisterRoutes(r)
-	srv.router = r
-	return r
-}
-func TestBlacklistFiltersNeighborGraph(t *testing.T) {
-	cfg := &Config{
-		NodeBlacklist: []string{"badnode"},
-	}
-	db := setupTestDB(t)
-	srv := NewServer(db, cfg, NewHub())
-	srv.RegisterRoutes(setupTestRouter(srv))
-
-	req := httptest.NewRequest("GET", "/api/analytics/neighbor-graph", nil)
-	w := httptest.NewRecorder()
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse response: %v", err)
-	}
-
-	// Check edges don't contain blacklisted node
-	if edges, ok := resp["edges"].([]interface{}); ok {
-		for _, e := range edges {
-			if edge, ok := e.(map[string]interface{}); ok {
-				if src, _ := edge["source"].(string); src == "badnode" {
-					t.Error("blacklisted node should not appear as edge source in neighbor graph")
-				}
-				if tgt, _ := edge["target"].(string); tgt == "badnode" {
-					t.Error("blacklisted node should not appear as edge target in neighbor graph")
-				}
-			}
-		}
-	}
-
-	// Check nodes list doesn't contain blacklisted node
-	if nodes, ok := resp["nodes"].([]interface{}); ok {
-		for _, n := range nodes {
-			if node, ok := n.(map[string]interface{}); ok {
-				if pk, _ := node["pubkey"].(string); pk == "badnode" {
-					t.Error("blacklisted node should not appear in neighbor graph nodes")
-				}
-			}
-		}
-	}
-}
-
-func TestBlacklistFiltersResolveHops(t *testing.T) {
-	db := setupTestDB(t)
-	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen) VALUES ('badnode', 'BadNode', 'companion', datetime('now'))")
-
-	cfg := &Config{
-		NodeBlacklist: []string{"badnode"},
-	}
-	srv := NewServer(db, cfg, NewHub())
-	srv.RegisterRoutes(setupTestRouter(srv))
-
-	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=badnode", nil)
-	w := httptest.NewRecorder()
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	var resp ResolveHopsResponse
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse response: %v", err)
-	}
-
-	if hr, ok := resp.Resolved["badnode"]; ok {
-		for _, c := range hr.Candidates {
-			if c.Pubkey == "badnode" {
-				t.Error("blacklisted node should not appear as resolve-hops candidate")
-			}
-		}
-	}
-}
-
-func TestBlacklistFiltersSubpathDetail(t *testing.T) {
-	cfg := &Config{
-		NodeBlacklist: []string{"badnode"},
-	}
-	db := setupTestDB(t)
-	srv := NewServer(db, cfg, NewHub())
-	srv.RegisterRoutes(setupTestRouter(srv))
-
-	req := httptest.NewRequest("GET", "/api/analytics/subpath-detail?hops=badnode,othernode", nil)
-	w := httptest.NewRecorder()
-	srv.router.ServeHTTP(w, req)
-
-	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404 for subpath-detail with blacklisted hop, got %d", w.Code)
-	}
-}
-
-func TestBlacklistConcurrentIsBlacklisted(t *testing.T) {
-	cfg := &Config{
-		NodeBlacklist: []string{"AA", "BB", "CC"},
-	}
-
-	errc := make(chan error, 100)
-	for i := 0; i < 100; i++ {
-		go func() {
-			for j := 0; j < 100; j++ {
-				cfg.IsBlacklisted("AA")
-				cfg.IsBlacklisted("BB")
-				cfg.IsBlacklisted("DD")
-			}
-		}()
-	}
-
-	// If sync.Once is wrong, this would panic or race.
-	// We can't run the race detector on ARM, but at least verify no panics.
-	done := false
-	for !done {
-		select {
-		case <-errc:
-			t.Error("concurrent IsBlacklisted panicked")
-		default:
-			done = true
-		}
-	}
-}

cmd/server/path_inspect.go

@@ -1,427 +0,0 @@
-package main
-
-import (
-	"encoding/hex"
-	"encoding/json"
-	"math"
-	"net/http"
-	"sort"
-	"strings"
-	"time"
-)
-
-// ─── Path Inspector ────────────────────────────────────────────────────────────
-// POST /api/paths/inspect — beam-search scorer for prefix path candidates.
-// Spec: issue #944 §2.1–2.5.
-
-// pathInspectRequest is the JSON body for the inspect endpoint.
-type pathInspectRequest struct {
-	Prefixes []string             `json:"prefixes"`
-	Context  *pathInspectContext  `json:"context,omitempty"`
-	Limit    int                  `json:"limit,omitempty"`
-}
-
-type pathInspectContext struct {
-	ObserverID string `json:"observerId,omitempty"`
-	Since      string `json:"since,omitempty"`
-	Until      string `json:"until,omitempty"`
-}
-
-// pathCandidate is one scored candidate path in the response.
-type pathCandidate struct {
-	Path        []string        `json:"path"`
-	Names       []string        `json:"names"`
-	Score       float64         `json:"score"`
-	Speculative bool            `json:"speculative"`
-	Evidence    pathEvidence    `json:"evidence"`
-}
-
-type pathEvidence struct {
-	PerHop []hopEvidence `json:"perHop"`
-}
-
-type hopEvidence struct {
-	Prefix               string           `json:"prefix"`
-	CandidatesConsidered int              `json:"candidatesConsidered"`
-	Chosen               string           `json:"chosen"`
-	EdgeWeight           float64          `json:"edgeWeight"`
-	Alternatives         []hopAlternative `json:"alternatives,omitempty"`
-}
-
-// hopAlternative shows a candidate that was considered but not chosen for this hop.
-type hopAlternative struct {
-	PublicKey string  `json:"publicKey"`
-	Name     string  `json:"name"`
-	Score    float64 `json:"score"`
-}
-
-type pathInspectResponse struct {
-	Candidates []pathCandidate        `json:"candidates"`
-	Input      map[string]interface{} `json:"input"`
-	Stats      map[string]interface{} `json:"stats"`
-}
-
-// beamEntry represents a partial path being extended during beam search.
-type beamEntry struct {
-	pubkeys  []string
-	names    []string
-	evidence []hopEvidence
-	score    float64 // product of per-hop scores (pre-geometric-mean)
-}
-
-const (
-	beamWidth       = 20
-	maxInputHops    = 64
-	maxPrefixBytes  = 3
-	maxRequestItems = 64
-	geoMaxKm        = 50.0
-	hopScoreFloor   = 0.05
-	speculativeThreshold = 0.7
-	inspectCacheTTL = 30 * time.Second
-	inspectBodyLimit = 4096
-)
-
-// Weights per spec §2.3.
-const (
-	wEdge        = 0.35
-	wGeo         = 0.20
-	wRecency     = 0.15
-	wSelectivity = 0.30
-)
-
-func (s *Server) handlePathInspect(w http.ResponseWriter, r *http.Request) {
-	// Body limit per spec §2.1.
-	r.Body = http.MaxBytesReader(w, r.Body, inspectBodyLimit)
-
-	var req pathInspectRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, `{"error":"invalid JSON"}`, http.StatusBadRequest)
-		return
-	}
-
-	// Validate prefixes.
-	if len(req.Prefixes) == 0 {
-		http.Error(w, `{"error":"prefixes required"}`, http.StatusBadRequest)
-		return
-	}
-	if len(req.Prefixes) > maxRequestItems {
-		http.Error(w, `{"error":"too many prefixes (max 64)"}`, http.StatusBadRequest)
-		return
-	}
-
-	// Normalize + validate each prefix.
-	prefixByteLen := -1
-	for i, p := range req.Prefixes {
-		p = strings.ToLower(strings.TrimSpace(p))
-		req.Prefixes[i] = p
-		if len(p) == 0 || len(p)%2 != 0 {
-			http.Error(w, `{"error":"prefixes must be even-length hex"}`, http.StatusBadRequest)
-			return
-		}
-		if _, err := hex.DecodeString(p); err != nil {
-			http.Error(w, `{"error":"prefixes must be valid hex"}`, http.StatusBadRequest)
-			return
-		}
-		byteLen := len(p) / 2
-		if byteLen > maxPrefixBytes {
-			http.Error(w, `{"error":"prefix exceeds 3 bytes"}`, http.StatusBadRequest)
-			return
-		}
-		if prefixByteLen == -1 {
-			prefixByteLen = byteLen
-		} else if byteLen != prefixByteLen {
-			http.Error(w, `{"error":"mixed prefix lengths not allowed"}`, http.StatusBadRequest)
-			return
-		}
-	}
-
-	limit := req.Limit
-	if limit <= 0 {
-		limit = 10
-	}
-	if limit > 50 {
-		limit = 50
-	}
-
-	// Check cache.
-	cacheKey := s.store.inspectCacheKey(req)
-	s.store.inspectMu.RLock()
-	if cached, ok := s.store.inspectCache[cacheKey]; ok && time.Now().Before(cached.expiresAt) {
-		s.store.inspectMu.RUnlock()
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(cached.data)
-		return
-	}
-	s.store.inspectMu.RUnlock()
-
-	// Snapshot data under read lock.
-	nodes, pm := s.store.getCachedNodesAndPM()
-
-	// Build pubkey→nodeInfo map for O(1) geo lookup in scorer.
-	nodeByPK := make(map[string]*nodeInfo, len(nodes))
-	for i := range nodes {
-		nodeByPK[strings.ToLower(nodes[i].PublicKey)] = &nodes[i]
-	}
-
-	// Get neighbor graph; handle cold start.
-	graph := s.store.graph
-	if graph == nil || graph.IsStale() {
-		rebuilt := make(chan struct{})
-		go func() {
-			s.store.ensureNeighborGraph()
-			close(rebuilt)
-		}()
-		select {
-		case <-rebuilt:
-			graph = s.store.graph
-		case <-time.After(2 * time.Second):
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusServiceUnavailable)
-			json.NewEncoder(w).Encode(map[string]interface{}{"retry": true})
-			return
-		}
-		if graph == nil {
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusServiceUnavailable)
-			json.NewEncoder(w).Encode(map[string]interface{}{"retry": true})
-			return
-		}
-	}
-
-	now := time.Now()
-	start := now
-
-	// Beam search.
-	beam := s.store.beamSearch(req.Prefixes, pm, graph, nodeByPK, now)
-
-	// Sort by score descending, take top limit.
-	sortBeam(beam)
-	if len(beam) > limit {
-		beam = beam[:limit]
-	}
-
-	// Build response with per-hop alternatives (spec §2.7, M2 fix).
-	candidates := make([]pathCandidate, 0, len(beam))
-	for _, entry := range beam {
-		nHops := len(entry.pubkeys)
-		var score float64
-		if nHops > 0 {
-			score = math.Pow(entry.score, 1.0/float64(nHops))
-		}
-
-		// Populate per-hop alternatives: other candidates at each hop that weren't chosen.
-		evidence := make([]hopEvidence, len(entry.evidence))
-		copy(evidence, entry.evidence)
-		for hi, ev := range evidence {
-			if hi >= len(req.Prefixes) {
-				break
-			}
-			prefix := req.Prefixes[hi]
-			allCands := pm.m[prefix]
-			var alts []hopAlternative
-			for _, c := range allCands {
-				if !canAppearInPath(c.Role) || c.PublicKey == ev.Chosen {
-					continue
-				}
-				// Score this alternative in context of the partial path up to this hop.
-				var partialEntry beamEntry
-				if hi > 0 {
-					partialEntry = beamEntry{pubkeys: entry.pubkeys[:hi], names: entry.names[:hi], score: 1.0}
-				}
-				altScore := s.store.scoreHop(partialEntry, c, ev.CandidatesConsidered, graph, nodeByPK, now, hi)
-				alts = append(alts, hopAlternative{PublicKey: c.PublicKey, Name: c.Name, Score: math.Round(altScore*1000) / 1000})
-			}
-			// Sort alts by score desc, cap at 5.
-			sort.Slice(alts, func(i, j int) bool { return alts[i].Score > alts[j].Score })
-			if len(alts) > 5 {
-				alts = alts[:5]
-			}
-			evidence[hi] = hopEvidence{
-				Prefix:               ev.Prefix,
-				CandidatesConsidered: ev.CandidatesConsidered,
-				Chosen:               ev.Chosen,
-				EdgeWeight:           ev.EdgeWeight,
-				Alternatives:         alts,
-			}
-		}
-
-		candidates = append(candidates, pathCandidate{
-			Path:        entry.pubkeys,
-			Names:       entry.names,
-			Score:       math.Round(score*1000) / 1000,
-			Speculative: score < speculativeThreshold,
-			Evidence:    pathEvidence{PerHop: evidence},
-		})
-	}
-
-	elapsed := time.Since(start).Milliseconds()
-	resp := pathInspectResponse{
-		Candidates: candidates,
-		Input: map[string]interface{}{
-			"prefixes": req.Prefixes,
-			"hops":     len(req.Prefixes),
-		},
-		Stats: map[string]interface{}{
-			"beamWidth":     beamWidth,
-			"expansionsRun": len(req.Prefixes) * beamWidth,
-			"elapsedMs":     elapsed,
-		},
-	}
-
-	// Cache result (and evict stale entries).
-	s.store.inspectMu.Lock()
-	if s.store.inspectCache == nil {
-		s.store.inspectCache = make(map[string]*inspectCachedResult)
-	}
-	now2 := time.Now()
-	for k, v := range s.store.inspectCache {
-		if now2.After(v.expiresAt) {
-			delete(s.store.inspectCache, k)
-		}
-	}
-	s.store.inspectCache[cacheKey] = &inspectCachedResult{
-		data:      resp,
-		expiresAt: now2.Add(inspectCacheTTL),
-	}
-	s.store.inspectMu.Unlock()
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(resp)
-}
-
-type inspectCachedResult struct {
-	data      pathInspectResponse
-	expiresAt time.Time
-}
-
-func (s *PacketStore) inspectCacheKey(req pathInspectRequest) string {
-	key := strings.Join(req.Prefixes, ",")
-	if req.Context != nil {
-		key += "|" + req.Context.ObserverID + "|" + req.Context.Since + "|" + req.Context.Until
-	}
-	return key
-}
-
-func (s *PacketStore) beamSearch(prefixes []string, pm *prefixMap, graph *NeighborGraph, nodeByPK map[string]*nodeInfo, now time.Time) []beamEntry {
-	// Start with empty beam.
-	beam := []beamEntry{{pubkeys: nil, names: nil, evidence: nil, score: 1.0}}
-
-	for hopIdx, prefix := range prefixes {
-		candidates := pm.m[prefix]
-		// Filter by role at lookup time (spec §2.2 step 2).
-		var filtered []nodeInfo
-		for _, c := range candidates {
-			if canAppearInPath(c.Role) {
-				filtered = append(filtered, c)
-			}
-		}
-
-		candidateCount := len(filtered)
-		if candidateCount == 0 {
-			// No candidates for this hop — beam dies.
-			return nil
-		}
-
-		var nextBeam []beamEntry
-		for _, entry := range beam {
-			for _, cand := range filtered {
-				hopScore := s.scoreHop(entry, cand, candidateCount, graph, nodeByPK, now, hopIdx)
-				if hopScore < hopScoreFloor {
-					hopScore = hopScoreFloor
-				}
-
-				newEntry := beamEntry{
-					pubkeys:  append(append([]string{}, entry.pubkeys...), cand.PublicKey),
-					names:    append(append([]string{}, entry.names...), cand.Name),
-					evidence: append(append([]hopEvidence{}, entry.evidence...), hopEvidence{
-						Prefix:               prefix,
-						CandidatesConsidered: candidateCount,
-						Chosen:               cand.PublicKey,
-						EdgeWeight:           hopScore,
-					}),
-					score: entry.score * hopScore,
-				}
-				nextBeam = append(nextBeam, newEntry)
-			}
-		}
-
-		// Prune to beam width.
-		sortBeam(nextBeam)
-		if len(nextBeam) > beamWidth {
-			nextBeam = nextBeam[:beamWidth]
-		}
-		beam = nextBeam
-	}
-
-	return beam
-}
-
-func (s *PacketStore) scoreHop(entry beamEntry, cand nodeInfo, candidateCount int, graph *NeighborGraph, nodeByPK map[string]*nodeInfo, now time.Time, hopIdx int) float64 {
-	var edgeScore float64
-	var geoScore float64 = 1.0
-	var recencyScore float64 = 1.0
-
-	if hopIdx == 0 || len(entry.pubkeys) == 0 {
-		// First hop: no prior node to compare against.
-		edgeScore = 1.0
-	} else {
-		lastPK := entry.pubkeys[len(entry.pubkeys)-1]
-
-		// Single scan over neighbors for both edge weight and recency.
-		edges := graph.Neighbors(lastPK)
-		var foundEdge *NeighborEdge
-		for _, e := range edges {
-			peer := e.NodeA
-			if strings.EqualFold(peer, lastPK) {
-				peer = e.NodeB
-			}
-			if strings.EqualFold(peer, cand.PublicKey) {
-				foundEdge = e
-				break
-			}
-		}
-
-		if foundEdge != nil {
-			edgeScore = foundEdge.Score(now)
-			hoursSince := now.Sub(foundEdge.LastSeen).Hours()
-			if hoursSince <= 24 {
-				recencyScore = 1.0
-			} else {
-				recencyScore = math.Max(0.1, 24.0/hoursSince)
-			}
-		} else {
-			edgeScore = 0
-			recencyScore = 0
-		}
-
-		// Geographic plausibility.
-		prevNode := nodeByPK[strings.ToLower(lastPK)]
-		if prevNode != nil && prevNode.HasGPS && cand.HasGPS {
-			dist := haversineKm(prevNode.Lat, prevNode.Lon, cand.Lat, cand.Lon)
-			if dist > geoMaxKm {
-				geoScore = math.Max(0.1, geoMaxKm/dist)
-			}
-		}
-	}
-
-	// Prefix selectivity.
-	selectivityScore := 1.0 / float64(candidateCount)
-
-	return wEdge*edgeScore + wGeo*geoScore + wRecency*recencyScore + wSelectivity*selectivityScore
-}
-
-
-func sortBeam(beam []beamEntry) {
-	sort.Slice(beam, func(i, j int) bool {
-		return beam[i].score > beam[j].score
-	})
-}
-
-// ensureNeighborGraph triggers a graph rebuild if nil or stale.
-func (s *PacketStore) ensureNeighborGraph() {
-	if s.graph != nil && !s.graph.IsStale() {
-		return
-	}
-	g := BuildFromStore(s)
-	s.graph = g
-}

cmd/server/path_inspect_test.go

@@ -1,308 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"math"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-)
-
-// ─── Unit tests for path inspector (issue #944) ────────────────────────────────
-
-func TestScoreHop_EdgeWeight(t *testing.T) {
-	store := &PacketStore{}
-	graph := NewNeighborGraph()
-	now := time.Now()
-
-	// Add an edge between A and B.
-	graph.mu.Lock()
-	edge := &NeighborEdge{
-		NodeA: "aaaa", NodeB: "bbbb",
-		Count: 50, LastSeen: now.Add(-1 * time.Hour),
-		Observers: map[string]bool{"obs1": true},
-	}
-	key := edgeKey{"aaaa", "bbbb"}
-	graph.edges[key] = edge
-	graph.byNode["aaaa"] = append(graph.byNode["aaaa"], edge)
-	graph.byNode["bbbb"] = append(graph.byNode["bbbb"], edge)
-	graph.mu.Unlock()
-
-	entry := beamEntry{pubkeys: []string{"aaaa"}, names: []string{"NodeA"}}
-	cand := nodeInfo{PublicKey: "bbbb", Name: "NodeB", Role: "repeater"}
-
-	score := store.scoreHop(entry, cand, 2, graph, nil, now, 1)
-
-	// With edge present, edgeScore > 0. With 2 candidates, selectivity = 0.5.
-	// Anti-tautology: if we zero out edge weight constant, score would change.
-	if score <= 0.05 {
-		t.Errorf("expected score > floor, got %f", score)
-	}
-
-	// No edge: score should be lower.
-	candNoEdge := nodeInfo{PublicKey: "cccc", Name: "NodeC", Role: "repeater"}
-	scoreNoEdge := store.scoreHop(entry, candNoEdge, 2, graph, nil, now, 1)
-	if scoreNoEdge >= score {
-		t.Errorf("expected no-edge score (%f) < edge score (%f)", scoreNoEdge, score)
-	}
-}
-
-func TestScoreHop_FirstHop(t *testing.T) {
-	store := &PacketStore{}
-	graph := NewNeighborGraph()
-	now := time.Now()
-
-	entry := beamEntry{pubkeys: nil, names: nil}
-	cand := nodeInfo{PublicKey: "aaaa", Name: "NodeA", Role: "repeater"}
-
-	score := store.scoreHop(entry, cand, 3, graph, nil, now, 0)
-	// First hop: edgeScore=1.0, geoScore=1.0, recencyScore=1.0, selectivity=1/3
-	// = 0.35*1 + 0.20*1 + 0.15*1 + 0.30*(1/3) = 0.35+0.20+0.15+0.10 = 0.80
-	expected := 0.35 + 0.20 + 0.15 + 0.30/3.0
-	if score < expected-0.01 || score > expected+0.01 {
-		t.Errorf("expected ~%f, got %f", expected, score)
-	}
-}
-
-func TestScoreHop_GeoPlausibility(t *testing.T) {
-	store := &PacketStore{}
-	store.nodeCache = []nodeInfo{
-		{PublicKey: "aaaa", Name: "A", Role: "repeater", Lat: 37.0, Lon: -122.0, HasGPS: true},
-		{PublicKey: "bbbb", Name: "B", Role: "repeater", Lat: 37.01, Lon: -122.01, HasGPS: true}, // ~1.4km
-		{PublicKey: "cccc", Name: "C", Role: "repeater", Lat: 40.0, Lon: -120.0, HasGPS: true},   // ~400km
-	}
-	store.nodePM = buildPrefixMap(store.nodeCache)
-	store.nodeCacheTime = time.Now()
-
-	graph := NewNeighborGraph()
-	now := time.Now()
-
-	nodeByPK := map[string]*nodeInfo{
-		"aaaa": &store.nodeCache[0],
-		"bbbb": &store.nodeCache[1],
-		"cccc": &store.nodeCache[2],
-	}
-
-	entry := beamEntry{pubkeys: []string{"aaaa"}, names: []string{"A"}}
-
-	// Close node should score higher than far node (geo component).
-	scoreClose := store.scoreHop(entry, store.nodeCache[1], 2, graph, nodeByPK, now, 1)
-	scoreFar := store.scoreHop(entry, store.nodeCache[2], 2, graph, nodeByPK, now, 1)
-	if scoreFar >= scoreClose {
-		t.Errorf("expected far node score (%f) < close node score (%f)", scoreFar, scoreClose)
-	}
-}
-
-func TestBeamSearch_WidthCap(t *testing.T) {
-	store := &PacketStore{}
-	graph := NewNeighborGraph()
-	graph.builtAt = time.Now()
-	now := time.Now()
-
-	// Create 25 nodes that all match prefix "aa".
-	var nodes []nodeInfo
-	for i := 0; i < 25; i++ {
-		// Each node has pubkey starting with "aa" followed by unique hex.
-		pk := "aa" + strings.Repeat("0", 4) + fmt.Sprintf("%02x", i)
-		nodes = append(nodes, nodeInfo{PublicKey: pk, Name: pk, Role: "repeater"})
-	}
-	pm := buildPrefixMap(nodes)
-
-	// Two hops of "aa" — should produce 25*25=625 combos, pruned to 20.
-	beam := store.beamSearch([]string{"aa", "aa"}, pm, graph, nil, now)
-	if len(beam) > beamWidth {
-		t.Errorf("beam exceeded width: got %d, want <= %d", len(beam), beamWidth)
-	}
-	// Anti-tautology: without beam pruning, we'd have up to 25*min(25,beamWidth)=500 entries.
-	// The test verifies pruning is effective.
-}
-
-func TestBeamSearch_Speculative(t *testing.T) {
-	store := &PacketStore{}
-	graph := NewNeighborGraph()
-	graph.builtAt = time.Now()
-	now := time.Now()
-
-	// Create nodes with no edges and multiple candidates — should result in low scores (speculative).
-	nodes := []nodeInfo{
-		{PublicKey: "aabb", Name: "N1", Role: "repeater"},
-		{PublicKey: "aabb22", Name: "N1b", Role: "repeater"},
-		{PublicKey: "ccdd", Name: "N2", Role: "repeater"},
-		{PublicKey: "ccdd22", Name: "N2b", Role: "repeater"},
-		{PublicKey: "ccdd33", Name: "N2c", Role: "repeater"},
-	}
-	pm := buildPrefixMap(nodes)
-
-	beam := store.beamSearch([]string{"aa", "cc"}, pm, graph, nil, now)
-	if len(beam) == 0 {
-		t.Fatal("expected at least one result")
-	}
-
-	// Score should be < 0.7 since there's no edge and multiple candidates (speculative).
-	nHops := len(beam[0].pubkeys)
-	score := 1.0
-	if nHops > 0 {
-		product := beam[0].score
-		score = pow(product, 1.0/float64(nHops))
-	}
-	if score >= speculativeThreshold {
-		t.Errorf("expected speculative score (< %f), got %f", speculativeThreshold, score)
-	}
-}
-
-func TestHandlePathInspect_EmptyPrefixes(t *testing.T) {
-	srv := newTestServerForInspect(t)
-	body := `{"prefixes":[]}`
-	rr := doInspectRequest(srv, body)
-	if rr.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", rr.Code)
-	}
-}
-
-func TestHandlePathInspect_OddLengthPrefix(t *testing.T) {
-	srv := newTestServerForInspect(t)
-	body := `{"prefixes":["abc"]}`
-	rr := doInspectRequest(srv, body)
-	if rr.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for odd-length prefix, got %d", rr.Code)
-	}
-}
-
-func TestHandlePathInspect_MixedLengths(t *testing.T) {
-	srv := newTestServerForInspect(t)
-	body := `{"prefixes":["aa","bbcc"]}`
-	rr := doInspectRequest(srv, body)
-	if rr.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for mixed lengths, got %d", rr.Code)
-	}
-}
-
-func TestHandlePathInspect_TooLongPrefix(t *testing.T) {
-	srv := newTestServerForInspect(t)
-	body := `{"prefixes":["aabbccdd"]}`
-	rr := doInspectRequest(srv, body)
-	if rr.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for >3-byte prefix, got %d", rr.Code)
-	}
-}
-
-func TestHandlePathInspect_TooManyPrefixes(t *testing.T) {
-	srv := newTestServerForInspect(t)
-	prefixes := make([]string, 65)
-	for i := range prefixes {
-		prefixes[i] = "aa"
-	}
-	b, _ := json.Marshal(map[string]interface{}{"prefixes": prefixes})
-	rr := doInspectRequest(srv, string(b))
-	if rr.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for >64 prefixes, got %d", rr.Code)
-	}
-}
-
-func TestHandlePathInspect_ValidRequest(t *testing.T) {
-	srv := newTestServerForInspect(t)
-
-	// Seed nodes in the store — multiple candidates per prefix to lower selectivity.
-	srv.store.nodeCache = []nodeInfo{
-		{PublicKey: "aabb1234", Name: "NodeA", Role: "repeater", Lat: 37.0, Lon: -122.0, HasGPS: true},
-		{PublicKey: "aabb5678", Name: "NodeA2", Role: "repeater"},
-		{PublicKey: "ccdd5678", Name: "NodeB", Role: "repeater", Lat: 37.01, Lon: -122.01, HasGPS: true},
-		{PublicKey: "ccdd9999", Name: "NodeB2", Role: "repeater"},
-		{PublicKey: "ccdd1111", Name: "NodeB3", Role: "repeater"},
-	}
-	srv.store.nodePM = buildPrefixMap(srv.store.nodeCache)
-	srv.store.nodeCacheTime = time.Now()
-	srv.store.graph = NewNeighborGraph()
-	srv.store.graph.builtAt = time.Now()
-
-	body := `{"prefixes":["aa","cc"]}`
-	rr := doInspectRequest(srv, body)
-	if rr.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
-	}
-
-	var resp pathInspectResponse
-	if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("invalid JSON response: %v", err)
-	}
-	if len(resp.Candidates) == 0 {
-		t.Error("expected at least one candidate")
-	}
-	if resp.Candidates[0].Speculative != true {
-		// No edge between nodes, so score should be < 0.7.
-		t.Error("expected speculative=true for no-edge path")
-	}
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-func newTestServerForInspect(t *testing.T) *Server {
-	t.Helper()
-	store := &PacketStore{
-		inspectCache: make(map[string]*inspectCachedResult),
-	}
-	store.graph = NewNeighborGraph()
-	store.graph.builtAt = time.Now()
-	return &Server{store: store}
-}
-
-func doInspectRequest(srv *Server, body string) *httptest.ResponseRecorder {
-	req := httptest.NewRequest("POST", "/api/paths/inspect", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	rr := httptest.NewRecorder()
-	srv.handlePathInspect(rr, req)
-	return rr
-}
-
-func pow(base, exp float64) float64 {
-	return math.Pow(base, exp)
-}
-
-// BenchmarkBeamSearch — performance proof for spec §2.5 (<100ms p99 for ≤64 hops).
-// Anti-tautology: removing beam pruning makes this ~625x slower; timing assertion catches it.
-func BenchmarkBeamSearch(b *testing.B) {
-	// Setup: 100 nodes, 10-hop prefix input, realistic neighbor graph.
-	// Anti-tautology: removing beam pruning makes this ~625x slower.
-	store := &PacketStore{}
-	pm := &prefixMap{m: make(map[string][]nodeInfo)}
-	graph := NewNeighborGraph()
-	nodes := make([]nodeInfo, 100)
-
-	now := time.Now()
-	for i := 0; i < 100; i++ {
-		pk := fmt.Sprintf("%064x", i)
-		prefix := fmt.Sprintf("%02x", i%256)
-		node := nodeInfo{PublicKey: pk, Name: fmt.Sprintf("Node%d", i), Role: "repeater", Lat: 37.0 + float64(i)*0.01, Lon: -122.0 + float64(i)*0.01}
-		nodes[i] = node
-		pm.m[prefix] = append(pm.m[prefix], node)
-		// Add neighbor edges to create a connected graph.
-		if i > 0 {
-			prevPK := fmt.Sprintf("%064x", i-1)
-			key := makeEdgeKey(prevPK, pk)
-			edge := &NeighborEdge{NodeA: prevPK, NodeB: pk, LastSeen: now, Count: 10}
-			graph.edges[key] = edge
-			graph.byNode[prevPK] = append(graph.byNode[prevPK], edge)
-			graph.byNode[pk] = append(graph.byNode[pk], edge)
-		}
-	}
-
-	// 10-hop input using prefixes that map to multiple candidates.
-	prefixes := make([]string, 10)
-	for i := 0; i < 10; i++ {
-		prefixes[i] = fmt.Sprintf("%02x", (i*3)%256)
-	}
-
-	nodeByPK := make(map[string]*nodeInfo)
-	for idx := range nodes {
-		nodeByPK[nodes[idx].PublicKey] = &nodes[idx]
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		store.beamSearch(prefixes, pm, graph, nodeByPK, now)
-	}
-}

cmd/server/prefix_map_role_test.go

@@ -1,212 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func TestCanAppearInPath(t *testing.T) {
-	cases := []struct {
-		role string
-		want bool
-	}{
-		{"repeater", true},
-		{"Repeater", true},
-		{"REPEATER", true},
-		{"room_server", true},
-		{"Room_Server", true},
-		{"room", true},
-		{"companion", false},
-		{"sensor", false},
-		{"", false},
-		{"unknown", false},
-	}
-	for _, tc := range cases {
-		if got := canAppearInPath(tc.role); got != tc.want {
-			t.Errorf("canAppearInPath(%q) = %v, want %v", tc.role, got, tc.want)
-		}
-	}
-}
-
-func TestBuildPrefixMap_ExcludesCompanions(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "companion", Name: "MyCompanion"},
-	}
-	pm := buildPrefixMap(nodes)
-	if len(pm.m) != 0 {
-		t.Fatalf("expected empty prefix map, got %d entries", len(pm.m))
-	}
-}
-
-func TestBuildPrefixMap_ExcludesSensors(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "sensor", Name: "MySensor"},
-	}
-	pm := buildPrefixMap(nodes)
-	if len(pm.m) != 0 {
-		t.Fatalf("expected empty prefix map, got %d entries", len(pm.m))
-	}
-}
-
-func TestResolveWithContext_NilWhenOnlyCompanionMatchesPrefix(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "companion", Name: "MyCompanion"},
-	}
-	pm := buildPrefixMap(nodes)
-	r, _, _ := pm.resolveWithContext("7a", nil, nil)
-	if r != nil {
-		t.Fatalf("expected nil, got %+v", r)
-	}
-}
-
-func TestResolveWithContext_NilWhenOnlySensorMatchesPrefix(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "sensor", Name: "MySensor"},
-	}
-	pm := buildPrefixMap(nodes)
-	r, _, _ := pm.resolveWithContext("7a", nil, nil)
-	if r != nil {
-		t.Fatalf("expected nil for sensor-only prefix, got %+v", r)
-	}
-}
-
-func TestResolveWithContext_PrefersRepeaterOverCompanionAtSamePrefix(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "companion", Name: "MyCompanion"},
-		{PublicKey: "7a5678901234", Role: "repeater", Name: "MyRepeater"},
-	}
-	pm := buildPrefixMap(nodes)
-	r, _, _ := pm.resolveWithContext("7a", nil, nil)
-	if r == nil {
-		t.Fatal("expected non-nil result")
-	}
-	if r.Name != "MyRepeater" {
-		t.Fatalf("expected MyRepeater, got %s", r.Name)
-	}
-}
-
-func TestResolveWithContext_PrefersRoomServerOverCompanionAtSamePrefix(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "ab1234abcdef", Role: "companion", Name: "MyCompanion"},
-		{PublicKey: "ab5678901234", Role: "room_server", Name: "MyRoom"},
-	}
-	pm := buildPrefixMap(nodes)
-	r, _, _ := pm.resolveWithContext("ab", nil, nil)
-	if r == nil {
-		t.Fatal("expected non-nil result")
-	}
-	if r.Name != "MyRoom" {
-		t.Fatalf("expected MyRoom, got %s", r.Name)
-	}
-}
-
-func TestResolve_NilWhenOnlyCompanionMatchesPrefix(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "companion", Name: "MyCompanion"},
-	}
-	pm := buildPrefixMap(nodes)
-	r := pm.resolve("7a")
-	if r != nil {
-		t.Fatalf("expected nil from resolve() for companion-only prefix, got %+v", r)
-	}
-}
-
-func TestResolve_NilWhenOnlySensorMatchesPrefix(t *testing.T) {
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "sensor", Name: "MySensor"},
-	}
-	pm := buildPrefixMap(nodes)
-	r := pm.resolve("7a")
-	if r != nil {
-		t.Fatalf("expected nil from resolve() for sensor-only prefix, got %+v", r)
-	}
-}
-
-func TestResolveWithContext_PicksRepeaterEvenWhenCompanionHasGPS(t *testing.T) {
-	// Adversarial: companion has GPS, repeater doesn't. Role filter should
-	// exclude companion entirely, so repeater wins despite lacking GPS.
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "companion", Name: "GPSCompanion", Lat: 37.0, Lon: -122.0, HasGPS: true},
-		{PublicKey: "7a5678901234", Role: "repeater", Name: "NoGPSRepeater", Lat: 0, Lon: 0, HasGPS: false},
-	}
-	pm := buildPrefixMap(nodes)
-	r, _, _ := pm.resolveWithContext("7a", nil, nil)
-	if r == nil {
-		t.Fatal("expected non-nil result")
-	}
-	if r.Name != "NoGPSRepeater" {
-		t.Fatalf("expected NoGPSRepeater (role filter excludes companion), got %s", r.Name)
-	}
-}
-
-func TestComputeDistancesForTx_CompanionNeverInResolvedChain(t *testing.T) {
-	// Integration test: a path with a prefix matching both a companion and a
-	// repeater. The resolveHop function (using buildPrefixMap) should only
-	// return the repeater.
-	nodes := []nodeInfo{
-		{PublicKey: "7a1234abcdef", Role: "companion", Name: "BadCompanion", Lat: 37.0, Lon: -122.0, HasGPS: true},
-		{PublicKey: "7a5678901234", Role: "repeater", Name: "GoodRepeater", Lat: 38.0, Lon: -123.0, HasGPS: true},
-		{PublicKey: "bb1111111111", Role: "repeater", Name: "OtherRepeater", Lat: 39.0, Lon: -124.0, HasGPS: true},
-	}
-	pm := buildPrefixMap(nodes)
-
-	nodeByPk := make(map[string]*nodeInfo)
-	for i := range nodes {
-		nodeByPk[nodes[i].PublicKey] = &nodes[i]
-	}
-	repeaterSet := map[string]bool{
-		"7a5678901234": true,
-		"bb1111111111": true,
-	}
-
-	// Build a synthetic StoreTx with a path ["7a", "bb"] and a sender with GPS
-	senderPK := "cc0000000000"
-	sender := nodeInfo{PublicKey: senderPK, Role: "repeater", Name: "Sender", Lat: 36.0, Lon: -121.0, HasGPS: true}
-	nodeByPk[senderPK] = &sender
-
-	pathJSON, _ := json.Marshal([]string{"7a", "bb"})
-	decoded, _ := json.Marshal(map[string]interface{}{"pubKey": senderPK})
-
-	tx := &StoreTx{
-		PathJSON:    string(pathJSON),
-		DecodedJSON: string(decoded),
-		FirstSeen:   "2026-04-30T12:00",
-	}
-
-	resolveHop := func(hop string) *nodeInfo {
-		return pm.resolve(hop)
-	}
-
-	hops, pathRec := computeDistancesForTx(tx, nodeByPk, repeaterSet, resolveHop)
-
-	// Verify BadCompanion's pubkey never appears in hops
-	badPK := "7a1234abcdef"
-	for i, h := range hops {
-		if h.FromPk == badPK || h.ToPk == badPK {
-			t.Fatalf("hop[%d] contains BadCompanion pubkey: from=%s to=%s", i, h.FromPk, h.ToPk)
-		}
-	}
-
-	// Verify BadCompanion's pubkey never appears in pathRec
-	if pathRec == nil {
-		t.Fatal("expected non-nil path record (3 GPS nodes in chain)")
-	}
-	for i, hop := range pathRec.Hops {
-		if hop.FromPk == badPK || hop.ToPk == badPK {
-			t.Fatalf("pathRec.Hops[%d] contains BadCompanion pubkey: from=%s to=%s", i, hop.FromPk, hop.ToPk)
-		}
-	}
-
-	// Verify GoodRepeater IS in the chain (proves the prefix was resolved to the right node)
-	goodPK := "7a5678901234"
-	foundGood := false
-	for _, hop := range pathRec.Hops {
-		if hop.FromPk == goodPK || hop.ToPk == goodPK {
-			foundGood = true
-			break
-		}
-	}
-	if !foundGood {
-		t.Fatal("expected GoodRepeater (7a5678901234) in pathRec.Hops but not found")
-	}
-}

cmd/server/resolve_context_test.go

@@ -11,7 +11,7 @@ import (
 
 func TestResolveWithContext_UniquePrefix(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1b2c3d4", Name: "Node-A", HasGPS: true, Lat: 1, Lon: 2},
+		{PublicKey: "a1b2c3d4", Name: "Node-A", HasGPS: true, Lat: 1, Lon: 2},
 	})
 	ni, confidence, _ := pm.resolveWithContext("a1b2c3d4", nil, nil)
 	if ni == nil || ni.Name != "Node-A" {
@@ -24,7 +24,7 @@ func TestResolveWithContext_UniquePrefix(t *testing.T) {
 
 func TestResolveWithContext_NoMatch(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1b2c3d4", Name: "Node-A"},
+		{PublicKey: "a1b2c3d4", Name: "Node-A"},
 	})
 	ni, confidence, _ := pm.resolveWithContext("ff", nil, nil)
 	if ni != nil {
@@ -37,8 +37,8 @@ func TestResolveWithContext_NoMatch(t *testing.T) {
 
 func TestResolveWithContext_AffinityWins(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1aaaaaa", Name: "Node-A1"},
-		{Role: "repeater", PublicKey: "a1bbbbbb", Name: "Node-A2"},
+		{PublicKey: "a1aaaaaa", Name: "Node-A1"},
+		{PublicKey: "a1bbbbbb", Name: "Node-A2"},
 	})
 
 	graph := NewNeighborGraph()
@@ -60,9 +60,9 @@ func TestResolveWithContext_AffinityWins(t *testing.T) {
 
 func TestResolveWithContext_AffinityTooClose_FallsToGeo(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1aaaaaa", Name: "Node-A1", HasGPS: true, Lat: 10, Lon: 20},
-		{Role: "repeater", PublicKey: "a1bbbbbb", Name: "Node-A2", HasGPS: true, Lat: 11, Lon: 21},
-		{Role: "repeater", PublicKey: "c0c0c0c0", Name: "Ctx", HasGPS: true, Lat: 10.1, Lon: 20.1},
+		{PublicKey: "a1aaaaaa", Name: "Node-A1", HasGPS: true, Lat: 10, Lon: 20},
+		{PublicKey: "a1bbbbbb", Name: "Node-A2", HasGPS: true, Lat: 11, Lon: 21},
+		{PublicKey: "c0c0c0c0", Name: "Ctx", HasGPS: true, Lat: 10.1, Lon: 20.1},
 	})
 
 	graph := NewNeighborGraph()
@@ -85,8 +85,8 @@ func TestResolveWithContext_AffinityTooClose_FallsToGeo(t *testing.T) {
 
 func TestResolveWithContext_GPSPreference(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1aaaaaa", Name: "NoGPS"},
-		{Role: "repeater", PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
+		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
+		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
 	})
 
 	ni, confidence, _ := pm.resolveWithContext("a1", nil, nil)
@@ -100,8 +100,8 @@ func TestResolveWithContext_GPSPreference(t *testing.T) {
 
 func TestResolveWithContext_FirstMatchFallback(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1aaaaaa", Name: "First"},
-		{Role: "repeater", PublicKey: "a1bbbbbb", Name: "Second"},
+		{PublicKey: "a1aaaaaa", Name: "First"},
+		{PublicKey: "a1bbbbbb", Name: "Second"},
 	})
 
 	ni, confidence, _ := pm.resolveWithContext("a1", nil, nil)
@@ -115,8 +115,8 @@ func TestResolveWithContext_FirstMatchFallback(t *testing.T) {
 
 func TestResolveWithContext_NilGraphFallsToGPS(t *testing.T) {
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1aaaaaa", Name: "NoGPS"},
-		{Role: "repeater", PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
+		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
+		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
 	})
 
 	ni, confidence, _ := pm.resolveWithContext("a1", []string{"someone"}, nil)
@@ -131,8 +131,8 @@ func TestResolveWithContext_NilGraphFallsToGPS(t *testing.T) {
 func TestResolveWithContext_BackwardCompatResolve(t *testing.T) {
 	// Verify original resolve() still works unchanged
 	pm := buildPrefixMap([]nodeInfo{
-		{Role: "repeater", PublicKey: "a1aaaaaa", Name: "NoGPS"},
-		{Role: "repeater", PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
+		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
+		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
 	})
 	ni := pm.resolve("a1")
 	if ni == nil || ni.Name != "HasGPS" {
@@ -164,8 +164,8 @@ func TestResolveHopsAPI_UniquePrefix(t *testing.T) {
 	_ = srv
 
 	// Insert a unique node
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"ff11223344", "UniqueNode", 37.0, -122.0, "repeater")
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"ff11223344", "UniqueNode", 37.0, -122.0)
 	srv.store.InvalidateNodeCache()
 
 	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=ff11223344", nil)
@@ -189,10 +189,10 @@ func TestResolveHopsAPI_UniquePrefix(t *testing.T) {
 func TestResolveHopsAPI_AmbiguousNoContext(t *testing.T) {
 	srv, router := setupTestServer(t)
 
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"ee1aaaaaaa", "Node-E1", 37.0, -122.0, "repeater")
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"ee1bbbbbbb", "Node-E2", 38.0, -121.0, "repeater")
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"ee1aaaaaaa", "Node-E1", 37.0, -122.0)
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"ee1bbbbbbb", "Node-E2", 38.0, -121.0)
 	srv.store.InvalidateNodeCache()
 
 	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=ee1", nil)
@@ -224,12 +224,12 @@ func TestResolveHopsAPI_AmbiguousNoContext(t *testing.T) {
 func TestResolveHopsAPI_WithAffinityContext(t *testing.T) {
 	srv, router := setupTestServer(t)
 
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"dd1aaaaaaa", "Node-D1", 37.0, -122.0, "repeater")
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"dd1bbbbbbb", "Node-D2", 38.0, -121.0, "repeater")
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"c0c0c0c0c0", "Context", 37.1, -122.1, "repeater")
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"dd1aaaaaaa", "Node-D1", 37.0, -122.0)
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"dd1bbbbbbb", "Node-D2", 38.0, -121.0)
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"c0c0c0c0c0", "Context", 37.1, -122.1)
 
 	// Invalidate node cache so the PM includes newly inserted nodes.
 	srv.store.cacheMu.Lock()
@@ -279,8 +279,8 @@ func TestResolveHopsAPI_WithAffinityContext(t *testing.T) {
 func TestResolveHopsAPI_ResponseShape(t *testing.T) {
 	srv, router := setupTestServer(t)
 
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon, role) VALUES (?, ?, ?, ?, ?)",
-		"bb1aaaaaaa", "Node-B1", 37.0, -122.0, "repeater")
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"bb1aaaaaaa", "Node-B1", 37.0, -122.0)
 
 	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=bb1a", nil)
 	rr := httptest.NewRecorder()

cmd/server/resolved_index.go

@@ -1,475 +0,0 @@
-package main
-
-// Lock ordering contract (MUST be followed everywhere):
-//
-//   s.mu  →  s.lruMu   (s.mu is the outer lock, lruMu is the inner lock)
-//
-// • Never acquire s.lruMu while holding s.mu.
-// • fetchResolvedPathForObs takes lruMu independently — callers under s.mu
-//   must NOT call it directly; instead collect IDs under s.mu, release, then
-//   do LRU ops under lruMu separately.
-// • The backfill path (backfillResolvedPathsAsync) follows this by collecting
-//   obsIDs to invalidate under s.mu, releasing it, then taking lruMu.
-
-import (
-	"database/sql"
-	"hash/fnv"
-	"log"
-	"strings"
-)
-
-// resolvedPubkeyHash computes a fast 64-bit hash for membership index keying.
-// Uses FNV-1a from stdlib — good distribution, no external dependency.
-func resolvedPubkeyHash(pk string) uint64 {
-	h := fnv.New64a()
-	h.Write([]byte(strings.ToLower(pk)))
-	return h.Sum64()
-}
-
-// addToResolvedPubkeyIndex adds a txID under each resolved pubkey hash.
-// Deduplicates both within a single call AND across calls — won't add the
-// same (hash, txID) pair twice even when called multiple times for the same tx.
-// Must be called under s.mu write lock.
-func (s *PacketStore) addToResolvedPubkeyIndex(txID int, resolvedPubkeys []string) {
-	if !s.useResolvedPathIndex {
-		return
-	}
-	seen := make(map[uint64]bool, len(resolvedPubkeys))
-	for _, pk := range resolvedPubkeys {
-		if pk == "" {
-			continue
-		}
-		h := resolvedPubkeyHash(pk)
-		if seen[h] {
-			continue
-		}
-		seen[h] = true
-
-		// Cross-call dedup: check if (h, txID) already exists in forward index.
-		existing := s.resolvedPubkeyIndex[h]
-		alreadyPresent := false
-		for _, id := range existing {
-			if id == txID {
-				alreadyPresent = true
-				break
-			}
-		}
-		if alreadyPresent {
-			continue
-		}
-
-		s.resolvedPubkeyIndex[h] = append(existing, txID)
-		s.resolvedPubkeyReverse[txID] = append(s.resolvedPubkeyReverse[txID], h)
-	}
-}
-
-// removeFromResolvedPubkeyIndex removes all index entries for a txID using the reverse map.
-// Must be called under s.mu write lock.
-func (s *PacketStore) removeFromResolvedPubkeyIndex(txID int) {
-	if !s.useResolvedPathIndex {
-		return
-	}
-	hashes := s.resolvedPubkeyReverse[txID]
-	for _, h := range hashes {
-		list := s.resolvedPubkeyIndex[h]
-		// Remove ALL occurrences of txID (not just the first) to prevent orphans.
-		filtered := list[:0]
-		for _, id := range list {
-			if id != txID {
-				filtered = append(filtered, id)
-			}
-		}
-		if len(filtered) == 0 {
-			delete(s.resolvedPubkeyIndex, h)
-		} else {
-			s.resolvedPubkeyIndex[h] = filtered
-		}
-	}
-	delete(s.resolvedPubkeyReverse, txID)
-}
-
-// extractResolvedPubkeys extracts all non-nil, non-empty pubkeys from a resolved path.
-func extractResolvedPubkeys(rp []*string) []string {
-	if len(rp) == 0 {
-		return nil
-	}
-	result := make([]string, 0, len(rp))
-	for _, p := range rp {
-		if p != nil && *p != "" {
-			result = append(result, *p)
-		}
-	}
-	return result
-}
-
-// mergeResolvedPubkeys collects unique non-empty pubkeys from multiple resolved paths.
-func mergeResolvedPubkeys(paths ...[]*string) []string {
-	seen := make(map[string]bool)
-	var result []string
-	for _, rp := range paths {
-		for _, p := range rp {
-			if p != nil && *p != "" && !seen[*p] {
-				seen[*p] = true
-				result = append(result, *p)
-			}
-		}
-	}
-	return result
-}
-
-// nodeInResolvedPathViaIndex checks whether a transmission is associated with
-// a target pubkey using the membership index + collision-safety SQL check.
-// Must be called under s.mu RLock at minimum.
-func (s *PacketStore) nodeInResolvedPathViaIndex(tx *StoreTx, targetPK string) bool {
-	if !s.useResolvedPathIndex {
-		// Flag off: can't disambiguate, keep candidate (conservative)
-		return true
-	}
-
-	// If this tx has no indexed pubkeys at all, we can't disambiguate —
-	// keep the candidate (same as old behavior for NULL resolved_path).
-	if _, hasReverse := s.resolvedPubkeyReverse[tx.ID]; !hasReverse {
-		return true
-	}
-
-	h := resolvedPubkeyHash(targetPK)
-	txIDs := s.resolvedPubkeyIndex[h]
-
-	// Check if this tx's ID is in the candidate list
-	for _, id := range txIDs {
-		if id == tx.ID {
-			// Found in index. Collision-safety: verify with SQL.
-			if s.db != nil && s.db.conn != nil {
-				return s.confirmResolvedPathContains(tx.ID, targetPK)
-			}
-			return true // no DB, trust the index
-		}
-	}
-
-	return false
-}
-
-// confirmResolvedPathContains verifies an exact pubkey match in resolved_path
-// via SQL. This is the collision-safety fallback for the membership index.
-func (s *PacketStore) confirmResolvedPathContains(txID int, pubkey string) bool {
-	if s.db == nil || s.db.conn == nil {
-		return true
-	}
-	// Use INSTR with surrounding quotes for exact match — avoids LIKE escape issues.
-	// resolved_path format: ["pubkey1","pubkey2",...]
-	needle := `"` + strings.ToLower(pubkey) + `"`
-	var count int
-	err := s.db.conn.QueryRow(
-		`SELECT COUNT(*) FROM observations WHERE transmission_id = ? AND INSTR(LOWER(resolved_path), ?) > 0`,
-		txID, needle,
-	).Scan(&count)
-	if err != nil {
-		return true // on error, keep the candidate
-	}
-	return count > 0
-}
-
-// fetchResolvedPathsForTx fetches resolved_path from SQLite for all observations
-// of a transmission. Used for on-demand API responses and eviction cleanup.
-func (s *PacketStore) fetchResolvedPathsForTx(txID int) map[int][]*string {
-	if s.db == nil || s.db.conn == nil {
-		return nil
-	}
-	rows, err := s.db.conn.Query(
-		`SELECT id, resolved_path FROM observations WHERE transmission_id = ? AND resolved_path IS NOT NULL`,
-		txID,
-	)
-	if err != nil {
-		return nil
-	}
-	defer rows.Close()
-
-	result := make(map[int][]*string)
-	for rows.Next() {
-		var obsID int
-		var rpJSON sql.NullString
-		if err := rows.Scan(&obsID, &rpJSON); err != nil {
-			continue
-		}
-		if rpJSON.Valid && rpJSON.String != "" {
-			result[obsID] = unmarshalResolvedPath(rpJSON.String)
-		}
-	}
-	return result
-}
-
-// fetchResolvedPathForObs fetches resolved_path for a single observation,
-// using the LRU cache.
-func (s *PacketStore) fetchResolvedPathForObs(obsID int) []*string {
-	if s.db == nil || s.db.conn == nil {
-		return nil
-	}
-
-	// Check LRU cache first
-	s.lruMu.RLock()
-	if s.apiResolvedPathLRU != nil {
-		if entry, ok := s.apiResolvedPathLRU[obsID]; ok {
-			s.lruMu.RUnlock()
-			return entry
-		}
-	}
-	s.lruMu.RUnlock()
-
-	var rpJSON sql.NullString
-	err := s.db.conn.QueryRow(
-		`SELECT resolved_path FROM observations WHERE id = ?`, obsID,
-	).Scan(&rpJSON)
-	if err != nil || !rpJSON.Valid {
-		return nil
-	}
-	rp := unmarshalResolvedPath(rpJSON.String)
-
-	// Store in LRU
-	s.lruMu.Lock()
-	s.lruPut(obsID, rp)
-	s.lruMu.Unlock()
-
-	return rp
-}
-
-// fetchResolvedPathForTxBest returns the best observation's resolved_path for a tx.
-//
-// "Best" = the longest path_json among observations that actually have a stored
-// resolved_path. Earlier versions picked the longest-path obs unconditionally
-// and queried SQL for that single ID — if the longest-path obs had NULL
-// resolved_path while a shorter sibling had one, the call returned nil and
-// callers (e.g. /api/nodes/{pk}/health.recentPackets) lost the field. Fixes
-// #810 by checking all observations and falling back to the longest sibling
-// that has a stored path.
-func (s *PacketStore) fetchResolvedPathForTxBest(tx *StoreTx) []*string {
-	if tx == nil || len(tx.Observations) == 0 {
-		return nil
-	}
-	// Fast path: try the longest-path obs first via the LRU/SQL helper.
-	longest := tx.Observations[0]
-	longestLen := pathLen(longest.PathJSON)
-	for _, obs := range tx.Observations[1:] {
-		if l := pathLen(obs.PathJSON); l > longestLen {
-			longest = obs
-			longestLen = l
-		}
-	}
-	if rp := s.fetchResolvedPathForObs(longest.ID); rp != nil {
-		return rp
-	}
-	// Fallback: longest-path obs has no stored resolved_path. Query all
-	// observations for this tx and pick the one with the longest path_json
-	// that actually has a stored resolved_path.
-	rpMap := s.fetchResolvedPathsForTx(tx.ID)
-	if len(rpMap) == 0 {
-		return nil
-	}
-	var bestRP []*string
-	bestObsID := 0
-	bestLen := -1
-	for _, obs := range tx.Observations {
-		rp, ok := rpMap[obs.ID]
-		if !ok || rp == nil {
-			continue
-		}
-		if l := pathLen(obs.PathJSON); l > bestLen {
-			bestLen = l
-			bestRP = rp
-			bestObsID = obs.ID
-		}
-	}
-	// Populate LRU so repeat lookups for this tx don't re-issue the multi-row
-	// SQL fallback (e.g. dashboard polling /api/nodes/{pk}/health).
-	if bestRP != nil && bestObsID != 0 {
-		s.lruMu.Lock()
-		s.lruPut(bestObsID, bestRP)
-		s.lruMu.Unlock()
-	}
-	return bestRP
-}
-
-// --- Simple LRU cache for resolved paths ---
-
-const lruMaxSize = 10000
-
-// lruPut adds an entry. Must be called under s.lruMu write lock.
-func (s *PacketStore) lruPut(obsID int, rp []*string) {
-	if s.apiResolvedPathLRU == nil {
-		return
-	}
-	if _, exists := s.apiResolvedPathLRU[obsID]; exists {
-		return
-	}
-	// Compact lruOrder if stale entries exceed 50% of capacity.
-	// This prevents effective capacity degradation after bulk deletions.
-	if len(s.lruOrder) >= lruMaxSize && len(s.apiResolvedPathLRU) < lruMaxSize/2 {
-		compacted := make([]int, 0, len(s.apiResolvedPathLRU))
-		for _, id := range s.lruOrder {
-			if _, ok := s.apiResolvedPathLRU[id]; ok {
-				compacted = append(compacted, id)
-			}
-		}
-		s.lruOrder = compacted
-	}
-	if len(s.lruOrder) >= lruMaxSize {
-		// Evict oldest, skipping stale entries
-		for len(s.lruOrder) > 0 {
-			evictID := s.lruOrder[0]
-			s.lruOrder = s.lruOrder[1:]
-			if _, ok := s.apiResolvedPathLRU[evictID]; ok {
-				delete(s.apiResolvedPathLRU, evictID)
-				break
-			}
-			// stale entry — skip and continue
-		}
-	}
-	s.apiResolvedPathLRU[obsID] = rp
-	s.lruOrder = append(s.lruOrder, obsID)
-}
-
-// lruDelete removes an entry. Must be called under s.lruMu write lock.
-func (s *PacketStore) lruDelete(obsID int) {
-	if s.apiResolvedPathLRU == nil {
-		return
-	}
-	delete(s.apiResolvedPathLRU, obsID)
-	// Don't scan lruOrder — eviction handles stale entries naturally.
-}
-
-// resolvedPubkeysForEvictionBatch fetches resolved pubkeys for multiple txIDs
-// from SQL in a single batched query. Returns a map from txID to unique pubkeys.
-// MUST be called WITHOUT holding s.mu — this is the whole point of the batch approach.
-// Chunks queries to stay under SQLite's 500-parameter limit.
-func (s *PacketStore) resolvedPubkeysForEvictionBatch(txIDs []int) map[int][]string {
-	result := make(map[int][]string, len(txIDs))
-	if len(txIDs) == 0 || s.db == nil || s.db.conn == nil {
-		return result
-	}
-
-	const chunkSize = 499 // SQLite SQLITE_MAX_VARIABLE_NUMBER default is 999; stay well under
-	for start := 0; start < len(txIDs); start += chunkSize {
-		end := start + chunkSize
-		if end > len(txIDs) {
-			end = len(txIDs)
-		}
-		chunk := txIDs[start:end]
-
-		// Build query with placeholders
-		placeholders := make([]byte, 0, len(chunk)*2)
-		args := make([]interface{}, len(chunk))
-		for i, id := range chunk {
-			if i > 0 {
-				placeholders = append(placeholders, ',')
-			}
-			placeholders = append(placeholders, '?')
-			args[i] = id
-		}
-
-		query := "SELECT transmission_id, resolved_path FROM observations WHERE transmission_id IN (" +
-			string(placeholders) + ") AND resolved_path IS NOT NULL"
-
-		rows, err := s.db.conn.Query(query, args...)
-		if err != nil {
-			continue
-		}
-
-		for rows.Next() {
-			var txID int
-			var rpJSON sql.NullString
-			if err := rows.Scan(&txID, &rpJSON); err != nil {
-				continue
-			}
-			if !rpJSON.Valid || rpJSON.String == "" {
-				continue
-			}
-			rp := unmarshalResolvedPath(rpJSON.String)
-			for _, p := range rp {
-				if p != nil && *p != "" {
-					result[txID] = append(result[txID], *p)
-				}
-			}
-		}
-		rows.Close()
-	}
-
-	// Deduplicate per-txID
-	for txID, pks := range result {
-		seen := make(map[string]bool, len(pks))
-		deduped := pks[:0]
-		for _, pk := range pks {
-			if !seen[pk] {
-				seen[pk] = true
-				deduped = append(deduped, pk)
-			}
-		}
-		result[txID] = deduped
-	}
-
-	return result
-}
-
-// initResolvedPathIndex initializes the resolved path index data structures.
-func (s *PacketStore) initResolvedPathIndex() {
-	s.resolvedPubkeyIndex = make(map[uint64][]int, 4096)
-	s.resolvedPubkeyReverse = make(map[int][]uint64, 4096)
-	s.apiResolvedPathLRU = make(map[int][]*string, lruMaxSize)
-	s.lruOrder = make([]int, 0, lruMaxSize)
-}
-
-// CompactResolvedPubkeyIndex reclaims memory from the resolved pubkey index maps
-// after eviction. It removes empty forward-index entries (shouldn't exist if
-// removeFromResolvedPubkeyIndex is correct, but defense in depth) and clips
-// oversized slice backing arrays where cap > 2*len.
-// Must be called under s.mu write lock.
-func (s *PacketStore) CompactResolvedPubkeyIndex() {
-	if !s.useResolvedPathIndex {
-		return
-	}
-	for h, ids := range s.resolvedPubkeyIndex {
-		if len(ids) == 0 {
-			delete(s.resolvedPubkeyIndex, h)
-			continue
-		}
-		// Clip oversized backing arrays: if cap > 2*len, reallocate.
-		if cap(ids) > 2*len(ids)+8 {
-			clipped := make([]int, len(ids))
-			copy(clipped, ids)
-			s.resolvedPubkeyIndex[h] = clipped
-		}
-	}
-	for txID, hashes := range s.resolvedPubkeyReverse {
-		if len(hashes) == 0 {
-			delete(s.resolvedPubkeyReverse, txID)
-			continue
-		}
-		if cap(hashes) > 2*len(hashes)+8 {
-			clipped := make([]uint64, len(hashes))
-			copy(clipped, hashes)
-			s.resolvedPubkeyReverse[txID] = clipped
-		}
-	}
-}
-
-// defaultMaxResolvedPubkeyIndexEntries is the default hard cap for the forward
-// index. When exceeded, a warning is logged. No auto-eviction — that's the
-// eviction ticker's job.
-const defaultMaxResolvedPubkeyIndexEntries = 5_000_000
-
-// CheckResolvedPubkeyIndexSize logs a warning if the resolved pubkey forward
-// index exceeds the configured maximum entries. Must be called under s.mu
-// read lock at minimum.
-func (s *PacketStore) CheckResolvedPubkeyIndexSize() {
-	if !s.useResolvedPathIndex {
-		return
-	}
-	maxEntries := s.maxResolvedPubkeyIndexEntries
-	if maxEntries <= 0 {
-		maxEntries = defaultMaxResolvedPubkeyIndexEntries
-	}
-	fwdLen := len(s.resolvedPubkeyIndex)
-	revLen := len(s.resolvedPubkeyReverse)
-	if fwdLen > maxEntries || revLen > maxEntries {
-		log.Printf("[store] WARNING: resolvedPubkeyIndex size exceeds limit — forward=%d reverse=%d limit=%d",
-			fwdLen, revLen, maxEntries)
-	}
-}

cmd/server/routes.go

@@ -16,7 +16,6 @@ import (
 	"time"
 
 	"github.com/gorilla/mux"
-	"github.com/meshcore-analyzer/packetpath"
 )
 
 // Server holds shared state for route handlers.
@@ -125,7 +124,6 @@ func (s *Server) RegisterRoutes(r *mux.Router) {
 	r.Handle("/api/perf/reset", s.requireAPIKey(http.HandlerFunc(s.handlePerfReset))).Methods("POST")
 	r.Handle("/api/admin/prune", s.requireAPIKey(http.HandlerFunc(s.handleAdminPrune))).Methods("POST")
 	r.Handle("/api/debug/affinity", s.requireAPIKey(http.HandlerFunc(s.handleDebugAffinity))).Methods("GET")
-	r.Handle("/api/dropped-packets", s.requireAPIKey(http.HandlerFunc(s.handleDroppedPackets))).Methods("GET")
 
 	// Packet endpoints
 	r.HandleFunc("/api/packets/observations", s.handleBatchObservations).Methods("POST")
@@ -173,7 +171,6 @@ func (s *Server) RegisterRoutes(r *mux.Router) {
 	r.HandleFunc("/api/observers/{id}", s.handleObserverDetail).Methods("GET")
 	r.HandleFunc("/api/observers", s.handleObservers).Methods("GET")
 	r.HandleFunc("/api/traces/{hash}", s.handleTraces).Methods("GET")
-	r.HandleFunc("/api/paths/inspect", s.handlePathInspect).Methods("POST")
 	r.HandleFunc("/api/iata-coords", s.handleIATACoords).Methods("GET")
 	r.HandleFunc("/api/audio-lab/buckets", s.handleAudioLabBuckets).Methods("GET")
 
@@ -571,16 +568,6 @@ func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
 		backfillProgress = 1
 	}
 
-	// Memory accounting (#832). storeDataMB is the in-store packet byte
-	// estimate (the old "trackedMB"); processRSSMB / goHeapInuseMB / goSysMB
-	// give ops the breakdown needed to reason about real RSS. All values
-	// share a single 1s-cached snapshot to amortize ReadMemStats cost.
-	var storeDataMB float64
-	if s.store != nil {
-		storeDataMB = s.store.trackedMemoryMB()
-	}
-	mem := s.getMemorySnapshot(storeDataMB)
-
 	resp := &StatsResponse{
 		TotalPackets:       stats.TotalPackets,
 		TotalTransmissions: &stats.TotalTransmissions,
@@ -600,16 +587,8 @@ func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
 			Companions: counts["companions"],
 			Sensors:    counts["sensors"],
 		},
-		Backfilling:           backfilling,
-		BackfillProgress:      backfillProgress,
-		SignatureDrops:        s.db.GetSignatureDropCount(),
-		HashMigrationComplete: s.store != nil && s.store.hashMigrationComplete.Load(),
-
-		TrackedMB:     mem.StoreDataMB, // deprecated alias
-		StoreDataMB:   mem.StoreDataMB,
-		ProcessRSSMB:  mem.ProcessRSSMB,
-		GoHeapInuseMB: mem.GoHeapInuseMB,
-		GoSysMB:       mem.GoSysMB,
+		Backfilling:      backfilling,
+		BackfillProgress: backfillProgress,
 	}
 
 	s.statsMu.Lock()
@@ -792,7 +771,6 @@ func (s *Server) handlePackets(w http.ResponseWriter, r *http.Request) {
 		Until:    r.URL.Query().Get("until"),
 		Region:   r.URL.Query().Get("region"),
 		Node:     r.URL.Query().Get("node"),
-		Channel:  r.URL.Query().Get("channel"),
 		Order:              "DESC",
 		ExpandObservations: r.URL.Query().Get("expand") == "observations",
 	}
@@ -895,11 +873,9 @@ func (s *Server) handleBatchObservations(w http.ResponseWriter, r *http.Request)
 func (s *Server) handlePacketDetail(w http.ResponseWriter, r *http.Request) {
 	param := mux.Vars(r)["id"]
 	var packet map[string]interface{}
-	fromDB := false
 
-	isHash := hashPattern.MatchString(strings.ToLower(param))
 	if s.store != nil {
-		if isHash {
+		if hashPattern.MatchString(strings.ToLower(param)) {
 			packet = s.store.GetPacketByHash(param)
 		}
 		if packet == nil {
@@ -912,25 +888,6 @@ func (s *Server) handlePacketDetail(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 	}
-	// DB fallback: in-memory PacketStore prunes old entries, but the SQLite
-	// DB retains them and is the source for /api/nodes recentAdverts. Without
-	// this fallback, links from node-detail pages 404 once the packet ages out.
-	if packet == nil && s.db != nil {
-		if isHash {
-			if dbPkt, err := s.db.GetPacketByHash(param); err == nil && dbPkt != nil {
-				packet = dbPkt
-				fromDB = true
-			}
-		}
-		if packet == nil {
-			if id, parseErr := strconv.Atoi(param); parseErr == nil {
-				if dbPkt, err := s.db.GetTransmissionByID(id); err == nil && dbPkt != nil {
-					packet = dbPkt
-					fromDB = true
-				}
-			}
-		}
-	}
 	if packet == nil {
 		writeError(w, 404, "Not found")
 		return
@@ -941,9 +898,6 @@ func (s *Server) handlePacketDetail(w http.ResponseWriter, r *http.Request) {
 	if s.store != nil {
 		observations = s.store.GetObservationsForHash(hash)
 	}
-	if len(observations) == 0 && fromDB && s.db != nil && hash != "" {
-		observations = s.db.GetObservationsForHash(hash)
-	}
 	observationCount := len(observations)
 	if observationCount == 0 {
 		observationCount = 1
@@ -959,9 +913,11 @@ func (s *Server) handlePacketDetail(w http.ResponseWriter, r *http.Request) {
 		pathHops = []interface{}{}
 	}
 
+	rawHex, _ := packet["raw_hex"].(string)
 	writeJSON(w, PacketDetailResponse{
 		Packet:           packet,
 		Path:             pathHops,
+		Breakdown:        BuildBreakdown(rawHex),
 		ObservationCount: observationCount,
 		Observations:     mapSliceToObservations(observations),
 	})
@@ -1020,17 +976,8 @@ func (s *Server) handlePostPacket(w http.ResponseWriter, r *http.Request) {
 
 	contentHash := ComputeContentHash(hexStr)
 	pathJSON := "[]"
-	// For TRACE packets, path_json must be the payload-decoded route hops
-	// (decoded.Path.Hops), NOT the raw_hex header bytes which are SNR values.
-	// For all other packet types, derive path from raw_hex (#886).
-	if !packetpath.PathBytesAreHops(byte(decoded.Header.PayloadType)) {
-		if len(decoded.Path.Hops) > 0 {
-			if pj, e := json.Marshal(decoded.Path.Hops); e == nil {
-				pathJSON = string(pj)
-			}
-		}
-	} else if hops, err := packetpath.DecodePathFromRawHex(hexStr); err == nil && len(hops) > 0 {
-		if pj, e := json.Marshal(hops); e == nil {
+	if len(decoded.Path.Hops) > 0 {
+		if pj, e := json.Marshal(decoded.Path.Hops); e == nil {
 			pathJSON = string(pj)
 		}
 	}
@@ -1104,17 +1051,6 @@ func (s *Server) handleNodes(w http.ResponseWriter, r *http.Request) {
 		total = len(filtered)
 		nodes = filtered
 	}
-	// Filter blacklisted nodes
-	if len(s.cfg.NodeBlacklist) > 0 {
-		filtered := nodes[:0]
-		for _, node := range nodes {
-			if pk, ok := node["public_key"].(string); !ok || !s.cfg.IsBlacklisted(pk) {
-				filtered = append(filtered, node)
-			}
-		}
-		total = len(filtered)
-		nodes = filtered
-	}
 	writeJSON(w, NodeListResponse{Nodes: nodes, Total: total, Counts: counts})
 }
 
@@ -1129,25 +1065,11 @@ func (s *Server) handleNodeSearch(w http.ResponseWriter, r *http.Request) {
 		writeError(w, 500, err.Error())
 		return
 	}
-	// Filter blacklisted nodes from search results
-	if len(s.cfg.NodeBlacklist) > 0 {
-		filtered := make([]map[string]interface{}, 0, len(nodes))
-		for _, node := range nodes {
-			if pk, ok := node["public_key"].(string); !ok || !s.cfg.IsBlacklisted(pk) {
-				filtered = append(filtered, node)
-			}
-		}
-		nodes = filtered
-	}
 	writeJSON(w, NodeSearchResponse{Nodes: nodes})
 }
 
 func (s *Server) handleNodeDetail(w http.ResponseWriter, r *http.Request) {
 	pubkey := mux.Vars(r)["pubkey"]
-	if s.cfg.IsBlacklisted(pubkey) {
-		writeError(w, 404, "Not found")
-		return
-	}
 	node, err := s.db.GetNodeByPubkey(pubkey)
 	if err != nil || node == nil {
 		writeError(w, 404, "Not found")
@@ -1173,10 +1095,6 @@ func (s *Server) handleNodeDetail(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) handleNodeHealth(w http.ResponseWriter, r *http.Request) {
 	pubkey := mux.Vars(r)["pubkey"]
-	if s.cfg.IsBlacklisted(pubkey) {
-		writeError(w, 404, "Not found")
-		return
-	}
 	if s.store != nil {
 		result, err := s.store.GetNodeHealth(pubkey)
 		if err != nil || result == nil {
@@ -1197,19 +1115,7 @@ func (s *Server) handleBulkHealth(w http.ResponseWriter, r *http.Request) {
 
 	if s.store != nil {
 		region := r.URL.Query().Get("region")
-		results := s.store.GetBulkHealth(limit, region)
-		// Filter blacklisted nodes
-		if len(s.cfg.NodeBlacklist) > 0 {
-			filtered := make([]map[string]interface{}, 0, len(results))
-			for _, entry := range results {
-				if pk, ok := entry["public_key"].(string); !ok || !s.cfg.IsBlacklisted(pk) {
-					filtered = append(filtered, entry)
-				}
-			}
-			writeJSON(w, filtered)
-			return
-		}
-		writeJSON(w, results)
+		writeJSON(w, s.store.GetBulkHealth(limit, region))
 		return
 	}
 
@@ -1228,10 +1134,6 @@ func (s *Server) handleNetworkStatus(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) handleNodePaths(w http.ResponseWriter, r *http.Request) {
 	pubkey := mux.Vars(r)["pubkey"]
-	if s.cfg.IsBlacklisted(pubkey) {
-		writeError(w, 404, "Not found")
-		return
-	}
 	node, err := s.db.GetNodeByPubkey(pubkey)
 	if err != nil || node == nil {
 		writeError(w, 404, "Not found")
@@ -1283,52 +1185,14 @@ func (s *Server) handleNodePaths(w http.ResponseWriter, r *http.Request) {
 	// Post-filter: verify target node actually appears in each candidate's resolved_path.
 	// The byPathHop index uses short prefixes which can collide (e.g. "c0" matches multiple nodes).
 	// We lean on resolved_path (from neighbor affinity graph) to disambiguate.
-	//
-	// Collect candidate IDs and index membership under the read lock, then release
-	// the lock before running SQL queries (confirmResolvedPathContains does disk I/O).
-	type candidateCheck struct {
-		tx         *StoreTx
-		hasReverse bool
-		inIndex    bool
-	}
-	checks := make([]candidateCheck, len(candidates))
-	for i, tx := range candidates {
-		cc := candidateCheck{tx: tx}
-		if !s.store.useResolvedPathIndex {
-			cc.inIndex = true // flag off — keep all
-		} else if _, hasRev := s.store.resolvedPubkeyReverse[tx.ID]; !hasRev {
-			cc.inIndex = true // no indexed pubkeys — keep (conservative)
-		} else {
-			h := resolvedPubkeyHash(lowerPK)
-			for _, id := range s.store.resolvedPubkeyIndex[h] {
-				if id == tx.ID {
-					cc.hasReverse = true // needs SQL confirmation
-					break
-				}
-			}
-			// If not in index at all, it's a definite no
+	filtered := candidates[:0] // reuse backing array
+	for _, tx := range candidates {
+		if nodeInResolvedPath(tx, lowerPK) {
+			filtered = append(filtered, tx)
 		}
-		checks[i] = cc
-	}
-	s.store.mu.RUnlock()
-
-	// Now run SQL checks outside the lock for candidates that need confirmation.
-	filtered := candidates[:0]
-	for _, cc := range checks {
-		if cc.inIndex {
-			filtered = append(filtered, cc.tx)
-		} else if cc.hasReverse {
-			if s.store.confirmResolvedPathContains(cc.tx.ID, lowerPK) {
-				filtered = append(filtered, cc.tx)
-			}
-		}
-		// else: not in index → exclude
 	}
 	candidates = filtered
 
-	// Re-acquire read lock for the aggregation phase that reads store data.
-	s.store.mu.RLock()
-
 	type pathAgg struct {
 		Hops       []PathHopResp
 		Count      int
@@ -1433,10 +1297,6 @@ func (s *Server) handleNodePaths(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) handleNodeAnalytics(w http.ResponseWriter, r *http.Request) {
 	pubkey := mux.Vars(r)["pubkey"]
-	if s.cfg.IsBlacklisted(pubkey) {
-		writeError(w, 404, "Not found")
-		return
-	}
 	days := queryInt(r, "days", 7)
 	if days < 1 {
 		days = 1
@@ -1513,11 +1373,7 @@ func (s *Server) handleAnalyticsRF(w http.ResponseWriter, r *http.Request) {
 func (s *Server) handleAnalyticsTopology(w http.ResponseWriter, r *http.Request) {
 	region := r.URL.Query().Get("region")
 	if s.store != nil {
-		data := s.store.GetAnalyticsTopology(region)
-		if s.cfg != nil && len(s.cfg.NodeBlacklist) > 0 {
-			data = s.filterBlacklistedFromTopology(data)
-		}
-		writeJSON(w, data)
+		writeJSON(w, s.store.GetAnalyticsTopology(region))
 		return
 	}
 	writeJSON(w, TopologyResponse{
@@ -1605,11 +1461,7 @@ func (s *Server) handleAnalyticsSubpaths(w http.ResponseWriter, r *http.Request)
 		}
 		maxLen := queryInt(r, "maxLen", 8)
 		limit := queryInt(r, "limit", 100)
-		data := s.store.GetAnalyticsSubpaths(region, minLen, maxLen, limit)
-		if s.cfg != nil && len(s.cfg.NodeBlacklist) > 0 {
-			data = s.filterBlacklistedFromSubpaths(data)
-		}
-		writeJSON(w, data)
+		writeJSON(w, s.store.GetAnalyticsSubpaths(region, minLen, maxLen, limit))
 		return
 	}
 	writeJSON(w, SubpathsResponse{
@@ -1661,11 +1513,6 @@ func (s *Server) handleAnalyticsSubpathsBulk(w http.ResponseWriter, r *http.Requ
 	}
 
 	results := s.store.GetAnalyticsSubpathsBulk(region, groups)
-	if s.cfg != nil && len(s.cfg.NodeBlacklist) > 0 {
-		for i, r := range results {
-			results[i] = s.filterBlacklistedFromSubpaths(r)
-		}
-	}
 	writeJSON(w, map[string]interface{}{"results": results})
 }
 
@@ -1685,15 +1532,6 @@ func (s *Server) handleAnalyticsSubpathDetail(w http.ResponseWriter, r *http.Req
 		writeJSON(w, ErrorResp{Error: "Need at least 2 hops"})
 		return
 	}
-	// Reject if any hop is a blacklisted node.
-	if s.cfg != nil && len(s.cfg.NodeBlacklist) > 0 {
-		for _, hop := range rawHops {
-			if s.cfg.IsBlacklisted(hop) {
-				writeError(w, 404, "Not found")
-				return
-			}
-		}
-	}
 	if s.store != nil {
 		writeJSON(w, s.store.GetSubpathDetail(rawHops))
 		return
@@ -1759,10 +1597,6 @@ func (s *Server) handleResolveHops(w http.ResponseWriter, r *http.Request) {
 		if pm != nil {
 			if matched, ok := pm.m[hopLower]; ok {
 				for _, ni := range matched {
-					// Skip blacklisted nodes from resolution results.
-					if s.cfg != nil && s.cfg.IsBlacklisted(ni.PublicKey) {
-						continue
-					}
 					c := HopCandidate{Pubkey: ni.PublicKey}
 					if ni.Name != "" {
 						c.Name = ni.Name
@@ -1831,8 +1665,7 @@ func (s *Server) handleResolveHops(w http.ResponseWriter, r *http.Request) {
 			}
 
 			// Use the resolved node as the default (best-effort pick).
-			// Skip if the best pick is a blacklisted node.
-			if best != nil && !(s.cfg != nil && s.cfg.IsBlacklisted(best.PublicKey)) {
+			if best != nil {
 				hr.Name = best.Name
 				hr.Pubkey = best.PublicKey
 			}
@@ -2375,6 +2208,9 @@ func mapSliceToTransmissions(maps []map[string]interface{}) []TransmissionResp {
 		tx.PathJSON = m["path_json"]
 		tx.Direction = m["direction"]
 		tx.Score = m["score"]
+		if rp, ok := m["resolved_path"].([]*string); ok {
+			tx.ResolvedPath = rp
+		}
 		result = append(result, tx)
 	}
 	return result
@@ -2395,10 +2231,10 @@ func mapSliceToObservations(maps []map[string]interface{}) []ObservationResp {
 		obs.SNR = m["snr"]
 		obs.RSSI = m["rssi"]
 		obs.PathJSON = m["path_json"]
-		obs.ResolvedPath = m["resolved_path"]
-		obs.Direction = m["direction"]
-		obs.RawHex = m["raw_hex"]
 		obs.Timestamp = m["timestamp"]
+		if rp, ok := m["resolved_path"].([]*string); ok {
+			obs.ResolvedPath = rp
+		}
 		result = append(result, obs)
 	}
 	return result
@@ -2549,167 +2385,16 @@ func (s *Server) handleAdminPrune(w http.ResponseWriter, r *http.Request) {
 		writeError(w, 400, "days parameter required (or set retention.packetDays in config)")
 		return
 	}
-
-	results := map[string]interface{}{}
-
-	// Prune old packets
 	n, err := s.db.PruneOldPackets(days)
 	if err != nil {
 		writeError(w, 500, err.Error())
 		return
 	}
 	log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
-	results["packets_deleted"] = n
-	results["deleted"] = n // legacy alias
-
-	// Also mark stale observers as inactive if observerDays is configured
-	observerDays := s.cfg.ObserverDaysOrDefault()
-	if observerDays > 0 {
-		obsN, obsErr := s.db.RemoveStaleObservers(observerDays)
-		if obsErr != nil {
-			log.Printf("[prune] observer prune error: %v", obsErr)
-		} else {
-			results["observers_inactive"] = obsN
-		}
-	}
-
-	results["days"] = days
-	writeJSON(w, results)
+	writeJSON(w, map[string]interface{}{"deleted": n, "days": days})
 }
 
 // constantTimeEqual compares two strings in constant time to prevent timing attacks.
 func constantTimeEqual(a, b string) bool {
 	return subtle.ConstantTimeCompare([]byte(a), []byte(b)) == 1
 }
-
-// filterBlacklistedFromTopology removes blacklisted node references from the
-// topology analytics response (TopRepeaters, TopPairs, BestPathList, MultiObsNodes, PerObserverReach).
-func (s *Server) filterBlacklistedFromTopology(data map[string]interface{}) map[string]interface{} {
-	// Filter TopRepeaters
-	if repeaters, ok := data["topRepeaters"]; ok {
-		if arr, ok := repeaters.([]TopRepeater); ok {
-			var filtered []TopRepeater
-			for _, r := range arr {
-				if pk, ok := r.Pubkey.(string); ok && s.cfg.IsBlacklisted(pk) {
-					continue
-				}
-				filtered = append(filtered, r)
-			}
-			data["topRepeaters"] = filtered
-		}
-	}
-
-	// Filter TopPairs
-	if pairs, ok := data["topPairs"]; ok {
-		if arr, ok := pairs.([]TopPair); ok {
-			var filtered []TopPair
-			for _, p := range arr {
-				if pkA, ok := p.PubkeyA.(string); ok && s.cfg.IsBlacklisted(pkA) {
-					continue
-				}
-				if pkB, ok := p.PubkeyB.(string); ok && s.cfg.IsBlacklisted(pkB) {
-					continue
-				}
-				filtered = append(filtered, p)
-			}
-			data["topPairs"] = filtered
-		}
-	}
-
-	// Filter BestPathList
-	if paths, ok := data["bestPathList"]; ok {
-		if arr, ok := paths.([]BestPathEntry); ok {
-			var filtered []BestPathEntry
-			for _, p := range arr {
-				if pk, ok := p.Pubkey.(string); ok && s.cfg.IsBlacklisted(pk) {
-					continue
-				}
-				filtered = append(filtered, p)
-			}
-			data["bestPathList"] = filtered
-		}
-	}
-
-	// Filter MultiObsNodes
-	if nodes, ok := data["multiObsNodes"]; ok {
-		if arr, ok := nodes.([]MultiObsNode); ok {
-			var filtered []MultiObsNode
-			for _, n := range arr {
-				if pk, ok := n.Pubkey.(string); ok && s.cfg.IsBlacklisted(pk) {
-					continue
-				}
-				filtered = append(filtered, n)
-			}
-			data["multiObsNodes"] = filtered
-		}
-	}
-
-	// Filter PerObserverReach
-	if reach, ok := data["perObserverReach"]; ok {
-		if m, ok := reach.(map[string]*ObserverReach); ok {
-			for k, v := range m {
-				for ri := range v.Rings {
-					var filteredNodes []ReachNode
-					for _, rn := range v.Rings[ri].Nodes {
-						if pk, ok := rn.Pubkey.(string); ok && s.cfg.IsBlacklisted(pk) {
-							continue
-						}
-						filteredNodes = append(filteredNodes, rn)
-					}
-					v.Rings[ri].Nodes = filteredNodes
-				}
-				m[k] = v
-			}
-		}
-	}
-
-	return data
-}
-
-// filterBlacklistedFromSubpaths removes blacklisted node references from
-// the subpaths analytics response.
-func (s *Server) filterBlacklistedFromSubpaths(data map[string]interface{}) map[string]interface{} {
-	if subpaths, ok := data["subpaths"]; ok {
-		if arr, ok := subpaths.([]interface{}); ok {
-			var filtered []interface{}
-			for _, item := range arr {
-				if m, ok := item.(map[string]interface{}); ok {
-					if hops, ok := m["hops"].([]interface{}); ok {
-						skip := false
-						for _, h := range hops {
-							if hp, ok := h.(string); ok && s.cfg.IsBlacklisted(hp) {
-								skip = true
-								break
-							}
-						}
-						if skip {
-							continue
-						}
-					}
-				}
-				filtered = append(filtered, item)
-			}
-			data["subpaths"] = filtered
-		}
-	}
-	return data
-}
-
-// handleDroppedPackets returns recently dropped packets for investigation.
-func (s *Server) handleDroppedPackets(w http.ResponseWriter, r *http.Request) {
-	limit := 100
-	if v := r.URL.Query().Get("limit"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil && n > 0 {
-			limit = n
-		}
-	}
-	observerID := r.URL.Query().Get("observer")
-	nodePubkey := r.URL.Query().Get("pubkey")
-
-	results, err := s.db.GetDroppedPackets(limit, observerID, nodePubkey)
-	if err != nil {
-		writeError(w, 500, err.Error())
-		return
-	}
-	writeJSON(w, results)
-}

cmd/server/routes_test.go

@@ -3681,55 +3681,67 @@ func TestNodePathsPrefixCollisionFilter(t *testing.T) {
 func TestNodeInResolvedPath(t *testing.T) {
 	target := "aabbccdd11223344"
 
-	// After #800, nodeInResolvedPath is replaced by nodeInResolvedPathViaIndex
-	// which uses the membership index. Test the index-based approach.
-	store := &PacketStore{
-		byNode:               make(map[string][]*StoreTx),
-		nodeHashes:           make(map[string]map[string]bool),
-		useResolvedPathIndex: true,
-	}
-	store.initResolvedPathIndex()
-
-	// Case 1: tx indexed with target pubkey
-	tx1 := &StoreTx{ID: 1}
-	store.addToResolvedPubkeyIndex(1, []string{target})
-	if !store.nodeInResolvedPathViaIndex(tx1, target) {
-		t.Error("should match when index contains target")
+	// Case 1: tx.ResolvedPath contains target
+	pk := "aabbccdd11223344"
+	tx1 := &StoreTx{ResolvedPath: []*string{&pk}}
+	if !nodeInResolvedPath(tx1, target) {
+		t.Error("should match when ResolvedPath contains target")
 	}
 
-	// Case 2: tx indexed with different pubkey
-	tx2 := &StoreTx{ID: 2}
-	store.addToResolvedPubkeyIndex(2, []string{"aacafe0000000000"})
-	if store.nodeInResolvedPathViaIndex(tx2, target) {
-		t.Error("should not match when index contains different node")
+	// Case 2: tx.ResolvedPath contains different node
+	other := "aacafe0000000000"
+	tx2 := &StoreTx{ResolvedPath: []*string{&other}}
+	if nodeInResolvedPath(tx2, target) {
+		t.Error("should not match when ResolvedPath contains different node")
 	}
 
-	// Case 3: tx not in index at all — should match (no data to disambiguate)
-	tx3 := &StoreTx{ID: 3}
-	if !store.nodeInResolvedPathViaIndex(tx3, target) {
-		t.Error("should match when tx has no index entries (no data to disambiguate)")
+	// Case 3: nil ResolvedPath — should match (no data to disambiguate, keep it)
+	tx3 := &StoreTx{}
+	if !nodeInResolvedPath(tx3, target) {
+		t.Error("should match when ResolvedPath is nil (no data to disambiguate)")
+	}
+
+	// Case 4: ResolvedPath with nil elements only — has data but no match
+	tx4 := &StoreTx{ResolvedPath: []*string{nil, nil}}
+	if nodeInResolvedPath(tx4, target) {
+		t.Error("should not match when all ResolvedPath elements are nil")
+	}
+
+	// Case 5: target in observation but not in tx.ResolvedPath
+	tx5 := &StoreTx{
+		ResolvedPath: []*string{&other},
+		Observations: []*StoreObs{
+			{ResolvedPath: []*string{&pk}},
+		},
+	}
+	if !nodeInResolvedPath(tx5, target) {
+		t.Error("should match when observation's ResolvedPath contains target")
 	}
 }
 
 func TestPathHopIndexIncrementalUpdate(t *testing.T) {
-	// After #800, addTxToPathHopIndex only indexes raw hops (not resolved pubkeys).
-	// Resolved pubkeys are handled by the resolved pubkey membership index.
+	// Test that addTxToPathHopIndex and removeTxFromPathHopIndex work correctly
 	idx := make(map[string][]*StoreTx)
 
+	pk1 := "fullpubkey1"
 	tx1 := &StoreTx{
 		ID:       1,
 		PathJSON: `["ab","cd"]`,
+		ResolvedPath: []*string{&pk1, nil},
 	}
 
 	addTxToPathHopIndex(idx, tx1)
 
-	// Should be indexed under "ab" and "cd" only (no resolved pubkey)
+	// Should be indexed under "ab", "cd", and "fullpubkey1"
 	if len(idx["ab"]) != 1 {
 		t.Errorf("expected 1 entry for 'ab', got %d", len(idx["ab"]))
 	}
 	if len(idx["cd"]) != 1 {
 		t.Errorf("expected 1 entry for 'cd', got %d", len(idx["cd"]))
 	}
+	if len(idx["fullpubkey1"]) != 1 {
+		t.Errorf("expected 1 entry for resolved pubkey, got %d", len(idx["fullpubkey1"]))
+	}
 
 	// Add another tx with overlapping hop
 	tx2 := &StoreTx{
@@ -3754,6 +3766,9 @@ func TestPathHopIndexIncrementalUpdate(t *testing.T) {
 	if _, ok := idx["cd"]; ok {
 		t.Error("expected 'cd' key to be deleted after removal")
 	}
+	if _, ok := idx["fullpubkey1"]; ok {
+		t.Error("expected resolved pubkey key to be deleted after removal")
+	}
 }
 
 func TestMetricsAPIEndpoints(t *testing.T) {
@@ -3793,182 +3808,3 @@ func TestMetricsAPIEndpoints(t *testing.T) {
 		t.Errorf("expected 1 observer in summary, got %v", resp2["observers"])
 	}
 }
-
-// TestNodeHealth_RecentPackets_ResolvedPath verifies that recentPackets in the
-// node health endpoint include resolved_path (regression for Codex review item #2).
-func TestNodeHealth_RecentPackets_ResolvedPath(t *testing.T) {
-	_, router := setupTestServer(t)
-	req := httptest.NewRequest("GET", "/api/nodes/aabbccdd11223344/health", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	if w.Code != 200 {
-		t.Fatalf("expected 200, got %d (body: %s)", w.Code, w.Body.String())
-	}
-	var body map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-		t.Fatalf("json decode: %v", err)
-	}
-	rp, ok := body["recentPackets"].([]interface{})
-	if !ok || len(rp) == 0 {
-		t.Fatal("expected non-empty recentPackets")
-	}
-	// At least one packet should have resolved_path (tx 1 has observations with resolved_path)
-	found := false
-	for _, p := range rp {
-		pm, ok := p.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		if pm["resolved_path"] != nil {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Error("expected at least one recentPacket with resolved_path")
-	}
-}
-
-// TestPacketsExpand_ResolvedPath verifies that expandObservations=true includes
-// resolved_path on expanded observations (regression for Codex review item #3).
-func TestPacketsExpand_ResolvedPath(t *testing.T) {
-	_, router := setupTestServer(t)
-	req := httptest.NewRequest("GET", "/api/packets?expand=observations&limit=10", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	if w.Code != 200 {
-		t.Fatalf("expected 200, got %d (body: %s)", w.Code, w.Body.String())
-	}
-	var body map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-		t.Fatalf("json decode: %v", err)
-	}
-	packets, ok := body["packets"].([]interface{})
-	if !ok || len(packets) == 0 {
-		t.Fatal("expected non-empty packets")
-	}
-	// Find a packet with observations that should have resolved_path
-	found := false
-	for _, p := range packets {
-		pm, ok := p.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		obs, ok := pm["observations"].([]interface{})
-		if !ok {
-			continue
-		}
-		for _, o := range obs {
-			om, ok := o.(map[string]interface{})
-			if !ok {
-				continue
-			}
-			if om["resolved_path"] != nil {
-				found = true
-				break
-			}
-		}
-		if found {
-			break
-		}
-	}
-	if !found {
-		t.Error("expected at least one expanded observation with resolved_path")
-	}
-}
-
-// TestPacketDetailFallsBackToDBWhenStoreMisses verifies that handlePacketDetail
-// serves transmissions present in the DB but absent from the in-memory store.
-// This is the recentAdverts → "Not found" bug (#827).
-func TestPacketDetailFallsBackToDBWhenStoreMisses(t *testing.T) {
-	srv, router := setupTestServer(t)
-	// Insert a transmission directly into the DB AFTER store.Load(), so the
-	// in-memory PacketStore won't see it. Mirrors the production case where
-	// the store has pruned an entry but the DB still has it.
-	const dbOnlyHash = "deadbeef00112233"
-	now := time.Now().UTC().Format(time.RFC3339)
-	if _, err := srv.db.conn.Exec(`INSERT INTO transmissions
-		(raw_hex, hash, first_seen, route_type, payload_type, decoded_json)
-		VALUES ('FFEE', ?, ?, 1, 4, '{"type":"ADVERT"}')`, dbOnlyHash, now); err != nil {
-		t.Fatalf("insert: %v", err)
-	}
-	var txID int
-	if err := srv.db.conn.QueryRow("SELECT id FROM transmissions WHERE hash = ?", dbOnlyHash).Scan(&txID); err != nil {
-		t.Fatalf("lookup tx id: %v", err)
-	}
-	if _, err := srv.db.conn.Exec(`INSERT INTO observations
-		(transmission_id, observer_idx, snr, rssi, path_json, timestamp)
-		VALUES (?, 1, 7.5, -99, '[]', ?)`, txID, time.Now().Unix()); err != nil {
-		t.Fatalf("insert obs: %v", err)
-	}
-
-	// Confirm the store really doesn't have it (precondition for the fix).
-	if got := srv.store.GetPacketByHash(dbOnlyHash); got != nil {
-		t.Fatalf("test precondition failed: store unexpectedly has %s", dbOnlyHash)
-	}
-
-	req := httptest.NewRequest("GET", "/api/packets/"+dbOnlyHash, nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-	if w.Code != 200 {
-		t.Fatalf("expected 200, got %d (body: %s)", w.Code, w.Body.String())
-	}
-	var body map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-		t.Fatal(err)
-	}
-	pkt, ok := body["packet"].(map[string]interface{})
-	if !ok {
-		t.Fatal("expected packet object")
-	}
-	if pkt["hash"] != dbOnlyHash {
-		t.Errorf("expected hash %s, got %v", dbOnlyHash, pkt["hash"])
-	}
-	// Observations fallback should populate from DB too.
-	obs, _ := body["observations"].([]interface{})
-	if len(obs) == 0 {
-		t.Errorf("expected DB observations to be returned, got 0")
-	}
-}
-
-// TestPacketDetail404WhenAbsentFromBoth verifies that a hash present in
-// neither store nor DB still returns 404 (no false positives from the fallback).
-func TestPacketDetail404WhenAbsentFromBoth(t *testing.T) {
-	_, router := setupTestServer(t)
-	req := httptest.NewRequest("GET", "/api/packets/0011223344556677", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-	if w.Code != 404 {
-		t.Errorf("expected 404, got %d (body: %s)", w.Code, w.Body.String())
-	}
-}
-
-// TestPacketDetailPrefersStoreOverDB verifies the store result wins when the
-// hash exists in both — the DB fallback must not double-fetch / overwrite.
-func TestPacketDetailPrefersStoreOverDB(t *testing.T) {
-	srv, router := setupTestServer(t)
-	// abc123def4567890 is seeded in both DB and (after Load) the store.
-	const hash = "abc123def4567890"
-	if got := srv.store.GetPacketByHash(hash); got == nil {
-		t.Fatalf("test precondition failed: store should have %s", hash)
-	}
-
-	req := httptest.NewRequest("GET", "/api/packets/"+hash, nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-	if w.Code != 200 {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-	var body map[string]interface{}
-	json.Unmarshal(w.Body.Bytes(), &body)
-	pkt, _ := body["packet"].(map[string]interface{})
-	if pkt == nil || pkt["hash"] != hash {
-		t.Fatalf("expected packet with hash %s, got %v", hash, pkt)
-	}
-	// observation_count comes from store observations (2 seeded for tx 1).
-	if cnt, _ := body["observation_count"].(float64); cnt != 2 {
-		t.Errorf("expected observation_count=2 (from store), got %v", body["observation_count"])
-	}
-}

cmd/server/stats_memory_test.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-// TestStatsMemoryFields verifies that /api/stats exposes the new memory
-// breakdown introduced for issue #832: storeDataMB, processRSSMB,
-// goHeapInuseMB, goSysMB, plus the deprecated trackedMB alias.
-//
-// We assert presence, type, sign, and ordering invariants — but NOT
-// "RSS within X% of true RSS" because that is flaky in CI under cgo,
-// containerization, and shared-runner load.
-func TestStatsMemoryFields(t *testing.T) {
-	_, router := setupTestServer(t)
-	req := httptest.NewRequest("GET", "/api/stats", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	if w.Code != 200 {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-	var body map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-		t.Fatalf("json decode: %v", err)
-	}
-
-	required := []string{"trackedMB", "storeDataMB", "processRSSMB", "goHeapInuseMB", "goSysMB"}
-	values := make(map[string]float64, len(required))
-	for _, k := range required {
-		v, ok := body[k]
-		if !ok {
-			t.Fatalf("missing field %q in /api/stats response", k)
-		}
-		f, ok := v.(float64)
-		if !ok {
-			t.Fatalf("field %q is %T, expected float64", k, v)
-		}
-		if f < 0 {
-			t.Errorf("field %q is negative: %v", k, f)
-		}
-		values[k] = f
-	}
-
-	// trackedMB is a deprecated alias for storeDataMB; they must match.
-	if values["trackedMB"] != values["storeDataMB"] {
-		t.Errorf("trackedMB (%v) != storeDataMB (%v); they must remain aliased",
-			values["trackedMB"], values["storeDataMB"])
-	}
-
-	// Ordering invariants. goSys is the runtime's view of total OS memory;
-	// HeapInuse is a subset of it. storeData is a subset of HeapInuse.
-	// processRSS may be 0 in environments without /proc — treat 0 as
-	// "unknown" rather than a failure.
-	if values["goHeapInuseMB"] > values["goSysMB"]+0.5 {
-		t.Errorf("invariant violated: goHeapInuseMB (%v) > goSysMB (%v)",
-			values["goHeapInuseMB"], values["goSysMB"])
-	}
-	if values["storeDataMB"] > values["goHeapInuseMB"]+0.5 && values["storeDataMB"] > 0 {
-		// In the test fixture storeDataMB is typically 0 (no packets in
-		// store); only enforce the bound when both are nonzero.
-		t.Errorf("invariant violated: storeDataMB (%v) > goHeapInuseMB (%v)",
-			values["storeDataMB"], values["goHeapInuseMB"])
-	}
-	if values["processRSSMB"] > 0 && values["goSysMB"] > 0 {
-		// goSys can briefly exceed RSS if pages are reserved-but-not-touched,
-		// so allow some slack.
-		if values["goSysMB"] > values["processRSSMB"]*4 {
-			t.Errorf("suspicious: goSysMB (%v) >> processRSSMB (%v)",
-				values["goSysMB"], values["processRSSMB"])
-		}
-	}
-}
-
-// TestStatsMemoryFieldsRawJSON spot-checks that the JSON wire format uses
-// the documented camelCase names (no accidental rename through struct tags).
-func TestStatsMemoryFieldsRawJSON(t *testing.T) {
-	_, router := setupTestServer(t)
-	req := httptest.NewRequest("GET", "/api/stats", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	body := w.Body.String()
-	for _, key := range []string{
-		`"trackedMB":`, `"storeDataMB":`,
-		`"processRSSMB":`, `"goHeapInuseMB":`, `"goSysMB":`,
-	} {
-		if !strings.Contains(body, key) {
-			t.Errorf("missing %s in raw response: %s", key, body)
-		}
-	}
-}

cmd/server/store_tophops_test.go

@@ -1,116 +0,0 @@
-package main
-
-import (
-	"testing"
-)
-
-func f64(v float64) *float64 { return &v }
-
-func TestDedupeTopHopsByPair(t *testing.T) {
-	hops := []distHopRecord{
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 100, Type: "R↔R", SNR: f64(5.0), Hash: "h1", Timestamp: "t1"},
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 90, Type: "R↔R", SNR: f64(8.0), Hash: "h2", Timestamp: "t2"},
-		{FromPk: "BBB", ToPk: "AAA", FromName: "B", ToName: "A", Dist: 80, Type: "R↔R", SNR: f64(3.0), Hash: "h3", Timestamp: "t3"},
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 70, Type: "R↔R", SNR: f64(6.0), Hash: "h4", Timestamp: "t4"},
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 60, Type: "R↔R", SNR: f64(4.0), Hash: "h5", Timestamp: "t5"},
-		{FromPk: "CCC", ToPk: "DDD", FromName: "C", ToName: "D", Dist: 50, Type: "C↔R", SNR: f64(7.0), Hash: "h6", Timestamp: "t6"},
-	}
-
-	result := dedupeHopsByPair(hops, 20)
-
-	if len(result) != 2 {
-		t.Fatalf("expected 2 entries, got %d", len(result))
-	}
-
-	// First entry: A↔B pair, max distance = 100, obsCount = 5
-	ab := result[0]
-	if ab["dist"].(float64) != 100 {
-		t.Errorf("expected dist 100, got %v", ab["dist"])
-	}
-	if ab["obsCount"].(int) != 5 {
-		t.Errorf("expected obsCount 5, got %v", ab["obsCount"])
-	}
-	if ab["hash"].(string) != "h1" {
-		t.Errorf("expected hash h1 (from max-dist record), got %v", ab["hash"])
-	}
-	if ab["bestSnr"].(float64) != 8.0 {
-		t.Errorf("expected bestSnr 8.0, got %v", ab["bestSnr"])
-	}
-	// medianSnr of [3,4,5,6,8] = 5.0
-	if ab["medianSnr"].(float64) != 5.0 {
-		t.Errorf("expected medianSnr 5.0, got %v", ab["medianSnr"])
-	}
-
-	// Second entry: C↔D pair
-	cd := result[1]
-	if cd["dist"].(float64) != 50 {
-		t.Errorf("expected dist 50, got %v", cd["dist"])
-	}
-	if cd["obsCount"].(int) != 1 {
-		t.Errorf("expected obsCount 1, got %v", cd["obsCount"])
-	}
-}
-
-func TestDedupeTopHopsReversePairMerges(t *testing.T) {
-	hops := []distHopRecord{
-		{FromPk: "BBB", ToPk: "AAA", FromName: "B", ToName: "A", Dist: 50, Type: "R↔R", Hash: "h1"},
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 80, Type: "R↔R", Hash: "h2"},
-	}
-	result := dedupeHopsByPair(hops, 20)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(result))
-	}
-	if result[0]["obsCount"].(int) != 2 {
-		t.Errorf("expected obsCount 2, got %v", result[0]["obsCount"])
-	}
-	if result[0]["dist"].(float64) != 80 {
-		t.Errorf("expected dist 80, got %v", result[0]["dist"])
-	}
-}
-
-func TestDedupeTopHopsNilSNR(t *testing.T) {
-	hops := []distHopRecord{
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 100, Type: "R↔R", SNR: nil, Hash: "h1"},
-		{FromPk: "AAA", ToPk: "BBB", FromName: "A", ToName: "B", Dist: 90, Type: "R↔R", SNR: nil, Hash: "h2"},
-	}
-	result := dedupeHopsByPair(hops, 20)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(result))
-	}
-	if result[0]["bestSnr"] != nil {
-		t.Errorf("expected bestSnr nil, got %v", result[0]["bestSnr"])
-	}
-	if result[0]["medianSnr"] != nil {
-		t.Errorf("expected medianSnr nil, got %v", result[0]["medianSnr"])
-	}
-}
-
-func TestDedupeTopHopsLimit(t *testing.T) {
-	// Generate 25 unique pairs, verify limit=20 caps output
-	hops := make([]distHopRecord, 25)
-	for i := range hops {
-		hops[i] = distHopRecord{
-			FromPk: "A", ToPk: string(rune('a' + i)),
-			Dist: float64(i), Type: "R↔R", Hash: "h",
-		}
-	}
-	result := dedupeHopsByPair(hops, 20)
-	if len(result) != 20 {
-		t.Errorf("expected 20 entries, got %d", len(result))
-	}
-}
-
-func TestDedupeTopHopsEvenMedian(t *testing.T) {
-	// Even count: median = avg of two middle values
-	hops := []distHopRecord{
-		{FromPk: "A", ToPk: "B", Dist: 10, Type: "R↔R", SNR: f64(2.0), Hash: "h1"},
-		{FromPk: "A", ToPk: "B", Dist: 20, Type: "R↔R", SNR: f64(4.0), Hash: "h2"},
-		{FromPk: "A", ToPk: "B", Dist: 30, Type: "R↔R", SNR: f64(6.0), Hash: "h3"},
-		{FromPk: "A", ToPk: "B", Dist: 40, Type: "R↔R", SNR: f64(8.0), Hash: "h4"},
-	}
-	result := dedupeHopsByPair(hops, 20)
-	// sorted SNR: [2,4,6,8], median = (4+6)/2 = 5.0
-	if result[0]["medianSnr"].(float64) != 5.0 {
-		t.Errorf("expected medianSnr 5.0, got %v", result[0]["medianSnr"])
-	}
-}

cmd/server/testdata/golden/shapes.json

@@ -42,20 +42,14 @@
             "type": {
               "type": "string"
             },
+            "snr": {
+              "type": "number"
+            },
             "hash": {
               "type": "string"
             },
             "timestamp": {
               "type": "string"
-            },
-            "bestSnr": {
-              "type": "number"
-            },
-            "medianSnr": {
-              "type": "number"
-            },
-            "obsCount": {
-              "type": "number"
             }
           }
         }
@@ -1586,4 +1580,4 @@
       }
     }
   }
-}
+}

cmd/server/touch_last_seen_test.go

@@ -69,11 +69,13 @@ func TestTouchRelayLastSeen_Debouncing(t *testing.T) {
 		lastSeenTouched: make(map[string]time.Time),
 	}
 
-	// After #800, touchRelayLastSeen takes a []string of pubkeys (from decode-window)
-	pks := []string{"relay1"}
+	pk := "relay1"
+	tx := &StoreTx{
+		ResolvedPath: []*string{&pk},
+	}
 
 	now := time.Now()
-	s.touchRelayLastSeen(pks, now)
+	s.touchRelayLastSeen(tx, now)
 
 	// Verify it was written
 	var lastSeen sql.NullString
@@ -86,7 +88,7 @@ func TestTouchRelayLastSeen_Debouncing(t *testing.T) {
 	db.conn.Exec("UPDATE nodes SET last_seen = NULL WHERE public_key = ?", "relay1")
 
 	// Call again within 5 minutes — should be debounced (no write)
-	s.touchRelayLastSeen(pks, now.Add(2*time.Minute))
+	s.touchRelayLastSeen(tx, now.Add(2*time.Minute))
 
 	db.conn.QueryRow("SELECT last_seen FROM nodes WHERE public_key = ?", "relay1").Scan(&lastSeen)
 	if lastSeen.Valid {
@@ -94,14 +96,14 @@ func TestTouchRelayLastSeen_Debouncing(t *testing.T) {
 	}
 
 	// Call after 5 minutes — should write again
-	s.touchRelayLastSeen(pks, now.Add(6*time.Minute))
+	s.touchRelayLastSeen(tx, now.Add(6*time.Minute))
 	db.conn.QueryRow("SELECT last_seen FROM nodes WHERE public_key = ?", "relay1").Scan(&lastSeen)
 	if !lastSeen.Valid {
 		t.Fatal("expected write after debounce interval expired")
 	}
 }
 
-func TestTouchRelayLastSeen_SkipsEmptyPubkeys(t *testing.T) {
+func TestTouchRelayLastSeen_SkipsNilResolvedPath(t *testing.T) {
 	db := setupTestDB(t)
 	defer db.Close()
 
@@ -110,9 +112,13 @@ func TestTouchRelayLastSeen_SkipsEmptyPubkeys(t *testing.T) {
 		lastSeenTouched: make(map[string]time.Time),
 	}
 
-	// Empty pubkeys — should not panic or error
-	s.touchRelayLastSeen([]string{}, time.Now())
-	s.touchRelayLastSeen(nil, time.Now())
+	// tx with nil entries and empty resolved_path
+	tx := &StoreTx{
+		ResolvedPath: []*string{nil, nil},
+	}
+
+	// Should not panic or error
+	s.touchRelayLastSeen(tx, time.Now())
 }
 
 func TestTouchRelayLastSeen_NilDB(t *testing.T) {
@@ -121,6 +127,11 @@ func TestTouchRelayLastSeen_NilDB(t *testing.T) {
 		lastSeenTouched: make(map[string]time.Time),
 	}
 
+	pk := "abc"
+	tx := &StoreTx{
+		ResolvedPath: []*string{&pk},
+	}
+
 	// Should not panic with nil db
-	s.touchRelayLastSeen([]string{"abc"}, time.Now())
+	s.touchRelayLastSeen(tx, time.Now())
 }

cmd/server/tracked_bytes_test.go

@@ -52,26 +52,26 @@ func TestEstimateStoreTxBytes_ManyHopsSubpaths(t *testing.T) {
 	}
 }
 
-// TestEstimateStoreObsBytes_AfterRefactor verifies that after #800 refactor,
-// observations no longer have ResolvedPath overhead in their estimate.
-func TestEstimateStoreObsBytes_AfterRefactor(t *testing.T) {
-	obs := &StoreObs{
+// TestEstimateStoreObsBytes_WithResolvedPath verifies that observations with
+// ResolvedPath estimate more than those without.
+func TestEstimateStoreObsBytes_WithResolvedPath(t *testing.T) {
+	s1, s2, s3 := "node1", "node2", "node3"
+
+	obsNoRP := &StoreObs{
 		ObserverID: "obs1",
 		PathJSON:   `["a","b"]`,
 	}
+	obsWithRP := &StoreObs{
+		ObserverID:   "obs1",
+		PathJSON:     `["a","b"]`,
+		ResolvedPath: []*string{&s1, &s2, &s3},
+	}
 
-	est := estimateStoreObsBytes(obs)
-	if est <= 0 {
-		t.Errorf("estimate should be positive, got %d", est)
-	}
-	// After #800, all obs estimates should be the same (no RP field variation)
-	obs2 := &StoreObs{
-		ObserverID: "obs1",
-		PathJSON:   `["a","b"]`,
-	}
-	est2 := estimateStoreObsBytes(obs2)
-	if est != est2 {
-		t.Errorf("estimates should be equal after #800 (no RP field), got %d vs %d", est, est2)
+	estNo := estimateStoreObsBytes(obsNoRP)
+	estWith := estimateStoreObsBytes(obsWithRP)
+
+	if estWith <= estNo {
+		t.Errorf("obs with ResolvedPath (%d) should estimate more than without (%d)", estWith, estNo)
 	}
 }
 
@@ -155,9 +155,11 @@ func BenchmarkEstimateStoreTxBytes(b *testing.B) {
 
 // BenchmarkEstimateStoreObsBytes verifies the obs estimate function is fast.
 func BenchmarkEstimateStoreObsBytes(b *testing.B) {
+	s := "resolvedNodePubkey123456"
 	obs := &StoreObs{
-		ObserverID: "observer1234",
-		PathJSON:   `["a","b","c"]`,
+		ObserverID:   "observer1234",
+		PathJSON:     `["a","b","c"]`,
+		ResolvedPath: []*string{&s, &s, &s},
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

cmd/server/types.go

@@ -68,26 +68,8 @@ type StatsResponse struct {
 	Commit             string     `json:"commit"`
 	BuildTime          string     `json:"buildTime"`
 	Counts             RoleCounts `json:"counts"`
-	Backfilling            bool       `json:"backfilling"`
-	BackfillProgress       float64    `json:"backfillProgress"`
-	SignatureDrops         int64      `json:"signatureDrops,omitempty"`
-	HashMigrationComplete  bool       `json:"hashMigrationComplete"`
-
-	// Memory accounting (issue #832). All values in MB.
-	//
-	// StoreDataMB ("trackedMB" historically) is the in-store packet byte
-	// estimate — useful packet bytes only. Subset of HeapInuse. Used as
-	// the eviction watermark input. NOT a proxy for RSS; ops dashboards
-	// should prefer ProcessRSSMB for capacity decisions.
-	//
-	// Old field name TrackedMB is retained for backward compatibility
-	// with pre-v3.6 consumers; it carries the same value as StoreDataMB
-	// and is deprecated.
-	TrackedMB     float64 `json:"trackedMB"`     // deprecated alias for storeDataMB
-	StoreDataMB   float64 `json:"storeDataMB"`   // in-store packet bytes (subset of heap)
-	ProcessRSSMB  float64 `json:"processRSSMB"`  // process RSS from /proc (Linux) or runtime.Sys fallback
-	GoHeapInuseMB float64 `json:"goHeapInuseMB"` // runtime.MemStats.HeapInuse
-	GoSysMB       float64 `json:"goSysMB"`       // runtime.MemStats.Sys (total Go-managed)
+	Backfilling        bool       `json:"backfilling"`
+	BackfillProgress   float64    `json:"backfillProgress"`
 }
 
 // ─── Health ────────────────────────────────────────────────────────────────────
@@ -263,6 +245,7 @@ type TransmissionResp struct {
 	SNR              interface{}      `json:"snr"`
 	RSSI             interface{}      `json:"rssi"`
 	PathJSON         interface{}      `json:"path_json"`
+	ResolvedPath     []*string        `json:"resolved_path,omitempty"`
 	Direction        interface{}      `json:"direction"`
 	Score            interface{}      `json:"score,omitempty"`
 	Observations     []ObservationResp `json:"observations,omitempty"`
@@ -277,9 +260,7 @@ type ObservationResp struct {
 	SNR            interface{} `json:"snr"`
 	RSSI           interface{} `json:"rssi"`
 	PathJSON       interface{} `json:"path_json"`
-	ResolvedPath   interface{} `json:"resolved_path,omitempty"`
-	Direction      interface{} `json:"direction,omitempty"`
-	RawHex         interface{} `json:"raw_hex,omitempty"`
+	ResolvedPath   []*string   `json:"resolved_path,omitempty"`
 	Timestamp      interface{} `json:"timestamp"`
 }
 
@@ -315,6 +296,7 @@ type PacketTimestampsResponse struct {
 type PacketDetailResponse struct {
 	Packet           interface{}       `json:"packet"`
 	Path             []interface{}     `json:"path"`
+	Breakdown        *Breakdown        `json:"breakdown"`
 	ObservationCount int               `json:"observation_count"`
 	Observations     []ObservationResp `json:"observations,omitempty"`
 }
@@ -680,9 +662,7 @@ type DistanceHop struct {
 	ToPk      string      `json:"toPk"`
 	Dist      float64     `json:"dist"`
 	Type      string      `json:"type"`
-	BestSnr   interface{} `json:"bestSnr"`
-	MedianSnr interface{} `json:"medianSnr"`
-	ObsCount  int         `json:"obsCount"`
+	SNR       interface{} `json:"snr"`
 	Hash      string      `json:"hash"`
 	Timestamp string      `json:"timestamp"`
 }

cmd/server/vacuum.go

@@ -1,84 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"time"
-)
-
-// checkAutoVacuum inspects the current auto_vacuum mode and logs a warning
-// if it's not INCREMENTAL. Optionally performs a one-time full VACUUM if
-// the operator has set db.vacuumOnStartup: true in config (#919).
-func checkAutoVacuum(db *DB, cfg *Config, dbPath string) {
-	var autoVacuum int
-	if err := db.conn.QueryRow("PRAGMA auto_vacuum").Scan(&autoVacuum); err != nil {
-		log.Printf("[db] warning: could not read auto_vacuum: %v", err)
-		return
-	}
-
-	if autoVacuum == 2 {
-		log.Printf("[db] auto_vacuum=INCREMENTAL")
-		return
-	}
-
-	modes := map[int]string{0: "NONE", 1: "FULL", 2: "INCREMENTAL"}
-	mode := modes[autoVacuum]
-	if mode == "" {
-		mode = fmt.Sprintf("UNKNOWN(%d)", autoVacuum)
-	}
-
-	log.Printf("[db] auto_vacuum=%s — DB needs one-time VACUUM to enable incremental auto-vacuum. "+
-		"Set db.vacuumOnStartup: true in config to migrate (will block startup for several minutes on large DBs). "+
-		"See https://github.com/Kpa-clawbot/CoreScope/issues/919", mode)
-
-	if cfg.DB != nil && cfg.DB.VacuumOnStartup {
-		// WARNING: Full VACUUM creates a temporary copy of the entire DB file.
-		// Requires ~2× the DB file size in free disk space or it will fail.
-		log.Printf("[db] vacuumOnStartup=true — starting one-time full VACUUM (ensure 2x DB size free disk space)...")
-		start := time.Now()
-
-		rw, err := openRW(dbPath)
-		if err != nil {
-			log.Printf("[db] VACUUM failed: could not open RW connection: %v", err)
-			return
-		}
-		defer rw.Close()
-
-		if _, err := rw.Exec("PRAGMA auto_vacuum = INCREMENTAL"); err != nil {
-			log.Printf("[db] VACUUM failed: could not set auto_vacuum: %v", err)
-			return
-		}
-		if _, err := rw.Exec("VACUUM"); err != nil {
-			log.Printf("[db] VACUUM failed: %v", err)
-			return
-		}
-
-		elapsed := time.Since(start)
-		log.Printf("[db] VACUUM complete in %v — auto_vacuum is now INCREMENTAL", elapsed.Round(time.Millisecond))
-
-		// Re-check
-		var newMode int
-		if err := db.conn.QueryRow("PRAGMA auto_vacuum").Scan(&newMode); err == nil {
-			if newMode == 2 {
-				log.Printf("[db] auto_vacuum=INCREMENTAL (confirmed after VACUUM)")
-			} else {
-				log.Printf("[db] warning: auto_vacuum=%d after VACUUM — expected 2", newMode)
-			}
-		}
-	}
-}
-
-// runIncrementalVacuum runs PRAGMA incremental_vacuum(N) on a read-write
-// connection. Safe to call on auto_vacuum=NONE databases (noop).
-func runIncrementalVacuum(dbPath string, pages int) {
-	rw, err := openRW(dbPath)
-	if err != nil {
-		log.Printf("[vacuum] could not open RW connection: %v", err)
-		return
-	}
-	defer rw.Close()
-
-	if _, err := rw.Exec(fmt.Sprintf("PRAGMA incremental_vacuum(%d)", pages)); err != nil {
-		log.Printf("[vacuum] incremental_vacuum error: %v", err)
-	}
-}

config.example.json

@@ -1,18 +1,10 @@
 {
   "port": 3000,
   "apiKey": "your-secret-api-key-here",
-  "nodeBlacklist": [],
-  "_comment_nodeBlacklist": "Public keys of nodes to hide from all API responses. Use for trolls, offensive names, or nodes reporting false data that operators refuse to fix.",
   "retention": {
     "nodeDays": 7,
-    "observerDays": 14,
     "packetDays": 30,
-    "_comment": "nodeDays: nodes not seen in N days moved to inactive_nodes (default 7). observerDays: observers not sending data in N days are removed (-1 = keep forever, default 14). packetDays: transmissions older than N days are deleted (0 = disabled)."
-  },
-  "db": {
-    "vacuumOnStartup": false,
-    "incrementalVacuumPages": 1024,
-    "_comment": "vacuumOnStartup: run one-time full VACUUM to enable incremental auto-vacuum on existing DBs (blocks startup for minutes on large DBs; requires 2x DB file size in free disk space). incrementalVacuumPages: free pages returned to OS after each retention reaper cycle (default 1024). See #919."
+    "_comment": "nodeDays: nodes not seen in N days are moved to inactive_nodes (default 7). packetDays: transmissions+observations older than N days are deleted daily (0 = disabled)."
   },
   "https": {
     "cert": "/path/to/cert.pem",
@@ -213,8 +205,7 @@
   "packetStore": {
     "maxMemoryMB": 1024,
     "estimatedPacketBytes": 450,
-    "retentionHours": 168,
-    "_comment": "In-memory packet store. maxMemoryMB caps RAM usage. retentionHours: only packets younger than this are loaded on startup and kept in memory (0 = unlimited, not recommended for large DBs — causes OOM on cold start). 168 = 7 days. Must be ≤ retention.packetDays * 24."
+    "_comment": "In-memory packet store. maxMemoryMB caps RAM usage. All packets loaded on startup, served from RAM."
   },
   "resolvedPath": {
     "backfillHours": 24,

docs/clock-skew-redesign.md

@@ -1,241 +0,0 @@
-# Clock Skew Classifier — Redesign
-
-**Status:** spec, pre-implementation
-**Supersedes:** parts of #690 / #789 / #845 / PR #894
-**Date drafted:** 2026-04-24
-
-## Problem
-
-The current classifier (`cmd/server/clock_skew.go`) uses windowed medians, hysteresis, "good fraction" floors, and a 365-day `no_clock` threshold. It produces:
-
-- False `no_clock` flags on nodes whose clocks are working today but had garbage timestamps in recent samples.
-- Symmetric severity bands that conflate "clock at firmware default" with "operator set the clock wrong by a year" — completely different operator actions required.
-- Compounding over-engineering as each operator complaint added a new tier or window.
-
-The actual physical reality of these devices is much simpler than the classifier assumes.
-
-## Hardware reality
-
-Most MeshCore nodes have **no auto-updating RTC**. There are two hardware paths:
-
-1. **Volatile RTC nodes** (`firmware/src/helpers/ArduinoHelpers.h:11` — `VolatileRTCClock`):
-   - On boot, `base_time` is hardcoded to a firmware-build constant (currently `1715770351` = 2024-05-15 20:52:31 UTC).
-   - `getCurrentTime()` returns `base_time + millis()/1000`.
-   - On reboot the value snaps back to the constant.
-   - User must manually sync via companion app (`set time` CLI invokes `setCurrentTime(...)`) to set a real wall-clock time, which then ticks until the next reboot.
-
-2. **Hardware-RTC nodes** (`firmware/src/helpers/AutoDiscoverRTCClock.cpp` — DS3231 / RV3028 / PCF8563):
-   - Real-time chip with battery backup. Holds the time across reboots.
-   - Behaves correctly once set; no default-snap behavior.
-
-The `set time RESET` CLI command (`firmware/src/helpers/CommonCLI.cpp:215`) explicitly calls `setCurrentTime(1715770351)` regardless of hardware — so even hardware-RTC nodes can be deliberately reset to the default epoch.
-
-**Therefore every node is in exactly one of these states:**
-
-| State | Description |
-|---|---|
-| **Default / never set** | RTC is at a firmware-default epoch + ticking up since the last boot. |
-| **Set, drifting normally** | RTC was synced; small skew accumulating at ~0.8s/day per #789 reports. |
-| **Set, drifted past tolerance** | Like above but skew has grown beyond what's useful. |
-| **Wrong** | Operator-set incorrect time, or genuine RTC malfunction not matching any known default. |
-
-There is no "bimodal RTC bug" — what looked bimodal in #845 is just a sequence of `defaulted → user sync → reboot → defaulted again`. The "bad" timestamps are not noise; they're a constant (the default epoch + a small uptime).
-
-## Production data analysis (2026-04-24)
-
-### 00id.net (this deployment, 416 nodes, commit `abd9c46`)
-
-`lastSkewSec` (advert_ts − observed_ts) distribution:
-
-| Bucket | Count | Pct |
-|---|---:|---:|
-| OK ≤15s | 90 | 22% |
-| Degrading ≤60s | 93 | 22% |
-| Degraded ≤10m | 13 | 3% |
-| off ≤1d | 5 | 1% |
-| off ≤1y | 110 | 26% |
-| absurd >1y | 105 | 25% |
-
-Per-node `lastAdvertTS` raw timestamp distribution shows a sharp default cluster:
-
-```
-+0 days  count=19 samples=114969       ← exactly at 1715770351 (just rebooted)
-+1d      count=9  samples=24766
-+2d      count=7  samples=58101
-+3d      count=2  samples=360
-...                                     ← decay through ~110 days
-+113d    count=2  samples=53776
-```
-
-103 of 416 nodes (25%) have `lastAdvertTS` between `1715770351` and `1715770351 + 1095 days`, consistent with the volatile-RTC-default-ticking-up pattern.
-
-A second cluster of 5 nodes has `lastAdvertTS = 1672531542 ≈ 1672531200 + 5min` = **2023-01-01 00:00:00 UTC** + small uptime. This is a *different* firmware-default epoch from an older firmware version.
-
-### Cascadia (analyzer.cascadiamesh.org, 433 nodes in 5000-packet sample, commit `111b03c` v3.5.0)
-
-ADVERT timestamp by year-month:
-
-```
-1970-01    1     ← epoch zero (ESP32 native fallback OR ancient firmware)
-2021-01    1     ← possible third default epoch
-2023-01    2     ← old firmware default (matches 00id)
-2024-05   60     ← current VolatileRTCClock + days uptime
-2024-06   39     ← same default + weeks uptime
-2024-07   21
-2024-08   10
-2024-09    2
-2024-10    1
-2024-11    2     ← decays out as fewer nodes have multi-month uptime since reboot
-2025-10    1     ← pre-current-now miscellany
-2025-11    2
-2026-03    4
-2026-04  285     ← currently set clocks (this is "now-ish")
-2027-04    1     ← operator set wrong by ~1 year (typo?)
-2067-12    1     ← operator set wildly wrong / corrupted RTC
-```
-
-Confirms the model: ~67% of nodes have a current clock, ~32% are at known firmware defaults at varying uptime offsets, ~3 outliers represent genuine misconfigurations.
-
-## Known firmware default epochs
-
-These are the values discovered in production data so far:
-
-| Epoch (unix) | UTC | Source |
-|---:|---|---|
-| `0` | 1970-01-01 | Likely ESP32 boot when no RTC initialization runs (`time(NULL)` returns 0). |
-| `1609459200` | 2021-01-01 | Speculation — single-sample evidence, validate as more data arrives. |
-| `1672531200` | 2023-01-01 | Older firmware `VolatileRTCClock::base_time` value. |
-| `1715770351` | 2024-05-15 20:52:31 | **Current** `VolatileRTCClock` constructor + `set time RESET` CLI. |
-
-Treat the table as data, not fixed code. New firmware versions will introduce new defaults; expect to add to the list over time.
-
-## Reconciliation with #690 — the four timestamps
-
-#690 lists three timestamps; in practice there are four signals worth distinguishing:
-
-| Signal | Source | Used for |
-|---|---|---|
-| `advert_ts` | Inside MeshCore packet, set by sending node | Per-node classification (THE signal). |
-| `mqtt_envelope_ts` | Set by observer when it forwards via MQTT | Observer-side calibration only — *not* a direct node-skew signal because observer clock can itself be wrong. |
-| `corescope_received_ts` | Wall clock when CoreScope ingested the message | Reference "now"; calibration cross-check. |
-| `same_packet_across_observers` | Multiple observers seeing the same hash | Phase 2 calibration (triangulation). |
-
-**Inputs flow:**
-
-1. **Phase 2 (existing, kept):** for each packet hash seen by ≥2 observers, compute each observer's deviation from the per-packet median observed_ts → `observerOffset`. This is the triangulation #690 calls for ("Same packet observed by more than one (ideally 3+) observers gives good indication if one observer is off"). Observer offsets are the calibration table.
-2. **Per-advert correction (existing, kept):** `correctedSkew = (advert_ts - observed_ts) + observerOffset[observer_id]`. If no calibration exists for an observer, fall back to raw skew with `calibrated: false`.
-3. **Default detection (new):** runs on RAW `advert_ts`, not corrected. The firmware default is a fixed wall-clock value; observer offsets are seconds-to-minutes scale and cannot move `advert_ts` from 2024 to 2026. Default check is independent of calibration.
-4. **Severity classification (new):** if `is_default(advert_ts)` → `default`; else classify by `|correctedSkew|` band.
-
-This keeps everything #690 asks for (observer detection, bias subtraction, triangulation), and adds the firmware-default cluster as a new pre-empting tier.
-
-## UI: explain WHY (#690 requirement)
-
-The classifier alone doesn't satisfy #690's "present on the UI why clock skew is obvious or suspected." The evidence panel from PR #906 (per-hash observer breakdown showing raw vs corrected skew per observer) is the WHY.
-
-For each per-node clock card the UI must show:
-
-- **Tier badge** (default / ok / degrading / degraded / wrong) + magnitude.
-- **Plain-English reason line**: e.g. "Last advert at 2024-05-15 + 3.2 days uptime — matches firmware default (volatile RTC, not yet user-set)" or "Last advert −12s vs wall clock — within OK tolerance."
-- **Calibration footnote**: "Skew corrected using observer X offset +1.7s (computed from 412 multi-observer packets)" or "Single-observer measurement, no calibration available."
-- **Evidence accordion** (PR #906 shape, retained): for the most recent N hashes, each observer's raw vs corrected skew + the observer's offset.
-
-For the per-observer page (also from PR #906): show the observer's offset, the multi-observer sample count, and a tier badge using the same scale (treating `|observerOffset|` as the skew).
-
-## Proposed classifier
-
-Per-advert classification, no windowing:
-
-```python
-DEFAULT_EPOCHS = [0, 1609459200, 1672531200, 1715770351]
-MAX_PLAUSIBLE_UPTIME_SEC = 1095 * 86400  # 3 years
-
-def is_default(ts):
-    return any(d <= ts <= d + MAX_PLAUSIBLE_UPTIME_SEC for d in DEFAULT_EPOCHS)
-
-def classify(advert_ts, corrected_skew_sec):
-    if is_default(advert_ts):
-        return "default"          # gray
-    abs_skew = abs(corrected_skew_sec)
-    if abs_skew <= 15:    return "ok"           # green
-    if abs_skew <= 60:    return "degrading"    # yellow
-    if abs_skew <= 600:   return "degraded"     # orange
-    return "wrong"                              # red
-```
-
-`corrected_skew_sec` is the observer-bias-subtracted skew per Phase 2 calibration. Default detection is independent of calibration (runs on raw `advert_ts`).
-
-Per-node state = classification of the node's most-recent advert (per hash, picking the most recent observation across all observers). No medians, no good-fraction, no hysteresis.
-
-## Severity tier definitions
-
-| Tier | Condition | Color | UI label | Meaning |
-|---|---|---|---|---|
-| `default` | Advert ts within `[default, default + 3y]` of any known epoch | Gray | "Default" | Volatile RTC at firmware boot constant; never set or rebooted and not re-synced. |
-| `ok` | abs(skew) ≤ 15s | Green | "OK" | Working clock. |
-| `degrading` | 15s < abs(skew) ≤ 60s | Yellow | "Degrading" | Real but accumulating drift. |
-| `degraded` | 60s < abs(skew) ≤ 600s | Orange | "Degraded" | Off by minutes — needs re-sync. |
-| `wrong` | abs(skew) > 600s and not `default` | Red | "Wrong" | Operator-set error or RTC malfunction. |
-
-## What this kills
-
-- The 365-day `no_clock` threshold and the entire `recentSkewWindow{Count,Sec}` machinery.
-- The hysteresis / `goodFraction` / `longTermGoodFraction` logic from PR #894.
-- The proposed `bimodal_clock` tier from #845 — the pattern is not bimodal, it's defaulted vs set.
-- All Theil-Sen drift calculations as classifier inputs (drift remains a derived display value).
-
-## What this preserves
-
-- **Phase 2 observer calibration** (`calibrateObservers()`) — kept verbatim. It's what powers the "subtract observer bias" requirement from #690 and provides the triangulation evidence the UI needs.
-- **Drift display** (computed but not classifying).
-- **PR #906 evidence UI** — orthogonal to the classifier; it is in fact the implementation of #690's "explain WHY" requirement. Only label strings change to match the new tier names.
-- **`/api/observers/clock-skew`** — unchanged shape.
-
-## API impact
-
-`/api/nodes/{pubkey}/clock-skew` response changes:
-
-- `severity` enum: `default | ok | degrading | degraded | wrong` (no more `no_clock | severe | warn | absurd`).
-- New field `defaultEpoch` (int, optional): if `severity == "default"`, the matched epoch.
-- Drop fields: `recentMedianSkewSec`, `goodFraction`, `recentBadSampleCount`, `longTermGoodFraction`.
-- Keep: `lastSkewSec`, `medianSkewSec`, `meanSkewSec`, `driftPerDaySec`, `sampleCount`, `calibrated`, `lastAdvertTS`, `lastObservedTS`, `nodeName`, `nodeRole`.
-
-`/api/nodes/clock-skew` (fleet) shape unchanged except severity enum values.
-
-## UI impact
-
-- New CSS classes `skew-badge--default`, `skew-badge--degrading`, `skew-badge--degraded`, `skew-badge--wrong`. Drop `--no_clock`, `--severe`, `--warn`, `--absurd`, `--bimodal_clock`.
-- Tooltip text updated per tier.
-- "Default" badge tooltip should explain the clock is at firmware default plus uptime since boot, and the operator hasn't set it yet (or hasn't re-set it since the last reboot).
-
-## Migration
-
-Single PR replaces the classifier in `clock_skew.go` and updates the frontend badges/labels. No database schema change, no data migration — all per-call computation.
-
-## Open issues to close
-
-- **#789** (median hides corrected clocks) — resolved by per-advert classification.
-- **#845** (bimodal_clock tier) — replaced by `default` tier; the pattern that motivated it is correctly captured.
-- **PR #894** — close without merging; this design supersedes Option C entirely.
-- **#690** UI completion (PR #906) — keeps moving in parallel; only label updates needed.
-
-## Validation plan
-
-1. Hand-run the classifier against a snapshot of `/api/nodes/clock-skew` from 00id and cascadia. Confirm:
-   - All 103 00id "absurd" nodes reclassify as `default`.
-   - All 5 cascadia 2023-01 nodes reclassify as `default`.
-   - The 2027 / 2067 cascadia outliers reclassify as `wrong`.
-   - The 285 cascadia 2026-04 nodes reclassify as `ok` (or `degrading` if drift exceeds 15s).
-2. Add per-tier unit tests in `cmd/server/clock_skew_test.go`.
-3. Add a regression test for each known default epoch (synthesize advert at `default + 0s`, `default + 1d`, `default + 3y - 1s` → all classify as `default`).
-4. Edge cases:
-   - `advert_ts == 0` → matches default epoch 0.
-   - `advert_ts == 1715770351 + 731 days` → no longer matches (uptime cap exceeded) — should fall through to time-based classification, likely `wrong`.
-   - Future timestamps beyond `now + 600s` → `wrong`.
-
-## Out of scope (follow-ups)
-
-- Per-firmware-version known-default lookup (when `firmware_version` field becomes reliable on adverts).
-- Reboot-count / flakiness indicator ("this node has hit default N times in last 30d").
-- Auto-discovery of new default epochs from clustering analysis (could detect a 4th default emerging in the wild).
-- Filtering defaulted-clock adverts out of time-windowed analytics queries (separate spec — affects path attribution).

docs/user-guide/configuration.md

@@ -98,22 +98,6 @@ How long (in hours) before a node is marked degraded or silent:
 | `retention.nodeDays` | `7` | Nodes not seen in N days move to inactive |
 | `retention.packetDays` | `30` | Packets older than N days are deleted daily |
 
-> **Note:** Lowering retention does **not** immediately shrink the database file.
-> SQLite marks deleted pages as free but does not return them to the filesystem
-> unless [incremental auto-vacuum](database.md) is enabled. New databases created
-> after v0.x.x have auto-vacuum enabled automatically. Existing databases require
-> a one-time migration — see the [Database](database.md) guide.
-
-## Database
-
-| Field | Default | Description |
-|-------|---------|-------------|
-| `db.vacuumOnStartup` | `false` | Run a one-time full `VACUUM` on startup to enable incremental auto-vacuum (blocks for minutes on large DBs) |
-| `db.incrementalVacuumPages` | `1024` | Free pages returned to the OS after each retention reaper cycle |
-
-See [Database](database.md) for details on SQLite auto-vacuum, WAL, and manual maintenance.
-See [#919](https://github.com/Kpa-clawbot/CoreScope/issues/919) for background.
-
 ## Channel decryption
 
 | Field | Description |
@@ -166,9 +150,6 @@ Lower values = fresher data but more server load.
 |-------|---------|-------------|
 | `packetStore.maxMemoryMB` | `1024` | Maximum RAM for in-memory packet store |
 | `packetStore.estimatedPacketBytes` | `450` | Estimated bytes per packet (for memory budgeting) |
-| `packetStore.retentionHours` | `0` | Only load packets younger than N hours on startup and keep them in memory. **Set this on any instance with a large DB.** `0` = unlimited (loads full DB history — causes OOM on cold start when the DB has hundreds of thousands of paths). Recommended: same as `retention.packetDays × 24` (e.g. `168` for 7 days). |
-
-> **Warning:** Leaving `retentionHours` at `0` on a large database will cause the server to OOM-kill itself on every cold start. The full packet history is loaded into the subpath index at startup; a DB with ~280K paths produces ~13M index entries before the process is killed.
 
 ## Timestamps
 

docs/user-guide/database.md

@@ -1,82 +0,0 @@
-# Database
-
-CoreScope uses SQLite in WAL (Write-Ahead Log) mode for both the server
-(read-only) and ingestor (read-write).
-
-## WAL mode
-
-WAL mode allows concurrent reads while writes happen. It is set automatically
-at connection time via `PRAGMA journal_mode=WAL`. No operator action needed.
-
-The WAL file (`meshcore.db-wal`) grows during writes and is checkpointed
-(merged back into the main DB) periodically and at clean shutdown.
-
-## Auto-vacuum
-
-By default, SQLite does not shrink the database file after `DELETE` operations.
-Deleted pages are marked free and reused by future writes, but the file size
-on disk stays the same. This is surprising when lowering retention settings.
-
-### New databases
-
-Databases created after this feature was added automatically have
-`PRAGMA auto_vacuum = INCREMENTAL`. After each retention reaper cycle,
-CoreScope runs `PRAGMA incremental_vacuum(N)` to return free pages to the OS.
-
-### Existing databases
-
-The `auto_vacuum` mode is stored in the database header and can only be changed
-by rewriting the entire file with `VACUUM`. CoreScope will **not** do this
-automatically — on large databases (5+ GB seen in the wild) it takes minutes
-and holds an exclusive lock.
-
-**To migrate an existing database:**
-
-1. At startup, CoreScope logs a warning:
-   ```
-   [db] auto_vacuum=NONE — DB needs one-time VACUUM to enable incremental auto-vacuum.
-   ```
-2. **Ensure at least 2× the database file size in free disk space.** Full VACUUM
-   creates a temporary copy of the entire file — on a near-full disk it will fail.
-3. Set `db.vacuumOnStartup: true` in your `config.json`:
-   ```json
-   {
-     "db": {
-       "vacuumOnStartup": true
-     }
-   }
-   ```
-4. Restart CoreScope. The one-time `VACUUM` will run and block startup.
-5. After migration, remove or set `vacuumOnStartup: false` — it's not needed again.
-
-### Configuration
-
-| Field | Default | Description |
-|-------|---------|-------------|
-| `db.vacuumOnStartup` | `false` | One-time full VACUUM to enable incremental auto-vacuum |
-| `db.incrementalVacuumPages` | `1024` | Pages returned to OS per reaper cycle |
-
-## Manual VACUUM
-
-You can also run a manual vacuum from the SQLite CLI:
-
-```bash
-sqlite3 data/meshcore.db "PRAGMA auto_vacuum = INCREMENTAL; VACUUM;"
-```
-
-This is equivalent to `vacuumOnStartup: true` but can be done offline.
-
-> ⚠️ Full VACUUM requires **2× the database file size** in free disk space (it
-> creates a temporary copy). Check with `ls -lh data/meshcore.db` before running.
-
-## Checking current mode
-
-```bash
-sqlite3 data/meshcore.db "PRAGMA auto_vacuum;"
-```
-
-- `0` = NONE (default for old databases)
-- `1` = FULL (automatic, but slower writes)
-- `2` = INCREMENTAL (recommended — CoreScope triggers vacuum after deletes)
-
-See [#919](https://github.com/Kpa-clawbot/CoreScope/issues/919) for background on this feature.

internal/packetpath/go.mod

@@ -1,3 +0,0 @@
-module github.com/meshcore-analyzer/packetpath
-
-go 1.22

internal/packetpath/path.go

@@ -1,76 +0,0 @@
-// Package packetpath provides shared helpers for extracting path hops from
-// raw MeshCore packet hex bytes.
-package packetpath
-
-import (
-	"encoding/hex"
-	"fmt"
-	"strings"
-)
-
-// DecodePathFromRawHex extracts the header path hops directly from raw hex bytes.
-// This is the authoritative path that matches what's in raw_hex, as opposed to
-// decoded.Path.Hops which may be overwritten for TRACE packets (issue #886).
-//
-// WARNING: This function returns the literal header path bytes regardless of
-// payload type. For TRACE packets these bytes are SNR values, NOT hop hashes.
-// Callers that may receive TRACE packets MUST check PathBytesAreHops(payloadType)
-// first, or use the safer DecodeHopsForPayload wrapper.
-func DecodePathFromRawHex(rawHex string) ([]string, error) {
-	buf, err := hex.DecodeString(rawHex)
-	if err != nil || len(buf) < 2 {
-		return nil, fmt.Errorf("invalid or too-short hex")
-	}
-
-	headerByte := buf[0]
-	offset := 1
-	if IsTransportRoute(int(headerByte & 0x03)) {
-		if len(buf) < offset+4 {
-			return nil, fmt.Errorf("too short for transport codes")
-		}
-		offset += 4
-	}
-	if offset >= len(buf) {
-		return nil, fmt.Errorf("too short for path byte")
-	}
-
-	pathByte := buf[offset]
-	offset++
-
-	hashSize := int(pathByte>>6) + 1
-	hashCount := int(pathByte & 0x3F)
-
-	hops := make([]string, 0, hashCount)
-	for i := 0; i < hashCount; i++ {
-		start := offset + i*hashSize
-		end := start + hashSize
-		if end > len(buf) {
-			break
-		}
-		hops = append(hops, strings.ToUpper(hex.EncodeToString(buf[start:end])))
-	}
-	return hops, nil
-}
-
-// DecodeHopsForPayload returns the header path hops only when the payload type's
-// header bytes are actually route hops (i.e. PathBytesAreHops(payloadType) is true).
-// For TRACE packets it returns (nil, ErrPayloadHasNoHeaderHops) so the caller is
-// forced to source hops from the decoded payload instead.
-//
-// Prefer this over DecodePathFromRawHex when the payload type is known.
-func DecodeHopsForPayload(rawHex string, payloadType byte) ([]string, error) {
-	if !PathBytesAreHops(payloadType) {
-		return nil, ErrPayloadHasNoHeaderHops
-	}
-	return DecodePathFromRawHex(rawHex)
-}
-
-// ErrPayloadHasNoHeaderHops is returned by DecodeHopsForPayload when the
-// payload type repurposes the raw_hex header path bytes (e.g. TRACE → SNR values).
-var ErrPayloadHasNoHeaderHops = errPayloadHasNoHeaderHops{}
-
-type errPayloadHasNoHeaderHops struct{}
-
-func (errPayloadHasNoHeaderHops) Error() string {
-	return "payload type repurposes header path bytes; source hops from decoded payload"
-}

internal/packetpath/path_test.go

@@ -1,150 +0,0 @@
-package packetpath
-
-import (
-	"encoding/hex"
-	"encoding/json"
-	"strings"
-	"testing"
-)
-
-func TestDecodePathFromRawHex_Basic(t *testing.T) {
-	// Build a simple FLOOD packet (route_type=1) with 2 hops of hashSize=1
-	// header: route_type=1, payload_type=2 (TXT_MSG), version=0 → 0b00_0010_01 = 0x09
-	// path byte: hashSize=1 (bits 7-6 = 0), hashCount=2 (bits 5-0 = 2) → 0x02
-	// hops: AB, CD
-	// payload: some bytes
-	raw := "0902ABCD" + "DEADBEEF"
-	hops, err := DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(hops) != 2 || hops[0] != "AB" || hops[1] != "CD" {
-		t.Fatalf("expected [AB, CD], got %v", hops)
-	}
-}
-
-func TestDecodePathFromRawHex_ZeroHops(t *testing.T) {
-	// DIRECT route (type=2), no hops → 0b00_0010_10 = 0x0A
-	// path byte: 0x00 (0 hops)
-	raw := "0A00" + "DEADBEEF"
-	hops, err := DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(hops) != 0 {
-		t.Fatalf("expected 0 hops, got %v", hops)
-	}
-}
-
-func TestDecodePathFromRawHex_TransportRoute(t *testing.T) {
-	// TRANSPORT_FLOOD (route_type=0), payload_type=5 (GRP_TXT), version=0
-	// header: 0b00_0101_00 = 0x14
-	// transport codes: 4 bytes
-	// path byte: hashSize=1, hashCount=1 → 0x01
-	// hop: FF
-	raw := "14" + "00112233" + "01" + "FF" + "DEAD"
-	hops, err := DecodePathFromRawHex(raw)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(hops) != 1 || hops[0] != "FF" {
-		t.Fatalf("expected [FF], got %v", hops)
-	}
-}
-
-// buildTracePacket creates a TRACE packet hex string where header path bytes are
-// SNR values, and payload contains the actual route hops.
-func buildTracePacket() (rawHex string, headerPathHops []string, payloadHops []string) {
-	// DIRECT route (type=2), TRACE payload (type=9), version=0
-	// header byte: 0b00_1001_10 = 0x26
-	headerByte := byte(0x26)
-
-	// Header path: 2 SNR bytes (hashSize=1, hashCount=2) → path byte = 0x02
-	// SNR values: 0x1A (26 dB), 0x0F (15 dB)
-	pathByte := byte(0x02)
-	snrBytes := []byte{0x1A, 0x0F}
-
-	// TRACE payload: tag(4) + authCode(4) + flags(1) + path hops
-	tag := []byte{0x01, 0x00, 0x00, 0x00}
-	authCode := []byte{0x02, 0x00, 0x00, 0x00}
-	// flags: path_sz=0 (1 byte hops), other bits=0 → 0x00
-	flags := byte(0x00)
-	// Payload hops: AA, BB, CC (the actual route)
-	payloadPathBytes := []byte{0xAA, 0xBB, 0xCC}
-
-	var buf []byte
-	buf = append(buf, headerByte, pathByte)
-	buf = append(buf, snrBytes...)
-	buf = append(buf, tag...)
-	buf = append(buf, authCode...)
-	buf = append(buf, flags)
-	buf = append(buf, payloadPathBytes...)
-
-	rawHex = strings.ToUpper(hex.EncodeToString(buf))
-	headerPathHops = []string{"1A", "0F"} // SNR values — NOT route hops
-	payloadHops = []string{"AA", "BB", "CC"} // actual route hops from payload
-	return
-}
-
-func TestDecodePathFromRawHex_TraceReturnsSNR(t *testing.T) {
-	rawHex, expectedSNR, _ := buildTracePacket()
-	hops, err := DecodePathFromRawHex(rawHex)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	// DecodePathFromRawHex always returns header path bytes — for TRACE these are SNR values
-	if len(hops) != len(expectedSNR) {
-		t.Fatalf("expected %d hops (SNR), got %d: %v", len(expectedSNR), len(hops), hops)
-	}
-	for i, h := range hops {
-		if h != expectedSNR[i] {
-			t.Errorf("hop[%d]: expected %s, got %s", i, expectedSNR[i], h)
-		}
-	}
-}
-
-func TestTracePathJSON_UsesPayloadHops(t *testing.T) {
-	// This test validates the TRACE vs non-TRACE logic that callers should implement:
-	// For TRACE: path_json = decoded.Path.Hops (payload-decoded route hops)
-	// For non-TRACE: path_json = DecodePathFromRawHex(raw_hex)
-	rawHex, snrHops, payloadHops := buildTracePacket()
-
-	// DecodePathFromRawHex returns SNR bytes for TRACE
-	headerHops, _ := DecodePathFromRawHex(rawHex)
-	headerJSON, _ := json.Marshal(headerHops)
-
-	// payload hops (what decoded.Path.Hops would return after TRACE decoding)
-	payloadJSON, _ := json.Marshal(payloadHops)
-
-	// They must differ — SNR != route hops
-	if string(headerJSON) == string(payloadJSON) {
-		t.Fatalf("SNR hops and payload hops should differ for TRACE; both are %s", headerJSON)
-	}
-
-	// For TRACE, path_json should be payloadHops, not headerHops
-	_ = snrHops // snrHops == headerHops — used for documentation
-	t.Logf("TRACE: header path (SNR) = %s, payload path (route) = %s", headerJSON, payloadJSON)
-}
-
-func TestDecodeHopsForPayload_NonTrace(t *testing.T) {
-	// header 0x01, path_len 0x02, hops 0xAA 0xBB, then payload bytes
-	raw := "0102AABB00"
-	hops, err := DecodeHopsForPayload(raw, 0x05) // GRP_TXT — header path bytes ARE hops
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(hops) != 2 || hops[0] != "AA" || hops[1] != "BB" {
-		t.Errorf("expected [AA BB], got %v", hops)
-	}
-}
-
-func TestDecodeHopsForPayload_TraceReturnsError(t *testing.T) {
-	raw := "010205F00100"
-	hops, err := DecodeHopsForPayload(raw, PayloadTRACE)
-	if err != ErrPayloadHasNoHeaderHops {
-		t.Errorf("expected ErrPayloadHasNoHeaderHops, got %v", err)
-	}
-	if hops != nil {
-		t.Errorf("expected nil hops for TRACE, got %v", hops)
-	}
-}

internal/packetpath/route.go

@@ -1,24 +0,0 @@
-package packetpath
-
-// Route type constants (header bits 1-0).
-const (
-	RouteTransportFlood  = 0
-	RouteFlood           = 1
-	RouteDirect          = 2
-	RouteTransportDirect = 3
-)
-
-// PayloadTRACE is the payload type constant for TRACE packets.
-const PayloadTRACE = 0x09
-
-// IsTransportRoute returns true for TRANSPORT_FLOOD (0) and TRANSPORT_DIRECT (3).
-func IsTransportRoute(routeType int) bool {
-	return routeType == RouteTransportFlood || routeType == RouteTransportDirect
-}
-
-// PathBytesAreHops returns true when the raw_hex header path bytes represent
-// route hop hashes (the normal case). Returns false for packet types where
-// header path bytes are repurposed (e.g. TRACE uses them for SNR values).
-func PathBytesAreHops(payloadType byte) bool {
-	return payloadType != PayloadTRACE
-}

internal/packetpath/route_test.go

@@ -1,31 +0,0 @@
-package packetpath
-
-import "testing"
-
-func TestIsTransportRoute(t *testing.T) {
-	if !IsTransportRoute(RouteTransportFlood) {
-		t.Error("RouteTransportFlood should be transport")
-	}
-	if !IsTransportRoute(RouteTransportDirect) {
-		t.Error("RouteTransportDirect should be transport")
-	}
-	if IsTransportRoute(RouteFlood) {
-		t.Error("RouteFlood should not be transport")
-	}
-	if IsTransportRoute(RouteDirect) {
-		t.Error("RouteDirect should not be transport")
-	}
-}
-
-func TestPathBytesAreHops(t *testing.T) {
-	if PathBytesAreHops(PayloadTRACE) {
-		t.Error("PathBytesAreHops(PayloadTRACE) should be false")
-	}
-	// All other known payload types should return true.
-	otherTypes := []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}
-	for _, pt := range otherTypes {
-		if !PathBytesAreHops(pt) {
-			t.Errorf("PathBytesAreHops(0x%02X) should be true", pt)
-		}
-	}
-}

public/analytics.js

@@ -28,7 +28,7 @@
 
   function barChart(data, labels, colors, w = 800, h = 220, pad = 40) {
     const max = Math.max(...data, 1);
-    const barW = Math.max(1, Math.min((w - pad * 2) / data.length - 2, 30));
+    const barW = Math.min((w - pad * 2) / data.length - 2, 30);
     let svg = `<svg viewBox="0 0 ${w} ${h}" style="width:100%;max-height:${h}px" role="img" aria-label="Bar chart showing data distribution"><title>Bar chart showing data distribution</title>`;
     // Grid
     for (let i = 0; i <= 4; i++) {
@@ -263,25 +263,7 @@
       <div class="analytics-row">
         <div class="analytics-card flex-1">
           <h3>📈 Packets / Hour</h3>
-          ${(() => {
-            const pph = rf.packetsPerHour;
-            const counts = pph.map(h => h.count);
-            // Decimate x-axis labels to avoid overlap
-            const totalHours = pph.length;
-            // Pick label interval: <=24h show every 6h, <=72h every 12h, else every 24h
-            const labelInterval = totalHours <= 24 ? 6 : totalHours <= 72 ? 12 : 24;
-            const labels = pph.map((h, i) => {
-              const hh = h.hour.slice(11, 13); // "HH"
-              const hourNum = parseInt(hh, 10);
-              if (hourNum % labelInterval === 0) {
-                // For multi-day ranges, show date on 00h boundaries
-                if (totalHours > 48 && hourNum === 0) return h.hour.slice(5, 10);
-                return hh + 'h';
-              }
-              return ''; // skip label
-            });
-            return barChart(counts, labels, 'var(--accent)');
-          })()}
+          ${barChart(rf.packetsPerHour.map(h=>h.count), rf.packetsPerHour.map(h=>h.hour.slice(11)+'h'), 'var(--accent)')}
         </div>
       </div>
 
@@ -642,13 +624,14 @@
     if (!data || !data.rings.length) return '<div class="text-muted">No path data for this observer</div>';
     let html = `<div class="reach-rings">`;
     data.rings.forEach(ring => {
+      const opacity = Math.max(0.3, 1 - ring.hops * 0.06);
       const nodeLinks = ring.nodes.slice(0, 8).map(n => {
         const label = n.name ? `<a href="#/nodes/${encodeURIComponent(n.pubkey)}" class="analytics-link">${esc(n.name)}</a>` : `<span class="mono">${n.hop}</span>`;
         const detail = n.distRange ? ` <span class="text-muted">(${n.distRange})</span>` : '';
         return label + detail;
       }).join(', ');
       const extra = ring.nodes.length > 8 ? ` <span class="text-muted">+${ring.nodes.length - 8} more</span>` : '';
-      html += `<div class="reach-ring">
+      html += `<div class="reach-ring" style="opacity:${opacity}">
         <div class="reach-hop">${ring.hops} hop${ring.hops > 1 ? 's' : ''}</div>
         <div class="reach-nodes">${nodeLinks}${extra}</div>
         <div class="reach-count">${ring.nodes.length} node${ring.nodes.length > 1 ? 's' : ''}</div>
@@ -692,6 +675,7 @@
     });
     let html = '<div class="reach-rings">';
     Object.entries(byDist).sort((a, b) => +a[0] - +b[0]).forEach(([dist, nodes]) => {
+      const opacity = Math.max(0.3, 1 - (+dist) * 0.06);
       const nodeLinks = nodes.slice(0, 10).map(n => {
         const label = n.name
           ? `<a href="#/nodes/${encodeURIComponent(n.pubkey)}" class="analytics-link">${esc(n.name)}</a>`
@@ -699,7 +683,7 @@
         return label + ` <span class="text-muted">via ${esc(n.observer_name)}</span>`;
       }).join(', ');
       const extra = nodes.length > 10 ? ` <span class="text-muted">+${nodes.length - 10} more</span>` : '';
-      html += `<div class="reach-ring">
+      html += `<div class="reach-ring" style="opacity:${opacity}">
         <div class="reach-hop">${dist} hop${+dist > 1 ? 's' : ''}</div>
         <div class="reach-nodes">${nodeLinks}${extra}</div>
         <div class="reach-count">${nodes.length} node${nodes.length > 1 ? 's' : ''}</div>
@@ -856,44 +840,29 @@
     }
   }
 
-  var CHANNEL_TIMELINE_MAX_SERIES = 8;
-
   function renderChannelTimeline(data) {
     if (!data.length) return '<div class="text-muted">No data</div>';
     var hours = []; var hourSet = {};
     var channelList = []; var channelSet = {};
     var lookup = {};
-    var channelVolume = {};
+    var maxCount = 1;
     for (var i = 0; i < data.length; i++) {
       var d = data[i];
       if (!hourSet[d.hour]) { hourSet[d.hour] = 1; hours.push(d.hour); }
       if (!channelSet[d.channel]) { channelSet[d.channel] = 1; channelList.push(d.channel); }
       lookup[d.hour + '|' + d.channel] = d.count;
-      channelVolume[d.channel] = (channelVolume[d.channel] || 0) + d.count;
+      if (d.count > maxCount) maxCount = d.count;
     }
     hours.sort();
-    // Sort channels by total volume descending, cap to top N
-    channelList.sort(function(a, b) { return channelVolume[b] - channelVolume[a]; });
-    var hiddenCount = Math.max(0, channelList.length - CHANNEL_TIMELINE_MAX_SERIES);
-    var visibleChannels = channelList.slice(0, CHANNEL_TIMELINE_MAX_SERIES);
-
-    var maxCount = 1;
-    for (var vi = 0; vi < visibleChannels.length; vi++) {
-      for (var hi2 = 0; hi2 < hours.length; hi2++) {
-        var c = lookup[hours[hi2] + '|' + visibleChannels[vi]] || 0;
-        if (c > maxCount) maxCount = c;
-      }
-    }
-
     var colors = ['#ef4444','#22c55e','#3b82f6','#f59e0b','#8b5cf6','#ec4899','#14b8a6','#64748b'];
     var w = 600, h = 180, pad = 35;
     var xScale = (w - pad * 2) / Math.max(hours.length - 1, 1);
     var yScale = (h - pad * 2) / maxCount;
     var svg = '<svg viewBox="0 0 ' + w + ' ' + h + '" style="width:100%;max-height:180px" role="img" aria-label="Channel message activity over time"><title>Channel message activity over time</title>';
-    for (var ci = 0; ci < visibleChannels.length; ci++) {
+    for (var ci = 0; ci < channelList.length; ci++) {
       var pts = [];
       for (var hi = 0; hi < hours.length; hi++) {
-        var count = lookup[hours[hi] + '|' + visibleChannels[ci]] || 0;
+        var count = lookup[hours[hi] + '|' + channelList[ci]] || 0;
         var x = pad + hi * xScale;
         var y = h - pad - count * yScale;
         pts.push(x + ',' + y);
@@ -907,11 +876,8 @@
     }
     svg += '</svg>';
     var legendParts = [];
-    for (var lci = 0; lci < visibleChannels.length; lci++) {
-      legendParts.push('<span><span class="legend-dot" style="background:' + colors[lci % colors.length] + '"></span>' + esc(visibleChannels[lci]) + '</span>');
-    }
-    if (hiddenCount > 0) {
-      legendParts.push('<span class="text-muted">+' + hiddenCount + ' more</span>');
+    for (var lci = 0; lci < channelList.length; lci++) {
+      legendParts.push('<span><span class="legend-dot" style="background:' + colors[lci % colors.length] + '"></span>' + esc(channelList[lci]) + '</span>');
     }
     svg += '<div class="timeline-legend">' + legendParts.join('') + '</div>';
     return svg;
@@ -1971,18 +1937,15 @@
       }
 
       // Top hops leaderboard
-      html += `<div class="analytics-section"><h3>🏆 Top 20 Longest Hops</h3><table class="data-table"><thead><tr><th scope="col">#</th><th scope="col">From</th><th scope="col">To</th><th scope="col">Distance (${distUnitLabel})</th><th scope="col">Type</th><th scope="col">Obs</th><th scope="col">Best SNR</th><th scope="col">Median SNR</th><th scope="col">Packet</th><th scope="col"></th></tr></thead><tbody>`;
+      html += `<div class="analytics-section"><h3>🏆 Top 20 Longest Hops</h3><table class="data-table"><thead><tr><th scope="col">#</th><th scope="col">From</th><th scope="col">To</th><th scope="col">Distance (${distUnitLabel})</th><th scope="col">Type</th><th scope="col">SNR</th><th scope="col">Packet</th><th scope="col"></th></tr></thead><tbody>`;
       const top20 = data.topHops.slice(0, 20);
       top20.forEach((h, i) => {
         const fromLink = h.fromPk ? `<a href="#/nodes/${encodeURIComponent(h.fromPk)}" class="analytics-link">${esc(h.fromName)}</a>` : esc(h.fromName || '?');
         const toLink = h.toPk ? `<a href="#/nodes/${encodeURIComponent(h.toPk)}" class="analytics-link">${esc(h.toName)}</a>` : esc(h.toName || '?');
-        const bestSnr = h.bestSnr != null ? Number(h.bestSnr).toFixed(1) + ' dB' : '<span class="text-muted">—</span>';
-        const medianSnr = h.medianSnr != null ? Number(h.medianSnr).toFixed(1) + ' dB' : '<span class="text-muted">—</span>';
-        const obs = h.obsCount != null ? h.obsCount : 1;
+        const snr = h.snr != null ? h.snr + ' dB' : '<span class="text-muted">—</span>';
         const pktLink = h.hash ? `<a href="#/packet/${encodeURIComponent(h.hash)}" class="analytics-link mono" style="font-size:0.85em">${esc(h.hash.slice(0, 12))}…</a>` : '—';
         const mapBtn = h.fromPk && h.toPk ? `<button class="btn-icon dist-map-hop" data-from="${esc(h.fromPk)}" data-to="${esc(h.toPk)}" title="View on map">🗺️</button>` : '';
-        const tsTitle = h.timestamp ? `Best observation: ${h.timestamp}` : '';
-        html += `<tr title="${esc(tsTitle)}"><td>${i+1}</td><td>${fromLink}</td><td>${toLink}</td><td><strong>${formatDistance(h.dist)}</strong></td><td>${esc(h.type)}</td><td>${obs}</td><td>${bestSnr}</td><td>${medianSnr}</td><td>${pktLink}</td><td>${mapBtn}</td></tr>`;
+        html += `<tr><td>${i+1}</td><td>${fromLink}</td><td>${toLink}</td><td><strong>${formatDistance(h.dist)}</strong></td><td>${esc(h.type)}</td><td>${snr}</td><td>${pktLink}</td><td>${mapBtn}</td></tr>`;
       });
       html += `</tbody></table></div>`;
 
@@ -3485,7 +3448,7 @@ function destroy() { _analyticsData = {}; _channelData = null; if (_ngState && _
           if (sortKey === 'severity') {
             v = (SKEW_SEVERITY_ORDER[a.severity] || 9) - (SKEW_SEVERITY_ORDER[b.severity] || 9);
           } else if (sortKey === 'skew') {
-            v = Math.abs(window.currentSkewValue(b) || 0) - Math.abs(window.currentSkewValue(a) || 0);
+            v = Math.abs(b.medianSkewSec || 0) - Math.abs(a.medianSkewSec || 0);
           } else if (sortKey === 'name') {
             v = (a.nodeName || '').localeCompare(b.nodeName || '');
           } else if (sortKey === 'drift') {
@@ -3495,12 +3458,12 @@ function destroy() { _analyticsData = {}; _channelData = null; if (_ngState && _
         });
 
         // Summary
-        var counts = { ok: 0, degrading: 0, degraded: 0, wrong: 0, default: 0 };
+        var counts = { ok: 0, warning: 0, critical: 0, absurd: 0 };
         data.forEach(function(n) { if (counts[n.severity] !== undefined) counts[n.severity]++; });
 
         // Filter buttons (also serve as summary — no separate stats pills needed)
-        var filterColors = { ok: 'var(--status-green)', degrading: 'var(--status-yellow)', degraded: 'var(--status-orange)', wrong: 'var(--status-red)', default: 'var(--text-muted)' };
-        var filters = ['all', 'ok', 'degrading', 'degraded', 'wrong', 'default'];
+        var filterColors = { ok: 'var(--status-green)', warning: 'var(--status-yellow)', critical: 'var(--status-orange)', absurd: 'var(--status-purple)', no_clock: 'var(--text-muted)' };
+        var filters = ['all', 'ok', 'warning', 'critical', 'absurd', 'no_clock'];
         var filterHtml = '<div style="margin-bottom:10px">' + filters.map(function(f) {
           var dot = f !== 'all' ? '<span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:' + filterColors[f] + ';margin-right:4px;vertical-align:middle"></span>' : '';
           return '<button class="clock-filter-btn' + (activeFilter === f ? ' active' : '') + '" data-filter="' + f + '">' +
@@ -3512,13 +3475,12 @@ function destroy() { _analyticsData = {}; _channelData = null; if (_ngState && _
         var rowsHtml = filtered.map(function(n) {
           var rowClass = 'clock-fleet-row--' + (n.severity || 'ok');
           var lastAdv = n.lastObservedTS ? new Date(n.lastObservedTS * 1000).toISOString().replace('T', ' ').replace(/\.\d+Z/, ' UTC') : '—';
-          var skewVal = window.currentSkewValue(n);
-          var skewText = n.severity === 'default' ? 'Default' : formatSkew(skewVal);
-          var driftText = n.severity === 'default' || !n.driftPerDaySec ? '–' : formatDrift(n.driftPerDaySec);
+          var skewText = n.severity === 'no_clock' ? 'No Clock' : formatSkew(n.medianSkewSec);
+          var driftText = n.severity === 'no_clock' || !n.driftPerDaySec ? '–' : formatDrift(n.driftPerDaySec);
           return '<tr class="' + rowClass + '" data-pubkey="' + esc(n.pubkey) + '" style="cursor:pointer">' +
             '<td><strong>' + esc(n.nodeName || n.pubkey.slice(0, 12)) + '</strong></td>' +
             '<td style="font-family:var(--mono,monospace)">' + skewText + '</td>' +
-            '<td>' + renderSkewBadge(n.severity, skewVal, n) + '</td>' +
+            '<td>' + renderSkewBadge(n.severity, n.medianSkewSec) + '</td>' +
             '<td style="font-family:var(--mono,monospace)">' + driftText + '</td>' +
             '<td style="font-size:11px">' + lastAdv + '</td>' +
             '</tr>';

public/app.js

@@ -10,75 +10,8 @@ function routeTypeName(n) { return ROUTE_TYPES[n] || 'UNKNOWN'; }
 function payloadTypeName(n) { return PAYLOAD_TYPES[n] || 'UNKNOWN'; }
 function payloadTypeColor(n) { return PAYLOAD_COLORS[n] || 'unknown'; }
 function isTransportRoute(rt) { return rt === 0 || rt === 3; }
-/** Byte offset of path_len in raw_hex: 5 for transport routes (4 bytes of next/last hop codes precede it), 1 otherwise. */
-function getPathLenOffset(routeType) { return isTransportRoute(routeType) ? 5 : 1; }
 function transportBadge(rt) { return isTransportRoute(rt) ? ' <span class="badge badge-transport" title="' + routeTypeName(rt) + '">T</span>' : ''; }
 
-/**
- * Compute breakdown byte ranges from raw_hex on the client.
- * Mirrors cmd/server/decoder.go BuildBreakdown(). Used so per-observation raw_hex
- * (which can differ in path length from the top-level packet) gets accurate
- * highlighted byte ranges, instead of using the server-supplied breakdown
- * computed once from the top-level raw_hex.
- */
-function computeBreakdownRanges(hexString, routeType, payloadType) {
-  if (!hexString) return [];
-  const clean = hexString.replace(/\s+/g, '');
-  const bytes = clean.length / 2;
-  if (bytes < 2) return [];
-  const ranges = [];
-  // Header
-  ranges.push({ start: 0, end: 0, label: 'Header' });
-  let offset = 1;
-  if (isTransportRoute(routeType)) {
-    if (bytes < offset + 4) return ranges;
-    ranges.push({ start: offset, end: offset + 3, label: 'Transport Codes' });
-    offset += 4;
-  }
-  if (offset >= bytes) return ranges;
-  // Path Length byte
-  ranges.push({ start: offset, end: offset, label: 'Path Length' });
-  const pathByte = parseInt(clean.slice(offset * 2, offset * 2 + 2), 16);
-  offset += 1;
-  if (isNaN(pathByte)) return ranges;
-  const hashSize = (pathByte >> 6) + 1;
-  const hashCount = pathByte & 0x3F;
-  const pathBytes = hashSize * hashCount;
-  if (hashCount > 0 && offset + pathBytes <= bytes) {
-    ranges.push({ start: offset, end: offset + pathBytes - 1, label: 'Path' });
-  }
-  offset += pathBytes;
-  if (offset >= bytes) return ranges;
-  const payloadStart = offset;
-  // ADVERT (payload_type 4) gets sub-fields when full record present
-  if (payloadType === 4 && bytes - payloadStart >= 100) {
-    ranges.push({ start: payloadStart,      end: payloadStart + 31, label: 'PubKey' });
-    ranges.push({ start: payloadStart + 32, end: payloadStart + 35, label: 'Timestamp' });
-    ranges.push({ start: payloadStart + 36, end: payloadStart + 99, label: 'Signature' });
-    const appStart = payloadStart + 100;
-    if (appStart < bytes) {
-      ranges.push({ start: appStart, end: appStart, label: 'Flags' });
-      const appFlags = parseInt(clean.slice(appStart * 2, appStart * 2 + 2), 16);
-      let fOff = appStart + 1;
-      if (!isNaN(appFlags)) {
-        if ((appFlags & 0x10) && fOff + 8 <= bytes) {
-          ranges.push({ start: fOff,     end: fOff + 3, label: 'Latitude' });
-          ranges.push({ start: fOff + 4, end: fOff + 7, label: 'Longitude' });
-          fOff += 8;
-        }
-        if ((appFlags & 0x20) && fOff + 2 <= bytes) fOff += 2;
-        if ((appFlags & 0x40) && fOff + 2 <= bytes) fOff += 2;
-        if ((appFlags & 0x80) && fOff < bytes) {
-          ranges.push({ start: fOff, end: bytes - 1, label: 'Name' });
-        }
-      }
-    }
-  } else {
-    ranges.push({ start: payloadStart, end: bytes - 1, label: 'Payload' });
-  }
-  return ranges;
-}
-
 // --- Utilities ---
 const _apiPerf = { calls: 0, totalMs: 0, log: [], cacheHits: 0 };
 const _apiCache = new Map();
@@ -505,21 +438,6 @@ const pages = {};
 
 function registerPage(name, mod) { pages[name] = mod; }
 
-// Tools landing page — shows sub-menu with Trace and Path Inspector (spec §2.8, M1 fix).
-registerPage('tools-landing', {
-  init: function (container) {
-    container.innerHTML =
-      '<div class="tools-landing">' +
-        '<h2>Tools</h2>' +
-        '<div class="tools-menu">' +
-          '<a href="#/tools/path-inspector" class="tools-card"><h3>🔍 Path Inspector</h3><p>Resolve prefix paths to candidate full-pubkey routes with confidence scoring.</p></a>' +
-          '<a href="#/tools/trace/" class="tools-card"><h3>📡 Trace Viewer</h3><p>View detailed packet traces by hash.</p></a>' +
-        '</div>' +
-      '</div>';
-  },
-  destroy: function () {}
-});
-
 let currentPage = null;
 
 function closeNav() {
@@ -540,12 +458,6 @@ function closeMoreMenu() {
 function navigate() {
   closeNav();
 
-  // Backward-compat redirect: #/traces/<hash> → #/tools/trace/<hash> (issue #944).
-  if (location.hash.startsWith('#/traces/')) {
-    location.hash = location.hash.replace('#/traces/', '#/tools/trace/');
-    return;
-  }
-
   const hash = location.hash.replace('#/', '') || 'packets';
   const route = hash.split('?')[0];
 
@@ -573,27 +485,9 @@ function navigate() {
     basePage = 'observer-detail';
   }
 
-  // Tools sub-routing (issue #944): tools/trace/<hash>, tools/path-inspector
-  if (basePage === 'tools') {
-    if (routeParam && routeParam.startsWith('trace/')) {
-      basePage = 'traces';
-      routeParam = routeParam.substring(6); // strip "trace/"
-    } else if (routeParam === 'path-inspector' || (routeParam && routeParam.startsWith('path-inspector'))) {
-      basePage = 'path-inspector';
-      routeParam = null;
-    } else if (!routeParam) {
-      // Default tools landing shows menu with both entries.
-      basePage = 'tools-landing';
-    }
-  }
-  // Also support old #/traces (no sub-path) → traces page.
-  if (basePage === 'traces' && !routeParam) {
-    basePage = 'traces';
-  }
-
   // Update nav active state
   document.querySelectorAll('.nav-link[data-route]').forEach(el => {
-    el.classList.toggle('active', el.dataset.route === basePage || (el.dataset.route === 'tools' && (basePage === 'traces' || basePage === 'path-inspector' || basePage === 'tools-landing')));
+    el.classList.toggle('active', el.dataset.route === basePage);
   });
   // Update "More" button to show active state if a low-priority page is selected
   var moreBtn = document.getElementById('navMoreBtn');
@@ -1133,6 +1027,7 @@ function makeColumnsResizable(tableSelector, storageKey) {
   // Add resize handles
   ths.forEach((th, i) => {
     if (i === ths.length - 1) return;
+    th.style.position = 'relative';
     const handle = document.createElement('div');
     handle.className = 'col-resize-handle';
     handle.addEventListener('mousedown', (e) => {

public/channels.js

@@ -393,25 +393,17 @@
     }
   }
 
-  // Merge user-stored keys into the channel list.
-  // If a stored key matches a server-known channel, mark that channel as
-  // userAdded so the ✕ button appears — otherwise the user has no way to
-  // remove a key they added but that the server already knows about.
+  // Merge user-stored keys into the channel list
   function mergeUserChannels() {
     var keys = ChannelDecrypt.getStoredKeys();
     var names = Object.keys(keys);
     for (var i = 0; i < names.length; i++) {
       var name = names[i];
-      var matched = false;
-      for (var j = 0; j < channels.length; j++) {
-        var ch = channels[j];
-        if (ch.name === name || ch.hash === name || ch.hash === ('user:' + name)) {
-          ch.userAdded = true;
-          matched = true;
-          break;
-        }
-      }
-      if (!matched) {
+      // Check if channel already exists by name
+      var exists = channels.some(function (ch) {
+        return ch.name === name || ch.hash === name || ch.hash === ('user:' + name);
+      });
+      if (!exists) {
         channels.push({
           hash: 'user:' + name,
           name: name,
@@ -757,38 +749,19 @@
         e.stopPropagation();
         var channelHash = removeBtn.getAttribute('data-remove-channel');
         if (!channelHash) return;
-        // The localStorage key is the channel name. For user:-prefixed entries
-        // strip the prefix; for server-known channels look up the channel
-        // object so we use its display name (the hash itself isn't the key).
-        var ch = channels.find(function (c) { return c.hash === channelHash; });
-        var chName = channelHash.startsWith('user:')
-          ? channelHash.substring(5)
-          : (ch && ch.name) || channelHash;
+        var chName = channelHash.startsWith('user:') ? channelHash.substring(5) : channelHash;
         if (!confirm('Remove channel "' + chName + '"? This will clear saved keys and cached messages.')) return;
         ChannelDecrypt.removeKey(chName);
-        if (channelHash.startsWith('user:')) {
-          // Pure user-added channel — drop from the list entirely.
-          channels = channels.filter(function (c) { return c.hash !== channelHash; });
-          if (selectedHash === channelHash) {
-            selectedHash = null;
-            messages = [];
-            history.replaceState(null, '', '#/channels');
-            var msgEl2 = document.getElementById('chMessages');
-            if (msgEl2) msgEl2.innerHTML = '<div class="ch-empty">Choose a channel from the sidebar to view messages</div>';
-            var header2 = document.getElementById('chHeader');
-            if (header2) header2.querySelector('.ch-header-text').textContent = 'Select a channel';
-          }
-        } else if (ch) {
-          // Server-known channel: keep the row, just unmark as user-added so
-          // the ✕ disappears until they re-add a key.
-          ch.userAdded = false;
-          // If this was the selected channel, clear decrypted messages since
-          // the key is gone — they can't be re-decrypted without re-adding it.
-          if (selectedHash === channelHash) {
-            messages = [];
-            var msgEl2 = document.getElementById('chMessages');
-            if (msgEl2) msgEl2.innerHTML = '<div class="ch-empty">Key removed — add a key to decrypt messages</div>';
-          }
+        // Remove from channels array
+        channels = channels.filter(function (c) { return c.hash !== channelHash; });
+        if (selectedHash === channelHash) {
+          selectedHash = null;
+          messages = [];
+          history.replaceState(null, '', '#/channels');
+          var msgEl2 = document.getElementById('chMessages');
+          if (msgEl2) msgEl2.innerHTML = '<div class="ch-empty">Choose a channel from the sidebar to view messages</div>';
+          var header2 = document.getElementById('chHeader');
+          if (header2) header2.querySelector('.ch-header-text').textContent = 'Select a channel';
         }
         renderChannelList();
         return;
@@ -1187,43 +1160,6 @@
           return;
         }
       }
-      // #781: No matching key found — show lock message instead of fetching gibberish
-      msgEl.innerHTML = '<div class="ch-empty">🔒 This channel is encrypted and no decryption key is configured</div>';
-      return;
-    }
-
-    // #811: Deep link to a `#`-named channel that's not in the loaded list.
-    // If a stored key matches, decrypt. Otherwise we must distinguish an
-    // encrypted-no-key channel (show lock) from an unencrypted channel that
-    // simply isn't in the toggle-off list (#825 — must fall through to REST).
-    if (hash.charAt(0) === '#') {
-      if (storedKeys[hash]) {
-        var keyHex2 = storedKeys[hash];
-        var keyBytes2 = ChannelDecrypt.hexToBytes(keyHex2);
-        var hashByte2 = await ChannelDecrypt.computeChannelHash(keyBytes2);
-        await decryptAndRender(keyHex2, hashByte2, hash);
-        return;
-      }
-      // #825: confirm encrypted-ness via an encrypted-included channel list
-      // before assuming a lock state. Conservative on error — fall through.
-      // Show a loading affordance so cold deep links don't display stale content
-      // for the duration of the metadata RTT (cached 15s thereafter).
-      msgEl.innerHTML = '<div class="ch-loading">Loading messages…</div>';
-      try {
-        var rpInc = RegionFilter.getRegionParam();
-        var paramsInc = ['includeEncrypted=true'];
-        if (rpInc) paramsInc.push('region=' + encodeURIComponent(rpInc));
-        var allCh = await api('/channels?' + paramsInc.join('&'), { ttl: CLIENT_TTL.channels });
-        if (isStaleMessageRequest(request)) return;
-        var foundCh = (allCh.channels || []).find(function (c) { return c.hash === hash; });
-        if (foundCh && foundCh.encrypted === true) {
-          msgEl.innerHTML = '<div class="ch-empty">🔒 This channel is encrypted and no decryption key is configured</div>';
-          return;
-        }
-        // Unencrypted (or unknown) — fall through to the REST fetch below.
-      } catch (e) {
-        // ignore — fall through to REST fetch
-      }
     }
 
     msgEl.innerHTML = '<div class="ch-loading">Loading messages…</div>';

public/customize-v2.js

@@ -629,11 +629,7 @@
       }
       writeOverrides(delta);
       _runPipeline();
-      // Skip re-render while the user is typing inside the panel — setting
-      // innerHTML would destroy the focused input and collapse the mobile keyboard.
-      if (!(_panelEl && _panelEl.contains(document.activeElement))) {
-        _refreshPanel();
-      }
+      _refreshPanel();
     }, 300);
   }
 

public/geofilter-builder.html

@@ -87,8 +87,7 @@ let polygon = null;
 let closingLine = null;
 
 function latLonPair(latlng) {
-  const w = latlng.wrap();
-  return [parseFloat(w.lat.toFixed(6)), parseFloat(w.lng.toFixed(6))];
+  return [parseFloat(latlng.lat.toFixed(6)), parseFloat(latlng.lng.toFixed(6))];
 }
 
 function render() {

public/hop-display.js

@@ -81,13 +81,9 @@ window.HopDisplay = (function() {
     const regionalConflicts = conflicts.filter(c => c.regional);
     const badgeCount = regionalConflicts.length > 0 ? regionalConflicts.length : (globalFallback ? conflicts.length : 0);
     const conflictData = escapeHtml(JSON.stringify({ h, conflicts, globalFallback }));
-    const conflictBadge = badgeCount > 1
+    const warnBadge = badgeCount > 1
       ? ` <button class="hop-conflict-btn" data-conflict='${conflictData}' onclick="event.preventDefault();event.stopPropagation();HopDisplay._showFromBtn(this)" title="${badgeCount} candidates — click for details">⚠${badgeCount}</button>`
       : '';
-    const unreliableBadge = unreliable
-      ? ' <button class="hop-unreliable-btn" aria-label="Unreliable name resolution" title="Unreliable name resolution — this hash\u2192name match is geographically inconsistent with the surrounding path hops. The repeater itself may be fine; this specific hop assignment is uncertain.">⚠️</button>'
-      : '';
-    const warnBadge = conflictBadge + unreliableBadge;
 
     const cls = [
       'hop',

public/hop-resolver.js

@@ -7,14 +7,6 @@ window.HopResolver = (function() {
 
   const MAX_HOP_DIST = 1.8; // ~200km in degrees
   const REGION_RADIUS_KM = 300;
-
-  // Only repeaters and room servers can appear as path hops per protocol.
-  // Companions/sensors originate but never relay packets.
-  function canAppearInPath(role) {
-    if (!role) return false;
-    var r = String(role).toLowerCase();
-    return r.indexOf('repeater') >= 0 || r.indexOf('room_server') >= 0 || r === 'room';
-  }
   let prefixIdx = {};   // lowercase hex prefix → [node, ...]
   let pubkeyIdx = {};   // full lowercase pubkey → node (O(1) lookup)
   let nodesList = [];
@@ -48,11 +40,7 @@ window.HopResolver = (function() {
     for (const n of nodesList) {
       if (!n.public_key) continue;
       const pk = n.public_key.toLowerCase();
-      // pubkeyIdx includes ALL nodes — used by resolveFromServer for
-      // server-confirmed full-pubkey lookups (any node type).
       pubkeyIdx[pk] = n;
-      // prefixIdx only includes nodes that can appear as path hops.
-      if (!canAppearInPath(n.role)) continue;
       for (let len = 1; len <= 3; len++) {
         const p = pk.slice(0, len * 2);
         if (!prefixIdx[p]) prefixIdx[p] = [];
@@ -84,89 +72,33 @@ window.HopResolver = (function() {
   }
 
   /**
-   * Pick the best candidate by scoring against BOTH prev and next resolved hops.
-   *
-   * Strategy (in priority order):
-   * 1. Neighbor-graph edge weight: sum of edge scores to prevPubkey + nextPubkey. Pick max.
-   * 2. Geographic centroid: if no candidate has graph edges, compute centroid of
-   *    prev+next positions and pick closest candidate by haversine distance.
-   * 3. Single-anchor geo fallback: if only one neighbor is resolved, use it as anchor.
-   * 4. Original heuristic: first candidate (when no context at all).
-   *
+   * Pick the best candidate using affinity first, then geo-distance fallback.
    * @param {Array} candidates - candidates with lat/lon/pubkey/name
-   * @param {string|null} prevPubkey - pubkey of previous resolved hop
-   * @param {string|null} nextPubkey - pubkey of next resolved hop
-   * @param {Object|null} prevPos - {lat, lon} of previous resolved hop or origin
-   * @param {Object|null} nextPos - {lat, lon} of next resolved hop or observer
+   * @param {string|null} adjacentPubkey - pubkey of the previously/next resolved hop
+   * @param {Object|null} anchor - {lat, lon} for geo fallback
+   * @param {number|null} fallbackLat - fallback anchor lat (e.g. observer)
+   * @param {number|null} fallbackLon - fallback anchor lon
    * @returns {Object} best candidate
    */
-  function pickByAffinity(candidates, prevPubkey, nextPubkey, prevPos, nextPos) {
-    const hasGraph = Object.keys(affinityMap).length > 0;
-    const hasAdj = prevPubkey || nextPubkey;
-
-    // Strategy 1: neighbor-graph edge weights (sum of prev + next)
-    if (hasGraph && hasAdj) {
-      const scored = candidates.map(function(c) {
-        let s = 0;
-        if (prevPubkey) s += getAffinity(prevPubkey, c.pubkey);
-        if (nextPubkey) s += getAffinity(nextPubkey, c.pubkey);
-        return { candidate: c, edgeScore: s };
-      });
-      const withEdges = scored.filter(function(s) { return s.edgeScore > 0; });
-      if (withEdges.length > 0) {
-        withEdges.sort(function(a, b) { return b.edgeScore - a.edgeScore; });
-        _traceMultiCandidate(candidates, scored, withEdges[0].candidate, 'graph');
-        return withEdges[0].candidate;
+  function pickByAffinity(candidates, adjacentPubkey, anchor, fallbackLat, fallbackLon) {
+    // If we have affinity data and an adjacent hop, prefer neighbors
+    if (adjacentPubkey && Object.keys(affinityMap).length > 0) {
+      const withAffinity = candidates
+        .map(c => ({ ...c, affinity: getAffinity(adjacentPubkey, c.pubkey) }))
+        .filter(c => c.affinity > 0);
+      if (withAffinity.length > 0) {
+        withAffinity.sort((a, b) => b.affinity - a.affinity);
+        return withAffinity[0];
       }
     }
-
-    // Strategy 2/3: geographic — centroid of prev+next, or single anchor
-    let anchorLat = null, anchorLon = null, anchorCount = 0;
-    if (prevPos && prevPos.lat != null && prevPos.lon != null) {
-      anchorLat = (anchorLat || 0) + prevPos.lat;
-      anchorLon = (anchorLon || 0) + prevPos.lon;
-      anchorCount++;
+    // Fallback: geo-distance sort (existing behavior)
+    const effectiveAnchor = anchor || (fallbackLat != null ? { lat: fallbackLat, lon: fallbackLon } : null);
+    if (effectiveAnchor) {
+      candidates.sort((a, b) => dist(a.lat, a.lon, effectiveAnchor.lat, effectiveAnchor.lon) - dist(b.lat, b.lon, effectiveAnchor.lat, effectiveAnchor.lon));
     }
-    if (nextPos && nextPos.lat != null && nextPos.lon != null) {
-      anchorLat = (anchorLat || 0) + nextPos.lat;
-      anchorLon = (anchorLon || 0) + nextPos.lon;
-      anchorCount++;
-    }
-    if (anchorCount > 0) {
-      anchorLat /= anchorCount;
-      anchorLon /= anchorCount;
-      const geoScored = candidates.map(function(c) {
-        const d = (c.lat != null && c.lon != null && !(c.lat === 0 && c.lon === 0))
-          ? haversineKm(c.lat, c.lon, anchorLat, anchorLon) : 999999;
-        return { candidate: c, distKm: d };
-      });
-      geoScored.sort(function(a, b) { return a.distKm - b.distKm; });
-      _traceMultiCandidate(candidates, geoScored, geoScored[0].candidate, 'centroid');
-      return geoScored[0].candidate;
-    }
-
-    // Strategy 4: no context — return first candidate
-    _traceMultiCandidate(candidates, null, candidates[0], 'fallback');
     return candidates[0];
   }
 
-  /** Dev-mode console trace for multi-candidate picks */
-  function _traceMultiCandidate(candidates, scored, chosen, method) {
-    if (typeof console === 'undefined' || !console.debug) return;
-    if (candidates.length < 2) return;
-    try {
-      const prefix = candidates[0].pubkey ? candidates[0].pubkey.slice(0, 2) : '??';
-      const scoreSummary = scored ? scored.map(function(s) {
-        const pk = (s.candidate || s).pubkey || '?';
-        const val = s.edgeScore != null ? s.edgeScore : (s.distKm != null ? s.distKm + 'km' : '?');
-        return pk.slice(0, 8) + ':' + val;
-      }) : [];
-      console.debug('[hop-resolver] hash=' + prefix + ' candidates=' + candidates.length +
-        ' scored=[' + scoreSummary.join(',') + '] chose=' + (chosen.pubkey || '?').slice(0, 8) +
-        ' method=' + method);
-    } catch(e) { /* trace is best-effort */ }
-  }
-
   /**
    * Resolve an array of hex hop prefixes to node info.
    * Returns a map: { hop: {name, pubkey, lat, lon, ambiguous, unreliable} }
@@ -237,54 +169,52 @@ window.HopResolver = (function() {
       }
     }
 
-    // Combined disambiguation: resolve ambiguous hops using both neighbors.
-    // We iterate until no more hops can be resolved (handles cascading dependencies).
-    const originPos = (originLat != null && originLon != null) ? { lat: originLat, lon: originLon } : null;
-    const observerPos = (observerLat != null && observerLon != null) ? { lat: observerLat, lon: observerLon } : null;
-
-    let changed = true;
-    let maxIter = hops.length + 1; // prevent infinite loops
-    while (changed && maxIter-- > 0) {
-      changed = false;
-      for (let i = 0; i < hops.length; i++) {
-        const hop = hops[i];
-        if (hopPositions[hop]) continue; // already resolved
-        const r = resolved[hop];
-        if (!r || !r.ambiguous) continue;
-        const withLoc = r.candidates.filter(c => c.lat != null && c.lon != null && !(c.lat === 0 && c.lon === 0));
-        if (!withLoc.length) continue;
-
-        // Find prev resolved neighbor
-        let prevPubkey = null, prevPos = null;
-        for (let j = i - 1; j >= 0; j--) {
-          if (hopPositions[hops[j]]) {
-            prevPos = hopPositions[hops[j]];
-            prevPubkey = resolved[hops[j]] ? resolved[hops[j]].pubkey : null;
-            break;
-          }
-        }
-        if (!prevPos && originPos) prevPos = originPos;
-
-        // Find next resolved neighbor
-        let nextPubkey = null, nextPos = null;
-        for (let j = i + 1; j < hops.length; j++) {
-          if (hopPositions[hops[j]]) {
-            nextPos = hopPositions[hops[j]];
-            nextPubkey = resolved[hops[j]] ? resolved[hops[j]].pubkey : null;
-            break;
-          }
-        }
-        if (!nextPos && observerPos) nextPos = observerPos;
-
-        // Skip if we have zero context (wait for a later iteration or neighbor resolution)
-        if (!prevPubkey && !nextPubkey && !prevPos && !nextPos) continue;
-
-        const picked = pickByAffinity(withLoc, prevPubkey, nextPubkey, prevPos, nextPos);
-        r.name = picked.name;
-        r.pubkey = picked.pubkey;
-        hopPositions[hop] = { lat: picked.lat, lon: picked.lon };
-        changed = true;
+    // Forward pass
+    let lastPos = (originLat != null && originLon != null) ? { lat: originLat, lon: originLon } : null;
+    let lastResolvedPubkey = null;
+    for (let i = 0; i < hops.length; i++) {
+      const hop = hops[i];
+      if (hopPositions[hop]) {
+        lastPos = hopPositions[hop];
+        lastResolvedPubkey = resolved[hop] ? resolved[hop].pubkey : null;
+        continue;
       }
+      const r = resolved[hop];
+      if (!r || !r.ambiguous) continue;
+      const withLoc = r.candidates.filter(c => c.lat && c.lon && !(c.lat === 0 && c.lon === 0));
+      if (!withLoc.length) continue;
+
+      // Affinity-aware: prefer candidates that are neighbors of the previous hop
+      const picked = pickByAffinity(withLoc, lastResolvedPubkey, lastPos, i === hops.length - 1 ? observerLat : null, i === hops.length - 1 ? observerLon : null);
+      r.name = picked.name;
+      r.pubkey = picked.pubkey;
+      hopPositions[hop] = { lat: picked.lat, lon: picked.lon };
+      lastPos = hopPositions[hop];
+      lastResolvedPubkey = picked.pubkey;
+    }
+
+    // Backward pass
+    let nextPos = (observerLat != null && observerLon != null) ? { lat: observerLat, lon: observerLon } : null;
+    let nextResolvedPubkey = null;
+    for (let i = hops.length - 1; i >= 0; i--) {
+      const hop = hops[i];
+      if (hopPositions[hop]) {
+        nextPos = hopPositions[hop];
+        nextResolvedPubkey = resolved[hop] ? resolved[hop].pubkey : null;
+        continue;
+      }
+      const r = resolved[hop];
+      if (!r || !r.ambiguous) continue;
+      const withLoc = r.candidates.filter(c => c.lat && c.lon && !(c.lat === 0 && c.lon === 0));
+      if (!withLoc.length || !nextPos) continue;
+
+      // Affinity-aware: prefer candidates that are neighbors of the next hop
+      const picked = pickByAffinity(withLoc, nextResolvedPubkey, nextPos, null, null);
+      r.name = picked.name;
+      r.pubkey = picked.pubkey;
+      hopPositions[hop] = { lat: picked.lat, lon: picked.lon };
+      nextPos = hopPositions[hop];
+      nextResolvedPubkey = picked.pubkey;
     }
 
     // Sanity check: drop hops impossibly far from neighbors
@@ -346,13 +276,13 @@ window.HopResolver = (function() {
    */
   function resolveFromServer(hops, resolvedPath) {
     if (!hops || !resolvedPath || hops.length !== resolvedPath.length) return {};
-    const result = {};
-    for (let i = 0; i < hops.length; i++) {
-      const hop = hops[i];
-      const pubkey = resolvedPath[i];
+    var result = {};
+    for (var i = 0; i < hops.length; i++) {
+      var hop = hops[i];
+      var pubkey = resolvedPath[i];
       if (!pubkey) continue; // null = unresolved, leave for client-side fallback
       // O(1) lookup via pubkeyIdx built during init()
-      const node = pubkeyIdx[pubkey.toLowerCase()] || null;
+      var node = pubkeyIdx[pubkey.toLowerCase()] || null;
       result[hop] = {
         name: node ? node.name : pubkey.slice(0, 8),
         pubkey: pubkey,

public/index.html

@@ -50,7 +50,7 @@
         <a href="#/live" class="nav-link" data-route="live" data-priority="high">🔴 Live</a>
         <a href="#/channels" class="nav-link" data-route="channels">Channels</a>
         <a href="#/nodes" class="nav-link" data-route="nodes" data-priority="high">Nodes</a>
-        <a href="#/tools" class="nav-link" data-route="tools">Tools</a>
+        <a href="#/traces" class="nav-link" data-route="traces">Traces</a>
         <a href="#/observers" class="nav-link" data-route="observers">Observers</a>
         <a href="#/analytics" class="nav-link" data-route="analytics">Analytics</a>
         <a href="#/perf" class="nav-link" data-route="perf">⚡ Perf</a>
@@ -105,7 +105,6 @@
   <script src="table-sort.js?v=__BUST__"></script>
   <script src="nodes.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="traces.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="path-inspector.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="analytics.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="audio.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="audio-v1-constellation.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>

public/live.css

@@ -132,7 +132,7 @@
 
 /* ---- Node Detail Panel ---- */
 .live-node-detail {
-  top: 64px;
+  top: 60px;
   right: 12px;
   width: 320px;
   max-height: calc(100vh - 140px);
@@ -325,14 +325,11 @@
   }
   .live-stats-row { flex-wrap: wrap; gap: 4px; }
   .live-stat-pill { font-size: 11px; padding: 2px 7px; }
-  .live-toggles { font-size: 10px; gap: 6px; margin-left: 0; overflow-x: auto; flex-wrap: nowrap; -webkit-overflow-scrolling: touch; width: 100%; min-width: 0; }
+  .live-toggles { font-size: 10px; gap: 6px; margin-left: 0; }
   .live-title { font-size: 12px; letter-spacing: 1px; }
   /* #203 — bottom-sheet node detail on mobile */
-  .live-node-detail { width: 100%; right: 0; left: 0; top: auto; bottom: 0; max-height: 60dvh; border-radius: 16px 16px 0 0; overflow-y: auto; z-index: 1050; }
+  .live-node-detail { width: 100%; right: 0; left: 0; top: auto; bottom: 0; max-height: 60vh; border-radius: 16px 16px 0 0; overflow-y: auto; }
   .live-node-detail.hidden { transform: translateY(100%); }
-  /* Close button was unreachable: panel-header collapsed to 8px on mobile, panel-content
-     scroll area started at y=8, overlapping the button's 36px tap target (y=6–42) */
-  .live-node-detail .panel-header { min-height: 44px; }
   .feed-detail-card {
     position: fixed !important;
     right: 0 !important;
@@ -692,18 +689,6 @@
 .live-feed { bottom: 68px; }
 .feed-show-btn { bottom: 68px !important; }
 
-/* Backdrop for mobile tap-outside-to-close (#797) */
-.node-detail-backdrop {
-  display: none;
-  position: absolute;
-  inset: 0;
-  z-index: 1049;
-  background: rgba(0, 0, 0, 0.25);
-}
-@media (max-width: 640px) {
-  .node-detail-backdrop.active { display: block; }
-}
-
 /* Mobile VCR */
 @media (max-width: 640px) {
   /* Mobile VCR: two-row stacked layout */

public/live.js

@@ -849,7 +849,6 @@
           <div class="panel-content" aria-live="polite" aria-relevant="additions" role="log"></div>
         </div>
         <button class="feed-show-btn hidden" id="feedShowBtn" title="Show feed">📋</button>
-        <div id="nodeDetailBackdrop" class="node-detail-backdrop"></div>
         <div class="live-overlay live-node-detail hidden" id="liveNodeDetail">
           <div class="panel-header">
             <button class="panel-corner-btn" data-panel="liveNodeDetail" title="Move panel to next corner" aria-label="Move panel to next corner">◫</button>
@@ -1217,14 +1216,10 @@
     // Node detail panel
     const nodeDetailPanel = document.getElementById('liveNodeDetail');
     const nodeDetailContent = document.getElementById('nodeDetailContent');
-    const nodeDetailBackdrop = document.getElementById('nodeDetailBackdrop');
-    function closeNodeDetail() {
+    document.getElementById('nodeDetailClose').addEventListener('click', () => {
       activeNodeDetailKey = null;
       nodeDetailPanel.classList.add('hidden');
-      nodeDetailBackdrop.classList.remove('active');
-    }
-    document.getElementById('nodeDetailClose').addEventListener('click', closeNodeDetail);
-    nodeDetailBackdrop.addEventListener('click', closeNodeDetail);
+    });
 
     // Feed panel resize handle (#27)
     const savedFeedWidth = localStorage.getItem('live-feed-width');
@@ -1456,7 +1451,6 @@
     const panel = document.getElementById('liveNodeDetail');
     const content = document.getElementById('nodeDetailContent');
     panel.classList.remove('hidden');
-    document.getElementById('nodeDetailBackdrop').classList.add('active');
     content.innerHTML = '<div style="padding:20px;color:var(--text-muted)">Loading…</div>';
     try {
       const [data, healthData] = await Promise.all([

public/map.js

@@ -102,21 +102,8 @@
 
   async function init(container) {
     container.innerHTML = `
-      <div id="map-wrap" style="position:relative;width:100%;height:100%;display:flex;">
-        <div id="leaflet-map" style="flex:1 1 0%;height:100%;"></div>
-        <div class="map-side-pane" id="mapSidePane">
-          <div class="pane-toggle" id="mapPaneToggle" title="Path Inspector">◀</div>
-          <div class="pane-content">
-            <h3 style="margin:0 0 8px 0;font-size:14px;">Path Inspector</h3>
-            <p style="font-size:11px;color:var(--text-muted);margin:0 0 8px 0;">Hex prefixes (1-3 bytes), comma or space separated.</p>
-            <div style="display:flex;gap:4px;margin-bottom:8px;">
-              <input type="text" id="mapPiInput" class="input" placeholder="2C,A1,F4" style="flex:1;">
-              <button id="mapPiSubmit" class="btn btn-primary btn-sm">Go</button>
-            </div>
-            <div id="mapPiError" class="path-inspector-error"></div>
-            <div id="mapPiResults"></div>
-          </div>
-        </div>
+      <div id="map-wrap" style="position:relative;width:100%;height:100%;">
+        <div id="leaflet-map" style="width:100%;height:100%;"></div>
         <button class="map-controls-toggle" id="mapControlsToggle" aria-label="Toggle map controls" aria-expanded="true">⚙️</button>
         <div class="map-controls" id="mapControls" role="region" aria-label="Map controls">
           <h3>🗺️ Map Controls</h3>
@@ -566,19 +553,6 @@
         }
       }
 
-      // Check for pending path inspector route (cross-page navigation from Path Inspector).
-      if (window._pendingPathInspectorRoute) {
-        var pending = window._pendingPathInspectorRoute;
-        delete window._pendingPathInspectorRoute;
-        if (pending.path && pending.path.length > 0) {
-          if (window.routeLayer) window.routeLayer.clearLayers();
-          drawPacketRoute(pending.path.slice(1), pending.path[0]);
-        }
-      }
-
-      // Wire up map side pane (Path Inspector embedded - spec §2.7).
-      initMapSidePane();
-
       // Don't fitBounds on initial load — respect the Bay Area default or saved view
       // Only fitBounds on subsequent data refreshes if user hasn't manually panned
     } catch (e) {
@@ -991,7 +965,7 @@
         </dl>
         <div style="margin-top:8px;clear:both;">
           <a href="#/nodes/${node.public_key}" style="color:var(--accent);font-size:12px;">View Node →</a>
-          ${node.public_key ? ` · <a href="javascript:void(0)" role="button" data-show-neighbors data-pubkey="${escapeHtml(node.public_key)}" data-name="${escapeHtml(node.name || 'Unknown')}" style="color:var(--accent);font-size:12px;cursor:pointer;">Show Neighbors</a>` : ''}
+          ${node.public_key ? ` · <a href="#" data-show-neighbors data-pubkey="${escapeHtml(node.public_key)}" data-name="${escapeHtml(node.name || 'Unknown')}" style="color:var(--accent);font-size:12px;">Show Neighbors</a>` : ''}
         </div>
       </div>`;
   }
@@ -1007,122 +981,6 @@
     map.fitBounds(bounds, { padding: [50, 50], maxZoom: 14 });
   }
 
-  // === Map Side Pane — Path Inspector (spec §2.7) ===
-  function initMapSidePane() {
-    var pane = document.getElementById('mapSidePane');
-    var toggle = document.getElementById('mapPaneToggle');
-    var input = document.getElementById('mapPiInput');
-    var btn = document.getElementById('mapPiSubmit');
-    if (!pane || !toggle) return;
-
-    toggle.addEventListener('click', function () {
-      pane.classList.toggle('expanded');
-      toggle.textContent = pane.classList.contains('expanded') ? '▶' : '◀';
-      // Invalidate map size after transition.
-      setTimeout(function () { if (map) map.invalidateSize(); }, 220);
-    });
-
-    if (btn && input) {
-      btn.addEventListener('click', function () { mapPiSubmit(input.value); });
-      input.addEventListener('keydown', function (e) {
-        if (e.key === 'Enter') mapPiSubmit(input.value);
-      });
-    }
-
-    // Auto-open if URL has prefixes param while on map.
-    var params = new URLSearchParams(location.hash.split('?')[1] || '');
-    var prefixParam = params.get('prefixes');
-    if (prefixParam && input) {
-      pane.classList.add('expanded');
-      toggle.textContent = '▶';
-      input.value = prefixParam;
-      setTimeout(function () { if (map) map.invalidateSize(); }, 220);
-      mapPiSubmit(prefixParam);
-    }
-  }
-
-  function mapPiSubmit(raw) {
-    var errDiv = document.getElementById('mapPiError');
-    var resultsDiv = document.getElementById('mapPiResults');
-    if (!errDiv || !resultsDiv) return;
-    errDiv.textContent = '';
-    resultsDiv.innerHTML = '';
-
-    // Reuse PathInspector validation if available.
-    var prefixes = raw.trim().split(/[\s,]+/).filter(function (s) { return s.length > 0; }).map(function (s) { return s.toLowerCase(); });
-    var err = (window.PathInspector && window.PathInspector.validatePrefixes) ? window.PathInspector.validatePrefixes(prefixes) : null;
-    if (!err && prefixes.length === 0) err = 'Enter at least one prefix.';
-    if (err) { errDiv.textContent = err; return; }
-
-    resultsDiv.innerHTML = '<p style="font-size:12px;">Loading...</p>';
-    fetch('/api/paths/inspect', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ prefixes: prefixes })
-    })
-      .then(function (r) {
-        if (r.status === 503) return r.json().then(function () { throw new Error('Service warming up, retry shortly.'); });
-        if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || 'Request failed'); });
-        return r.json();
-      })
-      .then(function (data) { renderMapPiResults(data, resultsDiv); })
-      .catch(function (e) { resultsDiv.innerHTML = ''; errDiv.textContent = e.message; });
-  }
-
-  function renderMapPiResults(data, div) {
-    if (!data.candidates || data.candidates.length === 0) {
-      div.innerHTML = '<p style="font-size:12px;color:var(--text-muted);">No candidates found.</p>';
-      return;
-    }
-    var html = '<table class="path-inspector-table" style="font-size:11px;width:100%;"><thead><tr><th>#</th><th>Score</th><th>Path</th><th></th></tr></thead><tbody>';
-    for (var i = 0; i < data.candidates.length; i++) {
-      var c = data.candidates[i];
-      var rowClass = c.speculative ? 'speculative-row' : '';
-      html += '<tr class="' + rowClass + '">';
-      html += '<td>' + (i + 1) + '</td>';
-      html += '<td class="' + (c.speculative ? 'speculative-warning' : '') + '">' + c.score.toFixed(2) + (c.speculative ? ' ⚠' : '') + '</td>';
-      html += '<td title="' + safeEsc(c.names.join(' → ')) + '">' + safeEsc(c.names.slice(0, 3).join('→')) + (c.names.length > 3 ? '…' : '') + '</td>';
-      html += '<td><button class="btn btn-sm" data-idx="' + i + '" title="Show on Map">📍</button></td>';
-      html += '</tr>';
-      // Per-hop evidence (collapsed).
-      html += '<tr class="evidence-row collapsed" data-evidence="' + i + '"><td colspan="4"><div class="evidence-detail" style="font-size:10px;">';
-      if (c.evidence && c.evidence.perHop) {
-        for (var j = 0; j < c.evidence.perHop.length; j++) {
-          var h = c.evidence.perHop[j];
-          html += '<div>Hop ' + (j+1) + ': ' + h.prefix + ' (×' + h.candidatesConsidered + ') w=' + h.edgeWeight.toFixed(2);
-          if (h.alternatives && h.alternatives.length > 0) {
-            html += ' <span style="color:var(--text-muted);">[+' + h.alternatives.length + ' alt]</span>';
-          }
-          html += '</div>';
-        }
-      }
-      html += '</div></td></tr>';
-    }
-    html += '</tbody></table>';
-    div.innerHTML = html;
-
-    // Wire buttons.
-    div.querySelectorAll('button[data-idx]').forEach(function (btn) {
-      btn.addEventListener('click', function () {
-        var idx = parseInt(btn.dataset.idx);
-        var cand = data.candidates[idx];
-        if (routeLayer) routeLayer.clearLayers();
-        drawPacketRoute(cand.path.slice(1), cand.path[0]);
-      });
-    });
-    // Expand evidence on row click.
-    div.querySelectorAll('.path-inspector-table tbody tr:not(.evidence-row)').forEach(function (row) {
-      row.style.cursor = 'pointer';
-      row.addEventListener('click', function (e) {
-        if (e.target.tagName === 'BUTTON') return;
-        var b = row.querySelector('button[data-idx]');
-        if (!b) return;
-        var ev = div.querySelector('tr[data-evidence="' + b.dataset.idx + '"]');
-        if (ev) ev.classList.toggle('collapsed');
-      });
-    });
-  }
-
   function destroy() {
     if (wsHandler) offWS(wsHandler);
     wsHandler = null;

public/nodes.js

@@ -286,29 +286,11 @@
       if (h) h.textContent = 'Neighbors (' + data.neighbors.length + ')';
     }
     var html = renderNeighborTable(data.neighbors, limit);
-    if (limit && data.neighbors.length > limit) {
-      html += '<div style="margin-top:6px;text-align:right"><button class="btn-link show-all-neighbors-btn" style="font-size:12px;cursor:pointer;background:none;border:none;color:var(--accent);padding:0">Show all ' + data.neighbors.length + ' neighbors ▼</button></div>';
-    } else if (!limit && data.neighbors.length > 5) {
-      // Collapse toggle when expanded (#855)
-      html += '<div style="margin-top:6px;text-align:right"><button class="btn-link collapse-neighbors-btn" style="font-size:12px;cursor:pointer;background:none;border:none;color:var(--accent);padding:0">Show fewer ▲</button></div>';
+    if (limit && data.neighbors.length > limit && viewAllPubkey) {
+      html += '<div style="margin-top:6px;text-align:right"><a href="#/nodes/' + encodeURIComponent(viewAllPubkey) + '?section=node-neighbors" style="font-size:12px">View all ' + data.neighbors.length + ' neighbors →</a></div>';
     }
     el.innerHTML = html;
 
-    // Wire "Show all neighbors" expand button (#855)
-    var expandBtn = el.querySelector('.show-all-neighbors-btn');
-    if (expandBtn) {
-      expandBtn.addEventListener('click', function() {
-        renderNeighborData(data, containerId, 0, headerSelector, null);
-      });
-    }
-    // Wire collapse button (#855)
-    var collapseBtn = el.querySelector('.collapse-neighbors-btn');
-    if (collapseBtn) {
-      collapseBtn.addEventListener('click', function() {
-        renderNeighborData(data, containerId, 5, headerSelector, null);
-      });
-    }
-
     // Initialize TableSort on neighbor table
     var neighborTable = el.querySelector('.neighbor-sort-table');
     if (neighborTable && window.TableSort) {
@@ -333,32 +315,34 @@
 
   let regionChangeHandler = null;
 
+  // Show full-screen node detail view (works on any screen size)
+  function showFullScreenNode(pubkey) {
+    var app = document.getElementById('app');
+    app.innerHTML = '<div class="node-fullscreen">' +
+      '<div class="node-full-header">' +
+        '<button class="detail-back-btn node-back-btn" id="nodeBackBtn" aria-label="Back to nodes">←</button>' +
+        '<span class="node-full-title">Loading…</span>' +
+      '</div>' +
+      '<div class="node-full-body" id="nodeFullBody">' +
+        '<div class="text-center text-muted" style="padding:40px">Loading…</div>' +
+      '</div>' +
+    '</div>';
+    document.getElementById('nodeBackBtn').addEventListener('click', function() { location.hash = '#/nodes'; });
+    loadFullNode(pubkey);
+    document.addEventListener('keydown', function nodesEsc(e) {
+      if (e.key === 'Escape') {
+        document.removeEventListener('keydown', nodesEsc);
+        location.hash = '#/nodes';
+      }
+    });
+  }
+
   function init(app, routeParam) {
     directNode = routeParam || null;
 
-    if (directNode) {
-      // Full-screen single node view (desktop + mobile).
-      // Reached via the 🔍 Details link or a deep link to #/nodes/{pubkey}.
-      // Row clicks use history.replaceState (no hashchange → no re-init),
-      // so the split-panel UX on desktop is preserved.
-      app.innerHTML = `<div class="node-fullscreen">
-        <div class="node-full-header">
-          <button class="detail-back-btn node-back-btn" id="nodeBackBtn" aria-label="Back to nodes">←</button>
-          <span class="node-full-title">Loading…</span>
-        </div>
-        <div class="node-full-body" id="nodeFullBody">
-          <div class="text-center text-muted" style="padding:40px">Loading…</div>
-        </div>
-      </div>`;
-      document.getElementById('nodeBackBtn').addEventListener('click', () => { location.hash = '#/nodes'; });
-      loadFullNode(directNode);
-      // Escape to go back to nodes list
-      document.addEventListener('keydown', function nodesEsc(e) {
-        if (e.key === 'Escape') {
-          document.removeEventListener('keydown', nodesEsc);
-          location.hash = '#/nodes';
-        }
-      });
+    if (directNode && window.innerWidth <= 640) {
+      // Full-screen single node view (mobile)
+      showFullScreenNode(directNode);
       return;
     }
 
@@ -373,7 +357,7 @@
 
     app.innerHTML = `<div class="nodes-page">
       <div class="nodes-topbar">
-        <input type="text" class="nodes-search" id="nodeSearch" placeholder="Search by name or pubkey prefix…" aria-label="Search nodes by name or pubkey prefix">
+        <input type="text" class="nodes-search" id="nodeSearch" placeholder="Search nodes by name…" aria-label="Search nodes by name">
         <div class="nodes-counts" id="nodeCounts"></div>
       </div>
       <div id="nodesRegionFilter" class="region-filter-container"></div>
@@ -559,10 +543,9 @@
         </div>
 
         <div class="node-full-card" id="node-packets">
-          ${(() => { const validPackets = adverts.filter(p => p.hash && p.timestamp); return `
-          <h4>Recent Packets (${validPackets.length})</h4>
+          <h4>Recent Packets (${adverts.length})</h4>
           <div class="node-activity-list">
-            ${validPackets.length ? validPackets.map(p => {
+            ${adverts.length ? adverts.map(p => {
               let decoded; try { decoded = JSON.parse(p.decoded_json); } catch {}
               const typeLabel = p.payload_type === 4 ? '📡 Advert' : p.payload_type === 5 ? '💬 Channel' : p.payload_type === 2 ? '✉️ DM' : '📦 Packet';
               const detail = decoded?.text ? ': ' + escapeHtml(truncate(decoded.text, 50)) : decoded?.name ? ' — ' + escapeHtml(decoded.name) : '';
@@ -588,7 +571,6 @@
               </div>`;
             }).join('') : '<div class="text-muted">No recent packets</div>'}
           </div>
-        `; })()}
         </div>`;
 
       // Map
@@ -651,9 +633,34 @@
         headerSelector: '#fullNeighborsHeader'
       });
 
-      // #690 — Clock Skew detail section (full-screen view)
-      loadClockSkewInto(document.getElementById('node-clock-skew'), n.public_key);
-
+      // #690 — Clock Skew detail section
+      (async function loadClockSkew() {
+        var container = document.getElementById('node-clock-skew');
+        if (!container) return;
+        try {
+          var cs = await api('/nodes/' + encodeURIComponent(n.public_key) + '/clock-skew', { ttl: 30000 });
+          if (!cs || !cs.severity) return;
+          container.style.display = '';
+          var severityColor = SKEW_SEVERITY_COLORS[cs.severity] || 'var(--text-muted)';
+          var severityLabel = SKEW_SEVERITY_LABELS[cs.severity] || cs.severity;
+          var driftHtml = cs.driftPerDaySec ? '<div style="font-size:12px;color:var(--text-muted);margin-top:2px">Drift: ' + formatDrift(cs.driftPerDaySec) + '</div>' : '';
+          var sparkHtml = renderSkewSparkline(cs.samples, 200, 32);
+          var skewDisplay = cs.severity === 'no_clock'
+            ? '<span style="font-size:18px;font-weight:700;color:var(--text-muted)">No Clock</span>'
+            : '<span style="font-size:18px;font-weight:700;font-family:var(--mono)">' + formatSkew(cs.medianSkewSec) + '</span>';
+          container.innerHTML =
+            '<h4 style="margin:0 0 6px">⏰ Clock Skew</h4>' +
+            '<div style="display:flex;align-items:center;gap:12px;flex-wrap:wrap">' +
+              skewDisplay +
+              renderSkewBadge(cs.severity, cs.medianSkewSec) +
+              (cs.calibrated ? ' <span style="font-size:10px;color:var(--text-muted)" title="Observer-calibrated">✓ calibrated</span>' : '') +
+            '</div>' +
+            driftHtml +
+            (sparkHtml ? '<div class="skew-sparkline-wrap" style="margin-top:8px">' + sparkHtml + '<div style="font-size:10px;color:var(--text-muted)">Skew over time (' + (cs.samples || []).length + ' samples)</div></div>' : '');
+        } catch (e) {
+          // Non-fatal — section stays hidden
+        }
+      })();
 
       // Affinity debug panel — show if debugAffinity is enabled
       (function loadAffinityDebug() {
@@ -810,57 +817,6 @@
   let _allNodes = null; // cached full node list
   let _fleetSkew = null; // cached clock skew map: pubkey → {severity, medianSkewSec, ...}
 
-  /**
-   * Fetch per-node clock skew and render into the given container element.
-   * Shared between the full-screen detail page and the side panel (#813, #690).
-   * No-op if the container is missing, the API errors, or the response lacks severity.
-   */
-  async function loadClockSkewInto(container, pubkey) {
-    if (!container) return;
-    try {
-      var cs = await api('/nodes/' + encodeURIComponent(pubkey) + '/clock-skew', { ttl: 30000 });
-      if (!cs || !cs.severity) return;
-      container.style.display = '';
-      var driftHtml = cs.driftPerDaySec ? '<div style="font-size:12px;color:var(--text-muted);margin-top:2px">Drift: ' + formatDrift(cs.driftPerDaySec) + '</div>' : '';
-      var sparkHtml = renderSkewSparkline(cs.samples, 200, 32);
-      var skewVal = window.currentSkewValue(cs);
-      var skewDisplay = cs.severity === 'default'
-        ? '<span style="font-size:18px;font-weight:700;color:var(--text-muted)">Default</span>'
-        : '<span style="font-size:18px;font-weight:700;font-family:var(--mono)">' + formatSkew(skewVal) + '</span>';
-
-      // Per-tier explainer line (plain English reason).
-      var explainer = '';
-      var absSkew = Math.abs(cs.lastSkewSec || 0);
-      var skewStr = Math.round(absSkew) + 's';
-      if (cs.severity === 'default') {
-        var isoAdv = cs.lastAdvertTS ? new Date(cs.lastAdvertTS * 1000).toISOString() : '?';
-        explainer = 'Last advert at ' + isoAdv + ' — matches firmware default (volatile RTC, not user-set since boot)';
-      } else if (cs.severity === 'ok') {
-        explainer = 'Last advert ' + skewStr + ' vs wall clock — within OK tolerance (≤15s)';
-      } else if (cs.severity === 'degrading') {
-        explainer = 'Last advert ' + skewStr + ' vs wall clock — drift accumulating (≤60s)';
-      } else if (cs.severity === 'degraded') {
-        explainer = 'Last advert ' + skewStr + ' vs wall clock — significantly off (≤10m)';
-      } else if (cs.severity === 'wrong') {
-        explainer = 'Last advert ' + skewStr + ' vs wall clock — clock incorrect (operator-set or RTC failure)';
-      }
-      var explainerHtml = explainer ? '<div style="font-size:12px;color:var(--text-muted);margin-top:4px">' + explainer + '</div>' : '';
-
-      container.innerHTML =
-        '<h4 style="margin:0 0 6px">⏰ Clock Skew</h4>' +
-        '<div style="display:flex;align-items:center;gap:12px;flex-wrap:wrap">' +
-          skewDisplay +
-          renderSkewBadge(cs.severity, skewVal, cs) +
-          (cs.calibrated ? ' <span style="font-size:10px;color:var(--text-muted)" title="Observer-calibrated">✓ calibrated</span>' : '') +
-        '</div>' +
-        explainerHtml +
-        driftHtml +
-        (sparkHtml ? '<div class="skew-sparkline-wrap" style="margin-top:8px">' + sparkHtml + '<div style="font-size:10px;color:var(--text-muted)">Skew over time (' + (cs.samples || []).length + ' samples)</div></div>' : '');
-    } catch (e) {
-      // Non-fatal — section stays hidden
-    }
-  }
-
   /** Fetch fleet clock skew once, return map keyed by pubkey */
   async function getFleetSkew() {
     if (_fleetSkew) return _fleetSkew;
@@ -916,7 +872,8 @@
       let filtered = _allNodes;
       if (activeTab !== 'all') filtered = filtered.filter(n => (n.role || '').toLowerCase() === activeTab);
       if (search) {
-        filtered = filtered.filter(n => window._nodesMatchesSearch(n, search));
+        const q = search.toLowerCase();
+        filtered = filtered.filter(n => (n.name || '').toLowerCase().includes(q) || (n.public_key || '').toLowerCase().includes(q));
       }
       if (lastHeard) {
         const ms = { '1h': 3600000, '2h': 7200000, '6h': 21600000, '12h': 43200000, '24h': 86400000, '48h': 172800000, '3d': 259200000, '7d': 604800000, '14d': 1209600000, '30d': 2592000000 }[lastHeard];
@@ -1087,16 +1044,22 @@
 
     // #630: Close button for node detail panel (important for mobile full-screen overlay)
     document.getElementById('nodesRight').addEventListener('click', function(e) {
-      // #778/#856: Analytics link — force hashchange via replaceState + assign.
-      // (Details button is handled separately via .node-detail-btn click listener)
+      // #778: Details/Analytics links don't navigate because replaceState
+      // already set the hash to #/nodes/PUBKEY, so clicking <a href="#/nodes/PUBKEY">
+      // is a same-hash no-op. Force navigation by temporarily clearing the hash.
       var link = e.target.closest('a.btn-primary[href^="#/nodes/"]');
       if (link) {
         e.preventDefault();
         var href = link.getAttribute('href');
-        if (href.indexOf('/analytics') !== -1) {
-          // Analytics link — different page, force hashchange via replaceState + assign
+        var pubkey = decodeURIComponent(href.replace('#/nodes/', '').replace('/analytics', ''));
+        if (href.includes('/analytics')) {
+          // Navigate to analytics page
           history.replaceState(null, '', '#/');
-          location.hash = href.substring(1);
+          location.hash = '/nodes/' + encodeURIComponent(pubkey) + '/analytics';
+        } else {
+          // Show full-screen node detail view
+          showFullScreenNode(pubkey);
+          history.replaceState(null, '', '#/nodes/' + encodeURIComponent(pubkey));
         }
         return;
       }
@@ -1145,7 +1108,7 @@
       const status = getNodeStatus(n.role || 'companion', lastSeenTime ? new Date(lastSeenTime).getTime() : 0);
       const lastSeenClass = status === 'active' ? 'last-seen-active' : 'last-seen-stale';
       const cs = _fleetSkew && _fleetSkew[n.public_key];
-      const skewBadgeHtml = cs && cs.severity && cs.severity !== 'ok' ? renderSkewBadge(cs.severity, window.currentSkewValue(cs), cs) : '';
+      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>
@@ -1158,19 +1121,6 @@
     makeColumnsResizable('#nodesTable', 'meshcore-nodes-col-widths');
   }
 
-  /**
-   * Navigate to the full-screen node view for `pubkey` from anywhere within
-   * the nodes module. Single source of navigation truth — works regardless
-   * of current hash state (hash assignment alone is a no-op when the hash
-   * is already the target).
-   */
-  function navigateToNode(pubkey) {
-    destroy();
-    var appEl = document.getElementById('app');
-    history.replaceState(null, '', '#/nodes/' + encodeURIComponent(pubkey));
-    init(appEl, pubkey);
-  }
-
   async function selectNode(pubkey) {
     // On mobile, navigate to full-screen node view
     if (window.innerWidth <= 640) {
@@ -1217,7 +1167,7 @@
       <div class="node-detail">
         <div class="node-detail-name">${escapeHtml(n.name || '(unnamed)')}${dupBadge}</div>
         <div class="node-detail-role">${renderNodeBadges(n, roleColor)}
-          <button class="btn-primary node-detail-btn" data-pubkey="${encodeURIComponent(n.public_key)}" aria-label="View details for ${escapeHtml(n.name || n.public_key)}" style="font-size:11px;padding:2px 8px;margin-left:8px;cursor:pointer">🔍 Details</button>
+          <a href="#/nodes/${encodeURIComponent(n.public_key)}" class="btn-primary" style="display:inline-block;text-decoration:none;font-size:11px;padding:2px 8px;margin-left:8px">🔍 Details</a>
           <a href="#/nodes/${encodeURIComponent(n.public_key)}/analytics" class="btn-primary" style="display:inline-block;margin-left:4px;text-decoration:none;font-size:11px;padding:2px 8px">📊 Analytics</a>
         </div>
         ${renderStatusExplanation(n)}
@@ -1244,8 +1194,6 @@
           </dl>
         </div>
 
-        <div class="node-detail-section skew-detail-section" id="node-clock-skew" style="display:none"></div>
-
         ${observers.length ? `<div class="node-detail-section">
           ${(() => { const regions = [...new Set(observers.map(o => o.iata).filter(Boolean))]; return regions.length ? `<div style="margin-bottom:6px;font-size:12px"><strong>Regions:</strong> ${regions.join(', ')}</div>` : ''; })()}
           <h4>Heard By (${observers.length} observer${observers.length > 1 ? 's' : ''})</h4>
@@ -1268,10 +1216,9 @@
         </div>
 
         <div class="node-detail-section">
-          ${(() => { const validPackets = adverts.filter(a => a.hash && a.timestamp); return `
-          <h4>Recent Packets (${validPackets.length})</h4>
+          <h4>Recent Packets (${adverts.length})</h4>
           <div id="advertTimeline">
-            ${validPackets.length ? validPackets.map(a => {
+            ${adverts.length ? adverts.map(a => {
               let decoded;
               try { decoded = JSON.parse(a.decoded_json); } catch {}
               const pType = PAYLOAD_TYPES[a.payload_type] || 'Packet';
@@ -1290,7 +1237,6 @@
               </div>`;
             }).join('') : '<div class="text-muted" style="padding:8px">No recent packets</div>'}
           </div>
-          `; })()}
         </div>
       </div>`;
 
@@ -1334,14 +1280,6 @@
       } catch {}
     }
 
-    // Wire "Details" button via the unified navigateToNode helper
-    var detailBtn = panel.querySelector('.node-detail-btn');
-    if (detailBtn) {
-      detailBtn.addEventListener('click', function() {
-        navigateToNode(decodeURIComponent(detailBtn.getAttribute('data-pubkey')));
-      });
-    }
-
     // Fetch neighbors for this node (condensed panel — top 5)
     fetchAndRenderNeighbors(n.public_key, 'panelNeighborsContent', {
       limit: 5,
@@ -1349,10 +1287,6 @@
       viewAllPubkey: n.public_key
     });
 
-    // #813 — Clock Skew section in side panel (mirrors full-screen view)
-    loadClockSkewInto(document.getElementById('node-clock-skew'), n.public_key);
-
-
     // Fetch paths through this node
     api('/nodes/' + encodeURIComponent(n.public_key) + '/paths', { ttl: CLIENT_TTL.nodeDetail }).then(pathData => {
       const el = document.getElementById('pathsContent');
@@ -1451,14 +1385,4 @@
   window._nodesRenderNodeTimestampText = renderNodeTimestampText;
   window._nodesGetStatusInfo = getStatusInfo;
   window._nodesGetStatusTooltip = getStatusTooltip;
-
-  // #862: Expose search filter logic for testing
-  window._nodesMatchesSearch = function(node, query) {
-    if (!query) return true;
-    var q = query.toLowerCase();
-    var isHex = /^[0-9a-f]+$/i.test(q);
-    if ((node.name || '').toLowerCase().includes(q)) return true;
-    if (isHex && (node.public_key || '').toLowerCase().startsWith(q)) return true;
-    return false;
-  };
 })();

public/packets.js

@@ -48,7 +48,6 @@
     if (filters.hash) parts.push('hash=' + encodeURIComponent(filters.hash));
     if (filters.node) parts.push('node=' + encodeURIComponent(filters.node));
     if (filters.observer) parts.push('observer=' + encodeURIComponent(filters.observer));
-    if (filters.channel) parts.push('channel=' + encodeURIComponent(filters.channel));
     if (filters._filterExpr) parts.push('filter=' + encodeURIComponent(filters._filterExpr));
     return parts.length ? '?' + parts.join('&') : '';
   }
@@ -353,8 +352,6 @@
     if (_urlNode) { filters.node = _urlNode; filters.nodeName = _urlNode.slice(0, 8); }
     var _urlObserver = _initUrlParams.get('observer');
     if (_urlObserver) filters.observer = _urlObserver;
-    var _urlChannel = _initUrlParams.get('channel');
-    if (_urlChannel) filters.channel = _urlChannel;
     var _urlFilterExpr = _initUrlParams.get('filter');
     if (_urlFilterExpr) filters._filterExpr = _urlFilterExpr;
 
@@ -387,9 +384,9 @@
             const obs = data.observations.find(o => String(o.id) === String(obsTarget));
             if (obs) {
               expandedHashes.add(h);
-              const obsPacket = {...data.packet, observer_id: obs.observer_id, observer_name: obs.observer_name, snr: obs.snr, rssi: obs.rssi, path_json: obs.path_json, resolved_path: obs.resolved_path, direction: obs.direction, timestamp: obs.timestamp, first_seen: obs.timestamp};
+              const obsPacket = {...data.packet, observer_id: obs.observer_id, observer_name: obs.observer_name, snr: obs.snr, rssi: obs.rssi, path_json: obs.path_json, resolved_path: obs.resolved_path, timestamp: obs.timestamp, first_seen: obs.timestamp};
               clearParsedCache(obsPacket);
-              selectPacket(obs.id, h, {packet: obsPacket, observations: data.observations}, obs.id);
+              selectPacket(obs.id, h, {packet: obsPacket, breakdown: data.breakdown, observations: data.observations}, obs.id);
             } else {
               selectPacket(data.packet.id, h, data);
             }
@@ -468,9 +465,6 @@
 
       // Check if new packets pass current filters
       const filtered = newPkts.filter(p => {
-        // When user pinned a hash, accept ONLY that exact packet — bypass all
-        // other filters (window/region/type/observer/node).
-        if (filters.hash) return p.hash === filters.hash;
         // Respect time window filter — drop packets outside the selected window
         const windowMin = savedTimeWindowMin;
         if (windowMin > 0) {
@@ -480,6 +474,7 @@
         }
         if (filters.type) { const types = filters.type.split(',').map(Number); if (!types.includes(p.payload_type)) return false; }
         if (filters.observer) { const obsSet = new Set(filters.observer.split(',')); if (!obsSet.has(p.observer_id) && !(p._children && p._children.some(c => obsSet.has(String(c.observer_id))))) return false; }
+        if (filters.hash && p.hash !== filters.hash) return false;
         if (RegionFilter.getRegionParam()) {
           const selectedRegions = RegionFilter.getRegionParam().split(',');
           const obs = observerMap.get(p.observer_id);
@@ -521,7 +516,7 @@
               if (p.decoded_json) existing.decoded_json = p.decoded_json;
               // Update expanded children if this group is expanded
               if (expandedHashes.has(h) && existing._children) {
-                existing._children.unshift(clearParsedCache({...p, _isObservation: true}));
+                existing._children.unshift(p);
                 if (existing._children.length > 200) existing._children.length = 200;
                 sortGroupChildren(existing);
                 // Invalidate row counts — child count changed, so virtual scroll
@@ -612,52 +607,26 @@
     } catch {}
   }
 
-  // Build URLSearchParams for /api/packets given UI state. Pure function for
-  // testability — returns the params object the next call to /api/packets
-  // would use. The hash filter is an exact identifier: when present it
-  // suppresses ALL other filters (region, time window, observer, node,
-  // channel). The user is asking for THAT packet regardless of saved
-  // selections.
-  function buildPacketsParams({ filters, regionParam, windowMin, groupByHash, limit }) {
-    const params = new URLSearchParams();
-    if (filters.hash) {
-      params.set('hash', filters.hash);
-      params.set('limit', String(limit));
+  async function loadPackets() {
+    try {
+      const params = new URLSearchParams();
+      const selectedWindow = Number(document.getElementById('fTimeWindow')?.value);
+      const windowMin = Number.isFinite(selectedWindow) ? selectedWindow : savedTimeWindowMin;
+      if (windowMin > 0 && !filters.hash) {
+        const since = new Date(Date.now() - windowMin * 60000).toISOString();
+        params.set('since', since);
+      }
+      params.set('limit', String(PACKET_LIMIT));
+      const regionParam = RegionFilter.getRegionParam();
+      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);
       if (groupByHash) {
         params.set('groupByHash', 'true');
       } else {
         params.set('expand', 'observations');
       }
-      return params;
-    }
-    if (windowMin > 0) {
-      const since = new Date(Date.now() - windowMin * 60000).toISOString();
-      params.set('since', since);
-    }
-    params.set('limit', String(limit));
-    if (regionParam) params.set('region', regionParam);
-    if (filters.node) params.set('node', filters.node);
-    if (filters.observer) params.set('observer', filters.observer);
-    if (filters.channel) params.set('channel', filters.channel);
-    if (groupByHash) {
-      params.set('groupByHash', 'true');
-    } else {
-      params.set('expand', 'observations');
-    }
-    return params;
-  }
-
-  async function loadPackets() {
-    try {
-      const selectedWindow = Number(document.getElementById('fTimeWindow')?.value);
-      const windowMin = Number.isFinite(selectedWindow) ? selectedWindow : savedTimeWindowMin;
-      const params = buildPacketsParams({
-        filters,
-        regionParam: RegionFilter.getRegionParam(),
-        windowMin,
-        groupByHash,
-        limit: PACKET_LIMIT,
-      });
 
       const data = await api('/packets?' + params.toString());
       packets = data.packets || [];
@@ -710,14 +679,10 @@
       // Restore expanded group children (parallel fetch, Map lookup)
       if (groupByHash && expandedHashes.size > 0) {
         const expandedArr = [...expandedHashes];
-        // Fetch the full packet detail (which includes per-observation rows) for each expanded hash.
-        // Previously this used `/packets?hash=X&limit=20` which returned ONE aggregate row, causing
-        // every "child" row in the table to carry the parent packet.id instead of unique observation
-        // ids — so clicking any child pointed the side pane at the same aggregate. See #866.
         const results = await Promise.all(expandedArr.map(hash => {
           const group = hashIndex.get(hash);
           if (!group) return { hash, group: null, data: null };
-          return api(`/packets/${hash}`)
+          return api(`/packets?hash=${hash}&limit=20`)
             .then(data => ({ hash, group, data }))
             .catch(() => ({ hash, group, data: null }));
         }));
@@ -725,15 +690,7 @@
           if (!group) {
             expandedHashes.delete(hash);
           } else if (data) {
-            const pkt = data.packet || group;
-            // Build per-observation children. Spread (pkt, obs) so obs-level fields
-            // (id, observer_id/name, path_json, snr/rssi, timestamp, raw_hex) override
-            // the aggregate. Each child's `id` is the observation id (unique per observer).
-            const obs = data.observations || [];
-            group._children = obs.length
-              ? obs.map(o => clearParsedCache({...pkt, ...o, _isObservation: true}))
-              : [pkt];
-            group._fetchedData = { packet: pkt, observations: obs };
+            group._children = data.packets || [];
             sortGroupChildren(group);
           }
         }
@@ -793,11 +750,6 @@
             <button class="multi-select-trigger" id="typeTrigger" title="Filter by packet type">All Types ▾</button>
             <div class="multi-select-menu" id="typeMenu"></div>
           </div>
-          <div class="filter-group" style="display:inline-flex;align-items:center;gap:4px">
-            <select id="fChannel" class="filter-select" aria-label="Filter by channel" title="Filter Channel Messages (GRP_TXT) by channel">
-              <option value="">All Channels</option>
-            </select>
-          </div>
         </div>
         <div class="filter-group">
           <button class="btn ${groupByHash ? 'active' : ''}" id="fGroup" title="Collapse duplicate observations of the same packet into expandable groups">Group by Hash</button>
@@ -986,63 +938,6 @@
       renderTableRows();
     });
 
-    // --- Channel filter (#812) ---
-    // Server-side filter: /api/packets?channel=<hash>. Triggers loadPackets()
-    // (not just renderTableRows) so the filter applies before pagination.
-    const channelSel = document.getElementById('fChannel');
-    if (channelSel) {
-      if (filters.channel) {
-        // Pre-seed an option so the current filter shows as selected even
-        // before the channels list arrives. Replaced when populateChannels resolves.
-        const opt = document.createElement('option');
-        opt.value = filters.channel;
-        opt.textContent = filters.channel;
-        opt.selected = true;
-        channelSel.appendChild(opt);
-      }
-      api('/channels').then(data => {
-        const channels = (data && data.channels) || [];
-        // Build options via DOM API: channel names are network-supplied
-        // and must NOT be interpolated into innerHTML (XSS, #812).
-        // Sort alphabetically (case-insensitive) for predictable picker order;
-        // the API returns last-activity order which is unstable for a dropdown.
-        const sorted = channels.slice().sort((a, b) => {
-          const an = (a.name || a.hash || '').toLowerCase();
-          const bn = (b.name || b.hash || '').toLowerCase();
-          return an < bn ? -1 : an > bn ? 1 : 0;
-        });
-        channelSel.textContent = '';
-        const allOpt = document.createElement('option');
-        allOpt.value = '';
-        allOpt.textContent = 'All Channels';
-        channelSel.appendChild(allOpt);
-        let matched = false;
-        for (const ch of sorted) {
-          const v = ch.hash || ch.name || '';
-          if (!v) continue;
-          const opt = document.createElement('option');
-          opt.value = v;
-          opt.textContent = ch.name || v;
-          if (v === filters.channel) { opt.selected = true; matched = true; }
-          channelSel.appendChild(opt);
-        }
-        // If current filter isn't in the list (encrypted hash, stale, or
-        // race with cache), keep it as a selected option so the UI reflects state.
-        if (filters.channel && !matched) {
-          const opt = document.createElement('option');
-          opt.value = filters.channel;
-          opt.textContent = filters.channel;
-          opt.selected = true;
-          channelSel.appendChild(opt);
-        }
-      }).catch(() => {});
-      channelSel.addEventListener('change', (e) => {
-        filters.channel = e.target.value || undefined;
-        updatePacketsUrl();
-        loadPackets();
-      });
-    }
-
     // Close multi-select menus on outside click
     bindDocumentHandler('menu', 'click', (e) => {
       const obsWrap = document.getElementById('observerFilterWrap');
@@ -1204,7 +1099,7 @@
         const nodes = data.nodes || [];
         if (nodes.length === 0) { fNodeDrop.classList.add('hidden'); fNode.setAttribute('aria-expanded', 'false'); return; }
         fNodeDrop.innerHTML = nodes.map((n, i) =>
-          `<div class="node-filter-option" id="fNodeOpt-${i}" role="option" data-key="${n.public_key}" data-name="${escapeHtml(n.name || n.public_key.slice(0,8))}">${escapeHtml(n.name || n.public_key.slice(0,8))} <span style="color:var(--text-muted);font-size:0.8em">${n.public_key.slice(0,8)}</span></div>`
+          `<div class="node-filter-option" id="fNodeOpt-${i}" role="option" data-key="${n.public_key}" data-name="${escapeHtml(n.name || n.public_key.slice(0,8))}">${escapeHtml(n.name || n.public_key.slice(0,8))} <span style="color:var(--muted);font-size:0.8em">${n.public_key.slice(0,8)}</span></div>`
         ).join('');
         fNodeDrop.classList.remove('hidden');
         fNode.setAttribute('aria-expanded', 'true');
@@ -1285,9 +1180,9 @@
           const child = group?._children?.find(c => String(c.id) === String(value));
           if (child) {
             const parentData = group._fetchedData;
-            const obsPacket = parentData ? {...parentData.packet, observer_id: child.observer_id, observer_name: child.observer_name, snr: child.snr, rssi: child.rssi, path_json: child.path_json, resolved_path: child.resolved_path, direction: child.direction, timestamp: child.timestamp, first_seen: child.timestamp} : child;
+            const obsPacket = parentData ? {...parentData.packet, observer_id: child.observer_id, observer_name: child.observer_name, snr: child.snr, rssi: child.rssi, path_json: child.path_json, resolved_path: child.resolved_path, timestamp: child.timestamp, first_seen: child.timestamp} : child;
             if (parentData) { clearParsedCache(obsPacket); }
-            selectPacket(child.id, parentHash, {packet: obsPacket, observations: parentData?.observations}, child.id);
+            selectPacket(child.id, parentHash, {packet: obsPacket, breakdown: parentData?.breakdown, observations: parentData?.observations}, child.id);
           }
         }
         else if (action === 'select-hash') pktSelectHash(value);
@@ -1674,14 +1569,7 @@
 
     // Filter to claimed/favorited nodes — pure client-side filter (no server round-trip)
     let displayPackets = packets;
-
-    // When loading a specific packet by hash, bypass ALL client-side filters
-    // (myNodes, type, observer, packet-filter-expression). The user is asking
-    // for THAT exact packet — saved type/observer/expression filters must not
-    // hide it. Hash filter is the exact identifier; nothing else applies.
-    const hashOnly = !!filters.hash;
-
-    if (!hashOnly && filters.myNodes) {
+    if (filters.myNodes) {
       const myNodes = JSON.parse(localStorage.getItem('meshcore-my-nodes') || '[]');
       const myKeys = myNodes.map(n => n.pubkey).filter(Boolean);
       const favs = getFavorites();
@@ -1697,11 +1585,11 @@
     }
 
     // Client-side type/observer filtering
-    if (!hashOnly && filters.type) {
+    if (filters.type) {
       const types = filters.type.split(',').map(Number);
       displayPackets = displayPackets.filter(p => types.includes(p.payload_type));
     }
-    if (!hashOnly && filters.observer) {
+    if (filters.observer) {
       const obsIds = new Set(filters.observer.split(','));
       displayPackets = displayPackets.filter(p => {
         if (obsIds.has(p.observer_id)) return true;
@@ -1712,7 +1600,7 @@
 
     // Packet Filter Language
     const pfCount = document.getElementById('packetFilterCount');
-    if (!hashOnly && filters._packetFilter) {
+    if (filters._packetFilter) {
       const beforeCount = displayPackets.length;
       displayPackets = displayPackets.filter(filters._packetFilter);
       if (pfCount) {
@@ -1843,56 +1731,19 @@
       panel.innerHTML = isMobileNow ? '' : '<div class="panel-resize-handle" id="pktResizeHandle"></div>' + PANEL_CLOSE_HTML;
       const content = document.createElement('div');
       panel.appendChild(content);
-      await renderDetail(content, data, selectedObservationId);
+      await renderDetail(content, data);
       if (!isMobileNow) initPanelResize();
     } catch (e) {
       panel.innerHTML = `<div class="text-muted">Error: ${e.message}</div>`;
     }
   }
 
-  async function renderDetail(panel, data, chosenObsId) {
+  async function renderDetail(panel, data) {
     const pkt = data.packet;
-    const observations = data.observations || [];
-
-    // Per-observation rendering (issue #849):
-    // When opened from a packet row (no specific observer), default to first observation.
-    // When opened from an observation child row, use that observation.
-    // Clicking a different observation row in the detail re-renders with that observation.
-    let currentObs = null;
-    const targetObsId = chosenObsId || selectedObservationId;
-    if (targetObsId && observations.length) {
-      currentObs = observations.find(o => String(o.id) === String(targetObsId));
-    }
-    if (!currentObs && observations.length) {
-      currentObs = observations[0]; // fall back to first observation
-    }
-
-    // If we have a current observation, build pkt fields from it so summary is per-observation
-    const effectivePkt = currentObs ? clearParsedCache({...pkt, ...currentObs, _isObservation: true}) : pkt;
-    const decoded = getParsedDecoded(effectivePkt) || {};
-    const pathHops = getParsedPath(effectivePkt) || [];
-
-    // Compute breakdown ranges from the actually-rendered raw_hex (per-observation).
-    // Single source of truth — derived from the same bytes we display, so a
-    // post-#882 per-obs raw_hex with a different path length than the top-level
-    // packet's raw_hex still gets accurate byte highlights.
-    const obsRawHexForRanges = effectivePkt.raw_hex || pkt.raw_hex || '';
-    const ranges = obsRawHexForRanges
-      ? computeBreakdownRanges(obsRawHexForRanges, pkt.route_type, pkt.payload_type)
-      : [];
-
-    // Cross-check: hop count from raw_hex path_len byte vs path_json length
-    const obsRawHex = effectivePkt.raw_hex || pkt.raw_hex || '';
-    let rawHopCount = null;
-    if (obsRawHex.length >= 4) {
-      // path_len byte position depends on route type
-      const plOff = getPathLenOffset(pkt.route_type);
-      const plByte = parseInt(obsRawHex.slice(plOff * 2, plOff * 2 + 2), 16);
-      if (!isNaN(plByte)) rawHopCount = plByte & 0x3F;
-    }
-    if (rawHopCount != null && pathHops.length !== rawHopCount) {
-      console.warn(`[CoreScope] Hop count inconsistency for packet ${pkt.hash}: path_json has ${pathHops.length} hops but raw_hex path_len has ${rawHopCount}. UI shows path_json.`);
-    }
+    const breakdown = data.breakdown || {};
+    const ranges = breakdown.ranges || [];
+    const decoded = getParsedDecoded(pkt) || {};
+    const pathHops = getParsedPath(pkt) || [];
 
     // Resolve sender GPS — from packet directly, or from known node in DB
     let senderLat = decoded.lat != null ? decoded.lat : (decoded.latitude || null);
@@ -1936,16 +1787,15 @@
     }
 
     // Parse hash size from path byte
-    const plOff = getPathLenOffset(pkt.route_type);
-    const rawPathByte = pkt.raw_hex ? parseInt(pkt.raw_hex.slice(plOff * 2, plOff * 2 + 2), 16) : NaN;
+    const rawPathByte = pkt.raw_hex ? parseInt(pkt.raw_hex.slice(2, 4), 16) : NaN;
     const hashSize = (isNaN(rawPathByte) || (rawPathByte & 0x3F) === 0) ? null : ((rawPathByte >> 6) + 1);
 
-    const size = effectivePkt.raw_hex ? Math.floor(effectivePkt.raw_hex.length / 2) : (pkt.raw_hex ? Math.floor(pkt.raw_hex.length / 2) : 0);
+    const size = pkt.raw_hex ? Math.floor(pkt.raw_hex.length / 2) : 0;
     const typeName = payloadTypeName(pkt.payload_type);
 
-    const snr = effectivePkt.snr ?? decoded.SNR ?? decoded.snr ?? null;
-    const rssi = effectivePkt.rssi ?? decoded.RSSI ?? decoded.rssi ?? null;
-    const hasRawHex = !!(effectivePkt.raw_hex || pkt.raw_hex);
+    const snr = pkt.snr ?? decoded.SNR ?? decoded.snr ?? null;
+    const rssi = pkt.rssi ?? decoded.RSSI ?? decoded.rssi ?? null;
+    const hasRawHex = !!pkt.raw_hex;
 
     // Build message preview
     let messageHtml = '';
@@ -1956,16 +1806,17 @@
       const meta = [chLabel, hopLabel, snrLabel].filter(Boolean).join(' · ');
       messageHtml = `<div class="detail-message" style="padding:12px;margin:8px 0;background:var(--card-bg);border-radius:8px;border-left:3px solid var(--accent)">
         <div style="font-size:1.1em">${escapeHtml(decoded.text)}</div>
-        ${meta ? `<div style="font-size:0.85em;color:var(--text-muted);margin-top:4px">${meta}</div>` : ''}
+        ${meta ? `<div style="font-size:0.85em;color:var(--muted);margin-top:4px">${meta}</div>` : ''}
       </div>`;
     } else if (decoded.type === 'GRP_TXT' && decoded.channelHash != null) {
       const hashHex = decoded.channelHashHex || decoded.channelHash.toString(16).padStart(2, '0').toUpperCase();
       const statusLabel = decoded.decryptionStatus === 'no_key' ? 'no key' : 'decryption failed';
       messageHtml = `<div class="detail-message" style="padding:12px;margin:8px 0;background:var(--card-bg);border-radius:8px;border-left:3px solid var(--warning, #f0ad4e)">
-        <div style="font-size:1.1em">🔒 Channel Hash: 0x${hashHex} <span style="color:var(--text-muted)">(${statusLabel})</span></div>
+        <div style="font-size:1.1em">🔒 Channel Hash: 0x${hashHex} <span style="color:var(--muted)">(${statusLabel})</span></div>
       </div>`;
     }
 
+    const observations = data.observations || [];
     const obsCount = data.observation_count || observations.length || 1;
     const uniqueObservers = new Set(observations.map(o => o.observer_id)).size;
 
@@ -2028,30 +1879,21 @@
       ? `<div class="anomaly-banner" style="background:var(--warning, #f0ad4e); color:#000; padding:8px 12px; border-radius:4px; margin-bottom:8px; font-weight:600;">⚠️ Anomaly: ${escapeHtml(decoded.anomaly)}</div>`
       : '';
 
-    // Hop count display: use pathHops length (= effective observation's path_json).
-    // The raw_hex/path_json mismatch warning is logged above for diagnostics; the UI
-    // must stay self-consistent — top pill names and byte breakdown rows must agree.
-    const displayHopCount = pathHops.length;
-    const obsIndicator = currentObs && observations.length > 1
-      ? `<span style="font-size:0.8em;color:var(--text-muted);margin-left:6px">(observation ${observations.indexOf(currentObs) + 1} of ${observations.length})</span>`
-      : '';
-
     panel.innerHTML = `
       ${anomalyBanner}
       <div class="detail-title">${hasRawHex ? `Packet Byte Breakdown (${size} bytes)` : typeName + ' Packet'}</div>
-      <div class="detail-hash">${pkt.hash || 'Packet #' + pkt.id}${obsIndicator}</div>
+      <div class="detail-hash">${pkt.hash || 'Packet #' + pkt.id}</div>
       ${messageHtml}
       <dl class="detail-meta">
-        <dt>Observer</dt><dd>${obsName(effectivePkt.observer_id)}</dd>
+        <dt>Observer</dt><dd>${obsName(pkt.observer_id)}</dd>
         <dt>Location</dt><dd>${locationHtml}</dd>
         <dt>SNR / RSSI</dt><dd>${snr != null ? snr + ' dB' : '—'} / ${rssi != null ? rssi + ' dBm' : '—'}</dd>
         <dt>Route Type</dt><dd>${routeTypeName(pkt.route_type)}</dd>
         <dt>Payload Type</dt><dd><span class="badge badge-${payloadTypeColor(pkt.payload_type)}">${typeName}</span></dd>
         ${hashSize ? `<dt>Hash Size</dt><dd>${hashSize} byte${hashSize !== 1 ? 's' : ''}</dd>` : ''}
-        <dt>Timestamp</dt><dd>${renderTimestampCell(effectivePkt.timestamp)}</dd>
+        <dt>Timestamp</dt><dd>${renderTimestampCell(pkt.timestamp)}</dd>
         <dt>Propagation</dt><dd>${propagationHtml}</dd>
-        <dt>Path</dt><dd>${displayHopCount > 0 ? `<span class="badge badge-info">${displayHopCount} hop${displayHopCount !== 1 ? 's' : ''}</span> ` + renderPath(pathHops, effectivePkt.observer_id) : '— (direct)'}</dd>
-        ${effectivePkt.direction ? `<dt>Direction</dt><dd>${escapeHtml(effectivePkt.direction)}</dd>` : ''}
+        <dt>Path</dt><dd>${pathHops.length ? renderPath(pathHops, pkt.observer_id) : '—'}</dd>
       </dl>
       <div class="detail-actions">
         <button class="copy-link-btn" data-packet-hash="${pkt.hash || ''}" data-packet-id="${pkt.id}" title="Copy link to this packet">🔗 Copy Link</button>
@@ -2061,59 +1903,11 @@
       </div>
 
       ${hasRawHex ? `<div class="hex-legend">${buildHexLegend(ranges)}</div>
-      <div class="hex-dump">${createColoredHexDump(effectivePkt.raw_hex || pkt.raw_hex, ranges)}</div>` : ''}
+      <div class="hex-dump">${createColoredHexDump(pkt.raw_hex, ranges)}</div>` : ''}
 
-      ${hasRawHex ? buildFieldTable(effectivePkt.raw_hex ? effectivePkt : pkt, decoded, pathHops, ranges) : buildDecodedTable(decoded)}
-
-      ${observations.length > 1 ? `
-      <div class="detail-observations" style="margin-top:16px">
-        <div style="font-weight:600;margin-bottom:6px">Observations (${observations.length})</div>
-        <table class="detail-obs-table" style="width:100%;border-collapse:collapse;font-size:0.9em">
-          <thead><tr style="border-bottom:1px solid var(--border)">
-            <th style="padding:4px 6px;text-align:left">Observer</th>
-            <th style="padding:4px 6px;text-align:left">Hops</th>
-            <th style="padding:4px 6px;text-align:left">SNR</th>
-            <th style="padding:4px 6px;text-align:left">RSSI</th>
-            <th style="padding:4px 6px;text-align:left">Time</th>
-          </tr></thead>
-          <tbody>${observations.map(o => {
-            const oPath = getParsedPath(o);
-            const isCurrent = currentObs && String(o.id) === String(currentObs.id);
-            return `<tr class="detail-obs-row${isCurrent ? ' observation-current' : ''}" data-obs-id="${o.id}" style="cursor:pointer;${isCurrent ? 'background:var(--accent-bg, rgba(0,122,255,0.1))' : ''}" title="Click to view this observation">
-              <td style="padding:4px 6px">${obsName(o.observer_id)}</td>
-              <td style="padding:4px 6px">${oPath.length}</td>
-              <td style="padding:4px 6px">${o.snr != null ? o.snr + ' dB' : '—'}</td>
-              <td style="padding:4px 6px">${o.rssi != null ? o.rssi + ' dBm' : '—'}</td>
-              <td style="padding:4px 6px">${renderTimestampCell(o.timestamp)}</td>
-            </tr>`;
-          }).join('')}</tbody>
-        </table>
-      </div>` : ''}
-
-      ${observations.length > 1 ? (() => {
-        // Cross-observer aggregate (Option B): show longest observed path across all observers
-        const aggregatePath = getParsedPath(pkt) || [];
-        return `<div class="detail-aggregate" style="margin-top:12px;padding:10px;background:var(--card-bg);border-radius:6px;border:1px solid var(--border);font-size:0.9em">
-          <div style="font-weight:600;margin-bottom:4px;color:var(--text-muted)">Cross-observer aggregate</div>
-          <div>Longest observed path: ${aggregatePath.length ? `${aggregatePath.length} hops — ${renderPath(aggregatePath, pkt.observer_id)}` : '— (direct)'}</div>
-          <div style="font-size:0.8em;color:var(--text-muted);margin-top:2px">Longest path seen across all ${uniqueObservers} observer${uniqueObservers !== 1 ? 's' : ''}</div>
-        </div>`;
-      })() : ''}
+      ${hasRawHex ? buildFieldTable(pkt, decoded, pathHops, ranges) : buildDecodedTable(decoded)}
     `;
 
-    // Wire up observation row click handlers — re-render detail with clicked observation
-    panel.querySelectorAll('.detail-obs-row').forEach(row => {
-      row.addEventListener('click', () => {
-        const obsId = row.dataset.obsId;
-        selectedObservationId = obsId;
-        // Update URL hash to reflect selected observation (deep linking)
-        const pktHash = pkt.hash || pkt.id;
-        const obsParam = obsId ? `?obs=${obsId}` : '';
-        history.replaceState(null, '', `#/packets/${pktHash}${obsParam}`);
-        renderDetail(panel, data, obsId);
-      });
-    });
-
     // Wire up copy link button
     const copyLinkBtn = panel.querySelector('.copy-link-btn');
     if (copyLinkBtn) {
@@ -2221,7 +2015,7 @@
 
     // Transport codes come BEFORE path length for transport routes (bytes 1-4)
     let off = 1;
-    if (isTransportRoute(pkt.route_type)) {
+    if (pkt.route_type === 0 || pkt.route_type === 3) {
       rows += sectionRow('Transport Codes', 'section-transport');
       rows += fieldRow(off, 'Next Hop', buf.slice(off * 2, (off + 2) * 2), '');
       rows += fieldRow(off + 2, 'Last Hop', buf.slice((off + 2) * 2, (off + 4) * 2), '');
@@ -2236,17 +2030,14 @@
     rows += fieldRow(off, 'Path Length', '0x' + (buf.slice(off * 2, off * 2 + 2) || '??'), hashCountVal === 0 ? `hash_count=0 (direct advert)` : `hash_size=${hashSizeVal} byte${hashSizeVal !== 1 ? 's' : ''}, hash_count=${hashCountVal}`);
     off += 1;
 
-    // Path — render hops from path_json (what this observation reported).
-    // Byte offsets advance by hashSize * pathHops.length to match.
-    const hashSize = isNaN(pathByte0) ? 1 : ((pathByte0 >> 6) + 1);
+    // Path
     if (pathHops.length > 0) {
       rows += sectionRow('Path (' + pathHops.length + ' hops)', 'section-path');
+      const hashSize = isNaN(pathByte0) ? 1 : ((pathByte0 >> 6) + 1);
       for (let i = 0; i < pathHops.length; i++) {
-        const hopOff = off + i * hashSize;
-        const hex = String(pathHops[i] || '').toUpperCase();
-        const hopHtml = HopDisplay.renderHop(hex, hopNameCache[hex]);
+        const hopHtml = HopDisplay.renderHop(pathHops[i], hopNameCache[pathHops[i]]);
         const label = `Hop ${i} — ${hopHtml}`;
-        rows += fieldRow(hopOff, label, hex, '');
+        rows += fieldRow(off + i * hashSize, label, pathHops[i], '');
       }
       off += hashSize * pathHops.length;
     }
@@ -2522,7 +2313,7 @@
       renderTableRows();
       return;
     }
-    // Single fetch — gets packet + observations + path
+    // Single fetch — gets packet + observations + path + breakdown
     try {
       const data = await api(`/packets/${hash}`);
       const pkt = data.packet;
@@ -2597,7 +2388,6 @@
       buildGroupRowHtml,
       buildFlatRowHtml,
       _calcVisibleRange,
-      buildPacketsParams,
     };
   }
 

public/path-inspector.js

@@ -1,202 +0,0 @@
-// Path Inspector — prefix candidate scoring with map overlay (issue #944).
-// IIFE; exports window.PathInspector for testability.
-(function () {
-  'use strict';
-
-  var container = null;
-  var currentResults = null;
-
-  function init(app) {
-    container = app;
-    var params = new URLSearchParams(location.hash.split('?')[1] || '');
-    var prefixParam = params.get('prefixes') || '';
-
-    container.innerHTML =
-      '<div class="path-inspector-page">' +
-        '<h2>Path Inspector</h2>' +
-        '<p class="help-text">Enter comma or space-separated hex prefixes (1-3 bytes each, e.g. <code>2C,A1,F4</code> or <code>2C A1 F4</code>).</p>' +
-        '<div class="path-inspector-input-row">' +
-          '<input type="text" id="path-inspector-input" class="input" placeholder="2C,A1,F4 or 2C A1 F4" value="' + escapeAttr(prefixParam) + '">' +
-          '<button id="path-inspector-submit" class="btn btn-primary">Inspect</button>' +
-        '</div>' +
-        '<div id="path-inspector-error" class="path-inspector-error"></div>' +
-        '<div id="path-inspector-results"></div>' +
-      '</div>';
-
-    var input = document.getElementById('path-inspector-input');
-    var btn = document.getElementById('path-inspector-submit');
-    btn.addEventListener('click', function () { submit(input.value); });
-    input.addEventListener('keydown', function (e) {
-      if (e.key === 'Enter') submit(input.value);
-    });
-
-    // Auto-run if prefixes in URL.
-    if (prefixParam) submit(prefixParam);
-  }
-
-  function destroy() {
-    container = null;
-    currentResults = null;
-  }
-
-  function parsePrefixes(raw) {
-    // Accept comma or space separated.
-    var parts = raw.trim().split(/[\s,]+/).filter(function (s) { return s.length > 0; });
-    return parts.map(function (p) { return p.toLowerCase(); });
-  }
-
-  function validatePrefixes(prefixes) {
-    if (prefixes.length === 0) return 'Enter at least one prefix.';
-    if (prefixes.length > 64) return 'Too many prefixes (max 64).';
-    var hexRe = /^[0-9a-f]+$/;
-    var byteLen = -1;
-    for (var i = 0; i < prefixes.length; i++) {
-      var p = prefixes[i];
-      if (!hexRe.test(p)) return 'Invalid hex: ' + p;
-      if (p.length % 2 !== 0) return 'Odd-length prefix: ' + p;
-      var bl = p.length / 2;
-      if (bl > 3) return 'Prefix too long (max 3 bytes): ' + p;
-      if (byteLen === -1) byteLen = bl;
-      else if (bl !== byteLen) return 'Mixed prefix lengths not allowed.';
-    }
-    return null;
-  }
-
-  function submit(raw) {
-    var errDiv = document.getElementById('path-inspector-error');
-    var resultsDiv = document.getElementById('path-inspector-results');
-    errDiv.textContent = '';
-    resultsDiv.innerHTML = '';
-
-    var prefixes = parsePrefixes(raw);
-    var err = validatePrefixes(prefixes);
-    if (err) {
-      errDiv.textContent = err;
-      return;
-    }
-
-    // Update URL.
-    var base = '#/tools/path-inspector';
-    if (location.hash.indexOf(base) === 0) {
-      history.replaceState(null, '', base + '?prefixes=' + prefixes.join(','));
-    }
-
-    resultsDiv.innerHTML = '<p>Loading...</p>';
-    fetch('/api/paths/inspect', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ prefixes: prefixes })
-    })
-      .then(function (r) {
-        if (r.status === 503) return r.json().then(function (d) { throw new Error('Service warming up, retry in a few seconds.'); });
-        if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || 'Request failed'); });
-        return r.json();
-      })
-      .then(function (data) {
-        currentResults = data;
-        renderResults(data, resultsDiv);
-      })
-      .catch(function (e) {
-        resultsDiv.innerHTML = '';
-        errDiv.textContent = e.message;
-      });
-  }
-
-  function renderResults(data, div) {
-    if (!data.candidates || data.candidates.length === 0) {
-      div.innerHTML = '<p class="no-results">No candidates found. The prefixes may not match any known path-eligible nodes.</p>';
-      return;
-    }
-
-    var html = '<table class="path-inspector-table"><thead><tr>' +
-      '<th>#</th><th>Score</th><th>Path</th><th>Action</th>' +
-      '</tr></thead><tbody>';
-
-    for (var i = 0; i < data.candidates.length; i++) {
-      var c = data.candidates[i];
-      var rowClass = c.speculative ? 'speculative-row' : '';
-      html += '<tr class="' + rowClass + '">';
-      html += '<td>' + (i + 1) + '</td>';
-      html += '<td class="' + (c.speculative ? 'speculative-warning' : '') + '">' +
-        c.score.toFixed(3) +
-        (c.speculative ? ' <span class="speculative-badge" title="Low evidence; may be wrong">⚠</span>' : '') +
-        '</td>';
-      html += '<td>' + escapeHtml(c.names.join(' → ')) + '</td>';
-      html += '<td><button class="btn btn-sm" data-idx="' + i + '">Show on Map</button></td>';
-      html += '</tr>';
-
-      // Per-hop evidence (collapsed).
-      html += '<tr class="evidence-row collapsed" data-evidence="' + i + '"><td colspan="4"><div class="evidence-detail">';
-      for (var j = 0; j < c.evidence.perHop.length; j++) {
-        var h = c.evidence.perHop[j];
-        html += '<div class="hop-evidence">Hop ' + (j + 1) + ': prefix=' + h.prefix +
-          ', candidates=' + h.candidatesConsidered +
-          ', edge=' + h.edgeWeight.toFixed(3);
-        if (h.alternatives && h.alternatives.length > 0) {
-          html += '<div class="hop-alternatives" style="margin-left:12px;font-size:12px;color:var(--text-muted);">';
-          for (var k = 0; k < h.alternatives.length; k++) {
-            var alt = h.alternatives[k];
-            html += '<div>↳ ' + escapeHtml(alt.name || alt.publicKey.substring(0, 8)) + ' (score=' + alt.score.toFixed(3) + ')</div>';
-          }
-          html += '</div>';
-        }
-        html += '</div>';
-      }
-      html += '</div></td></tr>';
-    }
-
-    html += '</tbody></table>';
-    html += '<div class="path-inspector-stats">Beam width: ' + data.stats.beamWidth +
-      ' | Expansions: ' + data.stats.expansionsRun +
-      ' | Elapsed: ' + data.stats.elapsedMs + 'ms</div>';
-
-    div.innerHTML = html;
-
-    // Wire up Show on Map buttons.
-    div.querySelectorAll('button[data-idx]').forEach(function (btn) {
-      btn.addEventListener('click', function () {
-        var idx = parseInt(btn.dataset.idx);
-        showOnMap(data.candidates[idx]);
-      });
-    });
-
-    // Wire up row expand for evidence.
-    div.querySelectorAll('.path-inspector-table tbody tr:not(.evidence-row)').forEach(function (row) {
-      row.style.cursor = 'pointer';
-      row.addEventListener('click', function (e) {
-        if (e.target.tagName === 'BUTTON') return;
-        var idx = row.querySelector('button[data-idx]');
-        if (!idx) return;
-        var evidenceRow = div.querySelector('tr[data-evidence="' + idx.dataset.idx + '"]');
-        if (evidenceRow) evidenceRow.classList.toggle('collapsed');
-      });
-    });
-  }
-
-  function showOnMap(candidate) {
-    // Store pending route for map init to pick up.
-    window._pendingPathInspectorRoute = candidate;
-    // Switch to map page if not there; map init will draw the route.
-    if (location.hash.indexOf('#/map') !== 0) {
-      location.hash = '#/map';
-    } else {
-      // Already on map — draw directly.
-      delete window._pendingPathInspectorRoute;
-      if (window.routeLayer) window.routeLayer.clearLayers();
-      var hops = candidate.path.slice(1);
-      var origin = candidate.path[0] || null;
-      if (window.drawPacketRoute) window.drawPacketRoute(hops, origin);
-    }
-  }
-
-  function escapeAttr(s) {
-    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
-  }
-
-  function escapeHtml(s) {
-    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-  }
-
-  window.PathInspector = { init: init, destroy: destroy, parsePrefixes: parsePrefixes, validatePrefixes: validatePrefixes };
-  if (typeof registerPage === 'function') registerPage('path-inspector', { init: init, destroy: destroy });
-})();

public/roles.js

@@ -397,16 +397,16 @@
 
   // #690 — Clock Skew shared helpers
   var SKEW_SEVERITY_COLORS = {
-    default: 'var(--text-muted)',
     ok: 'var(--status-green)',
-    degrading: 'var(--status-yellow)',
-    degraded: 'var(--status-orange)',
-    wrong: 'var(--status-red)'
+    warning: 'var(--status-yellow)',
+    critical: 'var(--status-orange)',
+    absurd: 'var(--status-purple)',
+    no_clock: 'var(--text-muted)'
   };
   var SKEW_SEVERITY_LABELS = {
-    default: 'Default', ok: 'OK', degrading: 'Degrading', degraded: 'Degraded', wrong: 'Wrong'
+    ok: 'OK', warning: 'Warning', critical: 'Critical', absurd: 'Absurd', no_clock: 'No Clock'
   };
-  var SKEW_SEVERITY_ORDER = { default: 0, wrong: 1, degraded: 2, degrading: 3, ok: 4 };
+  var SKEW_SEVERITY_ORDER = { no_clock: 0, absurd: 1, critical: 2, warning: 3, ok: 4 };
 
   window.SKEW_SEVERITY_COLORS = SKEW_SEVERITY_COLORS;
   window.SKEW_SEVERITY_LABELS = SKEW_SEVERITY_LABELS;
@@ -429,19 +429,12 @@
     return (secPerDay >= 0 ? '+' : '') + secPerDay.toFixed(1) + ' s/day';
   };
 
-  /** Pick the skew value that drives current-health UI. Uses lastSkewSec
-   *  (most recent corrected skew) when available, falls back to medianSkewSec. */
-  window.currentSkewValue = function(cs) {
-    if (!cs) return null;
-    return cs.lastSkewSec != null ? cs.lastSkewSec : cs.medianSkewSec;
-  };
-
   /** Render a clock skew badge HTML */
-  window.renderSkewBadge = function(severity, skewSec, cs) {
+  window.renderSkewBadge = function(severity, skewSec) {
     if (!severity) return '';
     var cls = 'skew-badge skew-badge--' + severity;
-    if (severity === 'default') {
-      return '<span class="' + cls + '" title="Firmware default clock — volatile RTC not yet user-set since boot">⏰ Default</span>';
+    if (severity === 'no_clock') {
+      return '<span class="' + cls + '" title="Uninitialized RTC — no valid clock">🚫 No Clock</span>';
     }
     var label = severity === 'ok' ? '⏰' : '⏰ ' + window.formatSkew(skewSec);
     return '<span class="' + cls + '" title="Clock skew: ' + window.formatSkew(skewSec) + ' (' + (SKEW_SEVERITY_LABELS[severity] || severity) + ')">' + label + '</span>';

public/style.css

@@ -13,10 +13,6 @@
   --status-red: #ef4444;
   --status-orange: #f97316;
   --status-purple: #a855f7;
-  --status-amber: #f59e0b;
-  --status-amber-light: #fef3c7;
-  --status-amber-text: #92400e;
-  --path-inspector-speculative: #d97706;
   --role-observer: #8b5cf6;
   --accent-hover: #6db3ff;
   --text: #1a1a2e;
@@ -50,10 +46,6 @@
     --status-red: #ef4444;
     --status-orange: #f97316;
     --status-purple: #a855f7;
-    --status-amber: #f59e0b;
-    --status-amber-light: #422006;
-    --status-amber-text: #fcd34d;
-    --path-inspector-speculative: #f59e0b;
     --surface-0: #0f0f23;
     --surface-1: #1a1a2e;
     --surface-2: #232340;
@@ -80,9 +72,6 @@
   --status-red: #ef4444;
   --status-orange: #f97316;
   --status-purple: #a855f7;
-  --status-amber: #f59e0b;
-  --status-amber-light: #422006;
-  --status-amber-text: #fcd34d;
   --surface-0: #0f0f23;
   --surface-1: #1a1a2e;
   --surface-2: #232340;
@@ -356,9 +345,6 @@ a:focus-visible, button:focus-visible, input:focus-visible, select:focus-visible
 }
 .detail-meta dt { color: var(--text-muted); font-size: 11px; text-transform: uppercase; letter-spacing: .3px; }
 .detail-meta dd { font-weight: 500; margin-bottom: 4px; }
-.observation-current { background: var(--accent-bg, rgba(0,122,255,0.1)); font-weight: 600; }
-.detail-obs-row:hover { background: var(--hover-bg, rgba(255,255,255,0.05)); }
-.detail-obs-table th { font-size: 0.8em; text-transform: uppercase; color: var(--text-muted); }
 
 /* === Hex Dump === */
 .hex-dump {
@@ -711,9 +697,7 @@ button.ch-item:hover .ch-remove-btn { opacity: 0.6; }
 .advert-dot {
   width: 10px; height: 10px; border-radius: 50%; flex-shrink: 0; margin-top: 4px;
 }
-/* #829: explicit color so text stays readable when inherited color matches card-bg */
-.advert-info { font-size: 12px; line-height: 1.5; color: var(--text); }
-.advert-info a { color: var(--accent); }
+.advert-info { font-size: 12px; line-height: 1.5; }
 
 /* === Traces Page === */
 .traces-page { padding: 16px; max-width: var(--trace-max-width, 95vw); margin: 0 auto; }
@@ -1439,9 +1423,7 @@ button.ch-item.ch-item-encrypted .ch-badge { filter: grayscale(0.6); }
 .hop-conflict-name { font-weight: 600; flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .hop-conflict-dist { font-size: 11px; color: var(--text-muted); font-family: var(--mono); white-space: nowrap; }
 .hop-conflict-pk { font-size: 10px; color: var(--text-muted); font-family: var(--mono); }
-.hop-unreliable { opacity: 0.85; }
-.hop-unreliable-btn { background: none; border: none; color: var(--status-yellow, #f59e0b); font-size: 13px;
-  cursor: help; vertical-align: middle; margin-left: 2px; padding: 0 2px; line-height: 1; }
+.hop-unreliable { opacity: 0.5; text-decoration: line-through; }
 .hop-global-fallback { border-bottom: 1px dashed var(--status-red); }
 .hop-current { font-weight: 700 !important; color: var(--accent) !important; }
 
@@ -2293,55 +2275,21 @@ th.sort-active { color: var(--accent, #60a5fa); }
 
 /* #690 — Clock Skew badges & fleet table */
 .skew-badge { display: inline-block; font-size: 10px; padding: 1px 5px; border-radius: 3px; margin-left: 4px; font-weight: 600; white-space: nowrap; }
-.skew-badge--default { background: var(--text-muted); color: #fff; }
 .skew-badge--ok { background: var(--status-green); color: #fff; }
-.skew-badge--degrading { background: var(--status-yellow); color: #000; }
-.skew-badge--degraded { background: var(--status-orange); color: #fff; }
-.skew-badge--wrong { background: var(--status-red); color: #fff; }
+.skew-badge--warning { background: var(--status-yellow); color: #000; }
+.skew-badge--critical { background: var(--status-orange); color: #fff; }
+.skew-badge--absurd { background: var(--status-purple); color: #fff; }
+.skew-badge--no_clock { background: var(--text-muted); color: #fff; }
 
 .skew-detail-section { padding: 10px 16px; margin-bottom: 8px; }
 .skew-sparkline-wrap { margin-top: 6px; }
 .skew-sparkline-wrap svg { display: block; }
 
 
-.clock-fleet-row--degrading { background: color-mix(in srgb, var(--status-yellow) 10%, transparent); }
-.clock-fleet-row--degraded { background: color-mix(in srgb, var(--status-orange) 10%, transparent); }
-.clock-fleet-row--wrong { background: color-mix(in srgb, var(--status-red) 10%, transparent); }
-.clock-fleet-row--default { background: color-mix(in srgb, var(--text-muted) 10%, transparent); }
+.clock-fleet-row--warning { background: color-mix(in srgb, var(--status-yellow) 10%, transparent); }
+.clock-fleet-row--critical { background: color-mix(in srgb, var(--status-orange) 10%, transparent); }
+.clock-fleet-row--absurd { background: color-mix(in srgb, var(--status-purple) 10%, transparent); }
+.clock-fleet-row--no_clock { background: color-mix(in srgb, var(--text-muted) 10%, transparent); }
 
 .clock-filter-btn { font-size: 12px; padding: 3px 8px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg, #fff); color: var(--text); cursor: pointer; margin-right: 4px; }
 .clock-filter-btn.active { background: var(--accent); color: #fff; border-color: var(--accent); }
-
-/* === Path Inspector (issue #944) === */
-.path-inspector-page { padding: 16px; max-width: 900px; margin: 0 auto; }
-.path-inspector-input-row { display: flex; gap: 8px; margin-bottom: 12px; }
-.path-inspector-input-row .input { flex: 1; }
-.path-inspector-error { color: var(--status-red, #ef4444); font-size: 13px; margin-bottom: 8px; }
-.path-inspector-table { width: 100%; border-collapse: collapse; font-size: 13px; }
-.path-inspector-table th,
-.path-inspector-table td { padding: 6px 10px; border-bottom: 1px solid var(--border); text-align: left; }
-.path-inspector-table th { background: var(--card-bg); font-weight: 600; }
-.speculative-warning { color: var(--path-inspector-speculative, #d97706); font-weight: 600; }
-.speculative-badge { cursor: help; }
-.speculative-row { background: color-mix(in srgb, var(--path-inspector-speculative, #d97706) 8%, transparent); }
-.evidence-row { font-size: 12px; color: var(--text-muted); }
-.evidence-row.collapsed { display: none; }
-.evidence-detail { padding: 4px 10px; }
-.hop-evidence { margin: 2px 0; }
-.path-inspector-stats { margin-top: 12px; font-size: 12px; color: var(--text-muted); }
-.no-results { color: var(--text-muted); font-style: italic; }
-
-/* Map side pane for path inspector */
-.map-side-pane { flex: 0 0 32px; overflow: hidden; transition: flex-basis 0.2s; border-left: 1px solid var(--border); background: var(--card-bg); }
-.map-side-pane.expanded { flex: 0 0 320px; overflow-y: auto; padding: 12px; }
-.map-side-pane .pane-toggle { cursor: pointer; padding: 8px; font-size: 14px; text-align: center; }
-.map-side-pane .pane-content { display: none; }
-.map-side-pane.expanded .pane-content { display: block; }
-
-/* Tools landing page */
-.tools-landing { padding: 24px; max-width: 600px; }
-.tools-menu { display: flex; flex-direction: column; gap: 12px; margin-top: 16px; }
-.tools-card { display: block; padding: 16px; border-radius: 8px; border: 1px solid var(--border); background: var(--card-bg); color: var(--text); text-decoration: none; transition: border-color 0.2s; }
-.tools-card:hover { border-color: var(--primary); }
-.tools-card h3 { margin: 0 0 4px 0; font-size: 16px; }
-.tools-card p { margin: 0; font-size: 13px; color: var(--text-muted); }

qa/README.md

@@ -1,45 +0,0 @@
-# CoreScope QA artifacts
-
-Project-specific assets for the [`qa-suite`](https://github.com/Kpa-clawbot/ai-sdlc/tree/master/skills/qa-suite) skill.
-
-## Layout
-
-```
-qa/
-├── README.md                  ← this file
-├── plans/
-│   └── <release>.md           ← per-release test plans (one file per RC)
-└── scripts/
-    └── api-contract-diff.sh   ← CoreScope-tuned API contract diff
-```
-
-## How to run
-
-```
-qa staging              # use the latest plans/v*-rc.md against staging
-qa pr 806               # use plans/pr-806.md if it exists, else latest plans/v*-rc.md
-qa v3.6.0-rc            # use plans/v3.6.0-rc.md
-```
-
-The parent agent loads the qa-suite skill, which reads:
-1. The plan file from `qa/plans/`
-2. Bundled scripts from `qa/scripts/`
-3. The reusable engine + qa-engineer persona from the skill itself
-
-## Adding a new plan
-
-For each release candidate, copy the latest `plans/v*-rc.md` to `plans/<new-tag>.md` and update:
-- The commit-range header (`vN.M..master`)
-- Any new sections for new features in the release
-- The "Test data" section if new fixture types are needed
-- The GO criteria (which sections are blockers)
-
-## Adding a new script
-
-Custom scripts go in `qa/scripts/` with `mode=auto: <script-name>` referenced from the plan. The qa-engineer subagent runs them with two args: `BASELINE_URL TARGET_URL`.
-
-Authoring rules from the qa-suite skill:
-- 4-way error classification: `curl-failed` / `parse-empty` / `shape-diff` / field-missing
-- Distinguish HTTP errors from jq parse failures
-- Don't silence stderr — script bugs must surface
-- Exit code = number of failures

qa/plans/v3.6.0-rc.md

@@ -1,108 +0,0 @@
-# Plan: v3.6.0-rc
-
-Targets the changes between v3.5.1 and v3.6.0 candidate (~34 commits).
-
-## Test data
-The qa-engineer should pick concrete test fixtures at run time and include them in the report:
-- **Pivot node pubkey**: pick the top-result from `/api/nodes?limit=20&sort=advert_count` that has `role=repeater` AND a non-zero `totalPaths` from `/api/nodes/{pk}/paths`. Used for sections 5.1, 8.1, 8.2.
-- **Multi-role pubkey** (section 8.6): pick a node whose pubkey appears in BOTH `/api/observers` and `/api/nodes?role=repeater`. If none → mark 8.6 `needs-human`.
-- **Sample packet hash**: `/api/packets?limit=1` → `.packets[0].hash`. Used for sections 3.x.
-- **Channel sample**: pick a channel name from `/api/channels` (if endpoint exists) or scrape `/#channels` page.
-
-Record every fixture used in the final report so failures are reproducible.
-
-## Sections
-
-### 1. Memory & Load
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 1.1 | Container with **3 GB** limit starts on heaviest available DB | No OOM, steady state under limit. Note: 1 GB cap is unrealistic without `GOMEMLIMIT` and bounded cold-load — see #836 | #806/#836 | human |
-| 1.2 | Hit `/debug/pprof/heap` after Load completes; run `pprof-snapshot.sh` | `unmarshalResolvedPath` absent from top-15 inuse_space; `Load()`-attributed inuse_space ≤ 250 MB on staging-sized DB (~1.5M obs); total heap < 1 GB | #806 | auto: pprof-snapshot.sh |
-| 1.3 | Set tight `MaxLoadMemMB`, restart | Load stops gracefully at budget; server still serves `/api/stats` 200 | #790 | human |
-| 1.4 | Watch `processRSSMB` (from `/api/stats`) vs procfs RSS over ingest+eviction cycles | `processRSSMB` tracks `cat /proc/$(pidof corescope)/status | awk '/VmRSS/{print $2}'` (kB → MB) within ±20% across one full eviction cycle. Note: `storeDataMB` (formerly `trackedMB`) is the in-store packet byte estimate and is expected to be a **subset** of RSS, not equal to it. | #751, #832 | human |
-| 1.5 | Run 30 min under live ingest | Sawtooth heap pattern (≥1 eviction-driven dip), not monotonic ramp | #806/#807 | human |
-
-### 2. API contract
-Run `scripts/api-contract-diff.sh BASELINE_URL TARGET_URL` once. Report the script's exit code; nonzero = failures.
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 2.1 | api-contract-diff baseline vs target | Exit code 0; all endpoints carry `resolved_path` where expected | #806 | auto: api-contract-diff.sh |
-| 2.2 | WebSocket `/ws` carries `resolved_path` on broadcasts | Run JS hook in browser console: `(function(){let n=0,r=0; const W=WebSocket; window.WebSocket=function(...a){const s=new W(...a); s.addEventListener('message',e=>{n++; try{const m=JSON.parse(e.data); if(m && (m.resolved_path !== undefined || (m.observations||[]).some(o=>o.resolved_path!==undefined))) r++;}catch{}}); return s;}; window.__wsCount=()=>({n,r});})()` then navigate to `/`, wait 30s, eval `__wsCount()` — `r` must be ≥ 1 if `n` ≥ 1 | #806 | browser |
-
-### 3. Decoder & hashing
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 3.1 | Recompute content hashes for sample of recent packets vs stored | All match (hash uses payload-type bits only) | #787 | human |
-| 3.2 | Inspect a TRACE packet detail panel | path_json length matches path_sz from flags byte | #732 | browser |
-| 3.3 | Check `hash_size` on transport-route packet AND zero-hop advert | Correct hash_size detected | #747 | browser |
-| 3.4 | Field-table column offsets for transport-route packet | Snapshot of detail panel: each field row has nonzero `offset`/`length` cells AND offsets monotonically increase | #766 | browser |
-| 3.5 | Corrupt advert ingest log check | Rejected, counted, no DB entry | #794 | human |
-| 3.6 | Public channel packet rendering | No empty/garbled decode | #761 | browser |
-
-### 4. Channels (#725)
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 4.1 | Channel list — full message history loads from DB | Past messages persist across reload | #726 | browser |
-| 4.2 | Add custom channel via UI (then remove it as teardown) | Channel appears, encrypted msgs decrypt; teardown removes it cleanly. STAGING ONLY. | #733 | browser |
-| 4.3 | PSK channel add + channel removal (already a self-teardown) | Both work, UI state correct after | #750 | browser |
-| 4.4 | Deep link to encrypted channel without key | Lock message shows | #783 | browser |
-| 4.5 | Undecryptable msgs hidden by default + toggle | Hidden default; toggle shows | #728 | browser |
-| 4.6 | Add-channel button + hint + status feedback | All present | #760 | browser |
-| 4.7 | Filter packets by channel | Functional: filter applies, packet count drops; performance: response time ≤ 500 ms for `/api/packets?channel=<name>&limit=100` (timed via `curl -w '%{time_total}'`) | #762/#763 | browser+auto |
-
-### 5. Clock skew (#690)
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 5.1 | Node detail clock-skew badge + sparkline | Both render | #746/#752 | browser |
-| 5.2 | Analytics fleet clock-skew page | Renders, epoch-0 filtered | #769 | browser |
-| 5.3 | Outlier sample doesn't poison median | Sanity caps respected; severity uses `recentMedianSkewSec` (#789), not all-time `medianSkewSec` | #769/#789 | human |
-| 5.4 | Roles page clock-skew indicator | Renders | #752 | browser |
-
-### 6. Observers
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 6.1 | Observer with no packets in N days disappears after retention sweep | Removed | #764 | human |
-| 6.2 | Analytics observer-graph (M1+M2) | Renders (`#observerGraph` element present at `public/analytics.js:2048-2051`) | #774 | browser |
-
-### 7. Multi-byte hash adopters
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 7.1 | Hash Usage Matrix collision details for all hash sizes | Click cell → colliding pubkeys shown | #758 | browser |
-| 7.2 | Multi-byte adopter table includes all node types | Repeaters, room servers, sensors all present | #767 | browser |
-| 7.3 | Role column reflects multi-byte adoption + advert precedence | For 3 sample multi-byte adopter pubkeys (from #758 matrix), the Role column on `/#nodes` matches the role inferred from their latest advert flags via `/api/nodes/{pk}/health` | #767 | browser |
-
-### 8. Frontend nav & deep linking
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 8.1 | Click node on map/list — URL hash updates, panel opens | Hash matches | #739 | browser |
-| 8.2 | Open saved deep-link to a node | Full-screen detail view opens (post-#823: desktop deep links match the Details-link path) | #739/#823 | browser |
-| 8.3 | Packets page filter URL hash | Reload preserves filters | #740 | browser |
-| 8.4 | Details/Analytics links in node detail panel | Navigate without router glitch | #779/#785 | browser |
-| 8.5 | Neighbor graph slider | Persists across reloads, default 0.7 | #776 | browser |
-| 8.6 | Repeater that's also observer | Single map marker | #745 | browser |
-| 8.7 | Side-panel "Recent Packets" — click any entry, lands on packet detail (no 404), entry text is readable in current theme | DB-fallback works (#827); `.advert-info` has explicit color (#829) | #827/#829 | browser |
-
-### 9. Geofilter & customizer
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 9.1 | Customize → "Open geofilter builder" link | Opens app-served builder | #735 | browser |
-| 9.2 | Build a filter, save, reload (STAGING ONLY; teardown: delete the saved filter) | Persists across reload; teardown removes it | #735 | browser |
-| 9.3 | Geofilter docs page | Renders, content matches behavior | #734 | browser |
-
-### 10. Node blacklist
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 10.1 | Add node pubkey to nodeBlacklist config; restart | Hidden from listings/map/neighbor graph | #742 | auto: blacklist-test.sh |
-| 10.2 | Packets still in DB | Yes (filter not delete) | #742 | auto: blacklist-test.sh |
-
-`blacklist-test.sh` covers both 10.1 and 10.2 in one run. Required env: `TEST_NODE_PUBKEY` (hex, of a real visible node on TARGET), `TARGET_SSH_HOST`, `TARGET_CONFIG_PATH`, `TARGET_CONTAINER`. Optional: `TARGET_DB_PATH` or `ADMIN_API_TOKEN` for §10.2 probe; `TARGET_SSH_KEY` (default `/root/.ssh/id_ed25519`). Mandatory teardown removes the pubkey and verifies the node returns to listings.
-
-### 11. Deploy/ops
-| # | Step | Pass criteria | Source | Mode |
-|---|---|---|---|---|
-| 11.1 | Force-redeploy staging | Container removed cleanly even if `docker run`, not compose. Playwright E2E `Desktop: deep link #/nodes/{pubkey} opens full-screen detail view` passes (updated #833 — was asserting old pre-#823 split-panel behavior). | fa348ef/#833 | human |
-
-## GO criteria
-- Sections 1.2, 2, 3 must all pass — release blockers
-- Section 4 (channels) — any visible regression must be fixed before tag
-- Other sections: file follow-up issues; decide per-item whether to tag with known issues

qa/scripts/api-contract-diff.sh

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-# api-contract-diff.sh — diff CoreScope API endpoints between two deployments.
-# Usage: api-contract-diff.sh BASELINE_URL TARGET_URL [-k AUTH_HEADER]
-#
-# Compares JSON shape (recursive key set) per endpoint and asserts presence of
-# `resolved_path` where contract requires it. Prints a per-endpoint result line
-# (✅/❌) and a summary. Exit code = number of failures.
-#
-# Distinguishes:
-#   curl-failed  → HTTP error or network timeout (real outage)
-#   parse-empty  → curl succeeded but response shape unexpected (probable
-#                  contract drift in this script or in the API)
-#   shape-diff   → recursive key set differs between baseline and target
-#   rp-missing   → resolved_path absent on target where it was promised
-#
-# PUBLIC repo: do not commit URLs or keys here. Caller passes them.
-
-set -uo pipefail
-
-OLD="${1:-}"; NEW="${2:-}"
-[[ -z "$OLD" || -z "$NEW" ]] && { echo "usage: $0 BASELINE_URL TARGET_URL [-k AUTH_HEADER]" >&2; exit 2; }
-shift 2 || true
-AUTH=""
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -k) AUTH="$2"; shift 2 ;;
-    *) echo "unknown arg: $1" >&2; exit 2 ;;
-  esac
-done
-
-TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
-
-# Wrapper: fetch URL, return body on stdout, exit 1 on HTTP error / timeout.
-fetch() {
-  local url="$1" out="$2"
-  local code
-  code=$(curl -s -m 30 -o "$out" -w "%{http_code}" ${AUTH:+-H "$AUTH"} "$url" 2>/dev/null) || code="000"
-  if [[ "$code" != "2"* ]]; then
-    echo "  HTTP $code"
-    return 1
-  fi
-  return 0
-}
-
-# Seed lookups from TARGET (so the picked IDs are guaranteed present there).
-seed_packets="$TMP/seed_packets.json"
-seed_observers="$TMP/seed_observers.json"
-seed_nodes="$TMP/seed_nodes.json"
-
-if ! fetch "$NEW/api/packets?limit=1" "$seed_packets"; then echo "seed /api/packets failed" >&2; fi
-if ! fetch "$NEW/api/observers"       "$seed_observers"; then echo "seed /api/observers failed" >&2; fi
-if ! fetch "$NEW/api/nodes?limit=1"   "$seed_nodes"; then echo "seed /api/nodes failed" >&2; fi
-
-HASH=$(jq -r '.packets[0].hash // empty'         "$seed_packets"   2>/dev/null || true)
-OBSID=$(jq -r '.observers[0].id // empty'        "$seed_observers" 2>/dev/null || true)
-NODEPK=$(jq -r '.nodes[0].public_key // empty'   "$seed_nodes"     2>/dev/null || true)
-
-[[ -z "$HASH"   ]] && echo "warn: no packet hash from /api/packets — packet-detail endpoints will be skipped" >&2
-[[ -z "$OBSID"  ]] && echo "warn: no observer id   from /api/observers — observer-detail endpoints will be skipped" >&2
-[[ -z "$NODEPK" ]] && echo "warn: no node pubkey   from /api/nodes — node-detail endpoints will be skipped" >&2
-
-# Endpoints to diff: path | jq filter (selects subobject to compare) | RP-required(yes/no)
-declare -a ENDPOINTS
-ENDPOINTS+=("/api/packets?limit=20|.packets[0]|yes")
-ENDPOINTS+=("/api/packets?limit=20&expandObservations=true|.packets[0]|yes")
-ENDPOINTS+=("/api/observers|.observers[0]|no")
-[[ -n "$HASH"   ]] && ENDPOINTS+=("/api/packets/$HASH|.|yes")
-[[ -n "$OBSID"  ]] && ENDPOINTS+=("/api/observers/$OBSID|.|no")
-[[ -n "$OBSID"  ]] && ENDPOINTS+=("/api/observers/$OBSID/analytics|.|no")
-[[ -n "$NODEPK" ]] && ENDPOINTS+=("/api/nodes/$NODEPK/health|.recentPackets[0]|yes")
-[[ -n "$NODEPK" ]] && ENDPOINTS+=("/api/nodes/$NODEPK/paths|.|no")
-
-# Strip volatile fields (timestamps + counters) from a JSON value.
-STRIP='walk(if type=="object" then del(.timestamp, .first_seen, .last_seen, .last_heard, .updated_at, .server_time, .packet_count, .packetsLastHour, .uptime_secs, .battery_mv, .noise_floor, .observation_count, .advert_count) else . end)'
-
-fails=0
-for ep in "${ENDPOINTS[@]}"; do
-  IFS='|' read -r path filter need_rp <<<"$ep"
-  echo "=== $path  (resolved_path required: $need_rp) ==="
-
-  oldfile="$TMP/old.json"; newfile="$TMP/new.json"
-  if ! fetch "$OLD$path" "$oldfile"; then echo "  ❌ baseline curl-failed"; fails=$((fails+1)); continue; fi
-  if ! fetch "$NEW$path" "$newfile"; then echo "  ❌ target curl-failed";   fails=$((fails+1)); continue; fi
-
-  # Selector + strip on each side. jq stderr is preserved so script bugs surface.
-  oldj=$(jq "$filter | $STRIP" "$oldfile")
-  jq_old_rc=$?
-  newj=$(jq "$filter | $STRIP" "$newfile")
-  jq_new_rc=$?
-
-  if [[ $jq_old_rc -ne 0 ]]; then
-    echo "  ❌ baseline jq-error (filter='$filter') — likely script bug or API shape changed"
-    fails=$((fails+1)); continue
-  fi
-  if [[ $jq_new_rc -ne 0 ]]; then
-    echo "  ❌ target jq-error (filter='$filter') — likely script bug or API shape changed"
-    fails=$((fails+1)); continue
-  fi
-  if [[ -z "$oldj" || "$oldj" == "null" ]]; then
-    echo "  ❌ baseline parse-empty (filter returned empty/null; check API shape)"
-    fails=$((fails+1)); continue
-  fi
-  if [[ -z "$newj" || "$newj" == "null" ]]; then
-    echo "  ❌ target parse-empty (filter returned empty/null; check API shape)"
-    fails=$((fails+1)); continue
-  fi
-
-  # Recursive key-set diff. Canonicalize array indices (numbers) → "[]" so two
-  # different sample responses with different array lengths don't false-positive.
-  KEYS_FILTER='[paths(scalars or type=="null" or (type=="array" and length==0) or (type=="object" and length==0)) | map(if type=="number" then "[]" else . end) | join(".")] | unique | .[]'
-  oldkeys=$(echo "$oldj" | jq -r "$KEYS_FILTER" | sort -u)
-  newkeys=$(echo "$newj" | jq -r "$KEYS_FILTER" | sort -u)
-  if ! diff <(echo "$oldkeys") <(echo "$newkeys") >/dev/null; then
-    echo "  ❌ shape-diff (key set differs):"
-    diff <(echo "$oldkeys") <(echo "$newkeys") | sed 's/^/    /'
-    fails=$((fails+1))
-    continue
-  fi
-
-  # If RP expected, assert present on target (any value, may be null).
-  if [[ "$need_rp" == "yes" ]]; then
-    if ! echo "$newj" | jq -e '.. | objects | select(has("resolved_path")) | .resolved_path' >/dev/null 2>&1; then
-      echo "  ❌ rp-missing (resolved_path not present anywhere in selector)"
-      fails=$((fails+1))
-      continue
-    fi
-  fi
-
-  echo "  ✅ ok"
-done
-
-echo
-echo "failures: $fails / ${#ENDPOINTS[@]}"
-exit $fails

qa/scripts/blacklist-test.sh

@@ -1,271 +0,0 @@
-#!/usr/bin/env bash
-# blacklist-test.sh — verify nodeBlacklist hides a pubkey from API surface
-# while retaining its packets in the DB. Implements QA plan §10.1 + §10.2.
-#
-# Usage:
-#   blacklist-test.sh BASELINE_URL TARGET_URL
-#
-# BASELINE_URL is currently unused for assertions but kept as a positional
-# arg for parity with other qa-suite scripts (always called with two URLs).
-#
-# Required env (target host control + test data):
-#   TEST_NODE_PUBKEY      — hex pubkey of a real, currently-visible node on TARGET_URL
-#   TARGET_SSH_HOST       — e.g. runner@example
-#   TARGET_SSH_KEY        — path to ssh private key (default: /root/.ssh/id_ed25519)
-#   TARGET_CONFIG_PATH    — absolute path to config.json on the target
-#   TARGET_CONTAINER      — docker container name on the target
-# Optional env:
-#   TARGET_DB_PATH        — sqlite db path on the target (for §10.2 sqlite probe)
-#   ADMIN_API_TOKEN       — if /api/admin/transmissions exists, use it instead of ssh+sqlite
-#                            (read from env, not argv — never appears in ps)
-#   CURL_TIMEOUT          — per-request curl timeout, seconds (default 60)
-#   RESTART_WAIT_S        — max wait for /api/stats after restart (default 120)
-#
-# Distinguishes:
-#   ssh-failed     → cannot reach/control target
-#   restart-stuck  → /api/stats not 200 within RESTART_WAIT_S
-#   hide-failed    → blacklisted pubkey still surfaced via API (§10.1 fail)
-#   retain-failed  → blacklisted pubkey absent from DB (§10.2 fail)
-#   teardown-failed→ post-test removal did not restore listing
-#
-# Exit code = number of failures (0 = pass).
-# PUBLIC repo: zero PII — no real pubkeys, IPs, or hostnames as defaults.
-
-set -uo pipefail
-
-BASELINE_URL="${1:-}"
-TARGET_URL="${2:-}"
-if [[ -z "$BASELINE_URL" || -z "$TARGET_URL" ]]; then
-  echo "usage: $0 BASELINE_URL TARGET_URL  (TEST_NODE_PUBKEY+TARGET_* via env)" >&2
-  exit 2
-fi
-
-TEST_PUBKEY="${TEST_NODE_PUBKEY:-}"
-TARGET_SSH_HOST="${TARGET_SSH_HOST:-}"
-TARGET_SSH_KEY="${TARGET_SSH_KEY:-/root/.ssh/id_ed25519}"
-TARGET_CONFIG_PATH="${TARGET_CONFIG_PATH:-}"
-TARGET_CONTAINER="${TARGET_CONTAINER:-}"
-TARGET_DB_PATH="${TARGET_DB_PATH:-}"
-ADMIN_API_TOKEN="${ADMIN_API_TOKEN:-}"
-
-if [[ -z "$TEST_PUBKEY" || -z "$TARGET_SSH_HOST" || -z "$TARGET_CONFIG_PATH" || -z "$TARGET_CONTAINER" ]]; then
-  echo "error: TEST_NODE_PUBKEY, TARGET_SSH_HOST, TARGET_CONFIG_PATH, TARGET_CONTAINER are required" >&2
-  exit 2
-fi
-
-# Hard input validation — these strings are interpolated into remote shell/SQL.
-# Pubkey must be hex (MeshCore pubkeys are hex-encoded ed25519 prefixes).
-if ! [[ "$TEST_PUBKEY" =~ ^[0-9a-fA-F]+$ ]]; then
-  echo "error: TEST_NODE_PUBKEY must be hex (got: redacted)" >&2
-  exit 2
-fi
-# Container name must match docker's allowed chars: [a-zA-Z0-9][a-zA-Z0-9_.-]*
-if ! [[ "$TARGET_CONTAINER" =~ ^[a-zA-Z0-9][a-zA-Z0-9_.-]*$ ]]; then
-  echo "error: TARGET_CONTAINER has illegal chars" >&2
-  exit 2
-fi
-# Config path must be an absolute, sane path (no spaces, quotes, $, ;, etc.).
-if ! [[ "$TARGET_CONFIG_PATH" =~ ^/[A-Za-z0-9_./-]+$ ]]; then
-  echo "error: TARGET_CONFIG_PATH must be a sane absolute path" >&2
-  exit 2
-fi
-if [[ -n "$TARGET_DB_PATH" ]] && ! [[ "$TARGET_DB_PATH" =~ ^/[A-Za-z0-9_./-]+$ ]]; then
-  echo "error: TARGET_DB_PATH must be a sane absolute path" >&2
-  exit 2
-fi
-
-CURL_TIMEOUT="${CURL_TIMEOUT:-60}"
-RESTART_WAIT_S="${RESTART_WAIT_S:-120}"
-
-SSH_OPTS=(-i "$TARGET_SSH_KEY" -o StrictHostKeyChecking=accept-new -o ConnectTimeout=15 -o BatchMode=yes)
-ssh_t() { ssh "${SSH_OPTS[@]}" "$TARGET_SSH_HOST" "$@"; }
-
-TMP=$(mktemp -d)
-fails=0
-TEARDOWN_DONE=0
-
-# -----------------------------------------------------------------------------
-# Teardown — MANDATORY in all exit paths.
-# -----------------------------------------------------------------------------
-teardown() {
-  local rc=$?
-  if [[ "$TEARDOWN_DONE" == "1" ]]; then rm -rf "$TMP"; exit "$rc"; fi
-  TEARDOWN_DONE=1
-  echo "=== teardown: removing $TEST_PUBKEY from nodeBlacklist ==="
-  if remove_from_blacklist && restart_target && wait_for_stats; then
-    if node_visible; then
-      echo "  ✅ teardown ok — node returned to listings"
-    else
-      echo "  ❌ teardown-failed: node still hidden after removal"
-      rc=$((rc + 1))
-    fi
-  else
-    echo "  ❌ teardown-failed: could not restore config / restart / stats"
-    rc=$((rc + 1))
-  fi
-  rm -rf "$TMP"
-  exit "$rc"
-}
-trap teardown EXIT INT TERM
-
-# -----------------------------------------------------------------------------
-# Helpers
-# -----------------------------------------------------------------------------
-fetch_code() {
-  local url="$1" out="$2"
-  curl -s -m "$CURL_TIMEOUT" -o "$out" -w "%{http_code}" "$url" 2>/dev/null || echo "000"
-}
-
-wait_for_stats() {
-  local deadline code
-  echo "  waiting up to ${RESTART_WAIT_S}s for $TARGET_URL/api/stats ..."
-  deadline=$(( $(date +%s) + RESTART_WAIT_S ))
-  while (( $(date +%s) < deadline )); do
-    code=$(fetch_code "$TARGET_URL/api/stats" "$TMP/stats.json")
-    if [[ "$code" == "200" ]]; then echo "  stats OK"; return 0; fi
-    sleep 3
-  done
-  echo "  ❌ restart-stuck: /api/stats never returned 200"
-  return 1
-}
-
-restart_target() {
-  echo "  restarting container $TARGET_CONTAINER ..."
-  # TARGET_CONTAINER is validated above; still quote defensively.
-  if ! ssh_t "docker restart $(printf %q "$TARGET_CONTAINER")" >/dev/null; then
-    echo "  ❌ ssh-failed: docker restart failed"
-    return 1
-  fi
-  return 0
-}
-
-# Mutate config.json on target. Values pass via env (printf %q + single-quoted
-# heredoc) so $TEST_PUBKEY etc. never enter the remote shell as code.
-set_blacklist_state() {
-  local mode="$1"  # add | remove
-  ssh_t "CFG=$(printf %q "$TARGET_CONFIG_PATH") PK=$(printf %q "$TEST_PUBKEY") MODE=$(printf %q "$mode") bash -s" <<'REMOTE'
-set -euo pipefail
-TMP="$(mktemp)"
-trap 'rm -f "$TMP"' EXIT
-if command -v jq >/dev/null; then
-  if [ "$MODE" = "add" ]; then
-    jq --arg pk "$PK" '.nodeBlacklist = ((.nodeBlacklist // []) + [$pk] | unique)' "$CFG" > "$TMP"
-  else
-    jq --arg pk "$PK" '.nodeBlacklist = ((.nodeBlacklist // []) - [$pk])' "$CFG" > "$TMP"
-  fi
-else
-  python3 - "$CFG" "$PK" "$MODE" "$TMP" <<'PY'
-import json, sys
-cfg, pk, mode, out = sys.argv[1:]
-with open(cfg) as f: d = json.load(f)
-bl = list(dict.fromkeys(d.get("nodeBlacklist") or []))
-if mode == "add":
-    if pk not in bl: bl.append(pk)
-else:
-    bl = [x for x in bl if x != pk]
-d["nodeBlacklist"] = bl
-with open(out, "w") as f: json.dump(d, f, indent=2)
-PY
-fi
-# Preserve mode and ownership; mv across same FS is atomic.
-chmod --reference="$CFG" "$TMP" 2>/dev/null || true
-chown --reference="$CFG" "$TMP" 2>/dev/null || true
-mv "$TMP" "$CFG"
-trap - EXIT
-REMOTE
-  local rc=$?
-  if (( rc != 0 )); then
-    echo "  ❌ ssh-failed: could not edit $TARGET_CONFIG_PATH ($mode)"
-    return 1
-  fi
-  return 0
-}
-
-add_to_blacklist()      { set_blacklist_state add; }
-remove_from_blacklist() { set_blacklist_state remove; }
-
-node_visible() {
-  # Returns 0 if the pubkey is currently visible via API.
-  local code
-  code=$(fetch_code "$TARGET_URL/api/nodes/$TEST_PUBKEY" "$TMP/node.json")
-  if [[ "$code" == "200" ]]; then return 0; fi
-  fetch_code "$TARGET_URL/api/nodes?limit=10000" "$TMP/nodes.json" >/dev/null
-  if grep -qF -- "\"$TEST_PUBKEY\"" "$TMP/nodes.json" 2>/dev/null; then
-    return 0
-  fi
-  return 1
-}
-
-# -----------------------------------------------------------------------------
-# §10.1 — hide
-# -----------------------------------------------------------------------------
-echo "=== §10.1 add $TEST_PUBKEY to nodeBlacklist ==="
-if ! add_to_blacklist; then fails=$((fails+1)); exit "$fails"; fi
-if ! restart_target;    then fails=$((fails+1)); exit "$fails"; fi
-if ! wait_for_stats;    then fails=$((fails+1)); exit "$fails"; fi
-
-detail_code=$(fetch_code "$TARGET_URL/api/nodes/$TEST_PUBKEY" "$TMP/detail.json")
-list_code=$(fetch_code "$TARGET_URL/api/nodes?limit=10000" "$TMP/list.json")
-in_list=0
-if [[ "$list_code" == "200" ]] && grep -qF -- "\"$TEST_PUBKEY\"" "$TMP/list.json"; then
-  in_list=1
-fi
-if [[ "$detail_code" == "404" || "$in_list" == "0" ]]; then
-  echo "  ✅ hide ok: detail=$detail_code in_list=$in_list"
-else
-  echo "  ❌ hide-failed: detail=$detail_code in_list=$in_list — pubkey still surfaced"
-  fails=$((fails+1))
-fi
-
-topo_code=$(fetch_code "$TARGET_URL/api/topology" "$TMP/topo.json")
-if [[ "$topo_code" != "200" ]]; then
-  echo "  ⚠️  /api/topology HTTP $topo_code — skipping topology assertion"
-elif grep -qF -- "$TEST_PUBKEY" "$TMP/topo.json"; then
-  echo "  ❌ hide-failed: /api/topology references blacklisted pubkey"
-  fails=$((fails+1))
-else
-  echo "  ✅ topology clean"
-fi
-
-# -----------------------------------------------------------------------------
-# §10.2 — DB retain
-# -----------------------------------------------------------------------------
-echo "=== §10.2 verify packets retained in DB ==="
-count=""
-if [[ -n "$ADMIN_API_TOKEN" ]]; then
-  # Read auth header from stdin so the token never enters argv (ps-safe).
-  code=$(printf 'header = "Authorization: Bearer %s"\n' "$ADMIN_API_TOKEN" | \
-    curl -s -m "$CURL_TIMEOUT" -K - -o "$TMP/admin.json" -w "%{http_code}" \
-      "$TARGET_URL/api/admin/transmissions?from_node=$TEST_PUBKEY&count=1" 2>/dev/null || echo "000")
-  if [[ "$code" == "200" ]]; then
-    count=$(jq -r '.count // ((.transmissions // []) | length)' "$TMP/admin.json" 2>/dev/null || echo "")
-  fi
-fi
-if [[ -z "$count" ]]; then
-  if [[ -z "$TARGET_DB_PATH" ]]; then
-    echo "  ❌ retain-failed: TARGET_DB_PATH unset and no ADMIN_API_TOKEN — cannot probe"
-    fails=$((fails+1))
-  else
-    # TEST_PUBKEY is hex-validated → safe to inline single-quoted in SQL.
-    # Container/db path also validated; printf %q for defense in depth.
-    q="SELECT COUNT(*) FROM transmissions WHERE from_node = '$TEST_PUBKEY';"
-    qq=$(printf %q "$q")
-    if ! count=$(ssh_t "docker exec $(printf %q "$TARGET_CONTAINER") sqlite3 $(printf %q "$TARGET_DB_PATH") $qq" 2>/dev/null); then
-      count=$(ssh_t "sqlite3 $(printf %q "$TARGET_DB_PATH") $qq" 2>/dev/null || echo "")
-    fi
-  fi
-fi
-
-if [[ -z "$count" ]]; then
-  echo "  ❌ retain-failed: could not read transmissions count"
-  fails=$((fails+1))
-elif [[ "$count" =~ ^[0-9]+$ ]] && (( count > 0 )); then
-  echo "  ✅ DB retains $count packets from $TEST_PUBKEY"
-else
-  echo "  ❌ retain-failed: count=$count (expected > 0)"
-  fails=$((fails+1))
-fi
-
-echo "=== summary: $fails failure(s) before teardown ==="
-# trap handles teardown + exit
-exit "$fails"

scripts/migrate-fixture-hashes.go

@@ -1,136 +0,0 @@
-// migrate-fixture-hashes recomputes content hashes in a fixture DB using the
-// current ComputeContentHash formula.  Run once; idempotent.
-package main
-
-import (
-	"crypto/sha256"
-	"database/sql"
-	"encoding/hex"
-	"fmt"
-	"log"
-	"os"
-
-	_ "modernc.org/sqlite"
-)
-
-func computeContentHash(rawHex string) string {
-	buf, err := hex.DecodeString(rawHex)
-	if err != nil || len(buf) < 2 {
-		if len(rawHex) >= 16 {
-			return rawHex[:16]
-		}
-		return rawHex
-	}
-
-	headerByte := buf[0]
-	offset := 1
-	routeType := int(headerByte & 0x03)
-	if routeType == 2 || routeType == 3 { // transport
-		offset += 4
-	}
-	if offset >= len(buf) {
-		if len(rawHex) >= 16 {
-			return rawHex[:16]
-		}
-		return rawHex
-	}
-	pathByte := buf[offset]
-	offset++
-	hashSize := int((pathByte>>6)&0x3) + 1
-	hashCount := int(pathByte & 0x3F)
-	pathBytes := hashSize * hashCount
-
-	payloadStart := offset + pathBytes
-	if payloadStart > len(buf) {
-		if len(rawHex) >= 16 {
-			return rawHex[:16]
-		}
-		return rawHex
-	}
-
-	payload := buf[payloadStart:]
-	payloadType := (headerByte >> 2) & 0x0F
-	toHash := []byte{payloadType}
-
-	// TRACE = payload type 7
-	if int(payloadType) == 7 {
-		toHash = append(toHash, pathByte, 0x00)
-	}
-	toHash = append(toHash, payload...)
-
-	h := sha256.Sum256(toHash)
-	return hex.EncodeToString(h[:])[:16]
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintf(os.Stderr, "usage: %s <db-path>\n", os.Args[0])
-		os.Exit(1)
-	}
-	dbPath := os.Args[1]
-
-	db, err := sql.Open("sqlite", dbPath)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer db.Close()
-
-	rows, err := db.Query("SELECT id, raw_hex, hash FROM transmissions")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	type update struct {
-		id      int
-		newHash string
-	}
-	var updates []update
-
-	for rows.Next() {
-		var id int
-		var rawHex, oldHash string
-		if err := rows.Scan(&id, &rawHex, &oldHash); err != nil {
-			log.Printf("scan: %v", err)
-			continue
-		}
-		newHash := computeContentHash(rawHex)
-		if newHash != oldHash {
-			updates = append(updates, update{id, newHash})
-		}
-	}
-	rows.Close()
-
-	if len(updates) == 0 {
-		fmt.Println("All hashes already match current formula.")
-		return
-	}
-
-	tx, err := db.Begin()
-	if err != nil {
-		log.Fatal(err)
-	}
-	stmt, err := tx.Prepare("UPDATE transmissions SET hash = ? WHERE id = ?")
-	if err != nil {
-		log.Fatal(err)
-	}
-	merged := 0
-	for _, u := range updates {
-		if _, err := stmt.Exec(u.newHash, u.id); err != nil {
-			// UNIQUE constraint = duplicate (same content, different old hash).
-			// Move observations to the surviving tx, then delete the dup.
-			log.Printf("update id %d: %v — merging duplicate", u.id, err)
-			// Find surviving tx id
-			var survID int
-			if err2 := tx.QueryRow("SELECT id FROM transmissions WHERE hash = ?", u.newHash).Scan(&survID); err2 == nil {
-				tx.Exec("UPDATE observations SET transmission_id = ? WHERE transmission_id = ?", survID, u.id)
-				tx.Exec("DELETE FROM transmissions WHERE id = ?", u.id)
-				merged++
-			}
-		}
-	}
-	stmt.Close()
-	if err := tx.Commit(); err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("Migrated %d hashes, merged %d duplicates.\n", len(updates)-merged, merged)
-}

test-aging.js

@@ -59,7 +59,118 @@ test('null lastSeenMs → stale', () => assert.strictEqual(getNodeStatus('repeat
 test('undefined lastSeenMs → stale', () => assert.strictEqual(getNodeStatus('repeater', undefined), 'stale'));
 test('0 lastSeenMs → stale', () => assert.strictEqual(getNodeStatus('repeater', 0), 'stale'));
 
+// === getStatusInfo tests (inline since nodes.js has too many DOM deps) ===
+console.log('\n=== getStatusInfo (logic validation) ===');
 
+// Simulate getStatusInfo logic
+function mockGetStatusInfo(n) {
+  const ROLE_COLORS = ctx.window.ROLE_COLORS;
+  const role = (n.role || '').toLowerCase();
+  const roleColor = ROLE_COLORS[n.role] || '#6b7280';
+  const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
+  const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
+  const status = getNodeStatus(role, lastHeardMs);
+  const statusLabel = status === 'active' ? '🟢 Active' : '⚪ Stale';
+  const isInfra = role === 'repeater' || role === 'room';
+
+  let explanation = '';
+  if (status === 'active') {
+    explanation = 'Last heard recently';
+  } else {
+    const reason = isInfra
+      ? 'repeaters typically advertise every 12-24h'
+      : 'companions only advertise when user initiates, this may be normal';
+    explanation = 'Not heard — ' + reason;
+  }
+  return { status, statusLabel, roleColor, explanation, role };
+}
+
+test('active repeater → 🟢 Active, red color', () => {
+  const info = mockGetStatusInfo({ role: 'repeater', last_seen: new Date(now - 1*h).toISOString() });
+  assert.strictEqual(info.status, 'active');
+  assert.strictEqual(info.statusLabel, '🟢 Active');
+  assert.strictEqual(info.roleColor, '#dc2626');
+});
+
+test('stale companion → ⚪ Stale, explanation mentions "this may be normal"', () => {
+  const info = mockGetStatusInfo({ role: 'companion', last_seen: new Date(now - 25*h).toISOString() });
+  assert.strictEqual(info.status, 'stale');
+  assert.strictEqual(info.statusLabel, '⚪ Stale');
+  assert(info.explanation.includes('this may be normal'), 'should mention "this may be normal"');
+});
+
+test('missing last_seen → stale', () => {
+  const info = mockGetStatusInfo({ role: 'repeater' });
+  assert.strictEqual(info.status, 'stale');
+});
+
+test('missing role → defaults to empty string, uses node threshold', () => {
+  const info = mockGetStatusInfo({ last_seen: new Date(now - 25*h).toISOString() });
+  assert.strictEqual(info.status, 'stale');
+  assert.strictEqual(info.roleColor, '#6b7280');
+});
+
+test('prefers last_heard over last_seen', () => {
+  // last_seen is stale, but last_heard is recent
+  const info = mockGetStatusInfo({
+    role: 'companion',
+    last_seen: new Date(now - 48*h).toISOString(),
+    last_heard: new Date(now - 1*h).toISOString()
+  });
+  assert.strictEqual(info.status, 'active');
+});
+
+// === getStatusTooltip tests ===
+console.log('\n=== getStatusTooltip ===');
+
+// Load from nodes.js by extracting the function
+// Since nodes.js is complex, I'll re-implement the tooltip function for testing
+function getStatusTooltip(role, status) {
+  const isInfra = role === 'repeater' || role === 'room';
+  const threshold = isInfra ? '72h' : '24h';
+  if (status === 'active') {
+    return 'Active — heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
+  }
+  if (role === 'companion') {
+    return 'Stale — not heard for over ' + threshold + '. Companions only advertise when the user initiates — this may be normal.';
+  }
+  if (role === 'sensor') {
+    return 'Stale — not heard for over ' + threshold + '. This sensor may be offline.';
+  }
+  return 'Stale — not heard for over ' + threshold + '. This ' + role + ' may be offline or out of range.';
+}
+
+test('active repeater mentions "72h" and "advertise every 12-24h"', () => {
+  const tip = getStatusTooltip('repeater', 'active');
+  assert(tip.includes('72h'), 'should mention 72h');
+  assert(tip.includes('advertise every 12-24h'), 'should mention advertise frequency');
+});
+
+test('active companion mentions "24h"', () => {
+  const tip = getStatusTooltip('companion', 'active');
+  assert(tip.includes('24h'), 'should mention 24h');
+});
+
+test('stale companion mentions "24h" and "user initiates"', () => {
+  const tip = getStatusTooltip('companion', 'stale');
+  assert(tip.includes('24h'), 'should mention 24h');
+  assert(tip.includes('user initiates'), 'should mention user initiates');
+});
+
+test('stale repeater mentions "offline or out of range"', () => {
+  const tip = getStatusTooltip('repeater', 'stale');
+  assert(tip.includes('offline or out of range'), 'should mention offline or out of range');
+});
+
+test('stale sensor mentions "sensor may be offline"', () => {
+  const tip = getStatusTooltip('sensor', 'stale');
+  assert(tip.includes('sensor may be offline'));
+});
+
+test('stale room uses 72h threshold', () => {
+  const tip = getStatusTooltip('room', 'stale');
+  assert(tip.includes('72h'));
+});
 
 // === Bug check: renderRows uses last_seen instead of last_heard || last_seen ===
 console.log('\n=== BUG CHECK ===');

test-anim-perf.js

@@ -0,0 +1,123 @@
+/**
+ * test-anim-perf.js — Performance benchmark for animation timer management
+ *
+ * Demonstrates that the rAF + concurrency-cap approach keeps active animation
+ * count bounded, whereas the old setInterval approach accumulated without limit.
+ *
+ * Run: node test-anim-perf.js
+ */
+
+'use strict';
+
+let passed = 0, failed = 0;
+function assert(cond, msg) {
+  if (cond) { console.log(`  ✅ ${msg}`); passed++; }
+  else { console.log(`  ❌ ${msg}`); failed++; }
+}
+
+// ---------------------------------------------------------------------------
+// Simulate OLD behaviour: setInterval-based, no concurrency cap
+// ---------------------------------------------------------------------------
+function simulateOldModel(packetsPerSec, hopsPerPacket, durationSec) {
+  // Each hop spawns 3 intervals (pulse 26ms, line 33ms, fade 52ms).
+  // Pulse lasts ~2s, line ~0.66s, fade ~0.8s+0.4s ≈ 1.2s
+  // At any moment, timers from the last ~2s of packets are still alive.
+  const intervalLifetimes = [2.0, 0.66, 1.2]; // seconds each interval lives
+  let maxConcurrent = 0;
+  // Walk through time in 0.1s steps
+  const dt = 0.1;
+  const spawns = []; // {time, lifetime}
+  for (let t = 0; t < durationSec; t += dt) {
+    // Spawn timers for packets arriving in this window
+    const pktsInWindow = packetsPerSec * dt;
+    for (let p = 0; p < pktsInWindow; p++) {
+      for (let h = 0; h < hopsPerPacket; h++) {
+        for (const lt of intervalLifetimes) {
+          spawns.push({ time: t, lifetime: lt });
+        }
+      }
+    }
+    // Count alive timers
+    const alive = spawns.filter(s => t < s.time + s.lifetime).length;
+    if (alive > maxConcurrent) maxConcurrent = alive;
+  }
+  return maxConcurrent;
+}
+
+// ---------------------------------------------------------------------------
+// Simulate NEW behaviour: rAF + MAX_CONCURRENT_ANIMS cap
+// ---------------------------------------------------------------------------
+function simulateNewModel(packetsPerSec, hopsPerPacket, durationSec) {
+  const MAX_CONCURRENT_ANIMS = 20;
+  let activeAnims = 0;
+  let maxConcurrent = 0;
+  const anims = []; // {endTime}
+  const dt = 0.1;
+  for (let t = 0; t < durationSec; t += dt) {
+    // Expire finished animations
+    while (anims.length && anims[0].endTime <= t) {
+      anims.shift();
+      activeAnims--;
+    }
+    // Try to start new animations
+    const pktsInWindow = packetsPerSec * dt;
+    for (let p = 0; p < pktsInWindow; p++) {
+      if (activeAnims >= MAX_CONCURRENT_ANIMS) break; // cap reached — drop
+      activeAnims++;
+      // rAF animation lifetime: longest is pulse ~2s
+      anims.push({ endTime: t + 2.0 });
+    }
+    // Sort by endTime so expiry works
+    anims.sort((a, b) => a.endTime - b.endTime);
+    if (activeAnims > maxConcurrent) maxConcurrent = activeAnims;
+  }
+  return maxConcurrent;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+console.log('\n=== Animation timer accumulation: old vs new ===');
+
+// Scenario: 5 pkts/sec, 3 hops each, 30 seconds
+const oldPeak30s = simulateOldModel(5, 3, 30);
+const newPeak30s = simulateNewModel(5, 3, 30);
+console.log(`  Old model (30s @ 5pkt/s×3hops): peak ${oldPeak30s} concurrent timers`);
+console.log(`  New model (30s @ 5pkt/s×3hops): peak ${newPeak30s} concurrent animations`);
+assert(oldPeak30s > 100, `old model accumulates >100 timers (got ${oldPeak30s})`);
+assert(newPeak30s <= 20, `new model stays ≤20 (got ${newPeak30s})`);
+
+// Scenario: 5 minutes sustained
+const oldPeak5m = simulateOldModel(5, 3, 300);
+const newPeak5m = simulateNewModel(5, 3, 300);
+console.log(`  Old model (5min @ 5pkt/s×3hops): peak ${oldPeak5m} concurrent timers`);
+console.log(`  New model (5min @ 5pkt/s×3hops): peak ${newPeak5m} concurrent animations`);
+assert(oldPeak5m > 100, `old model at 5min still unbounded (got ${oldPeak5m})`);
+assert(newPeak5m <= 20, `new model at 5min still ≤20 (got ${newPeak5m})`);
+
+// Scenario: burst — 20 pkts/sec for 10s
+const oldBurst = simulateOldModel(20, 3, 10);
+const newBurst = simulateNewModel(20, 3, 10);
+console.log(`  Old model (burst 20pkt/s×3hops, 10s): peak ${oldBurst} concurrent timers`);
+console.log(`  New model (burst 20pkt/s×3hops, 10s): peak ${newBurst} concurrent animations`);
+assert(oldBurst > 200, `old model under burst >200 timers (got ${oldBurst})`);
+assert(newBurst <= 20, `new model under burst stays ≤20 (got ${newBurst})`);
+
+console.log('\n=== drawAnimatedLine frame-drop catch-up ===');
+
+// Read the source and verify catch-up logic exists
+const fs = require('fs');
+const src = fs.readFileSync(__dirname + '/public/live.js', 'utf8');
+
+// Extract the animateLine function body
+const lineMatch = src.match(/function animateLine\(now\)\s*\{[\s\S]*?requestAnimationFrame\(animateLine\)/);
+assert(lineMatch && /Math\.min\(Math\.floor\(elapsed\s*\/\s*33\)/.test(lineMatch[0]),
+  'drawAnimatedLine catches up on frame drops (multi-tick per frame)');
+
+const fadeMatch = src.match(/function animateFade\(now\)\s*\{[\s\S]*?requestAnimationFrame\(animateFade\)/);
+assert(fadeMatch && /Math\.min\(Math\.floor\(fadeElapsed\s*\/\s*52\)/.test(fadeMatch[0]),
+  'animateFade catches up on frame drops (multi-tick per frame)');
+
+console.log(`\n${passed} passed, ${failed} failed\n`);
+process.exit(failed ? 1 : 0);

test-channel-add-ux.js

@@ -0,0 +1,64 @@
+/**
+ * Tests for #759 — Add channel UX: button, hint, status feedback.
+ * Validates the HTML structure rendered by channels.js init.
+ */
+'use strict';
+
+const fs = require('fs');
+
+let passed = 0;
+let failed = 0;
+
+function assert(cond, msg) {
+  if (cond) { passed++; console.log('  ✓ ' + msg); }
+  else { failed++; console.error('  ✗ ' + msg); }
+}
+
+function assertIncludes(html, substr, msg) {
+  assert(html.includes(substr), msg);
+}
+
+// Read the channels.js source to extract the HTML template
+const src = fs.readFileSync(__dirname + '/public/channels.js', 'utf8');
+
+// Extract the sidebar HTML from the template literal
+const htmlMatch = src.match(/app\.innerHTML\s*=\s*`([\s\S]*?)`;/);
+const html = htmlMatch ? htmlMatch[1] : '';
+
+console.log('Test: Add channel UX (#759)');
+
+// 1. Button renders in the form
+assertIncludes(html, 'class="ch-add-btn"', 'Add button has ch-add-btn class');
+assertIncludes(html, 'type="submit"', 'Button is type=submit');
+assertIncludes(html, '>+</button>', 'Button shows + text');
+
+// 2. Form has proper structure
+assertIncludes(html, 'class="ch-add-form"', 'Form has ch-add-form class');
+assertIncludes(html, 'class="ch-add-row"', 'Row wrapper present');
+assert(!html.includes('class="ch-add-label"'), 'Label removed (redundant with hint)');
+
+// 3. Hint text present
+assertIncludes(html, 'class="ch-add-hint"', 'Hint div present');
+assertIncludes(html, 'e.g. #LongFast or 32-char hex key', 'Hint text correct');
+
+// 4. Status div present
+assertIncludes(html, 'id="chAddStatus"', 'Status div has correct id');
+assertIncludes(html, 'class="ch-add-status"', 'Status div has correct class');
+assertIncludes(html, 'style="display:none"', 'Status div hidden by default');
+
+// 5. showAddStatus function exists in source
+assert(src.includes('function showAddStatus('), 'showAddStatus function defined');
+assert(src.includes("'success'"), 'Success status type referenced');
+assert(src.includes("'error'"), 'Error status type referenced');
+
+// 6. CSS classes exist
+const css = fs.readFileSync(__dirname + '/public/style.css', 'utf8');
+assert(css.includes('.ch-add-form'), 'CSS: .ch-add-form defined');
+assert(css.includes('.ch-add-btn'), 'CSS: .ch-add-btn defined');
+assert(css.includes('.ch-add-hint'), 'CSS: .ch-add-hint defined');
+assert(css.includes('.ch-add-status'), 'CSS: .ch-add-status defined');
+assert(css.includes('.ch-add-row'), 'CSS: .ch-add-row defined');
+// .ch-add-label CSS kept for backward compat but label removed from HTML
+
+console.log('\n' + passed + ' passed, ' + failed + ' failed');
+process.exit(failed > 0 ? 1 : 0);

test-e2e-playwright.js

@@ -15,11 +15,6 @@ async function test(name, fn) {
     results.push({ name, pass: true });
     console.log(`  \u2705 ${name}`);
   } catch (err) {
-    if (err.skip) {
-      results.push({ name, pass: true, skipped: true });
-      console.log(`  ⏭ ${name}: ${err.message}`);
-      return;
-    }
     results.push({ name, pass: false, error: err.message });
     console.log(`  \u274c ${name}: ${err.message}`);
     console.log(`\nFail-fast: stopping after first failure.`);
@@ -224,7 +219,10 @@ async function run() {
   // Test 5: Node detail loads (reuses nodes page from test 2)
   await test('Node detail loads', async () => {
     await page.waitForSelector('table tbody tr');
-    await page.click('table tbody tr');
+    // Click first row
+    const firstRow = await page.$('table tbody tr');
+    assert(firstRow, 'No node rows found');
+    await firstRow.click();
     // Wait for detail pane to appear
     await page.waitForSelector('.node-detail');
     const html = await page.content();
@@ -233,25 +231,24 @@ async function run() {
     assert(hasStatus, 'No status indicator found in node detail');
   });
 
-  // Test: Node side panel Details link navigates to full detail page (#778)
-  await test('Node side panel Details link navigates', async () => {
+  // Test: Node side panel Details link opens full-screen detail view (#778)
+  await test('Node side panel Details link opens full detail', async () => {
     await page.goto(`${BASE}/#/nodes`, { waitUntil: 'domcontentloaded' });
     await page.waitForSelector('table tbody tr');
-    await page.click('table tbody tr');
+    // Click first row to open side panel
+    const firstRow = await page.$('table tbody tr');
+    assert(firstRow, 'No node rows found');
+    await firstRow.click();
     await page.waitForSelector('.node-detail');
     // Find the Details link in the side panel
-    await page.waitForSelector('#nodesRight a.btn-primary[href^="#/nodes/"]');
-    const href = await page.$eval('#nodesRight a.btn-primary[href^="#/nodes/"]', el => el.getAttribute('href'));
-    assert(href, 'Details link not found in side panel');
-    // Click the Details link — this should navigate to the full detail page
-    await page.click('#nodesRight a.btn-primary[href^="#/nodes/"]');
-    // Wait for navigation — the full detail page has sections like neighbors/packets
-    await page.waitForFunction((expectedHash) => {
-      return location.hash === expectedHash;
-    }, href, { timeout: 5000 });
-    // Verify we're on the full detail page (should have section tabs or detail content)
-    const hash = await page.evaluate(() => location.hash);
-    assert(hash === href, `Expected hash "${href}" but got "${hash}"`);
+    const detailsLink = await page.$('#nodesRight a.btn-primary[href^="#/nodes/"]');
+    assert(detailsLink, 'Details link not found in side panel');
+    // Click the Details link — should open full-screen node detail view
+    await detailsLink.click();
+    // Wait for the full-screen node detail view to render
+    await page.waitForSelector('.node-fullscreen', { timeout: 5000 });
+    const hasFullBody = await page.$('.node-full-body');
+    assert(hasFullBody, 'Full-screen node detail body not found');
   });
 
   // Test: Nodes page has WebSocket auto-update listener (#131)
@@ -657,8 +654,6 @@ async function run() {
     await page.waitForSelector('#ngCanvas', { timeout: 8000 });
     const hasCanvas = await page.$('#ngCanvas');
     assert(hasCanvas, 'Neighbor Graph tab should have a canvas element');
-    // Stats are populated after the async API call — wait for at least one card before counting
-    await page.waitForSelector('#ngStats .stat-card', { timeout: 8000 });
     const hasStats = await page.$$eval('#ngStats .stat-card', els => els.length);
     assert(hasStats >= 3, `Neighbor Graph stats should have >=3 cards, got ${hasStats}`);
     // Verify filters exist
@@ -1354,38 +1349,6 @@ async function run() {
     await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
   });
 
-  await test('Customizer v2: typing in text field does not collapse focus (re-render guard)', async () => {
-    await page.goto(BASE, { waitUntil: 'domcontentloaded' });
-    await page.waitForSelector('nav, .navbar, .nav, [class*="nav"]');
-    await page.waitForFunction(() => window._customizerV2 && window._customizerV2.initDone, { timeout: 5000 });
-    const toggleSel = '#customizeToggle, button[title*="ustom" i], [class*="customize"]';
-    const btn = await page.$(toggleSel);
-    if (!btn) { console.log('    ⏭️  Customizer toggle not found'); return; }
-    await btn.click();
-    await page.waitForSelector('.cust-overlay', { timeout: 5000 });
-    const result = await page.evaluate(() => {
-      const input = document.querySelector('.cust-overlay input[type="text"][data-cv2-field]');
-      if (!input) return { skipped: true };
-      input.focus();
-      input.value = 'test';
-      input.dispatchEvent(new Event('input', { bubbles: true }));
-      const inputRef = input;
-      return new Promise(resolve => {
-        setTimeout(() => {
-          const panel = document.querySelector('.cust-overlay');
-          resolve({
-            inputConnected: inputRef.isConnected,
-            focusInPanel: panel ? panel.contains(document.activeElement) : false,
-          });
-        }, 500);
-      });
-    });
-    if (result.skipped) { console.log('    ⏭️  No text input with data-cv2-field found in panel'); return; }
-    assert(result.inputConnected, 'Input element should remain connected to DOM after debounce fires');
-    assert(result.focusInPanel, 'Focus should remain inside panel after debounce — re-render must not run while typing');
-    await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
-  });
-
 
   await test('Show Neighbors populates neighborPubkeys from affinity API', async () => {
     const testPubkey = 'aabbccdd11223344556677889900aabbccddeeff00112233445566778899001122';
@@ -1541,9 +1504,7 @@ async function run() {
     const pubkey = await page.$eval('#nodesBody tr[data-key]', el => el.dataset.key);
     // Use evaluate to change hash (reliable same-document navigation)
     await page.evaluate((pk) => { location.hash = '#/nodes/' + pk; }, pubkey);
-    // Wait for the full-node view to render (async API fetch populates body)
-    await page.waitForSelector('.node-fullscreen', { timeout: 10000 });
-    await page.waitForSelector('#node-neighbors', { timeout: 25000 });
+    await page.waitForSelector('#node-neighbors', { timeout: 15000 });
     // Check the section exists
     const header = await page.$eval('#fullNeighborsHeader', el => el.textContent);
     assert(header.startsWith('Neighbors'), 'Header should start with "Neighbors", got: ' + header);
@@ -1734,18 +1695,18 @@ async function run() {
     assert(!url.includes('node-fullscreen') || await page.$('#nodesRight:not(.empty)'), 'Split panel should be visible on desktop');
   });
 
-  // Test: loading #/nodes/{pubkey} on desktop opens full-screen detail view (#823)
-  // Updated from #676's earlier "split panel on desktop" assertion. The Details
-  // link now opens the full-screen single-node view on desktop too — see PR #824.
-  await test('Desktop: deep link #/nodes/{pubkey} opens full-screen detail view', async () => {
+  // Test: loading #/nodes/{pubkey} on desktop shows split panel (#676)
+  await test('Desktop: deep link #/nodes/{pubkey} opens split panel, not full-screen', async () => {
     await page.setViewportSize({ width: 1280, height: 800 });
     await page.goto(BASE + '#/nodes', { waitUntil: 'domcontentloaded' });
     await page.waitForSelector('#nodesBody tr[data-key]', { timeout: 10000 });
     const pubkey = await page.$eval('#nodesBody tr[data-key]', el => el.dataset.key);
     await page.goto(BASE + '#/nodes/' + encodeURIComponent(pubkey), { waitUntil: 'domcontentloaded' });
     await page.waitForTimeout(500);
+    const hasSplitPanel = await page.$('#nodesRight:not(.empty)');
     const hasFullScreen = await page.$('.node-fullscreen');
-    assert(hasFullScreen, 'Full-screen detail view should be open on desktop deep link (#823)');
+    assert(hasSplitPanel, 'Split panel should be open on desktop deep link');
+    assert(!hasFullScreen, 'Full-screen view should NOT appear on desktop deep link');
   });
 
   // Test: packets timeWindow deep link
@@ -1811,343 +1772,12 @@ async function run() {
     }
   });
 
-  // Test: Expanded group children have unique observation ids (#866)
-  await test('Expanded group children update detail pane per-observation', async () => {
-    await page.goto(`${BASE}/#/packets`, { waitUntil: 'domcontentloaded' });
-    // Ensure grouped mode and wide time window
-    await page.evaluate(() => {
-      localStorage.setItem('meshcore-time-window', '525600');
-      localStorage.setItem('meshcore-groupbyhash', 'true');
-    });
-    await page.reload({ waitUntil: 'load' });
-    await page.waitForSelector('table tbody tr', { timeout: 15000 });
-
-    // Find a group row with observation_count > 1 (has expand button)
-    const expandBtn = await page.$('table tbody tr .expand-btn, table tbody tr [data-expand]');
-    if (!expandBtn) {
-      console.log('    ℹ️  No expandable groups found — skipping child assertion');
-      return;
-    }
-
-    // Click expand and wait for the /packets/<hash> detail API call
-    const [detailResp] = await Promise.all([
-      page.waitForResponse(resp => {
-        const u = new URL(resp.url(), BASE);
-        // Match /api/packets/<hash> but not /api/packets?... or /api/packets/observations
-        return /\/api\/packets\/[A-Fa-f0-9]+$/.test(u.pathname) && resp.status() === 200;
-      }, { timeout: 15000 }),
-      expandBtn.click(),
-    ]);
-    assert(detailResp, 'Expected /api/packets/<hash> response on expand');
-
-    // Wait for child rows to appear
-    await page.waitForSelector('table tbody tr.child-row, table tbody tr[class*="child"]', { timeout: 5000 });
-    const childRows = await page.$$('table tbody tr.child-row, table tbody tr[class*="child"]');
-    if (childRows.length < 2) {
-      console.log('    ℹ️  Group has < 2 children — skipping per-observation assertion');
-      return;
-    }
-
-    // Click first child row
-    await childRows[0].click();
-    await page.waitForFunction(() => {
-      const panel = document.getElementById('pktRight');
-      return panel && !panel.classList.contains('empty') && panel.textContent.trim().length > 0;
-    }, { timeout: 10000 });
-    const content1 = await page.$eval('#pktRight', el => el.textContent.trim());
-    const url1 = page.url();
-
-    // Click second child row
-    await childRows[1].click();
-    await page.waitForTimeout(500);
-    const content2 = await page.$eval('#pktRight', el => el.textContent.trim());
-    const url2 = page.url();
-
-    // URL should contain ?obs= with a real observation id
-    assert(url1.includes('obs=') || url2.includes('obs='), `URL should contain obs= parameter, got: ${url1}`);
-
-    // The two children should show different detail pane content (different observers)
-    // At minimum, the URL obs= values should differ
-    if (url1.includes('obs=') && url2.includes('obs=')) {
-      const obs1 = new URL(url1).hash.match(/obs=(\d+)/)?.[1];
-      const obs2 = new URL(url2).hash.match(/obs=(\d+)/)?.[1];
-      if (obs1 && obs2) {
-        assert(obs1 !== obs2, `Two children should have different obs ids, both got obs=${obs1}`);
-      }
-    }
-
-    // Verify obs id is NOT the aggregate packet id (the bug from #866)
-    const obsMatch = url2.match(/obs=(\d+)/);
-    if (obsMatch) {
-      const detailJson = await detailResp.json().catch(() => null);
-      if (detailJson?.packet?.id) {
-        const aggId = String(detailJson.packet.id);
-        // At least one child obs id should differ from the aggregate packet id
-        const obs1 = url1.match(/obs=(\d+)/)?.[1];
-        const obs2 = url2.match(/obs=(\d+)/)?.[1];
-        const allSameAsAgg = obs1 === aggId && obs2 === aggId;
-        assert(!allSameAsAgg, `Child obs ids should not all equal aggregate packet.id (${aggId})`);
-      }
-    }
-  });
-
-  // Test: per-observation raw_hex — hex pane updates when switching observations (#881)
-  await test('Packet detail hex pane updates per observation', async () => {
-    await page.goto(BASE + '#/packets', { waitUntil: 'domcontentloaded' });
-    await page.waitForSelector('table tbody tr', { timeout: 15000 });
-    await page.waitForTimeout(500);
-
-    // Try clicking packet rows to find one with multiple observations
-    const rows = await page.$$('table tbody tr[data-action]');
-    let obsRows = [];
-    for (let i = 0; i < Math.min(rows.length, 10); i++) {
-      await rows[i].click({ timeout: 3000 }).catch(() => null);
-      await page.waitForTimeout(600);
-      obsRows = await page.$$('.detail-obs-row');
-      if (obsRows.length >= 2) break;
-    }
-
-    if (obsRows.length < 2) {
-      console.log('    ⏭ Skipped: no packet with ≥2 observations found in first 10 rows');
-      return;
-    }
-
-    // Click first observation, capture hex dump
-    await obsRows[0].click({ timeout: 5000 });
-    await page.waitForTimeout(500);
-    const hex1 = await page.$eval('.hex-dump', el => el.textContent).catch(() => '');
-
-    // Click second observation, capture hex dump
-    await obsRows[1].click({ timeout: 5000 });
-    await page.waitForTimeout(500);
-    const hex2 = await page.$eval('.hex-dump', el => el.textContent).catch(() => '');
-
-    // If both have content and differ, the feature works
-    if (hex1 && hex2 && hex1 !== hex2) {
-      console.log('    ✓ Hex pane content differs between observations');
-    } else if (hex1 && hex2 && hex1 === hex2) {
-      console.log('    ⏭ Hex same for both observations (likely historical NULL raw_hex — OK)');
-    } else {
-      console.log('    ⏭ Could not capture hex content from both observations');
-    }
-  });
-
-  // Test: path pill (top) and byte breakdown (bottom) agree on hop count
-  // Regression for visual mismatch where badge said "1 hop" but path text listed N names
-  await test('Packet detail path pill and byte breakdown agree on hop count', async () => {
-    await page.goto(BASE + '#/packets', { waitUntil: 'domcontentloaded' });
-    await page.waitForSelector('table tbody tr', { timeout: 15000 });
-    await page.waitForTimeout(500);
-
-    // Click rows until we find one whose detail pane renders a multi-hop path
-    const rows = await page.$$('table tbody tr[data-action]');
-    let found = false;
-    for (let i = 0; i < Math.min(rows.length, 15); i++) {
-      await rows[i].click({ timeout: 3000 }).catch(() => null);
-      await page.waitForTimeout(500);
-
-      const result = await page.evaluate(() => {
-        // Path pill: <dt>Path</dt><dd><span class="badge ...">N hops</span> ...names...</dd>
-        const dts = document.querySelectorAll('dl.detail-meta dt');
-        let pillBadgeCount = null;
-        let pillNameCount = null;
-        for (const dt of dts) {
-          if (dt.textContent.trim() === 'Path') {
-            const dd = dt.nextElementSibling;
-            if (!dd) break;
-            const badge = dd.querySelector('.badge');
-            if (badge) {
-              const m = badge.textContent.match(/(\d+)\s*hop/);
-              if (m) pillBadgeCount = parseInt(m[1], 10);
-            }
-            // Count rendered hop links/spans (HopDisplay.renderHop output)
-            const hops = dd.querySelectorAll('.hop-link, [data-hop-link], .hop-named, .hop-anonymous');
-            pillNameCount = hops.length;
-            break;
-          }
-        }
-        // Byte breakdown: section row "Path (N hops)" + N "Hop X — ..." rows
-        let breakdownSectionCount = null;
-        let breakdownRowCount = 0;
-        const fieldTable = document.querySelector('table.field-table');
-        if (fieldTable) {
-          for (const tr of fieldTable.querySelectorAll('tr')) {
-            const txt = tr.textContent.trim();
-            const sec = txt.match(/^Path\s*\((\d+)\s*hops?\)/);
-            if (sec) breakdownSectionCount = parseInt(sec[1], 10);
-            if (/^\s*\d+\s*Hop\s+\d+\s*—/.test(txt) || /^Hop\s+\d+\s*—/.test(txt.replace(/^\d+/, '').trim())) {
-              breakdownRowCount++;
-            }
-          }
-        }
-        return { pillBadgeCount, pillNameCount, breakdownSectionCount, breakdownRowCount };
-      });
-
-      if (result.pillBadgeCount && result.pillBadgeCount > 0 && result.breakdownSectionCount != null) {
-        found = true;
-        // Top badge count must equal bottom section count
-        assert(result.pillBadgeCount === result.breakdownSectionCount,
-          `Path pill badge says ${result.pillBadgeCount} hops but byte breakdown says ${result.breakdownSectionCount} hops`);
-        // Number of rendered hop names in pill should also match (within 1, since renderPath may add separators)
-        if (result.pillNameCount != null && result.pillNameCount > 0) {
-          assert(Math.abs(result.pillNameCount - result.pillBadgeCount) <= 1,
-            `Path pill badge ${result.pillBadgeCount} but rendered ${result.pillNameCount} hop names`);
-        }
-        // And breakdown rendered rows should match its own section count
-        assert(result.breakdownRowCount > 0,
-          'breakdown rows selector matched nothing — selector or DOM changed');
-        assert(result.breakdownRowCount === result.breakdownSectionCount,
-          `Byte breakdown section says ${result.breakdownSectionCount} hops but rendered ${result.breakdownRowCount} hop rows`);
-        console.log(`    ✓ Path pill (${result.pillBadgeCount}) and byte breakdown (${result.breakdownSectionCount}) agree`);
-        break;
-      }
-    }
-    if (!found) {
-      if (process.env.E2E_REQUIRE_PATH_TEST === '1') {
-        throw new Error('BLOCKED — no multi-hop packet found in first 15 rows (E2E_REQUIRE_PATH_TEST=1 requires it)');
-      }
-      const skipErr = new Error('SKIP: No multi-hop packet with byte breakdown found in first 15 rows — needs fixture');
-      skipErr.skip = true;
-      throw skipErr;
-    }
-  });
-
-  // Test: hex-strip color spans match the labeled byte rows (per-obs raw_hex).
-  // Regression #891: server-supplied breakdown was computed once from top-level
-  // raw_hex, so per-observation rendering had off-by-N highlights vs the labels.
-  await test('Packet detail hex strip Path range matches hop row count', async () => {
-    await page.goto(BASE + '#/packets', { waitUntil: 'domcontentloaded' });
-    await page.waitForSelector('table tbody tr', { timeout: 15000 });
-    await page.waitForTimeout(500);
-
-    const rows = await page.$$('table tbody tr[data-action]');
-    let checked = 0;
-    for (let i = 0; i < Math.min(rows.length, 25) && checked < 3; i++) {
-      await rows[i].click({ timeout: 3000 }).catch(() => null);
-      await page.waitForTimeout(400);
-
-      const result = await page.evaluate(() => {
-        const dump = document.querySelector('.hex-dump');
-        const fieldTable = document.querySelector('table.field-table');
-        if (!dump || !fieldTable) return null;
-        const pathSpan = dump.querySelector('span.hex-byte.hex-path');
-        const pathBytes = pathSpan ? pathSpan.textContent.trim().split(/\s+/).filter(Boolean).length : 0;
-        const hopRows = [];
-        for (const tr of fieldTable.querySelectorAll('tr')) {
-          const cells = [...tr.cells].map(c => c.textContent.trim());
-          if (cells.length >= 2 && /^Hop\s+\d+/.test(cells[1])) hopRows.push(cells[2]);
-        }
-        return { pathBytes, hopRows };
-      });
-
-      if (!result || (result.pathBytes === 0 && result.hopRows.length === 0)) continue;
-      checked++;
-      // Either both zero, or the count of bytes inside hex-path == hop rows.
-      // (For multi-byte hash sizes this is bytes-per-hop * hops; for hash_size=1 it's just hops.)
-      // The simpler invariant: if there are hop rows, hex-path span must exist and have at least
-      // as many bytes as there are hops (== exactly hops * hash_size).
-      assert(result.hopRows.length > 0,
-        `row ${i}: hex-path span has ${result.pathBytes} bytes but no hop rows in the labeled table`);
-      assert(result.pathBytes >= result.hopRows.length,
-        `row ${i}: hex-path has ${result.pathBytes} bytes but ${result.hopRows.length} hop rows — strip and labels disagree`);
-      assert(result.pathBytes % result.hopRows.length === 0,
-        `row ${i}: hex-path has ${result.pathBytes} bytes but ${result.hopRows.length} hop rows — bytes/hops not divisible (hash_size violated)`);
-      console.log(`    ✓ row ${i}: hex-path ${result.pathBytes} bytes / ${result.hopRows.length} hop rows (hash_size=${result.pathBytes / result.hopRows.length})`);
-    }
-    if (checked === 0) {
-      const skipErr = new Error('SKIP: no packet with rendered hex strip + hop rows found in first 25 rows');
-      skipErr.skip = true;
-      throw skipErr;
-    }
-  });
-
-  // Test: clicking a different observation row re-renders strip + breakdown consistently.
-  // Regression: observations of the same packet hash have different raw_hex (#882),
-  // so picking a different obs must recompute the byte ranges, not reuse the old ones.
-  await test('Packet detail switches consistently across observations', async () => {
-    await page.goto(BASE + '#/packets?groupByHash=1', { waitUntil: 'domcontentloaded' });
-    await page.waitForSelector('table tbody tr', { timeout: 15000 });
-    await page.waitForTimeout(500);
-
-    let opened = false;
-    const groupRows = await page.$$('table tbody tr[data-action]');
-    for (let i = 0; i < Math.min(groupRows.length, 10); i++) {
-      await groupRows[i].click({ timeout: 3000 }).catch(() => null);
-      await page.waitForTimeout(400);
-      const obsCount = await page.evaluate(() => {
-        return document.querySelectorAll('table.observations-table tbody tr, .obs-row').length;
-      });
-      if (obsCount >= 2) { opened = true; break; }
-    }
-    if (!opened) {
-      const skipErr = new Error('SKIP: no multi-observation packet found in first 10 group rows');
-      skipErr.skip = true;
-      throw skipErr;
-    }
-
-    async function snapshot() {
-      return page.evaluate(() => {
-        const dump = document.querySelector('.hex-dump');
-        const fieldTable = document.querySelector('table.field-table');
-        if (!dump || !fieldTable) return null;
-        const pathSpan = dump.querySelector('span.hex-byte.hex-path');
-        const pathBytes = pathSpan ? pathSpan.textContent.trim().split(/\s+/).filter(Boolean).length : 0;
-        const hopRows = [];
-        for (const tr of fieldTable.querySelectorAll('tr')) {
-          const cells = [...tr.cells].map(c => c.textContent.trim());
-          if (cells.length >= 2 && /^Hop\s+\d+/.test(cells[1])) hopRows.push(cells[2]);
-        }
-        const rawHexParts = [...dump.querySelectorAll('span.hex-byte')].map(s => s.textContent.trim());
-        return { pathBytes, hopCount: hopRows.length, rawHexJoined: rawHexParts.join('|') };
-      });
-    }
-
-    const snapA = await snapshot();
-    assert(snapA, 'first snapshot must have hex dump + field table');
-    assert(snapA.hopCount === 0 || snapA.pathBytes >= snapA.hopCount,
-      `obs A inconsistent: hex-path ${snapA.pathBytes} bytes vs ${snapA.hopCount} hop rows`);
-
-    const switched = await page.evaluate(() => {
-      const obsRows = [...document.querySelectorAll('table.observations-table tbody tr, .obs-row')];
-      if (obsRows.length < 2) return false;
-      obsRows[1].click();
-      return true;
-    });
-    assert(switched, 'should click second observation row');
-    await page.waitForTimeout(500);
-
-    const snapB = await snapshot();
-    assert(snapB, 'second snapshot must have hex dump + field table');
-    assert(snapB.hopCount === 0 || snapB.pathBytes >= snapB.hopCount,
-      `obs B inconsistent: hex-path ${snapB.pathBytes} bytes vs ${snapB.hopCount} hop rows`);
-    console.log(`    ✓ obs A: ${snapA.pathBytes} path bytes / ${snapA.hopCount} hops; obs B: ${snapB.pathBytes} / ${snapB.hopCount}`);
-  });
-
-  // Test: clicking the 🔍 Details button in the nodes side panel navigates to
-  // the full-screen node detail view. Regression: hash already === target,
-  // so location.hash assignment was a no-op and the panel stayed open.
-  await test('Nodes side panel Details button opens full-screen view', async () => {
-    await page.goto(BASE + '#/nodes', { waitUntil: 'domcontentloaded' });
-    await page.waitForSelector('table tbody tr[data-action]', { timeout: 15000 });
-    await page.waitForTimeout(500);
-    // Open side panel
-    await page.click('table tbody tr[data-action]');
-    await page.waitForSelector('#nodesRight .node-detail-btn', { timeout: 5000 });
-    // Click Details
-    await page.click('#nodesRight .node-detail-btn');
-    // Wait for full-screen view to appear
-    await page.waitForSelector('.node-fullscreen', { timeout: 5000 });
-    const isFullScreen = await page.evaluate(() => !!document.querySelector('.node-fullscreen'));
-    assert(isFullScreen, 'Details button should open full-screen node view');
-  });
-
   await browser.close();
 
   // Summary
-  const skipped = results.filter(r => r.skipped).length;
-  const passed = results.filter(r => r.pass && !r.skipped).length;
+  const passed = results.filter(r => r.pass).length;
   const failed = results.filter(r => !r.pass).length;
-  console.log(`\n${passed}/${results.length} tests passed${skipped ? `, ${skipped} skipped` : ''}${failed ? `, ${failed} failed` : ''}`);
+  console.log(`\n${passed}/${results.length} tests passed${failed ? `, ${failed} failed` : ''}`);
   process.exit(failed > 0 ? 1 : 0);
 }
 

test-frontend-helpers.js

@@ -222,10 +222,6 @@ console.log('\n=== app.js: routeTypeName / payloadTypeName ===');
   test('payloadTypeName(4) = Advert', () => assert.strictEqual(ctx.payloadTypeName(4), 'Advert'));
   test('payloadTypeName(2) = Direct Msg', () => assert.strictEqual(ctx.payloadTypeName(2), 'Direct Msg'));
   test('payloadTypeName(99) = UNKNOWN', () => assert.strictEqual(ctx.payloadTypeName(99), 'UNKNOWN'));
-  test('getPathLenOffset: transport route (0) → 5', () => assert.strictEqual(ctx.getPathLenOffset(0), 5));
-  test('getPathLenOffset: transport route (3) → 5', () => assert.strictEqual(ctx.getPathLenOffset(3), 5));
-  test('getPathLenOffset: flood route (1) → 1', () => assert.strictEqual(ctx.getPathLenOffset(1), 1));
-  test('getPathLenOffset: direct route (2) → 1', () => assert.strictEqual(ctx.getPathLenOffset(2), 1));
 }
 
 console.log('\n=== app.js: truncate ===');
@@ -690,88 +686,6 @@ console.log('\n=== haversineKm (hop-resolver.js) ===');
   });
 }
 
-// ===== pickByAffinity — neighbor-graph + centroid scoring (#874) =====
-console.log('\n=== pickByAffinity neighbor-graph scoring (#874) ===');
-{
-  const ctx = makeSandbox();
-  ctx.IATA_COORDS_GEO = {};
-  loadInCtx(ctx, 'public/hop-resolver.js');
-  const HR = ctx.window.HopResolver;
-
-  // Two nodes sharing prefix "ab", hundreds of km apart.
-  // NodeSF is near San Francisco, NodeDEN is near Denver.
-  const nodeSF = { public_key: 'ab11111111111111', name: 'NodeSF', lat: 37.7, lon: -122.4 };
-  const nodeDEN = { public_key: 'ab22222222222222', name: 'NodeDEN', lat: 39.7, lon: -104.9 };
-  // A known neighbor of NodeSF (in the graph)
-  const nodeNeighbor = { public_key: 'cc33333333333333', name: 'SFNeighbor', lat: 37.8, lon: -122.3 };
-  // Another known node near Denver
-  const nodeDenNeighbor = { public_key: 'dd44444444444444', name: 'DENNeighbor', lat: 39.8, lon: -105.0 };
-
-  test('#874: graph edge scoring picks correct regional candidate (SF)', () => {
-    HR.init([nodeSF, nodeDEN, nodeNeighbor, nodeDenNeighbor]);
-    HR.setAffinity({ edges: [
-      { source: 'cc33333333333333', target: 'ab11111111111111', weight: 5 },
-      { source: 'dd44444444444444', target: 'ab22222222222222', weight: 5 },
-    ]});
-    // Path: SFNeighbor → [ab??] → DENNeighbor
-    // With graph edges, ab11 (NodeSF) has edge to SFNeighbor, ab22 (NodeDEN) has edge to DENNeighbor
-    // Prev=SFNeighbor, Next=DENNeighbor → both have score 5, but SFNeighbor edge only to ab11
-    const result = HR.resolve(['cc', 'ab', 'dd'],
-      null, null, null, null);
-    assert.strictEqual(result['ab'].name, 'NodeSF',
-      'Should pick NodeSF because it has a graph edge to prev hop SFNeighbor');
-  });
-
-  test('#874: graph edge scoring — next hop breaks tie', () => {
-    HR.init([nodeSF, nodeDEN, nodeNeighbor, nodeDenNeighbor]);
-    HR.setAffinity({ edges: [
-      { source: 'dd44444444444444', target: 'ab22222222222222', weight: 8 },
-      // No edge from SFNeighbor to either ab node
-    ]});
-    // Path: SFNeighbor → [ab??] → DENNeighbor
-    // Only ab22 (NodeDEN) has edge to DENNeighbor (next hop)
-    const result = HR.resolve(['cc', 'ab', 'dd'],
-      null, null, null, null);
-    assert.strictEqual(result['ab'].name, 'NodeDEN',
-      'Should pick NodeDEN because it has graph edge to next hop DENNeighbor');
-  });
-
-  test('#874: centroid fallback when no graph edges exist', () => {
-    HR.init([nodeSF, nodeDEN, nodeNeighbor]);
-    HR.setAffinity({ edges: [] }); // no edges at all
-    // Path: SFNeighbor → [ab??]
-    // SFNeighbor is at (37.8, -122.3), centroid is just that point
-    // NodeSF (37.7, -122.4) is ~14km away, NodeDEN (39.7, -104.9) is ~1500km away
-    const result = HR.resolve(['cc', 'ab'],
-      null, null, null, null);
-    assert.strictEqual(result['ab'].name, 'NodeSF',
-      'Should pick NodeSF via centroid proximity to SFNeighbor');
-  });
-
-  test('#874: centroid uses average of prev+next positions', () => {
-    // Prev near SF, next near Denver → centroid is midpoint (~Nevada)
-    // NodeDEN is closer to Nevada midpoint than NodeSF
-    const nodeMid = { public_key: 'ee55555555555555', name: 'MidNode', lat: 38.5, lon: -114.0 };
-    HR.init([nodeSF, nodeDEN, nodeNeighbor, nodeDenNeighbor, nodeMid]);
-    HR.setAffinity({ edges: [] });
-    // Path: SFNeighbor → [ab??] → DENNeighbor
-    // centroid = avg(37.8,-122.3, 39.8,-105.0) = (38.8, -113.65) — closer to Denver
-    const result = HR.resolve(['cc', 'ab', 'dd'],
-      null, null, null, null);
-    assert.strictEqual(result['ab'].name, 'NodeDEN',
-      'Should pick NodeDEN because centroid of SF+Denver neighbors is closer to Denver');
-  });
-
-  test('#874: fallback when no context at all', () => {
-    HR.init([nodeSF, nodeDEN]);
-    HR.setAffinity({ edges: [] });
-    // Single ambiguous hop, no origin/observer, no neighbors
-    const result = HR.resolve(['ab'], null, null, null, null);
-    assert.ok(result['ab'].ambiguous || result['ab'].name != null,
-      'Should resolve to some candidate without crashing');
-  });
-}
-
 // ===== SNR/RSSI Number casting =====
 {
   // These test the pattern used in observer-detail.js, home.js, traces.js, live.js
@@ -1804,128 +1718,6 @@ console.log('\n=== app.js: formatEngineBadge ===');
   });
 }
 
-// ===== APP.JS: computeBreakdownRanges =====
-console.log('\n=== app.js: computeBreakdownRanges ===');
-{
-  const ctx = makeSandbox();
-  loadInCtx(ctx, 'public/roles.js');
-  loadInCtx(ctx, 'public/app.js');
-  const computeBreakdownRanges = ctx.computeBreakdownRanges;
-
-  function findRange(ranges, label) {
-    return ranges.find(r => r.label === label);
-  }
-
-  test('returns [] for empty hex', () => {
-    assert.deepEqual(computeBreakdownRanges('', 1, 5), []);
-  });
-
-  test('returns [] for too-short hex (< 2 bytes)', () => {
-    assert.deepEqual(computeBreakdownRanges('15', 1, 5), []);
-  });
-
-  test('FLOOD non-transport: 4-hop hash_size=1', () => {
-    // header=15, plb=04 → hash_size=1, hash_count=4
-    // bytes: 15 04 90 FA F9 10 6E 01 D9
-    const r = computeBreakdownRanges('150490FAF910 6E01D9'.replace(/\s/g,''), 1, 5);
-    assert.deepEqual(findRange(r, 'Header'),      { start: 0, end: 0, label: 'Header' });
-    assert.deepEqual(findRange(r, 'Path Length'), { start: 1, end: 1, label: 'Path Length' });
-    assert.deepEqual(findRange(r, 'Path'),        { start: 2, end: 5, label: 'Path' });
-    assert.deepEqual(findRange(r, 'Payload'),     { start: 6, end: 8, label: 'Payload' });
-    assert.strictEqual(findRange(r, 'Transport Codes'), undefined);
-  });
-
-  test('FLOOD non-transport: 7-hop hash_size=1', () => {
-    // header=15, plb=07
-    const hex = '15077f6d7d1cadeca33988fd95e0851ebf01ea12e1879e';
-    const r = computeBreakdownRanges(hex, 1, 5);
-    assert.deepEqual(findRange(r, 'Path'), { start: 2, end: 8, label: 'Path' });
-    const payload = findRange(r, 'Payload');
-    assert.strictEqual(payload.start, 9, 'payload starts after the 7 path bytes');
-  });
-
-  test('FLOOD non-transport: 8-hop hash_size=1', () => {
-    const hex = '1508' + '11223344556677AA' + 'BBCCDD';
-    const r = computeBreakdownRanges(hex, 1, 5);
-    assert.deepEqual(findRange(r, 'Path'), { start: 2, end: 9, label: 'Path' });
-    assert.deepEqual(findRange(r, 'Payload'), { start: 10, end: 12, label: 'Payload' });
-  });
-
-  test('Direct advert: 0-hop, no Path range', () => {
-    // plb=00 → 0 hops; expect Path Length but NO Path range
-    const r = computeBreakdownRanges('1100AABBCCDD', 1, 4);
-    assert.deepEqual(findRange(r, 'Path Length'), { start: 1, end: 1, label: 'Path Length' });
-    assert.strictEqual(findRange(r, 'Path'), undefined);
-  });
-
-  test('Transport route shifts path-length offset by 4', () => {
-    // route_type=0 (TRANSPORT_FLOOD): bytes 1..4 are Transport Codes
-    // header=14, transport=AABBCCDD, plb=02, hops=11 22, payload=99
-    const hex = '14AABBCCDD021122' + '99';
-    const r = computeBreakdownRanges(hex, 0, 5);
-    assert.deepEqual(findRange(r, 'Transport Codes'), { start: 1, end: 4, label: 'Transport Codes' });
-    assert.deepEqual(findRange(r, 'Path Length'),     { start: 5, end: 5, label: 'Path Length' });
-    assert.deepEqual(findRange(r, 'Path'),            { start: 6, end: 7, label: 'Path' });
-    assert.deepEqual(findRange(r, 'Payload'),         { start: 8, end: 8, label: 'Payload' });
-  });
-
-  test('hash_size=2 (plb top bits=01): 4 hops × 2 bytes', () => {
-    // plb = 01 0001 00 = 0x44 → hash_size=2, hash_count=4 → 8 path bytes
-    const hex = '15' + '44' + 'AABB' + 'CCDD' + 'EEFF' + '1122' + '9988';
-    const r = computeBreakdownRanges(hex, 1, 5);
-    assert.deepEqual(findRange(r, 'Path'), { start: 2, end: 9, label: 'Path' });
-    assert.deepEqual(findRange(r, 'Payload'), { start: 10, end: 11, label: 'Payload' });
-  });
-
-  test('hash_size=3 (plb top bits=10): 2 hops × 3 bytes', () => {
-    // plb = 10 0000 10 = 0x82 → hash_size=3, hash_count=2 → 6 path bytes
-    const hex = '15' + '82' + 'AABBCC' + 'DDEEFF' + '99';
-    const r = computeBreakdownRanges(hex, 1, 5);
-    assert.deepEqual(findRange(r, 'Path'), { start: 2, end: 7, label: 'Path' });
-    assert.deepEqual(findRange(r, 'Payload'), { start: 8, end: 8, label: 'Payload' });
-  });
-
-  test('hash_size=4 (plb top bits=11): 2 hops × 4 bytes', () => {
-    // plb = 11 0000 10 = 0xC2 → hash_size=4, hash_count=2 → 8 path bytes
-    const hex = '15' + 'C2' + 'AABBCCDD' + 'EEFF1122' + '99887766';
-    const r = computeBreakdownRanges(hex, 1, 5);
-    assert.deepEqual(findRange(r, 'Path'), { start: 2, end: 9, label: 'Path' });
-    assert.deepEqual(findRange(r, 'Payload'), { start: 10, end: 13, label: 'Payload' });
-  });
-
-  test('truncated path: not enough bytes → no Path range', () => {
-    // plb=04 says 4 hops but only 2 bytes remain
-    const hex = '1504AABB';
-    const r = computeBreakdownRanges(hex, 1, 5);
-    assert.strictEqual(findRange(r, 'Path'), undefined);
-  });
-
-  test('ADVERT (payload_type=4) with full record: PubKey/Timestamp/Signature/Flags', () => {
-    // header=11, plb=00 (direct advert)
-    // payload: 32 bytes pubkey + 4 bytes ts + 64 bytes sig + 1 byte flags
-    const pubkey = 'AB'.repeat(32);
-    const ts = '11223344';
-    const sig = 'CD'.repeat(64);
-    const flags = '00';
-    const hex = '1100' + pubkey + ts + sig + flags;
-    const r = computeBreakdownRanges(hex, 1, 4);
-    assert.deepEqual(findRange(r, 'PubKey'),    { start: 2,  end: 33,  label: 'PubKey' });
-    assert.deepEqual(findRange(r, 'Timestamp'), { start: 34, end: 37,  label: 'Timestamp' });
-    assert.deepEqual(findRange(r, 'Signature'), { start: 38, end: 101, label: 'Signature' });
-    assert.deepEqual(findRange(r, 'Flags'),     { start: 102, end: 102, label: 'Flags' });
-  });
-
-  test('NaN-safe: malformed path-length byte produces no Path range', () => {
-    // hex with non-hex char in plb position would parseInt-fail → bail
-    // Use a 1-byte payload that makes pathByte parseInt produce NaN-ish via X
-    // (parseInt of 'XY' is NaN). Since fs reads only hex chars, simulate via short hex.
-    // Easier: empty string already returns []; 1-byte returns []. Both covered above.
-    // Use plb=FF (hash_size=4, hash_count=63) too long for input → no Path
-    const r = computeBreakdownRanges('15FF' + 'AA', 1, 5);
-    assert.strictEqual(findRange(r, 'Path'), undefined);
-  });
-}
-
 // ===== APP.JS: isTransportRoute + transportBadge =====
 console.log('\n=== app.js: isTransportRoute + transportBadge ===');
 {
@@ -2908,234 +2700,6 @@ console.log('\n=== channels.js: WS batch + region snapshot integration ===');
     assert.ok(historyCalls.includes('#/channels'), 'should route back to channels root');
   });
 }
-// ===== CHANNELS.JS: #781 encrypted channel without key shows lock message =====
-console.log('\n=== channels.js: encrypted channel without key shows lock message (#781) ===');
-{
-  test('selectChannel shows lock message for encrypted channel with no matching key', async () => {
-    const ctx = makeSandbox();
-    const dom = {};
-    function makeEl(id) {
-      if (dom[id]) return dom[id];
-      dom[id] = {
-        id,
-        innerHTML: '',
-        textContent: '',
-        value: '',
-        scrollTop: 0,
-        scrollHeight: 100,
-        clientHeight: 80,
-        style: {},
-        dataset: {},
-        classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
-        addEventListener() {},
-        removeEventListener() {},
-        querySelector() { return null; },
-        querySelectorAll() { return []; },
-        getBoundingClientRect() { return { left: 0, bottom: 0, width: 0 }; },
-        setAttribute() {},
-        removeAttribute() {},
-        focus() {},
-      };
-      return dom[id];
-    }
-    const headerText = { textContent: '' };
-    makeEl('chHeader').querySelector = (sel) => (sel === '.ch-header-text' ? headerText : null);
-    makeEl('chMessages');
-    makeEl('chList');
-    makeEl('chScrollBtn');
-    makeEl('chAriaLive');
-    makeEl('chBackBtn');
-    makeEl('chRegionFilter');
-    const appEl = {
-      innerHTML: '',
-      querySelector(sel) {
-        if (sel === '.ch-sidebar' || sel === '.ch-sidebar-resize' || sel === '.ch-main') return makeEl(sel);
-        if (sel === '.ch-layout') return { classList: { add() {}, remove() {}, contains() { return false; } } };
-        return makeEl(sel);
-      },
-      addEventListener() {},
-    };
-    let apiCallPaths = [];
-    ctx.document.getElementById = makeEl;
-    ctx.document.querySelector = (sel) => {
-      if (sel === '.ch-layout') return { classList: { add() {}, remove() {}, contains() { return false; } } };
-      return null;
-    };
-    ctx.document.querySelectorAll = () => [];
-    ctx.document.addEventListener = () => {};
-    ctx.document.removeEventListener = () => {};
-    ctx.document.documentElement = { getAttribute: () => null, setAttribute: () => {} };
-    ctx.document.body = { appendChild() {}, removeChild() {}, contains() { return false; } };
-    ctx.history = { replaceState() {} };
-    ctx.matchMedia = () => ({ matches: false });
-    ctx.window.matchMedia = ctx.matchMedia;
-    ctx.MutationObserver = function () { this.observe = () => {}; this.disconnect = () => {}; };
-    ctx.RegionFilter = { init() {}, onChange() { return () => {}; }, offChange() {}, getRegionParam() { return ''; } };
-    ctx.debouncedOnWS = (fn) => fn;
-    ctx.onWS = () => {};
-    ctx.offWS = () => {};
-    ctx.api = (path) => {
-      apiCallPaths.push(path);
-      if (path.indexOf('/observers') === 0) return Promise.resolve({ observers: [] });
-      // Return an encrypted channel in the list
-      if (path.indexOf('/channels') === 0 && path.indexOf('/messages') === -1) {
-        return Promise.resolve({ channels: [
-          { hash: '42', name: 'secret-chan', messageCount: 5, lastActivity: null, encrypted: true }
-        ] });
-      }
-      // This should NOT be called for encrypted channels without a key
-      if (path.indexOf('/messages') !== -1) {
-        return Promise.resolve({ messages: [{ sender: 'X', text: 'gibberish', timestamp: '2025-01-01T00:00:00Z' }] });
-      }
-      return Promise.resolve({});
-    };
-    ctx.CLIENT_TTL = { observers: 120000, channels: 15000, channelMessages: 10000, nodeDetail: 10000 };
-    ctx.ROLE_EMOJI = {};
-    ctx.ROLE_LABELS = {};
-    ctx.timeAgo = () => '1m ago';
-    ctx.registerPage = (name, handlers) => { ctx._pageHandlers = handlers; };
-    ctx.btoa = (s) => Buffer.from(String(s), 'utf8').toString('base64');
-    ctx.atob = (s) => Buffer.from(String(s), 'base64').toString('utf8');
-
-    ctx.crypto = { subtle: require('crypto').webcrypto.subtle }; ctx.TextEncoder = TextEncoder; ctx.TextDecoder = TextDecoder; ctx.Uint8Array = Uint8Array;
-    loadInCtx(ctx, 'public/channel-decrypt.js');
-    loadInCtx(ctx, 'public/channels.js');
-    ctx._pageHandlers.init(appEl);
-    // Wait for loadChannels() to resolve (async in init)
-    for (let i = 0; i < 10; i++) await Promise.resolve();
-
-    // Select the encrypted channel — no stored keys exist
-    apiCallPaths = [];
-    await ctx.window._channelsSelectChannelForTest('42');
-
-    // Should show lock message, NOT fetch messages API
-    const msgEl = dom['chMessages'];
-    assert.ok(msgEl.innerHTML.includes('🔒'), 'should show lock emoji for encrypted channel without key');
-    assert.ok(msgEl.innerHTML.includes('no decryption key'), 'should mention no decryption key');
-    const messageApiFetched = apiCallPaths.some(p => p.indexOf('/messages') !== -1);
-    assert.ok(!messageApiFetched, 'should NOT fetch messages API for encrypted channel without key');
-  });
-
-  // #825 regression: deep link to a `#`-named channel not in the loaded list.
-  // The 3 acceptance cases (unencrypted / encrypted-no-key / encrypted-with-key)
-  // must each behave correctly without the unconditional lock affordance.
-  async function runHashDeepLinkScenario(opts) {
-    // opts: { includeEncryptedChannels: [...], storedKey: { name, hex } | null, target: '#name' }
-    const ctx = makeSandbox();
-    const dom = {};
-    function makeEl(id) {
-      if (dom[id]) return dom[id];
-      dom[id] = {
-        id, innerHTML: '', textContent: '', value: '',
-        scrollTop: 0, scrollHeight: 100, clientHeight: 80,
-        style: {}, dataset: {},
-        classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
-        addEventListener() {}, removeEventListener() {},
-        querySelector() { return null; }, querySelectorAll() { return []; },
-        getBoundingClientRect() { return { left: 0, bottom: 0, width: 0 }; },
-        setAttribute() {}, removeAttribute() {}, focus() {},
-      };
-      return dom[id];
-    }
-    const headerText = { textContent: '' };
-    makeEl('chHeader').querySelector = (sel) => (sel === '.ch-header-text' ? headerText : null);
-    ['chMessages', 'chList', 'chScrollBtn', 'chAriaLive', 'chBackBtn', 'chRegionFilter'].forEach(makeEl);
-    const appEl = {
-      innerHTML: '',
-      querySelector(sel) {
-        if (sel === '.ch-sidebar' || sel === '.ch-sidebar-resize' || sel === '.ch-main') return makeEl(sel);
-        if (sel === '.ch-layout') return { classList: { add() {}, remove() {}, contains() { return false; } } };
-        return makeEl(sel);
-      },
-      addEventListener() {},
-    };
-    let apiCallPaths = [];
-    ctx.document.getElementById = makeEl;
-    ctx.document.querySelector = (sel) => {
-      if (sel === '.ch-layout') return { classList: { add() {}, remove() {}, contains() { return false; } } };
-      return null;
-    };
-    ctx.document.querySelectorAll = () => [];
-    ctx.document.addEventListener = () => {};
-    ctx.document.removeEventListener = () => {};
-    ctx.document.documentElement = { getAttribute: () => null, setAttribute: () => {} };
-    ctx.document.body = { appendChild() {}, removeChild() {}, contains() { return false; } };
-    ctx.history = { replaceState() {} };
-    ctx.matchMedia = () => ({ matches: false });
-    ctx.window.matchMedia = ctx.matchMedia;
-    ctx.MutationObserver = function () { this.observe = () => {}; this.disconnect = () => {}; };
-    ctx.RegionFilter = { init() {}, onChange() { return () => {}; }, offChange() {}, getRegionParam() { return ''; } };
-    ctx.debouncedOnWS = (fn) => fn;
-    ctx.onWS = () => {};
-    ctx.offWS = () => {};
-    ctx.api = (path) => {
-      apiCallPaths.push(path);
-      if (path.indexOf('/observers') === 0) return Promise.resolve({ observers: [] });
-      if (path.indexOf('/channels') === 0 && path.indexOf('/messages') === -1) {
-        // Toggle-off list never includes encrypted channels for the initial load
-        if (path.indexOf('includeEncrypted=true') !== -1) {
-          return Promise.resolve({ channels: opts.includeEncryptedChannels || [] });
-        }
-        return Promise.resolve({ channels: [] });
-      }
-      if (path.indexOf('/messages') !== -1) {
-        return Promise.resolve({ messages: [{ sender: 'X', text: 'hello', timestamp: '2025-01-01T00:00:00Z' }] });
-      }
-      return Promise.resolve({});
-    };
-    ctx.CLIENT_TTL = { observers: 120000, channels: 15000, channelMessages: 10000, nodeDetail: 10000 };
-    ctx.ROLE_EMOJI = {}; ctx.ROLE_LABELS = {};
-    ctx.timeAgo = () => '1m ago';
-    ctx.registerPage = (name, handlers) => { ctx._pageHandlers = handlers; };
-    ctx.btoa = (s) => Buffer.from(String(s), 'utf8').toString('base64');
-    ctx.atob = (s) => Buffer.from(String(s), 'base64').toString('utf8');
-    ctx.crypto = { subtle: require('crypto').webcrypto.subtle };
-    ctx.TextEncoder = TextEncoder; ctx.TextDecoder = TextDecoder; ctx.Uint8Array = Uint8Array;
-    loadInCtx(ctx, 'public/channel-decrypt.js');
-    loadInCtx(ctx, 'public/channels.js');
-    if (opts.storedKey) {
-      ctx.ChannelDecrypt.saveKey(opts.storedKey.name, opts.storedKey.hex);
-    }
-    ctx._pageHandlers.init(appEl);
-    for (let i = 0; i < 10; i++) await Promise.resolve();
-    apiCallPaths = [];
-    await ctx.window._channelsSelectChannelForTest(opts.target);
-    return { msgHtml: dom['chMessages'].innerHTML, apiCallPaths };
-  }
-
-  test('#825: deep link to unencrypted #channel falls through to REST and renders messages', async () => {
-    const r = await runHashDeepLinkScenario({
-      target: '#test',
-      includeEncryptedChannels: [{ hash: '#test', name: '#test', messageCount: 3, lastActivity: null, encrypted: null }],
-      storedKey: null,
-    });
-    assert.ok(!r.msgHtml.includes('🔒'), 'unencrypted #channel must NOT show lock affordance');
-    const messageApiFetched = r.apiCallPaths.some(p => p.indexOf('/messages') !== -1);
-    assert.ok(messageApiFetched, 'unencrypted #channel must fetch messages REST endpoint');
-  });
-
-  test('#811 preserved: deep link to encrypted #channel without key shows lock', async () => {
-    const r = await runHashDeepLinkScenario({
-      target: '#private',
-      includeEncryptedChannels: [{ hash: '#private', name: '#private', messageCount: 5, lastActivity: null, encrypted: true }],
-      storedKey: null,
-    });
-    assert.ok(r.msgHtml.includes('🔒'), 'encrypted #channel without key must show lock affordance');
-    assert.ok(r.msgHtml.includes('no decryption key'), 'lock should mention no decryption key');
-    const messageApiFetched = r.apiCallPaths.some(p => p.indexOf('/messages') !== -1);
-    assert.ok(!messageApiFetched, 'must NOT fetch /messages REST for encrypted channel without key');
-  });
-
-  test('#815 preserved: deep link to #channel with stored key triggers decrypt path (no lock)', async () => {
-    const r = await runHashDeepLinkScenario({
-      target: '#private',
-      includeEncryptedChannels: [{ hash: '#private', name: '#private', messageCount: 5, lastActivity: null, encrypted: true }],
-      storedKey: { name: '#private', hex: 'abcd1234abcd1234abcd1234abcd1234' },
-    });
-    assert.ok(!r.msgHtml.includes('no decryption key'), 'must not show no-key lock when key is stored');
-    // Decrypt path either renders something or shows decrypt-specific empty/wrong-key state — never the no-key lock.
-  });
-}
 // ===== PACKETS.JS: savedTimeWindowMin default guard =====
 console.log('\n=== packets.js: savedTimeWindowMin defaults ===');
 {
@@ -5568,11 +5132,6 @@ console.log('\n=== packets.js: buildFieldTable transport offsets (#765) ===');
   ftCtx.window.truncate = ftCtx.truncate;
   ftCtx.escapeHtml = (s) => String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
   ftCtx.window.escapeHtml = ftCtx.escapeHtml;
-  ftCtx.window.HopDisplay = { renderHop: (hex) => hex };
-  ftCtx.isTransportRoute = (rt) => rt === 0 || rt === 3;
-  ftCtx.window.isTransportRoute = ftCtx.isTransportRoute;
-  ftCtx.getPathLenOffset = (rt) => ftCtx.isTransportRoute(rt) ? 5 : 1;
-  ftCtx.window.getPathLenOffset = ftCtx.getPathLenOffset;
   loadInCtx(ftCtx, 'public/packets.js');
   const { buildFieldTable, fieldRow } = ftCtx.window._packetsTestAPI;
 
@@ -5638,73 +5197,6 @@ console.log('\n=== packets.js: buildFieldTable transport offsets (#765) ===');
   });
 }
 
-// ===== packets.js: buildFieldTable hop count from path_len (#844) =====
-console.log('\n=== packets.js: buildFieldTable hop count from path_len (#844) ===');
-{
-  const ftCtx = makeSandbox();
-  ftCtx.registerPage = () => {};
-  ftCtx.onWS = () => {};
-  ftCtx.offWS = () => {};
-  ftCtx.api = () => Promise.resolve({});
-  ftCtx.window.getParsedPath = () => [];
-  ftCtx.window.getParsedDecoded = () => ({});
-  const ROUTE_TYPES = {0:'TRANSPORT_FLOOD',1:'FLOOD',2:'DIRECT',3:'TRANSPORT_DIRECT'};
-  const PAYLOAD_TYPES = {0:'ADVERT',1:'TXT_MSG',2:'GRP_TXT',3:'REQ',4:'ACK'};
-  ftCtx.routeTypeName = (n) => ROUTE_TYPES[n] || 'UNKNOWN';
-  ftCtx.payloadTypeName = (n) => PAYLOAD_TYPES[n] || 'UNKNOWN';
-  ftCtx.window.routeTypeName = ftCtx.routeTypeName;
-  ftCtx.window.payloadTypeName = ftCtx.payloadTypeName;
-  ftCtx.truncate = (str, len) => str && str.length > len ? str.slice(0, len) + '…' : (str || '');
-  ftCtx.window.truncate = ftCtx.truncate;
-  ftCtx.escapeHtml = (s) => String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
-  ftCtx.window.escapeHtml = ftCtx.escapeHtml;
-  ftCtx.window.HopDisplay = { renderHop: (hex) => hex };
-  ftCtx.isTransportRoute = (rt) => rt === 0 || rt === 3;
-  ftCtx.window.isTransportRoute = ftCtx.isTransportRoute;
-  ftCtx.getPathLenOffset = (rt) => ftCtx.isTransportRoute(rt) ? 5 : 1;
-  ftCtx.window.getPathLenOffset = ftCtx.getPathLenOffset;
-  loadInCtx(ftCtx, 'public/packets.js');
-  const { buildFieldTable } = ftCtx.window._packetsTestAPI;
-
-  test('#885: byte breakdown uses pathHops length (single source of truth)', () => {
-    // After #885 the byte breakdown agrees with the path pill: both render
-    // from the per-observation path_json. raw_hex is the underlying bytes
-    // for that same observation, so consistency is by construction.
-    // path_len = 0x42 → hash_size=2, hash_count=2
-    // raw_hex: header(11) + path_len(42) + hop0(41B1) + hop1(27D7) + pubkey(32 bytes)...
-    const pubkey = 'C0DEDAD4'.padEnd(64, '0'); // 32 bytes = 64 hex chars
-    const raw = '1142' + '41B1' + '27D7' + pubkey + '00000000' + '0'.repeat(128);
-    const pkt = { raw_hex: raw, route_type: 1, payload_type: 0 };
-    // Per-obs path_json IS the source of truth — pass the 2 hops that match raw_hex.
-    const pathHops = ['41B1', '27D7'];
-    const html = buildFieldTable(pkt, {}, pathHops, {});
-
-    assert.ok(html.includes('Path (2 hops)'), 'Should show "Path (2 hops)"');
-    assert.ok(html.includes('41B1'), 'Should show hop 0 = 41B1');
-    assert.ok(html.includes('27D7'), 'Should show hop 1 = 27D7');
-  });
-
-  test('#885: pubkey offset advances by hashSize * pathHops.length', () => {
-    const pubkey = 'C0DEDAD4'.padEnd(64, '0');
-    const raw = '1142' + '41B1' + '27D7' + pubkey + '00000000' + '0'.repeat(128);
-    const pkt = { raw_hex: raw, route_type: 1, payload_type: 0 };
-    const html = buildFieldTable(pkt, { type: 'ADVERT', pubKey: pubkey }, ['41B1', '27D7'], {});
-
-    // Public Key should be at offset 6 (1 header + 1 path_len + 2*2 hops = 6)
-    assert.ok(html.includes('>6<') || html.includes('"6"'),
-      'Public Key should be at offset 6');
-  });
-
-  test('#844: hashCountVal=0 (direct advert) skips Path section', () => {
-    // path_len = 0x00 → hash_size=1, hash_count=0
-    const raw = '1100' + '0'.repeat(200);
-    const pkt = { raw_hex: raw, route_type: 1, payload_type: 0 };
-    const html = buildFieldTable(pkt, {}, [], {});
-    assert.ok(!html.includes('section-path'), 'Should not render Path section for direct advert');
-    assert.ok(html.includes('direct advert'), 'Should note direct advert in path_length description');
-  });
-}
-
 // ===== live.js: anomaly icon in feed =====
 console.log('\n=== live.js: anomaly icon in feed ===');
 {
@@ -5904,14 +5396,6 @@ console.log('\n=== channel-decrypt.js: key derivation, MAC, parsing, storage ===
     assert.strictEqual(ctx.window.renderSkewBadge(null, 0), '');
   });
 
-  test('renderSkewBadge renders default badge with tooltip', () => {
-    var cs = {};
-    var html = ctx.window.renderSkewBadge('default', 0, cs);
-    assert.ok(html.includes('skew-badge--default'), 'should contain default class');
-    assert.ok(html.toLowerCase().includes('firmware default'), 'tooltip should mention firmware default');
-    assert.ok(html.includes('⏰'), 'should contain clock emoji');
-  });
-
   test('renderSkewSparkline returns SVG with data points', () => {
     var samples = [
       { ts: 1000, skew: 10 },
@@ -5932,9 +5416,9 @@ console.log('\n=== channel-decrypt.js: key derivation, MAC, parsing, storage ===
 
   test('SKEW_SEVERITY_ORDER sorts worst first', () => {
     var order = ctx.window.SKEW_SEVERITY_ORDER;
-    assert.ok(order.wrong < order.degraded, 'wrong should sort before degraded');
-    assert.ok(order.degraded < order.degrading, 'degraded should sort before degrading');
-    assert.ok(order.degrading < order.ok, 'degrading should sort before ok');
+    assert.ok(order.absurd < order.critical, 'absurd should sort before critical');
+    assert.ok(order.critical < order.warning, 'critical should sort before warning');
+    assert.ok(order.warning < order.ok, 'warning should sort before ok');
   });
 }
 
@@ -6104,352 +5588,6 @@ console.log('\n=== analytics.js: renderCollisionsFromServer collision table ==='
   });
 }
 
-// ===== Issue #849: Per-observation packet detail tests =====
-{
-  console.log('\n=== Issue #849: Per-observation packet detail ===');
-
-  // Test helper: extract hop count from raw_hex path_len byte
-  function extractRawHopCount(rawHex, routeType) {
-    if (!rawHex || rawHex.length < 4) return null;
-    let plOff = 1;
-    if (routeType === 0 || routeType === 3) plOff = 5;
-    const plByte = parseInt(rawHex.slice(plOff * 2, plOff * 2 + 2), 16);
-    if (isNaN(plByte)) return null;
-    return plByte & 0x3F;
-  }
-
-  test('#849: hop count from raw_hex path_len byte (2 hops)', () => {
-    // path_len byte = 0x82: hash_size=2+1=3, hash_count=2
-    const rawHex = '0482aabbccddee'; // header + path_len(0x82) + path data
-    assert.strictEqual(extractRawHopCount(rawHex, 1), 2);
-  });
-
-  test('#849: hop count from raw_hex path_len byte (0 hops = direct)', () => {
-    const rawHex = '0400'; // header + path_len=0x00
-    assert.strictEqual(extractRawHopCount(rawHex, 1), 0);
-  });
-
-  test('#849: hop count from raw_hex for transport route (offset 5)', () => {
-    // Transport routes have 4 bytes of transport codes before path_len
-    const rawHex = '00112233440541B127D7'; // header + 4 transport bytes + path_len(0x05)=5 hops
-    assert.strictEqual(extractRawHopCount(rawHex, 0), 5);
-  });
-
-  test('#849: hop count warns on inconsistency (path_json vs raw_hex)', () => {
-    // path_json has 3 hops, but raw_hex says 2
-    const pathJson = ['41B1', '27D7', '5EB0'];
-    const rawHopCount = 2;
-    assert.notStrictEqual(pathJson.length, rawHopCount, 'should detect inconsistency');
-    // In production code, rawHopCount is trusted
-    assert.strictEqual(rawHopCount, 2);
-  });
-
-  test('#849: per-observation fields override aggregated packet fields', () => {
-    const pkt = { id: 1, hash: 'abc', observer_id: 'obs-agg', snr: 10, rssi: -90, path_json: '["A","B","C"]', timestamp: '2026-01-01T00:00:00Z' };
-    const obs = { id: 2, observer_id: 'obs-1', snr: 5, rssi: -85, path_json: '["A"]', timestamp: '2026-01-01T00:01:00Z' };
-    // Simulate what renderDetail does: spread obs over pkt
-    const effective = {...pkt, ...obs, _isObservation: true};
-    delete effective._parsedPath; // clear cache
-    assert.strictEqual(effective.observer_id, 'obs-1');
-    assert.strictEqual(effective.snr, 5);
-    assert.strictEqual(effective.rssi, -85);
-    assert.strictEqual(effective.timestamp, '2026-01-01T00:01:00Z');
-  });
-
-  test('#849: first observation used when no specific observation selected', () => {
-    const observations = [
-      { id: 10, observer_id: 'obs-A', path_json: '["X"]' },
-      { id: 20, observer_id: 'obs-B', path_json: '["X","Y","Z"]' }
-    ];
-    // No targetObsId → use observations[0]
-    const currentObs = observations[0];
-    assert.strictEqual(currentObs.id, 10);
-    assert.strictEqual(currentObs.observer_id, 'obs-A');
-  });
-
-  test('#849: clicking observation row selects that observation', () => {
-    const observations = [
-      { id: 10, observer_id: 'obs-A', path_json: '["X"]' },
-      { id: 20, observer_id: 'obs-B', path_json: '["X","Y","Z"]' }
-    ];
-    const targetObsId = '20';
-    const currentObs = observations.find(o => String(o.id) === String(targetObsId));
-    assert.ok(currentObs);
-    assert.strictEqual(currentObs.observer_id, 'obs-B');
-  });
-
-  test('#849: null/missing raw_hex returns null hop count', () => {
-    assert.strictEqual(extractRawHopCount(null, 1), null);
-    assert.strictEqual(extractRawHopCount('', 1), null);
-    assert.strictEqual(extractRawHopCount('04', 1), null); // too short
-  });
-}
-
-// ===== Issue #852: hashSize offset + var(--muted) regression =====
-{
-  console.log('\n=== Issue #852: hashSize path_len offset + var(--muted) regression ===');
-
-  // Use getPathLenOffset from app.js (loaded via vm context) to avoid duplicating offset logic
-  const ctx852 = makeSandbox();
-  loadInCtx(ctx852, 'public/roles.js');
-  loadInCtx(ctx852, 'public/app.js');
-
-  function extractHashSize(rawHex, routeType) {
-    const plOff = ctx852.getPathLenOffset(routeType);
-    const rawPathByte = rawHex ? parseInt(rawHex.slice(plOff * 2, plOff * 2 + 2), 16) : NaN;
-    return (isNaN(rawPathByte) || (rawPathByte & 0x3F) === 0) ? null : ((rawPathByte >> 6) + 1);
-  }
-
-  test('#852: hashSize for flood route (route_type=1, offset 1)', () => {
-    // Byte at offset 1 = 0x82 → hash_size = (0x82 >> 6) + 1 = 3
-    const rawHex = '0482aabbccddee';
-    assert.strictEqual(extractHashSize(rawHex, 1), 3);
-  });
-
-  test('#852: hashSize for direct transport route (route_type=0, offset 5)', () => {
-    // Bytes 1-4 are next_hop+last_hop, byte at offset 5 = 0x45 → hash_size = (0x45 >> 6) + 1 = 2
-    const rawHex = '001122334445aabb';
-    assert.strictEqual(extractHashSize(rawHex, 0), 2);
-  });
-
-  test('#852: hashSize for transport route flood (route_type=3, offset 5)', () => {
-    const rawHex = '00aabbccdd85aabb';
-    assert.strictEqual(extractHashSize(rawHex, 3), 3); // 0x85 >> 6 = 2, +1 = 3
-  });
-
-  test('#852: hashSize returns null for missing raw_hex', () => {
-    assert.strictEqual(extractHashSize(null, 1), null);
-    assert.strictEqual(extractHashSize('', 0), null);
-  });
-
-  test('#852: no var(--muted) in public/ files (regression guard)', () => {
-    const fs = require('fs');
-    const path = require('path');
-    const pubDir = path.join(__dirname, 'public');
-    const files = fs.readdirSync(pubDir).filter(f => f.endsWith('.js') || f.endsWith('.css'));
-    files.forEach(f => {
-      const content = fs.readFileSync(path.join(pubDir, f), 'utf8');
-      // Match var(--muted) but not var(--text-muted) or var(--bg-muted) etc.
-      const matches = content.match(/var\(--muted\)/g);
-      if (matches) throw new Error(`${f} contains undefined CSS var var(--muted); use var(--text-muted)`);
-    });
-  });
-}
-
-// ─── #862: Pubkey prefix search ──────────────────────────────────────────────
-{
-  const ctx = makeSandbox();
-  ctx.ROLE_COLORS = { repeater: '#22c55e', room: '#6366f1', companion: '#3b82f6', sensor: '#f59e0b' };
-  ctx.ROLE_STYLE = {};
-  ctx.TYPE_COLORS = {};
-  ctx.getNodeStatus = () => 'active';
-  ctx.getHealthThresholds = () => ({ staleMs: 600000, degradedMs: 1800000, silentMs: 86400000 });
-  ctx.timeAgo = () => '1m ago';
-  ctx.truncate = (s) => s;
-  ctx.escapeHtml = (s) => String(s || '');
-  ctx.payloadTypeName = () => 'Advert';
-  ctx.payloadTypeColor = () => 'advert';
-  ctx.registerPage = () => {};
-  ctx.RegionFilter = { init: () => {}, onChange: () => () => {}, getRegionParam: () => '' };
-  ctx.debouncedOnWS = () => null;
-  ctx.onWS = () => {};
-  ctx.offWS = () => {};
-  ctx.debounce = (fn) => fn;
-  ctx.api = () => Promise.resolve({ nodes: [], counts: {} });
-  ctx.invalidateApiCache = () => {};
-  ctx.CLIENT_TTL = { nodeList: 90000, nodeDetail: 240000, nodeHealth: 240000 };
-  ctx.initTabBar = () => {};
-  ctx.getFavorites = () => [];
-  ctx.favStar = () => '';
-  ctx.bindFavStars = () => {};
-  ctx.makeColumnsResizable = () => {};
-  ctx.Set = Set;
-  ctx.HEALTH_THRESHOLDS = { infraSilentMs: 86400000, nodeSilentMs: 7200000 };
-  loadInCtx(ctx, 'public/nodes.js');
-
-  const matchesSearch = ctx.window._nodesMatchesSearch;
-
-  test('#862: _nodesMatchesSearch matches name substring', () => {
-    const node = { name: 'MyRepeater', public_key: '3faebb0011223344' };
-    assert.strictEqual(matchesSearch(node, 'repeat'), true);
-    assert.strictEqual(matchesSearch(node, 'REPEAT'), true);
-  });
-
-  test('#862: _nodesMatchesSearch matches pubkey prefix (hex)', () => {
-    const node = { name: 'MyRepeater', public_key: '3faebb0011223344' };
-    assert.strictEqual(matchesSearch(node, '3f'), true);
-    assert.strictEqual(matchesSearch(node, '3fae'), true);
-    assert.strictEqual(matchesSearch(node, '3FAEBB'), true);
-  });
-
-  test('#862: _nodesMatchesSearch does NOT match pubkey substring (only prefix)', () => {
-    const node = { name: 'MyRepeater', public_key: '3faebb0011223344' };
-    assert.strictEqual(matchesSearch(node, 'aebb'), false);
-  });
-
-  test('#862: _nodesMatchesSearch returns true for empty query', () => {
-    const node = { name: 'Test', public_key: 'abcdef1234567890' };
-    assert.strictEqual(matchesSearch(node, ''), true);
-    assert.strictEqual(matchesSearch(node, null), true);
-  });
-
-  test('#862: _nodesMatchesSearch mixed query (non-hex) only matches name', () => {
-    const node = { name: 'alpha', public_key: 'abcdef1234567890' };
-    assert.strictEqual(matchesSearch(node, 'xyz'), false);
-    assert.strictEqual(matchesSearch(node, 'alph'), true);
-  });
-
-  test('#862: _nodesMatchesSearch hex-named node — name "cafe" with pubkey "deadbeef..."', () => {
-    const node = { name: 'cafe', public_key: 'deadbeef11223344' };
-    // "cafe" matches by name (substring), NOT pubkey prefix
-    assert.strictEqual(matchesSearch(node, 'cafe'), true);
-    // "dead" matches by pubkey prefix
-    assert.strictEqual(matchesSearch(node, 'dead'), true);
-    // "cafe" should NOT match pubkey (not a prefix of "deadbeef")
-    assert.strictEqual(matchesSearch(node, 'beef'), false); // not a prefix, not in name
-    // "ca" matches name substring
-    assert.strictEqual(matchesSearch(node, 'ca'), true);
-  });
-}
-
-// ===== Issue #866: Full-page obs-switch — hex + path must update per observation =====
-{
-  console.log('\n=== Issue #866: Full-page observation switch ===');
-
-  const ctx866 = makeSandbox();
-  loadInCtx(ctx866, 'public/roles.js');
-  loadInCtx(ctx866, 'public/app.js');
-  loadInCtx(ctx866, 'public/packet-helpers.js');
-
-  test('#866: switching observation updates effectivePkt path_json', () => {
-    const pkt = { id: 1, hash: 'abc123', observer_id: 'obs-agg', path_json: '["A","B","C","D"]', raw_hex: '0484A1B1C1D1', route_type: 1, timestamp: '2026-01-01T00:00:00Z' };
-    const obs1 = { id: 10, observer_id: 'obs-1', path_json: '["A","B"]', snr: 5, rssi: -80, timestamp: '2026-01-01T00:01:00Z' };
-    const obs2 = { id: 20, observer_id: 'obs-2', path_json: '["A","B","C","D"]', snr: 8, rssi: -75, timestamp: '2026-01-01T00:02:00Z' };
-
-    // Simulate renderDetail logic: pick obs1
-    const eff1 = ctx866.clearParsedCache({...pkt, ...obs1, _isObservation: true});
-    const path1 = ctx866.getParsedPath(eff1);
-    assert.deepStrictEqual(path1, ['A', 'B']);
-    assert.strictEqual(eff1.observer_id, 'obs-1');
-    assert.strictEqual(eff1.snr, 5);
-
-    // Switch to obs2
-    const eff2 = ctx866.clearParsedCache({...pkt, ...obs2, _isObservation: true});
-    const path2 = ctx866.getParsedPath(eff2);
-    assert.deepStrictEqual(path2, ['A', 'B', 'C', 'D']);
-    assert.strictEqual(eff2.observer_id, 'obs-2');
-    assert.strictEqual(eff2.snr, 8);
-  });
-
-  test('#866: effectivePkt preserves raw_hex from packet when obs has none', () => {
-    const pkt = { id: 1, hash: 'h1', raw_hex: '0482AABB', route_type: 1 };
-    const obs = { id: 10, observer_id: 'obs-1', path_json: '["AA"]', snr: 3, rssi: -90, timestamp: '2026-01-01T00:00:00Z' };
-    const eff = ctx866.clearParsedCache({...pkt, ...obs, _isObservation: true});
-    // obs doesn't have raw_hex, so packet's raw_hex survives spread
-    assert.strictEqual(eff.raw_hex, '0482AABB');
-  });
-
-  test('#866: effectivePkt uses obs raw_hex when available (API now returns it)', () => {
-    const pkt = { id: 1, hash: 'h1', raw_hex: '0482AABB', route_type: 1 };
-    const obs = { id: 10, observer_id: 'obs-1', raw_hex: '0441CC', path_json: '["CC"]', snr: 3, rssi: -90, timestamp: '2026-01-01T00:00:00Z' };
-    const eff = ctx866.clearParsedCache({...pkt, ...obs, _isObservation: true});
-    // obs has raw_hex from API, should override
-    assert.strictEqual(eff.raw_hex, '0441CC');
-  });
-
-  test('#866: direction field carried through observation spread', () => {
-    const pkt = { id: 1, hash: 'h1', direction: 'rx', route_type: 1 };
-    const obs = { id: 10, observer_id: 'obs-1', direction: 'tx', path_json: '[]', timestamp: '2026-01-01T00:00:00Z' };
-    const eff = {...pkt, ...obs, _isObservation: true};
-    assert.strictEqual(eff.direction, 'tx');
-  });
-
-  test('#866: resolved_path carried through observation spread', () => {
-    const pkt = { id: 1, hash: 'h1', resolved_path: '["aaa","bbb","ccc"]', route_type: 1 };
-    const obs = { id: 10, observer_id: 'obs-1', resolved_path: '["aaa"]', path_json: '["AA"]', timestamp: '2026-01-01T00:00:00Z' };
-    const eff = ctx866.clearParsedCache({...pkt, ...obs, _isObservation: true});
-    const rp = ctx866.getResolvedPath(eff);
-    assert.deepStrictEqual(rp, ['aaa']);
-  });
-
-  test('#866: getPathLenOffset used for hop count cross-check', () => {
-    // Flood route: offset 1
-    assert.strictEqual(ctx866.getPathLenOffset(1), 1);
-    assert.strictEqual(ctx866.getPathLenOffset(2), 1);
-    // Transport route: offset 5
-    assert.strictEqual(ctx866.getPathLenOffset(0), 5);
-    assert.strictEqual(ctx866.getPathLenOffset(3), 5);
-  });
-
-  test('#866: URL hash should encode obs parameter for deep linking', () => {
-    // Simulate the URL construction pattern from renderDetail obs click
-    const pktHash = 'abc123def456';
-    const obsId = '42';
-    const url = `#/packets/${pktHash}?obs=${obsId}`;
-    assert.strictEqual(url, '#/packets/abc123def456?obs=42');
-    // Parse back
-    const qIdx = url.indexOf('?');
-    const qs = new URLSearchParams(url.substring(qIdx));
-    assert.strictEqual(qs.get('obs'), '42');
-  });
-}
-
-// ===== #872 — hop-display unreliable badge =====
-{
-  console.log('\n--- #872: hop-display unreliable warning badge ---');
-
-  function makeHopDisplaySandbox() {
-    const sb = {
-      window: { addEventListener: () => {}, dispatchEvent: () => {} },
-      document: {
-        readyState: 'complete',
-        createElement: () => ({ id: '', textContent: '', innerHTML: '' }),
-        head: { appendChild: () => {} },
-        getElementById: () => null,
-        addEventListener: () => {},
-        querySelectorAll: () => [],
-        querySelector: () => null,
-      },
-      console,
-      Date, Math, Array, Object, String, Number, JSON, RegExp, Map, Set,
-      encodeURIComponent, parseInt, parseFloat, isNaN, Infinity, NaN, undefined,
-      setTimeout: () => {}, setInterval: () => {}, clearTimeout: () => {}, clearInterval: () => {},
-    };
-    sb.window.document = sb.document;
-    sb.self = sb.window;
-    sb.globalThis = sb.window;
-    const ctx = vm.createContext(sb);
-    const hopSrc = fs.readFileSync(__dirname + '/public/hop-display.js', 'utf8');
-    vm.runInContext(hopSrc, ctx);
-    return ctx;
-  }
-
-  const hopCtx = makeHopDisplaySandbox();
-
-  test('#872: unreliable hop renders warning badge, not strikethrough', () => {
-    const html = hopCtx.window.HopDisplay.renderHop('AABB', {
-      name: 'TestNode', pubkey: 'pk123', unreliable: true,
-      ambiguous: false, conflicts: [], globalFallback: false,
-    }, {});
-    // Must contain unreliable warning badge button
-    assert.ok(html.includes('hop-unreliable-btn'), 'should have unreliable badge button');
-    assert.ok(html.includes('⚠️'), 'should have ⚠️ icon');
-    assert.ok(html.includes('Unreliable name resolution'), 'should have tooltip text');
-    // Must NOT contain line-through in inline style (CSS class no longer has it)
-    assert.ok(!html.includes('line-through'), 'should not contain line-through');
-    // Should still have hop-unreliable class for subtle styling
-    assert.ok(html.includes('hop-unreliable'), 'should have hop-unreliable class');
-  });
-
-  test('#872: reliable hop does NOT render unreliable badge', () => {
-    const html = hopCtx.window.HopDisplay.renderHop('CCDD', {
-      name: 'GoodNode', pubkey: 'pk456', unreliable: false,
-      ambiguous: false, conflicts: [], globalFallback: false,
-    }, {});
-    assert.ok(!html.includes('hop-unreliable-btn'), 'should not have unreliable badge');
-  });
-}
-
 // ===== SUMMARY =====
 Promise.allSettled(pendingTests).then(() => {
   console.log(`\n${'═'.repeat(40)}`);

test-hop-resolver-affinity.js

@@ -22,9 +22,9 @@ function assert(condition, msg) {
 
 // ── Test nodes ──
 // Two nodes share the same 1-byte prefix "ab"
-const nodeA = { public_key: 'ab1111', name: 'NodeA', role: 'repeater', lat: 37.0, lon: -122.0 };
-const nodeB = { public_key: 'ab2222', name: 'NodeB', role: 'repeater', lat: 38.0, lon: -123.0 };
-const nodeC = { public_key: 'cd3333', name: 'NodeC', role: 'repeater', lat: 37.5, lon: -122.5 };
+const nodeA = { public_key: 'ab1111', name: 'NodeA', lat: 37.0, lon: -122.0 };
+const nodeB = { public_key: 'ab2222', name: 'NodeB', lat: 38.0, lon: -123.0 };
+const nodeC = { public_key: 'cd3333', name: 'NodeC', lat: 37.5, lon: -122.5 };
 
 console.log('\n=== HopResolver Affinity Tests ===\n');
 
@@ -88,65 +88,12 @@ assert(result5['ab'].name === 'NodeB', 'Should pick NodeB (highest affinity 0.9)
 
 // Test 6: Unambiguous hops are not affected by affinity
 console.log('\nTest 6: Unambiguous hops unaffected by affinity');
-const nodeD = { public_key: 'ee4444', name: 'NodeD', role: 'repeater', lat: 36.0, lon: -121.0 };
+const nodeD = { public_key: 'ee4444', name: 'NodeD', lat: 36.0, lon: -121.0 };
 HopResolver.init([nodeA, nodeB, nodeC, nodeD]);
 HopResolver.setAffinity({ edges: [] });
 const result6 = HopResolver.resolve(['ee44'], null, null, null, null, null);
 assert(result6['ee44'].name === 'NodeD', 'Unique prefix resolves directly — got: ' + result6['ee44'].name);
 assert(!result6['ee44'].ambiguous, 'Should not be marked ambiguous');
 
-// Test 7: lat=0 / lon=0 candidates are NOT excluded (equator/prime-meridian bug fix)
-console.log('\nTest 7: lat=0 / lon=0 candidates are included in geo scoring');
-const nodeEquator = { public_key: 'ab5555', name: 'EquatorNode', role: 'repeater', lat: 0, lon: 10 };
-const nodeFar = { public_key: 'ab6666', name: 'FarNode', role: 'repeater', lat: 60, lon: 60 };
-const anchorNearEq = { public_key: 'cd7777', name: 'AnchorEq', role: 'repeater', lat: 1, lon: 11 };
-HopResolver.init([nodeEquator, nodeFar, anchorNearEq]);
-HopResolver.setAffinity({});
-// Anchor near equator — EquatorNode (0,10) should be geo-closest
-const result7 = HopResolver.resolve(['cd77', 'ab'], 1.0, 11.0, null, null, null);
-assert(result7['ab'].name === 'EquatorNode',
-  'lat=0 candidate should be included and win by geo — got: ' + result7['ab'].name);
-
-// Test 8: lon=0 candidate is also included
-console.log('\nTest 8: lon=0 candidate is included in geo scoring');
-const nodePrime = { public_key: 'ab8888', name: 'PrimeMeridian', role: 'repeater', lat: 10, lon: 0 };
-const anchorNearPM = { public_key: 'cd9999', name: 'AnchorPM', role: 'repeater', lat: 11, lon: 1 };
-HopResolver.init([nodePrime, nodeFar, anchorNearPM]);
-HopResolver.setAffinity({});
-const result8 = HopResolver.resolve(['cd99', 'ab'], 11.0, 1.0, null, null, null);
-assert(result8['ab'].name === 'PrimeMeridian',
-  'lon=0 candidate should be included and win by geo — got: ' + result8['ab'].name);
-
-// ── Role filter tests (#935) ──
-console.log('\nTest: Role filter — companions excluded from prefixIdx');
-const companion = { public_key: 'ab9999', name: 'Companion1', role: 'companion', lat: 37.0, lon: -122.0 };
-const sensor = { public_key: 'ab7777', name: 'Sensor1', role: 'sensor', lat: 37.0, lon: -122.0 };
-const repeater = { public_key: 'ab1234', name: 'Repeater1', role: 'repeater', lat: 37.0, lon: -122.0 };
-const roomSrv = { public_key: 'ff1234', name: 'RoomSrv1', role: 'room_server', lat: 37.0, lon: -122.0 };
-
-HopResolver.init([companion, sensor, repeater, roomSrv]);
-HopResolver.setAffinity({});
-
-// Prefix 'ab' should only resolve to repeater (companion/sensor excluded)
-const r1 = HopResolver.resolve(['ab12'], 0, 0, null, null, null);
-assert(r1['ab12'] && r1['ab12'].name === 'Repeater1',
-  'prefix ab12 resolves to Repeater1 not companion — got: ' + (r1['ab12'] && r1['ab12'].name));
-
-// Prefix 'ff' should resolve to room_server
-const r2 = HopResolver.resolve(['ff12'], 0, 0, null, null, null);
-assert(r2['ff12'] && r2['ff12'].name === 'RoomSrv1',
-  'prefix ff12 resolves to RoomSrv1 — got: ' + (r2['ff12'] && r2['ff12'].name));
-
-// Prefix that only matches companion should return nothing
-const r3 = HopResolver.resolve(['ab99'], 0, 0, null, null, null);
-assert(!r3['ab99'] || !r3['ab99'].name,
-  'prefix ab99 (companion only) resolves to nothing — got: ' + (r3['ab99'] && r3['ab99'].name));
-
-// pubkeyIdx should still have companion (full pubkey lookup)
-console.log('\nTest: pubkeyIdx still includes all roles');
-const fromServer = HopResolver.resolveFromServer(['ab99'], [companion.public_key]);
-assert(fromServer['ab99'] && fromServer['ab99'].name === 'Companion1',
-  'resolveFromServer finds companion by full pubkey — got: ' + (fromServer['ab99'] && fromServer['ab99'].name));
-
 console.log('\n' + (passed + failed) + ' tests, ' + passed + ' passed, ' + failed + ' failed\n');
 process.exit(failed > 0 ? 1 : 0);

test-packets.js

@@ -844,120 +844,6 @@ console.log('\n=== packets.js: _invalidateRowCounts / _refreshRowCountsIfDirty (
   });
 }
 
-console.log('\n=== packets.js: buildPacketsParams ===');
-{
-  const ctx = loadPacketsSandbox();
-  const api = ctx._packetsTestAPI;
-  assert(typeof api.buildPacketsParams === 'function', 'buildPacketsParams must be exported');
-
-  test('hash filter suppresses region — direct hash links work regardless of saved region', () => {
-    // This is the bug from URL https://analyzer.../#/packets?hash=178525e9f693aa7e
-    // when the user's saved RegionFilter excludes the packet's observer region.
-    // The hash is an exact identifier; ALL other filters must be ignored.
-    const p = api.buildPacketsParams({
-      filters: { hash: 'abc123' },
-      regionParam: 'SJC,SFO,OAK,MRY',
-      windowMin: 60,
-      groupByHash: false,
-      limit: 200,
-    });
-    assert.strictEqual(p.get('hash'), 'abc123');
-    assert.strictEqual(p.get('region'), null, 'region must NOT be set when hash is present');
-    assert.strictEqual(p.get('since'), null, 'since must NOT be set when hash is present');
-  });
-
-  test('hash filter suppresses ALL other filters — observer, node, channel too', () => {
-    const p = api.buildPacketsParams({
-      filters: { hash: 'h', node: 'n', observer: 'o', channel: 'c' },
-      regionParam: 'SJC',
-      windowMin: 60,
-      groupByHash: false,
-      limit: 200,
-    });
-    assert.strictEqual(p.get('hash'), 'h');
-    assert.strictEqual(p.get('node'), null);
-    assert.strictEqual(p.get('observer'), null);
-    assert.strictEqual(p.get('channel'), null);
-    assert.strictEqual(p.get('region'), null);
-    assert.strictEqual(p.get('since'), null);
-  });
-
-  test('hash filter suppresses region with default windowMin=0', () => {
-    const p = api.buildPacketsParams({
-      filters: { hash: 'deadbeef' },
-      regionParam: 'COA',
-      windowMin: 0,
-      groupByHash: false,
-      limit: 50,
-    });
-    assert.strictEqual(p.get('hash'), 'deadbeef');
-    assert.strictEqual(p.get('region'), null);
-  });
-
-  test('region applied normally when hash filter is absent', () => {
-    const p = api.buildPacketsParams({
-      filters: {},
-      regionParam: 'SJC,SFO',
-      windowMin: 60,
-      groupByHash: false,
-      limit: 200,
-    });
-    assert.strictEqual(p.get('region'), 'SJC,SFO', 'region must apply when no hash');
-    assert.strictEqual(p.get('hash'), null);
-    assert(p.get('since'), 'since must apply when no hash and windowMin>0');
-  });
-
-  test('observer/node/channel pass through normally when no hash', () => {
-    const p = api.buildPacketsParams({
-      filters: { observer: 'obs1', node: 'node1', channel: '#test' },
-      regionParam: '',
-      windowMin: 0,
-      groupByHash: false,
-      limit: 50,
-    });
-    assert.strictEqual(p.get('observer'), 'obs1');
-    assert.strictEqual(p.get('node'), 'node1');
-    assert.strictEqual(p.get('channel'), '#test');
-  });
-
-  test('region absent when regionParam empty — no spurious empty region= param', () => {
-    const p = api.buildPacketsParams({
-      filters: {},
-      regionParam: '',
-      windowMin: 0,
-      groupByHash: false,
-      limit: 50,
-    });
-    assert.strictEqual(p.get('region'), null);
-  });
-
-  test('groupByHash=true with hash sets groupByHash and omits expand', () => {
-    const p = api.buildPacketsParams({
-      filters: { hash: 'h' }, regionParam: '', windowMin: 0, groupByHash: true, limit: 50,
-    });
-    assert.strictEqual(p.get('groupByHash'), 'true');
-    assert.strictEqual(p.get('expand'), null);
-    assert.strictEqual(p.get('hash'), 'h');
-  });
-
-  test('groupByHash=false with hash sets expand=observations', () => {
-    const p = api.buildPacketsParams({
-      filters: { hash: 'h' }, regionParam: '', windowMin: 0, groupByHash: false, limit: 50,
-    });
-    assert.strictEqual(p.get('expand'), 'observations');
-    assert.strictEqual(p.get('groupByHash'), null);
-    assert.strictEqual(p.get('hash'), 'h');
-  });
-
-  test('groupByHash=false without hash sets expand=observations', () => {
-    const p = api.buildPacketsParams({
-      filters: {}, regionParam: '', windowMin: 0, groupByHash: false, limit: 50,
-    });
-    assert.strictEqual(p.get('expand'), 'observations');
-    assert.strictEqual(p.get('groupByHash'), null);
-  });
-}
-
 // ===== SUMMARY =====
 console.log(`\n${'='.repeat(40)}`);
 console.log(`packets.js tests: ${passed} passed, ${failed} failed`);

test-path-inspector-e2e.js

@@ -1,87 +0,0 @@
-// E2E tests for Path Inspector (spec §5 — Playwright).
-// Run: npx playwright test test-path-inspector-e2e.js
-// Requires: running server on BASE_URL (default http://localhost:3000).
-'use strict';
-
-const { test, expect } = require('@playwright/test');
-const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
-
-test.describe('Path Inspector — Map Side Pane (spec §2.7)', () => {
-  test('side pane present and collapsed by default', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    const pane = page.locator('#mapSidePane');
-    await expect(pane).toBeVisible();
-    await expect(pane).not.toHaveClass(/expanded/);
-  });
-
-  test('click toggle expands the pane', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    const pane = page.locator('#mapSidePane');
-    await expect(pane).toHaveClass(/expanded/);
-  });
-
-  test('submit valid prefixes renders candidates within 1s', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    await page.fill('#mapPiInput', '2c,a1,f4');
-    await page.click('#mapPiSubmit');
-    // Wait for results or error (both indicate API round-trip complete).
-    await expect(page.locator('#mapPiResults table, #mapPiResults .no-results, #mapPiError')).toBeVisible({ timeout: 1000 });
-  });
-
-  test('Show on Map button draws polyline on map', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    await page.fill('#mapPiInput', '2c,a1');
-    await page.click('#mapPiSubmit');
-    // Wait for results.
-    const btn = page.locator('#mapPiResults button[data-idx="0"]');
-    await btn.waitFor({ timeout: 2000 });
-    await btn.click();
-    // Check that route layer has SVG polyline paths drawn.
-    const svg = page.locator('#leaflet-map .leaflet-overlay-pane svg path');
-    await expect(svg.first()).toBeVisible({ timeout: 2000 });
-  });
-
-  test('switching candidate clears prior polyline', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    await page.fill('#mapPiInput', '2c,a1');
-    await page.click('#mapPiSubmit');
-    const btn0 = page.locator('#mapPiResults button[data-idx="0"]');
-    await btn0.waitFor({ timeout: 2000 });
-    await btn0.click();
-    // Click second candidate if available.
-    const btn1 = page.locator('#mapPiResults button[data-idx="1"]');
-    if (await btn1.isVisible()) {
-      await btn1.click();
-      // Prior route should be cleared — only one polyline group visible.
-    }
-  });
-});
-
-test.describe('Path Inspector — Standalone Page', () => {
-  test('deep link auto-fills and runs', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/tools/path-inspector?prefixes=2c,a1,f4`);
-    const input = page.locator('#path-inspector-input');
-    await expect(input).toHaveValue('2c,a1,f4');
-    // Should auto-submit and show results or error.
-    await expect(page.locator('#path-inspector-results table, #path-inspector-results .no-results, #path-inspector-error')).toBeVisible({ timeout: 2000 });
-  });
-
-  test('old #/traces/<hash> redirects to #/tools/trace/<hash>', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/traces/abc123`);
-    await page.waitForTimeout(500);
-    expect(page.url()).toContain('#/tools/trace/abc123');
-  });
-});
-
-test.describe('Path Inspector — Tools Landing (spec §2.8)', () => {
-  test('Tools nav shows landing with both entries', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/tools`);
-    await expect(page.locator('.tools-landing')).toBeVisible();
-    await expect(page.locator('a[href="#/tools/path-inspector"]')).toBeVisible();
-    await expect(page.locator('a[href*="#/tools/trace"]')).toBeVisible();
-  });
-});

test-path-inspector.js

@@ -1,106 +0,0 @@
-// test-path-inspector.js — vm.createContext sandbox tests for path-inspector.js
-'use strict';
-const vm = require('vm');
-const fs = require('fs');
-const assert = require('assert');
-
-const src = fs.readFileSync(__dirname + '/public/path-inspector.js', 'utf8');
-
-function createSandbox() {
-  const sandbox = {
-    window: {},
-    document: {
-      getElementById: () => ({ textContent: '', innerHTML: '', addEventListener: () => {}, querySelectorAll: () => [] }),
-      querySelectorAll: () => []
-    },
-    location: { hash: '#/tools/path-inspector' },
-    history: { replaceState: () => {} },
-    fetch: () => Promise.resolve({ ok: true, json: () => Promise.resolve({ candidates: [] }) }),
-    URLSearchParams: URLSearchParams,
-    registerPage: function () {},
-    escapeHtml: s => s,
-    console: console
-  };
-  sandbox.self = sandbox;
-  sandbox.globalThis = sandbox;
-  const ctx = vm.createContext(sandbox);
-  vm.runInContext(src, ctx);
-  return sandbox;
-}
-
-// Test: parsePrefixes accepts comma-separated.
-(function testParseComma() {
-  const sb = createSandbox();
-  const result = sb.window.PathInspector.parsePrefixes('2C,A1,F4');
-  assert.strictEqual(JSON.stringify(result), JSON.stringify(['2c', 'a1', 'f4']));
-  console.log('✓ parsePrefixes comma-separated');
-})();
-
-// Test: parsePrefixes accepts space-separated.
-(function testParseSpace() {
-  const sb = createSandbox();
-  const result = sb.window.PathInspector.parsePrefixes('2C A1 F4');
-  assert.strictEqual(JSON.stringify(result), JSON.stringify(['2c', 'a1', 'f4']));
-  console.log('✓ parsePrefixes space-separated');
-})();
-
-// Test: parsePrefixes accepts mixed.
-(function testParseMixed() {
-  const sb = createSandbox();
-  const result = sb.window.PathInspector.parsePrefixes(' 2C, A1  F4 ');
-  assert.strictEqual(JSON.stringify(result), JSON.stringify(['2c', 'a1', 'f4']));
-  console.log('✓ parsePrefixes mixed separators');
-})();
-
-// Test: validatePrefixes rejects empty.
-(function testValidateEmpty() {
-  const sb = createSandbox();
-  const err = sb.window.PathInspector.validatePrefixes([]);
-  assert.ok(err !== null, 'should reject empty');
-  console.log('✓ validatePrefixes rejects empty');
-})();
-
-// Test: validatePrefixes rejects odd-length.
-(function testValidateOdd() {
-  const sb = createSandbox();
-  const err = sb.window.PathInspector.validatePrefixes(['abc']);
-  assert.ok(err !== null && err.includes('Odd'), 'should reject odd-length');
-  console.log('✓ validatePrefixes rejects odd-length');
-})();
-
-// Test: validatePrefixes rejects >3 bytes.
-(function testValidateTooLong() {
-  const sb = createSandbox();
-  const err = sb.window.PathInspector.validatePrefixes(['aabbccdd']);
-  assert.ok(err !== null && err.includes('too long'), 'should reject >3 bytes');
-  console.log('✓ validatePrefixes rejects >3 bytes');
-})();
-
-// Test: validatePrefixes rejects mixed lengths.
-(function testValidateMixed() {
-  const sb = createSandbox();
-  const err = sb.window.PathInspector.validatePrefixes(['aa', 'bbcc']);
-  assert.ok(err !== null && err.includes('Mixed'), 'should reject mixed');
-  console.log('✓ validatePrefixes rejects mixed lengths');
-})();
-
-// Test: validatePrefixes accepts valid input.
-(function testValidateValid() {
-  const sb = createSandbox();
-  const err = sb.window.PathInspector.validatePrefixes(['2c', 'a1', 'f4']);
-  assert.strictEqual(err, null);
-  console.log('✓ validatePrefixes accepts valid');
-})();
-
-// Test: validatePrefixes rejects invalid hex.
-(function testValidateInvalidHex() {
-  const sb = createSandbox();
-  const err = sb.window.PathInspector.validatePrefixes(['zz']);
-  assert.ok(err !== null && err.includes('Invalid hex'), 'should reject invalid hex');
-  console.log('✓ validatePrefixes rejects invalid hex');
-})();
-
-// Anti-tautology: if validation were removed (always return null), the odd-length test would fail.
-// Mental revert: validatePrefixes = () => null; → testValidateOdd would fail because err would be null.
-
-console.log('\nAll path-inspector tests passed!');

tools/geofilter-builder.html

@@ -72,8 +72,7 @@ let polygon = null;
 let closingLine = null;
 
 function latLonPair(latlng) {
-  const w = latlng.wrap();
-  return [parseFloat(w.lat.toFixed(6)), parseFloat(w.lng.toFixed(6))];
+  return [parseFloat(latlng.lat.toFixed(6)), parseFloat(latlng.lng.toFixed(6))];
 }
 
 function render() {