fix: address PR #905 review — migration error handling, backfill heuristic, test comment

1. Migration ALTER error no longer swallowed: check error from ALTER TABLE
   and return if it fails (unless column already exists). Migration is not
   marked complete on failure.

2. Backfill heuristic fixed: use observations table JOIN instead of
   packet_count > 0, since UpsertObserver sets packet_count = 1 on INSERT
   even for status-only observers.

3. Test clarifying comment: document that InsertTransmission uses
   data.Timestamp (not time.Now()) as source-of-truth for last_packet_at,
   so the hardcoded assertion is correct.

.badges/e2e-tests.json

@@ -1 +1 @@
-{"schemaVersion":1,"label":"e2e tests","message":"82 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.26%","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: |
@@ -359,7 +372,7 @@ jobs:
   # ───────────────────────────────────────────────────────────────
   deploy:
     name: "🚀 Deploy Staging"
-    if: false  # disabled: staging VM offline, manual deploy required
+    if: github.event_name == 'push'
     needs: [build-and-publish]
     runs-on: [self-hosted, meshcore-runner-2]
     steps:
@@ -448,8 +461,8 @@ jobs:
   publish:
     name: "📝 Publish Badges & Summary"
     if: github.event_name == 'push'
-    needs: [build-and-publish]
-    runs-on: ubuntu-latest
+    needs: [deploy]
+    runs-on: [self-hosted, Linux]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5

cmd/ingestor/db.go

@@ -113,7 +113,8 @@ func applySchema(db *sql.DB) error {
 			battery_mv INTEGER,
 			uptime_secs INTEGER,
 			noise_floor REAL,
-			inactive INTEGER DEFAULT 0
+			inactive INTEGER DEFAULT 0,
+			last_packet_at TEXT DEFAULT NULL
 		);
 
 		CREATE INDEX IF NOT EXISTS idx_nodes_last_seen ON nodes(last_seen);
@@ -418,6 +419,28 @@ func applySchema(db *sql.DB) error {
 		log.Println("[migration] observations.raw_hex column added")
 	}
 
+	// Migration: add last_packet_at column to observers (#last-packet-at)
+	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observers_last_packet_at_v1'")
+	if row.Scan(&migDone) != nil {
+		log.Println("[migration] Adding last_packet_at column to observers...")
+		_, alterErr := db.Exec(`ALTER TABLE observers ADD COLUMN last_packet_at TEXT DEFAULT NULL`)
+		if alterErr != nil && !strings.Contains(alterErr.Error(), "duplicate column") {
+			return fmt.Errorf("observers last_packet_at ALTER: %w", alterErr)
+		}
+		// Backfill: set last_packet_at = last_seen only for observers that actually have
+		// observation rows (packet_count alone is unreliable — UpsertObserver sets it to 1
+		// on INSERT even for status-only observers).
+		res, err := db.Exec(`UPDATE observers SET last_packet_at = last_seen
+			WHERE last_packet_at IS NULL
+			AND rowid IN (SELECT DISTINCT observer_idx FROM observations WHERE observer_idx IS NOT NULL)`)
+		if err == nil {
+			n, _ := res.RowsAffected()
+			log.Printf("[migration] Backfilled last_packet_at for %d observers with packets", n)
+		}
+		db.Exec(`INSERT INTO _migrations (name) VALUES ('observers_last_packet_at_v1')`)
+		log.Println("[migration] observers.last_packet_at column added")
+	}
+
 	return nil
 }
 
@@ -501,7 +524,7 @@ func (s *Store) prepareStatements() error {
 		return err
 	}
 
-	s.stmtUpdateObserverLastSeen, err = s.db.Prepare("UPDATE observers SET last_seen = ? WHERE rowid = ?")
+	s.stmtUpdateObserverLastSeen, err = s.db.Prepare("UPDATE observers SET last_seen = ?, last_packet_at = ? WHERE rowid = ?")
 	if err != nil {
 		return err
 	}
@@ -580,9 +603,9 @@ func (s *Store) InsertTransmission(data *PacketData) (bool, error) {
 		err := s.stmtGetObserverRowid.QueryRow(data.ObserverID).Scan(&rowid)
 		if err == nil {
 			observerIdx = &rowid
-			// Update observer last_seen on every packet to prevent
+			// Update observer last_seen and last_packet_at on every packet to prevent
 			// low-traffic observers from appearing offline (#463)
-			_, _ = s.stmtUpdateObserverLastSeen.Exec(now, rowid)
+			_, _ = s.stmtUpdateObserverLastSeen.Exec(now, now, rowid)
 		}
 	}
 

cmd/ingestor/db_test.go

@@ -569,6 +569,61 @@ func TestInsertTransmissionUpdatesObserverLastSeen(t *testing.T) {
 	}
 }
 
+func TestLastPacketAtUpdatedOnPacketOnly(t *testing.T) {
+	s, err := OpenStore(tempDBPath(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Close()
+
+	// Insert observer via status path — last_packet_at should be NULL
+	if err := s.UpsertObserver("obs1", "Observer1", "SJC", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	var lastPacketAt sql.NullString
+	s.db.QueryRow("SELECT last_packet_at FROM observers WHERE id = ?", "obs1").Scan(&lastPacketAt)
+	if lastPacketAt.Valid {
+		t.Fatalf("expected last_packet_at to be NULL after UpsertObserver, got %s", lastPacketAt.String)
+	}
+
+	// Insert a packet from this observer — last_packet_at should be set
+	data := &PacketData{
+		RawHex:      "0A00D69F",
+		Timestamp:   "2026-04-24T12:00:00Z",
+		ObserverID:  "obs1",
+		Hash:        "lastpackettest123456",
+		RouteType:   2,
+		PayloadType: 2,
+		PathJSON:    "[]",
+		DecodedJSON: `{"type":"TXT_MSG"}`,
+	}
+	if _, err := s.InsertTransmission(data); err != nil {
+		t.Fatal(err)
+	}
+
+	s.db.QueryRow("SELECT last_packet_at FROM observers WHERE id = ?", "obs1").Scan(&lastPacketAt)
+	if !lastPacketAt.Valid {
+		t.Fatal("expected last_packet_at to be non-NULL after InsertTransmission")
+	}
+	// InsertTransmission uses `now = data.Timestamp || time.Now()`, so last_packet_at
+	// should match the packet's Timestamp when provided (same source-of-truth as last_seen).
+	if lastPacketAt.String != "2026-04-24T12:00:00Z" {
+		t.Errorf("expected last_packet_at=2026-04-24T12:00:00Z, got %s", lastPacketAt.String)
+	}
+
+	// UpsertObserver again (status path) — last_packet_at should NOT change
+	if err := s.UpsertObserver("obs1", "Observer1", "SJC", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	var lastPacketAtAfterStatus sql.NullString
+	s.db.QueryRow("SELECT last_packet_at FROM observers WHERE id = ?", "obs1").Scan(&lastPacketAtAfterStatus)
+	if !lastPacketAtAfterStatus.Valid || lastPacketAtAfterStatus.String != lastPacketAt.String {
+		t.Errorf("UpsertObserver should not change last_packet_at; expected %s, got %v", lastPacketAt.String, lastPacketAtAfterStatus)
+	}
+}
+
 func TestEndToEndIngest(t *testing.T) {
 	s, err := OpenStore(tempDBPath(t))
 	if err != nil {

cmd/server/concurrent_ingest_eviction_test.go

@@ -1,403 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-// TestConcurrentIngestAndEviction exercises the race between IngestNewFromDB
-// adding packets (via direct store manipulation simulating the locked section)
-// and RunEviction removing packets. Without proper locking this would trigger
-// the race detector and produce inconsistent index state.
-func TestConcurrentIngestAndEviction(t *testing.T) {
-	// Seed store with 200 old packets that are eligible for eviction
-	startTime := time.Now().UTC().Add(-48 * time.Hour)
-	store := makeTestStore(200, startTime, 1)
-	store.retentionHours = 24 // everything older than 24h is evictable
-	store.loaded = true
-
-	// Track bytes for all seeded packets
-	for _, tx := range store.packets {
-		store.trackedBytes += estimateStoreTxBytes(tx)
-		for _, obs := range tx.Observations {
-			store.trackedBytes += estimateStoreObsBytes(obs)
-		}
-	}
-
-	const numIngestGoroutines = 5
-	const packetsPerGoroutine = 50
-	const numEvictionGoroutines = 3
-
-	var wg sync.WaitGroup
-	var ingestedCount int64
-
-	// Concurrent ingest: simulate what IngestNewFromDB does under the lock
-	for g := 0; g < numIngestGoroutines; g++ {
-		wg.Add(1)
-		go func(goroutineID int) {
-			defer wg.Done()
-			for i := 0; i < packetsPerGoroutine; i++ {
-				txID := 1000 + goroutineID*1000 + i
-				hash := fmt.Sprintf("new_hash_%d_%04d", goroutineID, i)
-				pt := 5 // GRP_TXT
-				ts := time.Now().UTC().Format(time.RFC3339)
-
-				tx := &StoreTx{
-					ID:          txID,
-					Hash:        hash,
-					FirstSeen:   ts,
-					LatestSeen:  ts,
-					PayloadType: &pt,
-					DecodedJSON: fmt.Sprintf(`{"pubKey":"newpk_%d_%04d"}`, goroutineID, i),
-					obsKeys:     make(map[string]bool),
-					observerSet: make(map[string]bool),
-				}
-
-				obs := &StoreObs{
-					ID:             txID*10 + 1,
-					TransmissionID: txID,
-					ObserverID:     fmt.Sprintf("obs_g%d", goroutineID),
-					ObserverName:   fmt.Sprintf("Observer_g%d", goroutineID),
-					Timestamp:      ts,
-				}
-				tx.Observations = append(tx.Observations, obs)
-				tx.ObservationCount = 1
-
-				// Acquire write lock (same as IngestNewFromDB)
-				store.mu.Lock()
-				store.packets = append(store.packets, tx)
-				store.byHash[hash] = tx
-				store.byTxID[txID] = tx
-				store.byObsID[obs.ID] = obs
-				store.byObserver[obs.ObserverID] = append(store.byObserver[obs.ObserverID], obs)
-				store.byPayloadType[pt] = append(store.byPayloadType[pt], tx)
-				pk := fmt.Sprintf("newpk_%d_%04d", goroutineID, i)
-				if store.nodeHashes[pk] == nil {
-					store.nodeHashes[pk] = make(map[string]bool)
-				}
-				store.nodeHashes[pk][hash] = true
-				store.byNode[pk] = append(store.byNode[pk], tx)
-				store.trackedBytes += estimateStoreTxBytes(tx)
-				store.trackedBytes += estimateStoreObsBytes(obs)
-				store.totalObs++
-				store.mu.Unlock()
-
-				atomic.AddInt64(&ingestedCount, 1)
-			}
-		}(g)
-	}
-
-	// Concurrent eviction goroutines
-	var evictedTotal int64
-	for g := 0; g < numEvictionGoroutines; g++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for i := 0; i < 10; i++ {
-				store.mu.Lock()
-				n := store.EvictStale()
-				store.mu.Unlock()
-				atomic.AddInt64(&evictedTotal, int64(n))
-				time.Sleep(time.Millisecond)
-			}
-		}()
-	}
-
-	// Concurrent readers (QueryPackets uses RLock)
-	for g := 0; g < 3; g++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for i := 0; i < 20; i++ {
-				store.mu.RLock()
-				_ = len(store.packets)
-				_ = len(store.byHash)
-				store.mu.RUnlock()
-				time.Sleep(500 * time.Microsecond)
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	// --- Post-state assertions ---
-	store.mu.RLock()
-	defer store.mu.RUnlock()
-
-	totalIngested := int(atomic.LoadInt64(&ingestedCount))
-	totalEvicted := int(atomic.LoadInt64(&evictedTotal))
-
-	if totalIngested != numIngestGoroutines*packetsPerGoroutine {
-		t.Fatalf("expected %d ingested, got %d", numIngestGoroutines*packetsPerGoroutine, totalIngested)
-	}
-
-	// Invariant: packets remaining = initial(200) + ingested - evicted
-	expectedRemaining := 200 + totalIngested - totalEvicted
-	if len(store.packets) != expectedRemaining {
-		t.Fatalf("packets count mismatch: got %d, expected %d (200 + %d ingested - %d evicted)",
-			len(store.packets), expectedRemaining, totalIngested, totalEvicted)
-	}
-
-	// Invariant: byHash must be consistent with packets slice
-	if len(store.byHash) != len(store.packets) {
-		t.Fatalf("byHash size %d != packets len %d", len(store.byHash), len(store.packets))
-	}
-
-	// Invariant: every packet in the slice must be in byHash
-	for _, tx := range store.packets {
-		if store.byHash[tx.Hash] != tx {
-			t.Fatalf("packet %s in slice but not in byHash (or points to different tx)", tx.Hash)
-		}
-	}
-
-	// Invariant: byTxID must map to packets in the slice
-	byTxIDCount := 0
-	for _, tx := range store.packets {
-		if store.byTxID[tx.ID] == tx {
-			byTxIDCount++
-		}
-	}
-	if byTxIDCount != len(store.packets) {
-		t.Fatalf("byTxID consistency: %d/%d packets found", byTxIDCount, len(store.packets))
-	}
-
-	// Invariant: trackedBytes must be non-negative
-	if store.trackedBytes < 0 {
-		t.Fatalf("trackedBytes went negative: %d", store.trackedBytes)
-	}
-
-	// Verify eviction actually happened (old packets were eligible)
-	if totalEvicted == 0 {
-		t.Fatal("expected some evictions to occur but got 0")
-	}
-
-	t.Logf("OK: ingested=%d, evicted=%d, remaining=%d, trackedBytes=%d",
-		totalIngested, totalEvicted, len(store.packets), store.trackedBytes)
-}
-
-// TestConcurrentIngestNewObservationsAndEviction exercises the race between
-// adding new observations to existing transmissions and eviction removing those
-// same transmissions. This targets the IngestNewObservations path.
-func TestConcurrentIngestNewObservationsAndEviction(t *testing.T) {
-	// Create store with 100 packets, half old (evictable), half recent
-	now := time.Now().UTC()
-	store := makeTestStore(0, now, 1) // empty, we'll add manually
-	store.retentionHours = 1
-
-	// Add 50 old packets (2h ago) and 50 recent packets
-	for i := 0; i < 100; i++ {
-		var ts time.Time
-		if i < 50 {
-			ts = now.Add(-2 * time.Hour).Add(time.Duration(i) * time.Second)
-		} else {
-			ts = now.Add(-time.Duration(100-i) * time.Second)
-		}
-		hash := fmt.Sprintf("obs_hash_%04d", i)
-		txID := i + 1
-		pt := 4
-		tx := &StoreTx{
-			ID:          txID,
-			Hash:        hash,
-			FirstSeen:   ts.UTC().Format(time.RFC3339),
-			LatestSeen:  ts.UTC().Format(time.RFC3339),
-			PayloadType: &pt,
-			DecodedJSON: fmt.Sprintf(`{"pubKey":"pk%04d"}`, i),
-			obsKeys:     make(map[string]bool),
-			observerSet: make(map[string]bool),
-		}
-		store.packets = append(store.packets, tx)
-		store.byHash[hash] = tx
-		store.byTxID[txID] = tx
-		store.byPayloadType[pt] = append(store.byPayloadType[pt], tx)
-		store.trackedBytes += estimateStoreTxBytes(tx)
-	}
-	store.loaded = true
-
-	const numObsGoroutines = 4
-	const obsPerGoroutine = 100
-
-	var wg sync.WaitGroup
-	var addedObs int64
-
-	// Goroutines adding observations to RECENT packets (index 50-99)
-	for g := 0; g < numObsGoroutines; g++ {
-		wg.Add(1)
-		go func(gID int) {
-			defer wg.Done()
-			for i := 0; i < obsPerGoroutine; i++ {
-				targetIdx := 50 + (i % 50) // only target recent packets
-				hash := fmt.Sprintf("obs_hash_%04d", targetIdx)
-
-				store.mu.Lock()
-				tx := store.byHash[hash]
-				if tx != nil {
-					obsID := 50000 + gID*10000 + i
-					obs := &StoreObs{
-						ID:             obsID,
-						TransmissionID: tx.ID,
-						ObserverID:     fmt.Sprintf("obs_new_%d", gID),
-						ObserverName:   fmt.Sprintf("NewObs_%d", gID),
-						Timestamp:      time.Now().UTC().Format(time.RFC3339),
-					}
-					dk := obs.ObserverID + "|"
-					if !tx.obsKeys[dk] || true { // allow duplicates for stress
-						tx.Observations = append(tx.Observations, obs)
-						tx.ObservationCount++
-						store.byObsID[obsID] = obs
-						store.byObserver[obs.ObserverID] = append(store.byObserver[obs.ObserverID], obs)
-						store.trackedBytes += estimateStoreObsBytes(obs)
-						store.totalObs++
-						atomic.AddInt64(&addedObs, 1)
-					}
-				}
-				store.mu.Unlock()
-			}
-		}(g)
-	}
-
-	// Concurrent eviction
-	var evictedTotal int64
-	for g := 0; g < 2; g++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for i := 0; i < 15; i++ {
-				store.mu.Lock()
-				n := store.EvictStale()
-				store.mu.Unlock()
-				atomic.AddInt64(&evictedTotal, int64(n))
-				time.Sleep(500 * time.Microsecond)
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	// --- Assertions ---
-	store.mu.RLock()
-	defer store.mu.RUnlock()
-
-	totalEvicted := int(atomic.LoadInt64(&evictedTotal))
-	totalAdded := int(atomic.LoadInt64(&addedObs))
-
-	// All 50 old packets should have been evicted
-	if totalEvicted < 50 {
-		t.Fatalf("expected at least 50 evictions (old packets), got %d", totalEvicted)
-	}
-
-	// Recent packets (50) should survive
-	if len(store.packets) < 50 {
-		t.Fatalf("expected at least 50 remaining packets (recent ones), got %d", len(store.packets))
-	}
-
-	// byHash consistency
-	for _, tx := range store.packets {
-		if store.byHash[tx.Hash] != tx {
-			t.Fatalf("byHash inconsistency for %s", tx.Hash)
-		}
-	}
-
-	// No evicted packet should remain in byHash
-	for i := 0; i < 50; i++ {
-		hash := fmt.Sprintf("obs_hash_%04d", i)
-		if store.byHash[hash] != nil {
-			t.Fatalf("evicted packet %s still in byHash", hash)
-		}
-	}
-
-	// byObsID should not reference observations from evicted packets
-	for obsID, obs := range store.byObsID {
-		if store.byTxID[obs.TransmissionID] == nil {
-			t.Fatalf("byObsID[%d] references evicted transmission %d", obsID, obs.TransmissionID)
-		}
-	}
-
-	// trackedBytes non-negative
-	if store.trackedBytes < 0 {
-		t.Fatalf("trackedBytes negative: %d", store.trackedBytes)
-	}
-
-	t.Logf("OK: evicted=%d, added_obs=%d, remaining=%d, trackedBytes=%d",
-		totalEvicted, totalAdded, len(store.packets), store.trackedBytes)
-}
-
-// TestConcurrentRunEvictionWithReads exercises RunEviction's two-phase locking
-// against concurrent read operations (simulating QueryPackets / GetStoreStats).
-// Without proper RWMutex usage, this would race on slice/map reads.
-func TestConcurrentRunEvictionWithReads(t *testing.T) {
-	startTime := time.Now().UTC().Add(-3 * time.Hour)
-	store := makeTestStore(500, startTime, 1)
-	store.retentionHours = 1
-	store.loaded = true
-
-	for _, tx := range store.packets {
-		store.trackedBytes += estimateStoreTxBytes(tx)
-		for _, obs := range tx.Observations {
-			store.trackedBytes += estimateStoreObsBytes(obs)
-		}
-	}
-
-	var wg sync.WaitGroup
-
-	// Multiple RunEviction calls (uses its own locking)
-	var evicted int64
-	for g := 0; g < 3; g++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			n := store.RunEviction()
-			atomic.AddInt64(&evicted, int64(n))
-		}()
-	}
-
-	// Concurrent readers using the public read-lock pattern
-	var readCount int64
-	for g := 0; g < 5; g++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for i := 0; i < 50; i++ {
-				store.mu.RLock()
-				count := len(store.packets)
-				_ = count
-				// Iterate a portion of byHash (simulating query)
-				for hash, tx := range store.byHash {
-					_ = hash
-					_ = tx.ObservationCount
-					break // just access one
-				}
-				store.mu.RUnlock()
-				atomic.AddInt64(&readCount, 1)
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	store.mu.RLock()
-	defer store.mu.RUnlock()
-
-	totalEvicted := int(atomic.LoadInt64(&evicted))
-
-	// Must have evicted packets older than 1h (most of the 500 are 1-3h old)
-	if totalEvicted == 0 {
-		t.Fatal("expected evictions but got 0")
-	}
-
-	// Consistency: byHash == packets len
-	if len(store.byHash) != len(store.packets) {
-		t.Fatalf("byHash %d != packets %d after concurrent RunEviction+reads",
-			len(store.byHash), len(store.packets))
-	}
-
-	// All reads completed without panic
-	if atomic.LoadInt64(&readCount) != 250 {
-		t.Fatalf("not all reads completed: %d/250", atomic.LoadInt64(&readCount))
-	}
-
-	t.Logf("OK: evicted=%d, remaining=%d, reads=%d",
-		totalEvicted, len(store.packets), atomic.LoadInt64(&readCount))
-}

cmd/server/coverage_test.go

@@ -763,9 +763,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 +805,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 +820,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)
 

cmd/server/db.go

@@ -170,6 +170,7 @@ type Observer struct {
 	BatteryMv     *int     `json:"battery_mv"`
 	UptimeSecs    *int64   `json:"uptime_secs"`
 	NoiseFloor    *float64 `json:"noise_floor"`
+	LastPacketAt  *string  `json:"last_packet_at"`
 }
 
 // Transmission represents a row from the transmissions table.
@@ -972,7 +973,7 @@ func (db *DB) getObservationsForTransmissions(txIDs []int) map[int][]map[string]
 
 // GetObservers returns all observers sorted by last_seen DESC.
 func (db *DB) GetObservers() ([]Observer, error) {
-	rows, err := db.conn.Query("SELECT id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor FROM observers ORDER BY last_seen DESC")
+	rows, err := db.conn.Query("SELECT id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor, last_packet_at FROM observers ORDER BY last_seen DESC")
 	if err != nil {
 		return nil, err
 	}
@@ -983,7 +984,7 @@ func (db *DB) GetObservers() ([]Observer, error) {
 		var o Observer
 		var batteryMv, uptimeSecs sql.NullInt64
 		var noiseFloor sql.NullFloat64
-		if err := rows.Scan(&o.ID, &o.Name, &o.IATA, &o.LastSeen, &o.FirstSeen, &o.PacketCount, &o.Model, &o.Firmware, &o.ClientVersion, &o.Radio, &batteryMv, &uptimeSecs, &noiseFloor); err != nil {
+		if err := rows.Scan(&o.ID, &o.Name, &o.IATA, &o.LastSeen, &o.FirstSeen, &o.PacketCount, &o.Model, &o.Firmware, &o.ClientVersion, &o.Radio, &batteryMv, &uptimeSecs, &noiseFloor, &o.LastPacketAt); err != nil {
 			continue
 		}
 		if batteryMv.Valid {
@@ -1006,8 +1007,8 @@ func (db *DB) GetObserverByID(id string) (*Observer, error) {
 	var o Observer
 	var batteryMv, uptimeSecs sql.NullInt64
 	var noiseFloor sql.NullFloat64
-	err := db.conn.QueryRow("SELECT id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor FROM observers WHERE id = ?", id).
-		Scan(&o.ID, &o.Name, &o.IATA, &o.LastSeen, &o.FirstSeen, &o.PacketCount, &o.Model, &o.Firmware, &o.ClientVersion, &o.Radio, &batteryMv, &uptimeSecs, &noiseFloor)
+	err := db.conn.QueryRow("SELECT id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor, last_packet_at FROM observers WHERE id = ?", id).
+		Scan(&o.ID, &o.Name, &o.IATA, &o.LastSeen, &o.FirstSeen, &o.PacketCount, &o.Model, &o.Firmware, &o.ClientVersion, &o.Radio, &batteryMv, &uptimeSecs, &noiseFloor, &o.LastPacketAt)
 	if err != nil {
 		return nil, err
 	}

cmd/server/db_test.go

@@ -48,7 +48,8 @@ func setupTestDB(t *testing.T) *DB {
 			radio TEXT,
 			battery_mv INTEGER,
 			uptime_secs INTEGER,
-			noise_floor REAL
+			noise_floor REAL,
+			last_packet_at TEXT DEFAULT NULL
 		);
 
 		CREATE TABLE transmissions (
@@ -355,6 +356,10 @@ func TestGetObservers(t *testing.T) {
 	if observers[0].ID != "obs1" {
 		t.Errorf("expected obs1 first (most recent), got %s", observers[0].ID)
 	}
+	// last_packet_at should be nil since seedTestData doesn't set it
+	if observers[0].LastPacketAt != nil {
+		t.Errorf("expected nil LastPacketAt for obs1 from seed, got %v", *observers[0].LastPacketAt)
+	}
 }
 
 func TestGetObserverByID(t *testing.T) {
@@ -369,6 +374,48 @@ func TestGetObserverByID(t *testing.T) {
 	if obs.ID != "obs1" {
 		t.Errorf("expected obs1, got %s", obs.ID)
 	}
+	// Verify last_packet_at is nil by default
+	if obs.LastPacketAt != nil {
+		t.Errorf("expected nil LastPacketAt, got %v", *obs.LastPacketAt)
+	}
+}
+
+func TestGetObserverLastPacketAt(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+
+	// Set last_packet_at for obs1
+	ts := "2026-04-24T12:00:00Z"
+	db.conn.Exec(`UPDATE observers SET last_packet_at = ? WHERE id = ?`, ts, "obs1")
+
+	// Verify via GetObservers
+	observers, err := db.GetObservers()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var obs1 *Observer
+	for i := range observers {
+		if observers[i].ID == "obs1" {
+			obs1 = &observers[i]
+			break
+		}
+	}
+	if obs1 == nil {
+		t.Fatal("obs1 not found")
+	}
+	if obs1.LastPacketAt == nil || *obs1.LastPacketAt != ts {
+		t.Errorf("expected LastPacketAt=%s via GetObservers, got %v", ts, obs1.LastPacketAt)
+	}
+
+	// Verify via GetObserverByID
+	obs, err := db.GetObserverByID("obs1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if obs.LastPacketAt == nil || *obs.LastPacketAt != ts {
+		t.Errorf("expected LastPacketAt=%s via GetObserverByID, got %v", ts, obs.LastPacketAt)
+	}
 }
 
 func TestGetObserverByIDNotFound(t *testing.T) {
@@ -1109,7 +1156,8 @@ func setupTestDBV2(t *testing.T) *DB {
 			iata TEXT,
 			last_seen TEXT,
 			first_seen TEXT,
-			packet_count INTEGER DEFAULT 0
+			packet_count INTEGER DEFAULT 0,
+			last_packet_at TEXT DEFAULT NULL
 		);
 
 		CREATE TABLE transmissions (

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_test.go

@@ -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)
 
@@ -437,8 +437,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/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/store.go

@@ -4551,20 +4551,9 @@ type prefixMap struct {
 // entries to ~7×N (+ 1 full-key entry per node for exact-match lookups).
 const maxPrefixLen = 8
 
-// canAppearInPath returns true if the node's role allows it to appear as a
-// path hop.  Only repeaters, room servers, and rooms can forward packets;
-// companions and sensors originate but never relay.
-func canAppearInPath(role string) bool {
-	r := strings.ToLower(role)
-	return strings.Contains(r, "repeater") || strings.Contains(r, "room_server") || r == "room"
-}
-
 func buildPrefixMap(nodes []nodeInfo) *prefixMap {
 	pm := &prefixMap{m: make(map[string][]nodeInfo, len(nodes)*(maxPrefixLen+1))}
 	for _, n := range nodes {
-		if !canAppearInPath(n.Role) {
-			continue
-		}
 		pk := strings.ToLower(n.PublicKey)
 		maxLen := maxPrefixLen
 		if maxLen > len(pk) {

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] = [];

public/observer-detail.js

@@ -150,6 +150,14 @@
           <div class="stat-label">First Seen</div>
           <div class="stat-value" style="font-size:0.85em">${obs.first_seen ? new Date(obs.first_seen).toLocaleDateString() : '—'}</div>
         </div>
+        <div class="stat-card">
+          <div class="stat-label">Last Status Update</div>
+          <div class="stat-value" style="font-size:0.85em">${obs.last_seen ? timeAgo(obs.last_seen) + '<br><span style="font-size:0.8em;color:var(--text-muted)">' + new Date(obs.last_seen).toLocaleString() + '</span>' : '—'}</div>
+        </div>
+        <div class="stat-card">
+          <div class="stat-label">Last Packet Observation</div>
+          <div class="stat-value" style="font-size:0.85em">${obs.last_packet_at ? timeAgo(obs.last_packet_at) + '<br><span style="font-size:0.8em;color:var(--text-muted)">' + new Date(obs.last_packet_at).toLocaleString() + '</span>' : '<span style="color:var(--text-muted)">never</span>'}</div>
+        </div>
       </div>
       <div class="mono" style="font-size:0.75em;color:var(--text-muted);margin-bottom:20px;word-break:break-all">
         ID: ${obs.id}

public/observers.js

@@ -75,6 +75,17 @@
     return { cls: 'health-red', label: 'Offline' };
   }
 
+  function packetBadge(o) {
+    if (!o.last_packet_at) return '<span title="No packets ever observed">📡⚠ never</span>';
+    const pktAgo = Date.now() - new Date(o.last_packet_at).getTime();
+    const statusAgo = o.last_seen ? Date.now() - new Date(o.last_seen).getTime() : Infinity;
+    const gap = pktAgo - statusAgo;
+    if (gap > 600000) {
+      return `<span title="Last packet ${timeAgo(o.last_packet_at)} — status is newer by ${Math.round(gap/60000)}min. Observer may be alive but not forwarding packets.">📡⚠ ${timeAgo(o.last_packet_at)}</span>`;
+    }
+    return timeAgo(o.last_packet_at);
+  }
+
   function uptimeStr(firstSeen) {
     if (!firstSeen) return '—';
     const ms = Date.now() - new Date(firstSeen).getTime();
@@ -123,7 +134,7 @@
       <div class="obs-table-scroll"><table class="data-table obs-table" id="obsTable">
         <caption class="sr-only">Observer status and statistics</caption>
         <thead><tr>
-          <th scope="col">Status</th><th scope="col">Name</th><th scope="col">Region</th><th scope="col">Last Seen</th>
+          <th scope="col">Status</th><th scope="col">Name</th><th scope="col">Region</th><th scope="col">Last Status</th><th scope="col">Last Packet</th>
           <th scope="col">Packets</th><th scope="col">Packets/Hour</th><th scope="col">Uptime</th>
         </tr></thead>
         <tbody>${filtered.map(o => {
@@ -134,6 +145,7 @@
             <td class="mono">${o.name || o.id}</td>
             <td>${o.iata ? `<span class="badge-region">${o.iata}</span>` : '—'}</td>
             <td>${timeAgo(o.last_seen)}</td>
+            <td>${packetBadge(o)}</td>
             <td>${(o.packet_count || 0).toLocaleString()}</td>
             <td>${sparkBar(o.packetsLastHour || 0, maxPktsHr)}</td>
             <td>${uptimeStr(o.first_seen)}</td>

public/style.css

@@ -1556,7 +1556,7 @@ tr[data-hops]:hover { background: rgba(59,130,246,0.1); }
 
 /* #20 — Observers table horizontal scroll on mobile */
 .obs-table-scroll { overflow-x: auto; -webkit-overflow-scrolling: touch; }
-.obs-table-scroll .obs-table { min-width: 640px; }
+.obs-table-scroll .obs-table { min-width: 720px; }
 
 /* #206 — Analytics/Compare tables scroll wrappers on mobile */
 .analytics-table-scroll { overflow-x: auto; -webkit-overflow-scrolling: touch; }

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,7 +88,7 @@ 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);
@@ -97,9 +97,9 @@ 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 };
+const nodeEquator = { public_key: 'ab5555', name: 'EquatorNode', lat: 0, lon: 10 };
+const nodeFar = { public_key: 'ab6666', name: 'FarNode', lat: 60, lon: 60 };
+const anchorNearEq = { public_key: 'cd7777', name: 'AnchorEq', lat: 1, lon: 11 };
 HopResolver.init([nodeEquator, nodeFar, anchorNearEq]);
 HopResolver.setAffinity({});
 // Anchor near equator — EquatorNode (0,10) should be geo-closest
@@ -109,44 +109,13 @@ assert(result7['ab'].name === 'EquatorNode',
 
 // 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 };
+const nodePrime = { public_key: 'ab8888', name: 'PrimeMeridian', lat: 10, lon: 0 };
+const anchorNearPM = { public_key: 'cd9999', name: 'AnchorPM', 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);