Phase 4

Overhaul post-message fanout. Closes PR #37.

.dockerignore

@@ -29,6 +29,7 @@ frontend/src/test/
 # Docs
 *.md
 !README.md
+!LICENSES.md
 
 # Other
 references/

.gitignore

@@ -8,11 +8,12 @@ wheels/
 # Virtual environments
 .venv
 frontend/node_modules/
+frontend/package-lock.json
 frontend/test-results/
 
 # Frontend build output (built from source by end users)
 frontend/dist/
-frontend/package-lock.json
+frontend/.eslintcache
 
 # reference libraries
 references/

.python-version

@@ -1 +0,0 @@
-3.12

AGENTS.md

@@ -4,28 +4,25 @@
 
 **NEVER make git commits.** A human must make all commits. You may stage files and prepare commit messages, but do not run `git commit`.
 
-If instructed to "run all tests" or "get ready for a commit" or other summative, work ending directives, make sure you run the following and that they all pass green:
+If instructed to "run all tests" or "get ready for a commit" or other summative, work ending directives, run:
 
 ```bash
-uv run ruff check app/ tests/ --fix # check for python violations
-uv run ruff format app/ tests/ # format python
-uv run pyright app/ # type check python
-PYTHONPATH=. uv run pytest tests/ -v # test python
-
-cd frontend/ # move to frontend directory
-npm run lint:fix # fix lint violations
-npm run format # format the code
-npm run build # run a frontend build
+./scripts/all_quality.sh
 ```
 
+This runs all linting, formatting, type checking, tests, and builds for both backend and frontend sequentially. All checks must pass green.
+
 ## Overview
 
 A web interface for MeshCore mesh radio networks. The backend connects to a MeshCore-compatible radio over Serial, TCP, or BLE and exposes REST/WebSocket APIs. The React frontend provides real-time messaging and radio configuration.
 
-**For detailed component documentation, see:**
+**For detailed component documentation, see these primary AGENTS.md files:**
 - `app/AGENTS.md` - Backend (FastAPI, database, radio connection, packet decryption)
 - `frontend/AGENTS.md` - Frontend (React, state management, WebSocket, components)
-- `frontend/src/components/AGENTS.md` - Frontend visualizer feature (a particularly complex and long force-directed graph visualizer component; can skip this file unless you're working on that feature)
+
+Ancillary AGENTS.md files which should generally not be reviewed unless specific work is being performed on those features include:
+- `app/fanout/AGENTS_fanout.md` - Fanout bus architecture (MQTT, bots, webhooks, Apprise)
+- `frontend/src/components/AGENTS_packet_visualizer.md` - Packet visualizer (force-directed graph, advert-path identity, layout engine)
 
 ## Architecture Overview
 
@@ -78,7 +75,7 @@ A web interface for MeshCore mesh radio networks. The backend connects to a Mesh
 - Raw packet feed — a debug/observation tool ("radio aquarium"); interesting to watch or copy packets from, but not critical infrastructure
 - Map view — visual display of node locations from advertisements
 - Network visualizer — force-directed graph of mesh topology
-- Bot system — automated message responses
+- Fanout integrations (MQTT, bots, webhooks, Apprise) — see `app/fanout/AGENTS_fanout.md`
 - Read state tracking / mark-all-read — convenience feature for unread badges; no need for transactional atomicity or race-condition hardening
 
 ## Error Handling Philosophy
@@ -90,7 +87,7 @@ A web interface for MeshCore mesh radio networks. The backend connects to a Mesh
 1. **Store-and-serve**: Backend stores all packets even when no client is connected
 2. **Parallel storage**: Messages stored both decrypted (when possible) and as raw packets
 3. **Extended capacity**: Server stores contacts/channels beyond radio limits (~350 contacts, ~40 channels)
-4. **Real-time updates**: WebSocket pushes events; REST for actions
+4. **Real-time updates**: WebSocket pushes events; REST for actions; optional MQTT forwarding
 5. **Offline-capable**: Radio operates independently; server syncs when connected
 6. **Auto-reconnect**: Background monitor detects disconnection and attempts reconnection
 
@@ -100,15 +97,32 @@ The following are **deliberate design choices**, not bugs. They are documented i
 
 1. **No CORS restrictions**: The backend allows all origins (`allow_origins=["*"]`). This lets users access their radio from any device/origin on their network without configuration hassle.
 2. **No authentication or authorization**: There is no login, no API keys, no session management. The app is designed for trusted networks (home LAN, VPN). The README warns users not to expose it to untrusted networks.
-3. **Arbitrary bot code execution**: The bot system (`app/bot.py`) executes user-provided Python via `exec()` with full `__builtins__`. This is intentional — bots are a power-user feature for automation. The README explicitly warns that anyone on the network can execute arbitrary code through this.
+3. **Arbitrary bot code execution**: The bot system (`app/fanout/bot_exec.py`) executes user-provided Python via `exec()` with full `__builtins__`. This is intentional — bots are a power-user feature for automation. The README explicitly warns that anyone on the network can execute arbitrary code through this. Operators can set `MESHCORE_DISABLE_BOTS=true` to completely disable the bot system at startup — this skips all bot execution, returns 403 on bot settings updates, and shows a disabled message in the frontend.
+
+## Intentional Packet Handling Decision
+
+Raw packet handling uses two identities by design:
+- **`id` (DB packet row ID)**: storage identity from payload-hash deduplication (path bytes are excluded), so repeated payloads share one stored raw-packet row.
+- **`observation_id` (WebSocket only)**: realtime observation identity, unique per RF arrival, so path-diverse repeats are still visible in-session.
+
+Frontend packet-feed consumers should treat `observation_id` as the dedup/render key, while `id` remains the storage reference.
+
+## Contact Advert Path Memory
+
+To improve repeater disambiguation in the network visualizer, the backend stores recent unique advertisement paths per contact in a dedicated table (`contact_advert_paths`).
+
+- This is independent of raw-packet payload deduplication.
+- Paths are keyed per contact + path, with `heard_count`, `first_seen`, and `last_seen`.
+- Only the N most recent unique paths are retained per contact (currently 10).
+- See `frontend/src/components/AGENTS_packet_visualizer.md` § "Advert-Path Identity Hints" for how the visualizer consumes this data.
 
 ## Data Flow
 
 ### Incoming Messages
 
-1. Radio receives message → MeshCore library emits event
-2. `event_handlers.py` catches event → stores in database
-3. `ws_manager` broadcasts to connected clients
+1. Radio receives raw bytes → `packet_processor.py` parses, decrypts, deduplicates, and stores in database (primary path via `RX_LOG_DATA` event)
+2. `event_handlers.py` handles higher-level events (`CONTACT_MSG_RECV`, `ACK`) as a fallback/supplement
+3. `broadcast_event()` in `websocket.py` fans out to both WebSocket clients and MQTT
 4. Frontend `useWebSocket` receives → updates React state
 
 ### Outgoing Messages
@@ -123,7 +137,9 @@ The following are **deliberate design choices**, not bugs. They are documented i
 
 **Direct messages**: Expected ACK code is tracked. When ACK event arrives, message marked as acked.
 
-**Channel messages**: Flood messages echo back through repeaters. Repeats are identified by the database UNIQUE constraint on `(type, conversation_key, text, sender_timestamp)` — when an INSERT hits a duplicate, `_handle_duplicate_message()` in `packet_processor.py` increments the ack count on the original and adds the new path. There is no timestamp-windowed matching; deduplication is exact-match only.
+**Channel messages**: Flood messages echo back through repeaters. Repeats are identified by the database UNIQUE constraint on `(type, conversation_key, text, sender_timestamp)` — when an INSERT hits a duplicate, `_handle_duplicate_message()` in `packet_processor.py` adds the new path and, for outgoing messages only, increments the ack count. Incoming repeats add path data but do not change the ack count. There is no timestamp-windowed matching; deduplication is exact-match only.
+
+This message-layer echo/path handling is independent of raw-packet storage deduplication.
 
 ## Directory Structure
 
@@ -133,10 +149,12 @@ The following are **deliberate design choices**, not bugs. They are documented i
 │   ├── AGENTS.md           # Backend documentation
 │   ├── main.py             # App entry, lifespan
 │   ├── routers/            # API endpoints
-│   ├── repository.py       # Database CRUD
+│   ├── packet_processor.py # Raw packet pipeline, dedup, path handling
+│   ├── repository/         # Database CRUD (contacts, channels, messages, raw_packets, settings, fanout)
 │   ├── event_handlers.py   # Radio events
 │   ├── decoder.py          # Packet decryption
-│   └── websocket.py        # Real-time broadcasts
+│   ├── websocket.py        # Real-time broadcasts
+│   └── fanout/             # Fanout bus: MQTT, bots, webhooks, Apprise (see fanout/AGENTS_fanout.md)
 ├── frontend/               # React frontend
 │   ├── AGENTS.md           # Frontend documentation
 │   ├── src/
@@ -148,7 +166,12 @@ The following are **deliberate design choices**, not bugs. They are documented i
 │   │       ├── MapView.tsx       # Leaflet map showing node locations
 │   │       └── ...
 │   └── vite.config.ts
-├── references/meshcore_py/ # MeshCore Python library
+├── scripts/
+│   ├── all_quality.sh      # Run all lint, format, typecheck, tests, build (sequential)
+│   ├── collect_licenses.sh # Gather third-party license attributions
+│   ├── e2e.sh              # End-to-end test runner
+│   └── publish.sh          # Version bump, changelog, docker build & push
+├── remoteterm.service      # Systemd unit file for production deployment
 ├── tests/                  # Backend tests (pytest)
 ├── data/                   # SQLite database (runtime)
 └── pyproject.toml          # Python dependencies
@@ -207,9 +230,17 @@ Key test files:
 - `tests/test_decoder.py` - Channel + direct message decryption, key exchange
 - `tests/test_keystore.py` - Ephemeral key store
 - `tests/test_event_handlers.py` - ACK tracking, repeat detection
+- `tests/test_packet_pipeline.py` - End-to-end packet processing
 - `tests/test_api.py` - API endpoints, read state tracking
 - `tests/test_migrations.py` - Database migration system
 - `tests/test_frontend_static.py` - Frontend static route registration (missing `dist`/`index.html` handling)
+- `tests/test_messages_search.py` - Message search, around endpoint, forward pagination
+- `tests/test_rx_log_data.py` - on_rx_log_data event handler integration
+- `tests/test_ack_tracking_wiring.py` - DM ACK tracking extraction and wiring
+- `tests/test_health_mqtt_status.py` - Health endpoint MQTT status field
+- `tests/test_community_mqtt.py` - Community MQTT publisher (JWT, packet format, hash, broadcast)
+- `tests/test_real_crypto.py` - Real cryptographic operations
+- `tests/test_disable_bots.py` - MESHCORE_DISABLE_BOTS=true feature
 
 ### Frontend (Vitest)
 
@@ -220,20 +251,7 @@ npm run test:run
 
 ### Before Completing Changes
 
-**Always run both backend and frontend validation before finishing any changes:**
-
-```bash
-# From project root - run backend tests
-PYTHONPATH=. uv run pytest tests/ -v
-
-# From project root - run frontend tests and build
-cd frontend && npm run test:run && npm run build
-```
-
-This catches:
-- Type mismatches between frontend and backend (e.g., missing fields in TypeScript interfaces)
-- Breaking changes to shared types or API contracts
-- Runtime errors that only surface during compilation
+**Always run `./scripts/all_quality.sh` before finishing any changes that have modified code or tests.** This runs all linting, formatting, type checking, tests, and builds sequentially, catching type mismatches, breaking changes, and compilation errors. This is not necessary for docs-only changes.
 
 ## API Summary
 
@@ -241,7 +259,7 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 
 | Method | Endpoint | Description |
 |--------|----------|-------------|
-| GET | `/api/health` | Connection status |
+| GET | `/api/health` | Connection status, fanout statuses, bots_disabled flag |
 | GET | `/api/radio/config` | Radio configuration |
 | PATCH | `/api/radio/config` | Update name, location, radio params |
 | PUT | `/api/radio/private-key` | Import private key to radio |
@@ -249,25 +267,40 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | POST | `/api/radio/reboot` | Reboot radio or reconnect if disconnected |
 | POST | `/api/radio/reconnect` | Manual radio reconnection |
 | GET | `/api/contacts` | List contacts |
-| GET | `/api/contacts/{key}` | Get contact by public key or prefix |
+| GET | `/api/contacts/repeaters/advert-paths` | List recent unique advert paths for all contacts |
+| GET | `/api/contacts/{public_key}` | Get contact by public key or prefix |
+| GET | `/api/contacts/{public_key}/detail` | Comprehensive contact profile (stats, name history, paths) |
+| GET | `/api/contacts/{public_key}/advert-paths` | List recent unique advert paths for a contact |
 | POST | `/api/contacts` | Create contact (optionally trigger historical DM decrypt) |
-| DELETE | `/api/contacts/{key}` | Delete contact |
+| DELETE | `/api/contacts/{public_key}` | Delete contact |
 | POST | `/api/contacts/sync` | Pull from radio |
-| POST | `/api/contacts/{key}/add-to-radio` | Push contact to radio |
-| POST | `/api/contacts/{key}/remove-from-radio` | Remove contact from radio |
-| POST | `/api/contacts/{key}/mark-read` | Mark contact conversation as read |
-| POST | `/api/contacts/{key}/telemetry` | Request telemetry from repeater |
-| POST | `/api/contacts/{key}/command` | Send CLI command to repeater |
-| POST | `/api/contacts/{key}/trace` | Trace route to contact |
+| POST | `/api/contacts/{public_key}/add-to-radio` | Push contact to radio |
+| POST | `/api/contacts/{public_key}/remove-from-radio` | Remove contact from radio |
+| POST | `/api/contacts/{public_key}/mark-read` | Mark contact conversation as read |
+| POST | `/api/contacts/{public_key}/command` | Send CLI command to repeater |
+| POST | `/api/contacts/{public_key}/reset-path` | Reset contact path to flood |
+| POST | `/api/contacts/{public_key}/trace` | Trace route to contact |
+| POST | `/api/contacts/{public_key}/repeater/login` | Log in to a repeater |
+| POST | `/api/contacts/{public_key}/repeater/status` | Fetch repeater status telemetry |
+| POST | `/api/contacts/{public_key}/repeater/lpp-telemetry` | Fetch CayenneLPP sensor data |
+| POST | `/api/contacts/{public_key}/repeater/neighbors` | Fetch repeater neighbors |
+| POST | `/api/contacts/{public_key}/repeater/acl` | Fetch repeater ACL |
+| POST | `/api/contacts/{public_key}/repeater/radio-settings` | Fetch radio settings via CLI |
+| POST | `/api/contacts/{public_key}/repeater/advert-intervals` | Fetch advert intervals |
+| POST | `/api/contacts/{public_key}/repeater/owner-info` | Fetch owner info |
+
 | GET | `/api/channels` | List channels |
+| GET | `/api/channels/{key}/detail` | Comprehensive channel profile (message stats, top senders) |
 | GET | `/api/channels/{key}` | Get channel by key |
 | POST | `/api/channels` | Create channel |
 | DELETE | `/api/channels/{key}` | Delete channel |
 | POST | `/api/channels/sync` | Pull from radio |
 | POST | `/api/channels/{key}/mark-read` | Mark channel as read |
-| GET | `/api/messages` | List with filters |
+| GET | `/api/messages` | List with filters (`q`, `after`/`after_id` for forward pagination) |
+| GET | `/api/messages/around/{id}` | Get messages around a specific message (for jump-to-message) |
 | POST | `/api/messages/direct` | Send direct message |
 | POST | `/api/messages/channel` | Send channel message |
+| POST | `/api/messages/channel/{message_id}/resend` | Resend channel message (default: byte-perfect within 30s; `?new_timestamp=true`: fresh timestamp, no time limit, creates new message row) |
 | GET | `/api/packets/undecrypted/count` | Count of undecrypted packets |
 | POST | `/api/packets/decrypt/historical` | Decrypt stored packets |
 | POST | `/api/packets/maintenance` | Delete old packets and vacuum |
@@ -276,7 +309,14 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | GET | `/api/settings` | Get app settings |
 | PATCH | `/api/settings` | Update app settings |
 | POST | `/api/settings/favorites/toggle` | Toggle favorite status |
+| POST | `/api/settings/blocked-keys/toggle` | Toggle blocked key |
+| POST | `/api/settings/blocked-names/toggle` | Toggle blocked name |
 | POST | `/api/settings/migrate` | One-time migration from frontend localStorage |
+| GET | `/api/fanout` | List all fanout configs |
+| POST | `/api/fanout` | Create new fanout config |
+| PATCH | `/api/fanout/{id}` | Update fanout config (triggers module reload) |
+| DELETE | `/api/fanout/{id}` | Delete fanout config (stops module) |
+| GET | `/api/statistics` | Aggregated mesh network statistics |
 | WS | `/api/ws` | Real-time updates |
 
 ## Key Concepts
@@ -293,6 +333,7 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 - `1` - Client (regular node)
 - `2` - Repeater
 - `3` - Room
+- `4` - Sensor
 
 ### Channel Keys
 
@@ -310,7 +351,7 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 
 Read state (`last_read_at`) is tracked **server-side** for consistency across devices:
 - Stored as Unix timestamp in `contacts.last_read_at` and `channels.last_read_at`
-- Updated via `POST /api/contacts/{key}/mark-read` and `POST /api/channels/{key}/mark-read`
+- Updated via `POST /api/contacts/{public_key}/mark-read` and `POST /api/channels/{key}/mark-read`
 - Bulk update via `POST /api/read-state/mark-all-read`
 - Aggregated counts via `GET /api/read-state/unreads` (server-side computation)
 
@@ -320,6 +361,12 @@ Read state (`last_read_at`) is tracked **server-side** for consistency across de
 
 **Note:** These are NOT the same as `Message.conversation_key` (the database field).
 
+### Fanout Bus (MQTT, Bots, Webhooks, Apprise)
+
+All external integrations are managed through the fanout bus (`app/fanout/`). Each integration is a `FanoutModule` with scope-based event filtering, stored in the `fanout_configs` table and managed via `GET/POST/PATCH/DELETE /api/fanout`.
+
+`broadcast_event()` in `websocket.py` dispatches `message` and `raw_packet` events to the fanout manager. See `app/fanout/AGENTS_fanout.md` for full architecture details.
+
 ### Server-Side Decryption
 
 The server can decrypt packets using stored keys, both in real-time and for historical packets.
@@ -357,10 +404,13 @@ mc.subscribe(EventType.ACK, handler)
 | `MESHCORE_TCP_PORT` | `4000` | TCP port (used with `MESHCORE_TCP_HOST`) |
 | `MESHCORE_BLE_ADDRESS` | *(none)* | BLE device address (mutually exclusive with serial/TCP) |
 | `MESHCORE_BLE_PIN` | *(required with BLE)* | BLE PIN code |
+| `MESHCORE_SERIAL_BAUDRATE` | `115200` | Serial baud rate |
+| `MESHCORE_LOG_LEVEL` | `INFO` | Logging level (`DEBUG`/`INFO`/`WARNING`/`ERROR`) |
 | `MESHCORE_DATABASE_PATH` | `data/meshcore.db` | SQLite database location |
+| `MESHCORE_DISABLE_BOTS` | `false` | Disable bot system entirely (blocks execution and config) |
 
-**Note:** Runtime app settings are stored in the database (`app_settings` table), not environment variables. These include `max_radio_contacts`, `experimental_channel_double_send`, `auto_decrypt_dm_on_advert`, `sidebar_sort_order`, `advert_interval`, `last_advert_time`, `favorites`, `last_message_times`, and `bots`. They are configured via `GET/PATCH /api/settings` (and related settings endpoints).
+**Note:** Runtime app settings are stored in the database (`app_settings` table), not environment variables. These include `max_radio_contacts`, `auto_decrypt_dm_on_advert`, `sidebar_sort_order`, `advert_interval`, `last_advert_time`, `favorites`, `last_message_times`, `flood_scope`, `blocked_keys`, and `blocked_names`. They are configured via `GET/PATCH /api/settings`. MQTT, bot, webhook, and Apprise configs are stored in the `fanout_configs` table, managed via `/api/fanout`.
 
-`experimental_channel_double_send` is an opt-in experimental setting: when enabled, channel sends perform a second byte-perfect resend after a 3-second delay.
+Byte-perfect channel retries are user-triggered via `POST /api/messages/channel/{message_id}/resend` and are allowed for 30 seconds after the original send.
 
 **Transport mutual exclusivity:** Only one of `MESHCORE_SERIAL_PORT`, `MESHCORE_TCP_HOST`, or `MESHCORE_BLE_ADDRESS` may be set. If none are set, serial auto-detection is used.

CHANGELOG.md

@@ -1,3 +1,127 @@
+## [2.5.0] - 2026-03-05
+
+Feature: Far better accessibility across the app (with far to go)
+Feature: Add community MQTT stats reporting, and improve over a few commits
+Feature: Color schemes and misc. settings reorg
+Feature: Add why-active to filtered nodes
+Feature: Add channel and contact info box
+Feature: Add contact blocking
+Feature: Add potential repeater path map display
+Feature: Add flood scoping/regions
+Feature: Global message search
+Feature: Fully safe bot disable
+Feature: Add default #remoteterm channel (lol sorry I had to)
+Feature: Custom recency pruning in visualizer
+Bugfix: Be more cautious around null byte stripping
+Bugfix: Clear channel-add interface on not-add-another
+Bugfix: Add status/name/MQTT LWT
+Bugfix: Channel deletion propagates over WS
+Bugfix: Show map location for all nodes on link, not 7-day-limited
+Bugfix: Hide private key channel keys by default
+Misc: Logline to show if cleanup loop on non-sync'd meshcore radio links fixes anything
+Misc: Doc, changelog, and test improvements
+Misc: Add, and remove, package lock (sorry Windows users)
+Misc: Don't show mark all as read if not necessary
+Misc: Fix stale closures and misc. frontend perf/correctness improvements
+Misc: Add Windows startup notes
+Misc: E2E expansion + improvement
+Misc: Move around visualizer settings
+
+## [2.4.0] - 2026-03-02
+
+Feature: Add community MQTT reporting (e.g. LetsMesh.net)
+Misc: Build scripts and library attribution
+Misc: Add sign of life to E2E tests
+
+## [2.3.0] - 2026-03-01
+
+Feature: Click path description to reset to flood
+Feature: Add MQTT publishing
+Feature: Visualizer remembers settings
+Bugfix: Fix prefetch usage
+Bugfix: Fixed an issue where busy channels can result in double-display of incoming messages
+Misc: Drop py3.12 requirement
+Misc: Performance, documentation, test, and file structure optimizations
+Misc: Add arrows between route nodes on contact info
+Misc: Show repeater path/type in title bar
+
+## [2.2.0] - 2026-02-28
+
+Feature: Track advert paths and use to disambiguate repeater identity in visualizer
+Feature: Contact info pane
+Feature: Overhaul repeater interface
+Bugfix: Misc. frontend rendering + perf improvements
+Bugfix: Better behavior around radio locking and autofetch/polling
+Bugfix: Clear channel name field on new-channel modal tab change
+Bugfix: Repeater inforbox can scroll
+Bugfix: Better handling of historical DM encrypts
+Bugfix: Handle errors if returned in prefetch phase
+Misc: Radio event response failure is logged/surfaced better
+Misc: Improve test coverage and remove dead code
+Misc: Documentation and errata improvements
+Misc: Database storage optimization
+
+## [2.1.0] - 2026-02-23
+
+Feature: Add ability to remember last-used channel on load
+Feature: Add `docker compose` support (thanks @suymur !)
+Feature: Better-aligned favicon (lol)
+Bugfix: Disable autocomplete on message field
+Bugfix: Legacy hash restoration on page load
+Bugfix: Align resend buttons in pathing modal
+Bugfix: Update README.md (briefly), then docker-compose.yaml, to reflect correct docker image host
+Bugfix: Correct settings pane scroll lock on zoom (thanks @yellowcooln !)
+Bugfix: Improved repeater comms on busy meshes
+Bugfix: Drain before autofetch from radio
+Bugfix: Fix, or document exceptions to, sub-second resolution message failure
+Bugfix: Improved handling of radio connection, disconnection, and connection-aliveness-status
+Bugfix: Force server-side keystore update when radio key changes
+Bugfix: Reduce WS churn for incoming message handling
+Bugfix: Fix content type signalling for irrelevant endpoints
+Bugfix: Handle stuck post-connect failure state
+Misc: Documentation & version parsing improvements
+Misc: Hide char counter on mobile for short messages
+Misc: Typo fixes in docs and settings
+Misc: Add dynamic webmanifest for hosts that can support it
+Misc: Improve DB size via dropping unnecessary uniqs, indices, vacuum, and offering ability to drop historical matches packets
+Misc: Drop weird rounded bounding box for settings
+Misc: Move resend buttons to pathing modal
+Misc: Improved comments around database ownership on *nix systems
+Misc: Move to SSoT for message dedupe on frontend
+Misc: Move DM ack clearing to standard poll, and increase hold time between polling
+Misc: Holistic testing overhaul
+
+## [2.0.1] - 2026-02-16
+
+Bugfix: Fix missing trigger condition on statistics pane expansion on mobile
+
+## [2.0.0] - 2026-02-16
+
+Feature: Frontend UX + log overhaul
+Bugfix: Use contact object from DB for broadcast rather than handrolling
+Bugfix: Fix out of order path WS messages overwriting each other
+Bugfix: Make broadcast timestamp match fallback logic used in storage code
+Bugfix: Fix repeater command timestamp selection logic
+Bugfix: Use actual pubkey matching for path update, and don't action serial path update events (use RX packet)
+Bugfix: Add missing radio operation locks in a few spots
+Bugfix: Fix dedupe for frontend raw packet delivery (mesh visualizer much more active now!)
+Bugfix: Less aggressive dedupe for advert packets (we don't care about the payload, we care about the path, duh)
+Misc: Visualizer layout refinement & option labels
+
+## [1.10.0] - 2026-02-16
+
+Feature: Collapsible sidebar sections with per-section unread badge (thanks @rgregg !)
+Feature: 3D mesh visualizer
+Feature: Statistics pane
+Feature: Support incoming/outgoing indication for bot invocations
+Feature: Quick byte-perfect message resend if you got unlucky with repeats (thanks @rgregg -- we had a parallel implementation but I appreciate your work!)
+Bugfix: Fix top padding out outgoing message
+Bugfix: Frontend performance, appearance, and Lighthouse improvements (prefetches, form labelling, contrast, channel/roomlist changes)
+Bugfix: Multiple-sent messages had path appearing delays until rerender
+Bugfix: Fix ack/message race condition that caused dropped ack displays until rerender
+Misc: Dedupe contacts/rooms by key and not name to prevent name collisions creating unreachable conversations
+Misc: s/stopped/idle/ for room finder
+
 ## [1.9.3] - 2026-02-12
 
 Feature: Upgrade the room finder to support two-word rooms
@@ -5,7 +129,7 @@ Feature: Upgrade the room finder to support two-word rooms
 ## [1.9.2] - 2026-02-12
 
 Feature: Options dialog sucks less
-Bugix: Move tests to isolated memory DB
+Bugfix: Move tests to isolated memory DB
 Bugfix: Mention case sensitivity
 Bugfix: Stale header retention on settings page view
 Bugfix: Non-isolated path writing
@@ -58,30 +182,13 @@ Misc: Always flood advertisements
 Misc: Better packet dupe handling
 Misc: Dead code cleanup, test improvements
 
-## [1.8.0] - 2026-02-07
-
-Feature: Single hop ping
-Feature: PWA viewport fixes(thanks @rgregg)
-Feature (?): No frontend distribution; build it yourself ;P
-Bugfix: Fix channel message send race condition (concurrent sends could corrupt shared radio slot)
-Bugfix: Fix TOCTOU race in radio reconnect (duplicate connections under contention)
-Bugfix: Better guarding around reconnection
-Bugfix: Duplicate websocket connection fixes
-Bugfix: Settings tab error cleanliness on tab swap
-Bugfix: Fix path traversal vuln
-UI: Swap visualizer legend ordering (yay prettier)
-Misc: Perf and locking improvements
-Misc: Always flood advertisements
-Misc: Better packet dupe handling
-Misc: Dead code cleanup, test improvements
-
 ## [1.7.1] - 2026-02-03
 
 Feature: Clickable hyperlinks
 Bugfix: More consistent public key normalization
 Bugfix: Use more reliable cursor paging
 Bugfix: Fix null timestamp dedupe failure
-Bugfix: More concistent prefix-based message claiming on key reciept
+Bugfix: More consistent prefix-based message claiming on key receipt
 Misc: Bot can respond to its own messages
 Misc: Additional tests
 Misc: Remove unneeded message dedupe logic

Dockerfile

@@ -1,13 +1,15 @@
 # Stage 1: Build frontend
 FROM node:20-slim AS frontend-builder
 
+ARG COMMIT_HASH=unknown
+
 WORKDIR /build
 
-COPY frontend/package*.json ./
-RUN npm ci
+COPY frontend/package.json ./
+RUN npm install
 
 COPY frontend/ ./
-RUN npm run build
+RUN VITE_COMMIT_HASH=${COMMIT_HASH} npm run build
 
 
 # Stage 2: Python runtime
@@ -27,6 +29,9 @@ RUN uv sync --frozen --no-dev
 # Copy application code
 COPY app/ ./app/
 
+# Copy license attributions
+COPY LICENSES.md ./
+
 # Copy built frontend from first stage
 COPY --from=frontend-builder /build/dist ./frontend/dist
 
@@ -35,5 +40,5 @@ RUN mkdir -p /app/data
 
 EXPOSE 8000
 
-# Run the application
+# Run the application (we retain root for max compatibility)
 CMD ["uv", "run", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -2,26 +2,29 @@
 
 Backend server + browser interface for MeshCore mesh radio networks. Connect your radio over Serial, TCP, or BLE, and then you can:
 
-* Send and receive DMs and GroupTexts
+* Send and receive DMs and channel messages
 * Cache all received packets, decrypting as you gain keys
+* Run multiple Python bots that can analyze messages and respond to DMs and channels
 * Monitor unlimited contacts and channels (radio limits don't apply -- packets are decrypted server-side)
 * Access your radio remotely over your network or VPN
-* Brute force hashtag room names for GroupTexts you don't have keys for yet
+* Search for hashtag room names for channels you don't have keys for yet
+* Forward packets to MQTT brokers (private: decrypted messages and/or raw packets; community aggregators like LetsMesh.net: raw packets only)
+* Visualize the mesh as a map or node set, view repeater stats, and more!
 
-**Warning:** This app has no auth, and is for trusted environments only. _Do not put this on an untrusted network, or open it to the public._ The bots can execute arbitrary Python code which means anyone on your network can, too. If you need access control, consider using a reverse proxy like Nginx, or extending FastAPI.
+**Warning:** This app has no auth, and is for trusted environments only. _Do not put this on an untrusted network, or open it to the public._ The bots can execute arbitrary Python code which means anyone on your network can, too. To completely disable the bot system, start the server with `MESHCORE_DISABLE_BOTS=true` — this prevents all bot execution and blocks bot configuration changes via the API. If you need access control, consider using a reverse proxy like Nginx, or extending FastAPI; access control and user management are outside the scope of this app.
 
-![Screenshot of the application's web interface](screenshot.png)
+![Screenshot of the application's web interface](app_screenshot.png)
 
 ## Disclaimer
 
-This is entirely vibecoded slop -- no warranty of fitness for any purpose. It's been lovingly guided by an engineer with a passion for clean code and good tests, but it's still mostly LLM output, so you may find some bugs.
+This is developed with very heavy agentic assistance -- there is no warranty of fitness for any purpose. It's been lovingly guided by an engineer with a passion for clean code and good tests, but it's still mostly LLM output, so you may find some bugs.
 
 If extending, have your LLM read the three `AGENTS.md` files: `./AGENTS.md`, `./frontend/AGENTS.md`, and `./app/AGENTS.md`.
 
 ## Requirements
 
 - Python 3.10+
-- Node.js 18+ (for frontend development only)
+- Node.js 18+
 - [UV](https://astral.sh/uv) package manager: `curl -LsSf https://astral.sh/uv/install.sh | sh`
 - MeshCore radio connected via USB serial, TCP, or BLE
 
@@ -39,19 +42,25 @@ ls /dev/ttyUSB* /dev/ttyACM*
 #######
 ls /dev/cu.usbserial-* /dev/cu.usbmodem*
 
+###########
+# Windows
+###########
+# In PowerShell:
+Get-CimInstance Win32_SerialPort | Select-Object DeviceID, Caption
+
 ######
 # WSL2
 ######
 # Run this in an elevated PowerShell (not WSL) window
 winget install usbipd
-
 # restart console
-
-# find device ID (e.g. 3-8)
+# then find device ID
 usbipd list
-
-# attach device to WSL
-usbipd bind --busid 3-8
+# make device shareable
+usbipd bind --busid 3-8 # (or whatever the right ID is)
+# attach device to WSL (run this each time you plug in the device)
+usbipd attach --wsl --busid 3-8
+# device will appear in WSL as /dev/ttyUSB0 or /dev/ttyACM0
 ```
 </details>
 
@@ -85,31 +94,59 @@ MESHCORE_TCP_HOST=192.168.1.100 MESHCORE_TCP_PORT=4000 uv run uvicorn app.main:a
 MESHCORE_BLE_ADDRESS=AA:BB:CC:DD:EE:FF MESHCORE_BLE_PIN=123456 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
 ```
 
+On Windows (PowerShell), set environment variables as a separate statement:
+```powershell
+$env:MESHCORE_SERIAL_PORT="COM8" # or your COM port
+uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
+```
+
 Access at http://localhost:8000
 
 > **Note:** WebGPU cracking requires HTTPS when not on localhost. See the HTTPS section under Additional Setup.
 
-## Docker
+## Docker Compose
 
 > **Warning:** Docker has intermittent issues with serial event subscriptions. The native method above is more reliable.
 
 > **Note:** BLE-in-docker is outside the scope of this README, but the env vars should all still work.
 
-```bash
-# Serial
-docker run -d \
-  --device=/dev/ttyUSB0 \
-  -v remoteterm-data:/app/data \
-  -p 8000:8000 \
-  jkingsman/remote-terminal-for-meshcore:latest
+Edit `docker-compose.yaml` to set a serial device for passthrough, or uncomment your transport (serial or TCP). Then:
 
-# TCP
-docker run -d \
-  -e MESHCORE_TCP_HOST=192.168.1.100 \
-  -e MESHCORE_TCP_PORT=4000 \
-  -v remoteterm-data:/app/data \
-  -p 8000:8000 \
-  jkingsman/remote-terminal-for-meshcore:latest
+```bash
+docker compose up -d
+```
+
+The database is stored in `./data/` (bind-mounted), so the container shares the same database as the native app. To rebuild after pulling updates:
+
+```bash
+docker compose up -d --build
+```
+
+To use the prebuilt Docker Hub image instead of building locally, replace:
+
+```yaml
+build: .
+```
+
+with:
+
+```yaml
+image: jkingsman/remoteterm-meshcore:latest
+```
+
+Then run:
+
+```bash
+docker compose pull
+docker compose up -d
+```
+
+The container runs as root by default for maximum serial passthrough compatibility across host setups. On Linux, if you switch between native and Docker runs, `./data` can end up root-owned. If you do not need that compatibility behavior, you can enable the optional `user: "${UID:-1000}:${GID:-1000}"` line in `docker-compose.yaml` to keep ownership aligned with your host user.
+
+To stop:
+
+```bash
+docker compose down
 ```
 
 ## Development
@@ -118,12 +155,21 @@ docker run -d \
 
 ```bash
 uv sync
-uv run uvicorn app.main:app --reload
+uv run uvicorn app.main:app --reload # autodetects serial port
 
 # Or with explicit serial port
 MESHCORE_SERIAL_PORT=/dev/ttyUSB0 uv run uvicorn app.main:app --reload
 ```
 
+On Windows (PowerShell):
+```powershell
+uv sync
+$env:MESHCORE_SERIAL_PORT="COM8" # or your COM port
+uv run uvicorn app.main:app --reload
+```
+
+> **Windows note:** I've seen an intermittent startup issue like `"Received empty packet: index out of range"` with failed contact sync. I can't figure out why this happens. The issue typically resolves on restart. If you can figure out why this happens, I will buy you a virtual or iRL six pack if you're in the PNW. As a former always-windows-girlie before embracing WSL2, I despise second-classing M$FT users, but I'm just stuck with this one.
+
 ### Frontend
 
 ```bash
@@ -137,10 +183,16 @@ Run both the backend and `npm run dev` for hot-reloading frontend development.
 
 ### Code Quality & Tests
 
-Please test, lint, format, and quality check your code before PRing or committing. At the least, run a lint + autoformat + pyright check on the bakend, and a lint + autoformat on the frontend.
+Please test, lint, format, and quality check your code before PRing or committing. At the least, run a lint + autoformat + pyright check on the backend, and a lint + autoformat on the frontend.
+
+Run everything at once:
+
+```bash
+./scripts/all_quality.sh
+```
 
 <details>
-<summary>But how?</summary>
+<summary>Or run individual checks</summary>
 
 ```bash
 # python
@@ -170,14 +222,14 @@ npm run build                        # build the frontend
 | `MESHCORE_BLE_PIN` | | BLE PIN (required when BLE address is set) |
 | `MESHCORE_LOG_LEVEL` | INFO | DEBUG, INFO, WARNING, ERROR |
 | `MESHCORE_DATABASE_PATH` | data/meshcore.db | SQLite database path |
-| `MESHCORE_MAX_RADIO_CONTACTS` | 200 | Max recent contacts to keep on radio for DM ACKs |
+| `MESHCORE_DISABLE_BOTS` | false | Disable bot system entirely (blocks execution and config) |
 
 Only one transport may be active at a time. If multiple are set, the server will refuse to start.
 
 ## Additional Setup
 
 <details>
-<summary>HTTPS (Required for WebGPU Cracking outside localhost)</summary>
+<summary>HTTPS (Required for WebGPU room-finding outside localhost)</summary>
 
 WebGPU requires a secure context. When not on `localhost`, serve over HTTPS:
 
@@ -186,21 +238,21 @@ openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -node
 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000 --ssl-keyfile=key.pem --ssl-certfile=cert.pem
 ```
 
-For Docker:
+For Docker Compose, generate the cert and add the volume mounts and command override to `docker-compose.yaml`:
 
 ```bash
-# generate TLS cert
+# generate snakeoil TLS cert
 openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'
+```
 
-# run with cert
-docker run -d \
-  --device=/dev/ttyUSB0 \
-  -v remoteterm-data:/app/data \
-  -v $(pwd)/cert.pem:/app/cert.pem:ro \
-  -v $(pwd)/key.pem:/app/key.pem:ro \
-  -p 8000:8000 \
-  jkingsman/remote-terminal-for-meshcore:latest \
-  uv run uvicorn app.main:app --host 0.0.0.0 --port 8000 --ssl-keyfile=/app/key.pem --ssl-certfile=/app/cert.pem
+Then add the key and cert to the `remoteterm` service in `docker-compose.yaml`, and add an explicit launch command that uses them:
+
+```yaml
+    volumes:
+      - ./data:/app/data
+      - ./cert.pem:/app/cert.pem:ro
+      - ./key.pem:/app/key.pem:ro
+    command: uv run uvicorn app.main:app --host 0.0.0.0 --port 8000 --ssl-keyfile=/app/key.pem --ssl-certfile=/app/cert.pem
 ```
 
 Accept the browser warning, or use [mkcert](https://github.com/FiloSottile/mkcert) for locally-trusted certs.
@@ -209,6 +261,8 @@ Accept the browser warning, or use [mkcert](https://github.com/FiloSottile/mkcer
 <details>
 <summary>Systemd Service (Linux)</summary>
 
+Assumes you're running from `/opt/remoteterm`; update commands and `remoteterm.service` if you're running elsewhere.
+
 ```bash
 # Create service user
 sudo useradd -r -m -s /bin/false remoteterm
@@ -245,17 +299,41 @@ Edit `/etc/systemd/system/remoteterm.service` to set `MESHCORE_SERIAL_PORT` if n
 <summary>Testing</summary>
 
 **Backend:**
+
 ```bash
 PYTHONPATH=. uv run pytest tests/ -v
 ```
 
 **Frontend:**
+
 ```bash
 cd frontend
 npm run test:run
 ```
+
+**E2E:**
+
+Warning: these tests are only guaranteed to run correctly in a narrow subset of environments; they require a busy mesh with messages arriving constantly and an available autodetect-able radio, as well as a contact in the test database (which you can provide in `tests/e2e/.tmp/e2e-test.db` after an initial run). E2E tests are generally not necessary to run for normal development work.
+
+```bash
+cd tests/e2e
+npx playwright test # headless
+npx playwright test --headed # show the browser window
+```
 </details>
 
 ## API Documentation
 
 With the backend running: http://localhost:8000/docs
+
+## Debugging & Bug Reports
+
+If you're experiencing issues or opening a bug report, please start the backend with debug logging enabled. Debug mode provides a much more detailed breakdown of radio communication, packet processing, and other internal operations, which makes it significantly easier to diagnose problems.
+
+To start the server with debug logging:
+
+```bash
+MESHCORE_LOG_LEVEL=DEBUG uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
+```
+
+Please include the relevant debug log output when filing an issue on GitHub.

app/AGENTS.md

@@ -8,7 +8,7 @@ Keep it aligned with `app/` source files and router behavior.
 - FastAPI
 - aiosqlite
 - Pydantic
-- MeshCore Python library (`references/meshcore_py`)
+- MeshCore Python library (`meshcore` from PyPI)
 - PyCryptodome
 
 ## Backend Map
@@ -20,14 +20,14 @@ app/
 ├── database.py          # SQLite connection + base schema + migration runner
 ├── migrations.py        # Schema migrations (SQLite user_version)
 ├── models.py            # Pydantic request/response models
-├── repository.py        # Data access layer
+├── repository/          # Data access layer (contacts, channels, messages, raw_packets, settings)
 ├── radio.py             # RadioManager + auto-reconnect monitor
 ├── radio_sync.py        # Polling, sync, periodic advertisement loop
 ├── decoder.py           # Packet parsing/decryption
 ├── packet_processor.py  # Raw packet pipeline, dedup, path handling
 ├── event_handlers.py    # MeshCore event subscriptions and ACK tracking
 ├── websocket.py         # WS manager + broadcast helpers
-├── bot.py               # Bot execution and outbound bot sends
+├── fanout/              # Fanout bus: MQTT, bots, webhooks, Apprise (see fanout/AGENTS_fanout.md)
 ├── dependencies.py      # Shared FastAPI dependency providers
 ├── keystore.py          # Ephemeral private/public key storage for DM decryption
 ├── frontend_static.py   # Mount/serve built frontend (production)
@@ -40,6 +40,9 @@ app/
     ├── packets.py
     ├── read_state.py
     ├── settings.py
+    ├── fanout.py
+    ├── repeaters.py
+    ├── statistics.py
     └── ws.py
 ```
 
@@ -58,11 +61,13 @@ app/
 2. Message is persisted as outgoing.
 3. Endpoint broadcasts WS `message` event so all live clients update.
 4. ACK/repeat updates arrive later as `message_acked` events.
+5. Channel resend (`POST /messages/channel/{id}/resend`) strips the sender name prefix by exact match against the current radio name. This assumes the radio name hasn't changed between the original send and the resend. Name changes require an explicit radio config update and are rare, but the `new_timestamp=true` resend path has no time window, so a mismatch is possible if the name was changed between the original send and a later resend.
 
 ### Connection lifecycle
 
 - `RadioManager.start_connection_monitor()` checks health every 5s.
-- On reconnect, monitor runs `post_connect_setup()` before broadcasting healthy state.
+- Monitor reconnect path runs `post_connect_setup()` before broadcasting healthy state.
+- Manual reconnect/reboot endpoints call `reconnect()` then `post_connect_setup()`.
 - Setup includes handler registration, key export, time sync, contact/channel sync, polling/advert tasks.
 
 ## Important Behaviors
@@ -75,7 +80,20 @@ app/
 ### Echo/repeat dedup
 
 - Message uniqueness: `(type, conversation_key, text, sender_timestamp)`.
-- Duplicate insert is treated as an echo/repeat; ACK count/path list is updated.
+- Duplicate insert is treated as an echo/repeat: the new path (if any) is appended, and the ACK count is incremented **only for outgoing messages**. Incoming repeats add path data but do not change the ACK count.
+
+### Raw packet dedup policy
+
+- Raw packet storage deduplicates by payload hash (`RawPacketRepository.create`), excluding routing/path bytes.
+- Stored packet `id` is therefore a payload identity, not a per-arrival identity.
+- Realtime raw-packet WS broadcasts include `observation_id` (unique per RF arrival) in addition to `id`.
+- Frontend packet-feed features should key/dedupe by `observation_id`; use `id` only as the storage reference.
+- Message-layer repeat handling (`_handle_duplicate_message` + `MessageRepository.add_path`) is separate from raw-packet storage dedup.
+
+### Contact sync throttle
+
+- `sync_recent_contacts_to_radio()` sets `_last_contact_sync = now` before the sync completes.
+- This is intentional: if sync fails, the next attempt is still throttled to prevent a retry-storm against a flaky radio. Contacts will resync on the next scheduled cycle or on reconnect.
 
 ### Periodic advertisement
 
@@ -83,6 +101,14 @@ app/
 - `0` means disabled.
 - Last send time tracked in `app_settings.last_advert_time`.
 
+### Fanout bus
+
+- All external integrations (MQTT, bots, webhooks, Apprise) are managed through the fanout bus (`app/fanout/`).
+- Configs stored in `fanout_configs` table, managed via `GET/POST/PATCH/DELETE /api/fanout`.
+- `broadcast_event()` in `websocket.py` dispatches to the fanout manager for `message` and `raw_packet` events.
+- Each integration is a `FanoutModule` with scope-based filtering.
+- See `app/fanout/AGENTS_fanout.md` for full architecture details.
+
 ## API Surface (all under `/api`)
 
 ### Health
@@ -98,19 +124,31 @@ app/
 
 ### Contacts
 - `GET /contacts`
+- `GET /contacts/repeaters/advert-paths` — recent advert paths for all contacts
 - `GET /contacts/{public_key}`
+- `GET /contacts/{public_key}/detail` — comprehensive contact profile (stats, name history, paths, nearest repeaters)
+- `GET /contacts/{public_key}/advert-paths` — recent advert paths for one contact
 - `POST /contacts`
 - `DELETE /contacts/{public_key}`
 - `POST /contacts/sync`
 - `POST /contacts/{public_key}/add-to-radio`
 - `POST /contacts/{public_key}/remove-from-radio`
 - `POST /contacts/{public_key}/mark-read`
-- `POST /contacts/{public_key}/telemetry`
 - `POST /contacts/{public_key}/command`
+- `POST /contacts/{public_key}/reset-path`
 - `POST /contacts/{public_key}/trace`
+- `POST /contacts/{public_key}/repeater/login`
+- `POST /contacts/{public_key}/repeater/status`
+- `POST /contacts/{public_key}/repeater/lpp-telemetry`
+- `POST /contacts/{public_key}/repeater/neighbors`
+- `POST /contacts/{public_key}/repeater/acl`
+- `POST /contacts/{public_key}/repeater/radio-settings`
+- `POST /contacts/{public_key}/repeater/advert-intervals`
+- `POST /contacts/{public_key}/repeater/owner-info`
 
 ### Channels
 - `GET /channels`
+- `GET /channels/{key}/detail`
 - `GET /channels/{key}`
 - `POST /channels`
 - `DELETE /channels/{key}`
@@ -118,9 +156,11 @@ app/
 - `POST /channels/{key}/mark-read`
 
 ### Messages
-- `GET /messages`
+- `GET /messages` — list with filters; supports `q` (full-text search), `after`/`after_id` (forward cursor)
+- `GET /messages/around/{message_id}` — context messages around a target (for jump-to-message navigation)
 - `POST /messages/direct`
 - `POST /messages/channel`
+- `POST /messages/channel/{message_id}/resend`
 
 ### Packets
 - `GET /packets/undecrypted/count`
@@ -135,8 +175,19 @@ app/
 - `GET /settings`
 - `PATCH /settings`
 - `POST /settings/favorites/toggle`
+- `POST /settings/blocked-keys/toggle`
+- `POST /settings/blocked-names/toggle`
 - `POST /settings/migrate`
 
+### Fanout
+- `GET /fanout` — list all fanout configs
+- `POST /fanout` — create new fanout config
+- `PATCH /fanout/{id}` — update fanout config (triggers module reload)
+- `DELETE /fanout/{id}` — delete fanout config (stops module)
+
+### Statistics
+- `GET /statistics` — aggregated mesh network stats (entity counts, message/packet splits, activity windows, busiest channels)
+
 ### WebSocket
 - `WS /ws`
 
@@ -147,6 +198,8 @@ app/
 - `message` — new message (channel or DM, from packet processor or send endpoints)
 - `message_acked` — ACK/echo update for existing message (ack count + paths)
 - `raw_packet` — every incoming RF packet (for real-time packet feed UI)
+- `contact_deleted` — contact removed from database (payload: `{ public_key }`)
+- `channel_deleted` — channel removed from database (payload: `{ key }`)
 - `error` — toast notification (reconnect failure, missing private key, etc.)
 - `success` — toast notification (historical decrypt complete, etc.)
 
@@ -156,15 +209,16 @@ Client sends `"ping"` text; server replies `{"type":"pong"}`.
 ## Data Model Notes
 
 Main tables:
-- `contacts`
+- `contacts` (includes `first_seen` for contact age tracking)
 - `channels`
-- `messages`
+- `messages` (includes `sender_name`, `sender_key` for per-contact channel message attribution)
 - `raw_packets`
+- `contact_advert_paths` (recent unique advertisement paths per contact)
+- `contact_name_history` (tracks name changes over time)
 - `app_settings`
 
 `app_settings` fields in active model:
 - `max_radio_contacts`
-- `experimental_channel_double_send`
 - `favorites`
 - `auto_decrypt_dm_on_advert`
 - `sidebar_sort_order`
@@ -172,7 +226,10 @@ Main tables:
 - `preferences_migrated`
 - `advert_interval`
 - `last_advert_time`
-- `bots`
+- `flood_scope`
+- `blocked_keys`, `blocked_names`
+
+Note: MQTT, community MQTT, and bot configs were migrated to the `fanout_configs` table (migrations 36-38).
 
 ## Security Posture (intentional)
 
@@ -190,13 +247,74 @@ Run backend tests:
 PYTHONPATH=. uv run pytest tests/ -v
 ```
 
-High-signal suites:
-- `tests/test_packet_pipeline.py`
-- `tests/test_event_handlers.py`
-- `tests/test_send_messages.py`
-- `tests/test_radio.py`
-- `tests/test_api.py`
-- `tests/test_migrations.py`
+Test suites:
+
+```text
+tests/
+├── conftest.py                 # Shared fixtures
+├── test_ack_tracking_wiring.py # DM ACK tracking extraction and wiring
+├── test_api.py                 # REST endpoint integration tests
+├── test_bot.py                 # Bot execution and sandboxing
+├── test_channels_router.py     # Channels router endpoints
+├── test_config.py              # Configuration validation
+├── test_contacts_router.py     # Contacts router endpoints
+├── test_decoder.py             # Packet parsing/decryption
+├── test_disable_bots.py        # MESHCORE_DISABLE_BOTS=true feature
+├── test_echo_dedup.py          # Echo/repeat deduplication (incl. concurrent)
+├── test_fanout.py              # Fanout bus CRUD, scope matching, manager dispatch
+├── test_fanout_integration.py  # Fanout integration tests
+├── test_event_handlers.py      # ACK tracking, event registration, cleanup
+├── test_frontend_static.py     # Frontend static file serving
+├── test_health_mqtt_status.py  # Health endpoint MQTT status field
+├── test_key_normalization.py   # Public key normalization
+├── test_keystore.py            # Ephemeral keystore
+├── test_message_pagination.py  # Cursor-based message pagination
+├── test_message_prefix_claim.py # Message prefix claim logic
+├── test_migrations.py          # Schema migration system
+├── test_community_mqtt.py      # Community MQTT publisher (JWT, packet format, hash, broadcast)
+├── test_mqtt.py                # MQTT publisher topic routing and lifecycle
+├── test_packet_pipeline.py     # End-to-end packet processing
+├── test_packets_router.py      # Packets router endpoints (decrypt, maintenance)
+├── test_radio.py               # RadioManager, serial detection
+├── test_real_crypto.py         # Real cryptographic operations
+├── test_radio_operation.py     # radio_operation() context manager
+├── test_radio_router.py        # Radio router endpoints
+├── test_radio_sync.py          # Polling, sync, advertisement
+├── test_repeater_routes.py     # Repeater command/telemetry/trace + granular pane endpoints
+├── test_repository.py          # Data access layer
+├── test_rx_log_data.py         # on_rx_log_data event handler integration
+├── test_messages_search.py      # Message search, around, forward pagination
+├── test_block_lists.py          # Blocked keys/names filtering
+├── test_send_messages.py       # Outgoing messages, bot triggers, concurrent sends
+├── test_settings_router.py     # Settings endpoints, advert validation
+├── test_statistics.py          # Statistics aggregation
+├── test_websocket.py           # WS manager broadcast/cleanup
+└── test_websocket_route.py     # WS endpoint lifecycle
+```
+
+## Errata & Known Non-Issues
+
+### Sender timestamps are 1-second resolution (protocol constraint)
+
+The MeshCore radio protocol encodes `sender_timestamp` as a 4-byte little-endian integer (Unix seconds). This is a firmware-level wire format — the radio, the Python library (`commands/messaging.py`), and the decoder (`decoder.py`) all read/write exactly 4 bytes. Millisecond Unix timestamps would overflow 4 bytes, so higher resolution is not possible without a firmware change.
+
+**Consequence:** The dedup index `(type, conversation_key, text, COALESCE(sender_timestamp, 0))` operates at 1-second granularity. Sending identical text to the same conversation twice within one second will hit the UNIQUE constraint on the second insert, returning HTTP 500 *after* the radio has already transmitted. The message is sent over the air but not stored in the database. Do not attempt to fix this by switching to millisecond timestamps — it will break echo dedup (the echo's 4-byte timestamp won't match the stored value) and overflow `to_bytes(4, "little")`.
+
+### Outgoing DM echoes remain undecrypted
+
+When our own outgoing DM is heard back via `RX_LOG_DATA` (self-echo, loopback), `_process_direct_message` passes `our_public_key=None` for the outgoing direction, disabling the outbound hash check in the decoder. The decoder's inbound check (`src_hash == their_first_byte`) fails because the source is us, not the contact — so decryption returns `None`. This is by design: outgoing DMs are stored directly by the send endpoint, so no message is lost.
+
+### Infinite setup retry on connection monitor
+
+When `post_connect_setup()` fails (e.g. `export_and_store_private_key` raises `RuntimeError` because the radio didn't respond), `_setup_complete` is never set to `True`. The connection monitor sees `connected and not setup_complete` and retries every 5 seconds — indefinitely. This is intentional: the radio may be rebooting, waking from sleep, or otherwise temporarily unresponsive. We keep retrying so that setup completes automatically once the radio becomes available, without requiring manual intervention.
+
+### DELETE channel returns 200 for non-existent keys
+
+`DELETE /api/channels/{key}` returns `{"status": "ok"}` even if the key didn't exist. This is intentional — the postcondition is "channel doesn't exist," which is satisfied regardless of whether it existed before. No 404 needed.
+
+### Contact lat/lon 0.0 vs NULL
+
+MeshCore uses `0.0` as the sentinel for "no GPS coordinates" (see `models.py` `to_radio_dict`). The upsert SQL uses `COALESCE(excluded.lat, contacts.lat)`, which preserves existing values when the new value is `NULL` — but `0.0` is not `NULL`, so it overwrites previously valid coordinates. This is intentional: we always want the most recent location data. If a device stops broadcasting GPS, the old coordinates are presumably stale/wrong, so overwriting with "not available" (`0.0`) is the correct behavior.
 
 ## Editing Checklist
 

app/config.py

@@ -16,6 +16,7 @@ class Settings(BaseSettings):
     ble_pin: str = ""
     log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO"
     database_path: str = "data/meshcore.db"
+    disable_bots: bool = False
 
     @model_validator(mode="after")
     def validate_transport_exclusivity(self) -> "Settings":
@@ -47,6 +48,40 @@ class Settings(BaseSettings):
 settings = Settings()
 
 
+class _RepeatSquelch(logging.Filter):
+    """Suppress rapid-fire identical messages and emit a summary instead.
+
+    Attached to the ``meshcore`` library logger to catch its repeated
+    "Serial Connection started" lines that flood the log when another
+    process holds the serial port.
+    """
+
+    def __init__(self, threshold: int = 3) -> None:
+        super().__init__()
+        self._last_msg: str | None = None
+        self._repeat_count: int = 0
+        self._threshold = threshold
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        msg = record.getMessage()
+        if msg == self._last_msg:
+            self._repeat_count += 1
+            if self._repeat_count == self._threshold:
+                record.msg = (
+                    "%s (repeated %d times — possible serial port contention from another process)"
+                )
+                record.args = (msg, self._repeat_count)
+                record.levelno = logging.WARNING
+                record.levelname = "WARNING"
+                return True
+            # Suppress further repeats beyond the threshold
+            return self._repeat_count < self._threshold
+        else:
+            self._last_msg = msg
+            self._repeat_count = 1
+            return True
+
+
 def setup_logging() -> None:
     """Configure logging for the application."""
     logging.basicConfig(
@@ -54,3 +89,6 @@ def setup_logging() -> None:
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
         datefmt="%Y-%m-%d %H:%M:%S",
     )
+    # Squelch repeated messages from the meshcore library (e.g. rapid-fire
+    # "Serial Connection started" when the port is contended).
+    logging.getLogger("meshcore").addFilter(_RepeatSquelch())

app/database.py

@@ -15,12 +15,14 @@ CREATE TABLE IF NOT EXISTS contacts (
     flags INTEGER DEFAULT 0,
     last_path TEXT,
     last_path_len INTEGER DEFAULT -1,
+    out_path_hash_mode INTEGER,
     last_advert INTEGER,
     lat REAL,
     lon REAL,
     last_seen INTEGER,
     on_radio INTEGER DEFAULT 0,
-    last_contacted INTEGER
+    last_contacted INTEGER,
+    first_seen INTEGER
 );
 
 CREATE TABLE IF NOT EXISTS channels (
@@ -42,11 +44,14 @@ CREATE TABLE IF NOT EXISTS messages (
     signature TEXT,
     outgoing INTEGER DEFAULT 0,
     acked INTEGER DEFAULT 0,
+    sender_name TEXT,
+    sender_key TEXT
     -- Deduplication: identical text + timestamp in the same conversation is treated as a
     -- mesh echo/repeat. Second-precision timestamps mean two intentional identical messages
     -- within the same second would collide, but this is not feasible in practice — LoRa
     -- transmission takes several seconds per message, and the UI clears the input on send.
-    UNIQUE(type, conversation_key, text, sender_timestamp)
+    -- Enforced via idx_messages_dedup_null_safe (unique index) rather than a table constraint
+    -- to avoid the storage overhead of SQLite's autoindex duplicating every message text.
 );
 
 CREATE TABLE IF NOT EXISTS raw_packets (
@@ -54,15 +59,43 @@ CREATE TABLE IF NOT EXISTS raw_packets (
     timestamp INTEGER NOT NULL,
     data BLOB NOT NULL,
     message_id INTEGER,
-    payload_hash TEXT,
+    payload_hash BLOB,
     FOREIGN KEY (message_id) REFERENCES messages(id)
 );
 
-CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(type, conversation_key);
+CREATE TABLE IF NOT EXISTS contact_advert_paths (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    public_key TEXT NOT NULL,
+    path_hex TEXT NOT NULL,
+    path_len INTEGER NOT NULL,
+    first_seen INTEGER NOT NULL,
+    last_seen INTEGER NOT NULL,
+    heard_count INTEGER NOT NULL DEFAULT 1,
+    UNIQUE(public_key, path_hex),
+    FOREIGN KEY (public_key) REFERENCES contacts(public_key)
+);
+
+CREATE TABLE IF NOT EXISTS contact_name_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    public_key TEXT NOT NULL,
+    name TEXT NOT NULL,
+    first_seen INTEGER NOT NULL,
+    last_seen INTEGER NOT NULL,
+    UNIQUE(public_key, name),
+    FOREIGN KEY (public_key) REFERENCES contacts(public_key)
+);
+
 CREATE INDEX IF NOT EXISTS idx_messages_received ON messages(received_at);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_dedup_null_safe
+    ON messages(type, conversation_key, text, COALESCE(sender_timestamp, 0));
 CREATE INDEX IF NOT EXISTS idx_raw_packets_message_id ON raw_packets(message_id);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_raw_packets_payload_hash ON raw_packets(payload_hash);
 CREATE INDEX IF NOT EXISTS idx_contacts_on_radio ON contacts(on_radio);
+-- idx_messages_sender_key is created by migration 25 (after adding the sender_key column)
+CREATE INDEX IF NOT EXISTS idx_contact_advert_paths_recent
+    ON contact_advert_paths(public_key, last_seen DESC);
+CREATE INDEX IF NOT EXISTS idx_contact_name_history_key
+    ON contact_name_history(public_key, last_seen DESC);
 """
 
 
@@ -76,6 +109,17 @@ class Database:
         Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
         self._connection = await aiosqlite.connect(self.db_path)
         self._connection.row_factory = aiosqlite.Row
+
+        # WAL mode: faster writes, concurrent readers during writes, no journal file churn.
+        # Persists in the DB file but we set it explicitly on every connection.
+        await self._connection.execute("PRAGMA journal_mode = WAL")
+
+        # Incremental auto-vacuum: freed pages are reclaimable via
+        # PRAGMA incremental_vacuum without a full VACUUM. Must be set before
+        # the first table is created (for new databases); for existing databases
+        # migration 20 handles the one-time VACUUM to restructure the file.
+        await self._connection.execute("PRAGMA auto_vacuum = INCREMENTAL")
+
         await self._connection.executescript(SCHEMA)
         await self._connection.commit()
         logger.debug("Database schema initialized")

app/decoder.py

@@ -79,9 +79,11 @@ class PacketInfo:
     route_type: RouteType
     payload_type: PayloadType
     payload_version: int
-    path_length: int
-    path: bytes  # The routing path (empty if path_length is 0)
+    path_length: int  # Hop count encoded in the lower 6 bits of the path byte
+    path: bytes  # The routing path bytes (empty if path_length is 0)
     payload: bytes
+    path_hash_size: int = 1  # Bytes per hop encoded in the upper 2 bits of the path byte
+    path_byte_length: int = 0
 
 
 def calculate_channel_hash(channel_key: bytes) -> str:
@@ -93,6 +95,14 @@ def calculate_channel_hash(channel_key: bytes) -> str:
     return format(hash_bytes[0], "02x")
 
 
+def decode_path_metadata(path_byte: int) -> tuple[int, int, int]:
+    """Decode the packed path byte into hop count and byte length."""
+    path_hash_size = (path_byte >> 6) + 1
+    path_length = path_byte & 0x3F
+    path_byte_length = path_length * path_hash_size
+    return path_length, path_hash_size, path_byte_length
+
+
 def extract_payload(raw_packet: bytes) -> bytes | None:
     """
     Extract just the payload from a raw packet, skipping header and path.
@@ -100,8 +110,10 @@ def extract_payload(raw_packet: bytes) -> bytes | None:
     Packet structure:
     - Byte 0: header (route_type, payload_type, version)
     - For TRANSPORT routes: bytes 1-4 are transport codes
-    - Next byte: path_length
-    - Next path_length bytes: path data
+    - Next byte: packed path metadata
+      - upper 2 bits: bytes per hop minus 1
+      - lower 6 bits: hop count
+    - Next hop_count * path_hash_size bytes: path data
     - Remaining: payload
 
     Returns the payload bytes, or None if packet is malformed.
@@ -120,16 +132,16 @@ def extract_payload(raw_packet: bytes) -> bytes | None:
                 return None
             offset += 4
 
-        # Get path length
+        # Decode packed path metadata
         if len(raw_packet) < offset + 1:
             return None
-        path_length = raw_packet[offset]
+        path_length, _path_hash_size, path_byte_length = decode_path_metadata(raw_packet[offset])
         offset += 1
 
         # Skip path data
-        if len(raw_packet) < offset + path_length:
+        if len(raw_packet) < offset + path_byte_length:
             return None
-        offset += path_length
+        offset += path_byte_length
 
         # Rest is payload
         return raw_packet[offset:]
@@ -156,17 +168,17 @@ def parse_packet(raw_packet: bytes) -> PacketInfo | None:
                 return None
             offset += 4
 
-        # Get path length
+        # Decode packed path metadata
         if len(raw_packet) < offset + 1:
             return None
-        path_length = raw_packet[offset]
+        path_length, path_hash_size, path_byte_length = decode_path_metadata(raw_packet[offset])
         offset += 1
 
         # Extract path data
-        if len(raw_packet) < offset + path_length:
+        if len(raw_packet) < offset + path_byte_length:
             return None
-        path = raw_packet[offset : offset + path_length]
-        offset += path_length
+        path = raw_packet[offset : offset + path_byte_length]
+        offset += path_byte_length
 
         # Rest is payload
         payload = raw_packet[offset:]
@@ -178,6 +190,8 @@ def parse_packet(raw_packet: bytes) -> PacketInfo | None:
             path_length=path_length,
             path=path,
             payload=payload,
+            path_hash_size=path_hash_size,
+            path_byte_length=path_byte_length,
         )
     except (ValueError, IndexError):
         return None
@@ -327,7 +341,6 @@ def parse_advertisement(payload: bytes) -> ParsedAdvertisement | None:
     # Parse fixed-position fields
     public_key = payload[0:32].hex()
     timestamp = int.from_bytes(payload[32:36], byteorder="little")
-    # signature = payload[36:100]  # Not currently verified
     flags = payload[100]
 
     # Parse flags
@@ -530,8 +543,10 @@ def decrypt_direct_message(payload: bytes, shared_secret: bytes) -> DecryptedDir
     message_bytes = decrypted[5:]
     try:
         message_text = message_bytes.decode("utf-8")
-        # Remove null terminator and any padding
-        message_text = message_text.rstrip("\x00")
+        # Truncate at first null terminator (consistent with channel message handling)
+        null_idx = message_text.find("\x00")
+        if null_idx >= 0:
+            message_text = message_text[:null_idx]
     except UnicodeDecodeError:
         return None
 

app/event_handlers.py

@@ -1,13 +1,17 @@
-import asyncio
 import logging
 import time
 from typing import TYPE_CHECKING
 
 from meshcore import EventType
 
-from app.models import CONTACT_TYPE_REPEATER, Contact
+from app.models import CONTACT_TYPE_REPEATER, Contact, Message, MessagePath
 from app.packet_processor import process_raw_packet
-from app.repository import AmbiguousPublicKeyPrefixError, ContactRepository, MessageRepository
+from app.repository import (
+    AmbiguousPublicKeyPrefixError,
+    ContactNameHistoryRepository,
+    ContactRepository,
+    MessageRepository,
+)
 from app.websocket import broadcast_event
 
 if TYPE_CHECKING:
@@ -35,7 +39,7 @@ def track_pending_ack(expected_ack: str, message_id: int, timeout_ms: int) -> No
     )
 
 
-def _cleanup_expired_acks() -> None:
+def cleanup_expired_acks() -> None:
     """Remove expired pending ACKs."""
     now = time.time()
     expired = []
@@ -99,15 +103,28 @@ async def on_contact_message(event: "Event") -> None:
 
     # Try to create message - INSERT OR IGNORE handles duplicates atomically
     # If the packet processor already stored this message, this returns None
+    ts = payload.get("sender_timestamp")
+    sender_timestamp = ts if ts is not None else received_at
+    sender_name = contact.name if contact else None
+    path = payload.get("path")
+    payload_path_len = payload.get("path_len")
+    normalized_path_len = (
+        payload_path_len
+        if isinstance(payload_path_len, int)
+        else (len(path) // 2 if path is not None else None)
+    )
     msg_id = await MessageRepository.create(
         msg_type="PRIV",
         text=payload.get("text", ""),
         conversation_key=sender_pubkey,
-        sender_timestamp=payload.get("sender_timestamp") or received_at,
+        sender_timestamp=sender_timestamp,
         received_at=received_at,
-        path=payload.get("path"),
+        path=path,
+        path_len=normalized_path_len,
         txt_type=txt_type,
         signature=payload.get("signature"),
+        sender_key=sender_pubkey,
+        sender_name=sender_name,
     )
 
     if msg_id is None:
@@ -120,48 +137,34 @@ async def on_contact_message(event: "Event") -> None:
     logger.debug("DM from %s handled by event handler (fallback path)", sender_pubkey[:12])
 
     # Build paths array for broadcast
-    path = payload.get("path")
-    paths = [{"path": path or "", "received_at": received_at}] if path is not None else None
+    paths = (
+        [MessagePath(path=path or "", received_at=received_at, path_len=normalized_path_len)]
+        if path is not None
+        else None
+    )
 
     # Broadcast the new message
     broadcast_event(
         "message",
-        {
-            "id": msg_id,
-            "type": "PRIV",
-            "conversation_key": sender_pubkey,
-            "text": payload.get("text", ""),
-            "sender_timestamp": payload.get("sender_timestamp"),
-            "received_at": received_at,
-            "paths": paths,
-            "txt_type": txt_type,
-            "signature": payload.get("signature"),
-            "outgoing": False,
-            "acked": 0,
-        },
+        Message(
+            id=msg_id,
+            type="PRIV",
+            conversation_key=sender_pubkey,
+            text=payload.get("text", ""),
+            sender_timestamp=sender_timestamp,
+            received_at=received_at,
+            paths=paths,
+            txt_type=txt_type,
+            signature=payload.get("signature"),
+            sender_key=sender_pubkey,
+            sender_name=sender_name,
+        ).model_dump(),
     )
 
     # Update contact last_contacted (contact was already fetched above)
     if contact:
         await ContactRepository.update_last_contacted(sender_pubkey, received_at)
 
-    # Run bot if enabled
-    from app.bot import run_bot_for_message
-
-    asyncio.create_task(
-        run_bot_for_message(
-            sender_name=contact.name if contact else None,
-            sender_key=sender_pubkey,
-            message_text=payload.get("text", ""),
-            is_dm=True,
-            channel_key=None,
-            channel_name=None,
-            sender_timestamp=payload.get("sender_timestamp"),
-            path=payload.get("path"),
-            is_outgoing=False,
-        )
-    )
-
 
 async def on_rx_log_data(event: "Event") -> None:
     """Store raw RF packet data and process via centralized packet processor.
@@ -189,15 +192,45 @@ async def on_rx_log_data(event: "Event") -> None:
 async def on_path_update(event: "Event") -> None:
     """Handle path update events."""
     payload = event.payload
-    logger.debug("Path update for %s", payload.get("pubkey_prefix"))
+    public_key = str(payload.get("public_key", "")).lower()
+    pubkey_prefix = str(payload.get("pubkey_prefix", "")).lower()
 
-    pubkey_prefix = payload.get("pubkey_prefix", "")
-    path = payload.get("path", "")
-    path_len = payload.get("path_len", -1)
+    contact: Contact | None = None
+    if public_key:
+        logger.debug("Path update for %s", public_key[:12])
+        contact = await ContactRepository.get_by_key(public_key)
+    elif pubkey_prefix:
+        # Legacy compatibility: older payloads may only include a prefix.
+        logger.debug("Path update for prefix %s", pubkey_prefix)
+        contact = await ContactRepository.get_by_key_prefix(pubkey_prefix)
+    else:
+        logger.debug("PATH_UPDATE missing public_key/pubkey_prefix, skipping")
+        return
 
-    existing = await ContactRepository.get_by_key_prefix(pubkey_prefix)
-    if existing:
-        await ContactRepository.update_path(existing.public_key, path, path_len)
+    if not contact:
+        return
+
+    # PATH_UPDATE is a serial control push event from firmware (not an RF packet).
+    # Current meshcore payloads only include public_key for this event.
+    # RF route/path bytes are handled via RX_LOG_DATA -> process_raw_packet,
+    # so if path fields are absent here we treat this as informational only.
+    path = payload.get("path")
+    path_len = payload.get("path_len")
+    if path is None or path_len is None:
+        logger.debug(
+            "PATH_UPDATE for %s has no path payload, skipping DB update", contact.public_key[:12]
+        )
+        return
+
+    try:
+        normalized_path_len = int(path_len)
+    except (TypeError, ValueError):
+        logger.warning(
+            "Invalid path_len in PATH_UPDATE for %s: %r", contact.public_key[:12], path_len
+        )
+        return
+
+    await ContactRepository.update_path(contact.public_key, str(path), normalized_path_len)
 
 
 async def on_new_contact(event: "Event") -> None:
@@ -216,12 +249,29 @@ async def on_new_contact(event: "Event") -> None:
     logger.debug("New contact: %s", public_key[:12])
 
     contact_data = {
-        **Contact.from_radio_dict(public_key, payload, on_radio=True),
+        **Contact.from_radio_dict(public_key.lower(), payload, on_radio=True),
         "last_seen": int(time.time()),
     }
     await ContactRepository.upsert(contact_data)
 
-    broadcast_event("contact", contact_data)
+    # Record name history if contact has a name
+    adv_name = payload.get("adv_name")
+    if adv_name:
+        await ContactNameHistoryRepository.record_name(
+            public_key.lower(), adv_name, int(time.time())
+        )
+        backfilled = await MessageRepository.backfill_channel_sender_key(public_key, adv_name)
+        if backfilled > 0:
+            logger.info(
+                "Backfilled sender_key on %d channel message(s) for %s",
+                backfilled,
+                adv_name,
+            )
+
+    # Read back from DB so the broadcast includes all fields (last_contacted,
+    # last_read_at, etc.) matching the REST Contact shape exactly.
+    db_contact = await ContactRepository.get_by_key(public_key)
+    broadcast_event("contact", (db_contact.model_dump() if db_contact else contact_data))
 
 
 async def on_ack(event: "Event") -> None:
@@ -235,13 +285,16 @@ async def on_ack(event: "Event") -> None:
 
     logger.debug("Received ACK with code %s", ack_code)
 
-    _cleanup_expired_acks()
+    cleanup_expired_acks()
 
     if ack_code in _pending_acks:
         message_id, _, _ = _pending_acks.pop(ack_code)
         logger.info("ACK received for message %d", message_id)
 
         ack_count = await MessageRepository.increment_ack_count(message_id)
+        # DM ACKs don't carry path data, so paths is intentionally omitted.
+        # The frontend's mergePendingAck handles the missing field correctly,
+        # preserving any previously known paths.
         broadcast_event("message_acked", {"message_id": message_id, "ack_count": ack_count})
     else:
         logger.debug("ACK code %s does not match any pending messages", ack_code)

app/fanout/AGENTS_fanout.md

@@ -0,0 +1,284 @@
+# Fanout Bus Architecture
+
+The fanout bus is a unified system for dispatching mesh radio events (decoded messages and raw packets) to external integrations. It replaces the previous scattered singleton MQTT publishers with a modular, configurable framework.
+
+## Core Concepts
+
+### FanoutModule (base.py)
+Base class that all integration modules extend:
+- `__init__(config_id, config, *, name="")` — constructor; receives the config UUID, the type-specific config dict, and the user-assigned name
+- `start()` / `stop()` — async lifecycle (e.g. open/close connections)
+- `on_message(data)` — receive decoded messages (DM/channel)
+- `on_raw(data)` — receive raw RF packets
+- `status` property (**must override**) — return `"connected"`, `"disconnected"`, or `"error"`
+
+### FanoutManager (manager.py)
+Singleton that owns all active modules and dispatches events:
+- `load_from_db()` — startup: load enabled configs, instantiate modules
+- `reload_config(id)` — CRUD: stop old, start new
+- `remove_config(id)` — delete: stop and remove
+- `broadcast_message(data)` — scope-check + dispatch `on_message`
+- `broadcast_raw(data)` — scope-check + dispatch `on_raw`
+- `stop_all()` — shutdown
+- `get_statuses()` — health endpoint data
+
+All modules are constructed uniformly: `cls(config_id, config_blob, name=cfg.get("name", ""))`.
+
+### Scope Matching
+Each config has a `scope` JSON blob controlling what events reach it:
+```json
+{"messages": "all", "raw_packets": "all"}
+{"messages": "none", "raw_packets": "all"}
+{"messages": {"channels": ["key1"], "contacts": "all"}, "raw_packets": "none"}
+```
+Community MQTT always enforces `{"messages": "none", "raw_packets": "all"}`.
+
+## Event Flow
+
+```
+Radio Event -> packet_processor / event_handler
+  -> broadcast_event("message"|"raw_packet", data, realtime=True)
+    -> WebSocket broadcast (always)
+    -> FanoutManager.broadcast_message/raw (only if realtime=True)
+      -> scope check per module
+      -> module.on_message / on_raw
+```
+
+Setting `realtime=False` (used during historical decryption) skips fanout dispatch entirely.
+
+## Current Module Types
+
+### mqtt_private (mqtt_private.py)
+Wraps `MqttPublisher` from `app/fanout/mqtt.py`. Config blob:
+- `broker_host`, `broker_port`, `username`, `password`
+- `use_tls`, `tls_insecure`, `topic_prefix`
+
+### mqtt_community (mqtt_community.py)
+Wraps `CommunityMqttPublisher` from `app/fanout/community_mqtt.py`. Config blob:
+- `broker_host`, `broker_port`, `iata`, `email`
+- Only publishes raw packets (on_message is a no-op)
+
+### bot (bot.py)
+Wraps bot code execution via `app/fanout/bot_exec.py`. Config blob:
+- `code` — Python bot function source code
+- Executes in a thread pool with timeout and semaphore concurrency control
+- Rate-limits outgoing messages for repeater compatibility
+
+### webhook (webhook.py)
+HTTP webhook delivery. Config blob:
+- `url`, `method` (POST/PUT/PATCH)
+- `hmac_secret` (optional) — when set, each request includes an HMAC-SHA256 signature of the JSON body
+- `hmac_header` (optional, default `X-Webhook-Signature`) — header name for the signature (value format: `sha256=<hex>`)
+- `headers` — arbitrary extra headers (JSON object)
+
+### apprise (apprise_mod.py)
+Push notifications via Apprise library. Config blob:
+- `urls` — newline-separated Apprise notification service URLs
+- `preserve_identity` — suppress Discord webhook name/avatar override
+- `include_path` — include routing path in notification body
+
+## Adding a New Integration Type
+
+### Step-by-step checklist
+
+#### 1. Backend module (`app/fanout/my_type.py`)
+
+Create a class extending `FanoutModule`:
+
+```python
+from app.fanout.base import FanoutModule
+
+class MyTypeModule(FanoutModule):
+    def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
+        super().__init__(config_id, config, name=name)
+        # Initialize module-specific state
+
+    async def start(self) -> None:
+        """Open connections, create clients, etc."""
+
+    async def stop(self) -> None:
+        """Close connections, clean up resources."""
+
+    async def on_message(self, data: dict) -> None:
+        """Handle decoded messages. Omit if not needed."""
+
+    async def on_raw(self, data: dict) -> None:
+        """Handle raw packets. Omit if not needed."""
+
+    @property
+    def status(self) -> str:
+        """Required. Return 'connected', 'disconnected', or 'error'."""
+        ...
+```
+
+Constructor requirements:
+- Must accept `config_id: str, config: dict, *, name: str = ""`
+- Must forward `name` to super: `super().__init__(config_id, config, name=name)`
+
+#### 2. Register in manager (`app/fanout/manager.py`)
+
+Add import and mapping in `_register_module_types()`:
+
+```python
+from app.fanout.my_type import MyTypeModule
+_MODULE_TYPES["my_type"] = MyTypeModule
+```
+
+#### 3. Router changes (`app/routers/fanout.py`)
+
+Three changes needed:
+
+**a)** Add to `_VALID_TYPES` set:
+```python
+_VALID_TYPES = {"mqtt_private", "mqtt_community", "bot", "webhook", "apprise", "my_type"}
+```
+
+**b)** Add a validation function:
+```python
+def _validate_my_type_config(config: dict) -> None:
+    """Validate my_type config blob."""
+    if not config.get("some_required_field"):
+        raise HTTPException(status_code=400, detail="some_required_field is required")
+```
+
+**c)** Wire validation into both `create_fanout_config` and `update_fanout_config` — add an `elif` to the validation block in each:
+```python
+elif body.type == "my_type":
+    _validate_my_type_config(body.config)
+```
+Note: validation only runs when the config will be enabled (disabled configs are treated as drafts).
+
+**d)** Add scope enforcement in `_enforce_scope()` if the type has fixed scope constraints (e.g. raw_packets always none). Otherwise it falls through to the `mqtt_private` default which allows both messages and raw_packets to be configurable.
+
+#### 4. Frontend editor component (`SettingsFanoutSection.tsx`)
+
+Four changes needed in this single file:
+
+**a)** Add to `TYPE_LABELS` and `TYPE_OPTIONS` at the top:
+```tsx
+const TYPE_LABELS: Record<string, string> = {
+  // ... existing entries ...
+  my_type: 'My Type',
+};
+
+const TYPE_OPTIONS = [
+  // ... existing entries ...
+  { value: 'my_type', label: 'My Type' },
+];
+```
+
+**b)** Create an editor component (follows the same pattern as existing editors):
+```tsx
+function MyTypeConfigEditor({
+  config,
+  scope,
+  onChange,
+  onScopeChange,
+}: {
+  config: Record<string, unknown>;
+  scope: Record<string, unknown>;
+  onChange: (config: Record<string, unknown>) => void;
+  onScopeChange: (scope: Record<string, unknown>) => void;
+}) {
+  return (
+    <div className="space-y-3">
+      {/* Type-specific config fields */}
+      <Separator />
+      <ScopeSelector scope={scope} onChange={onScopeChange} />
+    </div>
+  );
+}
+```
+
+If your type does NOT have user-configurable scope (like bot or community MQTT), omit the `scope`/`onScopeChange` props and the `ScopeSelector`.
+
+The `ScopeSelector` component is defined within the same file. It accepts an optional `showRawPackets` prop:
+- **Without `showRawPackets`** (webhook, apprise): shows message scope only (all/only/except — no "none" option since that would make the integration a no-op). A warning appears when the effective selection matches nothing.
+- **With `showRawPackets`** (private MQTT): adds a "Forward raw packets" toggle and includes the "No messages" option (valid when raw packets are enabled). The warning appears only when both raw packets and messages are effectively disabled.
+
+**c)** Add default config and scope in `handleAddCreate`:
+```tsx
+const defaults: Record<string, Record<string, unknown>> = {
+  // ... existing entries ...
+  my_type: { some_field: '', other_field: true },
+};
+const defaultScopes: Record<string, Record<string, unknown>> = {
+  // ... existing entries ...
+  my_type: { messages: 'all', raw_packets: 'none' },
+};
+```
+
+**d)** Wire the editor into the detail view's conditional render block:
+```tsx
+{editingConfig.type === 'my_type' && (
+  <MyTypeConfigEditor
+    config={editConfig}
+    scope={editScope}
+    onChange={setEditConfig}
+    onScopeChange={setEditScope}
+  />
+)}
+```
+
+#### 5. Tests
+
+**Backend integration tests** (`tests/test_fanout_integration.py`):
+- Test that a configured + enabled module receives messages via `FanoutManager.broadcast_message`
+- Test scope filtering (all, none, selective)
+- Test that a disabled module does not receive messages
+
+**Backend unit tests** (`tests/test_fanout_hitlist.py` or a dedicated file):
+- Test config validation (required fields, bad values)
+- Test module-specific logic in isolation
+
+**Frontend tests** (`frontend/src/test/fanoutSection.test.tsx`):
+- The existing suite covers the list/edit/create flow generically. If your editor has special behavior, add specific test cases.
+
+#### Summary of files to touch
+
+| File | Change |
+|------|--------|
+| `app/fanout/my_type.py` | New module class |
+| `app/fanout/manager.py` | Import + register in `_register_module_types()` |
+| `app/routers/fanout.py` | `_VALID_TYPES` + validator function + scope enforcement |
+| `frontend/.../SettingsFanoutSection.tsx` | `TYPE_LABELS` + `TYPE_OPTIONS` + editor component + defaults + detail view wiring |
+| `tests/test_fanout_integration.py` | Integration tests |
+
+## REST API
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/fanout` | List all fanout configs |
+| POST | `/api/fanout` | Create new config |
+| PATCH | `/api/fanout/{id}` | Update config (triggers module reload) |
+| DELETE | `/api/fanout/{id}` | Delete config (stops module) |
+
+## Database
+
+`fanout_configs` table:
+- `id` TEXT PRIMARY KEY
+- `type`, `name`, `enabled`, `config` (JSON), `scope` (JSON)
+- `sort_order`, `created_at`
+
+Migrations:
+- **36**: Creates `fanout_configs` table, migrates existing MQTT settings from `app_settings`
+- **37**: Migrates bot configs from `app_settings.bots` JSON column into fanout rows
+- **38**: Drops legacy `mqtt_*`, `community_mqtt_*`, and `bots` columns from `app_settings`
+
+## Key Files
+
+- `app/fanout/base.py` — FanoutModule base class
+- `app/fanout/manager.py` — FanoutManager singleton
+- `app/fanout/mqtt_base.py` — BaseMqttPublisher ABC (shared MQTT connection loop)
+- `app/fanout/mqtt.py` — MqttPublisher (private MQTT publishing)
+- `app/fanout/community_mqtt.py` — CommunityMqttPublisher (community MQTT with JWT auth)
+- `app/fanout/mqtt_private.py` — Private MQTT fanout module
+- `app/fanout/mqtt_community.py` — Community MQTT fanout module
+- `app/fanout/bot.py` — Bot fanout module
+- `app/fanout/bot_exec.py` — Bot code execution, response processing, rate limiting
+- `app/fanout/webhook.py` — Webhook fanout module
+- `app/fanout/apprise_mod.py` — Apprise fanout module
+- `app/repository/fanout.py` — Database CRUD
+- `app/routers/fanout.py` — REST API
+- `app/websocket.py` — `broadcast_event()` dispatches to fanout
+- `frontend/src/components/settings/SettingsFanoutSection.tsx` — UI

app/fanout/__init__.py

@@ -0,0 +1,8 @@
+from app.fanout.base import FanoutModule
+from app.fanout.manager import FanoutManager, fanout_manager
+
+__all__ = [
+    "FanoutManager",
+    "FanoutModule",
+    "fanout_manager",
+]

app/fanout/apprise_mod.py

@@ -0,0 +1,136 @@
+"""Fanout module for Apprise push notifications."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from app.fanout.base import FanoutModule
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_urls(raw: str) -> list[str]:
+    """Split multi-line URL string into individual URLs."""
+    return [line.strip() for line in raw.splitlines() if line.strip()]
+
+
+def _normalize_discord_url(url: str) -> str:
+    """Add avatar=no to Discord URLs to suppress identity override."""
+    parts = urlsplit(url)
+    scheme = parts.scheme.lower()
+    host = parts.netloc.lower()
+
+    is_discord = scheme in ("discord", "discords") or (
+        scheme in ("http", "https")
+        and host in ("discord.com", "discordapp.com")
+        and parts.path.lower().startswith("/api/webhooks/")
+    )
+    if not is_discord:
+        return url
+
+    query = dict(parse_qsl(parts.query, keep_blank_values=True))
+    query["avatar"] = "no"
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
+
+
+def _format_body(data: dict, *, include_path: bool) -> str:
+    """Build a human-readable notification body from message data."""
+    msg_type = data.get("type", "")
+    text = data.get("text", "")
+    sender_name = data.get("sender_name") or "Unknown"
+
+    via = ""
+    if include_path:
+        paths = data.get("paths")
+        first_path = (
+            paths[0]
+            if isinstance(paths, list) and len(paths) > 0 and isinstance(paths[0], dict)
+            else None
+        )
+        if first_path is not None:
+            path_str = first_path.get("path", "")
+        else:
+            path_str = None
+
+        if msg_type == "PRIV" and path_str is None:
+            via = " **via:** [`direct`]"
+        elif path_str is not None:
+            path_str = path_str.strip().lower()
+            if path_str == "":
+                via = " **via:** [`direct`]"
+            else:
+                path_len = first_path.get("path_len") if first_path is not None else None
+                hop_chars = (
+                    len(path_str) // path_len
+                    if isinstance(path_len, int) and path_len > 0 and len(path_str) % path_len == 0
+                    else 2
+                )
+                hops = [path_str[i : i + hop_chars] for i in range(0, len(path_str), hop_chars)]
+                if hops:
+                    hop_list = ", ".join(f"`{h}`" for h in hops)
+                    via = f" **via:** [{hop_list}]"
+
+    if msg_type == "PRIV":
+        return f"**DM:** {sender_name}: {text}{via}"
+
+    channel_name = data.get("channel_name") or data.get("conversation_key", "channel")
+    return f"**{channel_name}:** {sender_name}: {text}{via}"
+
+
+def _send_sync(urls_raw: str, body: str, *, preserve_identity: bool) -> bool:
+    """Send notification synchronously via Apprise. Returns True on success."""
+    import apprise as apprise_lib
+
+    urls = _parse_urls(urls_raw)
+    if not urls:
+        return False
+
+    notifier = apprise_lib.Apprise()
+    for url in urls:
+        if preserve_identity:
+            url = _normalize_discord_url(url)
+        notifier.add(url)
+
+    return bool(notifier.notify(title="", body=body))
+
+
+class AppriseModule(FanoutModule):
+    """Sends push notifications via Apprise for incoming messages."""
+
+    def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
+        super().__init__(config_id, config, name=name)
+        self._last_error: str | None = None
+
+    async def on_message(self, data: dict) -> None:
+        # Skip outgoing messages — only notify on incoming
+        if data.get("outgoing"):
+            return
+
+        urls = self.config.get("urls", "")
+        if not urls or not urls.strip():
+            return
+
+        preserve_identity = self.config.get("preserve_identity", True)
+        include_path = self.config.get("include_path", True)
+        body = _format_body(data, include_path=include_path)
+
+        try:
+            success = await asyncio.to_thread(
+                _send_sync, urls, body, preserve_identity=preserve_identity
+            )
+            self._last_error = None if success else "Apprise notify returned failure"
+            if not success:
+                logger.warning("Apprise notification failed for module %s", self.config_id)
+        except Exception as exc:
+            self._last_error = str(exc)
+            logger.exception("Apprise send error for module %s", self.config_id)
+
+    @property
+    def status(self) -> str:
+        if not self.config.get("urls", "").strip():
+            return "disconnected"
+        if self._last_error:
+            return "error"
+        return "connected"

app/fanout/base.py

@@ -0,0 +1,35 @@
+"""Base class for fanout integration modules."""
+
+from __future__ import annotations
+
+
+class FanoutModule:
+    """Base class for all fanout integrations.
+
+    Each module wraps a specific integration (MQTT, webhook, etc.) and
+    receives dispatched messages/packets from the FanoutManager.
+
+    Subclasses must override the ``status`` property.
+    """
+
+    def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
+        self.config_id = config_id
+        self.config = config
+        self.name = name
+
+    async def start(self) -> None:
+        """Start the module (e.g. connect to broker). Override for persistent connections."""
+
+    async def stop(self) -> None:
+        """Stop the module (e.g. disconnect from broker)."""
+
+    async def on_message(self, data: dict) -> None:
+        """Called for decoded messages (DM/channel). Override if needed."""
+
+    async def on_raw(self, data: dict) -> None:
+        """Called for raw RF packets. Override if needed."""
+
+    @property
+    def status(self) -> str:
+        """Return 'connected', 'disconnected', or 'error'."""
+        raise NotImplementedError

app/fanout/bot.py

@@ -0,0 +1,142 @@
+"""Fanout module wrapping bot execution logic."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from app.fanout.base import FanoutModule
+
+logger = logging.getLogger(__name__)
+
+
+class BotModule(FanoutModule):
+    """Wraps a single bot's code execution and response routing.
+
+    Each BotModule represents one bot configuration. It receives decoded
+    messages via ``on_message``, executes the bot's Python code in a
+    background task (after a 2-second settle delay), and sends any response
+    back through the radio.
+    """
+
+    def __init__(self, config_id: str, config: dict, *, name: str = "Bot") -> None:
+        super().__init__(config_id, config, name=name)
+        self._tasks: set[asyncio.Task] = set()
+        self._active = True
+
+    async def stop(self) -> None:
+        self._active = False
+        for task in self._tasks:
+            task.cancel()
+        # Wait briefly for tasks to acknowledge cancellation
+        if self._tasks:
+            await asyncio.gather(*self._tasks, return_exceptions=True)
+        self._tasks.clear()
+
+    async def on_message(self, data: dict) -> None:
+        """Kick off bot execution in a background task so we don't block dispatch."""
+        task = asyncio.create_task(self._run_for_message(data))
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+
+    async def _run_for_message(self, data: dict) -> None:
+        from app.fanout.bot_exec import (
+            BOT_EXECUTION_TIMEOUT,
+            execute_bot_code,
+            process_bot_response,
+        )
+
+        code = self.config.get("code", "")
+        if not code or not code.strip():
+            return
+
+        msg_type = data.get("type", "")
+        is_dm = msg_type == "PRIV"
+
+        # Extract bot parameters from broadcast data
+        if is_dm:
+            conversation_key = data.get("conversation_key", "")
+            sender_key = data.get("sender_key") or conversation_key
+            is_outgoing = data.get("outgoing", False)
+            message_text = data.get("text", "")
+            channel_key = None
+            channel_name = None
+
+            # Outgoing DMs: sender is us, not the contact
+            if is_outgoing:
+                sender_name = None
+            else:
+                sender_name = data.get("sender_name")
+                if sender_name is None:
+                    from app.repository import ContactRepository
+
+                    contact = await ContactRepository.get_by_key(conversation_key)
+                    sender_name = contact.name if contact else None
+        else:
+            conversation_key = data.get("conversation_key", "")
+            sender_key = None
+            is_outgoing = bool(data.get("outgoing", False))
+            sender_name = data.get("sender_name")
+            channel_key = conversation_key
+
+            channel_name = data.get("channel_name")
+            if channel_name is None:
+                from app.repository import ChannelRepository
+
+                channel = await ChannelRepository.get_by_key(conversation_key)
+                channel_name = channel.name if channel else None
+
+            # Strip "sender: " prefix from channel message text
+            text = data.get("text", "")
+            if sender_name and text.startswith(f"{sender_name}: "):
+                message_text = text[len(f"{sender_name}: ") :]
+            else:
+                message_text = text
+
+        sender_timestamp = data.get("sender_timestamp")
+        path_value = data.get("path")
+        # Message model serializes paths as list of dicts; extract first path string
+        if path_value is None:
+            paths = data.get("paths")
+            if paths and isinstance(paths, list) and len(paths) > 0:
+                path_value = paths[0].get("path") if isinstance(paths[0], dict) else None
+
+        # Wait for message to settle (allows retransmissions to be deduped)
+        await asyncio.sleep(2)
+
+        # Execute bot code in thread pool with timeout
+        from app.fanout.bot_exec import _bot_executor, _bot_semaphore
+
+        async with _bot_semaphore:
+            loop = asyncio.get_running_loop()
+            try:
+                response = await asyncio.wait_for(
+                    loop.run_in_executor(
+                        _bot_executor,
+                        execute_bot_code,
+                        code,
+                        sender_name,
+                        sender_key,
+                        message_text,
+                        is_dm,
+                        channel_key,
+                        channel_name,
+                        sender_timestamp,
+                        path_value,
+                        is_outgoing,
+                    ),
+                    timeout=BOT_EXECUTION_TIMEOUT,
+                )
+            except asyncio.TimeoutError:
+                logger.warning("Bot '%s' execution timed out", self.name)
+                return
+            except Exception as e:
+                logger.warning("Bot '%s' execution error: %s", self.name, e)
+                return
+
+        if response and self._active:
+            await process_bot_response(response, is_dm, sender_key or "", channel_key)
+
+    @property
+    def status(self) -> str:
+        return "connected"

app/fanout/bot_exec.py

@@ -11,6 +11,7 @@ the security implications.
 """
 
 import asyncio
+import inspect
 import logging
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -48,15 +49,19 @@ def execute_bot_code(
     channel_name: str | None,
     sender_timestamp: int | None,
     path: str | None,
+    is_outgoing: bool = False,
 ) -> str | list[str] | None:
     """
     Execute user-provided bot code with message context.
 
     The code should define a function:
-    `bot(sender_name, sender_key, message_text, is_dm, channel_key, channel_name, sender_timestamp, path)`
+    `bot(sender_name, sender_key, message_text, is_dm, channel_key, channel_name, sender_timestamp, path, is_outgoing)`
     that returns either None (no response), a string (single response message),
     or a list of strings (multiple messages sent in order).
 
+    Legacy bot functions with 8 parameters (without is_outgoing) are detected
+    via inspect and called without the new parameter for backward compatibility.
+
     Args:
         code: Python code defining the bot function
         sender_name: Display name of the sender (may be None)
@@ -67,6 +72,7 @@ def execute_bot_code(
         channel_name: Channel name (e.g. "#general" with hash), None for DMs
         sender_timestamp: Sender's timestamp from the message (may be None)
         path: Hex-encoded routing path (may be None)
+        is_outgoing: True if this is our own outgoing message
 
     Returns:
         Response string, list of strings, or None.
@@ -95,18 +101,63 @@ def execute_bot_code(
 
     bot_func = namespace["bot"]
 
+    # Detect whether the bot function accepts is_outgoing (new 9-param signature)
+    # or uses the legacy 8-param signature, for backward compatibility.
+    # Three cases: explicit is_outgoing param or 9+ params (positional),
+    # **kwargs (pass as keyword), or legacy 8-param (omit).
+    call_style = "legacy"  # "positional", "keyword", or "legacy"
     try:
-        # Call the bot function with message context
-        result = bot_func(
-            sender_name,
-            sender_key,
-            message_text,
-            is_dm,
-            channel_key,
-            channel_name,
-            sender_timestamp,
-            path,
-        )
+        sig = inspect.signature(bot_func)
+        params = sig.parameters
+        non_variadic = [
+            p
+            for p in params.values()
+            if p.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+        ]
+        if "is_outgoing" in params or len(non_variadic) >= 9:
+            call_style = "positional"
+        elif any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()):
+            call_style = "keyword"
+    except (ValueError, TypeError):
+        pass
+
+    try:
+        # Call the bot function with appropriate signature
+        if call_style == "positional":
+            result = bot_func(
+                sender_name,
+                sender_key,
+                message_text,
+                is_dm,
+                channel_key,
+                channel_name,
+                sender_timestamp,
+                path,
+                is_outgoing,
+            )
+        elif call_style == "keyword":
+            result = bot_func(
+                sender_name,
+                sender_key,
+                message_text,
+                is_dm,
+                channel_key,
+                channel_name,
+                sender_timestamp,
+                path,
+                is_outgoing=is_outgoing,
+            )
+        else:
+            result = bot_func(
+                sender_name,
+                sender_key,
+                message_text,
+                is_dm,
+                channel_key,
+                channel_name,
+                sender_timestamp,
+                path,
+            )
 
         # Validate result
         if result is None:
@@ -206,93 +257,3 @@ async def _send_single_bot_message(
 
         # Update last send time after successful send
         _last_bot_send_time = time.monotonic()
-
-
-async def run_bot_for_message(
-    sender_name: str | None,
-    sender_key: str | None,
-    message_text: str,
-    is_dm: bool,
-    channel_key: str | None,
-    channel_name: str | None = None,
-    sender_timestamp: int | None = None,
-    path: str | None = None,
-    is_outgoing: bool = False,
-) -> None:
-    """
-    Run all enabled bots for a message (incoming or outgoing).
-
-    This is the main entry point called by message handlers after
-    a message is successfully decrypted and stored. Bots run serially,
-    and errors in one bot don't prevent others from running.
-
-    Args:
-        sender_name: Display name of the sender
-        sender_key: 64-char hex public key of sender (DMs only, None for channels)
-        message_text: The message content
-        is_dm: True for direct messages, False for channel messages
-        channel_key: Channel key for channel messages
-        channel_name: Channel name (e.g. "#general"), None for DMs
-        sender_timestamp: Sender's timestamp from the message
-        path: Hex-encoded routing path
-        is_outgoing: Whether this is our own outgoing message
-    """
-    # Early check if any bots are enabled (will re-check after sleep)
-    from app.repository import AppSettingsRepository
-
-    settings = await AppSettingsRepository.get()
-    enabled_bots = [b for b in settings.bots if b.enabled and b.code.strip()]
-    if not enabled_bots:
-        return
-
-    async with _bot_semaphore:
-        logger.debug(
-            "Running %d bot(s) for message from %s (is_dm=%s)",
-            len(enabled_bots),
-            sender_name or (sender_key[:12] if sender_key else "unknown"),
-            is_dm,
-        )
-
-        # Wait for the initiating message's retransmissions to propagate through the mesh
-        await asyncio.sleep(2)
-
-        # Re-check settings after sleep (user may have changed bot config)
-        settings = await AppSettingsRepository.get()
-        enabled_bots = [b for b in settings.bots if b.enabled and b.code.strip()]
-        if not enabled_bots:
-            logger.debug("All bots disabled during wait, skipping")
-            return
-
-        # Run each enabled bot serially
-        loop = asyncio.get_event_loop()
-        for bot in enabled_bots:
-            logger.debug("Executing bot '%s'", bot.name)
-            try:
-                response = await asyncio.wait_for(
-                    loop.run_in_executor(
-                        _bot_executor,
-                        execute_bot_code,
-                        bot.code,
-                        sender_name,
-                        sender_key,
-                        message_text,
-                        is_dm,
-                        channel_key,
-                        channel_name,
-                        sender_timestamp,
-                        path,
-                    ),
-                    timeout=BOT_EXECUTION_TIMEOUT,
-                )
-            except asyncio.TimeoutError:
-                logger.warning(
-                    "Bot '%s' execution timed out after %ds", bot.name, BOT_EXECUTION_TIMEOUT
-                )
-                continue  # Continue to next bot
-            except Exception as e:
-                logger.warning("Bot '%s' execution error: %s", bot.name, e)
-                continue  # Continue to next bot
-
-            # Send response if any
-            if response:
-                await process_bot_response(response, is_dm, sender_key or "", channel_key)

app/fanout/community_mqtt.py

@@ -0,0 +1,571 @@
+"""Community MQTT publisher for sharing raw packets with the MeshCore community.
+
+Publishes raw packet data to mqtt-us-v1.letsmesh.net using the protocol
+defined by meshcore-packet-capture (https://github.com/agessaman/meshcore-packet-capture).
+
+Authentication uses Ed25519 JWT tokens signed with the radio's private key.
+This module is independent from the private MqttPublisher in app/mqtt.py.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import importlib.metadata
+import json
+import logging
+import ssl
+import time
+from datetime import datetime
+from typing import Any, Protocol
+
+import aiomqtt
+import nacl.bindings
+
+from app.decoder import decode_path_metadata
+from app.fanout.mqtt_base import BaseMqttPublisher
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_BROKER = "mqtt-us-v1.letsmesh.net"
+_DEFAULT_PORT = 443  # Community protocol uses WSS on port 443 by default
+_CLIENT_ID = "RemoteTerm (github.com/jkingsman/Remote-Terminal-for-MeshCore)"
+
+# Proactive JWT renewal: reconnect 1 hour before the 24h token expires
+_TOKEN_LIFETIME = 86400  # 24 hours (must match _generate_jwt_token exp)
+_TOKEN_RENEWAL_THRESHOLD = _TOKEN_LIFETIME - 3600  # 23 hours
+
+# Periodic status republish interval (matches meshcore-packet-capture reference)
+_STATS_REFRESH_INTERVAL = 300  # 5 minutes
+_STATS_MIN_CACHE_SECS = 60  # Don't re-fetch stats within 60s
+
+# Ed25519 group order
+_L = 2**252 + 27742317777372353535851937790883648493
+
+# Route type mapping: bottom 2 bits of first byte
+_ROUTE_MAP = {0: "F", 1: "F", 2: "D", 3: "T"}
+
+
+class CommunityMqttSettings(Protocol):
+    """Attributes expected on the settings object for the community MQTT publisher."""
+
+    community_mqtt_enabled: bool
+    community_mqtt_broker_host: str
+    community_mqtt_broker_port: int
+    community_mqtt_iata: str
+    community_mqtt_email: str
+
+
+def _base64url_encode(data: bytes) -> str:
+    """Base64url encode without padding."""
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _ed25519_sign_expanded(
+    message: bytes, scalar: bytes, prefix: bytes, public_key: bytes
+) -> bytes:
+    """Sign a message using MeshCore's expanded Ed25519 key format.
+
+    MeshCore stores 64-byte "orlp" format keys: scalar(32) || prefix(32).
+    Standard Ed25519 libraries expect seed format and would re-SHA-512 the key.
+    This performs the signing manually using the already-expanded key material.
+
+    Port of meshcore-packet-capture's ed25519_sign_with_expanded_key().
+    """
+    # r = SHA-512(prefix || message) mod L
+    r = int.from_bytes(hashlib.sha512(prefix + message).digest(), "little") % _L
+    # R = r * B (base point multiplication)
+    R = nacl.bindings.crypto_scalarmult_ed25519_base_noclamp(r.to_bytes(32, "little"))
+    # k = SHA-512(R || public_key || message) mod L
+    k = int.from_bytes(hashlib.sha512(R + public_key + message).digest(), "little") % _L
+    # s = (r + k * scalar) mod L
+    s = (r + k * int.from_bytes(scalar, "little")) % _L
+    return R + s.to_bytes(32, "little")
+
+
+def _generate_jwt_token(
+    private_key: bytes,
+    public_key: bytes,
+    *,
+    audience: str = _DEFAULT_BROKER,
+    email: str = "",
+) -> str:
+    """Generate a JWT token for community MQTT authentication.
+
+    Creates a token with Ed25519 signature using MeshCore's expanded key format.
+    Token format: header_b64.payload_b64.signature_hex
+
+    Optional ``email`` embeds a node-claiming identity so the community
+    aggregator can associate this radio with an owner.
+    """
+    header = {"alg": "Ed25519", "typ": "JWT"}
+    now = int(time.time())
+    pubkey_hex = public_key.hex().upper()
+    payload: dict[str, object] = {
+        "publicKey": pubkey_hex,
+        "iat": now,
+        "exp": now + _TOKEN_LIFETIME,
+        "aud": audience,
+        "owner": pubkey_hex,
+        "client": _CLIENT_ID,
+    }
+    if email:
+        payload["email"] = email
+
+    header_b64 = _base64url_encode(json.dumps(header, separators=(",", ":")).encode())
+    payload_b64 = _base64url_encode(json.dumps(payload, separators=(",", ":")).encode())
+
+    signing_input = f"{header_b64}.{payload_b64}".encode()
+
+    scalar = private_key[:32]
+    prefix = private_key[32:]
+    signature = _ed25519_sign_expanded(signing_input, scalar, prefix, public_key)
+
+    return f"{header_b64}.{payload_b64}.{signature.hex()}"
+
+
+def _calculate_packet_hash(raw_bytes: bytes) -> str:
+    """Calculate packet hash matching MeshCore's Packet::calculatePacketHash().
+
+    Parses the packet structure to extract payload type and payload data,
+    then hashes: payload_type(1 byte) [+ path_len(2 bytes LE) for TRACE] + payload_data.
+    Returns first 16 hex characters (uppercase).
+    """
+    if not raw_bytes:
+        return "0" * 16
+
+    try:
+        header = raw_bytes[0]
+        payload_type = (header >> 2) & 0x0F
+        route_type = header & 0x03
+
+        # Transport codes present for TRANSPORT_FLOOD (0) and TRANSPORT_DIRECT (3)
+        has_transport = route_type in (0x00, 0x03)
+
+        offset = 1  # Past header
+        if has_transport:
+            offset += 4  # Skip 4 bytes of transport codes
+
+        # Read packed path metadata. Invalid/truncated packets map to zero hash.
+        if offset >= len(raw_bytes):
+            return "0" * 16
+        packed_path_len = raw_bytes[offset]
+        path_len, _path_hash_size, path_byte_length = decode_path_metadata(packed_path_len)
+        offset += 1
+
+        # Skip past path to get to payload. Invalid/truncated packets map to zero hash.
+        if len(raw_bytes) < offset + path_byte_length:
+            return "0" * 16
+        payload_start = offset + path_byte_length
+        payload_data = raw_bytes[payload_start:]
+
+        # Hash: payload_type(1 byte) [+ packed path_len as uint16_t LE for TRACE] + payload_data
+        hash_obj = hashlib.sha256()
+        hash_obj.update(bytes([payload_type]))
+        if payload_type == 9:  # PAYLOAD_TYPE_TRACE
+            hash_obj.update(packed_path_len.to_bytes(2, byteorder="little"))
+        hash_obj.update(payload_data)
+
+        return hash_obj.hexdigest()[:16].upper()
+    except Exception:
+        return "0" * 16
+
+
+def _decode_packet_fields(raw_bytes: bytes) -> tuple[str, str, str, list[str], int | None]:
+    """Decode packet fields used by the community uploader payload format.
+
+    Returns:
+        (route_letter, packet_type_str, payload_len_str, path_values, payload_type_int)
+    """
+    # Reference defaults when decode fails
+    route = "U"
+    packet_type = "0"
+    payload_len = "0"
+    path_values: list[str] = []
+    payload_type: int | None = None
+
+    try:
+        if len(raw_bytes) < 2:
+            return route, packet_type, payload_len, path_values, payload_type
+
+        header = raw_bytes[0]
+        payload_version = (header >> 6) & 0x03
+        if payload_version != 0:
+            return route, packet_type, payload_len, path_values, payload_type
+
+        route_type = header & 0x03
+        has_transport = route_type in (0x00, 0x03)
+
+        offset = 1
+        if has_transport:
+            offset += 4
+
+        if len(raw_bytes) <= offset:
+            return route, packet_type, payload_len, path_values, payload_type
+
+        path_len, path_hash_size, path_byte_length = decode_path_metadata(raw_bytes[offset])
+        offset += 1
+
+        if len(raw_bytes) < offset + path_byte_length:
+            return route, packet_type, payload_len, path_values, payload_type
+
+        path_bytes = raw_bytes[offset : offset + path_byte_length]
+        offset += path_byte_length
+
+        payload_type = (header >> 2) & 0x0F
+        route = _ROUTE_MAP.get(route_type, "U")
+        packet_type = str(payload_type)
+        payload_len = str(max(0, len(raw_bytes) - offset))
+        path_values = [
+            path_bytes[i : i + path_hash_size].hex()
+            for i in range(0, len(path_bytes), path_hash_size)
+            if i + path_hash_size <= len(path_bytes)
+        ]
+
+        return route, packet_type, payload_len, path_values, payload_type
+    except Exception:
+        return route, packet_type, payload_len, path_values, payload_type
+
+
+def _format_raw_packet(data: dict[str, Any], device_name: str, public_key_hex: str) -> dict:
+    """Convert a RawPacketBroadcast dict to meshcore-packet-capture format."""
+    raw_hex = data.get("data", "")
+    raw_bytes = bytes.fromhex(raw_hex) if raw_hex else b""
+
+    route, packet_type, payload_len, path_values, _payload_type = _decode_packet_fields(raw_bytes)
+
+    # Reference format uses local "now" timestamp and derived time/date fields.
+    current_time = datetime.now()
+    ts_str = current_time.isoformat()
+
+    # SNR/RSSI are always strings in reference output.
+    snr_val = data.get("snr")
+    rssi_val = data.get("rssi")
+    snr = str(snr_val) if snr_val is not None else "Unknown"
+    rssi = str(rssi_val) if rssi_val is not None else "Unknown"
+
+    packet_hash = _calculate_packet_hash(raw_bytes)
+
+    packet = {
+        "origin": device_name or "MeshCore Device",
+        "origin_id": public_key_hex.upper(),
+        "timestamp": ts_str,
+        "type": "PACKET",
+        "direction": "rx",
+        "time": current_time.strftime("%H:%M:%S"),
+        "date": current_time.strftime("%d/%m/%Y"),
+        "len": str(len(raw_bytes)),
+        "packet_type": packet_type,
+        "route": route,
+        "payload_len": payload_len,
+        "raw": raw_hex.upper(),
+        "SNR": snr,
+        "RSSI": rssi,
+        "hash": packet_hash,
+    }
+
+    if route == "D":
+        packet["path"] = ",".join(path_values)
+
+    return packet
+
+
+def _build_status_topic(settings: CommunityMqttSettings, pubkey_hex: str) -> str:
+    """Build the ``meshcore/{IATA}/{PUBKEY}/status`` topic string."""
+    iata = settings.community_mqtt_iata.upper().strip()
+    return f"meshcore/{iata}/{pubkey_hex}/status"
+
+
+def _build_radio_info() -> str:
+    """Format the radio parameters string from self_info.
+
+    Matches the reference format: ``"freq,bw,sf,cr"`` (comma-separated raw
+    values).  Falls back to ``"0,0,0,0"`` when unavailable.
+    """
+    from app.radio import radio_manager
+
+    try:
+        if radio_manager.meshcore and radio_manager.meshcore.self_info:
+            info = radio_manager.meshcore.self_info
+            freq = info.get("radio_freq", 0)
+            bw = info.get("radio_bw", 0)
+            sf = info.get("radio_sf", 0)
+            cr = info.get("radio_cr", 0)
+            return f"{freq},{bw},{sf},{cr}"
+    except Exception:
+        pass
+    return "0,0,0,0"
+
+
+def _get_client_version() -> str:
+    """Return a client version string like ``'RemoteTerm 2.4.0'``."""
+    try:
+        version = importlib.metadata.version("remoteterm-meshcore")
+        return f"RemoteTerm {version}"
+    except Exception:
+        return "RemoteTerm unknown"
+
+
+class CommunityMqttPublisher(BaseMqttPublisher):
+    """Manages the community MQTT connection and publishes raw packets."""
+
+    _backoff_max = 60
+    _log_prefix = "Community MQTT"
+    _not_configured_timeout: float | None = 30
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._key_unavailable_warned: bool = False
+        self._cached_device_info: dict[str, str] | None = None
+        self._cached_stats: dict[str, Any] | None = None
+        self._stats_supported: bool | None = None
+        self._last_stats_fetch: float = 0.0
+        self._last_status_publish: float = 0.0
+
+    async def start(self, settings: object) -> None:
+        self._key_unavailable_warned = False
+        self._cached_device_info = None
+        self._cached_stats = None
+        self._stats_supported = None
+        self._last_stats_fetch = 0.0
+        self._last_status_publish = 0.0
+        await super().start(settings)
+
+    def _on_not_configured(self) -> None:
+        from app.keystore import has_private_key
+        from app.websocket import broadcast_error
+
+        s: CommunityMqttSettings | None = self._settings
+        if s and not has_private_key() and not self._key_unavailable_warned:
+            broadcast_error(
+                "Community MQTT unavailable",
+                "Radio firmware does not support private key export.",
+            )
+            self._key_unavailable_warned = True
+
+    def _is_configured(self) -> bool:
+        """Check if community MQTT is enabled and keys are available."""
+        from app.keystore import has_private_key
+
+        s: CommunityMqttSettings | None = self._settings
+        return bool(s and s.community_mqtt_enabled and has_private_key())
+
+    def _build_client_kwargs(self, settings: object) -> dict[str, Any]:
+        s: CommunityMqttSettings = settings  # type: ignore[assignment]
+        from app.keystore import get_private_key, get_public_key
+        from app.radio import radio_manager
+
+        private_key = get_private_key()
+        public_key = get_public_key()
+        assert private_key is not None and public_key is not None  # guaranteed by _pre_connect
+
+        pubkey_hex = public_key.hex().upper()
+        broker_host = s.community_mqtt_broker_host or _DEFAULT_BROKER
+        broker_port = s.community_mqtt_broker_port or _DEFAULT_PORT
+        jwt_token = _generate_jwt_token(
+            private_key,
+            public_key,
+            audience=broker_host,
+            email=s.community_mqtt_email or "",
+        )
+
+        tls_context = ssl.create_default_context()
+
+        device_name = ""
+        if radio_manager.meshcore and radio_manager.meshcore.self_info:
+            device_name = radio_manager.meshcore.self_info.get("name", "")
+
+        status_topic = _build_status_topic(s, pubkey_hex)
+        offline_payload = json.dumps(
+            {
+                "status": "offline",
+                "timestamp": datetime.now().isoformat(),
+                "origin": device_name or "MeshCore Device",
+                "origin_id": pubkey_hex,
+            }
+        )
+
+        return {
+            "hostname": broker_host,
+            "port": broker_port,
+            "transport": "websockets",
+            "tls_context": tls_context,
+            "websocket_path": "/",
+            "username": f"v1_{pubkey_hex}",
+            "password": jwt_token,
+            "will": aiomqtt.Will(status_topic, offline_payload, retain=True),
+        }
+
+    def _on_connected(self, settings: object) -> tuple[str, str]:
+        s: CommunityMqttSettings = settings  # type: ignore[assignment]
+        broker_host = s.community_mqtt_broker_host or _DEFAULT_BROKER
+        broker_port = s.community_mqtt_broker_port or _DEFAULT_PORT
+        return ("Community MQTT connected", f"{broker_host}:{broker_port}")
+
+    async def _fetch_device_info(self) -> dict[str, str]:
+        """Fetch firmware model/version from the radio (cached for the connection)."""
+        if self._cached_device_info is not None:
+            return self._cached_device_info
+
+        from app.radio import RadioDisconnectedError, RadioOperationBusyError, radio_manager
+
+        fallback = {"model": "unknown", "firmware_version": "unknown"}
+        try:
+            async with radio_manager.radio_operation(
+                "community_stats_device_info", blocking=False
+            ) as mc:
+                event = await mc.commands.send_device_query()
+                from meshcore.events import EventType
+
+                if event.type == EventType.DEVICE_INFO:
+                    fw_ver = event.payload.get("fw ver", 0)
+                    if fw_ver >= 3:
+                        model = event.payload.get("model", "unknown") or "unknown"
+                        ver = event.payload.get("ver", "unknown") or "unknown"
+                        fw_build = event.payload.get("fw_build", "") or ""
+                        fw_str = f"v{ver} (Build: {fw_build})" if fw_build else f"v{ver}"
+                        self._cached_device_info = {
+                            "model": model,
+                            "firmware_version": fw_str,
+                        }
+                    else:
+                        # Old firmware — cache what we can
+                        self._cached_device_info = {
+                            "model": "unknown",
+                            "firmware_version": f"v{fw_ver}" if fw_ver else "unknown",
+                        }
+                    return self._cached_device_info
+        except (RadioOperationBusyError, RadioDisconnectedError):
+            pass
+        except Exception as e:
+            logger.debug("Community MQTT: device info fetch failed: %s", e)
+
+        # Don't cache transient failures — allow retry on next status publish
+        return fallback
+
+    async def _fetch_stats(self) -> dict[str, Any] | None:
+        """Fetch core + radio stats from the radio (best-effort, cached)."""
+        if self._stats_supported is False:
+            return self._cached_stats
+
+        now = time.monotonic()
+        if (
+            now - self._last_stats_fetch
+        ) < _STATS_MIN_CACHE_SECS and self._cached_stats is not None:
+            return self._cached_stats
+
+        from app.radio import RadioDisconnectedError, RadioOperationBusyError, radio_manager
+
+        try:
+            async with radio_manager.radio_operation("community_stats_fetch", blocking=False) as mc:
+                from meshcore.events import EventType
+
+                result: dict[str, Any] = {}
+
+                core_event = await mc.commands.get_stats_core()
+                if core_event.type == EventType.ERROR:
+                    logger.info("Community MQTT: firmware does not support stats commands")
+                    self._stats_supported = False
+                    return self._cached_stats
+                if core_event.type == EventType.STATS_CORE:
+                    result.update(core_event.payload)
+
+                radio_event = await mc.commands.get_stats_radio()
+                if radio_event.type == EventType.ERROR:
+                    logger.info("Community MQTT: firmware does not support stats commands")
+                    self._stats_supported = False
+                    return self._cached_stats
+                if radio_event.type == EventType.STATS_RADIO:
+                    result.update(radio_event.payload)
+
+                if result:
+                    self._cached_stats = result
+                    self._last_stats_fetch = now
+                    return self._cached_stats
+
+        except (RadioOperationBusyError, RadioDisconnectedError):
+            pass
+        except Exception as e:
+            logger.debug("Community MQTT: stats fetch failed: %s", e)
+
+        return self._cached_stats
+
+    async def _publish_status(
+        self, settings: CommunityMqttSettings, *, refresh_stats: bool = True
+    ) -> None:
+        """Build and publish the enriched retained status message."""
+        from app.keystore import get_public_key
+        from app.radio import radio_manager
+
+        public_key = get_public_key()
+        if public_key is None:
+            return
+
+        pubkey_hex = public_key.hex().upper()
+
+        device_name = ""
+        if radio_manager.meshcore and radio_manager.meshcore.self_info:
+            device_name = radio_manager.meshcore.self_info.get("name", "")
+
+        device_info = await self._fetch_device_info()
+        stats = await self._fetch_stats() if refresh_stats else self._cached_stats
+
+        status_topic = _build_status_topic(settings, pubkey_hex)
+        payload: dict[str, Any] = {
+            "status": "online",
+            "timestamp": datetime.now().isoformat(),
+            "origin": device_name or "MeshCore Device",
+            "origin_id": pubkey_hex,
+            "model": device_info.get("model", "unknown"),
+            "firmware_version": device_info.get("firmware_version", "unknown"),
+            "radio": _build_radio_info(),
+            "client_version": _get_client_version(),
+        }
+        if stats:
+            payload["stats"] = stats
+
+        await self.publish(status_topic, payload, retain=True)
+        self._last_status_publish = time.monotonic()
+
+    async def _on_connected_async(self, settings: object) -> None:
+        """Publish a retained online status message after connecting."""
+        await self._publish_status(settings)  # type: ignore[arg-type]
+
+    async def _on_periodic_wake(self, elapsed: float) -> None:
+        if not self._settings:
+            return
+        now = time.monotonic()
+        if (now - self._last_status_publish) >= _STATS_REFRESH_INTERVAL:
+            await self._publish_status(self._settings, refresh_stats=True)
+
+    def _on_error(self) -> tuple[str, str]:
+        return (
+            "Community MQTT connection failure",
+            "Check your internet connection or try again later.",
+        )
+
+    def _should_break_wait(self, elapsed: float) -> bool:
+        if not self.connected:
+            logger.info("Community MQTT publish failure detected, reconnecting")
+            return True
+        if elapsed >= _TOKEN_RENEWAL_THRESHOLD:
+            logger.info("Community MQTT JWT nearing expiry, reconnecting")
+            return True
+        return False
+
+    async def _pre_connect(self, settings: object) -> bool:
+        from app.keystore import get_private_key, get_public_key
+
+        private_key = get_private_key()
+        public_key = get_public_key()
+        if private_key is None or public_key is None:
+            # Keys not available yet, wait for settings change or key export
+            self.connected = False
+            self._version_event.clear()
+            try:
+                await asyncio.wait_for(self._version_event.wait(), timeout=30)
+            except asyncio.TimeoutError:
+                pass
+            return False
+        return True

app/fanout/manager.py

@@ -0,0 +1,243 @@
+"""FanoutManager: owns all active fanout modules and dispatches events."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from app.fanout.base import FanoutModule
+
+logger = logging.getLogger(__name__)
+_DISPATCH_TIMEOUT_SECONDS = 30.0
+
+# Type string -> module class mapping
+_MODULE_TYPES: dict[str, type] = {}
+
+
+def _register_module_types() -> None:
+    """Lazily populate the type registry to avoid circular imports."""
+    if _MODULE_TYPES:
+        return
+    from app.fanout.apprise_mod import AppriseModule
+    from app.fanout.bot import BotModule
+    from app.fanout.mqtt_community import MqttCommunityModule
+    from app.fanout.mqtt_private import MqttPrivateModule
+    from app.fanout.webhook import WebhookModule
+
+    _MODULE_TYPES["mqtt_private"] = MqttPrivateModule
+    _MODULE_TYPES["mqtt_community"] = MqttCommunityModule
+    _MODULE_TYPES["bot"] = BotModule
+    _MODULE_TYPES["webhook"] = WebhookModule
+    _MODULE_TYPES["apprise"] = AppriseModule
+
+
+def _matches_filter(filter_value: Any, key: str) -> bool:
+    """Check a single filter value (channels or contacts) against a key.
+
+    Supported shapes:
+      "all"                        -> True
+      "none"                       -> False
+      ["key1", "key2"]             -> key in list  (only listed)
+      {"except": ["key1", "key2"]} -> key not in list  (all except listed)
+    """
+    if filter_value == "all":
+        return True
+    if filter_value == "none":
+        return False
+    if isinstance(filter_value, list):
+        return key in filter_value
+    if isinstance(filter_value, dict) and "except" in filter_value:
+        return key not in filter_value["except"]
+    return False
+
+
+def _scope_matches_message(scope: dict, data: dict) -> bool:
+    """Check whether a message event matches the given scope."""
+    messages = scope.get("messages", "none")
+    if messages == "all":
+        return True
+    if messages == "none":
+        return False
+    if isinstance(messages, dict):
+        msg_type = data.get("type", "")
+        conversation_key = data.get("conversation_key", "")
+        if msg_type == "CHAN":
+            return _matches_filter(messages.get("channels", "none"), conversation_key)
+        elif msg_type == "PRIV":
+            return _matches_filter(messages.get("contacts", "none"), conversation_key)
+    return False
+
+
+def _scope_matches_raw(scope: dict, _data: dict) -> bool:
+    """Check whether a raw packet event matches the given scope."""
+    return scope.get("raw_packets", "none") == "all"
+
+
+class FanoutManager:
+    """Owns all active fanout modules and dispatches events."""
+
+    def __init__(self) -> None:
+        self._modules: dict[str, tuple[FanoutModule, dict]] = {}  # id -> (module, scope)
+        self._restart_locks: dict[str, asyncio.Lock] = {}
+
+    async def load_from_db(self) -> None:
+        """Read enabled fanout_configs and instantiate modules."""
+        _register_module_types()
+        from app.repository.fanout import FanoutConfigRepository
+
+        configs = await FanoutConfigRepository.get_enabled()
+        for cfg in configs:
+            await self._start_module(cfg)
+
+    async def _start_module(self, cfg: dict[str, Any]) -> None:
+        """Instantiate and start a single module from a config dict."""
+        config_id = cfg["id"]
+        config_type = cfg["type"]
+        config_blob = cfg["config"]
+        scope = cfg["scope"]
+
+        # Skip bot modules when bots are disabled server-wide
+        if config_type == "bot":
+            from app.config import settings as server_settings
+
+            if server_settings.disable_bots:
+                logger.info("Skipping bot module %s (bots disabled by server config)", config_id)
+                return
+
+        cls = _MODULE_TYPES.get(config_type)
+        if cls is None:
+            logger.warning("Unknown fanout type %r for config %s, skipping", config_type, config_id)
+            return
+
+        try:
+            module = cls(config_id, config_blob, name=cfg.get("name", ""))
+            await module.start()
+            self._modules[config_id] = (module, scope)
+            logger.info(
+                "Started fanout module %s (type=%s)", cfg.get("name", config_id), config_type
+            )
+        except Exception:
+            logger.exception("Failed to start fanout module %s", config_id)
+
+    async def reload_config(self, config_id: str) -> None:
+        """Stop old module (if any) and start updated config."""
+        lock = self._restart_locks.setdefault(config_id, asyncio.Lock())
+        async with lock:
+            await self.remove_config(config_id)
+
+            from app.repository.fanout import FanoutConfigRepository
+
+            cfg = await FanoutConfigRepository.get(config_id)
+            if cfg is None or not cfg["enabled"]:
+                return
+            await self._start_module(cfg)
+
+    async def remove_config(self, config_id: str) -> None:
+        """Stop and remove a module."""
+        entry = self._modules.pop(config_id, None)
+        if entry is not None:
+            module, _ = entry
+            try:
+                await module.stop()
+            except Exception:
+                logger.exception("Error stopping fanout module %s", config_id)
+
+    async def _dispatch_matching(
+        self,
+        data: dict,
+        *,
+        matcher: Any,
+        handler_name: str,
+        log_label: str,
+    ) -> None:
+        """Dispatch to all matching modules concurrently."""
+        tasks = []
+        for config_id, (module, scope) in list(self._modules.items()):
+            if matcher(scope, data):
+                tasks.append(self._run_handler(config_id, module, handler_name, data, log_label))
+        if tasks:
+            await asyncio.gather(*tasks)
+
+    async def _run_handler(
+        self,
+        config_id: str,
+        module: FanoutModule,
+        handler_name: str,
+        data: dict,
+        log_label: str,
+    ) -> None:
+        """Run one module handler with per-module exception isolation."""
+        try:
+            handler = getattr(module, handler_name)
+            await asyncio.wait_for(handler(data), timeout=_DISPATCH_TIMEOUT_SECONDS)
+        except asyncio.TimeoutError:
+            logger.error(
+                "Fanout %s %s timed out after %.1fs; restarting module",
+                config_id,
+                log_label,
+                _DISPATCH_TIMEOUT_SECONDS,
+            )
+            await self._restart_module(config_id, module)
+        except Exception:
+            logger.exception("Fanout %s %s error", config_id, log_label)
+
+    async def _restart_module(self, config_id: str, module: FanoutModule) -> None:
+        """Restart a timed-out module if it is still the active instance."""
+        lock = self._restart_locks.setdefault(config_id, asyncio.Lock())
+        async with lock:
+            entry = self._modules.get(config_id)
+            if entry is None or entry[0] is not module:
+                return
+            try:
+                await module.stop()
+                await module.start()
+            except Exception:
+                logger.exception("Failed to restart timed-out fanout module %s", config_id)
+                self._modules.pop(config_id, None)
+
+    async def broadcast_message(self, data: dict) -> None:
+        """Dispatch a decoded message to modules whose scope matches."""
+        await self._dispatch_matching(
+            data,
+            matcher=_scope_matches_message,
+            handler_name="on_message",
+            log_label="on_message",
+        )
+
+    async def broadcast_raw(self, data: dict) -> None:
+        """Dispatch a raw packet to modules whose scope matches."""
+        await self._dispatch_matching(
+            data,
+            matcher=_scope_matches_raw,
+            handler_name="on_raw",
+            log_label="on_raw",
+        )
+
+    async def stop_all(self) -> None:
+        """Shutdown all modules."""
+        for config_id, (module, _) in list(self._modules.items()):
+            try:
+                await module.stop()
+            except Exception:
+                logger.exception("Error stopping fanout module %s", config_id)
+        self._modules.clear()
+        self._restart_locks.clear()
+
+    def get_statuses(self) -> dict[str, dict[str, str]]:
+        """Return status info for each active module."""
+        from app.repository.fanout import _configs_cache
+
+        result: dict[str, dict[str, str]] = {}
+        for config_id, (module, _) in self._modules.items():
+            info = _configs_cache.get(config_id, {})
+            result[config_id] = {
+                "name": info.get("name", config_id),
+                "type": info.get("type", "unknown"),
+                "status": module.status,
+            }
+        return result
+
+
+# Module-level singleton
+fanout_manager = FanoutManager()

app/fanout/mqtt.py

@@ -0,0 +1,91 @@
+"""MQTT publisher for forwarding mesh network events to an MQTT broker."""
+
+from __future__ import annotations
+
+import logging
+import ssl
+from typing import Any, Protocol
+
+from app.fanout.mqtt_base import BaseMqttPublisher
+
+logger = logging.getLogger(__name__)
+
+
+class PrivateMqttSettings(Protocol):
+    """Attributes expected on the settings object for the private MQTT publisher."""
+
+    mqtt_broker_host: str
+    mqtt_broker_port: int
+    mqtt_username: str
+    mqtt_password: str
+    mqtt_use_tls: bool
+    mqtt_tls_insecure: bool
+    mqtt_publish_messages: bool
+    mqtt_publish_raw_packets: bool
+
+
+class MqttPublisher(BaseMqttPublisher):
+    """Manages an MQTT connection and publishes mesh network events."""
+
+    _backoff_max = 30
+    _log_prefix = "MQTT"
+
+    def _is_configured(self) -> bool:
+        """Check if MQTT is configured and has something to publish."""
+        s: PrivateMqttSettings | None = self._settings
+        return bool(
+            s and s.mqtt_broker_host and (s.mqtt_publish_messages or s.mqtt_publish_raw_packets)
+        )
+
+    def _build_client_kwargs(self, settings: object) -> dict[str, Any]:
+        s: PrivateMqttSettings = settings  # type: ignore[assignment]
+        return {
+            "hostname": s.mqtt_broker_host,
+            "port": s.mqtt_broker_port,
+            "username": s.mqtt_username or None,
+            "password": s.mqtt_password or None,
+            "tls_context": self._build_tls_context(s),
+        }
+
+    def _on_connected(self, settings: object) -> tuple[str, str]:
+        s: PrivateMqttSettings = settings  # type: ignore[assignment]
+        return ("MQTT connected", f"{s.mqtt_broker_host}:{s.mqtt_broker_port}")
+
+    def _on_error(self) -> tuple[str, str]:
+        return ("MQTT connection failure", "Please correct the settings or disable.")
+
+    @staticmethod
+    def _build_tls_context(settings: PrivateMqttSettings) -> ssl.SSLContext | None:
+        """Build TLS context from settings, or None if TLS is disabled."""
+        if not settings.mqtt_use_tls:
+            return None
+        ctx = ssl.create_default_context()
+        if settings.mqtt_tls_insecure:
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+
+
+def _build_message_topic(prefix: str, data: dict[str, Any]) -> str:
+    """Build MQTT topic for a decrypted message."""
+    msg_type = data.get("type", "")
+    conversation_key = data.get("conversation_key", "unknown")
+
+    if msg_type == "PRIV":
+        return f"{prefix}/dm:{conversation_key}"
+    elif msg_type == "CHAN":
+        return f"{prefix}/gm:{conversation_key}"
+    return f"{prefix}/message:{conversation_key}"
+
+
+def _build_raw_packet_topic(prefix: str, data: dict[str, Any]) -> str:
+    """Build MQTT topic for a raw packet."""
+    info = data.get("decrypted_info")
+    if info and isinstance(info, dict):
+        contact_key = info.get("contact_key")
+        channel_key = info.get("channel_key")
+        if contact_key:
+            return f"{prefix}/raw/dm:{contact_key}"
+        if channel_key:
+            return f"{prefix}/raw/gm:{channel_key}"
+    return f"{prefix}/raw/unrouted"

app/fanout/mqtt_base.py

@@ -0,0 +1,232 @@
+"""Shared base class for MQTT publisher lifecycle management.
+
+Both ``MqttPublisher`` (private broker) and ``CommunityMqttPublisher``
+(community aggregator) inherit from ``BaseMqttPublisher``, which owns
+the connection-loop skeleton, reconnect/backoff logic, and publish method.
+Subclasses override a small set of hooks to control configuration checks,
+client construction, toast messages, and optional wait-loop behavior.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from abc import ABC, abstractmethod
+from typing import Any
+
+import aiomqtt
+
+logger = logging.getLogger(__name__)
+
+_BACKOFF_MIN = 5
+
+
+def _broadcast_health() -> None:
+    """Push updated health (including MQTT status) to all WS clients."""
+    from app.radio import radio_manager
+    from app.websocket import broadcast_health
+
+    broadcast_health(radio_manager.is_connected, radio_manager.connection_info)
+
+
+class BaseMqttPublisher(ABC):
+    """Base class for MQTT publishers with shared lifecycle management.
+
+    Subclasses implement the abstract hooks to control configuration checks,
+    client construction, toast messages, and optional wait-loop behavior.
+
+    The settings type is duck-typed — each subclass defines a Protocol
+    describing the attributes it expects (e.g. ``PrivateMqttSettings``,
+    ``CommunityMqttSettings``). Callers pass ``SimpleNamespace`` instances
+    that satisfy the protocol.
+    """
+
+    _backoff_max: int = 30
+    _log_prefix: str = "MQTT"
+    _not_configured_timeout: float | None = None  # None = block forever
+
+    def __init__(self) -> None:
+        self._client: aiomqtt.Client | None = None
+        self._task: asyncio.Task[None] | None = None
+        self._settings: Any = None
+        self._settings_version: int = 0
+        self._version_event: asyncio.Event = asyncio.Event()
+        self.connected: bool = False
+
+    # ── Lifecycle ──────────────────────────────────────────────────────
+
+    async def start(self, settings: object) -> None:
+        """Start the background connection loop."""
+        self._settings = settings
+        self._settings_version += 1
+        self._version_event.set()
+        if self._task is None or self._task.done():
+            self._task = asyncio.create_task(self._connection_loop())
+
+    async def stop(self) -> None:
+        """Cancel the background task and disconnect."""
+        if self._task and not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        self._task = None
+        self._client = None
+        self.connected = False
+
+    async def restart(self, settings: object) -> None:
+        """Called when settings change — stop + start."""
+        await self.stop()
+        await self.start(settings)
+
+    async def publish(self, topic: str, payload: dict[str, Any], *, retain: bool = False) -> None:
+        """Publish a JSON payload. Drops silently if not connected."""
+        if self._client is None or not self.connected:
+            return
+        try:
+            await self._client.publish(topic, json.dumps(payload), retain=retain)
+        except Exception as e:
+            logger.warning("%s publish failed on %s: %s", self._log_prefix, topic, e)
+            self.connected = False
+            # Wake the connection loop so it exits the wait and reconnects
+            self._settings_version += 1
+            self._version_event.set()
+
+    # ── Abstract hooks ─────────────────────────────────────────────────
+
+    @abstractmethod
+    def _is_configured(self) -> bool:
+        """Return True when this publisher should attempt to connect."""
+
+    @abstractmethod
+    def _build_client_kwargs(self, settings: object) -> dict[str, Any]:
+        """Return the keyword arguments for ``aiomqtt.Client(...)``."""
+
+    @abstractmethod
+    def _on_connected(self, settings: object) -> tuple[str, str]:
+        """Return ``(title, detail)`` for the success toast on connect."""
+
+    @abstractmethod
+    def _on_error(self) -> tuple[str, str]:
+        """Return ``(title, detail)`` for the error toast on connect failure."""
+
+    # ── Optional hooks ─────────────────────────────────────────────────
+
+    def _should_break_wait(self, elapsed: float) -> bool:
+        """Return True to break the inner wait (e.g. token expiry)."""
+        return False
+
+    async def _pre_connect(self, settings: object) -> bool:
+        """Called before connecting. Return True to proceed, False to retry."""
+        return True
+
+    def _on_not_configured(self) -> None:
+        """Called each time the loop finds the publisher not configured."""
+        return  # no-op by default; subclasses may override
+
+    async def _on_connected_async(self, settings: object) -> None:
+        """Async hook called after connection succeeds (before health broadcast).
+
+        Subclasses can override to publish messages immediately after connecting.
+        """
+        return  # no-op by default
+
+    async def _on_periodic_wake(self, elapsed: float) -> None:
+        """Called every ~60s while connected. Subclasses may override."""
+        return
+
+    # ── Connection loop ────────────────────────────────────────────────
+
+    async def _connection_loop(self) -> None:
+        """Background loop: connect, wait for version change, reconnect on failure."""
+        from app.websocket import broadcast_error, broadcast_success
+
+        backoff = _BACKOFF_MIN
+
+        while True:
+            if not self._is_configured():
+                self._on_not_configured()
+                self.connected = False
+                self._client = None
+                self._version_event.clear()
+                try:
+                    if self._not_configured_timeout is None:
+                        await self._version_event.wait()
+                    else:
+                        await asyncio.wait_for(
+                            self._version_event.wait(),
+                            timeout=self._not_configured_timeout,
+                        )
+                except asyncio.TimeoutError:
+                    continue
+                except asyncio.CancelledError:
+                    return
+                continue
+
+            settings = self._settings
+            assert settings is not None  # guaranteed by _is_configured()
+            version_at_connect = self._settings_version
+
+            try:
+                if not await self._pre_connect(settings):
+                    continue
+
+                client_kwargs = self._build_client_kwargs(settings)
+                connect_time = time.monotonic()
+
+                async with aiomqtt.Client(**client_kwargs) as client:
+                    self._client = client
+                    self.connected = True
+                    backoff = _BACKOFF_MIN
+
+                    title, detail = self._on_connected(settings)
+                    broadcast_success(title, detail)
+                    await self._on_connected_async(settings)
+                    _broadcast_health()
+
+                    # Wait until cancelled or settings version changes.
+                    # The 60s timeout is a housekeeping wake-up; actual connection
+                    # liveness is handled by paho-mqtt's keepalive mechanism.
+                    while self._settings_version == version_at_connect:
+                        self._version_event.clear()
+                        try:
+                            await asyncio.wait_for(self._version_event.wait(), timeout=60)
+                        except asyncio.TimeoutError:
+                            elapsed = time.monotonic() - connect_time
+                            await self._on_periodic_wake(elapsed)
+                            if self._should_break_wait(elapsed):
+                                break
+                            continue
+
+                # async with exited — client is now closed
+                self._client = None
+                self.connected = False
+                _broadcast_health()
+
+            except asyncio.CancelledError:
+                self.connected = False
+                self._client = None
+                return
+
+            except Exception as e:
+                self.connected = False
+                self._client = None
+
+                title, detail = self._on_error()
+                broadcast_error(title, detail)
+                _broadcast_health()
+                logger.warning(
+                    "%s connection error: %s (reconnecting in %ds)",
+                    self._log_prefix,
+                    e,
+                    backoff,
+                )
+
+                try:
+                    await asyncio.sleep(backoff)
+                except asyncio.CancelledError:
+                    return
+                backoff = min(backoff * 2, self._backoff_max)

app/fanout/mqtt_community.py

@@ -0,0 +1,89 @@
+"""Fanout module wrapping the community MQTT publisher."""
+
+from __future__ import annotations
+
+import logging
+import re
+from types import SimpleNamespace
+from typing import Any
+
+from app.fanout.base import FanoutModule
+from app.fanout.community_mqtt import CommunityMqttPublisher, _format_raw_packet
+
+logger = logging.getLogger(__name__)
+
+_IATA_RE = re.compile(r"^[A-Z]{3}$")
+
+
+def _config_to_settings(config: dict) -> SimpleNamespace:
+    """Map a fanout config blob to a settings namespace for the CommunityMqttPublisher."""
+    return SimpleNamespace(
+        community_mqtt_enabled=True,
+        community_mqtt_broker_host=config.get("broker_host", "mqtt-us-v1.letsmesh.net"),
+        community_mqtt_broker_port=config.get("broker_port", 443),
+        community_mqtt_iata=config.get("iata", ""),
+        community_mqtt_email=config.get("email", ""),
+    )
+
+
+class MqttCommunityModule(FanoutModule):
+    """Wraps a CommunityMqttPublisher for community packet sharing."""
+
+    def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
+        super().__init__(config_id, config, name=name)
+        self._publisher = CommunityMqttPublisher()
+
+    async def start(self) -> None:
+        settings = _config_to_settings(self.config)
+        await self._publisher.start(settings)
+
+    async def stop(self) -> None:
+        await self._publisher.stop()
+
+    async def on_message(self, data: dict) -> None:
+        # Community MQTT only publishes raw packets, not decoded messages.
+        pass
+
+    async def on_raw(self, data: dict) -> None:
+        if not self._publisher.connected or self._publisher._settings is None:
+            return
+        await _publish_community_packet(self._publisher, self.config, data)
+
+    @property
+    def status(self) -> str:
+        if self._publisher._is_configured():
+            return "connected" if self._publisher.connected else "disconnected"
+        return "disconnected"
+
+
+async def _publish_community_packet(
+    publisher: CommunityMqttPublisher,
+    config: dict,
+    data: dict[str, Any],
+) -> None:
+    """Format and publish a raw packet to the community broker."""
+    try:
+        from app.keystore import get_public_key
+        from app.radio import radio_manager
+
+        public_key = get_public_key()
+        if public_key is None:
+            return
+
+        pubkey_hex = public_key.hex().upper()
+
+        device_name = ""
+        if radio_manager.meshcore and radio_manager.meshcore.self_info:
+            device_name = radio_manager.meshcore.self_info.get("name", "")
+
+        packet = _format_raw_packet(data, device_name, pubkey_hex)
+        iata = config.get("iata", "").upper().strip()
+        if not _IATA_RE.fullmatch(iata):
+            logger.debug("Community MQTT: skipping publish — no valid IATA code configured")
+            return
+        topic = f"meshcore/{iata}/{pubkey_hex}/packets"
+
+        await publisher.publish(topic, packet)
+
+    except Exception as e:
+        logger.warning("Community MQTT broadcast error: %s", e)

app/fanout/mqtt_private.py

@@ -0,0 +1,61 @@
+"""Fanout module wrapping the private MQTT publisher."""
+
+from __future__ import annotations
+
+import logging
+from types import SimpleNamespace
+
+from app.fanout.base import FanoutModule
+from app.fanout.mqtt import MqttPublisher, _build_message_topic, _build_raw_packet_topic
+
+logger = logging.getLogger(__name__)
+
+
+def _config_to_settings(config: dict) -> SimpleNamespace:
+    """Map a fanout config blob to a settings namespace for the MqttPublisher."""
+    return SimpleNamespace(
+        mqtt_broker_host=config.get("broker_host", ""),
+        mqtt_broker_port=config.get("broker_port", 1883),
+        mqtt_username=config.get("username", ""),
+        mqtt_password=config.get("password", ""),
+        mqtt_use_tls=config.get("use_tls", False),
+        mqtt_tls_insecure=config.get("tls_insecure", False),
+        mqtt_topic_prefix=config.get("topic_prefix", "meshcore"),
+        mqtt_publish_messages=True,
+        mqtt_publish_raw_packets=True,
+    )
+
+
+class MqttPrivateModule(FanoutModule):
+    """Wraps an MqttPublisher instance for private MQTT forwarding."""
+
+    def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
+        super().__init__(config_id, config, name=name)
+        self._publisher = MqttPublisher()
+
+    async def start(self) -> None:
+        settings = _config_to_settings(self.config)
+        await self._publisher.start(settings)
+
+    async def stop(self) -> None:
+        await self._publisher.stop()
+
+    async def on_message(self, data: dict) -> None:
+        if not self._publisher.connected or self._publisher._settings is None:
+            return
+        prefix = self.config.get("topic_prefix", "meshcore")
+        topic = _build_message_topic(prefix, data)
+        await self._publisher.publish(topic, data)
+
+    async def on_raw(self, data: dict) -> None:
+        if not self._publisher.connected or self._publisher._settings is None:
+            return
+        prefix = self.config.get("topic_prefix", "meshcore")
+        topic = _build_raw_packet_topic(prefix, data)
+        await self._publisher.publish(topic, data)
+
+    @property
+    def status(self) -> str:
+        if not self.config.get("broker_host"):
+            return "disconnected"
+        return "connected" if self._publisher.connected else "disconnected"

app/fanout/webhook.py

@@ -0,0 +1,84 @@
+"""Fanout module for webhook (HTTP POST) delivery."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import logging
+
+import httpx
+
+from app.fanout.base import FanoutModule
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookModule(FanoutModule):
+    """Delivers message data to an HTTP endpoint via POST (or configurable method)."""
+
+    def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
+        super().__init__(config_id, config, name=name)
+        self._client: httpx.AsyncClient | None = None
+        self._last_error: str | None = None
+
+    async def start(self) -> None:
+        self._client = httpx.AsyncClient(timeout=httpx.Timeout(10.0))
+        self._last_error = None
+
+    async def stop(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def on_message(self, data: dict) -> None:
+        await self._send(data, event_type="message")
+
+    async def _send(self, data: dict, *, event_type: str) -> None:
+        if not self._client:
+            return
+
+        url = self.config.get("url", "")
+        if not url:
+            return
+
+        method = self.config.get("method", "POST").upper()
+        extra_headers = self.config.get("headers", {})
+        hmac_secret = self.config.get("hmac_secret", "")
+        hmac_header = self.config.get("hmac_header", "X-Webhook-Signature")
+
+        headers = {
+            "Content-Type": "application/json",
+            "X-Webhook-Event": event_type,
+            **extra_headers,
+        }
+
+        body_bytes = json.dumps(data, separators=(",", ":"), sort_keys=True).encode()
+
+        if hmac_secret:
+            sig = hmac.new(hmac_secret.encode(), body_bytes, hashlib.sha256).hexdigest()
+            headers[hmac_header or "X-Webhook-Signature"] = f"sha256={sig}"
+
+        try:
+            resp = await self._client.request(method, url, content=body_bytes, headers=headers)
+            resp.raise_for_status()
+            self._last_error = None
+        except httpx.HTTPStatusError as exc:
+            self._last_error = f"HTTP {exc.response.status_code}"
+            logger.warning(
+                "Webhook %s returned %s for %s",
+                self.config_id,
+                exc.response.status_code,
+                url,
+            )
+        except httpx.RequestError as exc:
+            self._last_error = str(exc)
+            logger.warning("Webhook %s request error: %s", self.config_id, exc)
+
+    @property
+    def status(self) -> str:
+        if not self.config.get("url"):
+            return "disconnected"
+        if self._last_error:
+            return "error"
+        return "connected"

app/frontend_static.py

@@ -1,13 +1,27 @@
 import logging
 from pathlib import Path
 
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 
 logger = logging.getLogger(__name__)
 
 
+def _resolve_request_origin(request: Request) -> str:
+    """Resolve the external origin, honoring common reverse-proxy headers."""
+    forwarded_proto = request.headers.get("x-forwarded-proto")
+    forwarded_host = request.headers.get("x-forwarded-host")
+
+    if forwarded_proto and forwarded_host:
+        proto = forwarded_proto.split(",")[0].strip()
+        host = forwarded_host.split(",")[0].strip()
+        if proto and host:
+            return f"{proto}://{host}"
+
+    return str(request.base_url).rstrip("/")
+
+
 def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
     """Register frontend static file routes if a built frontend is available.
 
@@ -55,6 +69,41 @@ def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
         """Serve the frontend index.html."""
         return FileResponse(index_file)
 
+    @app.get("/site.webmanifest")
+    async def serve_webmanifest(request: Request):
+        """Serve a dynamic web manifest using the active request origin."""
+        origin = _resolve_request_origin(request)
+        manifest = {
+            "name": "RemoteTerm for MeshCore",
+            "short_name": "RemoteTerm",
+            "id": f"{origin}/",
+            "start_url": f"{origin}/",
+            "scope": f"{origin}/",
+            "display": "standalone",
+            "display_override": ["window-controls-overlay", "standalone", "fullscreen"],
+            "theme_color": "#111419",
+            "background_color": "#111419",
+            "icons": [
+                {
+                    "src": f"{origin}/web-app-manifest-192x192.png",
+                    "sizes": "192x192",
+                    "type": "image/png",
+                    "purpose": "maskable",
+                },
+                {
+                    "src": f"{origin}/web-app-manifest-512x512.png",
+                    "sizes": "512x512",
+                    "type": "image/png",
+                    "purpose": "maskable",
+                },
+            ],
+        }
+        return JSONResponse(
+            manifest,
+            media_type="application/manifest+json",
+            headers={"Cache-Control": "no-store"},
+        )
+
     @app.get("/{path:path}")
     async def serve_frontend(path: str):
         """Serve frontend files, falling back to index.html for SPA routing."""
@@ -71,3 +120,16 @@ def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
 
     logger.info("Serving frontend from %s", frontend_dir)
     return True
+
+
+def register_frontend_missing_fallback(app: FastAPI) -> None:
+    """Register a fallback route that tells the user to build the frontend."""
+
+    @app.get("/", include_in_schema=False)
+    async def frontend_not_built():
+        return JSONResponse(
+            status_code=404,
+            content={
+                "detail": "Frontend not built. Run: cd frontend && npm install && npm run build"
+            },
+        )

app/keystore.py

@@ -18,6 +18,13 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+NO_EVENT_RECEIVED_GUIDANCE = (
+    "Radio command channel is unresponsive (no_event_received). Ensure that your firmware is not "
+    "incompatible, outdated, or wrong-mode (e.g. repeater, not client), and that"
+    "serial/TCP/BLE connectivity is successful (try another app and see if that one works?). The app cannot proceed because it cannot "
+    "issue commands to the radio."
+)
+
 # In-memory storage for the private key and derived public key
 _private_key: bytes | None = None
 _public_key: bytes | None = None
@@ -91,8 +98,14 @@ async def export_and_store_private_key(mc: "MeshCore") -> bool:
             )
             return False
         else:
+            reason = result.payload.get("reason") if isinstance(result.payload, dict) else None
+            if result.type == EventType.ERROR and reason == "no_event_received":
+                logger.error("%s Raw response: %s", NO_EVENT_RECEIVED_GUIDANCE, result.payload)
+                raise RuntimeError(NO_EVENT_RECEIVED_GUIDANCE)
             logger.error("Failed to export private key: %s", result.payload)
             return False
+    except RuntimeError:
+        raise
     except Exception as e:
         logger.error("Error exporting private key: %s", e)
         return False

app/main.py

@@ -2,13 +2,14 @@ import logging
 from contextlib import asynccontextmanager
 from pathlib import Path
 
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 
 from app.config import setup_logging
 from app.database import db
-from app.frontend_static import register_frontend_static_routes
-from app.radio import radio_manager
+from app.frontend_static import register_frontend_missing_fallback, register_frontend_static_routes
+from app.radio import RadioDisconnectedError, radio_manager
 from app.radio_sync import (
     stop_message_polling,
     stop_periodic_advert,
@@ -17,12 +18,15 @@ from app.radio_sync import (
 from app.routers import (
     channels,
     contacts,
+    fanout,
     health,
     messages,
     packets,
     radio,
     read_state,
+    repeaters,
     settings,
+    statistics,
     ws,
 )
 
@@ -36,6 +40,13 @@ async def lifespan(app: FastAPI):
     await db.connect()
     logger.info("Database connected")
 
+    # Ensure default channels exist in the database even before the radio
+    # connects. Without this, a fresh or disconnected instance would return
+    # zero channels from GET /channels until the first successful radio sync.
+    from app.radio_sync import ensure_default_channels
+
+    await ensure_default_channels()
+
     try:
         await radio_manager.connect()
         logger.info("Connected to radio")
@@ -46,9 +57,18 @@ async def lifespan(app: FastAPI):
     # Always start connection monitor (even if initial connection failed)
     await radio_manager.start_connection_monitor()
 
+    # Start fanout modules (MQTT, etc.) from database configs
+    from app.fanout.manager import fanout_manager
+
+    try:
+        await fanout_manager.load_from_db()
+    except Exception as e:
+        logger.warning("Failed to start fanout modules: %s", e)
+
     yield
 
     logger.info("Shutting down")
+    await fanout_manager.stop_all()
     await radio_manager.stop_connection_monitor()
     await stop_message_polling()
     await stop_periodic_advert()
@@ -59,10 +79,22 @@ async def lifespan(app: FastAPI):
     await db.disconnect()
 
 
+def _get_version() -> str:
+    """Read version from pyproject.toml so it stays in sync automatically."""
+    try:
+        pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
+        for line in pyproject.read_text().splitlines():
+            if line.startswith("version = "):
+                return line.split('"')[1]
+    except Exception:
+        pass
+    return "0.0.0"
+
+
 app = FastAPI(
     title="RemoteTerm for MeshCore API",
     description="API for interacting with MeshCore mesh radio networks",
-    version="1.9.2",
+    version=_get_version(),
     lifespan=lifespan,
 )
 
@@ -74,17 +106,28 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+
+@app.exception_handler(RadioDisconnectedError)
+async def radio_disconnected_handler(request: Request, exc: RadioDisconnectedError):
+    """Return 503 when a radio disconnect race occurs during an operation."""
+    return JSONResponse(status_code=503, content={"detail": "Radio not connected"})
+
+
 # API routes - all prefixed with /api for production compatibility
 app.include_router(health.router, prefix="/api")
+app.include_router(fanout.router, prefix="/api")
 app.include_router(radio.router, prefix="/api")
 app.include_router(contacts.router, prefix="/api")
+app.include_router(repeaters.router, prefix="/api")
 app.include_router(channels.router, prefix="/api")
 app.include_router(messages.router, prefix="/api")
 app.include_router(packets.router, prefix="/api")
 app.include_router(read_state.router, prefix="/api")
 app.include_router(settings.router, prefix="/api")
+app.include_router(statistics.router, prefix="/api")
 app.include_router(ws.router, prefix="/api")
 
 # Serve frontend static files in production
 FRONTEND_DIR = Path(__file__).parent.parent / "frontend" / "dist"
-register_frontend_static_routes(app, FRONTEND_DIR)
+if not register_frontend_static_routes(app, FRONTEND_DIR):
+    register_frontend_missing_fallback(app)

app/models.py

@@ -6,10 +6,11 @@ from pydantic import BaseModel, Field
 class Contact(BaseModel):
     public_key: str = Field(description="Public key (64-char hex)")
     name: str | None = None
-    type: int = 0  # 0=unknown, 1=client, 2=repeater, 3=room
+    type: int = 0  # 0=unknown, 1=client, 2=repeater, 3=room, 4=sensor
     flags: int = 0
     last_path: str | None = None
     last_path_len: int = -1
+    out_path_hash_mode: int | None = None
     last_advert: int | None = None
     lat: float | None = None
     lon: float | None = None
@@ -17,6 +18,27 @@ class Contact(BaseModel):
     on_radio: bool = False
     last_contacted: int | None = None  # Last time we sent/received a message
     last_read_at: int | None = None  # Server-side read state tracking
+    first_seen: int | None = None
+
+    @staticmethod
+    def _derive_out_path_hash_mode(path_hex: str | None, path_len: int) -> int:
+        """Infer the contact path hash mode from stored path bytes and hop count."""
+        if path_len < 0:
+            return -1
+        if path_len == 0 or not path_hex:
+            return 0
+
+        if len(path_hex) % 2 != 0:
+            return 0
+
+        path_bytes = len(path_hex) // 2
+        if path_bytes == 0 or path_bytes % path_len != 0:
+            return 0
+
+        bytes_per_hop = path_bytes // path_len
+        if bytes_per_hop < 1:
+            return 0
+        return bytes_per_hop - 1
 
     def to_radio_dict(self) -> dict:
         """Convert to the dict format expected by meshcore radio commands.
@@ -24,6 +46,10 @@ class Contact(BaseModel):
         The radio API uses different field names (adv_name, out_path, etc.)
         than our database schema (name, last_path, etc.).
         """
+        out_path_hash_mode = self.out_path_hash_mode
+        if out_path_hash_mode is None:
+            out_path_hash_mode = self._derive_out_path_hash_mode(self.last_path, self.last_path_len)
+
         return {
             "public_key": self.public_key,
             "adv_name": self.name or "",
@@ -31,6 +57,7 @@ class Contact(BaseModel):
             "flags": self.flags,
             "out_path": self.last_path or "",
             "out_path_len": self.last_path_len,
+            "out_path_hash_mode": out_path_hash_mode,
             "adv_lat": self.lat if self.lat is not None else 0.0,
             "adv_lon": self.lon if self.lon is not None else 0.0,
             "last_advert": self.last_advert if self.last_advert is not None else 0,
@@ -50,6 +77,7 @@ class Contact(BaseModel):
             "flags": radio_data.get("flags", 0),
             "last_path": radio_data.get("out_path"),
             "last_path_len": radio_data.get("out_path_len", -1),
+            "out_path_hash_mode": radio_data.get("out_path_hash_mode"),
             "lat": radio_data.get("adv_lat"),
             "lon": radio_data.get("adv_lon"),
             "last_advert": radio_data.get("last_advert"),
@@ -72,6 +100,70 @@ class CreateContactRequest(BaseModel):
 CONTACT_TYPE_REPEATER = 2
 
 
+class ContactAdvertPath(BaseModel):
+    """A unique advert path observed for a contact."""
+
+    path: str = Field(description="Hex-encoded routing path (empty string for direct)")
+    path_len: int = Field(description="Number of hops in the path")
+    next_hop: str | None = Field(
+        default=None, description="First hop toward us, or null for direct"
+    )
+    first_seen: int = Field(description="Unix timestamp of first observation")
+    last_seen: int = Field(description="Unix timestamp of most recent observation")
+    heard_count: int = Field(description="Number of times this unique path was heard")
+
+
+class ContactAdvertPathSummary(BaseModel):
+    """Recent unique advertisement paths for a single contact."""
+
+    public_key: str = Field(description="Contact public key (64-char hex)")
+    paths: list[ContactAdvertPath] = Field(
+        default_factory=list, description="Most recent unique advert paths"
+    )
+
+
+class ContactNameHistory(BaseModel):
+    """A historical name used by a contact."""
+
+    name: str
+    first_seen: int
+    last_seen: int
+
+
+class ContactActiveRoom(BaseModel):
+    """A channel/room where a contact has been active."""
+
+    channel_key: str
+    channel_name: str
+    message_count: int
+
+
+class NearestRepeater(BaseModel):
+    """A repeater that has relayed a contact's advertisements."""
+
+    public_key: str
+    name: str | None = None
+    path_len: int
+    last_seen: int
+    heard_count: int
+
+
+class ContactDetail(BaseModel):
+    """Comprehensive contact profile data."""
+
+    contact: Contact
+    name_history: list[ContactNameHistory] = Field(default_factory=list)
+    dm_message_count: int = 0
+    channel_message_count: int = 0
+    most_active_rooms: list[ContactActiveRoom] = Field(default_factory=list)
+    advert_paths: list[ContactAdvertPath] = Field(default_factory=list)
+    advert_frequency: float | None = Field(
+        default=None,
+        description="Advert observations per hour (includes multi-path arrivals of same advert)",
+    )
+    nearest_repeaters: list[NearestRepeater] = Field(default_factory=list)
+
+
 class Channel(BaseModel):
     key: str = Field(description="Channel key (32-char hex)")
     name: str
@@ -80,11 +172,40 @@ class Channel(BaseModel):
     last_read_at: int | None = None  # Server-side read state tracking
 
 
+class ChannelMessageCounts(BaseModel):
+    """Time-windowed message counts for a channel."""
+
+    last_1h: int = 0
+    last_24h: int = 0
+    last_48h: int = 0
+    last_7d: int = 0
+    all_time: int = 0
+
+
+class ChannelTopSender(BaseModel):
+    """A top sender in a channel over the last 24 hours."""
+
+    sender_name: str
+    sender_key: str | None = None
+    message_count: int
+
+
+class ChannelDetail(BaseModel):
+    """Comprehensive channel profile data."""
+
+    channel: Channel
+    message_counts: ChannelMessageCounts = Field(default_factory=ChannelMessageCounts)
+    first_message_at: int | None = None
+    unique_sender_count: int = 0
+    top_senders_24h: list[ChannelTopSender] = Field(default_factory=list)
+
+
 class MessagePath(BaseModel):
     """A single path that a message took to reach us."""
 
-    path: str = Field(description="Hex-encoded routing path (2 chars per hop)")
+    path: str = Field(description="Hex-encoded routing path")
     received_at: int = Field(description="Unix timestamp when this path was received")
+    path_len: int | None = Field(default=None, description="Number of hops in the path, when known")
 
 
 class Message(BaseModel):
@@ -99,8 +220,17 @@ class Message(BaseModel):
     )
     txt_type: int = 0
     signature: str | None = None
+    sender_key: str | None = None
     outgoing: bool = False
     acked: int = 0
+    sender_name: str | None = None
+    channel_name: str | None = None
+
+
+class MessagesAroundResponse(BaseModel):
+    messages: list[Message]
+    has_older: bool
+    has_newer: bool
 
 
 class RawPacketDecryptedInfo(BaseModel):
@@ -108,6 +238,8 @@ class RawPacketDecryptedInfo(BaseModel):
 
     channel_name: str | None = None
     sender: str | None = None
+    channel_key: str | None = None
+    contact_key: str | None = None
 
 
 class RawPacketBroadcast(BaseModel):
@@ -118,6 +250,11 @@ class RawPacketBroadcast(BaseModel):
     """
 
     id: int
+    observation_id: int = Field(
+        description=(
+            "Monotonic per-process ID for this RF observation (distinct from the DB packet row ID)"
+        )
+    )
     timestamp: int
     data: str = Field(description="Hex-encoded packet data")
     payload_type: str = Field(description="Packet type name (e.g., GROUP_TEXT, ADVERT)")
@@ -141,12 +278,87 @@ class SendChannelMessageRequest(SendMessageRequest):
     channel_key: str = Field(description="Channel key (32-char hex)")
 
 
-class TelemetryRequest(BaseModel):
+class RepeaterLoginRequest(BaseModel):
+    """Request to log in to a repeater."""
+
     password: str = Field(
-        default="", description="Repeater password (empty string for no password)"
+        default="", description="Repeater password (empty string for guest login)"
     )
 
 
+class RepeaterLoginResponse(BaseModel):
+    """Response from repeater login."""
+
+    status: str = Field(description="Login result status")
+
+
+class RepeaterStatusResponse(BaseModel):
+    """Status telemetry from a repeater (single attempt, no retries)."""
+
+    battery_volts: float = Field(description="Battery voltage in volts")
+    tx_queue_len: int = Field(description="Transmit queue length")
+    noise_floor_dbm: int = Field(description="Noise floor in dBm")
+    last_rssi_dbm: int = Field(description="Last RSSI in dBm")
+    last_snr_db: float = Field(description="Last SNR in dB")
+    packets_received: int = Field(description="Total packets received")
+    packets_sent: int = Field(description="Total packets sent")
+    airtime_seconds: int = Field(description="TX airtime in seconds")
+    rx_airtime_seconds: int = Field(description="RX airtime in seconds")
+    uptime_seconds: int = Field(description="Uptime in seconds")
+    sent_flood: int = Field(description="Flood packets sent")
+    sent_direct: int = Field(description="Direct packets sent")
+    recv_flood: int = Field(description="Flood packets received")
+    recv_direct: int = Field(description="Direct packets received")
+    flood_dups: int = Field(description="Duplicate flood packets")
+    direct_dups: int = Field(description="Duplicate direct packets")
+    full_events: int = Field(description="Full event queue count")
+
+
+class RepeaterRadioSettingsResponse(BaseModel):
+    """Radio settings from a repeater (batch CLI get commands)."""
+
+    firmware_version: str | None = Field(default=None, description="Firmware version string")
+    radio: str | None = Field(default=None, description="Radio settings (freq,bw,sf,cr)")
+    tx_power: str | None = Field(default=None, description="TX power in dBm")
+    airtime_factor: str | None = Field(default=None, description="Airtime factor")
+    repeat_enabled: str | None = Field(default=None, description="Repeat mode enabled")
+    flood_max: str | None = Field(default=None, description="Max flood hops")
+    name: str | None = Field(default=None, description="Repeater name")
+    lat: str | None = Field(default=None, description="Latitude")
+    lon: str | None = Field(default=None, description="Longitude")
+    clock_utc: str | None = Field(default=None, description="Repeater clock in UTC")
+
+
+class RepeaterAdvertIntervalsResponse(BaseModel):
+    """Advertisement intervals from a repeater."""
+
+    advert_interval: str | None = Field(default=None, description="Local advert interval")
+    flood_advert_interval: str | None = Field(default=None, description="Flood advert interval")
+
+
+class RepeaterOwnerInfoResponse(BaseModel):
+    """Owner info and guest password from a repeater."""
+
+    owner_info: str | None = Field(default=None, description="Owner info string")
+    guest_password: str | None = Field(default=None, description="Guest password")
+
+
+class LppSensor(BaseModel):
+    """A single CayenneLPP sensor reading from req_telemetry_sync."""
+
+    channel: int = Field(description="LPP channel number")
+    type_name: str = Field(description="Sensor type name (e.g. temperature, humidity)")
+    value: float | dict = Field(
+        description="Scalar value or dict for multi-value sensors (GPS, accel)"
+    )
+
+
+class RepeaterLppTelemetryResponse(BaseModel):
+    """CayenneLPP sensor telemetry from a repeater."""
+
+    sensors: list[LppSensor] = Field(default_factory=list, description="List of sensor readings")
+
+
 class NeighborInfo(BaseModel):
     """Information about a neighbor seen by a repeater."""
 
@@ -167,34 +379,18 @@ class AclEntry(BaseModel):
     permission_name: str = Field(description="Human-readable permission name")
 
 
-class TelemetryResponse(BaseModel):
-    """Telemetry data from a repeater, formatted for human readability."""
+class RepeaterNeighborsResponse(BaseModel):
+    """Neighbors list from a repeater."""
 
-    pubkey_prefix: str = Field(description="12-char public key prefix")
-    battery_volts: float = Field(description="Battery voltage in volts")
-    tx_queue_len: int = Field(description="Transmit queue length")
-    noise_floor_dbm: int = Field(description="Noise floor in dBm")
-    last_rssi_dbm: int = Field(description="Last RSSI in dBm")
-    last_snr_db: float = Field(description="Last SNR in dB")
-    packets_received: int = Field(description="Total packets received")
-    packets_sent: int = Field(description="Total packets sent")
-    airtime_seconds: int = Field(description="TX airtime in seconds")
-    rx_airtime_seconds: int = Field(description="RX airtime in seconds")
-    uptime_seconds: int = Field(description="Uptime in seconds")
-    sent_flood: int = Field(description="Flood packets sent")
-    sent_direct: int = Field(description="Direct packets sent")
-    recv_flood: int = Field(description="Flood packets received")
-    recv_direct: int = Field(description="Direct packets received")
-    flood_dups: int = Field(description="Duplicate flood packets")
-    direct_dups: int = Field(description="Duplicate direct packets")
-    full_events: int = Field(description="Full event queue count")
     neighbors: list[NeighborInfo] = Field(
         default_factory=list, description="List of neighbors seen by repeater"
     )
+
+
+class RepeaterAclResponse(BaseModel):
+    """ACL list from a repeater."""
+
     acl: list[AclEntry] = Field(default_factory=list, description="Access control list")
-    clock_output: str | None = Field(
-        default=None, description="Output from 'clock' command (or error message)"
-    )
 
 
 class TraceResponse(BaseModel):
@@ -232,15 +428,6 @@ class Favorite(BaseModel):
     id: str = Field(description="Channel key or contact public key")
 
 
-class BotConfig(BaseModel):
-    """Configuration for a single bot."""
-
-    id: str = Field(description="UUID for stable identity across renames/reorders")
-    name: str = Field(description="User-editable name")
-    enabled: bool = Field(default=False, description="Whether this bot is enabled")
-    code: str = Field(default="", description="Python code for this bot")
-
-
 class UnreadCounts(BaseModel):
     """Aggregated unread counts, mention flags, and last message times for all conversations."""
 
@@ -265,13 +452,6 @@ class AppSettings(BaseModel):
             "(favorite contacts first, then recent non-repeaters)"
         ),
     )
-    experimental_channel_double_send: bool = Field(
-        default=False,
-        description=(
-            "Experimental: when enabled, channel messages are sent twice with a 3-second delay, "
-            "reusing the same timestamp bytes"
-        ),
-    )
     favorites: list[Favorite] = Field(
         default_factory=list, description="List of favorited conversations"
     )
@@ -299,7 +479,55 @@ class AppSettings(BaseModel):
         default=0,
         description="Unix timestamp of last advertisement sent (0 = never)",
     )
-    bots: list[BotConfig] = Field(
-        default_factory=list,
-        description="List of bot configurations",
+    flood_scope: str = Field(
+        default="",
+        description="Outbound flood scope / region name (empty = disabled, no tagging)",
     )
+    blocked_keys: list[str] = Field(
+        default_factory=list,
+        description="Public keys whose messages are hidden from the UI",
+    )
+    blocked_names: list[str] = Field(
+        default_factory=list,
+        description="Display names whose messages are hidden from the UI",
+    )
+
+
+class FanoutConfig(BaseModel):
+    """Configuration for a single fanout integration."""
+
+    id: str
+    type: str  # 'mqtt_private' | 'mqtt_community' | 'bot' | 'webhook' | 'apprise'
+    name: str
+    enabled: bool
+    config: dict
+    scope: dict
+    sort_order: int = 0
+    created_at: int = 0
+
+
+class BusyChannel(BaseModel):
+    channel_key: str
+    channel_name: str
+    message_count: int
+
+
+class ContactActivityCounts(BaseModel):
+    last_hour: int
+    last_24_hours: int
+    last_week: int
+
+
+class StatisticsResponse(BaseModel):
+    busiest_channels_24h: list[BusyChannel]
+    contact_count: int
+    repeater_count: int
+    channel_count: int
+    total_packets: int
+    decrypted_packets: int
+    undecrypted_packets: int
+    total_dms: int
+    total_channel_messages: int
+    total_outgoing: int
+    contacts_heard: ContactActivityCounts
+    repeaters_heard: ContactActivityCounts

app/packet_processor.py

@@ -15,6 +15,7 @@ are offloaded from the radio to the server.
 import asyncio
 import logging
 import time
+from itertools import count
 
 from app.decoder import (
     DecryptedDirectMessage,
@@ -27,9 +28,17 @@ from app.decoder import (
     try_decrypt_packet_with_channel_key,
 )
 from app.keystore import get_private_key, get_public_key, has_private_key
-from app.models import CONTACT_TYPE_REPEATER, RawPacketBroadcast, RawPacketDecryptedInfo
+from app.models import (
+    CONTACT_TYPE_REPEATER,
+    Message,
+    MessagePath,
+    RawPacketBroadcast,
+    RawPacketDecryptedInfo,
+)
 from app.repository import (
     ChannelRepository,
+    ContactAdvertPathRepository,
+    ContactNameHistoryRepository,
     ContactRepository,
     MessageRepository,
     RawPacketRepository,
@@ -38,6 +47,8 @@ from app.websocket import broadcast_error, broadcast_event
 
 logger = logging.getLogger(__name__)
 
+_raw_observation_counter = count(1)
+
 
 async def _handle_duplicate_message(
     packet_id: int,
@@ -46,6 +57,7 @@ async def _handle_duplicate_message(
     text: str,
     sender_timestamp: int,
     path: str | None,
+    path_len: int | None,
     received: int,
 ) -> None:
     """Handle a duplicate message by updating paths/acks on the existing record.
@@ -79,7 +91,7 @@ async def _handle_duplicate_message(
 
     # Add path if provided
     if path is not None:
-        paths = await MessageRepository.add_path(existing_msg.id, path, received)
+        paths = await MessageRepository.add_path(existing_msg.id, path, received, path_len=path_len)
     else:
         # Get current paths for broadcast
         paths = existing_msg.paths or []
@@ -88,17 +100,22 @@ async def _handle_duplicate_message(
     if existing_msg.outgoing:
         ack_count = await MessageRepository.increment_ack_count(existing_msg.id)
     else:
-        ack_count = await MessageRepository.get_ack_count(existing_msg.id)
+        ack_count = existing_msg.acked
 
-    # Broadcast updated paths
-    broadcast_event(
-        "message_acked",
-        {
-            "message_id": existing_msg.id,
-            "ack_count": ack_count,
-            "paths": [p.model_dump() for p in paths] if paths else [],
-        },
-    )
+    # Only broadcast when something actually changed:
+    # - outgoing: ack count was incremented
+    # - path provided: a new path entry was appended
+    # The path=None case happens for direct-delivery DMs (0-hop, no routing bytes).
+    # A non-outgoing duplicate with no new path changes nothing in the DB, so skip.
+    if existing_msg.outgoing or path is not None:
+        broadcast_event(
+            "message_acked",
+            {
+                "message_id": existing_msg.id,
+                "ack_count": ack_count,
+                "paths": [p.model_dump() for p in paths] if paths else [],
+            },
+        )
 
     # Mark this packet as decrypted
     await RawPacketRepository.mark_decrypted(packet_id, existing_msg.id)
@@ -112,8 +129,9 @@ async def create_message_from_decrypted(
     timestamp: int,
     received_at: int | None = None,
     path: str | None = None,
+    path_len: int | None = None,
     channel_name: str | None = None,
-    trigger_bot: bool = True,
+    realtime: bool = True,
 ) -> int | None:
     """Create a message record from decrypted channel packet content.
 
@@ -129,11 +147,14 @@ async def create_message_from_decrypted(
         timestamp: Sender timestamp from the packet
         received_at: When the packet was received (defaults to now)
         path: Hex-encoded routing path
-        trigger_bot: Whether to trigger bot response (False for historical decryption)
+        realtime: If False, skip fanout dispatch (used for historical decryption)
 
     Returns the message ID if created, None if duplicate.
     """
     received = received_at or int(time.time())
+    normalized_path_len = (
+        path_len if isinstance(path_len, int) else (len(path) // 2 if path is not None else None)
+    )
 
     # Format the message text with sender prefix if present
     text = f"{sender}: {message_text}" if sender else message_text
@@ -141,6 +162,13 @@ async def create_message_from_decrypted(
     # Normalize channel key to uppercase for consistency
     channel_key_normalized = channel_key.upper()
 
+    # Resolve sender_key: look up contact by exact name match
+    resolved_sender_key: str | None = None
+    if sender:
+        candidates = await ContactRepository.get_by_name(sender)
+        if len(candidates) == 1:
+            resolved_sender_key = candidates[0].public_key
+
     # Try to create message - INSERT OR IGNORE handles duplicates atomically
     msg_id = await MessageRepository.create(
         msg_type="CHAN",
@@ -149,6 +177,9 @@ async def create_message_from_decrypted(
         sender_timestamp=timestamp,
         received_at=received,
         path=path,
+        path_len=normalized_path_len,
+        sender_name=sender,
+        sender_key=resolved_sender_key,
     )
 
     if msg_id is None:
@@ -157,7 +188,14 @@ async def create_message_from_decrypted(
         # 2. Same message arrives via multiple paths before first is committed
         # In either case, add the path to the existing message.
         await _handle_duplicate_message(
-            packet_id, "CHAN", channel_key_normalized, text, timestamp, path, received
+            packet_id,
+            "CHAN",
+            channel_key_normalized,
+            text,
+            timestamp,
+            path,
+            normalized_path_len,
+            received,
         )
         return None
 
@@ -168,43 +206,29 @@ async def create_message_from_decrypted(
 
     # Build paths array for broadcast
     # Use "is not None" to include empty string (direct/0-hop messages)
-    paths = [{"path": path or "", "received_at": received}] if path is not None else None
-
-    # Broadcast new message to connected clients
-    broadcast_event(
-        "message",
-        {
-            "id": msg_id,
-            "type": "CHAN",
-            "conversation_key": channel_key_normalized,
-            "text": text,
-            "sender_timestamp": timestamp,
-            "received_at": received,
-            "paths": paths,
-            "txt_type": 0,
-            "signature": None,
-            "outgoing": False,
-            "acked": 0,
-        },
+    paths = (
+        [MessagePath(path=path or "", received_at=received, path_len=normalized_path_len)]
+        if path is not None
+        else None
     )
 
-    # Run bot if enabled (for incoming channel messages, not historical decryption)
-    if trigger_bot:
-        from app.bot import run_bot_for_message
-
-        asyncio.create_task(
-            run_bot_for_message(
-                sender_name=sender,
-                sender_key=None,  # Channel messages don't have a sender public key
-                message_text=message_text,
-                is_dm=False,
-                channel_key=channel_key_normalized,
-                channel_name=channel_name,
-                sender_timestamp=timestamp,
-                path=path,
-                is_outgoing=False,
-            )
-        )
+    # Broadcast new message to connected clients (and fanout modules when realtime)
+    broadcast_event(
+        "message",
+        Message(
+            id=msg_id,
+            type="CHAN",
+            conversation_key=channel_key_normalized,
+            text=text,
+            sender_timestamp=timestamp,
+            received_at=received,
+            paths=paths,
+            sender_name=sender,
+            sender_key=resolved_sender_key,
+            channel_name=channel_name,
+        ).model_dump(),
+        realtime=realtime,
+    )
 
     return msg_id
 
@@ -216,8 +240,9 @@ async def create_dm_message_from_decrypted(
     our_public_key: str | None,
     received_at: int | None = None,
     path: str | None = None,
+    path_len: int | None = None,
     outgoing: bool = False,
-    trigger_bot: bool = True,
+    realtime: bool = True,
 ) -> int | None:
     """Create a message record from decrypted direct message packet content.
 
@@ -232,7 +257,7 @@ async def create_dm_message_from_decrypted(
         received_at: When the packet was received (defaults to now)
         path: Hex-encoded routing path
         outgoing: Whether this is an outgoing message (we sent it)
-        trigger_bot: Whether to trigger bot response (False for historical decryption)
+        realtime: If False, skip fanout dispatch (used for historical decryption)
 
     Returns the message ID if created, None if duplicate.
     """
@@ -248,10 +273,16 @@ async def create_dm_message_from_decrypted(
         return None
 
     received = received_at or int(time.time())
+    normalized_path_len = (
+        path_len if isinstance(path_len, int) else (len(path) // 2 if path is not None else None)
+    )
 
     # conversation_key is always the other party's public key
     conversation_key = their_public_key.lower()
 
+    # Resolve sender name for incoming messages (used for name-based blocking)
+    sender_name = contact.name if contact and not outgoing else None
+
     # Try to create message - INSERT OR IGNORE handles duplicates atomically
     msg_id = await MessageRepository.create(
         msg_type="PRIV",
@@ -260,7 +291,10 @@ async def create_dm_message_from_decrypted(
         sender_timestamp=decrypted.timestamp,
         received_at=received,
         path=path,
+        path_len=normalized_path_len,
         outgoing=outgoing,
+        sender_key=conversation_key if not outgoing else None,
+        sender_name=sender_name,
     )
 
     if msg_id is None:
@@ -272,6 +306,7 @@ async def create_dm_message_from_decrypted(
             decrypted.message,
             decrypted.timestamp,
             path,
+            normalized_path_len,
             received,
         )
         return None
@@ -287,51 +322,34 @@ async def create_dm_message_from_decrypted(
     await RawPacketRepository.mark_decrypted(packet_id, msg_id)
 
     # Build paths array for broadcast
-    paths = [{"path": path or "", "received_at": received}] if path is not None else None
+    paths = (
+        [MessagePath(path=path or "", received_at=received, path_len=normalized_path_len)]
+        if path is not None
+        else None
+    )
 
-    # Broadcast new message to connected clients
+    # Broadcast new message to connected clients (and fanout modules when realtime)
+    sender_name = contact.name if contact and not outgoing else None
     broadcast_event(
         "message",
-        {
-            "id": msg_id,
-            "type": "PRIV",
-            "conversation_key": conversation_key,
-            "text": decrypted.message,
-            "sender_timestamp": decrypted.timestamp,
-            "received_at": received,
-            "paths": paths,
-            "txt_type": 0,
-            "signature": None,
-            "outgoing": outgoing,
-            "acked": 0,
-        },
+        Message(
+            id=msg_id,
+            type="PRIV",
+            conversation_key=conversation_key,
+            text=decrypted.message,
+            sender_timestamp=decrypted.timestamp,
+            received_at=received,
+            paths=paths,
+            outgoing=outgoing,
+            sender_name=sender_name,
+            sender_key=conversation_key if not outgoing else None,
+        ).model_dump(),
+        realtime=realtime,
     )
 
     # Update contact's last_contacted timestamp (for sorting)
     await ContactRepository.update_last_contacted(conversation_key, received)
 
-    # Run bot if enabled (for all real-time DMs, including our own outgoing messages)
-    if trigger_bot:
-        from app.bot import run_bot_for_message
-
-        # Get contact name for the bot
-        contact = await ContactRepository.get_by_key(their_public_key)
-        sender_name = contact.name if contact else None
-
-        asyncio.create_task(
-            run_bot_for_message(
-                sender_name=sender_name,
-                sender_key=their_public_key,
-                message_text=decrypted.message,
-                is_dm=True,
-                channel_key=None,
-                channel_name=None,
-                sender_timestamp=decrypted.timestamp,
-                path=path,
-                is_outgoing=outgoing,
-            )
-        )
-
     return msg_id
 
 
@@ -358,11 +376,14 @@ async def run_historical_dm_decryption(
     our_public_key_bytes = derive_public_key(private_key_bytes)
 
     for packet_id, packet_data, packet_timestamp in packets:
-        # Note: passing our_public_key=None means outgoing DMs won't be matched
-        # by try_decrypt_dm (the inbound check requires src_hash == their_first_byte,
-        # which fails for our outgoing packets). This is acceptable because outgoing
-        # DMs are stored directly by the send endpoint. Historical decryption only
-        # recovers incoming messages.
+        # Note: passing our_public_key=None disables the outbound hash check in
+        # try_decrypt_dm (only the inbound check src_hash == their_first_byte runs).
+        # For the 255/256 case where our first byte differs from the contact's,
+        # outgoing packets fail the inbound check and are skipped — which is correct
+        # since outgoing DMs are stored directly by the send endpoint.
+        # For the 1/256 case where bytes match, an outgoing packet may decrypt
+        # successfully, but the dual-hash direction check below correctly identifies
+        # it and the DB dedup constraint prevents a duplicate insert.
         result = try_decrypt_dm(
             packet_data,
             private_key_bytes,
@@ -371,10 +392,20 @@ async def run_historical_dm_decryption(
         )
 
         if result is not None:
-            # Determine direction by checking src_hash
+            # Determine direction using both hashes (mirrors _process_direct_message
+            # logic at lines 806-818) to handle the 1/256 case where our first
+            # public key byte matches the contact's.
             src_hash = result.src_hash.lower()
+            dest_hash = result.dest_hash.lower()
             our_first_byte = format(our_public_key_bytes[0], "02x").lower()
-            outgoing = src_hash == our_first_byte
+
+            if src_hash == our_first_byte and dest_hash != our_first_byte:
+                outgoing = True
+            else:
+                # Incoming, ambiguous (both match), or neither matches.
+                # Default to incoming — outgoing DMs are stored by the send
+                # endpoint, so historical decryption only recovers incoming.
+                outgoing = False
 
             # Extract path from the raw packet for storage
             packet_info = parse_packet(packet_data)
@@ -387,8 +418,9 @@ async def run_historical_dm_decryption(
                 our_public_key=our_public_key_bytes.hex(),
                 received_at=packet_timestamp,
                 path=path_hex,
+                path_len=packet_info.path_length if packet_info else None,
                 outgoing=outgoing,
-                trigger_bot=False,  # Historical decryption should not trigger bot
+                realtime=False,  # Historical decryption should not trigger fanout
             )
 
             if msg_id is not None:
@@ -476,6 +508,7 @@ async def process_raw_packet(
     since the original packet was already processed.
     """
     ts = timestamp or int(time.time())
+    observation_id = next(_raw_observation_counter)
 
     packet_id, is_new_packet = await RawPacketRepository.create(raw_bytes, ts)
     raw_hex = raw_bytes.hex()
@@ -485,6 +518,13 @@ async def process_raw_packet(
     payload_type = packet_info.payload_type if packet_info else None
     payload_type_name = payload_type.name if payload_type else "Unknown"
 
+    if packet_info is None and len(raw_bytes) > 2:
+        logger.warning(
+            "Failed to parse %d-byte packet (id=%d); stored undecrypted",
+            len(raw_bytes),
+            packet_id,
+        )
+
     # Log packet arrival at debug level
     path_hex = packet_info.path.hex() if packet_info and packet_info.path else ""
     logger.debug(
@@ -517,8 +557,10 @@ async def process_raw_packet(
         if decrypt_result:
             result.update(decrypt_result)
 
-    elif payload_type == PayloadType.ADVERT and is_new_packet:
-        # Only process new advertisements (duplicates don't add value)
+    elif payload_type == PayloadType.ADVERT:
+        # Process all advert arrivals (even payload-hash duplicates) so the
+        # path-freshness logic in _process_advertisement can pick the shortest
+        # path heard within the freshness window.
         await _process_advertisement(raw_bytes, ts, packet_info)
 
     elif payload_type == PayloadType.TEXT_MESSAGE:
@@ -531,6 +573,7 @@ async def process_raw_packet(
     # This enables the frontend cracker to see all incoming packets in real-time
     broadcast_payload = RawPacketBroadcast(
         id=packet_id,
+        observation_id=observation_id,
         timestamp=ts,
         data=raw_hex,
         payload_type=payload_type_name,
@@ -540,6 +583,8 @@ async def process_raw_packet(
         decrypted_info=RawPacketDecryptedInfo(
             channel_name=result["channel_name"],
             sender=result["sender"],
+            channel_key=result.get("channel_key"),
+            contact_key=result.get("contact_key"),
         )
         if result["decrypted"]
         else None,
@@ -589,6 +634,7 @@ async def _process_group_text(
             timestamp=decrypted.timestamp,
             received_at=timestamp,
             path=packet_info.path.hex() if packet_info else None,
+            path_len=packet_info.path_length if packet_info else None,
         )
 
         return {
@@ -596,6 +642,7 @@ async def _process_group_text(
             "channel_name": channel.name,
             "sender": decrypted.sender,
             "message_id": msg_id,  # None if duplicate, msg_id if new
+            "channel_key": channel.key,
         }
 
     # Couldn't decrypt with any known key
@@ -676,6 +723,23 @@ async def _process_advertisement(
         advert.device_role if advert.device_role > 0 else (existing.type if existing else 0)
     )
 
+    # Keep recent unique advert paths for all contacts.
+    await ContactAdvertPathRepository.record_observation(
+        public_key=advert.public_key.lower(),
+        path_hex=new_path_hex,
+        timestamp=timestamp,
+        max_paths=10,
+        path_len=new_path_len,
+    )
+
+    # Record name history
+    if advert.name:
+        await ContactNameHistoryRepository.record_name(
+            public_key=advert.public_key.lower(),
+            name=advert.name,
+            timestamp=timestamp,
+        )
+
     contact_data = {
         "public_key": advert.public_key.lower(),
         "name": advert.name,
@@ -686,6 +750,7 @@ async def _process_advertisement(
         "last_seen": timestamp,
         "last_path": path_hex,
         "last_path_len": path_len,
+        "first_seen": timestamp,  # COALESCE in upsert preserves existing value
     }
 
     await ContactRepository.upsert(contact_data)
@@ -696,24 +761,24 @@ async def _process_advertisement(
             claimed,
             advert.public_key[:12],
         )
+    if advert.name:
+        backfilled = await MessageRepository.backfill_channel_sender_key(
+            advert.public_key, advert.name
+        )
+        if backfilled > 0:
+            logger.info(
+                "Backfilled sender_key on %d channel message(s) for %s",
+                backfilled,
+                advert.name,
+            )
 
-    # Broadcast contact update to connected clients
-    broadcast_event(
-        "contact",
-        {
-            "public_key": advert.public_key.lower(),
-            "name": advert.name,
-            "type": contact_type,
-            "flags": existing.flags if existing else 0,
-            "last_path": path_hex,
-            "last_path_len": path_len,
-            "last_advert": advert.timestamp if advert.timestamp > 0 else timestamp,
-            "lat": advert.lat,
-            "lon": advert.lon,
-            "last_seen": timestamp,
-            "on_radio": existing.on_radio if existing else False,
-        },
-    )
+    # Read back from DB so the broadcast includes all fields (last_contacted,
+    # last_read_at, flags, on_radio, etc.) matching the REST Contact shape exactly.
+    db_contact = await ContactRepository.get_by_key(advert.public_key.lower())
+    if db_contact:
+        broadcast_event("contact", db_contact.model_dump())
+    else:
+        broadcast_event("contact", contact_data)
 
     # For new contacts, optionally attempt to decrypt any historical DMs we may have stored
     # This is controlled by the auto_decrypt_dm_on_advert setting
@@ -836,7 +901,8 @@ async def _process_direct_message(
                 their_public_key=contact.public_key,
                 our_public_key=our_public_key.hex(),
                 received_at=timestamp,
-                path=packet_info.path.hex() if packet_info.path else None,
+                path=packet_info.path.hex() if packet_info else None,
+                path_len=packet_info.path_length if packet_info else None,
                 outgoing=is_outgoing,
             )
 
@@ -845,6 +911,7 @@ async def _process_direct_message(
                 "contact_name": contact.name,
                 "sender": contact.name or contact.public_key[:12],
                 "message_id": msg_id,
+                "contact_key": contact.public_key,
             }
 
     # Couldn't decrypt with any known contact

app/path_utils.py

@@ -0,0 +1,32 @@
+"""Helpers for working with hex-encoded routing paths."""
+
+
+def get_path_hop_width(path_hex: str | None, path_len: int | None) -> int:
+    """Return hop width in hex chars, falling back to legacy 1-byte hops."""
+    if not path_hex:
+        return 2
+    if isinstance(path_len, int) and path_len > 0 and len(path_hex) % path_len == 0:
+        hop_width = len(path_hex) // path_len
+        if hop_width > 0 and hop_width % 2 == 0:
+            return hop_width
+    return 2
+
+
+def split_path_hops(path_hex: str | None, path_len: int | None) -> list[str]:
+    """Split a hex path string into hop-sized chunks."""
+    if not path_hex:
+        return []
+
+    hop_width = get_path_hop_width(path_hex, path_len)
+    normalized = path_hex.lower()
+    return [
+        normalized[i : i + hop_width]
+        for i in range(0, len(normalized), hop_width)
+        if i + hop_width <= len(normalized)
+    ]
+
+
+def first_path_hop(path_hex: str | None, path_len: int | None) -> str | None:
+    """Return the first hop from a hex path string, if any."""
+    hops = split_path_hops(path_hex, path_len)
+    return hops[0] if hops else None

app/radio.py

@@ -1,11 +1,12 @@
 import asyncio
 import glob
+import inspect
 import logging
 import platform
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, nullcontext
 from pathlib import Path
 
-from meshcore import MeshCore
+from meshcore import EventType, MeshCore
 
 from app.config import settings
 
@@ -20,10 +21,8 @@ class RadioOperationBusyError(RadioOperationError):
     """Raised when a non-blocking radio operation cannot acquire the lock."""
 
 
-@asynccontextmanager
-async def _noop_context():
-    """No-op async context manager for optional nesting."""
-    yield
+class RadioDisconnectedError(RadioOperationError):
+    """Raised when the radio disconnects between pre-check and lock acquisition."""
 
 
 def detect_serial_devices() -> list[str]:
@@ -70,6 +69,7 @@ def detect_serial_devices() -> list[str]:
 
 async def test_serial_device(port: str, baudrate: int, timeout: float = 3.0) -> bool:
     """Test if a MeshCore radio responds on the given serial port."""
+    mc = None
     try:
         logger.debug("Testing serial device %s", port)
         mc = await asyncio.wait_for(
@@ -80,10 +80,8 @@ async def test_serial_device(port: str, baudrate: int, timeout: float = 3.0) ->
         # Check if we got valid self_info (indicates successful communication)
         if mc.is_connected and mc.self_info:
             logger.debug("Device %s responded with valid self_info", port)
-            await mc.disconnect()
             return True
 
-        await mc.disconnect()
         return False
     except asyncio.TimeoutError:
         logger.debug("Device %s timed out", port)
@@ -91,6 +89,12 @@ async def test_serial_device(port: str, baudrate: int, timeout: float = 3.0) ->
     except Exception as e:
         logger.debug("Device %s failed: %s", port, e)
         return False
+    finally:
+        if mc is not None:
+            try:
+                await mc.disconnect()
+            except Exception:
+                pass
 
 
 async def find_radio_port(baudrate: int) -> str | None:
@@ -124,6 +128,9 @@ class RadioManager:
         self._operation_lock: asyncio.Lock | None = None
         self._setup_lock: asyncio.Lock | None = None
         self._setup_in_progress: bool = False
+        self._setup_complete: bool = False
+        self._path_hash_mode: int = 0
+        self._path_hash_mode_supported: bool = False
 
     async def _acquire_operation_lock(
         self,
@@ -161,37 +168,48 @@ class RadioManager:
         pause_polling: bool = False,
         suspend_auto_fetch: bool = False,
         blocking: bool = True,
-        meshcore: MeshCore | None = None,
     ):
         """Acquire shared radio lock and optionally pause polling / auto-fetch.
 
+        After acquiring the lock, resolves the current MeshCore instance and
+        yields it.  Callers get a fresh reference via ``async with ... as mc:``,
+        avoiding stale-reference bugs when a reconnect swaps ``_meshcore``
+        between the pre-check and the lock acquisition.
+
         Args:
             name: Human-readable operation name for logs/errors.
             pause_polling: Pause fallback message polling while held.
             suspend_auto_fetch: Stop MeshCore auto message fetching while held.
             blocking: If False, fail immediately when lock is held.
-            meshcore: Optional explicit MeshCore instance for auto-fetch control.
+
+        Raises:
+            RadioDisconnectedError: If the radio disconnected before the lock
+                was acquired (``_meshcore`` is ``None``).
         """
         await self._acquire_operation_lock(name, blocking=blocking)
 
-        poll_context = _noop_context()
+        mc = self._meshcore
+        if mc is None:
+            self._release_operation_lock(name)
+            raise RadioDisconnectedError("Radio disconnected")
+
+        poll_context = nullcontext()
         if pause_polling:
             from app.radio_sync import pause_polling as pause_polling_context
 
             poll_context = pause_polling_context()
 
-        mc = meshcore or self._meshcore
         auto_fetch_paused = False
 
         try:
             async with poll_context:
-                if suspend_auto_fetch and mc is not None:
+                if suspend_auto_fetch:
                     await mc.stop_auto_message_fetching()
                     auto_fetch_paused = True
-                yield
+                yield mc
         finally:
             try:
-                if auto_fetch_paused and mc is not None:
+                if auto_fetch_paused:
                     try:
                         await mc.start_auto_message_fetching()
                     except Exception as e:
@@ -227,40 +245,67 @@ class RadioManager:
             if not self._meshcore:
                 return
             self._setup_in_progress = True
+            self._setup_complete = False
+            mc = self._meshcore
             try:
-                register_event_handlers(self._meshcore)
-                await export_and_store_private_key(self._meshcore)
+                # Register event handlers (no radio I/O, just callback setup)
+                register_event_handlers(mc)
 
-                # Sync radio clock with system time
-                await sync_radio_time()
+                # Hold the operation lock for all radio I/O during setup.
+                # This prevents user-initiated operations (send message, etc.)
+                # from interleaving commands on the serial link.
+                await self._acquire_operation_lock("post_connect_setup", blocking=True)
+                try:
+                    await export_and_store_private_key(mc)
 
-                # Sync contacts/channels from radio to DB and clear radio
-                logger.info("Syncing and offloading radio data...")
-                result = await sync_and_offload_all()
-                logger.info("Sync complete: %s", result)
+                    # Sync radio clock with system time
+                    await sync_radio_time(mc)
+                    await self.refresh_path_hash_mode_info(mc)
 
-                # Start periodic sync (idempotent)
+                    # Apply flood scope from settings (best-effort; older firmware
+                    # may not support set_flood_scope)
+                    from app.repository import AppSettingsRepository
+
+                    app_settings = await AppSettingsRepository.get()
+                    scope = app_settings.flood_scope
+                    try:
+                        await mc.commands.set_flood_scope(scope if scope else "")
+                        logger.info("Applied flood_scope=%r", scope or "(disabled)")
+                    except Exception as exc:
+                        logger.warning(
+                            "set_flood_scope failed (firmware may not support it): %s", exc
+                        )
+
+                    # Sync contacts/channels from radio to DB and clear radio
+                    logger.info("Syncing and offloading radio data...")
+                    result = await sync_and_offload_all(mc)
+                    logger.info("Sync complete: %s", result)
+
+                    # Send advertisement to announce our presence (if enabled and not throttled)
+                    if await send_advertisement(mc):
+                        logger.info("Advertisement sent")
+                    else:
+                        logger.debug("Advertisement skipped (disabled or throttled)")
+
+                    # Drain any messages that were queued before we connected.
+                    # This must happen BEFORE starting auto-fetch, otherwise both
+                    # compete on get_msg() with interleaved radio I/O.
+                    drained = await drain_pending_messages(mc)
+                    if drained > 0:
+                        logger.info("Drained %d pending message(s)", drained)
+
+                    await mc.start_auto_message_fetching()
+                    logger.info("Auto message fetching started")
+                finally:
+                    self._release_operation_lock("post_connect_setup")
+
+                # Start background tasks AFTER releasing the operation lock.
+                # These tasks acquire their own locks when they need radio access.
                 start_periodic_sync()
-
-                # Send advertisement to announce our presence (if enabled and not throttled)
-                if await send_advertisement():
-                    logger.info("Advertisement sent")
-                else:
-                    logger.debug("Advertisement skipped (disabled or throttled)")
-
-                # Start periodic advertisement (idempotent)
                 start_periodic_advert()
-
-                await self._meshcore.start_auto_message_fetching()
-                logger.info("Auto message fetching started")
-
-                # Drain any messages that were queued before we connected
-                drained = await drain_pending_messages()
-                if drained > 0:
-                    logger.info("Drained %d pending message(s)", drained)
-
-                # Start periodic message polling as fallback (idempotent)
                 start_message_polling()
+
+                self._setup_complete = True
             finally:
                 self._setup_in_progress = False
 
@@ -286,6 +331,52 @@ class RadioManager:
     def is_setup_in_progress(self) -> bool:
         return self._setup_in_progress
 
+    @property
+    def is_setup_complete(self) -> bool:
+        return self._setup_complete
+
+    @property
+    def path_hash_mode_info(self) -> tuple[int, bool]:
+        return self._path_hash_mode, self._path_hash_mode_supported
+
+    def set_path_hash_mode_info(self, mode: int, supported: bool) -> None:
+        self._path_hash_mode = mode if supported and 0 <= mode <= 2 else 0
+        self._path_hash_mode_supported = supported
+
+    async def refresh_path_hash_mode_info(self, mc: MeshCore | None = None) -> tuple[int, bool]:
+        target = mc or self._meshcore
+        if target is None:
+            self.set_path_hash_mode_info(0, False)
+            return self.path_hash_mode_info
+
+        commands = getattr(target, "commands", None)
+        send_device_query = getattr(commands, "send_device_query", None)
+        if commands is None or not callable(send_device_query):
+            self.set_path_hash_mode_info(0, False)
+            return self.path_hash_mode_info
+
+        try:
+            result = send_device_query()
+            if inspect.isawaitable(result):
+                result = await result
+        except Exception as exc:
+            logger.debug("Failed to query device info for path hash mode: %s", exc)
+            self.set_path_hash_mode_info(0, False)
+            return self.path_hash_mode_info
+
+        if result is None or getattr(result, "type", None) == EventType.ERROR:
+            self.set_path_hash_mode_info(0, False)
+            return self.path_hash_mode_info
+
+        payload_obj = getattr(result, "payload", None)
+        payload = payload_obj if isinstance(payload_obj, dict) else {}
+        mode = payload.get("path_hash_mode")
+        if isinstance(mode, int) and 0 <= mode <= 2:
+            self.set_path_hash_mode_info(mode, True)
+        else:
+            self.set_path_hash_mode_info(0, False)
+        return self.path_hash_mode_info
+
     async def connect(self) -> None:
         """Connect to the radio using the configured transport."""
         if self._meshcore is not None:
@@ -323,6 +414,8 @@ class RadioManager:
         )
         self._connection_info = f"Serial: {port}"
         self._last_connected = True
+        self._setup_complete = False
+        self.set_path_hash_mode_info(0, False)
         logger.debug("Serial connection established")
 
     async def _connect_tcp(self) -> None:
@@ -339,6 +432,8 @@ class RadioManager:
         )
         self._connection_info = f"TCP: {host}:{port}"
         self._last_connected = True
+        self._setup_complete = False
+        self.set_path_hash_mode_info(0, False)
         logger.debug("TCP connection established")
 
     async def _connect_ble(self) -> None:
@@ -355,6 +450,8 @@ class RadioManager:
         )
         self._connection_info = f"BLE: {address}"
         self._last_connected = True
+        self._setup_complete = False
+        self.set_path_hash_mode_info(0, False)
         logger.debug("BLE connection established")
 
     async def disconnect(self) -> None:
@@ -363,6 +460,8 @@ class RadioManager:
             logger.debug("Disconnecting from radio")
             await self._meshcore.disconnect()
             self._meshcore = None
+            self._setup_complete = False
+            self.set_path_hash_mode_info(0, False)
             logger.debug("Radio disconnected")
 
     async def reconnect(self, *, broadcast_on_success: bool = True) -> bool:
@@ -377,12 +476,13 @@ class RadioManager:
         if self._reconnect_lock is None:
             self._reconnect_lock = asyncio.Lock()
 
-        # Try to acquire lock without blocking to check if reconnect is in progress
-        if self._reconnect_lock.locked():
-            logger.debug("Reconnection already in progress")
-            return False
-
         async with self._reconnect_lock:
+            # If we became connected while waiting for the lock (another
+            # reconnect succeeded ahead of us), skip the redundant attempt.
+            if self.is_connected:
+                logger.debug("Already connected after acquiring lock, skipping reconnect")
+                return True
+
             logger.info("Attempting to reconnect to radio...")
 
             try:
@@ -420,6 +520,8 @@ class RadioManager:
             from app.websocket import broadcast_health
 
             CHECK_INTERVAL_SECONDS = 5
+            UNRESPONSIVE_THRESHOLD = 3
+            consecutive_setup_failures = 0
 
             while True:
                 try:
@@ -433,6 +535,7 @@ class RadioManager:
                         logger.warning("Radio connection lost, broadcasting status change")
                         broadcast_health(False, self._connection_info)
                         self._last_connected = False
+                        consecutive_setup_failures = 0
 
                     if not current_connected:
                         # Attempt reconnection on every loop while disconnected
@@ -442,6 +545,7 @@ class RadioManager:
                             await self.post_connect_setup()
                             broadcast_health(True, self._connection_info)
                             self._last_connected = True
+                            consecutive_setup_failures = 0
 
                     elif not self._last_connected and current_connected:
                         # Connection restored (might have reconnected automatically).
@@ -450,13 +554,34 @@ class RadioManager:
                         await self.post_connect_setup()
                         broadcast_health(True, self._connection_info)
                         self._last_connected = True
+                        consecutive_setup_failures = 0
+
+                    elif current_connected and not self._setup_complete:
+                        # Transport connected but setup incomplete — retry
+                        logger.info("Retrying post-connect setup...")
+                        await self.post_connect_setup()
+                        broadcast_health(True, self._connection_info)
+                        consecutive_setup_failures = 0
 
                 except asyncio.CancelledError:
                     # Task is being cancelled, exit cleanly
                     break
                 except Exception as e:
-                    # Log error but continue monitoring - don't let the monitor die
-                    logger.exception("Error in connection monitor, continuing: %s", e)
+                    consecutive_setup_failures += 1
+                    if consecutive_setup_failures == UNRESPONSIVE_THRESHOLD:
+                        logger.error(
+                            "Post-connect setup has failed %d times in a row. "
+                            "The radio port appears open but the radio is not "
+                            "responding to commands. Common causes: another "
+                            "process has the serial port open (check for other "
+                            "RemoteTerm instances, serial monitors, etc.), the "
+                            "firmware is in repeater mode (not client), or the "
+                            "radio needs a power cycle. Will keep retrying.",
+                            consecutive_setup_failures,
+                        )
+                    elif consecutive_setup_failures < UNRESPONSIVE_THRESHOLD:
+                        logger.exception("Error in connection monitor, continuing: %s", e)
+                    # After the threshold, silently retry (avoid log spam)
 
         self._reconnect_task = asyncio.create_task(monitor_loop())
         logger.info("Radio connection monitor started")

app/radio_sync.py

@@ -14,8 +14,9 @@ import logging
 import time
 from contextlib import asynccontextmanager
 
-from meshcore import EventType
+from meshcore import EventType, MeshCore
 
+from app.event_handlers import cleanup_expired_acks
 from app.models import Contact
 from app.radio import RadioOperationBusyError, radio_manager
 from app.repository import (
@@ -28,11 +29,38 @@ from app.repository import (
 
 logger = logging.getLogger(__name__)
 
+
+async def upsert_channel_from_radio_slot(payload: dict, *, on_radio: bool) -> str | None:
+    """Parse a radio channel-slot payload and upsert to the database.
+
+    Returns the uppercase hex key if a channel was upserted, or None if the
+    slot was empty/invalid.
+    """
+    name = payload.get("channel_name", "")
+    secret = payload.get("channel_secret", b"")
+
+    # Skip empty channels
+    if not name or name == "\x00" * len(name):
+        return None
+
+    is_hashtag = name.startswith("#")
+    key_bytes = secret if isinstance(secret, bytes) else bytes(secret)
+    key_hex = key_bytes.hex().upper()
+
+    await ChannelRepository.upsert(
+        key=key_hex,
+        name=name,
+        is_hashtag=is_hashtag,
+        on_radio=on_radio,
+    )
+    return key_hex
+
+
 # Message poll task handle
 _message_poll_task: asyncio.Task | None = None
 
-# Message poll interval in seconds
-MESSAGE_POLL_INTERVAL = 5
+# Message poll interval in seconds (10s gives DM ACKs plenty of time to arrive)
+MESSAGE_POLL_INTERVAL = 10
 
 # Periodic advertisement task handle
 _advert_task: asyncio.Task | None = None
@@ -41,6 +69,11 @@ _advert_task: asyncio.Task | None = None
 # We still need to periodically check if it's been enabled
 ADVERT_CHECK_INTERVAL = 60
 
+# Minimum allowed advertisement interval (1 hour).
+# Even if the database has a shorter value, we silently refuse to advertise
+# more frequently than this.
+MIN_ADVERT_INTERVAL = 3600
+
 # Counter to pause polling during repeater operations (supports nested pauses)
 _polling_pause_count: int = 0
 
@@ -71,16 +104,11 @@ _sync_task: asyncio.Task | None = None
 SYNC_INTERVAL = 300
 
 
-async def sync_and_offload_contacts() -> dict:
+async def sync_and_offload_contacts(mc: MeshCore) -> dict:
     """
     Sync contacts from radio to database, then remove them from radio.
     Returns counts of synced and removed contacts.
     """
-    if not radio_manager.is_connected or radio_manager.meshcore is None:
-        logger.warning("Cannot sync contacts: radio not connected")
-        return {"synced": 0, "removed": 0, "error": "Radio not connected"}
-
-    mc = radio_manager.meshcore
     synced = 0
     removed = 0
 
@@ -89,7 +117,16 @@ async def sync_and_offload_contacts() -> dict:
         result = await mc.commands.get_contacts()
 
         if result is None or result.type == EventType.ERROR:
-            logger.error("Failed to get contacts from radio: %s", result)
+            logger.error(
+                "Failed to get contacts from radio: %s. "
+                "If you see this repeatedly, the radio may be visible on the "
+                "serial/TCP/BLE port but not responding to commands. Check for "
+                "another process with the serial port open (other RemoteTerm "
+                "instances, serial monitors, etc.), verify the firmware is "
+                "up-to-date and in client mode (not repeater), or try a "
+                "power cycle.",
+                result,
+            )
             return {"synced": 0, "removed": 0, "error": str(result)}
 
         contacts = result.payload or {}
@@ -108,6 +145,17 @@ async def sync_and_offload_contacts() -> dict:
                     claimed,
                     public_key[:12],
                 )
+            adv_name = contact_data.get("adv_name")
+            if adv_name:
+                backfilled = await MessageRepository.backfill_channel_sender_key(
+                    public_key, adv_name
+                )
+                if backfilled > 0:
+                    logger.info(
+                        "Backfilled sender_key on %d channel message(s) for %s",
+                        backfilled,
+                        adv_name,
+                    )
             synced += 1
 
             # Remove from radio
@@ -115,6 +163,30 @@ async def sync_and_offload_contacts() -> dict:
                 remove_result = await mc.commands.remove_contact(contact_data)
                 if remove_result.type == EventType.OK:
                     removed += 1
+
+                    # LIBRARY INTERNAL FIXUP: The MeshCore library's
+                    # commands.remove_contact() sends the remove command over
+                    # the wire but does NOT update the library's in-memory
+                    # contact cache (mc._contacts). This is a gap in the
+                    # library — there's no public API to clear a single
+                    # contact from the cache, and the library only refreshes
+                    # it on a full get_contacts() call.
+                    #
+                    # Why this matters: sync_recent_contacts_to_radio() uses
+                    # mc.get_contact_by_key_prefix() to check whether a
+                    # contact is already loaded on the radio. That method
+                    # searches mc._contacts. If we don't evict the removed
+                    # contact from the cache here, get_contact_by_key_prefix()
+                    # will still find it and skip the add_contact() call —
+                    # meaning contacts never get loaded back onto the radio
+                    # after offload. The result: no DM ACKs, degraded routing
+                    # for potentially minutes until the next periodic sync
+                    # refreshes the cache from the (now-empty) radio.
+                    #
+                    # We access mc._contacts directly because the library
+                    # exposes it as a read-only property (mc.contacts) with
+                    # no removal API. The dict is keyed by public_key string.
+                    mc._contacts.pop(public_key, None)
                 else:
                     logger.warning(
                         "Failed to remove contact %s: %s", public_key[:12], remove_result.payload
@@ -131,16 +203,11 @@ async def sync_and_offload_contacts() -> dict:
     return {"synced": synced, "removed": removed}
 
 
-async def sync_and_offload_channels() -> dict:
+async def sync_and_offload_channels(mc: MeshCore) -> dict:
     """
     Sync channels from radio to database, then clear them from radio.
     Returns counts of synced and cleared channels.
     """
-    if not radio_manager.is_connected or radio_manager.meshcore is None:
-        logger.warning("Cannot sync channels: radio not connected")
-        return {"synced": 0, "cleared": 0, "error": "Radio not connected"}
-
-    mc = radio_manager.meshcore
     synced = 0
     cleared = 0
 
@@ -152,29 +219,15 @@ async def sync_and_offload_channels() -> dict:
             if result.type != EventType.CHANNEL_INFO:
                 continue
 
-            payload = result.payload
-            name = payload.get("channel_name", "")
-            secret = payload.get("channel_secret", b"")
-
-            # Skip empty channels
-            if not name or name == "\x00" * len(name) or all(b == 0 for b in secret):
-                continue
-
-            is_hashtag = name.startswith("#")
-
-            # Convert key bytes to hex string
-            key_bytes = secret if isinstance(secret, bytes) else bytes(secret)
-            key_hex = key_bytes.hex().upper()
-
-            # Save to database
-            await ChannelRepository.upsert(
-                key=key_hex,
-                name=name,
-                is_hashtag=is_hashtag,
+            key_hex = await upsert_channel_from_radio_slot(
+                result.payload,
                 on_radio=False,  # We're about to clear it
             )
+            if key_hex is None:
+                continue
+
             synced += 1
-            logger.debug("Synced channel %s: %s", key_hex[:8], name)
+            logger.debug("Synced channel %s: %s", key_hex[:8], result.payload.get("channel_name"))
 
             # Clear from radio (set empty name and zero key)
             try:
@@ -221,33 +274,36 @@ async def ensure_default_channels() -> None:
         )
 
 
-async def sync_and_offload_all() -> dict:
+async def sync_and_offload_all(mc: MeshCore) -> dict:
     """Sync and offload both contacts and channels, then ensure defaults exist."""
     logger.info("Starting full radio sync and offload")
 
-    contacts_result = await sync_and_offload_contacts()
-    channels_result = await sync_and_offload_channels()
+    contacts_result = await sync_and_offload_contacts(mc)
+    channels_result = await sync_and_offload_channels(mc)
 
     # Ensure default channels exist
     await ensure_default_channels()
 
+    # Reload favorites and recent contacts back onto the radio immediately
+    # so favorited contacts don't stay in the on_radio=False limbo until the
+    # next advertisement arrives.  Pass mc directly since the caller already
+    # holds the radio operation lock (asyncio.Lock is not reentrant).
+    reload_result = await sync_recent_contacts_to_radio(force=True, mc=mc)
+
     return {
         "contacts": contacts_result,
         "channels": channels_result,
+        "reloaded": reload_result,
     }
 
 
-async def drain_pending_messages() -> int:
+async def drain_pending_messages(mc: MeshCore) -> int:
     """
     Drain all pending messages from the radio.
 
     Calls get_msg() repeatedly until NO_MORE_MSGS is received.
     Returns the count of messages retrieved.
     """
-    if not radio_manager.is_connected or radio_manager.meshcore is None:
-        return 0
-
-    mc = radio_manager.meshcore
     count = 0
     max_iterations = 100  # Safety limit
 
@@ -269,13 +325,13 @@ async def drain_pending_messages() -> int:
         except asyncio.TimeoutError:
             break
         except Exception as e:
-            logger.debug("Error draining messages: %s", e)
+            logger.warning("Error draining messages: %s", e, exc_info=True)
             break
 
     return count
 
 
-async def poll_for_messages() -> int:
+async def poll_for_messages(mc: MeshCore) -> int:
     """
     Poll the radio for any pending messages (single pass).
 
@@ -284,10 +340,6 @@ async def poll_for_messages() -> int:
 
     Returns the count of messages retrieved.
     """
-    if not radio_manager.is_connected or radio_manager.meshcore is None:
-        return 0
-
-    mc = radio_manager.meshcore
     count = 0
 
     try:
@@ -302,12 +354,12 @@ async def poll_for_messages() -> int:
         elif result.type in (EventType.CONTACT_MSG_RECV, EventType.CHANNEL_MSG_RECV):
             count += 1
             # If we got a message, there might be more - drain them
-            count += await drain_pending_messages()
+            count += await drain_pending_messages(mc)
 
     except asyncio.TimeoutError:
         pass
     except Exception as e:
-        logger.debug("Message poll exception: %s", e)
+        logger.warning("Message poll exception: %s", e, exc_info=True)
 
     return count
 
@@ -318,22 +370,30 @@ async def _message_poll_loop():
         try:
             await asyncio.sleep(MESSAGE_POLL_INTERVAL)
 
+            # Clean up expired pending ACKs every poll cycle so they don't
+            # accumulate when no ACKs arrive (e.g. all recipients out of range).
+            cleanup_expired_acks()
+
             if radio_manager.is_connected and not is_polling_paused():
-                mc = radio_manager.meshcore
-                if mc is not None:
-                    try:
-                        async with radio_manager.radio_operation(
-                            "message_poll_loop",
-                            blocking=False,
-                        ):
-                            await poll_for_messages()
-                    except RadioOperationBusyError:
-                        logger.debug("Skipping message poll: radio busy")
+                try:
+                    async with radio_manager.radio_operation(
+                        "message_poll_loop",
+                        blocking=False,
+                        suspend_auto_fetch=True,
+                    ) as mc:
+                        count = await poll_for_messages(mc)
+                        if count > 0:
+                            logger.warning(
+                                "Poll loop caught %d message(s) missed by auto-fetch",
+                                count,
+                            )
+                except RadioOperationBusyError:
+                    logger.debug("Skipping message poll: radio busy")
 
         except asyncio.CancelledError:
             break
         except Exception as e:
-            logger.debug("Error in message poll loop: %s", e)
+            logger.warning("Error in message poll loop: %s", e, exc_info=True)
 
 
 def start_message_polling():
@@ -357,21 +417,18 @@ async def stop_message_polling():
         logger.info("Stopped periodic message polling")
 
 
-async def send_advertisement(force: bool = False) -> bool:
+async def send_advertisement(mc: MeshCore, *, force: bool = False) -> bool:
     """Send an advertisement to announce presence on the mesh.
 
     Respects the configured advert_interval - won't send if not enough time
     has elapsed since the last advertisement, unless force=True.
 
     Args:
+        mc: The MeshCore instance to use for the advertisement.
         force: If True, send immediately regardless of interval.
 
     Returns True if successful, False otherwise (including if throttled).
     """
-    if not radio_manager.is_connected or radio_manager.meshcore is None:
-        logger.debug("Cannot send advertisement: radio not connected")
-        return False
-
     # Check if enough time has elapsed (unless forced)
     if not force:
         settings = await AppSettingsRepository.get()
@@ -384,6 +441,9 @@ async def send_advertisement(force: bool = False) -> bool:
             logger.debug("Advertisement skipped: periodic advertising is disabled")
             return False
 
+        # Enforce minimum interval floor
+        interval = max(interval, MIN_ADVERT_INTERVAL)
+
         # Check if enough time has passed
         elapsed = now - last_time
         if elapsed < interval:
@@ -397,7 +457,7 @@ async def send_advertisement(force: bool = False) -> bool:
             return False
 
     try:
-        result = await radio_manager.meshcore.commands.send_advert(flood=True)
+        result = await mc.commands.send_advert(flood=True)
         if result.type == EventType.OK:
             # Update last_advert_time in database
             now = int(time.time())
@@ -421,22 +481,19 @@ async def _periodic_advert_loop():
     """
     while True:
         try:
+            await asyncio.sleep(ADVERT_CHECK_INTERVAL)
+
             # Try to send - send_advertisement() handles all checks
             # (disabled, throttled, not connected)
             if radio_manager.is_connected:
-                mc = radio_manager.meshcore
-                if mc is not None:
-                    try:
-                        async with radio_manager.radio_operation(
-                            "periodic_advertisement",
-                            blocking=False,
-                        ):
-                            await send_advertisement()
-                    except RadioOperationBusyError:
-                        logger.debug("Skipping periodic advertisement: radio busy")
-
-            # Sleep before next check
-            await asyncio.sleep(ADVERT_CHECK_INTERVAL)
+                try:
+                    async with radio_manager.radio_operation(
+                        "periodic_advertisement",
+                        blocking=False,
+                    ) as mc:
+                        await send_advertisement(mc)
+                except RadioOperationBusyError:
+                    logger.debug("Skipping periodic advertisement: radio busy")
 
         except asyncio.CancelledError:
             logger.info("Periodic advertisement task cancelled")
@@ -471,16 +528,11 @@ async def stop_periodic_advert():
         logger.info("Stopped periodic advertisement")
 
 
-async def sync_radio_time() -> bool:
+async def sync_radio_time(mc: MeshCore) -> bool:
     """Sync the radio's clock with the system time.
 
     Returns True if successful, False otherwise.
     """
-    mc = radio_manager.meshcore
-    if not mc:
-        logger.debug("Cannot sync time: radio not connected")
-        return False
-
     try:
         now = int(time.time())
         await mc.commands.set_time(now)
@@ -496,18 +548,17 @@ async def _periodic_sync_loop():
     while True:
         try:
             await asyncio.sleep(SYNC_INTERVAL)
-            mc = radio_manager.meshcore
-            if mc is None:
+            if not radio_manager.is_connected:
                 continue
 
             try:
                 async with radio_manager.radio_operation(
                     "periodic_sync",
                     blocking=False,
-                ):
+                ) as mc:
                     logger.debug("Running periodic radio sync")
-                    await sync_and_offload_all()
-                    await sync_radio_time()
+                    await sync_and_offload_all(mc)
+                    await sync_radio_time(mc)
             except RadioOperationBusyError:
                 logger.debug("Skipping periodic sync: radio busy")
         except asyncio.CancelledError:
@@ -543,7 +594,117 @@ _last_contact_sync: float = 0.0
 CONTACT_SYNC_THROTTLE_SECONDS = 30  # Don't sync more than once per 30 seconds
 
 
-async def sync_recent_contacts_to_radio(force: bool = False) -> dict:
+async def _sync_contacts_to_radio_inner(mc: MeshCore) -> dict:
+    """
+    Core logic for loading contacts onto the radio.
+
+    Favorite contacts are prioritized first, then recent non-repeater contacts
+    fill remaining slots up to max_radio_contacts.
+
+    Caller must hold the radio operation lock and pass a valid MeshCore instance.
+    """
+    app_settings = await AppSettingsRepository.get()
+    max_contacts = app_settings.max_radio_contacts
+    selected_contacts: list[Contact] = []
+    selected_keys: set[str] = set()
+
+    favorite_contacts_loaded = 0
+    for favorite in app_settings.favorites:
+        if favorite.type != "contact":
+            continue
+        try:
+            contact = await ContactRepository.get_by_key_or_prefix(favorite.id)
+        except AmbiguousPublicKeyPrefixError:
+            logger.warning(
+                "Skipping favorite contact '%s': ambiguous key prefix; use full key",
+                favorite.id,
+            )
+            continue
+        if not contact:
+            continue
+        key = contact.public_key.lower()
+        if key in selected_keys:
+            continue
+        selected_keys.add(key)
+        selected_contacts.append(contact)
+        favorite_contacts_loaded += 1
+        if len(selected_contacts) >= max_contacts:
+            break
+
+    if len(selected_contacts) < max_contacts:
+        recent_contacts = await ContactRepository.get_recent_non_repeaters(limit=max_contacts)
+        for contact in recent_contacts:
+            key = contact.public_key.lower()
+            if key in selected_keys:
+                continue
+            selected_keys.add(key)
+            selected_contacts.append(contact)
+            if len(selected_contacts) >= max_contacts:
+                break
+
+    logger.debug(
+        "Selected %d contacts to sync (%d favorite contacts first, limit=%d)",
+        len(selected_contacts),
+        favorite_contacts_loaded,
+        max_contacts,
+    )
+
+    loaded = 0
+    already_on_radio = 0
+    failed = 0
+
+    for contact in selected_contacts:
+        # Check if already on radio
+        radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+        if radio_contact:
+            already_on_radio += 1
+            # Update DB if not marked as on_radio
+            if not contact.on_radio:
+                await ContactRepository.set_on_radio(contact.public_key, True)
+            continue
+
+        try:
+            result = await mc.commands.add_contact(contact.to_radio_dict())
+            if result.type == EventType.OK:
+                loaded += 1
+                await ContactRepository.set_on_radio(contact.public_key, True)
+                logger.debug("Loaded contact %s to radio", contact.public_key[:12])
+            else:
+                failed += 1
+                reason = result.payload
+                hint = ""
+                if reason is None:
+                    hint = (
+                        " (no response from radio — if this repeats, check for "
+                        "serial port contention from another process or try a "
+                        "power cycle)"
+                    )
+                logger.warning(
+                    "Failed to load contact %s: %s%s",
+                    contact.public_key[:12],
+                    reason,
+                    hint,
+                )
+        except Exception as e:
+            failed += 1
+            logger.warning("Error loading contact %s: %s", contact.public_key[:12], e)
+
+    if loaded > 0 or failed > 0:
+        logger.info(
+            "Contact sync: loaded %d, already on radio %d, failed %d",
+            loaded,
+            already_on_radio,
+            failed,
+        )
+
+    return {
+        "loaded": loaded,
+        "already_on_radio": already_on_radio,
+        "failed": failed,
+    }
+
+
+async def sync_recent_contacts_to_radio(force: bool = False, mc: MeshCore | None = None) -> dict:
     """
     Load contacts to the radio for DM ACK support.
 
@@ -551,6 +712,12 @@ async def sync_recent_contacts_to_radio(force: bool = False) -> dict:
     fill remaining slots up to max_radio_contacts.
     Only runs at most once every CONTACT_SYNC_THROTTLE_SECONDS unless forced.
 
+    Args:
+        force: Skip the throttle check.
+        mc: Optional MeshCore instance. When provided, the caller already holds
+            the radio operation lock and the inner logic runs directly.
+            When None, this function acquires its own lock.
+
     Returns counts of contacts loaded.
     """
     global _last_contact_sync
@@ -561,112 +728,22 @@ async def sync_recent_contacts_to_radio(force: bool = False) -> dict:
         logger.debug("Contact sync throttled (last sync %ds ago)", int(now - _last_contact_sync))
         return {"loaded": 0, "throttled": True}
 
+    # If caller provided a MeshCore instance, use it directly (caller holds the lock)
+    if mc is not None:
+        _last_contact_sync = now
+        return await _sync_contacts_to_radio_inner(mc)
+
     if not radio_manager.is_connected or radio_manager.meshcore is None:
         logger.debug("Cannot sync contacts to radio: not connected")
         return {"loaded": 0, "error": "Radio not connected"}
 
-    mc = radio_manager.meshcore
-
     try:
         async with radio_manager.radio_operation(
             "sync_recent_contacts_to_radio",
             blocking=False,
-        ):
+        ) as mc:
             _last_contact_sync = now
-
-            # Build prioritized contact list:
-            # 1) favorite contacts, in favorite order
-            # 2) most recent non-repeater contacts (excluding already-selected favorites)
-            app_settings = await AppSettingsRepository.get()
-            max_contacts = app_settings.max_radio_contacts
-            selected_contacts: list[Contact] = []
-            selected_keys: set[str] = set()
-
-            favorite_contacts_loaded = 0
-            for favorite in app_settings.favorites:
-                if favorite.type != "contact":
-                    continue
-                try:
-                    contact = await ContactRepository.get_by_key_or_prefix(favorite.id)
-                except AmbiguousPublicKeyPrefixError:
-                    logger.warning(
-                        "Skipping favorite contact '%s': ambiguous key prefix; use full key",
-                        favorite.id,
-                    )
-                    continue
-                if not contact:
-                    continue
-                key = contact.public_key.lower()
-                if key in selected_keys:
-                    continue
-                selected_keys.add(key)
-                selected_contacts.append(contact)
-                favorite_contacts_loaded += 1
-                if len(selected_contacts) >= max_contacts:
-                    break
-
-            if len(selected_contacts) < max_contacts:
-                recent_contacts = await ContactRepository.get_recent_non_repeaters(
-                    limit=max_contacts
-                )
-                for contact in recent_contacts:
-                    key = contact.public_key.lower()
-                    if key in selected_keys:
-                        continue
-                    selected_keys.add(key)
-                    selected_contacts.append(contact)
-                    if len(selected_contacts) >= max_contacts:
-                        break
-
-            logger.debug(
-                "Selected %d contacts to sync (%d favorite contacts first, limit=%d)",
-                len(selected_contacts),
-                favorite_contacts_loaded,
-                max_contacts,
-            )
-
-            loaded = 0
-            already_on_radio = 0
-            failed = 0
-
-            for contact in selected_contacts:
-                # Check if already on radio
-                radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
-                if radio_contact:
-                    already_on_radio += 1
-                    # Update DB if not marked as on_radio
-                    if not contact.on_radio:
-                        await ContactRepository.set_on_radio(contact.public_key, True)
-                    continue
-
-                try:
-                    result = await mc.commands.add_contact(contact.to_radio_dict())
-                    if result.type == EventType.OK:
-                        loaded += 1
-                        await ContactRepository.set_on_radio(contact.public_key, True)
-                        logger.debug("Loaded contact %s to radio", contact.public_key[:12])
-                    else:
-                        failed += 1
-                        logger.warning(
-                            "Failed to load contact %s: %s", contact.public_key[:12], result.payload
-                        )
-                except Exception as e:
-                    failed += 1
-                    logger.warning("Error loading contact %s: %s", contact.public_key[:12], e)
-
-            if loaded > 0 or failed > 0:
-                logger.info(
-                    "Contact sync: loaded %d, already on radio %d, failed %d",
-                    loaded,
-                    already_on_radio,
-                    failed,
-                )
-
-            return {
-                "loaded": loaded,
-                "already_on_radio": already_on_radio,
-                "failed": failed,
-            }
+            return await _sync_contacts_to_radio_inner(mc)
     except RadioOperationBusyError:
         logger.debug("Skipping contact sync to radio: radio busy")
         return {"loaded": 0, "busy": True}

app/repository.py

@@ -1,981 +0,0 @@
-import json
-import logging
-import sqlite3
-import time
-from hashlib import sha256
-from typing import Any, Literal
-
-from app.database import db
-from app.decoder import PayloadType, extract_payload, get_packet_payload_type
-from app.models import (
-    AppSettings,
-    BotConfig,
-    Channel,
-    Contact,
-    Favorite,
-    Message,
-    MessagePath,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AmbiguousPublicKeyPrefixError(ValueError):
-    """Raised when a public key prefix matches multiple contacts."""
-
-    def __init__(self, prefix: str, matches: list[str]):
-        self.prefix = prefix.lower()
-        self.matches = matches
-        super().__init__(f"Ambiguous public key prefix '{self.prefix}'")
-
-
-class ContactRepository:
-    @staticmethod
-    async def upsert(contact: dict[str, Any]) -> None:
-        await db.conn.execute(
-            """
-            INSERT INTO contacts (public_key, name, type, flags, last_path, last_path_len,
-                                  last_advert, lat, lon, last_seen, on_radio, last_contacted)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(public_key) DO UPDATE SET
-                name = COALESCE(excluded.name, contacts.name),
-                type = CASE WHEN excluded.type = 0 THEN contacts.type ELSE excluded.type END,
-                flags = excluded.flags,
-                last_path = COALESCE(excluded.last_path, contacts.last_path),
-                last_path_len = excluded.last_path_len,
-                last_advert = COALESCE(excluded.last_advert, contacts.last_advert),
-                lat = COALESCE(excluded.lat, contacts.lat),
-                lon = COALESCE(excluded.lon, contacts.lon),
-                last_seen = excluded.last_seen,
-                on_radio = excluded.on_radio,
-                last_contacted = COALESCE(excluded.last_contacted, contacts.last_contacted)
-            """,
-            (
-                contact.get("public_key", "").lower(),
-                contact.get("name") or contact.get("adv_name"),
-                contact.get("type", 0),
-                contact.get("flags", 0),
-                contact.get("last_path") or contact.get("out_path"),
-                contact.get("last_path_len")
-                if "last_path_len" in contact
-                else contact.get("out_path_len", -1),
-                contact.get("last_advert"),
-                contact.get("lat") if contact.get("lat") is not None else contact.get("adv_lat"),
-                contact.get("lon") if contact.get("lon") is not None else contact.get("adv_lon"),
-                contact.get("last_seen", int(time.time())),
-                contact.get("on_radio", False),
-                contact.get("last_contacted"),
-            ),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    def _row_to_contact(row) -> Contact:
-        """Convert a database row to a Contact model."""
-        return Contact(
-            public_key=row["public_key"],
-            name=row["name"],
-            type=row["type"],
-            flags=row["flags"],
-            last_path=row["last_path"],
-            last_path_len=row["last_path_len"],
-            last_advert=row["last_advert"],
-            lat=row["lat"],
-            lon=row["lon"],
-            last_seen=row["last_seen"],
-            on_radio=bool(row["on_radio"]),
-            last_contacted=row["last_contacted"],
-            last_read_at=row["last_read_at"],
-        )
-
-    @staticmethod
-    async def get_by_key(public_key: str) -> Contact | None:
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE public_key = ?", (public_key.lower(),)
-        )
-        row = await cursor.fetchone()
-        return ContactRepository._row_to_contact(row) if row else None
-
-    @staticmethod
-    async def get_by_key_prefix(prefix: str) -> Contact | None:
-        """Get a contact by key prefix only if it resolves uniquely.
-
-        Returns None when no contacts match OR when multiple contacts match
-        the prefix (to avoid silently selecting the wrong contact).
-        """
-        normalized_prefix = prefix.lower()
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT 2",
-            (f"{normalized_prefix}%",),
-        )
-        rows = list(await cursor.fetchall())
-        if len(rows) != 1:
-            return None
-        return ContactRepository._row_to_contact(rows[0])
-
-    @staticmethod
-    async def _get_prefix_matches(prefix: str, limit: int = 2) -> list[Contact]:
-        """Get contacts matching a key prefix, up to limit."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT ?",
-            (f"{prefix.lower()}%", limit),
-        )
-        rows = list(await cursor.fetchall())
-        return [ContactRepository._row_to_contact(row) for row in rows]
-
-    @staticmethod
-    async def get_by_key_or_prefix(key_or_prefix: str) -> Contact | None:
-        """Get a contact by exact key match, falling back to prefix match.
-
-        Useful when the input might be a full 64-char public key or a shorter prefix.
-        """
-        contact = await ContactRepository.get_by_key(key_or_prefix)
-        if contact:
-            return contact
-
-        matches = await ContactRepository._get_prefix_matches(key_or_prefix, limit=2)
-        if len(matches) == 1:
-            return matches[0]
-        if len(matches) > 1:
-            raise AmbiguousPublicKeyPrefixError(
-                key_or_prefix,
-                [m.public_key for m in matches],
-            )
-        return None
-
-    @staticmethod
-    async def get_all(limit: int = 100, offset: int = 0) -> list[Contact]:
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts ORDER BY COALESCE(name, public_key) LIMIT ? OFFSET ?",
-            (limit, offset),
-        )
-        rows = await cursor.fetchall()
-        return [ContactRepository._row_to_contact(row) for row in rows]
-
-    @staticmethod
-    async def get_recent_non_repeaters(limit: int = 200) -> list[Contact]:
-        """Get the most recently active non-repeater contacts.
-
-        Orders by most recent activity (last_contacted or last_advert),
-        excluding repeaters (type=2).
-        """
-        cursor = await db.conn.execute(
-            """
-            SELECT * FROM contacts
-            WHERE type != 2
-            ORDER BY COALESCE(last_contacted, 0) DESC, COALESCE(last_advert, 0) DESC
-            LIMIT ?
-            """,
-            (limit,),
-        )
-        rows = await cursor.fetchall()
-        return [ContactRepository._row_to_contact(row) for row in rows]
-
-    @staticmethod
-    async def update_path(public_key: str, path: str, path_len: int) -> None:
-        await db.conn.execute(
-            "UPDATE contacts SET last_path = ?, last_path_len = ?, last_seen = ? WHERE public_key = ?",
-            (path, path_len, int(time.time()), public_key.lower()),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def set_on_radio(public_key: str, on_radio: bool) -> None:
-        await db.conn.execute(
-            "UPDATE contacts SET on_radio = ? WHERE public_key = ?",
-            (on_radio, public_key.lower()),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def delete(public_key: str) -> None:
-        await db.conn.execute(
-            "DELETE FROM contacts WHERE public_key = ?",
-            (public_key.lower(),),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def update_last_contacted(public_key: str, timestamp: int | None = None) -> None:
-        """Update the last_contacted timestamp for a contact."""
-        ts = timestamp if timestamp is not None else int(time.time())
-        await db.conn.execute(
-            "UPDATE contacts SET last_contacted = ?, last_seen = ? WHERE public_key = ?",
-            (ts, ts, public_key.lower()),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def update_last_read_at(public_key: str, timestamp: int | None = None) -> bool:
-        """Update the last_read_at timestamp for a contact.
-
-        Returns True if a row was updated, False if contact not found.
-        """
-        ts = timestamp if timestamp is not None else int(time.time())
-        cursor = await db.conn.execute(
-            "UPDATE contacts SET last_read_at = ? WHERE public_key = ?",
-            (ts, public_key.lower()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
-
-    @staticmethod
-    async def mark_all_read(timestamp: int) -> None:
-        """Mark all contacts as read at the given timestamp."""
-        await db.conn.execute("UPDATE contacts SET last_read_at = ?", (timestamp,))
-        await db.conn.commit()
-
-    @staticmethod
-    async def get_by_pubkey_first_byte(hex_byte: str) -> list[Contact]:
-        """Get contacts whose public key starts with the given hex byte (2 chars)."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE substr(public_key, 1, 2) = ?",
-            (hex_byte.lower(),),
-        )
-        rows = await cursor.fetchall()
-        return [ContactRepository._row_to_contact(row) for row in rows]
-
-
-class ChannelRepository:
-    @staticmethod
-    async def upsert(key: str, name: str, is_hashtag: bool = False, on_radio: bool = False) -> None:
-        """Upsert a channel. Key is 32-char hex string."""
-        await db.conn.execute(
-            """
-            INSERT INTO channels (key, name, is_hashtag, on_radio)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(key) DO UPDATE SET
-                name = excluded.name,
-                is_hashtag = excluded.is_hashtag,
-                on_radio = excluded.on_radio
-            """,
-            (key.upper(), name, is_hashtag, on_radio),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def get_by_key(key: str) -> Channel | None:
-        """Get a channel by its key (32-char hex string)."""
-        cursor = await db.conn.execute(
-            "SELECT key, name, is_hashtag, on_radio, last_read_at FROM channels WHERE key = ?",
-            (key.upper(),),
-        )
-        row = await cursor.fetchone()
-        if row:
-            return Channel(
-                key=row["key"],
-                name=row["name"],
-                is_hashtag=bool(row["is_hashtag"]),
-                on_radio=bool(row["on_radio"]),
-                last_read_at=row["last_read_at"],
-            )
-        return None
-
-    @staticmethod
-    async def get_all() -> list[Channel]:
-        cursor = await db.conn.execute(
-            "SELECT key, name, is_hashtag, on_radio, last_read_at FROM channels ORDER BY name"
-        )
-        rows = await cursor.fetchall()
-        return [
-            Channel(
-                key=row["key"],
-                name=row["name"],
-                is_hashtag=bool(row["is_hashtag"]),
-                on_radio=bool(row["on_radio"]),
-                last_read_at=row["last_read_at"],
-            )
-            for row in rows
-        ]
-
-    @staticmethod
-    async def delete(key: str) -> None:
-        """Delete a channel by key."""
-        await db.conn.execute(
-            "DELETE FROM channels WHERE key = ?",
-            (key.upper(),),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def update_last_read_at(key: str, timestamp: int | None = None) -> bool:
-        """Update the last_read_at timestamp for a channel.
-
-        Returns True if a row was updated, False if channel not found.
-        """
-        ts = timestamp if timestamp is not None else int(time.time())
-        cursor = await db.conn.execute(
-            "UPDATE channels SET last_read_at = ? WHERE key = ?",
-            (ts, key.upper()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
-
-    @staticmethod
-    async def mark_all_read(timestamp: int) -> None:
-        """Mark all channels as read at the given timestamp."""
-        await db.conn.execute("UPDATE channels SET last_read_at = ?", (timestamp,))
-        await db.conn.commit()
-
-
-class MessageRepository:
-    @staticmethod
-    def _parse_paths(paths_json: str | None) -> list[MessagePath] | None:
-        """Parse paths JSON string to list of MessagePath objects."""
-        if not paths_json:
-            return None
-        try:
-            paths_data = json.loads(paths_json)
-            return [MessagePath(**p) for p in paths_data]
-        except (json.JSONDecodeError, TypeError, KeyError):
-            return None
-
-    @staticmethod
-    async def create(
-        msg_type: str,
-        text: str,
-        received_at: int,
-        conversation_key: str,
-        sender_timestamp: int | None = None,
-        path: str | None = None,
-        txt_type: int = 0,
-        signature: str | None = None,
-        outgoing: bool = False,
-    ) -> int | None:
-        """Create a message, returning the ID or None if duplicate.
-
-        Uses INSERT OR IGNORE to handle the UNIQUE constraint on
-        (type, conversation_key, text, sender_timestamp). This prevents
-        duplicate messages when the same message arrives via multiple RF paths.
-
-        The path parameter is converted to the paths JSON array format.
-        """
-        # Convert single path to paths array format
-        paths_json = None
-        if path is not None:
-            paths_json = json.dumps([{"path": path, "received_at": received_at}])
-
-        cursor = await db.conn.execute(
-            """
-            INSERT OR IGNORE INTO messages (type, conversation_key, text, sender_timestamp,
-                                            received_at, paths, txt_type, signature, outgoing)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-            (
-                msg_type,
-                conversation_key,
-                text,
-                sender_timestamp,
-                received_at,
-                paths_json,
-                txt_type,
-                signature,
-                outgoing,
-            ),
-        )
-        await db.conn.commit()
-        # rowcount is 0 if INSERT was ignored due to UNIQUE constraint violation
-        if cursor.rowcount == 0:
-            return None
-        return cursor.lastrowid
-
-    @staticmethod
-    async def add_path(
-        message_id: int, path: str, received_at: int | None = None
-    ) -> list[MessagePath]:
-        """Add a new path to an existing message.
-
-        This is used when a repeat/echo of a message arrives via a different route.
-        Returns the updated list of paths.
-        """
-        ts = received_at if received_at is not None else int(time.time())
-
-        # Atomic append: use json_insert to avoid read-modify-write race when
-        # multiple duplicate packets arrive concurrently for the same message.
-        new_entry = json.dumps({"path": path, "received_at": ts})
-        await db.conn.execute(
-            """UPDATE messages SET paths = json_insert(
-                COALESCE(paths, '[]'), '$[#]', json(?)
-            ) WHERE id = ?""",
-            (new_entry, message_id),
-        )
-        await db.conn.commit()
-
-        # Read back the full list for the return value
-        cursor = await db.conn.execute("SELECT paths FROM messages WHERE id = ?", (message_id,))
-        row = await cursor.fetchone()
-        if not row or not row["paths"]:
-            return []
-
-        try:
-            all_paths = json.loads(row["paths"])
-        except json.JSONDecodeError:
-            return []
-
-        return [MessagePath(**p) for p in all_paths]
-
-    @staticmethod
-    async def claim_prefix_messages(full_key: str) -> int:
-        """Promote prefix-stored messages to the full conversation key.
-
-        When a full key becomes known for a contact, any messages stored with
-        only a prefix as conversation_key are updated to use the full key.
-        """
-        lower_key = full_key.lower()
-        cursor = await db.conn.execute(
-            """UPDATE messages SET conversation_key = ?
-               WHERE type = 'PRIV' AND length(conversation_key) < 64
-               AND ? LIKE conversation_key || '%'
-               AND (
-                   SELECT COUNT(*) FROM contacts
-                   WHERE public_key LIKE messages.conversation_key || '%'
-               ) = 1""",
-            (lower_key, lower_key),
-        )
-        await db.conn.commit()
-        return cursor.rowcount
-
-    @staticmethod
-    async def get_all(
-        limit: int = 100,
-        offset: int = 0,
-        msg_type: str | None = None,
-        conversation_key: str | None = None,
-        before: int | None = None,
-        before_id: int | None = None,
-    ) -> list[Message]:
-        query = "SELECT * FROM messages WHERE 1=1"
-        params: list[Any] = []
-
-        if msg_type:
-            query += " AND type = ?"
-            params.append(msg_type)
-        if conversation_key:
-            normalized_key = conversation_key
-            # Prefer exact matching for full keys.
-            if len(conversation_key) == 64:
-                normalized_key = conversation_key.lower()
-                query += " AND conversation_key = ?"
-                params.append(normalized_key)
-            elif len(conversation_key) == 32:
-                normalized_key = conversation_key.upper()
-                query += " AND conversation_key = ?"
-                params.append(normalized_key)
-            else:
-                # Prefix match is only for legacy/partial key callers.
-                query += " AND conversation_key LIKE ?"
-                params.append(f"{conversation_key}%")
-
-        if before is not None and before_id is not None:
-            query += " AND (received_at < ? OR (received_at = ? AND id < ?))"
-            params.extend([before, before, before_id])
-
-        query += " ORDER BY received_at DESC, id DESC LIMIT ?"
-        params.append(limit)
-        if before is None or before_id is None:
-            query += " OFFSET ?"
-            params.append(offset)
-
-        cursor = await db.conn.execute(query, params)
-        rows = await cursor.fetchall()
-        return [
-            Message(
-                id=row["id"],
-                type=row["type"],
-                conversation_key=row["conversation_key"],
-                text=row["text"],
-                sender_timestamp=row["sender_timestamp"],
-                received_at=row["received_at"],
-                paths=MessageRepository._parse_paths(row["paths"]),
-                txt_type=row["txt_type"],
-                signature=row["signature"],
-                outgoing=bool(row["outgoing"]),
-                acked=row["acked"],
-            )
-            for row in rows
-        ]
-
-    @staticmethod
-    async def increment_ack_count(message_id: int) -> int:
-        """Increment ack count and return the new value."""
-        await db.conn.execute("UPDATE messages SET acked = acked + 1 WHERE id = ?", (message_id,))
-        await db.conn.commit()
-        cursor = await db.conn.execute("SELECT acked FROM messages WHERE id = ?", (message_id,))
-        row = await cursor.fetchone()
-        return row["acked"] if row else 1
-
-    @staticmethod
-    async def get_ack_count(message_id: int) -> int:
-        """Get the current ack count for a message."""
-        cursor = await db.conn.execute("SELECT acked FROM messages WHERE id = ?", (message_id,))
-        row = await cursor.fetchone()
-        return row["acked"] if row else 0
-
-    @staticmethod
-    async def get_by_content(
-        msg_type: str,
-        conversation_key: str,
-        text: str,
-        sender_timestamp: int | None,
-    ) -> "Message | None":
-        """Look up a message by its unique content fields."""
-        cursor = await db.conn.execute(
-            """
-            SELECT id, type, conversation_key, text, sender_timestamp, received_at,
-                   paths, txt_type, signature, outgoing, acked
-            FROM messages
-            WHERE type = ? AND conversation_key = ? AND text = ?
-              AND (sender_timestamp = ? OR (sender_timestamp IS NULL AND ? IS NULL))
-            """,
-            (msg_type, conversation_key, text, sender_timestamp, sender_timestamp),
-        )
-        row = await cursor.fetchone()
-        if not row:
-            return None
-
-        paths = None
-        if row["paths"]:
-            try:
-                paths_data = json.loads(row["paths"])
-                paths = [
-                    MessagePath(path=p["path"], received_at=p["received_at"]) for p in paths_data
-                ]
-            except (json.JSONDecodeError, KeyError):
-                pass
-
-        return Message(
-            id=row["id"],
-            type=row["type"],
-            conversation_key=row["conversation_key"],
-            text=row["text"],
-            sender_timestamp=row["sender_timestamp"],
-            received_at=row["received_at"],
-            paths=paths,
-            txt_type=row["txt_type"],
-            signature=row["signature"],
-            outgoing=bool(row["outgoing"]),
-            acked=row["acked"],
-        )
-
-    @staticmethod
-    async def get_unread_counts(name: str | None = None) -> dict:
-        """Get unread message counts, mention flags, and last message times for all conversations.
-
-        Args:
-            name: User's display name for @[name] mention detection. If None, mentions are skipped.
-
-        Returns:
-            Dict with 'counts', 'mentions', and 'last_message_times' keys.
-        """
-        counts: dict[str, int] = {}
-        mention_flags: dict[str, bool] = {}
-        last_message_times: dict[str, int] = {}
-
-        mention_token = f"@[{name}]" if name else None
-
-        # Channel unreads
-        cursor = await db.conn.execute(
-            """
-            SELECT m.conversation_key,
-                   COUNT(*) as unread_count,
-                   MAX(m.received_at) as last_message_time,
-                   SUM(CASE
-                           WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
-                           ELSE 0
-                       END) > 0 as has_mention
-            FROM messages m
-            JOIN channels c ON m.conversation_key = c.key
-            WHERE m.type = 'CHAN' AND m.outgoing = 0
-              AND m.received_at > COALESCE(c.last_read_at, 0)
-            GROUP BY m.conversation_key
-            """,
-            (mention_token or "", mention_token or ""),
-        )
-        rows = await cursor.fetchall()
-        for row in rows:
-            state_key = f"channel-{row['conversation_key']}"
-            counts[state_key] = row["unread_count"]
-            if mention_token and row["has_mention"]:
-                mention_flags[state_key] = True
-
-        # Contact unreads
-        cursor = await db.conn.execute(
-            """
-            SELECT m.conversation_key,
-                   COUNT(*) as unread_count,
-                   MAX(m.received_at) as last_message_time,
-                   SUM(CASE
-                           WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
-                           ELSE 0
-                       END) > 0 as has_mention
-            FROM messages m
-            JOIN contacts ct ON m.conversation_key = ct.public_key
-            WHERE m.type = 'PRIV' AND m.outgoing = 0
-              AND m.received_at > COALESCE(ct.last_read_at, 0)
-            GROUP BY m.conversation_key
-            """,
-            (mention_token or "", mention_token or ""),
-        )
-        rows = await cursor.fetchall()
-        for row in rows:
-            state_key = f"contact-{row['conversation_key']}"
-            counts[state_key] = row["unread_count"]
-            if mention_token and row["has_mention"]:
-                mention_flags[state_key] = True
-
-        # Last message times for all conversations (including read ones)
-        cursor = await db.conn.execute(
-            """
-            SELECT type, conversation_key, MAX(received_at) as last_message_time
-            FROM messages
-            GROUP BY type, conversation_key
-            """
-        )
-        rows = await cursor.fetchall()
-        for row in rows:
-            prefix = "channel" if row["type"] == "CHAN" else "contact"
-            state_key = f"{prefix}-{row['conversation_key']}"
-            last_message_times[state_key] = row["last_message_time"]
-
-        return {
-            "counts": counts,
-            "mentions": mention_flags,
-            "last_message_times": last_message_times,
-        }
-
-
-class RawPacketRepository:
-    @staticmethod
-    async def create(data: bytes, timestamp: int | None = None) -> tuple[int, bool]:
-        """
-        Create a raw packet with payload-based deduplication.
-
-        Returns (packet_id, is_new) tuple:
-        - is_new=True: New packet stored, packet_id is the new row ID
-        - is_new=False: Duplicate payload detected, packet_id is the existing row ID
-
-        Deduplication is based on the SHA-256 hash of the packet payload
-        (excluding routing/path information).
-        """
-        ts = timestamp if timestamp is not None else int(time.time())
-
-        # Compute payload hash for deduplication
-        payload = extract_payload(data)
-        if payload:
-            payload_hash = sha256(payload).hexdigest()
-        else:
-            # For malformed packets, hash the full data
-            payload_hash = sha256(data).hexdigest()
-
-        # Check if this payload already exists
-        cursor = await db.conn.execute(
-            "SELECT id FROM raw_packets WHERE payload_hash = ?", (payload_hash,)
-        )
-        existing = await cursor.fetchone()
-
-        if existing:
-            # Duplicate - return existing packet ID
-            logger.debug(
-                "Duplicate payload detected (hash=%s..., existing_id=%d)",
-                payload_hash[:12],
-                existing["id"],
-            )
-            return (existing["id"], False)
-
-        # New packet - insert with hash
-        try:
-            cursor = await db.conn.execute(
-                "INSERT INTO raw_packets (timestamp, data, payload_hash) VALUES (?, ?, ?)",
-                (ts, data, payload_hash),
-            )
-            await db.conn.commit()
-            assert cursor.lastrowid is not None  # INSERT always returns a row ID
-            return (cursor.lastrowid, True)
-        except sqlite3.IntegrityError:
-            # Race condition: another insert with same payload_hash happened between
-            # our SELECT and INSERT. This is expected for duplicate packets arriving
-            # close together. Query again to get the existing ID.
-            logger.debug(
-                "Duplicate packet detected via race condition (payload_hash=%s), dropping",
-                payload_hash[:16],
-            )
-            cursor = await db.conn.execute(
-                "SELECT id FROM raw_packets WHERE payload_hash = ?", (payload_hash,)
-            )
-            existing = await cursor.fetchone()
-            if existing:
-                return (existing["id"], False)
-            # This shouldn't happen, but if it does, re-raise
-            raise
-
-    @staticmethod
-    async def get_undecrypted_count() -> int:
-        """Get count of undecrypted packets (those without a linked message)."""
-        cursor = await db.conn.execute(
-            "SELECT COUNT(*) as count FROM raw_packets WHERE message_id IS NULL"
-        )
-        row = await cursor.fetchone()
-        return row["count"] if row else 0
-
-    @staticmethod
-    async def get_oldest_undecrypted() -> int | None:
-        """Get timestamp of oldest undecrypted packet, or None if none exist."""
-        cursor = await db.conn.execute(
-            "SELECT MIN(timestamp) as oldest FROM raw_packets WHERE message_id IS NULL"
-        )
-        row = await cursor.fetchone()
-        return row["oldest"] if row and row["oldest"] is not None else None
-
-    @staticmethod
-    async def get_all_undecrypted() -> list[tuple[int, bytes, int]]:
-        """Get all undecrypted packets as (id, data, timestamp) tuples."""
-        cursor = await db.conn.execute(
-            "SELECT id, data, timestamp FROM raw_packets WHERE message_id IS NULL ORDER BY timestamp ASC"
-        )
-        rows = await cursor.fetchall()
-        return [(row["id"], bytes(row["data"]), row["timestamp"]) for row in rows]
-
-    @staticmethod
-    async def mark_decrypted(packet_id: int, message_id: int) -> None:
-        """Link a raw packet to its decrypted message."""
-        await db.conn.execute(
-            "UPDATE raw_packets SET message_id = ? WHERE id = ?",
-            (message_id, packet_id),
-        )
-        await db.conn.commit()
-
-    @staticmethod
-    async def prune_old_undecrypted(max_age_days: int) -> int:
-        """Delete undecrypted packets older than max_age_days. Returns count deleted."""
-        cutoff = int(time.time()) - (max_age_days * 86400)
-        cursor = await db.conn.execute(
-            "DELETE FROM raw_packets WHERE message_id IS NULL AND timestamp < ?",
-            (cutoff,),
-        )
-        await db.conn.commit()
-        return cursor.rowcount
-
-    @staticmethod
-    async def get_undecrypted_text_messages() -> list[tuple[int, bytes, int]]:
-        """Get all undecrypted TEXT_MESSAGE packets as (id, data, timestamp) tuples.
-
-        Filters raw packets to only include those with PayloadType.TEXT_MESSAGE (0x02).
-        These are direct messages that can be decrypted with contact ECDH keys.
-        """
-        cursor = await db.conn.execute(
-            "SELECT id, data, timestamp FROM raw_packets WHERE message_id IS NULL ORDER BY timestamp ASC"
-        )
-        rows = await cursor.fetchall()
-
-        # Filter for TEXT_MESSAGE packets
-        result = []
-        for row in rows:
-            data = bytes(row["data"])
-            payload_type = get_packet_payload_type(data)
-            if payload_type == PayloadType.TEXT_MESSAGE:
-                result.append((row["id"], data, row["timestamp"]))
-
-        return result
-
-
-class AppSettingsRepository:
-    """Repository for app_settings table (single-row pattern)."""
-
-    @staticmethod
-    async def get() -> AppSettings:
-        """Get the current app settings.
-
-        Always returns settings - creates default row if needed (migration handles initial row).
-        """
-        cursor = await db.conn.execute(
-            """
-            SELECT max_radio_contacts, experimental_channel_double_send,
-                   favorites, auto_decrypt_dm_on_advert,
-                   sidebar_sort_order, last_message_times, preferences_migrated,
-                   advert_interval, last_advert_time, bots
-            FROM app_settings WHERE id = 1
-            """
-        )
-        row = await cursor.fetchone()
-
-        if not row:
-            # Should not happen after migration, but handle gracefully
-            return AppSettings()
-
-        # Parse favorites JSON
-        favorites = []
-        if row["favorites"]:
-            try:
-                favorites_data = json.loads(row["favorites"])
-                favorites = [Favorite(**f) for f in favorites_data]
-            except (json.JSONDecodeError, TypeError, KeyError) as e:
-                logger.warning(
-                    "Failed to parse favorites JSON, using empty list: %s (data=%r)",
-                    e,
-                    row["favorites"][:100] if row["favorites"] else None,
-                )
-                favorites = []
-
-        # Parse last_message_times JSON
-        last_message_times: dict[str, int] = {}
-        if row["last_message_times"]:
-            try:
-                last_message_times = json.loads(row["last_message_times"])
-            except (json.JSONDecodeError, TypeError) as e:
-                logger.warning(
-                    "Failed to parse last_message_times JSON, using empty dict: %s",
-                    e,
-                )
-                last_message_times = {}
-
-        # Parse bots JSON
-        bots: list[BotConfig] = []
-        if row["bots"]:
-            try:
-                bots_data = json.loads(row["bots"])
-                bots = [BotConfig(**b) for b in bots_data]
-            except (json.JSONDecodeError, TypeError, KeyError) as e:
-                logger.warning(
-                    "Failed to parse bots JSON, using empty list: %s (data=%r)",
-                    e,
-                    row["bots"][:100] if row["bots"] else None,
-                )
-                bots = []
-
-        # Validate sidebar_sort_order (fallback to "recent" if invalid)
-        sort_order = row["sidebar_sort_order"]
-        if sort_order not in ("recent", "alpha"):
-            sort_order = "recent"
-
-        return AppSettings(
-            max_radio_contacts=row["max_radio_contacts"],
-            experimental_channel_double_send=bool(row["experimental_channel_double_send"]),
-            favorites=favorites,
-            auto_decrypt_dm_on_advert=bool(row["auto_decrypt_dm_on_advert"]),
-            sidebar_sort_order=sort_order,
-            last_message_times=last_message_times,
-            preferences_migrated=bool(row["preferences_migrated"]),
-            advert_interval=row["advert_interval"] or 0,
-            last_advert_time=row["last_advert_time"] or 0,
-            bots=bots,
-        )
-
-    @staticmethod
-    async def update(
-        max_radio_contacts: int | None = None,
-        experimental_channel_double_send: bool | None = None,
-        favorites: list[Favorite] | None = None,
-        auto_decrypt_dm_on_advert: bool | None = None,
-        sidebar_sort_order: str | None = None,
-        last_message_times: dict[str, int] | None = None,
-        preferences_migrated: bool | None = None,
-        advert_interval: int | None = None,
-        last_advert_time: int | None = None,
-        bots: list[BotConfig] | None = None,
-    ) -> AppSettings:
-        """Update app settings. Only provided fields are updated."""
-        updates = []
-        params: list[Any] = []
-
-        if max_radio_contacts is not None:
-            updates.append("max_radio_contacts = ?")
-            params.append(max_radio_contacts)
-
-        if experimental_channel_double_send is not None:
-            updates.append("experimental_channel_double_send = ?")
-            params.append(1 if experimental_channel_double_send else 0)
-
-        if favorites is not None:
-            updates.append("favorites = ?")
-            favorites_json = json.dumps([f.model_dump() for f in favorites])
-            params.append(favorites_json)
-
-        if auto_decrypt_dm_on_advert is not None:
-            updates.append("auto_decrypt_dm_on_advert = ?")
-            params.append(1 if auto_decrypt_dm_on_advert else 0)
-
-        if sidebar_sort_order is not None:
-            updates.append("sidebar_sort_order = ?")
-            params.append(sidebar_sort_order)
-
-        if last_message_times is not None:
-            updates.append("last_message_times = ?")
-            params.append(json.dumps(last_message_times))
-
-        if preferences_migrated is not None:
-            updates.append("preferences_migrated = ?")
-            params.append(1 if preferences_migrated else 0)
-
-        if advert_interval is not None:
-            updates.append("advert_interval = ?")
-            params.append(advert_interval)
-
-        if last_advert_time is not None:
-            updates.append("last_advert_time = ?")
-            params.append(last_advert_time)
-
-        if bots is not None:
-            updates.append("bots = ?")
-            bots_json = json.dumps([b.model_dump() for b in bots])
-            params.append(bots_json)
-
-        if updates:
-            query = f"UPDATE app_settings SET {', '.join(updates)} WHERE id = 1"
-            await db.conn.execute(query, params)
-            await db.conn.commit()
-
-        return await AppSettingsRepository.get()
-
-    @staticmethod
-    async def add_favorite(fav_type: Literal["channel", "contact"], fav_id: str) -> AppSettings:
-        """Add a favorite, avoiding duplicates."""
-        settings = await AppSettingsRepository.get()
-
-        # Check if already favorited
-        if any(f.type == fav_type and f.id == fav_id for f in settings.favorites):
-            return settings
-
-        new_favorites = settings.favorites + [Favorite(type=fav_type, id=fav_id)]
-        return await AppSettingsRepository.update(favorites=new_favorites)
-
-    @staticmethod
-    async def remove_favorite(fav_type: Literal["channel", "contact"], fav_id: str) -> AppSettings:
-        """Remove a favorite."""
-        settings = await AppSettingsRepository.get()
-        new_favorites = [
-            f for f in settings.favorites if not (f.type == fav_type and f.id == fav_id)
-        ]
-        return await AppSettingsRepository.update(favorites=new_favorites)
-
-    @staticmethod
-    async def migrate_preferences_from_frontend(
-        favorites: list[dict],
-        sort_order: str,
-        last_message_times: dict[str, int],
-    ) -> tuple[AppSettings, bool]:
-        """Migrate all preferences from frontend localStorage.
-
-        This is a one-time migration. If already migrated, returns current settings
-        without overwriting. Returns (settings, did_migrate) tuple.
-        """
-        settings = await AppSettingsRepository.get()
-
-        if settings.preferences_migrated:
-            # Already migrated, don't overwrite
-            return settings, False
-
-        # Convert frontend favorites format to Favorite objects
-        new_favorites = []
-        for f in favorites:
-            if f.get("type") in ("channel", "contact") and f.get("id"):
-                new_favorites.append(Favorite(type=f["type"], id=f["id"]))
-
-        # Update with migrated preferences and mark as migrated
-        settings = await AppSettingsRepository.update(
-            favorites=new_favorites,
-            sidebar_sort_order=sort_order if sort_order in ("recent", "alpha") else "recent",
-            last_message_times=last_message_times,
-            preferences_migrated=True,
-        )
-
-        return settings, True

app/repository/__init__.py

@@ -0,0 +1,24 @@
+from app.repository.channels import ChannelRepository
+from app.repository.contacts import (
+    AmbiguousPublicKeyPrefixError,
+    ContactAdvertPathRepository,
+    ContactNameHistoryRepository,
+    ContactRepository,
+)
+from app.repository.fanout import FanoutConfigRepository
+from app.repository.messages import MessageRepository
+from app.repository.raw_packets import RawPacketRepository
+from app.repository.settings import AppSettingsRepository, StatisticsRepository
+
+__all__ = [
+    "AmbiguousPublicKeyPrefixError",
+    "AppSettingsRepository",
+    "ChannelRepository",
+    "ContactAdvertPathRepository",
+    "ContactNameHistoryRepository",
+    "ContactRepository",
+    "FanoutConfigRepository",
+    "MessageRepository",
+    "RawPacketRepository",
+    "StatisticsRepository",
+]

app/repository/channels.py

@@ -0,0 +1,86 @@
+import time
+
+from app.database import db
+from app.models import Channel
+
+
+class ChannelRepository:
+    @staticmethod
+    async def upsert(key: str, name: str, is_hashtag: bool = False, on_radio: bool = False) -> None:
+        """Upsert a channel. Key is 32-char hex string."""
+        await db.conn.execute(
+            """
+            INSERT INTO channels (key, name, is_hashtag, on_radio)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(key) DO UPDATE SET
+                name = excluded.name,
+                is_hashtag = excluded.is_hashtag,
+                on_radio = excluded.on_radio
+            """,
+            (key.upper(), name, is_hashtag, on_radio),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def get_by_key(key: str) -> Channel | None:
+        """Get a channel by its key (32-char hex string)."""
+        cursor = await db.conn.execute(
+            "SELECT key, name, is_hashtag, on_radio, last_read_at FROM channels WHERE key = ?",
+            (key.upper(),),
+        )
+        row = await cursor.fetchone()
+        if row:
+            return Channel(
+                key=row["key"],
+                name=row["name"],
+                is_hashtag=bool(row["is_hashtag"]),
+                on_radio=bool(row["on_radio"]),
+                last_read_at=row["last_read_at"],
+            )
+        return None
+
+    @staticmethod
+    async def get_all() -> list[Channel]:
+        cursor = await db.conn.execute(
+            "SELECT key, name, is_hashtag, on_radio, last_read_at FROM channels ORDER BY name"
+        )
+        rows = await cursor.fetchall()
+        return [
+            Channel(
+                key=row["key"],
+                name=row["name"],
+                is_hashtag=bool(row["is_hashtag"]),
+                on_radio=bool(row["on_radio"]),
+                last_read_at=row["last_read_at"],
+            )
+            for row in rows
+        ]
+
+    @staticmethod
+    async def delete(key: str) -> None:
+        """Delete a channel by key."""
+        await db.conn.execute(
+            "DELETE FROM channels WHERE key = ?",
+            (key.upper(),),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def update_last_read_at(key: str, timestamp: int | None = None) -> bool:
+        """Update the last_read_at timestamp for a channel.
+
+        Returns True if a row was updated, False if channel not found.
+        """
+        ts = timestamp if timestamp is not None else int(time.time())
+        cursor = await db.conn.execute(
+            "UPDATE channels SET last_read_at = ? WHERE key = ?",
+            (ts, key.upper()),
+        )
+        await db.conn.commit()
+        return cursor.rowcount > 0
+
+    @staticmethod
+    async def mark_all_read(timestamp: int) -> None:
+        """Mark all channels as read at the given timestamp."""
+        await db.conn.execute("UPDATE channels SET last_read_at = ?", (timestamp,))
+        await db.conn.commit()

app/repository/contacts.py

@@ -0,0 +1,445 @@
+import time
+from typing import Any
+
+from app.database import db
+from app.models import (
+    Contact,
+    ContactAdvertPath,
+    ContactAdvertPathSummary,
+    ContactNameHistory,
+)
+from app.path_utils import first_path_hop
+
+
+class AmbiguousPublicKeyPrefixError(ValueError):
+    """Raised when a public key prefix matches multiple contacts."""
+
+    def __init__(self, prefix: str, matches: list[str]):
+        self.prefix = prefix.lower()
+        self.matches = matches
+        super().__init__(f"Ambiguous public key prefix '{self.prefix}'")
+
+
+class ContactRepository:
+    @staticmethod
+    async def upsert(contact: dict[str, Any]) -> None:
+        await db.conn.execute(
+            """
+            INSERT INTO contacts (public_key, name, type, flags, last_path, last_path_len,
+                                  out_path_hash_mode,
+                                  last_advert, lat, lon, last_seen, on_radio, last_contacted,
+                                  first_seen)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(public_key) DO UPDATE SET
+                name = COALESCE(excluded.name, contacts.name),
+                type = CASE WHEN excluded.type = 0 THEN contacts.type ELSE excluded.type END,
+                flags = excluded.flags,
+                last_path = COALESCE(excluded.last_path, contacts.last_path),
+                last_path_len = excluded.last_path_len,
+                out_path_hash_mode = COALESCE(
+                    excluded.out_path_hash_mode, contacts.out_path_hash_mode
+                ),
+                last_advert = COALESCE(excluded.last_advert, contacts.last_advert),
+                lat = COALESCE(excluded.lat, contacts.lat),
+                lon = COALESCE(excluded.lon, contacts.lon),
+                last_seen = excluded.last_seen,
+                on_radio = COALESCE(excluded.on_radio, contacts.on_radio),
+                last_contacted = COALESCE(excluded.last_contacted, contacts.last_contacted),
+                first_seen = COALESCE(contacts.first_seen, excluded.first_seen)
+            """,
+            (
+                contact.get("public_key", "").lower(),
+                contact.get("name"),
+                contact.get("type", 0),
+                contact.get("flags", 0),
+                contact.get("last_path"),
+                contact.get("last_path_len", -1),
+                contact.get("out_path_hash_mode"),
+                contact.get("last_advert"),
+                contact.get("lat"),
+                contact.get("lon"),
+                contact.get("last_seen", int(time.time())),
+                contact.get("on_radio"),
+                contact.get("last_contacted"),
+                contact.get("first_seen"),
+            ),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    def _row_to_contact(row) -> Contact:
+        """Convert a database row to a Contact model."""
+        return Contact(
+            public_key=row["public_key"],
+            name=row["name"],
+            type=row["type"],
+            flags=row["flags"],
+            last_path=row["last_path"],
+            last_path_len=row["last_path_len"],
+            out_path_hash_mode=row["out_path_hash_mode"],
+            last_advert=row["last_advert"],
+            lat=row["lat"],
+            lon=row["lon"],
+            last_seen=row["last_seen"],
+            on_radio=bool(row["on_radio"]),
+            last_contacted=row["last_contacted"],
+            last_read_at=row["last_read_at"],
+            first_seen=row["first_seen"],
+        )
+
+    @staticmethod
+    async def get_by_key(public_key: str) -> Contact | None:
+        cursor = await db.conn.execute(
+            "SELECT * FROM contacts WHERE public_key = ?", (public_key.lower(),)
+        )
+        row = await cursor.fetchone()
+        return ContactRepository._row_to_contact(row) if row else None
+
+    @staticmethod
+    async def get_by_key_prefix(prefix: str) -> Contact | None:
+        """Get a contact by key prefix only if it resolves uniquely.
+
+        Returns None when no contacts match OR when multiple contacts match
+        the prefix (to avoid silently selecting the wrong contact).
+        """
+        normalized_prefix = prefix.lower()
+        cursor = await db.conn.execute(
+            "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT 2",
+            (f"{normalized_prefix}%",),
+        )
+        rows = list(await cursor.fetchall())
+        if len(rows) != 1:
+            return None
+        return ContactRepository._row_to_contact(rows[0])
+
+    @staticmethod
+    async def _get_prefix_matches(prefix: str, limit: int = 2) -> list[Contact]:
+        """Get contacts matching a key prefix, up to limit."""
+        cursor = await db.conn.execute(
+            "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT ?",
+            (f"{prefix.lower()}%", limit),
+        )
+        rows = list(await cursor.fetchall())
+        return [ContactRepository._row_to_contact(row) for row in rows]
+
+    @staticmethod
+    async def get_by_key_or_prefix(key_or_prefix: str) -> Contact | None:
+        """Get a contact by exact key match, falling back to prefix match.
+
+        Useful when the input might be a full 64-char public key or a shorter prefix.
+        """
+        contact = await ContactRepository.get_by_key(key_or_prefix)
+        if contact:
+            return contact
+
+        matches = await ContactRepository._get_prefix_matches(key_or_prefix, limit=2)
+        if len(matches) == 1:
+            return matches[0]
+        if len(matches) > 1:
+            raise AmbiguousPublicKeyPrefixError(
+                key_or_prefix,
+                [m.public_key for m in matches],
+            )
+        return None
+
+    @staticmethod
+    async def get_by_name(name: str) -> list[Contact]:
+        """Get all contacts with the given exact name."""
+        cursor = await db.conn.execute("SELECT * FROM contacts WHERE name = ?", (name,))
+        rows = await cursor.fetchall()
+        return [ContactRepository._row_to_contact(row) for row in rows]
+
+    @staticmethod
+    async def resolve_prefixes(prefixes: list[str]) -> dict[str, Contact]:
+        """Resolve multiple key prefixes to contacts in a single query.
+
+        Returns a dict mapping each prefix to its Contact, only for prefixes
+        that resolve uniquely (exactly one match). Ambiguous or unmatched
+        prefixes are omitted.
+        """
+        if not prefixes:
+            return {}
+        normalized = [p.lower() for p in prefixes]
+        conditions = " OR ".join(["public_key LIKE ?"] * len(normalized))
+        params = [f"{p}%" for p in normalized]
+        cursor = await db.conn.execute(f"SELECT * FROM contacts WHERE {conditions}", params)
+        rows = await cursor.fetchall()
+        # Group by which prefix each row matches
+        prefix_to_rows: dict[str, list] = {p: [] for p in normalized}
+        for row in rows:
+            pk = row["public_key"]
+            for p in normalized:
+                if pk.startswith(p):
+                    prefix_to_rows[p].append(row)
+        # Only include uniquely-resolved prefixes
+        result: dict[str, Contact] = {}
+        for p in normalized:
+            if len(prefix_to_rows[p]) == 1:
+                result[p] = ContactRepository._row_to_contact(prefix_to_rows[p][0])
+        return result
+
+    @staticmethod
+    async def get_all(limit: int = 100, offset: int = 0) -> list[Contact]:
+        cursor = await db.conn.execute(
+            "SELECT * FROM contacts ORDER BY COALESCE(name, public_key) LIMIT ? OFFSET ?",
+            (limit, offset),
+        )
+        rows = await cursor.fetchall()
+        return [ContactRepository._row_to_contact(row) for row in rows]
+
+    @staticmethod
+    async def get_recent_non_repeaters(limit: int = 200) -> list[Contact]:
+        """Get the most recently active non-repeater contacts.
+
+        Orders by most recent activity (last_contacted or last_advert),
+        excluding repeaters (type=2).
+        """
+        cursor = await db.conn.execute(
+            """
+            SELECT * FROM contacts
+            WHERE type != 2
+            ORDER BY COALESCE(last_contacted, 0) DESC, COALESCE(last_advert, 0) DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        rows = await cursor.fetchall()
+        return [ContactRepository._row_to_contact(row) for row in rows]
+
+    @staticmethod
+    async def update_path(
+        public_key: str, path: str, path_len: int, out_path_hash_mode: int | None = None
+    ) -> None:
+        if out_path_hash_mode is None:
+            await db.conn.execute(
+                "UPDATE contacts SET last_path = ?, last_path_len = ?, last_seen = ? WHERE public_key = ?",
+                (path, path_len, int(time.time()), public_key.lower()),
+            )
+        else:
+            await db.conn.execute(
+                """
+                UPDATE contacts
+                SET last_path = ?, last_path_len = ?, out_path_hash_mode = ?, last_seen = ?
+                WHERE public_key = ?
+                """,
+                (path, path_len, out_path_hash_mode, int(time.time()), public_key.lower()),
+            )
+        await db.conn.commit()
+
+    @staticmethod
+    async def set_on_radio(public_key: str, on_radio: bool) -> None:
+        await db.conn.execute(
+            "UPDATE contacts SET on_radio = ? WHERE public_key = ?",
+            (on_radio, public_key.lower()),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def clear_on_radio_except(keep_keys: list[str]) -> None:
+        """Set on_radio=False for all contacts NOT in keep_keys."""
+        if not keep_keys:
+            await db.conn.execute("UPDATE contacts SET on_radio = 0 WHERE on_radio = 1")
+        else:
+            placeholders = ",".join("?" * len(keep_keys))
+            await db.conn.execute(
+                f"UPDATE contacts SET on_radio = 0 WHERE on_radio = 1 AND public_key NOT IN ({placeholders})",
+                keep_keys,
+            )
+        await db.conn.commit()
+
+    @staticmethod
+    async def delete(public_key: str) -> None:
+        normalized = public_key.lower()
+        await db.conn.execute(
+            "DELETE FROM contact_name_history WHERE public_key = ?", (normalized,)
+        )
+        await db.conn.execute(
+            "DELETE FROM contact_advert_paths WHERE public_key = ?", (normalized,)
+        )
+        await db.conn.execute("DELETE FROM contacts WHERE public_key = ?", (normalized,))
+        await db.conn.commit()
+
+    @staticmethod
+    async def update_last_contacted(public_key: str, timestamp: int | None = None) -> None:
+        """Update the last_contacted timestamp for a contact."""
+        ts = timestamp if timestamp is not None else int(time.time())
+        await db.conn.execute(
+            "UPDATE contacts SET last_contacted = ?, last_seen = ? WHERE public_key = ?",
+            (ts, ts, public_key.lower()),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def update_last_read_at(public_key: str, timestamp: int | None = None) -> bool:
+        """Update the last_read_at timestamp for a contact.
+
+        Returns True if a row was updated, False if contact not found.
+        """
+        ts = timestamp if timestamp is not None else int(time.time())
+        cursor = await db.conn.execute(
+            "UPDATE contacts SET last_read_at = ? WHERE public_key = ?",
+            (ts, public_key.lower()),
+        )
+        await db.conn.commit()
+        return cursor.rowcount > 0
+
+    @staticmethod
+    async def mark_all_read(timestamp: int) -> None:
+        """Mark all contacts as read at the given timestamp."""
+        await db.conn.execute("UPDATE contacts SET last_read_at = ?", (timestamp,))
+        await db.conn.commit()
+
+    @staticmethod
+    async def get_by_pubkey_first_byte(hex_byte: str) -> list[Contact]:
+        """Get contacts whose public key starts with the given hex byte (2 chars)."""
+        cursor = await db.conn.execute(
+            "SELECT * FROM contacts WHERE substr(public_key, 1, 2) = ?",
+            (hex_byte.lower(),),
+        )
+        rows = await cursor.fetchall()
+        return [ContactRepository._row_to_contact(row) for row in rows]
+
+
+class ContactAdvertPathRepository:
+    """Repository for recent unique advertisement paths per contact."""
+
+    @staticmethod
+    def _row_to_path(row) -> ContactAdvertPath:
+        path = row["path_hex"] or ""
+        next_hop = first_path_hop(path, row["path_len"])
+        return ContactAdvertPath(
+            path=path,
+            path_len=row["path_len"],
+            next_hop=next_hop,
+            first_seen=row["first_seen"],
+            last_seen=row["last_seen"],
+            heard_count=row["heard_count"],
+        )
+
+    @staticmethod
+    async def record_observation(
+        public_key: str,
+        path_hex: str,
+        timestamp: int,
+        max_paths: int = 10,
+        path_len: int | None = None,
+    ) -> None:
+        """
+        Upsert a unique advert path observation for a contact and prune to N most recent.
+        """
+        if max_paths < 1:
+            max_paths = 1
+
+        normalized_key = public_key.lower()
+        normalized_path = path_hex.lower()
+        normalized_path_len = path_len if isinstance(path_len, int) else len(normalized_path) // 2
+
+        await db.conn.execute(
+            """
+            INSERT INTO contact_advert_paths
+                (public_key, path_hex, path_len, first_seen, last_seen, heard_count)
+            VALUES (?, ?, ?, ?, ?, 1)
+            ON CONFLICT(public_key, path_hex) DO UPDATE SET
+                last_seen = MAX(contact_advert_paths.last_seen, excluded.last_seen),
+                path_len = excluded.path_len,
+                heard_count = contact_advert_paths.heard_count + 1
+            """,
+            (normalized_key, normalized_path, normalized_path_len, timestamp, timestamp),
+        )
+
+        # Keep only the N most recent unique paths per contact.
+        await db.conn.execute(
+            """
+            DELETE FROM contact_advert_paths
+            WHERE public_key = ?
+              AND path_hex NOT IN (
+                  SELECT path_hex
+                  FROM contact_advert_paths
+                  WHERE public_key = ?
+                  ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+                  LIMIT ?
+              )
+            """,
+            (normalized_key, normalized_key, max_paths),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def get_recent_for_contact(public_key: str, limit: int = 10) -> list[ContactAdvertPath]:
+        cursor = await db.conn.execute(
+            """
+            SELECT path_hex, path_len, first_seen, last_seen, heard_count
+            FROM contact_advert_paths
+            WHERE public_key = ?
+            ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+            LIMIT ?
+            """,
+            (public_key.lower(), limit),
+        )
+        rows = await cursor.fetchall()
+        return [ContactAdvertPathRepository._row_to_path(row) for row in rows]
+
+    @staticmethod
+    async def get_recent_for_all_contacts(
+        limit_per_contact: int = 10,
+    ) -> list[ContactAdvertPathSummary]:
+        cursor = await db.conn.execute(
+            """
+            SELECT public_key, path_hex, path_len, first_seen, last_seen, heard_count
+            FROM contact_advert_paths
+            ORDER BY public_key ASC, last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+            """
+        )
+        rows = await cursor.fetchall()
+
+        grouped: dict[str, list[ContactAdvertPath]] = {}
+        for row in rows:
+            key = row["public_key"]
+            paths = grouped.get(key)
+            if paths is None:
+                paths = []
+                grouped[key] = paths
+            if len(paths) >= limit_per_contact:
+                continue
+            paths.append(ContactAdvertPathRepository._row_to_path(row))
+
+        return [
+            ContactAdvertPathSummary(public_key=key, paths=paths) for key, paths in grouped.items()
+        ]
+
+
+class ContactNameHistoryRepository:
+    """Repository for contact name change history."""
+
+    @staticmethod
+    async def record_name(public_key: str, name: str, timestamp: int) -> None:
+        """Record a name observation. Upserts: updates last_seen if name already known."""
+        await db.conn.execute(
+            """
+            INSERT INTO contact_name_history (public_key, name, first_seen, last_seen)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(public_key, name) DO UPDATE SET
+                last_seen = MAX(contact_name_history.last_seen, excluded.last_seen)
+            """,
+            (public_key.lower(), name, timestamp, timestamp),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def get_history(public_key: str) -> list[ContactNameHistory]:
+        cursor = await db.conn.execute(
+            """
+            SELECT name, first_seen, last_seen
+            FROM contact_name_history
+            WHERE public_key = ?
+            ORDER BY last_seen DESC
+            """,
+            (public_key.lower(),),
+        )
+        rows = await cursor.fetchall()
+        return [
+            ContactNameHistory(
+                name=row["name"], first_seen=row["first_seen"], last_seen=row["last_seen"]
+            )
+            for row in rows
+        ]

app/repository/fanout.py

@@ -0,0 +1,137 @@
+"""Repository for fanout_configs table."""
+
+import json
+import logging
+import time
+import uuid
+from typing import Any
+
+from app.database import db
+
+logger = logging.getLogger(__name__)
+
+# In-memory cache of config metadata (name, type) for status reporting.
+# Populated by get_all/get/create/update and read by FanoutManager.get_statuses().
+_configs_cache: dict[str, dict[str, Any]] = {}
+
+
+def _row_to_dict(row: Any) -> dict[str, Any]:
+    """Convert a database row to a config dict."""
+    result = {
+        "id": row["id"],
+        "type": row["type"],
+        "name": row["name"],
+        "enabled": bool(row["enabled"]),
+        "config": json.loads(row["config"]) if row["config"] else {},
+        "scope": json.loads(row["scope"]) if row["scope"] else {},
+        "sort_order": row["sort_order"] or 0,
+        "created_at": row["created_at"] or 0,
+    }
+    _configs_cache[result["id"]] = result
+    return result
+
+
+class FanoutConfigRepository:
+    """CRUD operations for fanout_configs table."""
+
+    @staticmethod
+    async def get_all() -> list[dict[str, Any]]:
+        """Get all fanout configs ordered by sort_order."""
+        cursor = await db.conn.execute(
+            "SELECT * FROM fanout_configs ORDER BY sort_order, created_at"
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_dict(row) for row in rows]
+
+    @staticmethod
+    async def get(config_id: str) -> dict[str, Any] | None:
+        """Get a single fanout config by ID."""
+        cursor = await db.conn.execute("SELECT * FROM fanout_configs WHERE id = ?", (config_id,))
+        row = await cursor.fetchone()
+        if row is None:
+            return None
+        return _row_to_dict(row)
+
+    @staticmethod
+    async def create(
+        config_type: str,
+        name: str,
+        config: dict,
+        scope: dict,
+        enabled: bool = True,
+        config_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a new fanout config."""
+        new_id = config_id or str(uuid.uuid4())
+        now = int(time.time())
+
+        # Get next sort_order
+        cursor = await db.conn.execute(
+            "SELECT COALESCE(MAX(sort_order), -1) + 1 FROM fanout_configs"
+        )
+        row = await cursor.fetchone()
+        sort_order = row[0] if row else 0
+
+        await db.conn.execute(
+            """
+            INSERT INTO fanout_configs (id, type, name, enabled, config, scope, sort_order, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                new_id,
+                config_type,
+                name,
+                1 if enabled else 0,
+                json.dumps(config),
+                json.dumps(scope),
+                sort_order,
+                now,
+            ),
+        )
+        await db.conn.commit()
+
+        result = await FanoutConfigRepository.get(new_id)
+        assert result is not None
+        return result
+
+    @staticmethod
+    async def update(config_id: str, **fields: Any) -> dict[str, Any] | None:
+        """Update a fanout config. Only provided fields are updated."""
+        updates = []
+        params: list[Any] = []
+
+        for field in ("name", "enabled", "config", "scope", "sort_order"):
+            if field in fields:
+                value = fields[field]
+                if field == "enabled":
+                    value = 1 if value else 0
+                elif field in ("config", "scope"):
+                    value = json.dumps(value)
+                updates.append(f"{field} = ?")
+                params.append(value)
+
+        if not updates:
+            return await FanoutConfigRepository.get(config_id)
+
+        params.append(config_id)
+        query = f"UPDATE fanout_configs SET {', '.join(updates)} WHERE id = ?"
+        await db.conn.execute(query, params)
+        await db.conn.commit()
+
+        return await FanoutConfigRepository.get(config_id)
+
+    @staticmethod
+    async def delete(config_id: str) -> None:
+        """Delete a fanout config."""
+        await db.conn.execute("DELETE FROM fanout_configs WHERE id = ?", (config_id,))
+        await db.conn.commit()
+        _configs_cache.pop(config_id, None)
+
+    @staticmethod
+    async def get_enabled() -> list[dict[str, Any]]:
+        """Get all enabled fanout configs."""
+        cursor = await db.conn.execute(
+            "SELECT * FROM fanout_configs WHERE enabled = 1 ORDER BY sort_order, created_at"
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_dict(row) for row in rows]

app/repository/messages.py

@@ -0,0 +1,631 @@
+import json
+import time
+from typing import Any
+
+from app.database import db
+from app.models import Message, MessagePath
+
+
+class MessageRepository:
+    @staticmethod
+    def _parse_paths(paths_json: str | None) -> list[MessagePath] | None:
+        """Parse paths JSON string to list of MessagePath objects."""
+        if not paths_json:
+            return None
+        try:
+            paths_data = json.loads(paths_json)
+            return [MessagePath(**p) for p in paths_data]
+        except (json.JSONDecodeError, TypeError, KeyError, ValueError):
+            return None
+
+    @staticmethod
+    async def create(
+        msg_type: str,
+        text: str,
+        received_at: int,
+        conversation_key: str,
+        sender_timestamp: int | None = None,
+        path: str | None = None,
+        path_len: int | None = None,
+        txt_type: int = 0,
+        signature: str | None = None,
+        outgoing: bool = False,
+        sender_name: str | None = None,
+        sender_key: str | None = None,
+    ) -> int | None:
+        """Create a message, returning the ID or None if duplicate.
+
+        Uses INSERT OR IGNORE to handle the UNIQUE constraint on
+        (type, conversation_key, text, sender_timestamp). This prevents
+        duplicate messages when the same message arrives via multiple RF paths.
+
+        The path parameter is converted to the paths JSON array format.
+        """
+        # Convert single path to paths array format
+        paths_json = None
+        if path is not None:
+            normalized_path_len = path_len if isinstance(path_len, int) else len(path) // 2
+            path_entry: dict[str, Any] = {"path": path, "received_at": received_at}
+            path_entry["path_len"] = normalized_path_len
+            paths_json = json.dumps([path_entry])
+
+        cursor = await db.conn.execute(
+            """
+            INSERT OR IGNORE INTO messages (type, conversation_key, text, sender_timestamp,
+                                            received_at, paths, txt_type, signature, outgoing,
+                                            sender_name, sender_key)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                msg_type,
+                conversation_key,
+                text,
+                sender_timestamp,
+                received_at,
+                paths_json,
+                txt_type,
+                signature,
+                outgoing,
+                sender_name,
+                sender_key,
+            ),
+        )
+        await db.conn.commit()
+        # rowcount is 0 if INSERT was ignored due to UNIQUE constraint violation
+        if cursor.rowcount == 0:
+            return None
+        return cursor.lastrowid
+
+    @staticmethod
+    async def add_path(
+        message_id: int, path: str, received_at: int | None = None, path_len: int | None = None
+    ) -> list[MessagePath]:
+        """Add a new path to an existing message.
+
+        This is used when a repeat/echo of a message arrives via a different route.
+        Returns the updated list of paths.
+        """
+        ts = received_at if received_at is not None else int(time.time())
+
+        # Atomic append: use json_insert to avoid read-modify-write race when
+        # multiple duplicate packets arrive concurrently for the same message.
+        normalized_path_len = path_len if isinstance(path_len, int) else len(path) // 2
+        new_entry_dict: dict[str, Any] = {"path": path, "received_at": ts}
+        new_entry_dict["path_len"] = normalized_path_len
+        new_entry = json.dumps(new_entry_dict)
+        await db.conn.execute(
+            """UPDATE messages SET paths = json_insert(
+                COALESCE(paths, '[]'), '$[#]', json(?)
+            ) WHERE id = ?""",
+            (new_entry, message_id),
+        )
+        await db.conn.commit()
+
+        # Read back the full list for the return value
+        cursor = await db.conn.execute("SELECT paths FROM messages WHERE id = ?", (message_id,))
+        row = await cursor.fetchone()
+        if not row or not row["paths"]:
+            return []
+
+        try:
+            all_paths = json.loads(row["paths"])
+        except json.JSONDecodeError:
+            return []
+
+        return [MessagePath(**p) for p in all_paths]
+
+    @staticmethod
+    async def claim_prefix_messages(full_key: str) -> int:
+        """Promote prefix-stored messages to the full conversation key.
+
+        When a full key becomes known for a contact, any messages stored with
+        only a prefix as conversation_key are updated to use the full key.
+        """
+        lower_key = full_key.lower()
+        cursor = await db.conn.execute(
+            """UPDATE messages SET conversation_key = ?
+               WHERE type = 'PRIV' AND length(conversation_key) < 64
+               AND ? LIKE conversation_key || '%'
+               AND (
+                   SELECT COUNT(*) FROM contacts
+                   WHERE public_key LIKE messages.conversation_key || '%'
+               ) = 1""",
+            (lower_key, lower_key),
+        )
+        await db.conn.commit()
+        return cursor.rowcount
+
+    @staticmethod
+    async def backfill_channel_sender_key(public_key: str, name: str) -> int:
+        """Backfill sender_key on channel messages that match a contact's name.
+
+        When a contact becomes known (via advert, sync, or manual creation),
+        any channel messages with a matching sender_name but no sender_key
+        are updated to associate them with this contact's public key.
+        """
+        cursor = await db.conn.execute(
+            """UPDATE messages SET sender_key = ?
+               WHERE type = 'CHAN' AND sender_name = ? AND sender_key IS NULL""",
+            (public_key.lower(), name),
+        )
+        await db.conn.commit()
+        return cursor.rowcount
+
+    @staticmethod
+    def _normalize_conversation_key(conversation_key: str) -> tuple[str, str]:
+        """Normalize a conversation key and return (sql_clause, normalized_key).
+
+        Returns the WHERE clause fragment and the normalized key value.
+        """
+        if len(conversation_key) == 64:
+            return "AND conversation_key = ?", conversation_key.lower()
+        elif len(conversation_key) == 32:
+            return "AND conversation_key = ?", conversation_key.upper()
+        else:
+            return "AND conversation_key LIKE ?", f"{conversation_key}%"
+
+    @staticmethod
+    def _row_to_message(row: Any) -> Message:
+        """Convert a database row to a Message model."""
+        return Message(
+            id=row["id"],
+            type=row["type"],
+            conversation_key=row["conversation_key"],
+            text=row["text"],
+            sender_timestamp=row["sender_timestamp"],
+            received_at=row["received_at"],
+            paths=MessageRepository._parse_paths(row["paths"]),
+            txt_type=row["txt_type"],
+            signature=row["signature"],
+            sender_key=row["sender_key"],
+            outgoing=bool(row["outgoing"]),
+            acked=row["acked"],
+            sender_name=row["sender_name"],
+        )
+
+    @staticmethod
+    async def get_all(
+        limit: int = 100,
+        offset: int = 0,
+        msg_type: str | None = None,
+        conversation_key: str | None = None,
+        before: int | None = None,
+        before_id: int | None = None,
+        after: int | None = None,
+        after_id: int | None = None,
+        q: str | None = None,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
+    ) -> list[Message]:
+        query = "SELECT * FROM messages WHERE 1=1"
+        params: list[Any] = []
+
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            query += (
+                f" AND NOT (outgoing=0 AND ("
+                f"(type='PRIV' AND LOWER(conversation_key) IN ({placeholders}))"
+                f" OR (type='CHAN' AND sender_key IS NOT NULL AND LOWER(sender_key) IN ({placeholders}))"
+                f"))"
+            )
+            params.extend(blocked_keys)
+            params.extend(blocked_keys)
+
+        if blocked_names:
+            placeholders = ",".join("?" for _ in blocked_names)
+            query += (
+                f" AND NOT (outgoing=0 AND sender_name IS NOT NULL"
+                f" AND sender_name IN ({placeholders}))"
+            )
+            params.extend(blocked_names)
+
+        if msg_type:
+            query += " AND type = ?"
+            params.append(msg_type)
+        if conversation_key:
+            clause, norm_key = MessageRepository._normalize_conversation_key(conversation_key)
+            query += f" {clause}"
+            params.append(norm_key)
+
+        if q:
+            escaped_q = q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+            query += " AND text LIKE ? ESCAPE '\\' COLLATE NOCASE"
+            params.append(f"%{escaped_q}%")
+
+        # Forward cursor (after/after_id) — mutually exclusive with before/before_id
+        if after is not None and after_id is not None:
+            query += " AND (received_at > ? OR (received_at = ? AND id > ?))"
+            params.extend([after, after, after_id])
+            query += " ORDER BY received_at ASC, id ASC LIMIT ?"
+            params.append(limit)
+        else:
+            if before is not None and before_id is not None:
+                query += " AND (received_at < ? OR (received_at = ? AND id < ?))"
+                params.extend([before, before, before_id])
+
+            query += " ORDER BY received_at DESC, id DESC LIMIT ?"
+            params.append(limit)
+            if before is None or before_id is None:
+                query += " OFFSET ?"
+                params.append(offset)
+
+        cursor = await db.conn.execute(query, params)
+        rows = await cursor.fetchall()
+        return [MessageRepository._row_to_message(row) for row in rows]
+
+    @staticmethod
+    async def get_around(
+        message_id: int,
+        msg_type: str | None = None,
+        conversation_key: str | None = None,
+        context_size: int = 100,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
+    ) -> tuple[list[Message], bool, bool]:
+        """Get messages around a target message.
+
+        Returns (messages, has_older, has_newer).
+        """
+        # Build common WHERE clause for optional conversation/type filtering.
+        # If the target message doesn't match filters, return an empty result.
+        where_parts: list[str] = []
+        base_params: list[Any] = []
+        if msg_type:
+            where_parts.append("type = ?")
+            base_params.append(msg_type)
+        if conversation_key:
+            clause, norm_key = MessageRepository._normalize_conversation_key(conversation_key)
+            where_parts.append(clause.removeprefix("AND "))
+            base_params.append(norm_key)
+
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            where_parts.append(
+                f"NOT (outgoing=0 AND ("
+                f"(type='PRIV' AND LOWER(conversation_key) IN ({placeholders}))"
+                f" OR (type='CHAN' AND sender_key IS NOT NULL AND LOWER(sender_key) IN ({placeholders}))"
+                f"))"
+            )
+            base_params.extend(blocked_keys)
+            base_params.extend(blocked_keys)
+
+        if blocked_names:
+            placeholders = ",".join("?" for _ in blocked_names)
+            where_parts.append(
+                f"NOT (outgoing=0 AND sender_name IS NOT NULL AND sender_name IN ({placeholders}))"
+            )
+            base_params.extend(blocked_names)
+
+        where_sql = " AND ".join(["1=1", *where_parts])
+
+        # 1. Get the target message (must satisfy filters if provided)
+        target_cursor = await db.conn.execute(
+            f"SELECT * FROM messages WHERE id = ? AND {where_sql}",
+            (message_id, *base_params),
+        )
+        target_row = await target_cursor.fetchone()
+        if not target_row:
+            return [], False, False
+
+        target = MessageRepository._row_to_message(target_row)
+
+        # 2. Get context_size+1 messages before target (DESC)
+        before_query = f"""
+            SELECT * FROM messages WHERE {where_sql}
+            AND (received_at < ? OR (received_at = ? AND id < ?))
+            ORDER BY received_at DESC, id DESC LIMIT ?
+        """
+        before_params = [
+            *base_params,
+            target.received_at,
+            target.received_at,
+            target.id,
+            context_size + 1,
+        ]
+        before_cursor = await db.conn.execute(before_query, before_params)
+        before_rows = list(await before_cursor.fetchall())
+
+        has_older = len(before_rows) > context_size
+        before_messages = [MessageRepository._row_to_message(r) for r in before_rows[:context_size]]
+
+        # 3. Get context_size+1 messages after target (ASC)
+        after_query = f"""
+            SELECT * FROM messages WHERE {where_sql}
+            AND (received_at > ? OR (received_at = ? AND id > ?))
+            ORDER BY received_at ASC, id ASC LIMIT ?
+        """
+        after_params = [
+            *base_params,
+            target.received_at,
+            target.received_at,
+            target.id,
+            context_size + 1,
+        ]
+        after_cursor = await db.conn.execute(after_query, after_params)
+        after_rows = list(await after_cursor.fetchall())
+
+        has_newer = len(after_rows) > context_size
+        after_messages = [MessageRepository._row_to_message(r) for r in after_rows[:context_size]]
+
+        # Combine: before (reversed to ASC) + target + after
+        all_messages = list(reversed(before_messages)) + [target] + after_messages
+        return all_messages, has_older, has_newer
+
+    @staticmethod
+    async def increment_ack_count(message_id: int) -> int:
+        """Increment ack count and return the new value."""
+        await db.conn.execute("UPDATE messages SET acked = acked + 1 WHERE id = ?", (message_id,))
+        await db.conn.commit()
+        cursor = await db.conn.execute("SELECT acked FROM messages WHERE id = ?", (message_id,))
+        row = await cursor.fetchone()
+        return row["acked"] if row else 1
+
+    @staticmethod
+    async def get_ack_and_paths(message_id: int) -> tuple[int, list[MessagePath] | None]:
+        """Get the current ack count and paths for a message."""
+        cursor = await db.conn.execute(
+            "SELECT acked, paths FROM messages WHERE id = ?", (message_id,)
+        )
+        row = await cursor.fetchone()
+        if not row:
+            return 0, None
+        return row["acked"], MessageRepository._parse_paths(row["paths"])
+
+    @staticmethod
+    async def get_by_id(message_id: int) -> "Message | None":
+        """Look up a message by its ID."""
+        cursor = await db.conn.execute(
+            "SELECT * FROM messages WHERE id = ?",
+            (message_id,),
+        )
+        row = await cursor.fetchone()
+        if not row:
+            return None
+
+        return MessageRepository._row_to_message(row)
+
+    @staticmethod
+    async def get_by_content(
+        msg_type: str,
+        conversation_key: str,
+        text: str,
+        sender_timestamp: int | None,
+    ) -> "Message | None":
+        """Look up a message by its unique content fields."""
+        cursor = await db.conn.execute(
+            """
+            SELECT * FROM messages
+            WHERE type = ? AND conversation_key = ? AND text = ?
+              AND (sender_timestamp = ? OR (sender_timestamp IS NULL AND ? IS NULL))
+            """,
+            (msg_type, conversation_key, text, sender_timestamp, sender_timestamp),
+        )
+        row = await cursor.fetchone()
+        if not row:
+            return None
+
+        return MessageRepository._row_to_message(row)
+
+    @staticmethod
+    async def get_unread_counts(
+        name: str | None = None,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
+    ) -> dict:
+        """Get unread message counts, mention flags, and last message times for all conversations.
+
+        Args:
+            name: User's display name for @[name] mention detection. If None, mentions are skipped.
+            blocked_keys: Public keys whose messages should be excluded from counts.
+            blocked_names: Display names whose messages should be excluded from counts.
+
+        Returns:
+            Dict with 'counts', 'mentions', and 'last_message_times' keys.
+        """
+        counts: dict[str, int] = {}
+        mention_flags: dict[str, bool] = {}
+        last_message_times: dict[str, int] = {}
+
+        mention_token = f"@[{name}]" if name else None
+
+        # Build optional block-list WHERE fragments for channel messages
+        chan_block_sql = ""
+        chan_block_params: list[Any] = []
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            chan_block_sql += (
+                f" AND NOT (m.sender_key IS NOT NULL AND LOWER(m.sender_key) IN ({placeholders}))"
+            )
+            chan_block_params.extend(blocked_keys)
+        if blocked_names:
+            placeholders = ",".join("?" for _ in blocked_names)
+            chan_block_sql += (
+                f" AND NOT (m.sender_name IS NOT NULL AND m.sender_name IN ({placeholders}))"
+            )
+            chan_block_params.extend(blocked_names)
+
+        # Channel unreads
+        cursor = await db.conn.execute(
+            f"""
+            SELECT m.conversation_key,
+                   COUNT(*) as unread_count,
+                   SUM(CASE
+                           WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
+                           ELSE 0
+                       END) > 0 as has_mention
+            FROM messages m
+            JOIN channels c ON m.conversation_key = c.key
+            WHERE m.type = 'CHAN' AND m.outgoing = 0
+              AND m.received_at > COALESCE(c.last_read_at, 0)
+              {chan_block_sql}
+            GROUP BY m.conversation_key
+            """,
+            (mention_token or "", mention_token or "", *chan_block_params),
+        )
+        rows = await cursor.fetchall()
+        for row in rows:
+            state_key = f"channel-{row['conversation_key']}"
+            counts[state_key] = row["unread_count"]
+            if mention_token and row["has_mention"]:
+                mention_flags[state_key] = True
+
+        # Build block-list exclusion for contact (DM) unreads
+        contact_block_sql = ""
+        contact_block_params: list[Any] = []
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            contact_block_sql += f" AND LOWER(m.conversation_key) NOT IN ({placeholders})"
+            contact_block_params.extend(blocked_keys)
+
+        # Contact unreads
+        cursor = await db.conn.execute(
+            f"""
+            SELECT m.conversation_key,
+                   COUNT(*) as unread_count,
+                   SUM(CASE
+                           WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
+                           ELSE 0
+                       END) > 0 as has_mention
+            FROM messages m
+            JOIN contacts ct ON m.conversation_key = ct.public_key
+            WHERE m.type = 'PRIV' AND m.outgoing = 0
+              AND m.received_at > COALESCE(ct.last_read_at, 0)
+              {contact_block_sql}
+            GROUP BY m.conversation_key
+            """,
+            (mention_token or "", mention_token or "", *contact_block_params),
+        )
+        rows = await cursor.fetchall()
+        for row in rows:
+            state_key = f"contact-{row['conversation_key']}"
+            counts[state_key] = row["unread_count"]
+            if mention_token and row["has_mention"]:
+                mention_flags[state_key] = True
+
+        # Last message times for all conversations (including read ones)
+        cursor = await db.conn.execute(
+            """
+            SELECT type, conversation_key, MAX(received_at) as last_message_time
+            FROM messages
+            GROUP BY type, conversation_key
+            """
+        )
+        rows = await cursor.fetchall()
+        for row in rows:
+            prefix = "channel" if row["type"] == "CHAN" else "contact"
+            state_key = f"{prefix}-{row['conversation_key']}"
+            last_message_times[state_key] = row["last_message_time"]
+
+        return {
+            "counts": counts,
+            "mentions": mention_flags,
+            "last_message_times": last_message_times,
+        }
+
+    @staticmethod
+    async def count_dm_messages(contact_key: str) -> int:
+        """Count total DM messages for a contact."""
+        cursor = await db.conn.execute(
+            "SELECT COUNT(*) as cnt FROM messages WHERE type = 'PRIV' AND conversation_key = ?",
+            (contact_key.lower(),),
+        )
+        row = await cursor.fetchone()
+        return row["cnt"] if row else 0
+
+    @staticmethod
+    async def count_channel_messages_by_sender(sender_key: str) -> int:
+        """Count channel messages sent by a specific contact."""
+        cursor = await db.conn.execute(
+            "SELECT COUNT(*) as cnt FROM messages WHERE type = 'CHAN' AND sender_key = ?",
+            (sender_key.lower(),),
+        )
+        row = await cursor.fetchone()
+        return row["cnt"] if row else 0
+
+    @staticmethod
+    async def get_channel_stats(conversation_key: str) -> dict:
+        """Get channel message statistics: time-windowed counts, first message, unique senders, top senders.
+
+        Returns a dict with message_counts, first_message_at, unique_sender_count, top_senders_24h.
+        """
+        import time as _time
+
+        now = int(_time.time())
+        t_1h = now - 3600
+        t_24h = now - 86400
+        t_48h = now - 172800
+        t_7d = now - 604800
+
+        cursor = await db.conn.execute(
+            """
+            SELECT COUNT(*) AS all_time,
+                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_1h,
+                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_24h,
+                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_48h,
+                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_7d,
+                MIN(received_at) AS first_message_at,
+                COUNT(DISTINCT sender_key) AS unique_sender_count
+            FROM messages WHERE type = 'CHAN' AND conversation_key = ?
+            """,
+            (t_1h, t_24h, t_48h, t_7d, conversation_key),
+        )
+        row = await cursor.fetchone()
+        assert row is not None  # Aggregate query always returns a row
+
+        message_counts = {
+            "last_1h": row["last_1h"] or 0,
+            "last_24h": row["last_24h"] or 0,
+            "last_48h": row["last_48h"] or 0,
+            "last_7d": row["last_7d"] or 0,
+            "all_time": row["all_time"] or 0,
+        }
+
+        cursor2 = await db.conn.execute(
+            """
+            SELECT COALESCE(sender_name, sender_key, 'Unknown') AS display_name,
+                sender_key, COUNT(*) AS cnt
+            FROM messages
+            WHERE type = 'CHAN' AND conversation_key = ?
+                AND received_at >= ? AND sender_key IS NOT NULL
+            GROUP BY sender_key ORDER BY cnt DESC LIMIT 5
+            """,
+            (conversation_key, t_24h),
+        )
+        top_rows = await cursor2.fetchall()
+        top_senders = [
+            {
+                "sender_name": r["display_name"],
+                "sender_key": r["sender_key"],
+                "message_count": r["cnt"],
+            }
+            for r in top_rows
+        ]
+
+        return {
+            "message_counts": message_counts,
+            "first_message_at": row["first_message_at"],
+            "unique_sender_count": row["unique_sender_count"] or 0,
+            "top_senders_24h": top_senders,
+        }
+
+    @staticmethod
+    async def get_most_active_rooms(sender_key: str, limit: int = 5) -> list[tuple[str, str, int]]:
+        """Get channels where a contact has sent the most messages.
+
+        Returns list of (channel_key, channel_name, message_count) tuples.
+        """
+        cursor = await db.conn.execute(
+            """
+            SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
+                   COUNT(*) AS cnt
+            FROM messages m
+            LEFT JOIN channels c ON m.conversation_key = c.key
+            WHERE m.type = 'CHAN' AND m.sender_key = ?
+            GROUP BY m.conversation_key
+            ORDER BY cnt DESC
+            LIMIT ?
+            """,
+            (sender_key.lower(), limit),
+        )
+        rows = await cursor.fetchall()
+        return [(row["conversation_key"], row["channel_name"], row["cnt"]) for row in rows]

app/repository/raw_packets.py

@@ -0,0 +1,150 @@
+import logging
+import sqlite3
+import time
+from hashlib import sha256
+
+from app.database import db
+from app.decoder import PayloadType, extract_payload, get_packet_payload_type
+
+logger = logging.getLogger(__name__)
+
+
+class RawPacketRepository:
+    @staticmethod
+    async def create(data: bytes, timestamp: int | None = None) -> tuple[int, bool]:
+        """
+        Create a raw packet with payload-based deduplication.
+
+        Returns (packet_id, is_new) tuple:
+        - is_new=True: New packet stored, packet_id is the new row ID
+        - is_new=False: Duplicate payload detected, packet_id is the existing row ID
+
+        Deduplication is based on the SHA-256 hash of the packet payload
+        (excluding routing/path information).
+        """
+        ts = timestamp if timestamp is not None else int(time.time())
+
+        # Compute payload hash for deduplication
+        payload = extract_payload(data)
+        if payload:
+            payload_hash = sha256(payload).digest()
+        else:
+            # For malformed packets, hash the full data
+            payload_hash = sha256(data).digest()
+
+        # Check if this payload already exists
+        cursor = await db.conn.execute(
+            "SELECT id FROM raw_packets WHERE payload_hash = ?", (payload_hash,)
+        )
+        existing = await cursor.fetchone()
+
+        if existing:
+            # Duplicate - return existing packet ID
+            logger.debug(
+                "Duplicate payload detected (hash=%s..., existing_id=%d)",
+                payload_hash.hex()[:12],
+                existing["id"],
+            )
+            return (existing["id"], False)
+
+        # New packet - insert with hash
+        try:
+            cursor = await db.conn.execute(
+                "INSERT INTO raw_packets (timestamp, data, payload_hash) VALUES (?, ?, ?)",
+                (ts, data, payload_hash),
+            )
+            await db.conn.commit()
+            assert cursor.lastrowid is not None  # INSERT always returns a row ID
+            return (cursor.lastrowid, True)
+        except sqlite3.IntegrityError:
+            # Race condition: another insert with same payload_hash happened between
+            # our SELECT and INSERT. This is expected for duplicate packets arriving
+            # close together. Query again to get the existing ID.
+            logger.debug(
+                "Duplicate packet detected via race condition (payload_hash=%s), dropping",
+                payload_hash.hex()[:16],
+            )
+            cursor = await db.conn.execute(
+                "SELECT id FROM raw_packets WHERE payload_hash = ?", (payload_hash,)
+            )
+            existing = await cursor.fetchone()
+            if existing:
+                return (existing["id"], False)
+            # This shouldn't happen, but if it does, re-raise
+            raise
+
+    @staticmethod
+    async def get_undecrypted_count() -> int:
+        """Get count of undecrypted packets (those without a linked message)."""
+        cursor = await db.conn.execute(
+            "SELECT COUNT(*) as count FROM raw_packets WHERE message_id IS NULL"
+        )
+        row = await cursor.fetchone()
+        return row["count"] if row else 0
+
+    @staticmethod
+    async def get_oldest_undecrypted() -> int | None:
+        """Get timestamp of oldest undecrypted packet, or None if none exist."""
+        cursor = await db.conn.execute(
+            "SELECT MIN(timestamp) as oldest FROM raw_packets WHERE message_id IS NULL"
+        )
+        row = await cursor.fetchone()
+        return row["oldest"] if row and row["oldest"] is not None else None
+
+    @staticmethod
+    async def get_all_undecrypted() -> list[tuple[int, bytes, int]]:
+        """Get all undecrypted packets as (id, data, timestamp) tuples."""
+        cursor = await db.conn.execute(
+            "SELECT id, data, timestamp FROM raw_packets WHERE message_id IS NULL ORDER BY timestamp ASC"
+        )
+        rows = await cursor.fetchall()
+        return [(row["id"], bytes(row["data"]), row["timestamp"]) for row in rows]
+
+    @staticmethod
+    async def mark_decrypted(packet_id: int, message_id: int) -> None:
+        """Link a raw packet to its decrypted message."""
+        await db.conn.execute(
+            "UPDATE raw_packets SET message_id = ? WHERE id = ?",
+            (message_id, packet_id),
+        )
+        await db.conn.commit()
+
+    @staticmethod
+    async def prune_old_undecrypted(max_age_days: int) -> int:
+        """Delete undecrypted packets older than max_age_days. Returns count deleted."""
+        cutoff = int(time.time()) - (max_age_days * 86400)
+        cursor = await db.conn.execute(
+            "DELETE FROM raw_packets WHERE message_id IS NULL AND timestamp < ?",
+            (cutoff,),
+        )
+        await db.conn.commit()
+        return cursor.rowcount
+
+    @staticmethod
+    async def purge_linked_to_messages() -> int:
+        """Delete raw packets that are already linked to a stored message."""
+        cursor = await db.conn.execute("DELETE FROM raw_packets WHERE message_id IS NOT NULL")
+        await db.conn.commit()
+        return cursor.rowcount
+
+    @staticmethod
+    async def get_undecrypted_text_messages() -> list[tuple[int, bytes, int]]:
+        """Get all undecrypted TEXT_MESSAGE packets as (id, data, timestamp) tuples.
+
+        Filters raw packets to only include those with PayloadType.TEXT_MESSAGE (0x02).
+        These are direct messages that can be decrypted with contact ECDH keys.
+        """
+        cursor = await db.conn.execute(
+            "SELECT id, data, timestamp FROM raw_packets WHERE message_id IS NULL ORDER BY timestamp ASC"
+        )
+        rows = await cursor.fetchall()
+
+        # Filter for TEXT_MESSAGE packets
+        result = []
+        for row in rows:
+            data = bytes(row["data"])
+            payload_type = get_packet_payload_type(data)
+            if payload_type == PayloadType.TEXT_MESSAGE:
+                result.append((row["id"], data, row["timestamp"]))
+
+        return result

app/repository/settings.py

@@ -0,0 +1,365 @@
+import json
+import logging
+import time
+from typing import Any, Literal
+
+from app.database import db
+from app.models import AppSettings, Favorite
+
+logger = logging.getLogger(__name__)
+
+SECONDS_1H = 3600
+SECONDS_24H = 86400
+SECONDS_7D = 604800
+
+
+class AppSettingsRepository:
+    """Repository for app_settings table (single-row pattern)."""
+
+    @staticmethod
+    async def get() -> AppSettings:
+        """Get the current app settings.
+
+        Always returns settings - creates default row if needed (migration handles initial row).
+        """
+        cursor = await db.conn.execute(
+            """
+            SELECT max_radio_contacts, favorites, auto_decrypt_dm_on_advert,
+                   sidebar_sort_order, last_message_times, preferences_migrated,
+                   advert_interval, last_advert_time, flood_scope,
+                   blocked_keys, blocked_names
+            FROM app_settings WHERE id = 1
+            """
+        )
+        row = await cursor.fetchone()
+
+        if not row:
+            # Should not happen after migration, but handle gracefully
+            return AppSettings()
+
+        # Parse favorites JSON
+        favorites = []
+        if row["favorites"]:
+            try:
+                favorites_data = json.loads(row["favorites"])
+                favorites = [Favorite(**f) for f in favorites_data]
+            except (json.JSONDecodeError, TypeError, KeyError) as e:
+                logger.warning(
+                    "Failed to parse favorites JSON, using empty list: %s (data=%r)",
+                    e,
+                    row["favorites"][:100] if row["favorites"] else None,
+                )
+                favorites = []
+
+        # Parse last_message_times JSON
+        last_message_times: dict[str, int] = {}
+        if row["last_message_times"]:
+            try:
+                last_message_times = json.loads(row["last_message_times"])
+            except (json.JSONDecodeError, TypeError) as e:
+                logger.warning(
+                    "Failed to parse last_message_times JSON, using empty dict: %s",
+                    e,
+                )
+                last_message_times = {}
+
+        # Parse blocked_keys JSON
+        blocked_keys: list[str] = []
+        if row["blocked_keys"]:
+            try:
+                blocked_keys = json.loads(row["blocked_keys"])
+            except (json.JSONDecodeError, TypeError):
+                blocked_keys = []
+
+        # Parse blocked_names JSON
+        blocked_names: list[str] = []
+        if row["blocked_names"]:
+            try:
+                blocked_names = json.loads(row["blocked_names"])
+            except (json.JSONDecodeError, TypeError):
+                blocked_names = []
+
+        # Validate sidebar_sort_order (fallback to "recent" if invalid)
+        sort_order = row["sidebar_sort_order"]
+        if sort_order not in ("recent", "alpha"):
+            sort_order = "recent"
+
+        return AppSettings(
+            max_radio_contacts=row["max_radio_contacts"],
+            favorites=favorites,
+            auto_decrypt_dm_on_advert=bool(row["auto_decrypt_dm_on_advert"]),
+            sidebar_sort_order=sort_order,
+            last_message_times=last_message_times,
+            preferences_migrated=bool(row["preferences_migrated"]),
+            advert_interval=row["advert_interval"] or 0,
+            last_advert_time=row["last_advert_time"] or 0,
+            flood_scope=row["flood_scope"] or "",
+            blocked_keys=blocked_keys,
+            blocked_names=blocked_names,
+        )
+
+    @staticmethod
+    async def update(
+        max_radio_contacts: int | None = None,
+        favorites: list[Favorite] | None = None,
+        auto_decrypt_dm_on_advert: bool | None = None,
+        sidebar_sort_order: str | None = None,
+        last_message_times: dict[str, int] | None = None,
+        preferences_migrated: bool | None = None,
+        advert_interval: int | None = None,
+        last_advert_time: int | None = None,
+        flood_scope: str | None = None,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
+    ) -> AppSettings:
+        """Update app settings. Only provided fields are updated."""
+        updates = []
+        params: list[Any] = []
+
+        if max_radio_contacts is not None:
+            updates.append("max_radio_contacts = ?")
+            params.append(max_radio_contacts)
+
+        if favorites is not None:
+            updates.append("favorites = ?")
+            favorites_json = json.dumps([f.model_dump() for f in favorites])
+            params.append(favorites_json)
+
+        if auto_decrypt_dm_on_advert is not None:
+            updates.append("auto_decrypt_dm_on_advert = ?")
+            params.append(1 if auto_decrypt_dm_on_advert else 0)
+
+        if sidebar_sort_order is not None:
+            updates.append("sidebar_sort_order = ?")
+            params.append(sidebar_sort_order)
+
+        if last_message_times is not None:
+            updates.append("last_message_times = ?")
+            params.append(json.dumps(last_message_times))
+
+        if preferences_migrated is not None:
+            updates.append("preferences_migrated = ?")
+            params.append(1 if preferences_migrated else 0)
+
+        if advert_interval is not None:
+            updates.append("advert_interval = ?")
+            params.append(advert_interval)
+
+        if last_advert_time is not None:
+            updates.append("last_advert_time = ?")
+            params.append(last_advert_time)
+
+        if flood_scope is not None:
+            updates.append("flood_scope = ?")
+            params.append(flood_scope)
+
+        if blocked_keys is not None:
+            updates.append("blocked_keys = ?")
+            params.append(json.dumps(blocked_keys))
+
+        if blocked_names is not None:
+            updates.append("blocked_names = ?")
+            params.append(json.dumps(blocked_names))
+
+        if updates:
+            query = f"UPDATE app_settings SET {', '.join(updates)} WHERE id = 1"
+            await db.conn.execute(query, params)
+            await db.conn.commit()
+
+        return await AppSettingsRepository.get()
+
+    @staticmethod
+    async def add_favorite(fav_type: Literal["channel", "contact"], fav_id: str) -> AppSettings:
+        """Add a favorite, avoiding duplicates."""
+        settings = await AppSettingsRepository.get()
+
+        # Check if already favorited
+        if any(f.type == fav_type and f.id == fav_id for f in settings.favorites):
+            return settings
+
+        new_favorites = settings.favorites + [Favorite(type=fav_type, id=fav_id)]
+        return await AppSettingsRepository.update(favorites=new_favorites)
+
+    @staticmethod
+    async def remove_favorite(fav_type: Literal["channel", "contact"], fav_id: str) -> AppSettings:
+        """Remove a favorite."""
+        settings = await AppSettingsRepository.get()
+        new_favorites = [
+            f for f in settings.favorites if not (f.type == fav_type and f.id == fav_id)
+        ]
+        return await AppSettingsRepository.update(favorites=new_favorites)
+
+    @staticmethod
+    async def toggle_blocked_key(key: str) -> AppSettings:
+        """Toggle a public key in the blocked list. Keys are normalized to lowercase."""
+        normalized = key.lower()
+        settings = await AppSettingsRepository.get()
+        if normalized in settings.blocked_keys:
+            new_keys = [k for k in settings.blocked_keys if k != normalized]
+        else:
+            new_keys = settings.blocked_keys + [normalized]
+        return await AppSettingsRepository.update(blocked_keys=new_keys)
+
+    @staticmethod
+    async def toggle_blocked_name(name: str) -> AppSettings:
+        """Toggle a display name in the blocked list."""
+        settings = await AppSettingsRepository.get()
+        if name in settings.blocked_names:
+            new_names = [n for n in settings.blocked_names if n != name]
+        else:
+            new_names = settings.blocked_names + [name]
+        return await AppSettingsRepository.update(blocked_names=new_names)
+
+    @staticmethod
+    async def migrate_preferences_from_frontend(
+        favorites: list[dict],
+        sort_order: str,
+        last_message_times: dict[str, int],
+    ) -> tuple[AppSettings, bool]:
+        """Migrate all preferences from frontend localStorage.
+
+        This is a one-time migration. If already migrated, returns current settings
+        without overwriting. Returns (settings, did_migrate) tuple.
+        """
+        settings = await AppSettingsRepository.get()
+
+        if settings.preferences_migrated:
+            # Already migrated, don't overwrite
+            return settings, False
+
+        # Convert frontend favorites format to Favorite objects
+        new_favorites = []
+        for f in favorites:
+            if f.get("type") in ("channel", "contact") and f.get("id"):
+                new_favorites.append(Favorite(type=f["type"], id=f["id"]))
+
+        # Update with migrated preferences and mark as migrated
+        settings = await AppSettingsRepository.update(
+            favorites=new_favorites,
+            sidebar_sort_order=sort_order if sort_order in ("recent", "alpha") else "recent",
+            last_message_times=last_message_times,
+            preferences_migrated=True,
+        )
+
+        return settings, True
+
+
+class StatisticsRepository:
+    @staticmethod
+    async def _activity_counts(*, contact_type: int, exclude: bool = False) -> dict[str, int]:
+        """Get time-windowed counts for contacts/repeaters heard."""
+        now = int(time.time())
+        op = "!=" if exclude else "="
+        cursor = await db.conn.execute(
+            f"""
+            SELECT
+                SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_hour,
+                SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_24_hours,
+                SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_week
+            FROM contacts
+            WHERE type {op} ? AND last_seen IS NOT NULL
+            """,
+            (now - SECONDS_1H, now - SECONDS_24H, now - SECONDS_7D, contact_type),
+        )
+        row = await cursor.fetchone()
+        assert row is not None  # Aggregate query always returns a row
+        return {
+            "last_hour": row["last_hour"] or 0,
+            "last_24_hours": row["last_24_hours"] or 0,
+            "last_week": row["last_week"] or 0,
+        }
+
+    @staticmethod
+    async def get_all() -> dict:
+        """Aggregate all statistics from existing tables."""
+        now = int(time.time())
+
+        # Top 5 busiest channels in last 24h
+        cursor = await db.conn.execute(
+            """
+            SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
+                   COUNT(*) AS message_count
+            FROM messages m
+            LEFT JOIN channels c ON m.conversation_key = c.key
+            WHERE m.type = 'CHAN' AND m.received_at >= ?
+            GROUP BY m.conversation_key
+            ORDER BY COUNT(*) DESC
+            LIMIT 5
+            """,
+            (now - SECONDS_24H,),
+        )
+        rows = await cursor.fetchall()
+        busiest_channels_24h = [
+            {
+                "channel_key": row["conversation_key"],
+                "channel_name": row["channel_name"],
+                "message_count": row["message_count"],
+            }
+            for row in rows
+        ]
+
+        # Entity counts
+        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM contacts WHERE type != 2")
+        row = await cursor.fetchone()
+        assert row is not None
+        contact_count: int = row["cnt"]
+
+        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM contacts WHERE type = 2")
+        row = await cursor.fetchone()
+        assert row is not None
+        repeater_count: int = row["cnt"]
+
+        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM channels")
+        row = await cursor.fetchone()
+        assert row is not None
+        channel_count: int = row["cnt"]
+
+        # Packet split
+        cursor = await db.conn.execute(
+            """
+            SELECT COUNT(*) AS total,
+                   SUM(CASE WHEN message_id IS NOT NULL THEN 1 ELSE 0 END) AS decrypted
+            FROM raw_packets
+            """
+        )
+        pkt_row = await cursor.fetchone()
+        assert pkt_row is not None
+        total_packets = pkt_row["total"] or 0
+        decrypted_packets = pkt_row["decrypted"] or 0
+        undecrypted_packets = total_packets - decrypted_packets
+
+        # Message type counts
+        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM messages WHERE type = 'PRIV'")
+        row = await cursor.fetchone()
+        assert row is not None
+        total_dms: int = row["cnt"]
+
+        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM messages WHERE type = 'CHAN'")
+        row = await cursor.fetchone()
+        assert row is not None
+        total_channel_messages: int = row["cnt"]
+
+        # Outgoing count
+        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM messages WHERE outgoing = 1")
+        row = await cursor.fetchone()
+        assert row is not None
+        total_outgoing: int = row["cnt"]
+
+        # Activity windows
+        contacts_heard = await StatisticsRepository._activity_counts(contact_type=2, exclude=True)
+        repeaters_heard = await StatisticsRepository._activity_counts(contact_type=2)
+
+        return {
+            "busiest_channels_24h": busiest_channels_24h,
+            "contact_count": contact_count,
+            "repeater_count": repeater_count,
+            "channel_count": channel_count,
+            "total_packets": total_packets,
+            "decrypted_packets": decrypted_packets,
+            "undecrypted_packets": undecrypted_packets,
+            "total_dms": total_dms,
+            "total_channel_messages": total_channel_messages,
+            "total_outgoing": total_outgoing,
+            "contacts_heard": contacts_heard,
+            "repeaters_heard": repeaters_heard,
+        }

app/routers/channels.py

@@ -6,10 +6,10 @@ from meshcore import EventType
 from pydantic import BaseModel, Field
 
 from app.dependencies import require_connected
-from app.models import Channel
+from app.models import Channel, ChannelDetail, ChannelMessageCounts, ChannelTopSender
 from app.radio import radio_manager
-from app.radio_sync import ensure_default_channels
-from app.repository import ChannelRepository
+from app.radio_sync import upsert_channel_from_radio_slot
+from app.repository import ChannelRepository, MessageRepository
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/channels", tags=["channels"])
@@ -26,11 +26,27 @@ class CreateChannelRequest(BaseModel):
 @router.get("", response_model=list[Channel])
 async def list_channels() -> list[Channel]:
     """List all channels from the database."""
-    # Ensure Public channel always exists (self-healing)
-    await ensure_default_channels()
     return await ChannelRepository.get_all()
 
 
+@router.get("/{key}/detail", response_model=ChannelDetail)
+async def get_channel_detail(key: str) -> ChannelDetail:
+    """Get comprehensive channel profile data with message statistics."""
+    channel = await ChannelRepository.get_by_key(key)
+    if not channel:
+        raise HTTPException(status_code=404, detail="Channel not found")
+
+    stats = await MessageRepository.get_channel_stats(channel.key)
+
+    return ChannelDetail(
+        channel=channel,
+        message_counts=ChannelMessageCounts(**stats["message_counts"]),
+        first_message_at=stats["first_message_at"],
+        unique_sender_count=stats["unique_sender_count"],
+        top_senders_24h=[ChannelTopSender(**s) for s in stats["top_senders_24h"]],
+    )
+
+
 @router.get("/{key}", response_model=Channel)
 async def get_channel(key: str) -> Channel:
     """Get a specific channel by key (32-char hex string)."""
@@ -85,36 +101,22 @@ async def create_channel(request: CreateChannelRequest) -> Channel:
 @router.post("/sync")
 async def sync_channels_from_radio(max_channels: int = Query(default=40, ge=1, le=40)) -> dict:
     """Sync channels from the radio to the database."""
-    mc = require_connected()
+    require_connected()
 
     logger.info("Syncing channels from radio (checking %d slots)", max_channels)
     count = 0
 
-    async with radio_manager.radio_operation("sync_channels_from_radio"):
+    async with radio_manager.radio_operation("sync_channels_from_radio") as mc:
         for idx in range(max_channels):
             result = await mc.commands.get_channel(idx)
 
             if result.type == EventType.CHANNEL_INFO:
-                payload = result.payload
-                name = payload.get("channel_name", "")
-                secret = payload.get("channel_secret", b"")
-
-                # Skip empty channels
-                if not name or name == "\x00" * len(name):
-                    continue
-
-                is_hashtag = name.startswith("#")
-                key_bytes = secret if isinstance(secret, bytes) else bytes(secret)
-                key_hex = key_bytes.hex().upper()
-
-                await ChannelRepository.upsert(
-                    key=key_hex,
-                    name=name,
-                    is_hashtag=is_hashtag,
-                    on_radio=True,
-                )
-                count += 1
-                logger.debug("Synced channel %s: %s", key_hex, name)
+                key_hex = await upsert_channel_from_radio_slot(result.payload, on_radio=True)
+                if key_hex is not None:
+                    count += 1
+                    logger.debug(
+                        "Synced channel %s: %s", key_hex, result.payload.get("channel_name")
+                    )
 
     logger.info("Synced %d channels from radio", count)
     return {"synced": count}
@@ -143,4 +145,9 @@ async def delete_channel(key: str) -> dict:
     """
     logger.info("Deleting channel %s from database", key)
     await ChannelRepository.delete(key)
+
+    from app.websocket import broadcast_event
+
+    broadcast_event("channel_deleted", {"key": key})
+
     return {"status": "ok"}

app/routers/contacts.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 import random
 
@@ -7,35 +6,30 @@ from meshcore import EventType
 
 from app.dependencies import require_connected
 from app.models import (
-    CONTACT_TYPE_REPEATER,
-    AclEntry,
-    CommandRequest,
-    CommandResponse,
     Contact,
+    ContactActiveRoom,
+    ContactAdvertPath,
+    ContactAdvertPathSummary,
+    ContactDetail,
     CreateContactRequest,
-    NeighborInfo,
-    TelemetryRequest,
-    TelemetryResponse,
+    NearestRepeater,
     TraceResponse,
 )
 from app.packet_processor import start_historical_dm_decryption
+from app.path_utils import first_path_hop
 from app.radio import radio_manager
-from app.repository import AmbiguousPublicKeyPrefixError, ContactRepository, MessageRepository
+from app.repository import (
+    AmbiguousPublicKeyPrefixError,
+    ContactAdvertPathRepository,
+    ContactNameHistoryRepository,
+    ContactRepository,
+    MessageRepository,
+)
 
 logger = logging.getLogger(__name__)
 
-# ACL permission level names
-ACL_PERMISSION_NAMES = {
-    0: "Guest",
-    1: "Read-only",
-    2: "Read-write",
-    3: "Admin",
-}
 router = APIRouter(prefix="/contacts", tags=["contacts"])
 
-# Delay between repeater radio operations to allow key exchange and path establishment
-REPEATER_OP_DELAY_SECONDS = 2.0
-
 
 def _ambiguous_contact_detail(err: AmbiguousPublicKeyPrefixError) -> str:
     sample = ", ".join(key[:12] for key in err.matches[:2])
@@ -57,31 +51,13 @@ async def _resolve_contact_or_404(
     return contact
 
 
-async def prepare_repeater_connection(mc, contact: Contact, password: str) -> None:
-    """Prepare connection to a repeater by adding to radio and logging in.
-
-    Args:
-        mc: MeshCore instance
-        contact: The repeater contact
-        password: Password for login (empty string for no password)
-
-    Raises:
-        HTTPException: If login fails
-    """
-    # Add contact to radio with path from DB
-    logger.info("Adding repeater %s to radio", contact.public_key[:12])
-    await mc.commands.add_contact(contact.to_radio_dict())
-
-    # Send login with password
-    logger.info("Sending login to repeater %s", contact.public_key[:12])
-    login_result = await mc.commands.send_login(contact.public_key, password)
-
-    if login_result.type == EventType.ERROR:
-        raise HTTPException(status_code=401, detail=f"Login failed: {login_result.payload}")
-
-    # Wait for key exchange to complete before sending requests
-    logger.debug("Waiting %.1fs for key exchange to complete", REPEATER_OP_DELAY_SECONDS)
-    await asyncio.sleep(REPEATER_OP_DELAY_SECONDS)
+async def _ensure_on_radio(mc, contact: Contact) -> None:
+    """Add a contact to the radio for routing, raising 500 on failure."""
+    add_result = await mc.commands.add_contact(contact.to_radio_dict())
+    if add_result is not None and add_result.type == EventType.ERROR:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to add contact to radio: {add_result.payload}"
+        )
 
 
 @router.get("", response_model=list[Contact])
@@ -93,6 +69,20 @@ async def list_contacts(
     return await ContactRepository.get_all(limit=limit, offset=offset)
 
 
+@router.get("/repeaters/advert-paths", response_model=list[ContactAdvertPathSummary])
+async def list_repeater_advert_paths(
+    limit_per_repeater: int = Query(default=10, ge=1, le=50),
+) -> list[ContactAdvertPathSummary]:
+    """List recent unique advert paths for all repeaters.
+
+    Note: This endpoint now returns paths for all contacts (table was renamed).
+    The route is kept for backward compatibility.
+    """
+    return await ContactAdvertPathRepository.get_recent_for_all_contacts(
+        limit_per_contact=limit_per_repeater
+    )
+
+
 @router.post("", response_model=Contact)
 async def create_contact(
     request: CreateContactRequest, background_tasks: BackgroundTasks
@@ -129,7 +119,9 @@ async def create_contact(
                     "last_contacted": existing.last_contacted,
                 }
             )
-            existing.name = request.name
+            refreshed = await ContactRepository.get_by_key(request.public_key)
+            if refreshed is not None:
+                existing = refreshed
 
         # Trigger historical decryption if requested (even for existing contacts)
         if request.try_historical:
@@ -163,6 +155,14 @@ async def create_contact(
     if claimed > 0:
         logger.info("Claimed %d prefix messages for contact %s", claimed, lower_key[:12])
 
+    # Backfill sender_key on channel messages that match this contact's name
+    if request.name:
+        backfilled = await MessageRepository.backfill_channel_sender_key(lower_key, request.name)
+        if backfilled > 0:
+            logger.info(
+                "Backfilled sender_key on %d channel message(s) for %s", backfilled, request.name
+            )
+
     # Trigger historical decryption if requested
     if request.try_historical:
         await start_historical_dm_decryption(background_tasks, lower_key, request.name)
@@ -170,20 +170,109 @@ async def create_contact(
     return Contact(**contact_data)
 
 
+@router.get("/{public_key}/detail", response_model=ContactDetail)
+async def get_contact_detail(public_key: str) -> ContactDetail:
+    """Get comprehensive contact profile data.
+
+    Returns contact info, name history, message counts, most active rooms,
+    advertisement paths, advert frequency, and nearest repeaters.
+    """
+    contact = await _resolve_contact_or_404(public_key)
+
+    name_history = await ContactNameHistoryRepository.get_history(contact.public_key)
+    dm_count = await MessageRepository.count_dm_messages(contact.public_key)
+    chan_count = await MessageRepository.count_channel_messages_by_sender(contact.public_key)
+    active_rooms_raw = await MessageRepository.get_most_active_rooms(contact.public_key)
+    advert_paths = await ContactAdvertPathRepository.get_recent_for_contact(contact.public_key)
+
+    most_active_rooms = [
+        ContactActiveRoom(channel_key=key, channel_name=name, message_count=count)
+        for key, name, count in active_rooms_raw
+    ]
+
+    # Compute advert observation rate (observations/hour) from path data.
+    # Note: a single advertisement can arrive via multiple paths, so this counts
+    # RF observations, not unique advertisement broadcasts.
+    advert_frequency: float | None = None
+    if advert_paths:
+        total_observations = sum(p.heard_count for p in advert_paths)
+        earliest = min(p.first_seen for p in advert_paths)
+        latest = max(p.last_seen for p in advert_paths)
+        span_hours = (latest - earliest) / 3600.0
+        if span_hours > 0:
+            advert_frequency = round(total_observations / span_hours, 2)
+
+    # Compute nearest repeaters from first hops in advert paths
+    first_hop_stats: dict[str, dict] = {}  # first hop -> {heard_count, path_len, last_seen}
+    for p in advert_paths:
+        prefix = first_path_hop(p.path, p.path_len)
+        if prefix:
+            if prefix not in first_hop_stats:
+                first_hop_stats[prefix] = {
+                    "heard_count": 0,
+                    "path_len": p.path_len,
+                    "last_seen": p.last_seen,
+                }
+            first_hop_stats[prefix]["heard_count"] += p.heard_count
+            first_hop_stats[prefix]["last_seen"] = max(
+                first_hop_stats[prefix]["last_seen"], p.last_seen
+            )
+
+    # Resolve all first-hop prefixes to contacts in a single query
+    resolved_contacts = await ContactRepository.resolve_prefixes(list(first_hop_stats.keys()))
+
+    nearest_repeaters: list[NearestRepeater] = []
+    for prefix, stats in first_hop_stats.items():
+        resolved = resolved_contacts.get(prefix)
+        nearest_repeaters.append(
+            NearestRepeater(
+                public_key=resolved.public_key if resolved else prefix,
+                name=resolved.name if resolved else None,
+                path_len=stats["path_len"],
+                last_seen=stats["last_seen"],
+                heard_count=stats["heard_count"],
+            )
+        )
+
+    nearest_repeaters.sort(key=lambda r: r.heard_count, reverse=True)
+
+    return ContactDetail(
+        contact=contact,
+        name_history=name_history,
+        dm_message_count=dm_count,
+        channel_message_count=chan_count,
+        most_active_rooms=most_active_rooms,
+        advert_paths=advert_paths,
+        advert_frequency=advert_frequency,
+        nearest_repeaters=nearest_repeaters,
+    )
+
+
 @router.get("/{public_key}", response_model=Contact)
 async def get_contact(public_key: str) -> Contact:
     """Get a specific contact by public key or prefix."""
     return await _resolve_contact_or_404(public_key)
 
 
+@router.get("/{public_key}/advert-paths", response_model=list[ContactAdvertPath])
+async def get_contact_advert_paths(
+    public_key: str,
+    limit: int = Query(default=10, ge=1, le=50),
+) -> list[ContactAdvertPath]:
+    """List recent unique advert paths for a contact."""
+    contact = await _resolve_contact_or_404(public_key)
+    return await ContactAdvertPathRepository.get_recent_for_contact(contact.public_key, limit)
+
+
 @router.post("/sync")
 async def sync_contacts_from_radio() -> dict:
     """Sync contacts from the radio to the database."""
-    mc = require_connected()
+    require_connected()
 
     logger.info("Syncing contacts from radio")
 
-    result = await mc.commands.get_contacts()
+    async with radio_manager.radio_operation("sync_contacts_from_radio") as mc:
+        result = await mc.commands.get_contacts()
 
     if result.type == EventType.ERROR:
         raise HTTPException(status_code=500, detail=f"Failed to get contacts: {result.payload}")
@@ -191,12 +280,30 @@ async def sync_contacts_from_radio() -> dict:
     contacts = result.payload
     count = 0
 
+    synced_keys: list[str] = []
     for public_key, contact_data in contacts.items():
+        lower_key = public_key.lower()
         await ContactRepository.upsert(
-            Contact.from_radio_dict(public_key, contact_data, on_radio=True)
+            Contact.from_radio_dict(lower_key, contact_data, on_radio=True)
         )
+        synced_keys.append(lower_key)
+        claimed = await MessageRepository.claim_prefix_messages(lower_key)
+        if claimed > 0:
+            logger.info("Claimed %d prefix DM message(s) for contact %s", claimed, public_key[:12])
+        adv_name = contact_data.get("adv_name")
+        if adv_name:
+            backfilled = await MessageRepository.backfill_channel_sender_key(lower_key, adv_name)
+            if backfilled > 0:
+                logger.info(
+                    "Backfilled sender_key on %d channel message(s) for %s",
+                    backfilled,
+                    adv_name,
+                )
         count += 1
 
+    # Clear on_radio for contacts not found on the radio
+    await ContactRepository.clear_on_radio_except(synced_keys)
+
     logger.info("Synced %d contacts from radio", count)
     return {"synced": count}
 
@@ -204,23 +311,26 @@ async def sync_contacts_from_radio() -> dict:
 @router.post("/{public_key}/remove-from-radio")
 async def remove_contact_from_radio(public_key: str) -> dict:
     """Remove a contact from the radio (keeps it in database)."""
-    mc = require_connected()
+    require_connected()
 
     contact = await _resolve_contact_or_404(public_key)
 
-    # Get the contact from radio
-    radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
-    if not radio_contact:
-        # Already not on radio
-        await ContactRepository.set_on_radio(contact.public_key, False)
-        return {"status": "ok", "message": "Contact was not on radio"}
+    async with radio_manager.radio_operation("remove_contact_from_radio") as mc:
+        # Get the contact from radio
+        radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+        if not radio_contact:
+            # Already not on radio
+            await ContactRepository.set_on_radio(contact.public_key, False)
+            return {"status": "ok", "message": "Contact was not on radio"}
 
-    logger.info("Removing contact %s from radio", contact.public_key[:12])
+        logger.info("Removing contact %s from radio", contact.public_key[:12])
 
-    result = await mc.commands.remove_contact(radio_contact)
+        result = await mc.commands.remove_contact(radio_contact)
 
-    if result.type == EventType.ERROR:
-        raise HTTPException(status_code=500, detail=f"Failed to remove contact: {result.payload}")
+        if result.type == EventType.ERROR:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to remove contact: {result.payload}"
+            )
 
     await ContactRepository.set_on_radio(contact.public_key, False)
     return {"status": "ok"}
@@ -229,21 +339,22 @@ async def remove_contact_from_radio(public_key: str) -> dict:
 @router.post("/{public_key}/add-to-radio")
 async def add_contact_to_radio(public_key: str) -> dict:
     """Add a contact from the database to the radio."""
-    mc = require_connected()
+    require_connected()
 
     contact = await _resolve_contact_or_404(public_key, "Contact not found in database")
 
-    # Check if already on radio
-    radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
-    if radio_contact:
-        return {"status": "ok", "message": "Contact already on radio"}
+    async with radio_manager.radio_operation("add_contact_to_radio") as mc:
+        # Check if already on radio
+        radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+        if radio_contact:
+            return {"status": "ok", "message": "Contact already on radio"}
 
-    logger.info("Adding contact %s to radio", contact.public_key[:12])
+        logger.info("Adding contact %s to radio", contact.public_key[:12])
 
-    result = await mc.commands.add_contact(contact.to_radio_dict())
+        result = await mc.commands.add_contact(contact.to_radio_dict())
 
-    if result.type == EventType.ERROR:
-        raise HTTPException(status_code=500, detail=f"Failed to add contact: {result.payload}")
+        if result.type == EventType.ERROR:
+            raise HTTPException(status_code=500, detail=f"Failed to add contact: {result.payload}")
 
     await ContactRepository.set_on_radio(contact.public_key, True)
     return {"status": "ok"}
@@ -267,274 +378,26 @@ async def delete_contact(public_key: str) -> dict:
     contact = await _resolve_contact_or_404(public_key)
 
     # Remove from radio if connected and contact is on radio
-    if radio_manager.is_connected and radio_manager.meshcore:
-        mc = radio_manager.meshcore
-        radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
-        if radio_contact:
-            logger.info("Removing contact %s from radio before deletion", contact.public_key[:12])
-            await mc.commands.remove_contact(radio_contact)
+    if radio_manager.is_connected:
+        async with radio_manager.radio_operation("delete_contact_from_radio") as mc:
+            radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+            if radio_contact:
+                logger.info(
+                    "Removing contact %s from radio before deletion", contact.public_key[:12]
+                )
+                await mc.commands.remove_contact(radio_contact)
 
     # Delete from database
     await ContactRepository.delete(contact.public_key)
     logger.info("Deleted contact %s", contact.public_key[:12])
 
+    from app.websocket import broadcast_event
+
+    broadcast_event("contact_deleted", {"public_key": contact.public_key})
+
     return {"status": "ok"}
 
 
-@router.post("/{public_key}/telemetry", response_model=TelemetryResponse)
-async def request_telemetry(public_key: str, request: TelemetryRequest) -> TelemetryResponse:
-    """Request telemetry from a repeater.
-
-    The contact must be a repeater (type=2). If not on the radio, it will be added.
-    Uses login + status request with retry logic.
-    """
-    mc = require_connected()
-
-    # Get contact from database
-    contact = await _resolve_contact_or_404(public_key)
-
-    # Verify it's a repeater
-    if contact.type != CONTACT_TYPE_REPEATER:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Contact is not a repeater (type={contact.type}, expected {CONTACT_TYPE_REPEATER})",
-        )
-
-    async with radio_manager.radio_operation(
-        "request_telemetry",
-        meshcore=mc,
-        pause_polling=True,
-        suspend_auto_fetch=True,
-    ):
-        # Prepare connection (add/remove dance + login)
-        await prepare_repeater_connection(mc, contact, request.password)
-
-        # Request status with retries
-        logger.info("Requesting status from repeater %s", contact.public_key[:12])
-        status = None
-        for attempt in range(1, 4):
-            logger.debug("Status request attempt %d/3", attempt)
-            status = await mc.commands.req_status_sync(
-                contact.public_key, timeout=10, min_timeout=5
-            )
-            if status:
-                break
-            logger.debug("Status request timeout, retrying...")
-
-        if not status:
-            raise HTTPException(
-                status_code=504, detail="No response from repeater after 3 attempts"
-            )
-
-        logger.info("Received telemetry from %s: %s", contact.public_key[:12], status)
-
-        # Fetch neighbors (fetch_all_neighbours handles pagination)
-        logger.info("Fetching neighbors from repeater %s", contact.public_key[:12])
-        neighbors_data = None
-        for attempt in range(1, 4):
-            logger.debug("Neighbors request attempt %d/3", attempt)
-            neighbors_data = await mc.commands.fetch_all_neighbours(
-                contact.public_key, timeout=10, min_timeout=5
-            )
-            if neighbors_data:
-                break
-            logger.debug("Neighbors request timeout, retrying...")
-
-        # Process neighbors - resolve pubkey prefixes to contact names
-        neighbors: list[NeighborInfo] = []
-        if neighbors_data and "neighbours" in neighbors_data:
-            logger.info("Received %d neighbors", len(neighbors_data["neighbours"]))
-            for n in neighbors_data["neighbours"]:
-                pubkey_prefix = n.get("pubkey", "")
-                # Try to resolve to a contact name from our database
-                resolved_contact = await ContactRepository.get_by_key_prefix(pubkey_prefix)
-                neighbors.append(
-                    NeighborInfo(
-                        pubkey_prefix=pubkey_prefix,
-                        name=resolved_contact.name if resolved_contact else None,
-                        snr=n.get("snr", 0.0),
-                        last_heard_seconds=n.get("secs_ago", 0),
-                    )
-                )
-
-        # Fetch ACL
-        logger.info("Fetching ACL from repeater %s", contact.public_key[:12])
-        acl_data = None
-        for attempt in range(1, 4):
-            logger.debug("ACL request attempt %d/3", attempt)
-            acl_data = await mc.commands.req_acl_sync(contact.public_key, timeout=10, min_timeout=5)
-            if acl_data:
-                break
-            logger.debug("ACL request timeout, retrying...")
-
-        # Process ACL - resolve pubkey prefixes to contact names
-        acl_entries: list[AclEntry] = []
-        if acl_data and isinstance(acl_data, list):
-            logger.info("Received %d ACL entries", len(acl_data))
-            for entry in acl_data:
-                pubkey_prefix = entry.get("key", "")
-                perm = entry.get("perm", 0)
-                # Try to resolve to a contact name from our database
-                resolved_contact = await ContactRepository.get_by_key_prefix(pubkey_prefix)
-                acl_entries.append(
-                    AclEntry(
-                        pubkey_prefix=pubkey_prefix,
-                        name=resolved_contact.name if resolved_contact else None,
-                        permission=perm,
-                        permission_name=ACL_PERMISSION_NAMES.get(perm, f"Unknown({perm})"),
-                    )
-                )
-
-        # Fetch clock output (up to 2 attempts)
-        logger.info("Fetching clock from repeater %s", contact.public_key[:12])
-        clock_output: str | None = None
-        for attempt in range(1, 3):
-            logger.debug("Clock request attempt %d/2", attempt)
-            try:
-                send_result = await mc.commands.send_cmd(contact.public_key, "clock")
-                if send_result.type == EventType.ERROR:
-                    logger.debug("Clock command send error: %s", send_result.payload)
-                    continue
-
-                # Wait for response
-                wait_result = await mc.wait_for_event(EventType.MESSAGES_WAITING, timeout=5.0)
-                if wait_result is None:
-                    logger.debug("Clock request timeout, retrying...")
-                    continue
-
-                response_event = await mc.commands.get_msg()
-                if response_event.type == EventType.ERROR:
-                    logger.debug("Clock get_msg error: %s", response_event.payload)
-                    continue
-
-                clock_output = response_event.payload.get("text", "")
-                logger.info("Received clock output: %s", clock_output)
-                break
-            except Exception as e:
-                logger.debug("Clock request exception: %s", e)
-                continue
-
-    if clock_output is None:
-        clock_output = "Unable to fetch `clock` output (repeater did not respond)"
-
-    # Convert raw telemetry to response format
-    # bat is in mV, convert to V (e.g., 3775 -> 3.775)
-
-    return TelemetryResponse(
-        pubkey_prefix=status.get("pubkey_pre", contact.public_key[:12]),
-        battery_volts=status.get("bat", 0) / 1000.0,
-        tx_queue_len=status.get("tx_queue_len", 0),
-        noise_floor_dbm=status.get("noise_floor", 0),
-        last_rssi_dbm=status.get("last_rssi", 0),
-        last_snr_db=status.get("last_snr", 0.0),
-        packets_received=status.get("nb_recv", 0),
-        packets_sent=status.get("nb_sent", 0),
-        airtime_seconds=status.get("airtime", 0),
-        rx_airtime_seconds=status.get("rx_airtime", 0),
-        uptime_seconds=status.get("uptime", 0),
-        sent_flood=status.get("sent_flood", 0),
-        sent_direct=status.get("sent_direct", 0),
-        recv_flood=status.get("recv_flood", 0),
-        recv_direct=status.get("recv_direct", 0),
-        flood_dups=status.get("flood_dups", 0),
-        direct_dups=status.get("direct_dups", 0),
-        full_events=status.get("full_evts", 0),
-        neighbors=neighbors,
-        acl=acl_entries,
-        clock_output=clock_output,
-    )
-
-
-@router.post("/{public_key}/command", response_model=CommandResponse)
-async def send_repeater_command(public_key: str, request: CommandRequest) -> CommandResponse:
-    """Send a CLI command to a repeater.
-
-    The contact must be a repeater (type=2). The user must have already logged in
-    via the telemetry endpoint. This endpoint ensures the contact is on the radio
-    before sending commands (the repeater remembers ACL permissions after login).
-
-    Common commands:
-    - get name, set name <value>
-    - get tx, set tx <dbm>
-    - get radio, set radio <freq,bw,sf,cr>
-    - tempradio <freq,bw,sf,cr,minutes>
-    - setperm <pubkey> <permission>  (0=guest, 1=read-only, 2=read-write, 3=admin)
-    - clock, clock sync
-    - reboot
-    - ver
-    """
-    mc = require_connected()
-
-    # Get contact from database
-    contact = await _resolve_contact_or_404(public_key)
-
-    # Verify it's a repeater
-    if contact.type != CONTACT_TYPE_REPEATER:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Contact is not a repeater (type={contact.type}, expected {CONTACT_TYPE_REPEATER})",
-        )
-
-    async with radio_manager.radio_operation(
-        "send_repeater_command",
-        meshcore=mc,
-        pause_polling=True,
-        suspend_auto_fetch=True,
-    ):
-        # Add contact to radio with path from DB
-        logger.info("Adding repeater %s to radio", contact.public_key[:12])
-        await mc.commands.add_contact(contact.to_radio_dict())
-
-        # Send the command
-        logger.info("Sending command to repeater %s: %s", contact.public_key[:12], request.command)
-
-        send_result = await mc.commands.send_cmd(contact.public_key, request.command)
-
-        if send_result.type == EventType.ERROR:
-            raise HTTPException(
-                status_code=500, detail=f"Failed to send command: {send_result.payload}"
-            )
-
-        # Wait for response (MESSAGES_WAITING event, then get_msg)
-        try:
-            wait_result = await mc.wait_for_event(EventType.MESSAGES_WAITING, timeout=10.0)
-
-            if wait_result is None:
-                # Timeout - no response received
-                logger.warning(
-                    "No response from repeater %s for command: %s",
-                    contact.public_key[:12],
-                    request.command,
-                )
-                return CommandResponse(
-                    command=request.command,
-                    response="(no response - command may have been processed)",
-                )
-
-            response_event = await mc.commands.get_msg()
-
-            if response_event.type == EventType.ERROR:
-                return CommandResponse(
-                    command=request.command, response=f"(error: {response_event.payload})"
-                )
-
-            # Extract the response text and timestamp from the payload
-            response_text = response_event.payload.get("text", str(response_event.payload))
-            sender_timestamp = response_event.payload.get("timestamp")
-            logger.info("Received response from %s: %s", contact.public_key[:12], response_text)
-
-            return CommandResponse(
-                command=request.command,
-                response=response_text,
-                sender_timestamp=sender_timestamp,
-            )
-        except Exception as e:
-            logger.error("Error waiting for response: %s", e)
-            return CommandResponse(
-                command=request.command, response=f"(error waiting for response: {e})"
-            )
-
-
 @router.post("/{public_key}/trace", response_model=TraceResponse)
 async def request_trace(public_key: str) -> TraceResponse:
     """Send a single-hop trace to a contact and wait for the result.
@@ -543,7 +406,7 @@ async def request_trace(public_key: str) -> TraceResponse:
     (no intermediate repeaters). The radio firmware requires at least one
     node in the path.
     """
-    mc = require_connected()
+    require_connected()
 
     contact = await _resolve_contact_or_404(public_key)
 
@@ -553,9 +416,9 @@ async def request_trace(public_key: str) -> TraceResponse:
 
     # Trace does not need auto-fetch suspension: response arrives as TRACE_DATA
     # from the reader loop, not via get_msg().
-    async with radio_manager.radio_operation("request_trace", pause_polling=True):
+    async with radio_manager.radio_operation("request_trace", pause_polling=True) as mc:
         # Ensure contact is on radio so the trace can reach them
-        await mc.commands.add_contact(contact.to_radio_dict())
+        await _ensure_on_radio(mc, contact)
 
         logger.info(
             "Sending trace to %s (tag=%d, hash=%s)", contact.public_key[:12], tag, contact_hash
@@ -593,3 +456,31 @@ async def request_trace(public_key: str) -> TraceResponse:
     )
 
     return TraceResponse(remote_snr=remote_snr, local_snr=local_snr, path_len=path_len)
+
+
+@router.post("/{public_key}/reset-path")
+async def reset_contact_path(public_key: str) -> dict:
+    """Reset a contact's routing path to flood."""
+    contact = await _resolve_contact_or_404(public_key)
+
+    await ContactRepository.update_path(contact.public_key, "", -1, out_path_hash_mode=-1)
+    logger.info("Reset path to flood for %s", contact.public_key[:12])
+
+    # Push the updated path to radio if connected and contact is on radio
+    if radio_manager.is_connected and contact.on_radio:
+        try:
+            updated = await ContactRepository.get_by_key(contact.public_key)
+            if updated:
+                async with radio_manager.radio_operation("reset_path_on_radio") as mc:
+                    await mc.commands.add_contact(updated.to_radio_dict())
+        except Exception:
+            logger.warning("Failed to push flood path to radio for %s", contact.public_key[:12])
+
+    # Broadcast updated contact so frontend refreshes
+    from app.websocket import broadcast_event
+
+    updated_contact = await ContactRepository.get_by_key(contact.public_key)
+    if updated_contact:
+        broadcast_event("contact", updated_contact.model_dump())
+
+    return {"status": "ok", "public_key": contact.public_key}

app/routers/fanout.py

@@ -0,0 +1,235 @@
+"""REST API for fanout config CRUD."""
+
+import logging
+import re
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from app.config import settings as server_settings
+from app.repository.fanout import FanoutConfigRepository
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/fanout", tags=["fanout"])
+
+_VALID_TYPES = {"mqtt_private", "mqtt_community", "bot", "webhook", "apprise"}
+
+_IATA_RE = re.compile(r"^[A-Z]{3}$")
+
+
+class FanoutConfigCreate(BaseModel):
+    type: str = Field(description="Integration type: 'mqtt_private' or 'mqtt_community'")
+    name: str = Field(min_length=1, description="User-assigned label")
+    config: dict = Field(default_factory=dict, description="Type-specific config blob")
+    scope: dict = Field(default_factory=dict, description="Scope controls")
+    enabled: bool = Field(default=True, description="Whether enabled on creation")
+
+
+class FanoutConfigUpdate(BaseModel):
+    name: str | None = Field(default=None, min_length=1, description="Updated label")
+    config: dict | None = Field(default=None, description="Updated config blob")
+    scope: dict | None = Field(default=None, description="Updated scope controls")
+    enabled: bool | None = Field(default=None, description="Enable/disable toggle")
+
+
+def _validate_mqtt_private_config(config: dict) -> None:
+    """Validate mqtt_private config blob."""
+    if not config.get("broker_host"):
+        raise HTTPException(status_code=400, detail="broker_host is required for mqtt_private")
+    port = config.get("broker_port", 1883)
+    if not isinstance(port, int) or port < 1 or port > 65535:
+        raise HTTPException(status_code=400, detail="broker_port must be between 1 and 65535")
+
+
+def _validate_mqtt_community_config(config: dict) -> None:
+    """Validate mqtt_community config blob. Normalizes IATA to uppercase."""
+    iata = config.get("iata", "").upper().strip()
+    if not iata or not _IATA_RE.fullmatch(iata):
+        raise HTTPException(
+            status_code=400,
+            detail="IATA code is required and must be exactly 3 uppercase alphabetic characters",
+        )
+    config["iata"] = iata
+
+
+def _validate_bot_config(config: dict) -> None:
+    """Validate bot config blob (syntax-check the code)."""
+    code = config.get("code", "")
+    if not code or not code.strip():
+        raise HTTPException(status_code=400, detail="Bot code cannot be empty")
+    try:
+        compile(code, "<bot_code>", "exec")
+    except SyntaxError as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Bot code has syntax error at line {e.lineno}: {e.msg}",
+        ) from None
+
+
+def _validate_apprise_config(config: dict) -> None:
+    """Validate apprise config blob."""
+    urls = config.get("urls", "")
+    if not urls or not urls.strip():
+        raise HTTPException(status_code=400, detail="At least one Apprise URL is required")
+
+
+def _validate_webhook_config(config: dict) -> None:
+    """Validate webhook config blob."""
+    url = config.get("url", "")
+    if not url:
+        raise HTTPException(status_code=400, detail="url is required for webhook")
+    if not url.startswith(("http://", "https://")):
+        raise HTTPException(status_code=400, detail="url must start with http:// or https://")
+    method = config.get("method", "POST").upper()
+    if method not in ("POST", "PUT", "PATCH"):
+        raise HTTPException(status_code=400, detail="method must be POST, PUT, or PATCH")
+    headers = config.get("headers", {})
+    if not isinstance(headers, dict):
+        raise HTTPException(status_code=400, detail="headers must be a JSON object")
+
+
+def _enforce_scope(config_type: str, scope: dict) -> dict:
+    """Enforce type-specific scope constraints. Returns normalized scope."""
+    if config_type == "mqtt_community":
+        return {"messages": "none", "raw_packets": "all"}
+    if config_type == "bot":
+        return {"messages": "all", "raw_packets": "none"}
+    if config_type in ("webhook", "apprise"):
+        messages = scope.get("messages", "all")
+        if messages not in ("all", "none") and not isinstance(messages, dict):
+            raise HTTPException(
+                status_code=400,
+                detail="scope.messages must be 'all', 'none', or a filter object",
+            )
+        return {"messages": messages, "raw_packets": "none"}
+    # For mqtt_private, validate scope values
+    messages = scope.get("messages", "all")
+    if messages not in ("all", "none") and not isinstance(messages, dict):
+        raise HTTPException(
+            status_code=400,
+            detail="scope.messages must be 'all', 'none', or a filter object",
+        )
+    raw_packets = scope.get("raw_packets", "all")
+    if raw_packets not in ("all", "none"):
+        raise HTTPException(
+            status_code=400,
+            detail="scope.raw_packets must be 'all' or 'none'",
+        )
+    return {"messages": messages, "raw_packets": raw_packets}
+
+
+@router.get("")
+async def list_fanout_configs() -> list[dict]:
+    """List all fanout configs."""
+    return await FanoutConfigRepository.get_all()
+
+
+@router.post("")
+async def create_fanout_config(body: FanoutConfigCreate) -> dict:
+    """Create a new fanout config."""
+    if body.type not in _VALID_TYPES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid type '{body.type}'. Must be one of: {', '.join(sorted(_VALID_TYPES))}",
+        )
+
+    if body.type == "bot" and server_settings.disable_bots:
+        raise HTTPException(status_code=403, detail="Bot system disabled by server configuration")
+
+    # Only validate config when creating as enabled — disabled configs
+    # are drafts the user hasn't finished configuring yet.
+    if body.enabled:
+        if body.type == "mqtt_private":
+            _validate_mqtt_private_config(body.config)
+        elif body.type == "mqtt_community":
+            _validate_mqtt_community_config(body.config)
+        elif body.type == "bot":
+            _validate_bot_config(body.config)
+        elif body.type == "webhook":
+            _validate_webhook_config(body.config)
+        elif body.type == "apprise":
+            _validate_apprise_config(body.config)
+
+    scope = _enforce_scope(body.type, body.scope)
+
+    cfg = await FanoutConfigRepository.create(
+        config_type=body.type,
+        name=body.name,
+        config=body.config,
+        scope=scope,
+        enabled=body.enabled,
+    )
+
+    # Start the module if enabled
+    if cfg["enabled"]:
+        from app.fanout.manager import fanout_manager
+
+        await fanout_manager.reload_config(cfg["id"])
+
+    logger.info("Created fanout config %s (type=%s, name=%s)", cfg["id"], body.type, body.name)
+    return cfg
+
+
+@router.patch("/{config_id}")
+async def update_fanout_config(config_id: str, body: FanoutConfigUpdate) -> dict:
+    """Update a fanout config. Triggers module reload."""
+    existing = await FanoutConfigRepository.get(config_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail="Fanout config not found")
+
+    if existing["type"] == "bot" and server_settings.disable_bots:
+        raise HTTPException(status_code=403, detail="Bot system disabled by server configuration")
+
+    kwargs = {}
+    if body.name is not None:
+        kwargs["name"] = body.name
+    if body.enabled is not None:
+        kwargs["enabled"] = body.enabled
+    if body.config is not None:
+        kwargs["config"] = body.config
+    if body.scope is not None:
+        kwargs["scope"] = _enforce_scope(existing["type"], body.scope)
+
+    # Validate config when the result will be enabled
+    will_be_enabled = body.enabled if body.enabled is not None else existing["enabled"]
+    if will_be_enabled:
+        config_to_validate = body.config if body.config is not None else existing["config"]
+        if existing["type"] == "mqtt_private":
+            _validate_mqtt_private_config(config_to_validate)
+        elif existing["type"] == "mqtt_community":
+            _validate_mqtt_community_config(config_to_validate)
+        elif existing["type"] == "bot":
+            _validate_bot_config(config_to_validate)
+        elif existing["type"] == "webhook":
+            _validate_webhook_config(config_to_validate)
+        elif existing["type"] == "apprise":
+            _validate_apprise_config(config_to_validate)
+
+    updated = await FanoutConfigRepository.update(config_id, **kwargs)
+    if updated is None:
+        raise HTTPException(status_code=404, detail="Fanout config not found")
+
+    # Reload the module to pick up changes
+    from app.fanout.manager import fanout_manager
+
+    await fanout_manager.reload_config(config_id)
+
+    logger.info("Updated fanout config %s", config_id)
+    return updated
+
+
+@router.delete("/{config_id}")
+async def delete_fanout_config(config_id: str) -> dict:
+    """Delete a fanout config."""
+    existing = await FanoutConfigRepository.get(config_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail="Fanout config not found")
+
+    # Stop the module first
+    from app.fanout.manager import fanout_manager
+
+    await fanout_manager.remove_config(config_id)
+    await FanoutConfigRepository.delete(config_id)
+
+    logger.info("Deleted fanout config %s", config_id)
+    return {"deleted": True}

app/routers/health.py

@@ -1,4 +1,5 @@
 import os
+from typing import Any
 
 from fastapi import APIRouter
 from pydantic import BaseModel
@@ -16,6 +17,8 @@ class HealthResponse(BaseModel):
     connection_info: str | None
     database_size_mb: float
     oldest_undecrypted_timestamp: int | None
+    fanout_statuses: dict[str, dict[str, str]] = {}
+    bots_disabled: bool = False
 
 
 async def build_health_data(radio_connected: bool, connection_info: str | None) -> dict:
@@ -33,12 +36,23 @@ async def build_health_data(radio_connected: bool, connection_info: str | None)
     except RuntimeError:
         pass  # Database not connected
 
+    # Fanout module statuses
+    fanout_statuses: dict[str, Any] = {}
+    try:
+        from app.fanout.manager import fanout_manager
+
+        fanout_statuses = fanout_manager.get_statuses()
+    except Exception:
+        pass
+
     return {
         "status": "ok" if radio_connected else "degraded",
         "radio_connected": radio_connected,
         "connection_info": connection_info,
         "database_size_mb": db_size_mb,
         "oldest_undecrypted_timestamp": oldest_ts,
+        "fanout_statuses": fanout_statuses,
+        "bots_disabled": settings.disable_bots,
     }
 
 

app/routers/messages.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 import time
 
@@ -7,15 +6,42 @@ from meshcore import EventType
 
 from app.dependencies import require_connected
 from app.event_handlers import track_pending_ack
-from app.models import Message, SendChannelMessageRequest, SendDirectMessageRequest
+from app.models import (
+    Message,
+    MessagesAroundResponse,
+    SendChannelMessageRequest,
+    SendDirectMessageRequest,
+)
 from app.radio import radio_manager
-from app.repository import AmbiguousPublicKeyPrefixError, MessageRepository
+from app.repository import AmbiguousPublicKeyPrefixError, AppSettingsRepository, MessageRepository
 from app.websocket import broadcast_event
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/messages", tags=["messages"])
 
 
+@router.get("/around/{message_id}", response_model=MessagesAroundResponse)
+async def get_messages_around(
+    message_id: int,
+    type: str | None = Query(default=None, description="Filter by type: PRIV or CHAN"),
+    conversation_key: str | None = Query(default=None, description="Filter by conversation key"),
+    context: int = Query(default=100, ge=1, le=500, description="Number of messages before/after"),
+) -> MessagesAroundResponse:
+    """Get messages around a specific message for jump-to-message navigation."""
+    settings = await AppSettingsRepository.get()
+    blocked_keys = settings.blocked_keys or None
+    blocked_names = settings.blocked_names or None
+    messages, has_older, has_newer = await MessageRepository.get_around(
+        message_id=message_id,
+        msg_type=type,
+        conversation_key=conversation_key,
+        context_size=context,
+        blocked_keys=blocked_keys,
+        blocked_names=blocked_names,
+    )
+    return MessagesAroundResponse(messages=messages, has_older=has_older, has_newer=has_newer)
+
+
 @router.get("", response_model=list[Message])
 async def list_messages(
     limit: int = Query(default=100, ge=1, le=1000),
@@ -28,8 +54,18 @@ async def list_messages(
         default=None, description="Cursor: received_at of last seen message"
     ),
     before_id: int | None = Query(default=None, description="Cursor: id of last seen message"),
+    after: int | None = Query(
+        default=None, description="Forward cursor: received_at of last seen message"
+    ),
+    after_id: int | None = Query(
+        default=None, description="Forward cursor: id of last seen message"
+    ),
+    q: str | None = Query(default=None, description="Full-text search query"),
 ) -> list[Message]:
     """List messages from the database."""
+    settings = await AppSettingsRepository.get()
+    blocked_keys = settings.blocked_keys or None
+    blocked_names = settings.blocked_names or None
     return await MessageRepository.get_all(
         limit=limit,
         offset=offset,
@@ -37,13 +73,18 @@ async def list_messages(
         conversation_key=conversation_key,
         before=before,
         before_id=before_id,
+        after=after,
+        after_id=after_id,
+        q=q,
+        blocked_keys=blocked_keys,
+        blocked_names=blocked_names,
     )
 
 
 @router.post("/direct", response_model=Message)
 async def send_direct_message(request: SendDirectMessageRequest) -> Message:
     """Send a direct message to a contact."""
-    mc = require_connected()
+    require_connected()
 
     # First check our database for the contact
     from app.repository import ContactRepository
@@ -69,7 +110,7 @@ async def send_direct_message(request: SendDirectMessageRequest) -> Message:
     # so we can't rely on it to know if the firmware has the contact.
     # add_contact is idempotent - updates if exists, adds if not.
     contact_data = db_contact.to_radio_dict()
-    async with radio_manager.radio_operation("send_direct_message"):
+    async with radio_manager.radio_operation("send_direct_message") as mc:
         logger.debug("Ensuring contact %s is on radio before sending", db_contact.public_key[:12])
         add_result = await mc.commands.add_contact(contact_data)
         if add_result.type == EventType.ERROR:
@@ -134,48 +175,30 @@ async def send_direct_message(request: SendDirectMessageRequest) -> Message:
     )
 
     # Broadcast so all connected clients (not just sender) see the outgoing message immediately.
+    # Fanout modules (including bots) are triggered via broadcast_event's realtime dispatch.
     broadcast_event("message", message.model_dump())
 
-    # Trigger bots for outgoing DMs (runs in background, doesn't block response)
-    from app.bot import run_bot_for_message
-
-    asyncio.create_task(
-        run_bot_for_message(
-            sender_name=None,
-            sender_key=db_contact.public_key.lower(),
-            message_text=request.text,
-            is_dm=True,
-            channel_key=None,
-            channel_name=None,
-            sender_timestamp=now,
-            path=None,
-            is_outgoing=True,
-        )
-    )
-
     return message
 
 
 # Temporary radio slot used for sending channel messages
 TEMP_RADIO_SLOT = 0
-EXPERIMENTAL_CHANNEL_DOUBLE_SEND_DELAY_SECONDS = 3
 
 
 @router.post("/channel", response_model=Message)
 async def send_channel_message(request: SendChannelMessageRequest) -> Message:
     """Send a message to a channel."""
-    mc = require_connected()
+    require_connected()
 
     # Get channel info from our database
     from app.decoder import calculate_channel_hash
-    from app.repository import AppSettingsRepository, ChannelRepository
+    from app.repository import ChannelRepository
 
     db_channel = await ChannelRepository.get_by_key(request.channel_key)
     if not db_channel:
         raise HTTPException(
             status_code=404, detail=f"Channel {request.channel_key} not found in database"
         )
-    app_settings = await AppSettingsRepository.get()
 
     # Convert channel key hex to bytes
     try:
@@ -194,12 +217,17 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
         expected_hash,
     )
     channel_key_upper = request.channel_key.upper()
-    radio_name = mc.self_info.get("name", "") if mc.self_info else ""
-    text_with_sender = f"{radio_name}: {request.text}" if radio_name else request.text
     message_id: int | None = None
     now: int | None = None
+    radio_name: str = ""
+    text_with_sender: str = request.text
 
-    async with radio_manager.radio_operation("send_channel_message"):
+    our_public_key: str | None = None
+
+    async with radio_manager.radio_operation("send_channel_message") as mc:
+        radio_name = mc.self_info.get("name", "") if mc.self_info else ""
+        our_public_key = (mc.self_info.get("public_key") or None) if mc.self_info else None
+        text_with_sender = f"{radio_name}: {request.text}" if radio_name else request.text
         # Load the channel to a temporary radio slot before sending
         set_result = await mc.commands.set_channel(
             channel_idx=TEMP_RADIO_SLOT,
@@ -234,8 +262,8 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
         if result.type == EventType.ERROR:
             raise HTTPException(status_code=500, detail=f"Failed to send message: {result.payload}")
 
-        # Store outgoing immediately after the first successful send to avoid a race where
-        # our own echo lands before persistence (especially with delayed duplicate sends).
+        # Store outgoing immediately after send to avoid a race where
+        # our own echo lands before persistence.
         message_id = await MessageRepository.create(
             msg_type="CHAN",
             text=text_with_sender,
@@ -243,6 +271,8 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
             sender_timestamp=now,
             received_at=now,
             outgoing=True,
+            sender_name=radio_name or None,
+            sender_key=our_public_key,
         )
         if message_id is None:
             raise HTTPException(
@@ -250,29 +280,30 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
                 detail="Failed to store outgoing message - unexpected duplicate",
             )
 
-        # Experimental: byte-perfect resend after a delay to improve delivery reliability.
-        # This intentionally holds the radio operation lock for the full delay — it is an
-        # opt-in experimental feature where blocking other radio operations is acceptable.
-        if app_settings.experimental_channel_double_send:
-            logger.debug(
-                "Experimental channel double-send enabled; waiting %ds before byte-perfect duplicate",
-                EXPERIMENTAL_CHANNEL_DOUBLE_SEND_DELAY_SECONDS,
-            )
-            await asyncio.sleep(EXPERIMENTAL_CHANNEL_DOUBLE_SEND_DELAY_SECONDS)
-            duplicate_result = await mc.commands.send_chan_msg(
-                chan=TEMP_RADIO_SLOT,
-                msg=request.text,
-                timestamp=timestamp_bytes,
-            )
-            if duplicate_result.type == EventType.ERROR:
-                logger.warning(
-                    "Experimental duplicate channel send failed: %s", duplicate_result.payload
-                )
+        # Broadcast immediately so all connected clients see the message promptly.
+        # This ensures the message exists in frontend state when echo-driven
+        # `message_acked` events arrive.
+        broadcast_event(
+            "message",
+            Message(
+                id=message_id,
+                type="CHAN",
+                conversation_key=channel_key_upper,
+                text=text_with_sender,
+                sender_timestamp=now,
+                received_at=now,
+                outgoing=True,
+                acked=0,
+                sender_name=radio_name or None,
+                sender_key=our_public_key,
+                channel_name=db_channel.name,
+            ).model_dump(),
+        )
 
     if message_id is None or now is None:
         raise HTTPException(status_code=500, detail="Failed to store outgoing message")
 
-    acked_count = await MessageRepository.get_ack_count(message_id)
+    acked_count, paths = await MessageRepository.get_ack_and_paths(message_id)
 
     message = Message(
         id=message_id,
@@ -283,26 +314,149 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
         received_at=now,
         outgoing=True,
         acked=acked_count,
-    )
-
-    # Broadcast so all connected clients (not just sender) see the outgoing message immediately.
-    broadcast_event("message", message.model_dump())
-
-    # Trigger bots for outgoing channel messages (runs in background, doesn't block response)
-    from app.bot import run_bot_for_message
-
-    asyncio.create_task(
-        run_bot_for_message(
-            sender_name=radio_name or None,
-            sender_key=None,
-            message_text=request.text,
-            is_dm=False,
-            channel_key=channel_key_upper,
-            channel_name=db_channel.name,
-            sender_timestamp=now,
-            path=None,
-            is_outgoing=True,
-        )
+        paths=paths,
+        sender_name=radio_name or None,
+        sender_key=our_public_key,
+        channel_name=db_channel.name,
     )
 
     return message
+
+
+RESEND_WINDOW_SECONDS = 30
+
+
+@router.post("/channel/{message_id}/resend")
+async def resend_channel_message(
+    message_id: int,
+    new_timestamp: bool = Query(default=False),
+) -> dict:
+    """Resend a channel message.
+
+    When new_timestamp=False (default): byte-perfect resend using the original timestamp.
+    Only allowed within 30 seconds of the original send.
+
+    When new_timestamp=True: resend with a fresh timestamp so repeaters treat it as a
+    new packet. Creates a new message row in the database. No time window restriction.
+    """
+    require_connected()
+
+    from app.repository import ChannelRepository
+
+    msg = await MessageRepository.get_by_id(message_id)
+    if not msg:
+        raise HTTPException(status_code=404, detail="Message not found")
+
+    if not msg.outgoing:
+        raise HTTPException(status_code=400, detail="Can only resend outgoing messages")
+
+    if msg.type != "CHAN":
+        raise HTTPException(status_code=400, detail="Can only resend channel messages")
+
+    if msg.sender_timestamp is None:
+        raise HTTPException(status_code=400, detail="Message has no timestamp")
+
+    # Byte-perfect resend enforces the 30s window; new-timestamp resend does not
+    if not new_timestamp:
+        elapsed = int(time.time()) - msg.sender_timestamp
+        if elapsed > RESEND_WINDOW_SECONDS:
+            raise HTTPException(status_code=400, detail="Resend window has expired (30 seconds)")
+
+    db_channel = await ChannelRepository.get_by_key(msg.conversation_key)
+    if not db_channel:
+        raise HTTPException(status_code=404, detail=f"Channel {msg.conversation_key} not found")
+
+    # Choose timestamp: original for byte-perfect, fresh for new-timestamp
+    if new_timestamp:
+        now = int(time.time())
+        timestamp_bytes = now.to_bytes(4, "little")
+    else:
+        timestamp_bytes = msg.sender_timestamp.to_bytes(4, "little")
+
+    try:
+        key_bytes = bytes.fromhex(msg.conversation_key)
+    except ValueError:
+        raise HTTPException(
+            status_code=400, detail=f"Invalid channel key format: {msg.conversation_key}"
+        ) from None
+
+    resend_public_key: str | None = None
+
+    async with radio_manager.radio_operation("resend_channel_message") as mc:
+        # Strip sender prefix: DB stores "RadioName: message" but radio needs "message"
+        radio_name = mc.self_info.get("name", "") if mc.self_info else ""
+        resend_public_key = (mc.self_info.get("public_key") or None) if mc.self_info else None
+        text_to_send = msg.text
+        if radio_name and text_to_send.startswith(f"{radio_name}: "):
+            text_to_send = text_to_send[len(f"{radio_name}: ") :]
+
+        set_result = await mc.commands.set_channel(
+            channel_idx=TEMP_RADIO_SLOT,
+            channel_name=db_channel.name,
+            channel_secret=key_bytes,
+        )
+        if set_result.type == EventType.ERROR:
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to configure channel on radio before resending",
+            )
+
+        result = await mc.commands.send_chan_msg(
+            chan=TEMP_RADIO_SLOT,
+            msg=text_to_send,
+            timestamp=timestamp_bytes,
+        )
+        if result.type == EventType.ERROR:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to resend message: {result.payload}"
+            )
+
+    # For new-timestamp resend, create a new message row and broadcast it
+    if new_timestamp:
+        new_msg_id = await MessageRepository.create(
+            msg_type="CHAN",
+            text=msg.text,
+            conversation_key=msg.conversation_key,
+            sender_timestamp=now,
+            received_at=now,
+            outgoing=True,
+            sender_name=radio_name or None,
+            sender_key=resend_public_key,
+        )
+        if new_msg_id is None:
+            # Timestamp-second collision (same text+channel within the same second).
+            # The radio already transmitted, so log and return the original ID rather
+            # than surfacing a 500 for a message that was successfully sent over the air.
+            logger.warning(
+                "Duplicate timestamp collision resending message %d — radio sent but DB row not created",
+                message_id,
+            )
+            return {"status": "ok", "message_id": message_id}
+
+        broadcast_event(
+            "message",
+            Message(
+                id=new_msg_id,
+                type="CHAN",
+                conversation_key=msg.conversation_key,
+                text=msg.text,
+                sender_timestamp=now,
+                received_at=now,
+                outgoing=True,
+                acked=0,
+                sender_name=radio_name or None,
+                sender_key=resend_public_key,
+                channel_name=db_channel.name,
+            ).model_dump(),
+        )
+
+        logger.info(
+            "Resent channel message %d as new message %d to %s",
+            message_id,
+            new_msg_id,
+            db_channel.name,
+        )
+        return {"status": "ok", "message_id": new_msg_id}
+
+    logger.info("Resent channel message %d to %s", message_id, db_channel.name)
+    return {"status": "ok", "message_id": message_id}

app/routers/packets.py

@@ -1,5 +1,6 @@
 import logging
 from hashlib import sha256
+from sqlite3 import OperationalError
 
 import aiosqlite
 from fastapi import APIRouter, BackgroundTasks
@@ -70,7 +71,8 @@ async def _run_historical_channel_decryption(
                 timestamp=result.timestamp,
                 received_at=packet_timestamp,
                 path=path_hex,
-                trigger_bot=False,  # Historical decryption should not trigger bot
+                path_len=packet_info.path_length if packet_info else None,
+                realtime=False,  # Historical decryption should not trigger fanout
             )
 
             if msg_id is not None:
@@ -236,8 +238,12 @@ async def decrypt_historical_packets(
 
 
 class MaintenanceRequest(BaseModel):
-    prune_undecrypted_days: int = Field(
-        ge=1, description="Delete undecrypted packets older than this many days"
+    prune_undecrypted_days: int | None = Field(
+        default=None, ge=1, description="Delete undecrypted packets older than this many days"
+    )
+    purge_linked_raw_packets: bool = Field(
+        default=False,
+        description="Delete raw packets already linked to a stored message",
     )
 
 
@@ -249,22 +255,44 @@ class MaintenanceResult(BaseModel):
 @router.post("/maintenance", response_model=MaintenanceResult)
 async def run_maintenance(request: MaintenanceRequest) -> MaintenanceResult:
     """
-    Clean up old undecrypted packets and reclaim disk space.
+    Run packet maintenance tasks and reclaim disk space.
 
-    - Deletes undecrypted packets older than the specified number of days
+    - Optionally deletes undecrypted packets older than the specified number of days
+    - Optionally deletes raw packets already linked to stored messages
     - Runs VACUUM to reclaim disk space
     """
-    logger.info(
-        "Running maintenance: pruning packets older than %d days", request.prune_undecrypted_days
-    )
+    deleted = 0
 
-    # Prune old undecrypted packets
-    deleted = await RawPacketRepository.prune_old_undecrypted(request.prune_undecrypted_days)
-    logger.info("Deleted %d old undecrypted packets", deleted)
+    if request.prune_undecrypted_days is not None:
+        logger.info(
+            "Running maintenance: pruning undecrypted packets older than %d days",
+            request.prune_undecrypted_days,
+        )
+        pruned_undecrypted = await RawPacketRepository.prune_old_undecrypted(
+            request.prune_undecrypted_days
+        )
+        deleted += pruned_undecrypted
+        logger.info("Deleted %d old undecrypted packets", pruned_undecrypted)
 
-    # Run VACUUM to reclaim space on a dedicated connection
-    async with aiosqlite.connect(db.db_path) as vacuum_conn:
-        await vacuum_conn.executescript("VACUUM;")
-    logger.info("Database vacuumed")
+    if request.purge_linked_raw_packets:
+        logger.info("Running maintenance: purging raw packets linked to stored messages")
+        purged_linked = await RawPacketRepository.purge_linked_to_messages()
+        deleted += purged_linked
+        logger.info("Deleted %d linked raw packets", purged_linked)
 
-    return MaintenanceResult(packets_deleted=deleted, vacuumed=True)
+    # Run VACUUM to reclaim space on a dedicated connection.
+    # VACUUM requires exclusive access — if the main connection is actively
+    # writing (background sync, message processing, etc.) it fails with
+    # SQLITE_BUSY. This is expected; we just report vacuumed=False.
+    vacuumed = False
+    try:
+        async with aiosqlite.connect(db.db_path) as vacuum_conn:
+            await vacuum_conn.executescript("VACUUM;")
+        vacuumed = True
+        logger.info("Database vacuumed")
+    except OperationalError as e:
+        logger.warning("VACUUM skipped (database busy): %s", e)
+    except Exception as e:
+        logger.error("VACUUM failed unexpectedly: %s", e)
+
+    return MaintenanceResult(packets_deleted=deleted, vacuumed=vacuumed)

app/routers/radio.py

@@ -1,4 +1,6 @@
 import logging
+from collections.abc import Awaitable, Callable
+from typing import Any, cast
 
 from fastapi import APIRouter, HTTPException
 from meshcore import EventType
@@ -27,6 +29,12 @@ class RadioConfigResponse(BaseModel):
     lon: float
     tx_power: int = Field(description="Transmit power in dBm")
     max_tx_power: int = Field(description="Maximum transmit power in dBm")
+    path_hash_mode: int = Field(
+        default=0, description="Default outbound path hash mode (0=1 byte, 1=2 bytes, 2=3 bytes)"
+    )
+    path_hash_mode_supported: bool = Field(
+        default=False, description="Whether the connected radio/firmware exposes path hash mode"
+    )
     radio: RadioSettings
 
 
@@ -35,6 +43,9 @@ class RadioConfigUpdate(BaseModel):
     lat: float | None = None
     lon: float | None = None
     tx_power: int | None = Field(default=None, description="Transmit power in dBm")
+    path_hash_mode: int | None = Field(
+        default=None, ge=0, le=2, description="Default outbound path hash mode"
+    )
     radio: RadioSettings | None = None
 
 
@@ -42,15 +53,47 @@ class PrivateKeyUpdate(BaseModel):
     private_key: str = Field(description="Private key as hex string")
 
 
+async def _set_path_hash_mode(mc, mode: int):
+    """Set path hash mode using either the new helper or raw command fallback."""
+    commands = getattr(mc, "commands", None)
+    if commands is None:
+        raise HTTPException(status_code=503, detail="Radio command interface unavailable")
+
+    set_path_hash_mode = cast(
+        Callable[[int], Awaitable[Any]] | None, getattr(commands, "set_path_hash_mode", None)
+    )
+    send_raw = cast(
+        Callable[[bytes, list[EventType]], Awaitable[Any]] | None,
+        getattr(commands, "send", None),
+    )
+
+    if callable(set_path_hash_mode):
+        result = await set_path_hash_mode(mode)
+    elif callable(send_raw):
+        data = b"\x3d\x00" + int(mode).to_bytes(1, "little")
+        result = await send_raw(data, [EventType.OK, EventType.ERROR])
+    else:
+        raise HTTPException(
+            status_code=400,
+            detail="Installed meshcore interface library cannot set path hash mode",
+        )
+
+    if result is not None and result.type == EventType.ERROR:
+        raise HTTPException(status_code=500, detail="Failed to set path hash mode on radio")
+
+    return result
+
+
 @router.get("/config", response_model=RadioConfigResponse)
 async def get_radio_config() -> RadioConfigResponse:
     """Get the current radio configuration."""
     mc = require_connected()
-
     info = mc.self_info
     if not info:
         raise HTTPException(status_code=503, detail="Radio info not available")
 
+    path_hash_mode, path_hash_mode_supported = radio_manager.path_hash_mode_info
+
     return RadioConfigResponse(
         public_key=info.get("public_key", ""),
         name=info.get("name", ""),
@@ -58,6 +101,8 @@ async def get_radio_config() -> RadioConfigResponse:
         lon=info.get("adv_lon", 0.0),
         tx_power=info.get("tx_power", 0),
         max_tx_power=info.get("max_tx_power", 0),
+        path_hash_mode=path_hash_mode,
+        path_hash_mode_supported=path_hash_mode_supported,
         radio=RadioSettings(
             freq=info.get("radio_freq", 0.0),
             bw=info.get("radio_bw", 0.0),
@@ -70,9 +115,9 @@ async def get_radio_config() -> RadioConfigResponse:
 @router.patch("/config", response_model=RadioConfigResponse)
 async def update_radio_config(update: RadioConfigUpdate) -> RadioConfigResponse:
     """Update radio configuration. Only provided fields will be updated."""
-    mc = require_connected()
+    require_connected()
 
-    async with radio_manager.radio_operation("update_radio_config"):
+    async with radio_manager.radio_operation("update_radio_config") as mc:
         if update.name is not None:
             logger.info("Setting radio name to %s", update.name)
             await mc.commands.set_name(update.name)
@@ -88,6 +133,20 @@ async def update_radio_config(update: RadioConfigUpdate) -> RadioConfigResponse:
             logger.info("Setting TX power to %d dBm", update.tx_power)
             await mc.commands.set_tx_power(val=update.tx_power)
 
+        if update.path_hash_mode is not None:
+            current_mode, supported = radio_manager.path_hash_mode_info
+            if not supported:
+                current_mode, supported = await radio_manager.refresh_path_hash_mode_info(mc)
+            if not supported:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Connected radio/firmware does not expose path hash mode",
+                )
+            if current_mode != update.path_hash_mode:
+                logger.info("Setting path hash mode to %d", update.path_hash_mode)
+                await _set_path_hash_mode(mc, update.path_hash_mode)
+                radio_manager.set_path_hash_mode_info(update.path_hash_mode, True)
+
         if update.radio is not None:
             logger.info(
                 "Setting radio params: freq=%f MHz, bw=%f kHz, sf=%d, cr=%d",
@@ -104,7 +163,7 @@ async def update_radio_config(update: RadioConfigUpdate) -> RadioConfigResponse:
             )
 
         # Sync time with system clock
-        await sync_radio_time()
+        await sync_radio_time(mc)
 
         # Re-fetch self_info so the response reflects the changes we just made.
         # Commands like set_name() write to flash but don't update the cached
@@ -117,7 +176,7 @@ async def update_radio_config(update: RadioConfigUpdate) -> RadioConfigResponse:
 @router.put("/private-key")
 async def set_private_key(update: PrivateKeyUpdate) -> dict:
     """Set the radio's private key. This is write-only."""
-    mc = require_connected()
+    require_connected()
 
     try:
         key_bytes = bytes.fromhex(update.private_key)
@@ -125,11 +184,30 @@ async def set_private_key(update: PrivateKeyUpdate) -> dict:
         raise HTTPException(status_code=400, detail="Invalid hex string for private key") from None
 
     logger.info("Importing private key")
-    result = await mc.commands.import_private_key(key_bytes)
+    async with radio_manager.radio_operation("import_private_key") as mc:
+        result = await mc.commands.import_private_key(key_bytes)
 
-    if result.type == EventType.ERROR:
+        if result.type == EventType.ERROR:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to import private key: {result.payload}"
+            )
+
+        # Re-export from radio so the server-side keystore uses the new key
+        # for DM decryption immediately, rather than waiting for reconnect.
+        from app.keystore import export_and_store_private_key
+
+        keystore_refreshed = await export_and_store_private_key(mc)
+        if not keystore_refreshed:
+            logger.warning("Keystore refresh failed after import, retrying once")
+            keystore_refreshed = await export_and_store_private_key(mc)
+
+    if not keystore_refreshed:
         raise HTTPException(
-            status_code=500, detail=f"Failed to import private key: {result.payload}"
+            status_code=500,
+            detail=(
+                "Private key imported on radio, but server-side keystore "
+                "refresh failed. Reconnect to apply the new key for DM decryption."
+            ),
         )
 
     return {"status": "ok"}
@@ -149,7 +227,8 @@ async def send_advertisement() -> dict:
     require_connected()
 
     logger.info("Sending flood advertisement")
-    success = await do_send_advertisement(force=True)
+    async with radio_manager.radio_operation("manual_advertisement") as mc:
+        success = await do_send_advertisement(mc, force=True)
 
     if not success:
         raise HTTPException(status_code=500, detail="Failed to send advertisement")
@@ -157,6 +236,33 @@ async def send_advertisement() -> dict:
     return {"status": "ok"}
 
 
+async def _attempt_reconnect() -> dict:
+    """Shared reconnection logic for reboot and reconnect endpoints."""
+    if radio_manager.is_reconnecting:
+        return {
+            "status": "pending",
+            "message": "Reconnection already in progress",
+            "connected": False,
+        }
+
+    success = await radio_manager.reconnect()
+    if not success:
+        raise HTTPException(
+            status_code=503, detail="Failed to reconnect. Check radio connection and power."
+        )
+
+    try:
+        await radio_manager.post_connect_setup()
+    except Exception as e:
+        logger.exception("Post-connect setup failed after reconnect")
+        raise HTTPException(
+            status_code=503,
+            detail=f"Radio connected but setup failed: {e}",
+        ) from e
+
+    return {"status": "ok", "message": "Reconnected successfully", "connected": True}
+
+
 @router.post("/reboot")
 async def reboot_radio() -> dict:
     """Reboot the radio, or reconnect if not currently connected.
@@ -164,34 +270,17 @@ async def reboot_radio() -> dict:
     If connected: sends reboot command, connection will temporarily drop and auto-reconnect.
     If not connected: attempts to reconnect (same as /reconnect endpoint).
     """
-    # If connected, send reboot command
-    if radio_manager.is_connected and radio_manager.meshcore:
+    if radio_manager.is_connected:
         logger.info("Rebooting radio")
-        await radio_manager.meshcore.commands.reboot()
+        async with radio_manager.radio_operation("reboot_radio") as mc:
+            await mc.commands.reboot()
         return {
             "status": "ok",
             "message": "Reboot command sent. Radio will reconnect automatically.",
         }
 
-    # Not connected - attempt to reconnect
-    if radio_manager.is_reconnecting:
-        return {
-            "status": "pending",
-            "message": "Reconnection already in progress",
-            "connected": False,
-        }
-
     logger.info("Radio not connected, attempting reconnect")
-    success = await radio_manager.reconnect()
-
-    if success:
-        await radio_manager.post_connect_setup()
-
-        return {"status": "ok", "message": "Reconnected successfully", "connected": True}
-    else:
-        raise HTTPException(
-            status_code=503, detail="Failed to reconnect. Check radio connection and power."
-        )
+    return await _attempt_reconnect()
 
 
 @router.post("/reconnect")
@@ -203,23 +292,19 @@ async def reconnect_radio() -> dict:
     or power-cycled.
     """
     if radio_manager.is_connected:
-        return {"status": "ok", "message": "Already connected", "connected": True}
+        if radio_manager.is_setup_complete:
+            return {"status": "ok", "message": "Already connected", "connected": True}
 
-    if radio_manager.is_reconnecting:
-        return {
-            "status": "pending",
-            "message": "Reconnection already in progress",
-            "connected": False,
-        }
+        logger.info("Radio connected but setup incomplete, retrying setup")
+        try:
+            await radio_manager.post_connect_setup()
+            return {"status": "ok", "message": "Setup completed", "connected": True}
+        except Exception as e:
+            logger.exception("Post-connect setup failed")
+            raise HTTPException(
+                status_code=503,
+                detail=f"Radio connected but setup failed: {e}",
+            ) from e
 
     logger.info("Manual reconnect requested")
-    success = await radio_manager.reconnect()
-
-    if success:
-        await radio_manager.post_connect_setup()
-
-        return {"status": "ok", "message": "Reconnected successfully", "connected": True}
-    else:
-        raise HTTPException(
-            status_code=503, detail="Failed to reconnect. Check radio connection and power."
-        )
+    return await _attempt_reconnect()

app/routers/read_state.py

@@ -3,25 +3,40 @@
 import logging
 import time
 
-from fastapi import APIRouter, Query
+from fastapi import APIRouter
 
 from app.models import UnreadCounts
-from app.repository import ChannelRepository, ContactRepository, MessageRepository
+from app.radio import radio_manager
+from app.repository import (
+    AppSettingsRepository,
+    ChannelRepository,
+    ContactRepository,
+    MessageRepository,
+)
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/read-state", tags=["read-state"])
 
 
 @router.get("/unreads", response_model=UnreadCounts)
-async def get_unreads(
-    name: str | None = Query(default=None, description="User's name for @mention detection"),
-) -> UnreadCounts:
+async def get_unreads() -> UnreadCounts:
     """Get unread counts, mention flags, and last message times for all conversations.
 
     Computes unread counts server-side using last_read_at timestamps on
     channels and contacts, avoiding the need to fetch bulk messages.
+    The radio's own name is sourced directly from the connected radio
+    for @mention detection.
     """
-    data = await MessageRepository.get_unread_counts(name)
+    name: str | None = None
+    mc = radio_manager.meshcore
+    if mc and mc.self_info:
+        name = mc.self_info.get("name") or None
+    settings = await AppSettingsRepository.get()
+    blocked_keys = settings.blocked_keys or None
+    blocked_names = settings.blocked_names or None
+    data = await MessageRepository.get_unread_counts(
+        name, blocked_keys=blocked_keys, blocked_names=blocked_names
+    )
     return UnreadCounts(**data)
 
 
@@ -30,7 +45,7 @@ async def mark_all_read() -> dict:
     """Mark all contacts and channels as read.
 
     Updates last_read_at to current timestamp for all contacts and channels
-    in a single database transaction.
+    using two repository updates (same timestamp value across both tables).
     """
     now = int(time.time())
 

app/routers/repeaters.py

@@ -0,0 +1,510 @@
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter, HTTPException
+from meshcore import EventType
+
+from app.dependencies import require_connected
+from app.models import (
+    CONTACT_TYPE_REPEATER,
+    AclEntry,
+    CommandRequest,
+    CommandResponse,
+    Contact,
+    LppSensor,
+    NeighborInfo,
+    RepeaterAclResponse,
+    RepeaterAdvertIntervalsResponse,
+    RepeaterLoginRequest,
+    RepeaterLoginResponse,
+    RepeaterLppTelemetryResponse,
+    RepeaterNeighborsResponse,
+    RepeaterOwnerInfoResponse,
+    RepeaterRadioSettingsResponse,
+    RepeaterStatusResponse,
+)
+from app.radio import radio_manager
+from app.repository import ContactRepository
+from app.routers.contacts import _ensure_on_radio, _resolve_contact_or_404
+
+if TYPE_CHECKING:
+    from meshcore.events import Event
+
+logger = logging.getLogger(__name__)
+
+# ACL permission level names
+ACL_PERMISSION_NAMES = {
+    0: "Guest",
+    1: "Read-only",
+    2: "Read-write",
+    3: "Admin",
+}
+router = APIRouter(prefix="/contacts", tags=["repeaters"])
+
+# Delay between repeater radio operations to allow key exchange and path establishment
+REPEATER_OP_DELAY_SECONDS = 2.0
+
+
+def _monotonic() -> float:
+    """Wrapper around time.monotonic() for testability.
+
+    Patching time.monotonic directly breaks the asyncio event loop which also
+    uses it. This indirection allows tests to control the clock safely.
+    """
+    return time.monotonic()
+
+
+def _extract_response_text(event) -> str:
+    """Extract text from a CLI response event, stripping the firmware '> ' prefix."""
+    text = event.payload.get("text", str(event.payload))
+    if text.startswith("> "):
+        text = text[2:]
+    return text
+
+
+async def _fetch_repeater_response(
+    mc,
+    target_pubkey_prefix: str,
+    timeout: float = 20.0,
+) -> "Event | None":
+    """Fetch a CLI response from a specific repeater via a validated get_msg() loop.
+
+    Calls get_msg() repeatedly until a matching CLI response (txt_type=1) from the
+    target repeater arrives or the wall-clock deadline expires. Unrelated messages
+    are safe to skip — meshcore's event dispatcher already delivers them to the
+    normal subscription handlers (on_contact_message, etc.) when get_msg() returns.
+
+    Args:
+        mc: MeshCore instance
+        target_pubkey_prefix: 12-char hex prefix of the repeater's public key
+        timeout: Wall-clock seconds before giving up
+
+    Returns:
+        The matching Event, or None if no response arrived before the deadline.
+    """
+    deadline = _monotonic() + timeout
+
+    while _monotonic() < deadline:
+        try:
+            result = await mc.commands.get_msg(timeout=2.0)
+        except asyncio.TimeoutError:
+            continue
+        except Exception as e:
+            logger.debug("get_msg() exception: %s", e)
+            await asyncio.sleep(1.0)
+            continue
+
+        if result.type == EventType.NO_MORE_MSGS:
+            # No messages queued yet — wait and retry
+            await asyncio.sleep(1.0)
+            continue
+
+        if result.type == EventType.ERROR:
+            logger.debug("get_msg() error: %s", result.payload)
+            await asyncio.sleep(1.0)
+            continue
+
+        if result.type == EventType.CONTACT_MSG_RECV:
+            msg_prefix = result.payload.get("pubkey_prefix", "")
+            txt_type = result.payload.get("txt_type", 0)
+            if msg_prefix == target_pubkey_prefix and txt_type == 1:
+                return result
+            # Not our target — already dispatched to subscribers by meshcore,
+            # so just continue draining the queue.
+            logger.debug(
+                "Skipping non-target message (from=%s, txt_type=%d) while waiting for %s",
+                msg_prefix,
+                txt_type,
+                target_pubkey_prefix,
+            )
+            continue
+
+        if result.type == EventType.CHANNEL_MSG_RECV:
+            # Already dispatched to subscribers by meshcore; skip.
+            logger.debug(
+                "Skipping channel message (channel_idx=%s) during repeater fetch",
+                result.payload.get("channel_idx"),
+            )
+            continue
+
+        logger.debug("Unexpected event type %s during repeater fetch, skipping", result.type)
+
+    logger.warning("No CLI response from repeater %s within %.1fs", target_pubkey_prefix, timeout)
+    return None
+
+
+async def prepare_repeater_connection(mc, contact: Contact, password: str) -> None:
+    """Prepare connection to a repeater by adding to radio and logging in.
+
+    Args:
+        mc: MeshCore instance
+        contact: The repeater contact
+        password: Password for login (empty string for no password)
+
+    Raises:
+        HTTPException: If login fails
+    """
+    # Add contact to radio with path from DB (non-fatal — contact may already be loaded)
+    logger.info("Adding repeater %s to radio", contact.public_key[:12])
+    await _ensure_on_radio(mc, contact)
+
+    # Send login with password
+    logger.info("Sending login to repeater %s", contact.public_key[:12])
+    login_result = await mc.commands.send_login(contact.public_key, password)
+
+    if login_result.type == EventType.ERROR:
+        raise HTTPException(status_code=401, detail=f"Login failed: {login_result.payload}")
+
+    # Wait for key exchange to complete before sending requests
+    logger.debug("Waiting %.1fs for key exchange to complete", REPEATER_OP_DELAY_SECONDS)
+    await asyncio.sleep(REPEATER_OP_DELAY_SECONDS)
+
+
+def _require_repeater(contact: Contact) -> None:
+    """Raise 400 if contact is not a repeater."""
+    if contact.type != CONTACT_TYPE_REPEATER:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Contact is not a repeater (type={contact.type}, expected {CONTACT_TYPE_REPEATER})",
+        )
+
+
+# ---------------------------------------------------------------------------
+# Granular repeater endpoints — one attempt, no server-side retries.
+# Frontend manages retry logic for better UX control.
+# ---------------------------------------------------------------------------
+
+
+@router.post("/{public_key}/repeater/login", response_model=RepeaterLoginResponse)
+async def repeater_login(public_key: str, request: RepeaterLoginRequest) -> RepeaterLoginResponse:
+    """Log in to a repeater. Adds contact to radio, sends login, waits for key exchange."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    async with radio_manager.radio_operation(
+        "repeater_login",
+        pause_polling=True,
+        suspend_auto_fetch=True,
+    ) as mc:
+        await prepare_repeater_connection(mc, contact, request.password)
+
+    return RepeaterLoginResponse(status="ok")
+
+
+@router.post("/{public_key}/repeater/status", response_model=RepeaterStatusResponse)
+async def repeater_status(public_key: str) -> RepeaterStatusResponse:
+    """Fetch status telemetry from a repeater (single attempt, 10s timeout)."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    async with radio_manager.radio_operation(
+        "repeater_status", pause_polling=True, suspend_auto_fetch=True
+    ) as mc:
+        # Ensure contact is on radio for routing
+        await _ensure_on_radio(mc, contact)
+
+        status = await mc.commands.req_status_sync(contact.public_key, timeout=10, min_timeout=5)
+
+    if status is None:
+        raise HTTPException(status_code=504, detail="No status response from repeater")
+
+    return RepeaterStatusResponse(
+        battery_volts=status.get("bat", 0) / 1000.0,
+        tx_queue_len=status.get("tx_queue_len", 0),
+        noise_floor_dbm=status.get("noise_floor", 0),
+        last_rssi_dbm=status.get("last_rssi", 0),
+        last_snr_db=status.get("last_snr", 0.0),
+        packets_received=status.get("nb_recv", 0),
+        packets_sent=status.get("nb_sent", 0),
+        airtime_seconds=status.get("airtime", 0),
+        rx_airtime_seconds=status.get("rx_airtime", 0),
+        uptime_seconds=status.get("uptime", 0),
+        sent_flood=status.get("sent_flood", 0),
+        sent_direct=status.get("sent_direct", 0),
+        recv_flood=status.get("recv_flood", 0),
+        recv_direct=status.get("recv_direct", 0),
+        flood_dups=status.get("flood_dups", 0),
+        direct_dups=status.get("direct_dups", 0),
+        full_events=status.get("full_evts", 0),
+    )
+
+
+@router.post("/{public_key}/repeater/lpp-telemetry", response_model=RepeaterLppTelemetryResponse)
+async def repeater_lpp_telemetry(public_key: str) -> RepeaterLppTelemetryResponse:
+    """Fetch CayenneLPP sensor telemetry from a repeater (single attempt, 10s timeout)."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    async with radio_manager.radio_operation(
+        "repeater_lpp_telemetry", pause_polling=True, suspend_auto_fetch=True
+    ) as mc:
+        await _ensure_on_radio(mc, contact)
+
+        telemetry = await mc.commands.req_telemetry_sync(
+            contact.public_key, timeout=10, min_timeout=5
+        )
+
+    if telemetry is None:
+        raise HTTPException(status_code=504, detail="No telemetry response from repeater")
+
+    sensors: list[LppSensor] = []
+    for entry in telemetry:
+        channel = entry.get("channel", 0)
+        type_name = str(entry.get("type", "unknown"))
+        value = entry.get("value", 0)
+        sensors.append(LppSensor(channel=channel, type_name=type_name, value=value))
+
+    return RepeaterLppTelemetryResponse(sensors=sensors)
+
+
+@router.post("/{public_key}/repeater/neighbors", response_model=RepeaterNeighborsResponse)
+async def repeater_neighbors(public_key: str) -> RepeaterNeighborsResponse:
+    """Fetch neighbors from a repeater (single attempt, 10s timeout)."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    async with radio_manager.radio_operation(
+        "repeater_neighbors", pause_polling=True, suspend_auto_fetch=True
+    ) as mc:
+        # Ensure contact is on radio for routing
+        await _ensure_on_radio(mc, contact)
+
+        neighbors_data = await mc.commands.fetch_all_neighbours(
+            contact.public_key, timeout=10, min_timeout=5
+        )
+
+    neighbors: list[NeighborInfo] = []
+    if neighbors_data and "neighbours" in neighbors_data:
+        for n in neighbors_data["neighbours"]:
+            pubkey_prefix = n.get("pubkey", "")
+            resolved_contact = await ContactRepository.get_by_key_prefix(pubkey_prefix)
+            neighbors.append(
+                NeighborInfo(
+                    pubkey_prefix=pubkey_prefix,
+                    name=resolved_contact.name if resolved_contact else None,
+                    snr=n.get("snr", 0.0),
+                    last_heard_seconds=n.get("secs_ago", 0),
+                )
+            )
+
+    return RepeaterNeighborsResponse(neighbors=neighbors)
+
+
+@router.post("/{public_key}/repeater/acl", response_model=RepeaterAclResponse)
+async def repeater_acl(public_key: str) -> RepeaterAclResponse:
+    """Fetch ACL from a repeater (single attempt, 10s timeout)."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    async with radio_manager.radio_operation(
+        "repeater_acl", pause_polling=True, suspend_auto_fetch=True
+    ) as mc:
+        # Ensure contact is on radio for routing
+        await _ensure_on_radio(mc, contact)
+
+        acl_data = await mc.commands.req_acl_sync(contact.public_key, timeout=10, min_timeout=5)
+
+    acl_entries: list[AclEntry] = []
+    if acl_data and isinstance(acl_data, list):
+        for entry in acl_data:
+            pubkey_prefix = entry.get("key", "")
+            perm = entry.get("perm", 0)
+            resolved_contact = await ContactRepository.get_by_key_prefix(pubkey_prefix)
+            acl_entries.append(
+                AclEntry(
+                    pubkey_prefix=pubkey_prefix,
+                    name=resolved_contact.name if resolved_contact else None,
+                    permission=perm,
+                    permission_name=ACL_PERMISSION_NAMES.get(perm, f"Unknown({perm})"),
+                )
+            )
+
+    return RepeaterAclResponse(acl=acl_entries)
+
+
+async def _batch_cli_fetch(
+    contact: Contact,
+    operation_name: str,
+    commands: list[tuple[str, str]],
+) -> dict[str, str | None]:
+    """Send a batch of CLI commands to a repeater and collect responses.
+
+    Opens a radio operation with polling paused and auto-fetch suspended (since
+    we call get_msg() directly via _fetch_repeater_response), adds the contact
+    to the radio for routing, then sends each command sequentially with a 1-second
+    gap between them.
+
+    Returns a dict mapping field names to response strings (or None on timeout).
+    """
+    results: dict[str, str | None] = {field: None for _, field in commands}
+
+    async with radio_manager.radio_operation(
+        operation_name,
+        pause_polling=True,
+        suspend_auto_fetch=True,
+    ) as mc:
+        await _ensure_on_radio(mc, contact)
+        await asyncio.sleep(1.0)
+
+        for i, (cmd, field) in enumerate(commands):
+            if i > 0:
+                await asyncio.sleep(1.0)
+
+            send_result = await mc.commands.send_cmd(contact.public_key, cmd)
+            if send_result.type == EventType.ERROR:
+                logger.debug("Command '%s' send error: %s", cmd, send_result.payload)
+                continue
+
+            response_event = await _fetch_repeater_response(
+                mc, contact.public_key[:12], timeout=10.0
+            )
+            if response_event is not None:
+                results[field] = _extract_response_text(response_event)
+            else:
+                logger.warning("No response for command '%s' (%s)", cmd, field)
+
+    return results
+
+
+@router.post("/{public_key}/repeater/radio-settings", response_model=RepeaterRadioSettingsResponse)
+async def repeater_radio_settings(public_key: str) -> RepeaterRadioSettingsResponse:
+    """Fetch radio settings from a repeater via batch CLI commands."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    results = await _batch_cli_fetch(
+        contact,
+        "repeater_radio_settings",
+        [
+            ("ver", "firmware_version"),
+            ("get radio", "radio"),
+            ("get tx", "tx_power"),
+            ("get af", "airtime_factor"),
+            ("get repeat", "repeat_enabled"),
+            ("get flood.max", "flood_max"),
+            ("get name", "name"),
+            ("get lat", "lat"),
+            ("get lon", "lon"),
+            ("clock", "clock_utc"),
+        ],
+    )
+    return RepeaterRadioSettingsResponse(**results)
+
+
+@router.post(
+    "/{public_key}/repeater/advert-intervals", response_model=RepeaterAdvertIntervalsResponse
+)
+async def repeater_advert_intervals(public_key: str) -> RepeaterAdvertIntervalsResponse:
+    """Fetch advertisement intervals from a repeater via CLI commands."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    results = await _batch_cli_fetch(
+        contact,
+        "repeater_advert_intervals",
+        [
+            ("get advert.interval", "advert_interval"),
+            ("get flood.advert.interval", "flood_advert_interval"),
+        ],
+    )
+    return RepeaterAdvertIntervalsResponse(**results)
+
+
+@router.post("/{public_key}/repeater/owner-info", response_model=RepeaterOwnerInfoResponse)
+async def repeater_owner_info(public_key: str) -> RepeaterOwnerInfoResponse:
+    """Fetch owner info and guest password from a repeater via CLI commands."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    results = await _batch_cli_fetch(
+        contact,
+        "repeater_owner_info",
+        [
+            ("get owner.info", "owner_info"),
+            ("get guest.password", "guest_password"),
+        ],
+    )
+    return RepeaterOwnerInfoResponse(**results)
+
+
+@router.post("/{public_key}/command", response_model=CommandResponse)
+async def send_repeater_command(public_key: str, request: CommandRequest) -> CommandResponse:
+    """Send a CLI command to a repeater.
+
+    The contact must be a repeater (type=2). The user must have already logged in
+    via the repeater/login endpoint. This endpoint ensures the contact is on the
+    radio before sending commands (the repeater remembers ACL permissions after login).
+
+    Common commands:
+    - get name, set name <value>
+    - get tx, set tx <dbm>
+    - get radio, set radio <freq,bw,sf,cr>
+    - tempradio <freq,bw,sf,cr,minutes>
+    - setperm <pubkey> <permission>  (0=guest, 1=read-only, 2=read-write, 3=admin)
+    - clock, clock sync
+    - reboot
+    - ver
+    """
+    require_connected()
+
+    # Get contact from database
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
+
+    async with radio_manager.radio_operation(
+        "send_repeater_command",
+        pause_polling=True,
+        suspend_auto_fetch=True,
+    ) as mc:
+        # Add contact to radio with path from DB (non-fatal — contact may already be loaded)
+        logger.info("Adding repeater %s to radio", contact.public_key[:12])
+        await _ensure_on_radio(mc, contact)
+        await asyncio.sleep(1.0)
+
+        # Send the command
+        logger.info("Sending command to repeater %s: %s", contact.public_key[:12], request.command)
+
+        send_result = await mc.commands.send_cmd(contact.public_key, request.command)
+
+        if send_result.type == EventType.ERROR:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to send command: {send_result.payload}"
+            )
+
+        # Wait for response using validated fetch loop
+        response_event = await _fetch_repeater_response(mc, contact.public_key[:12])
+
+        if response_event is None:
+            logger.warning(
+                "No response from repeater %s for command: %s",
+                contact.public_key[:12],
+                request.command,
+            )
+            return CommandResponse(
+                command=request.command,
+                response="(no response - command may have been processed)",
+            )
+
+        # CONTACT_MSG_RECV payloads use sender_timestamp in meshcore.
+        response_text = _extract_response_text(response_event)
+        sender_timestamp = response_event.payload.get(
+            "sender_timestamp",
+            response_event.payload.get("timestamp"),
+        )
+        logger.info("Received response from %s: %s", contact.public_key[:12], response_text)
+
+        return CommandResponse(
+            command=request.command,
+            response=response_text,
+            sender_timestamp=sender_timestamp,
+        )

app/routers/settings.py

@@ -1,37 +1,17 @@
+import asyncio
 import logging
 from typing import Literal
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter
 from pydantic import BaseModel, Field
 
-from app.models import AppSettings, BotConfig
+from app.models import AppSettings
 from app.repository import AppSettingsRepository
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/settings", tags=["settings"])
 
 
-def validate_bot_code(code: str, bot_name: str | None = None) -> None:
-    """Validate bot code syntax. Raises HTTPException on error."""
-    if not code or not code.strip():
-        return  # Empty code is valid (disables bot)
-
-    try:
-        compile(code, "<bot_code>", "exec")
-    except SyntaxError as e:
-        name_part = f"'{bot_name}' " if bot_name else ""
-        raise HTTPException(
-            status_code=400,
-            detail=f"Bot {name_part}has syntax error at line {e.lineno}: {e.msg}",
-        ) from None
-
-
-def validate_all_bots(bots: list[BotConfig]) -> None:
-    """Validate all bots' code syntax. Raises HTTPException on first error."""
-    for bot in bots:
-        validate_bot_code(bot.code, bot.name)
-
-
 class AppSettingsUpdate(BaseModel):
     max_radio_contacts: int | None = Field(
         default=None,
@@ -41,13 +21,6 @@ class AppSettingsUpdate(BaseModel):
             "Maximum contacts to keep on radio (favorites first, then recent non-repeaters)"
         ),
     )
-    experimental_channel_double_send: bool | None = Field(
-        default=None,
-        description=(
-            "Experimental: always send channel messages twice with a 3-second delay using "
-            "identical timestamp bytes"
-        ),
-    )
     auto_decrypt_dm_on_advert: bool | None = Field(
         default=None,
         description="Whether to attempt historical DM decryption on new contact advertisement",
@@ -59,12 +32,28 @@ class AppSettingsUpdate(BaseModel):
     advert_interval: int | None = Field(
         default=None,
         ge=0,
-        description="Periodic advertisement interval in seconds (0 = disabled)",
+        description="Periodic advertisement interval in seconds (0 = disabled, minimum 3600)",
     )
-    bots: list[BotConfig] | None = Field(
+    flood_scope: str | None = Field(
         default=None,
-        description="List of bot configurations",
+        description="Outbound flood scope / region name (empty = disabled)",
     )
+    blocked_keys: list[str] | None = Field(
+        default=None,
+        description="Public keys whose messages are hidden from the UI",
+    )
+    blocked_names: list[str] | None = Field(
+        default=None,
+        description="Display names whose messages are hidden from the UI",
+    )
+
+
+class BlockKeyRequest(BaseModel):
+    key: str = Field(description="Public key to toggle block status")
+
+
+class BlockNameRequest(BaseModel):
+    name: str = Field(description="Display name to toggle block status")
 
 
 class FavoriteRequest(BaseModel):
@@ -109,13 +98,6 @@ async def update_settings(update: AppSettingsUpdate) -> AppSettings:
         logger.info("Updating max_radio_contacts to %d", update.max_radio_contacts)
         kwargs["max_radio_contacts"] = update.max_radio_contacts
 
-    if update.experimental_channel_double_send is not None:
-        logger.info(
-            "Updating experimental_channel_double_send to %s",
-            update.experimental_channel_double_send,
-        )
-        kwargs["experimental_channel_double_send"] = update.experimental_channel_double_send
-
     if update.auto_decrypt_dm_on_advert is not None:
         logger.info("Updating auto_decrypt_dm_on_advert to %s", update.auto_decrypt_dm_on_advert)
         kwargs["auto_decrypt_dm_on_advert"] = update.auto_decrypt_dm_on_advert
@@ -125,16 +107,43 @@ async def update_settings(update: AppSettingsUpdate) -> AppSettings:
         kwargs["sidebar_sort_order"] = update.sidebar_sort_order
 
     if update.advert_interval is not None:
-        logger.info("Updating advert_interval to %d", update.advert_interval)
-        kwargs["advert_interval"] = update.advert_interval
+        # Enforce minimum 1-hour interval; 0 means disabled
+        interval = update.advert_interval
+        if 0 < interval < 3600:
+            interval = 3600
+        logger.info("Updating advert_interval to %d", interval)
+        kwargs["advert_interval"] = interval
 
-    if update.bots is not None:
-        validate_all_bots(update.bots)
-        logger.info("Updating bots (count=%d)", len(update.bots))
-        kwargs["bots"] = update.bots
+    # Block lists
+    if update.blocked_keys is not None:
+        kwargs["blocked_keys"] = [k.lower() for k in update.blocked_keys]
+    if update.blocked_names is not None:
+        kwargs["blocked_names"] = update.blocked_names
+
+    # Flood scope
+    flood_scope_changed = False
+    if update.flood_scope is not None:
+        stripped = update.flood_scope.strip()
+        kwargs["flood_scope"] = stripped
+        flood_scope_changed = True
 
     if kwargs:
-        return await AppSettingsRepository.update(**kwargs)
+        result = await AppSettingsRepository.update(**kwargs)
+
+        # Apply flood scope to radio immediately if changed
+        if flood_scope_changed:
+            from app.radio import radio_manager
+
+            if radio_manager.is_connected:
+                try:
+                    scope = result.flood_scope
+                    async with radio_manager.radio_operation("set_flood_scope") as mc:
+                        await mc.commands.set_flood_scope(scope if scope else "")
+                        logger.info("Applied flood_scope=%r to radio", scope or "(disabled)")
+                except Exception as e:
+                    logger.warning("Failed to apply flood_scope to radio: %s", e)
+
+        return result
 
     return await AppSettingsRepository.get()
 
@@ -147,10 +156,33 @@ async def toggle_favorite(request: FavoriteRequest) -> AppSettings:
 
     if is_favorited:
         logger.info("Removing favorite: %s %s", request.type, request.id[:12])
-        return await AppSettingsRepository.remove_favorite(request.type, request.id)
+        result = await AppSettingsRepository.remove_favorite(request.type, request.id)
     else:
         logger.info("Adding favorite: %s %s", request.type, request.id[:12])
-        return await AppSettingsRepository.add_favorite(request.type, request.id)
+        result = await AppSettingsRepository.add_favorite(request.type, request.id)
+
+    # When a contact favorite changes, sync the radio so the contact is
+    # loaded/unloaded immediately rather than waiting for the next advert.
+    if request.type == "contact":
+        from app.radio_sync import sync_recent_contacts_to_radio
+
+        asyncio.create_task(sync_recent_contacts_to_radio(force=True))
+
+    return result
+
+
+@router.post("/blocked-keys/toggle", response_model=AppSettings)
+async def toggle_blocked_key(request: BlockKeyRequest) -> AppSettings:
+    """Toggle a public key's blocked status."""
+    logger.info("Toggling blocked key: %s", request.key[:12])
+    return await AppSettingsRepository.toggle_blocked_key(request.key)
+
+
+@router.post("/blocked-names/toggle", response_model=AppSettings)
+async def toggle_blocked_name(request: BlockNameRequest) -> AppSettings:
+    """Toggle a display name's blocked status."""
+    logger.info("Toggling blocked name: %s", request.name)
+    return await AppSettingsRepository.toggle_blocked_name(request.name)
 
 
 @router.post("/migrate", response_model=MigratePreferencesResponse)

app/routers/statistics.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+
+from app.models import StatisticsResponse
+from app.repository import StatisticsRepository
+
+router = APIRouter(prefix="/statistics", tags=["statistics"])
+
+
+@router.get("", response_model=StatisticsResponse)
+async def get_statistics() -> StatisticsResponse:
+    data = await StatisticsRepository.get_all()
+    return StatisticsResponse(**data)

app/websocket.py

@@ -92,14 +92,27 @@ class WebSocketManager:
 ws_manager = WebSocketManager()
 
 
-def broadcast_event(event_type: str, data: dict) -> None:
+def broadcast_event(event_type: str, data: dict, *, realtime: bool = True) -> None:
     """Schedule a broadcast without blocking.
 
     Convenience function that creates an asyncio task to broadcast
-    an event to all connected WebSocket clients.
+    an event to all connected WebSocket clients and forward to fanout modules.
+
+    Args:
+        event_type: Event type string (e.g. "message", "raw_packet")
+        data: Event payload dict
+        realtime: If False, skip fanout dispatch (used for historical decryption)
     """
     asyncio.create_task(ws_manager.broadcast(event_type, data))
 
+    if realtime:
+        from app.fanout.manager import fanout_manager
+
+        if event_type == "message":
+            asyncio.create_task(fanout_manager.broadcast_message(data))
+        elif event_type == "raw_packet":
+            asyncio.create_task(fanout_manager.broadcast_raw(data))
+
 
 def broadcast_error(message: str, details: str | None = None) -> None:
     """Broadcast an error notification to all connected clients.

docker-compose.yaml

@@ -0,0 +1,32 @@
+services:
+  remoteterm:
+    build: .
+    # image: jkingsman/remoteterm-meshcore:latest
+
+    # Optional on Linux: run container as your host user to avoid root-owned files in ./data
+    # user: "${UID:-1000}:${GID:-1000}"
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./data:/app/data
+    ################################################
+    # Set your serial device for passthrough here! #
+    ################################################
+    devices:
+      - /dev/ttyUSB0:/dev/ttyUSB0
+
+    environment:
+      MESHCORE_DATABASE_PATH: data/meshcore.db
+      # Radio connection -- optional if you map just a single serial device above, as the app will autodetect
+
+      # Serial (USB)
+      # MESHCORE_SERIAL_PORT: /dev/ttyUSB0
+      # MESHCORE_SERIAL_BAUDRATE: 115200
+
+      # TCP
+      # MESHCORE_TCP_HOST: 192.168.1.100
+      # MESHCORE_TCP_PORT: 4000
+
+      # Logging
+      # MESHCORE_LOG_LEVEL: INFO
+    restart: unless-stopped

frontend/AGENTS.md

@@ -18,43 +18,94 @@ Keep it aligned with `frontend/src` source code.
 
 ```text
 frontend/src/
+├── main.tsx                # React entry point (StrictMode, root render)
 ├── App.tsx                 # App shell and orchestration
 ├── api.ts                  # Typed REST client
 ├── types.ts                # Shared TS contracts
 ├── useWebSocket.ts         # WS lifecycle + event dispatch
 ├── messageCache.ts         # Conversation-scoped cache
+├── prefetch.ts             # Consumes prefetched API promises started in index.html
 ├── index.css               # Global styles/utilities
 ├── styles.css              # Additional global app styles
+├── themes.css              # Color theme definitions
+├── lib/
+│   └── utils.ts            # cn() — clsx + tailwind-merge helper
 ├── hooks/
-│   ├── useConversationMessages.ts
-│   ├── useUnreadCounts.ts
-│   ├── useRepeaterMode.ts
-│   └── useAirtimeTracking.ts
+│   ├── index.ts            # Central re-export of all hooks
+│   ├── useConversationMessages.ts  # Fetch, pagination, dedup, ACK buffering
+│   ├── useUnreadCounts.ts          # Unread counters, mentions, recent-sort timestamps
+│   ├── useRepeaterDashboard.ts      # Repeater dashboard state (login, panes, console, retries)
+│   ├── useRadioControl.ts          # Radio health/config state, reconnection
+│   ├── useAppSettings.ts           # Settings, favorites, preferences migration
+│   ├── useConversationRouter.ts    # URL hash → active conversation routing
+│   └── useContactsAndChannels.ts   # Contact/channel loading, creation, deletion
 ├── utils/
-│   ├── urlHash.ts
-│   ├── conversationState.ts
-│   ├── favorites.ts
-│   ├── messageParser.ts
-│   ├── pathUtils.ts
-│   ├── pubkey.ts
-│   └── contactAvatar.ts
+│   ├── urlHash.ts              # Hash parsing and encoding
+│   ├── conversationState.ts    # State keys, in-memory + localStorage helpers
+│   ├── favorites.ts            # LocalStorage migration for favorites
+│   ├── messageParser.ts        # Message text → rendered segments
+│   ├── pathUtils.ts            # Distance/validation helpers for paths + map
+│   ├── pubkey.ts               # getContactDisplayName (12-char prefix fallback)
+│   ├── contactAvatar.ts        # Avatar color derivation from public key
+│   ├── rawPacketIdentity.ts    # observation_id vs id dedup helpers
+│   ├── visualizerUtils.ts      # 3D visualizer node types, colors, particles
+│   ├── visualizerSettings.ts   # LocalStorage persistence for visualizer options
+│   ├── a11y.ts                 # Keyboard accessibility helper
+│   ├── lastViewedConversation.ts   # localStorage for last-viewed conversation
+│   ├── contactMerge.ts            # Merge WS contact updates into list
+│   ├── localLabel.ts              # Local label (text + color) in localStorage
+│   ├── radioPresets.ts            # LoRa radio preset configurations
+│   └── theme.ts                   # Theme switching helpers
 ├── components/
 │   ├── StatusBar.tsx
 │   ├── Sidebar.tsx
+│   ├── ChatHeader.tsx          # Conversation header (trace, favorite, delete)
 │   ├── MessageList.tsx
 │   ├── MessageInput.tsx
 │   ├── NewMessageModal.tsx
-│   ├── SettingsModal.tsx
+│   ├── SearchView.tsx          # Full-text message search pane
+│   ├── SettingsModal.tsx       # Layout shell — delegates to settings/ sections
 │   ├── RawPacketList.tsx
 │   ├── MapView.tsx
 │   ├── VisualizerView.tsx
-│   ├── PacketVisualizer.tsx
+│   ├── PacketVisualizer3D.tsx
 │   ├── PathModal.tsx
+│   ├── PathRouteMap.tsx
 │   ├── CrackerPanel.tsx
 │   ├── BotCodeEditor.tsx
 │   ├── ContactAvatar.tsx
-│   └── ui/
+│   ├── ContactInfoPane.tsx     # Contact detail sheet (stats, name history, paths)
+│   ├── ContactStatusInfo.tsx   # Contact status info component
+│   ├── RepeaterDashboard.tsx   # Layout shell — delegates to repeater/ panes
+│   ├── RepeaterLogin.tsx       # Repeater login form (password + guest)
+│   ├── ChannelInfoPane.tsx     # Channel detail sheet (stats, top senders)
+│   ├── NeighborsMiniMap.tsx    # Leaflet mini-map for repeater neighbor locations
+│   ├── settings/
+│   │   ├── settingsConstants.ts          # Settings section type, ordering, labels
+│   │   ├── SettingsRadioSection.tsx      # Name, keys, advert interval, max contacts, radio preset, freq/bw/sf/cr, txPower, lat/lon, reboot
+│   │   ├── SettingsLocalSection.tsx      # Browser-local settings: theme, local label, reopen last conversation
+│   │   ├── SettingsFanoutSection.tsx     # Fanout integrations: MQTT, bots, config CRUD
+│   │   ├── SettingsDatabaseSection.tsx   # DB size, cleanup, auto-decrypt, local label
+│   │   ├── SettingsStatisticsSection.tsx # Read-only mesh network stats
+│   │   ├── SettingsAboutSection.tsx     # Version, author, license, links
+│   │   └── ThemeSelector.tsx           # Color theme picker
+│   ├── repeater/
+│   │   ├── repeaterPaneShared.tsx        # Shared: RepeaterPane, KvRow, format helpers
+│   │   ├── RepeaterTelemetryPane.tsx    # Battery, airtime, packet counts
+│   │   ├── RepeaterNeighborsPane.tsx    # Neighbor table + lazy mini-map
+│   │   ├── RepeaterAclPane.tsx          # Permission table
+│   │   ├── RepeaterRadioSettingsPane.tsx # Radio settings + advert intervals
+│   │   ├── RepeaterLppTelemetryPane.tsx # CayenneLPP sensor data
+│   │   ├── RepeaterOwnerInfoPane.tsx    # Owner info + guest password
+│   │   ├── RepeaterActionsPane.tsx      # Send Advert, Sync Clock, Reboot
+│   │   └── RepeaterConsolePane.tsx      # CLI console with history
+│   └── ui/                     # shadcn/ui primitives
+├── types/
+│   ├── d3-force-3d.d.ts       # Type declarations for d3-force-3d
+│   └── globals.d.ts           # Global type declarations (__APP_VERSION__, __COMMIT_HASH__)
 └── test/
+    ├── setup.ts
+    ├── fixtures/websocket_events.json
     ├── api.test.ts
     ├── appFavorites.test.tsx
     ├── appStartupHash.test.tsx
@@ -63,27 +114,44 @@ frontend/src/
     ├── messageCache.test.ts
     ├── messageParser.test.ts
     ├── pathUtils.test.ts
+    ├── prefetch.test.ts
     ├── radioPresets.test.ts
-    ├── repeaterMode.test.ts
+    ├── rawPacketIdentity.test.ts
+    ├── repeaterDashboard.test.tsx
+    ├── repeaterFormatters.test.ts
+    ├── repeaterLogin.test.tsx
+    ├── repeaterMessageParsing.test.ts
+    ├── localLabel.test.ts
+    ├── messageInput.test.tsx
+    ├── newMessageModal.test.tsx
     ├── settingsModal.test.tsx
+    ├── sidebar.test.tsx
     ├── unreadCounts.test.ts
     ├── urlHash.test.ts
+    ├── appSearchJump.test.tsx
+    ├── channelInfoKeyVisibility.test.tsx
+    ├── chatHeaderKeyVisibility.test.tsx
+    ├── searchView.test.tsx
     ├── useConversationMessages.test.ts
-    ├── useRepeaterMode.test.ts
-    ├── useWebSocket.lifecycle.test.ts
-    ├── websocket.test.ts
-    └── setup.ts
+    ├── useConversationMessages.race.test.ts
+    ├── useRepeaterDashboard.test.ts
+    ├── useContactsAndChannels.test.ts
+    ├── useWebSocket.dispatch.test.ts
+    └── useWebSocket.lifecycle.test.ts
 ```
 
 ## Architecture Notes
 
 ### State ownership
 
-`App.tsx` orchestrates high-level state (health, config, contacts/channels, active conversation, UI flags).
-Specialized logic is delegated to hooks:
+`App.tsx` orchestrates high-level state and delegates to hooks:
+- `useRadioControl`: radio health/config state, reconnect/reboot polling
+- `useAppSettings`: settings CRUD, favorites, preferences migration
+- `useContactsAndChannels`: contact/channel lists, creation, deletion
+- `useConversationRouter`: URL hash → active conversation routing
 - `useConversationMessages`: fetch, pagination, dedup/update helpers
 - `useUnreadCounts`: unread counters, mention tracking, recent-sort timestamps
-- `useRepeaterMode`: repeater login/command workflow
+- `useRepeaterDashboard`: repeater dashboard state (login, pane data/retries, console, actions)
 
 ### Initial load + realtime
 
@@ -91,17 +159,33 @@ Specialized logic is delegated to hooks:
 - WebSocket: realtime deltas/events.
 - On WS connect, backend sends `health` only; contacts/channels still come from REST.
 
+### New Message modal
+
+`NewMessageModal` resets form state on close. The component instance persists across open/close cycles for smooth animations.
+
 ### Message behavior
 
-- Outgoing sends are optimistic in UI and persisted server-side.
+- Outgoing sends are added to UI after the send API returns (not pre-send optimistic insertion), then persisted server-side.
 - Backend also emits WS `message` for outgoing sends so other clients stay in sync.
 - ACK/repeat updates arrive as `message_acked` events.
+- Outgoing channel messages show a 30-second resend control; resend calls `POST /api/messages/channel/{message_id}/resend`.
+
+### Visualizer behavior
+
+- `VisualizerView.tsx` hosts `PacketVisualizer3D.tsx` (desktop split-pane and mobile tabs).
+- `PacketVisualizer3D` uses persistent Three.js geometries for links/highlights/particles and updates typed-array buffers in-place per frame.
+- Packet repeat aggregation keys prefer decoder `messageHash` (path-insensitive), with hash fallback for malformed packets.
+- Raw packet events carry both:
+  - `id`: backend storage row identity (payload-level dedup)
+  - `observation_id`: realtime per-arrival identity (session fidelity)
+- Packet feed/visualizer render keys and dedup logic should use `observation_id` (fallback to `id` only for older payloads).
 
 ## WebSocket (`useWebSocket.ts`)
 
 - Auto reconnect (3s) with cleanup guard on unmount.
 - Heartbeat ping every 30s.
-- Event handlers: `health`, `message`, `contact`, `raw_packet`, `message_acked`, `error`, `success`, `pong` (ignored).
+- Event handlers: `health`, `message`, `contact`, `raw_packet`, `message_acked`, `contact_deleted`, `channel_deleted`, `error`, `success`, `pong` (ignored).
+- For `raw_packet` events, use `observation_id` as event identity; `id` is a storage reference and may repeat.
 
 ## URL Hash Navigation (`utils/urlHash.ts`)
 
@@ -110,6 +194,7 @@ Supported routes:
 - `#map`
 - `#map/focus/{pubkey_or_prefix}`
 - `#visualizer`
+- `#search`
 - `#channel/{channelKey}`
 - `#channel/{channelKey}/{label}`
 - `#contact/{publicKey}`
@@ -149,7 +234,6 @@ LocalStorage migration helpers for favorites; canonical favorites are server-sid
 
 `AppSettings` currently includes:
 - `max_radio_contacts`
-- `experimental_channel_double_send`
 - `favorites`
 - `auto_decrypt_dm_on_advert`
 - `sidebar_sort_order`
@@ -157,15 +241,69 @@ LocalStorage migration helpers for favorites; canonical favorites are server-sid
 - `preferences_migrated`
 - `advert_interval`
 - `last_advert_time`
-- `bots`
+- `flood_scope`
+- `blocked_keys`, `blocked_names`
 
-## Repeater Mode
+Note: MQTT, bot, and community MQTT settings were migrated to the `fanout_configs` table (managed via `/api/fanout`). They are no longer part of `AppSettings`.
 
-For repeater contacts (`type=2`):
-1. Telemetry/login phase (`POST /api/contacts/{key}/telemetry`)
-2. Command phase (`POST /api/contacts/{key}/command`)
+`HealthStatus` includes `fanout_statuses: Record<string, FanoutStatusEntry>` mapping config IDs to `{name, type, status}`. Also includes `bots_disabled: boolean`.
 
-CLI responses are rendered as local-only messages (not persisted to DB).
+`FanoutConfig` represents a single fanout integration: `{id, type, name, enabled, config, scope, sort_order, created_at}`.
+
+`RawPacket.decrypted_info` includes `channel_key` and `contact_key` for MQTT topic routing.
+
+## Contact Info Pane
+
+Clicking a contact's avatar in `ChatHeader` or `MessageList` opens a `ContactInfoPane` sheet (right drawer) showing comprehensive contact details fetched from `GET /api/contacts/{key}/detail`:
+
+- Header: avatar, name, public key, type badge, on-radio badge
+- Info grid: last seen, first heard, last contacted, distance, hops
+- GPS location (clickable → map)
+- Favorite toggle
+- Name history ("Also Known As") — shown only when the contact has used multiple names
+- Message stats: DM count, channel message count
+- Most active rooms (clickable → navigate to channel)
+- Advert observation rate
+- Nearest repeaters (resolved from first-hop path prefixes)
+- Recent advert paths
+
+State: `infoPaneContactKey` in App.tsx controls open/close. Live contact data from WebSocket updates is preferred over the initial detail snapshot.
+
+## Channel Info Pane
+
+Clicking a channel name in `ChatHeader` opens a `ChannelInfoPane` sheet (right drawer) showing channel details fetched from `GET /api/channels/{key}/detail`:
+
+- Header: channel name, key (clickable copy), type badge (hashtag/private key), on-radio badge
+- Favorite toggle
+- Message activity: time-windowed counts (1h, 24h, 48h, 7d, all time) + unique senders
+- First message date
+- Top senders in last 24h (name + count)
+
+State: `infoPaneChannelKey` in App.tsx controls open/close. Live channel data from the `channels` array is preferred over the initial detail snapshot.
+
+## Repeater Dashboard
+
+For repeater contacts (`type=2`), App.tsx renders `RepeaterDashboard` instead of the normal chat UI (ChatHeader + MessageList + MessageInput).
+
+**Login**: `RepeaterLogin` component — password or guest login via `POST /api/contacts/{key}/repeater/login`.
+
+**Dashboard panes** (after login): Telemetry, Neighbors, ACL, Radio Settings, Advert Intervals, Owner Info — each fetched via granular `POST /api/contacts/{key}/repeater/{pane}` endpoints. Panes retry up to 3 times client-side. "Load All" fetches all panes serially (parallel would queue behind the radio lock).
+
+**Actions pane**: Send Advert, Sync Clock, Reboot — all send CLI commands via `POST /api/contacts/{key}/command`.
+
+**Console pane**: Full CLI access via the same command endpoint. History is ephemeral (not persisted to DB).
+
+All state is managed by `useRepeaterDashboard` hook. State resets on conversation change.
+
+## Message Search Pane
+
+The `SearchView` component (`components/SearchView.tsx`) provides full-text search across all DMs and channel messages. Key behaviors:
+
+- **State**: `targetMessageId` in `App.tsx` drives the jump-to-message flow. When a search result is clicked, `handleNavigateToMessage` sets `targetMessageId` and switches to the target conversation.
+- **Persistence**: `SearchView` stays mounted after first open using the same `hidden` class pattern as `CrackerPanel`, preserving search state when navigating to results.
+- **Jump-to-message**: `useConversationMessages` accepts optional `targetMessageId`. When set, it calls `api.getMessagesAround()` instead of normal fetch, loading context around the target message. `MessageList` scrolls to the target via `data-message-id` attribute and applies a `message-highlight` CSS animation.
+- **Bidirectional pagination**: After jumping mid-history, `hasNewerMessages` enables forward pagination via `fetchNewerMessages`. The scroll-to-bottom button calls `jumpToBottom` (re-fetches latest page) instead of just scrolling.
+- **WS message suppression**: When `hasNewerMessages` is true, incoming WS messages for the active conversation are not added to the message list (the user is viewing historical context, not the latest page).
 
 ## Styling
 
@@ -180,6 +318,14 @@ Do not rely on old class-only layout assumptions.
 
 ## Testing
 
+Run all quality checks (backend + frontend) from the repo root:
+
+```bash
+./scripts/all_quality.sh
+```
+
+Or run frontend checks individually:
+
 ```bash
 cd frontend
 npm run test:run
@@ -192,6 +338,12 @@ When touching cross-layer contracts, also run backend tests from repo root:
 PYTHONPATH=. uv run pytest tests/ -v
 ```
 
+## Errata & Known Non-Issues
+
+### RawPacketList always scrolls to bottom
+
+`RawPacketList` unconditionally scrolls to the latest packet on every update. This is intentional — the packet feed is a live status display, not an interactive log meant for lingering or long-term analysis. Users watching it want to see the newest packet, not hold a scroll position.
+
 ## Editing Checklist
 
 1. If API/WS payloads change, update `types.ts`, handlers, and tests.

frontend/index.html

@@ -6,13 +6,50 @@
     <meta name="mobile-web-app-capable" content="yes" />
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <meta name="apple-mobile-web-app-title" content="MCTerm" />
-    <meta name="theme-color" content="#0a0a0a" />
+    <meta name="theme-color" content="#111419" />
+    <meta name="description" content="Web interface for MeshCore mesh radio networks. Send and receive messages, manage contacts and channels, and configure your radio." />
     <title>RemoteTerm for MeshCore</title>
     <link rel="icon" type="image/png" href="/favicon-96x96.png" sizes="96x96" />
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="shortcut icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
     <link rel="manifest" href="/site.webmanifest" />
+    <script>
+      // Start critical data fetches before React/Vite JS loads.
+      // Must be in <head> BEFORE the module script so the browser queues these
+      // fetches before it discovers and starts downloading the JS bundle.
+      // React hooks consume the promises via window.__prefetch.
+      var fetchJsonOrThrow = function(url) {
+        return fetch(url).then(function(response) {
+          if (response.ok) {
+            return response.json();
+          }
+          return response.text().then(function(rawError) {
+            var message = rawError || response.statusText || ('HTTP ' + response.status);
+            try {
+              var parsed = JSON.parse(rawError);
+              if (parsed && typeof parsed.detail === 'string' && parsed.detail.length > 0) {
+                message = parsed.detail;
+              }
+            } catch {
+              // Keep raw text fallback when body is not JSON.
+            }
+            throw new Error('Prefetch failed for ' + url + ': ' + message);
+          });
+        }).catch(function(err) {
+          console.error(err);
+          throw err;
+        });
+      };
+      window.__prefetch = {
+        config: fetchJsonOrThrow('/api/radio/config'),
+        settings: fetchJsonOrThrow('/api/settings'),
+        channels: fetchJsonOrThrow('/api/channels'),
+        contacts: fetchJsonOrThrow('/api/contacts?limit=1000&offset=0'),
+        unreads: fetchJsonOrThrow('/api/read-state/unreads'),
+        undecryptedCount: fetchJsonOrThrow('/api/packets/undecrypted/count'),
+      };
+    </script>
   </head>
   <body>
     <div id="root"></div>

frontend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "remoteterm-meshcore-frontend",
   "private": true,
-  "version": "1.9.3",
+  "version": "2.5.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -9,8 +9,8 @@
     "preview": "vite preview",
     "test": "vitest",
     "test:run": "vitest run",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
+    "lint": "eslint src/ --cache",
+    "lint:fix": "eslint src/ --fix --cache",
     "format": "prettier --write src/",
     "format:check": "prettier --check src/"
   },
@@ -28,7 +28,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "d3-force": "^3.0.0",
-    "framer-motion": "^12.34.0",
+    "d3-force-3d": "^3.0.6",
     "leaflet": "^1.9.4",
     "lucide-react": "^0.562.0",
     "meshcore-hashtag-cracker": "^1.7.0",
@@ -38,17 +38,20 @@
     "react-leaflet": "^4.2.1",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.4.0",
-    "tailwindcss-animate": "^1.0.7"
+    "tailwindcss-animate": "^1.0.7",
+    "three": "^0.182.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
     "@testing-library/jest-dom": "^6.6.0",
     "@testing-library/react": "^16.0.0",
+    "@testing-library/user-event": "^14.6.1",
     "@types/d3-force": "^3.0.10",
     "@types/leaflet": "^1.9.21",
     "@types/node": "^25.0.3",
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
+    "@types/three": "^0.182.0",
     "@vitejs/plugin-react": "^4.3.3",
     "autoprefixer": "^10.4.23",
     "eslint": "^9.17.0",

frontend/public/glyph.svg

@@ -1,8 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg width="700pt" height="700pt" version="1.1" viewBox="0 0 700 700" xmlns="http://www.w3.org/2000/svg">
- <path d="m405.89 352.77c0 30.797-25.02 55.762-55.887 55.762s-55.887-24.965-55.887-55.762c0-30.797 25.02-55.762 55.887-55.762s55.887 24.965 55.887 55.762z"/>
- <path d="m333.07 352.77h33.871v297.37h-33.871z"/>
- <path d="m412.71 495.07-13.648-30.926c44.27-19.438 72.879-63.152 72.879-111.37 0-67.082-54.699-121.65-121.94-121.65-67.242 0-121.94 54.57-121.94 121.65 0 48.215 28.609 91.93 72.879 111.37l-13.648 30.926c-56.547-24.844-93.094-80.695-93.094-142.3 0-85.715 69.887-155.44 155.8-155.44 85.918 0 155.8 69.727 155.8 155.44-0.003906 61.594-36.551 117.46-93.094 142.3z"/>
- <path d="m410.17 581.6-8.5742-32.691c89.277-23.309 151.63-103.96 151.63-196.15 0-111.8-91.168-202.75-203.22-202.75-112.06 0.003907-203.23 90.961-203.23 202.77 0 92.184 62.348 172.83 151.63 196.15l-8.5742 32.691c-104.18-27.195-176.93-121.3-176.93-228.83 0-130.43 106.36-236.54 237.1-236.54 130.73 0 237.1 106.12 237.1 236.54-0.003906 107.52-72.754 201.62-176.93 228.82z"/>
- <path d="m409.05 661.5-6.3125-33.199c132.34-25.047 228.39-140.93 228.39-275.53 0-154.66-126.12-280.48-281.13-280.48-155 0-281.13 125.82-281.13 280.48 0 134.6 96.055 250.48 228.39 275.53l-6.3164 33.199c-148.3-28.07-255.95-157.91-255.95-308.73 0-173.29 141.32-314.27 315-314.27s315 140.98 315 314.27c0 150.81-107.65 280.66-255.95 308.73z"/>
+<svg width="512pt" height="512pt" version="1.1" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">
+ <path d="m455.68 85.902c-31.289 0-56.32 25.031-56.32 56.32 0 11.379 3.4141 21.617 8.5352 30.152l-106.38 135.39c12.516 6.2578 23.895 15.359 32.996 25.602l107.52-136.54c4.5508 1.1367 9.1016 1.707 13.652 1.707 31.289 0 56.32-25.031 56.32-56.32 0-30.719-25.031-56.32-56.32-56.32z"/>
+ <path d="m256 343.04c-5.6875 0-10.809 0.57031-15.93 2.2773l-106.38-135.96c-9.1016 10.809-20.48 19.344-32.996 25.602l106.38 135.96c-5.1211 8.5352-7.3945 18.203-7.3945 28.445 0 31.289 25.031 56.32 56.32 56.32s56.32-25.031 56.32-56.32c0-31.293-25.031-56.324-56.32-56.324z"/>
+ <path d="m356.69 114.91c3.9805-13.652 10.238-26.738 19.344-37.547-38.113-13.652-78.508-21.047-120.04-21.047-59.164 0-115.48 14.789-166.12 42.668-9.1016-6.8281-21.051-10.809-33.562-10.809-31.289-0.57031-56.32 25.027-56.32 55.75 0 31.289 25.031 56.32 56.32 56.32 31.289 0 56.32-25.031 56.32-56.32 0-3.4141-0.57031-6.8281-1.1367-9.6719 44.371-23.895 93.297-36.41 144.5-36.41 34.703 0 68.836 5.6914 100.69 17.066z"/>
 </svg>

frontend/public/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

frontend/public/site.webmanifest

@@ -1,21 +0,0 @@
-{
-  "name": "RemoteTerm for MeshCore",
-  "short_name": "RemoteTerm",
-  "icons": [
-    {
-      "src": "/web-app-manifest-192x192.png",
-      "sizes": "192x192",
-      "type": "image/png",
-      "purpose": "maskable"
-    },
-    {
-      "src": "/web-app-manifest-512x512.png",
-      "sizes": "512x512",
-      "type": "image/png",
-      "purpose": "maskable"
-    }
-  ],
-  "theme_color": "#ffffff",
-  "background_color": "#ffffff",
-  "display": "standalone"
-}

frontend/src/api.ts

@@ -2,17 +2,31 @@ import type {
   AppSettings,
   AppSettingsUpdate,
   Channel,
+  ChannelDetail,
   CommandResponse,
   Contact,
+  ContactAdvertPath,
+  ContactAdvertPathSummary,
+  ContactDetail,
+  FanoutConfig,
   Favorite,
   HealthStatus,
   MaintenanceResult,
   Message,
+  MessagesAroundResponse,
   MigratePreferencesRequest,
   MigratePreferencesResponse,
   RadioConfig,
   RadioConfigUpdate,
-  TelemetryResponse,
+  RepeaterAclResponse,
+  RepeaterAdvertIntervalsResponse,
+  RepeaterLoginResponse,
+  RepeaterLppTelemetryResponse,
+  RepeaterNeighborsResponse,
+  RepeaterOwnerInfoResponse,
+  RepeaterRadioSettingsResponse,
+  RepeaterStatusResponse,
+  StatisticsResponse,
   TraceResponse,
   UnreadCounts,
 } from './types';
@@ -20,10 +34,11 @@ import type {
 const API_BASE = '/api';
 
 async function fetchJson<T>(url: string, options?: RequestInit): Promise<T> {
+  const hasBody = options?.body !== undefined;
   const res = await fetch(`${API_BASE}${url}`, {
     ...options,
     headers: {
-      'Content-Type': 'application/json',
+      ...(hasBody && { 'Content-Type': 'application/json' }),
       ...options?.headers,
     },
   });
@@ -92,6 +107,14 @@ export const api = {
   // Contacts
   getContacts: (limit = 100, offset = 0) =>
     fetchJson<Contact[]>(`/contacts?limit=${limit}&offset=${offset}`),
+  getRepeaterAdvertPaths: (limitPerRepeater = 10) =>
+    fetchJson<ContactAdvertPathSummary[]>(
+      `/contacts/repeaters/advert-paths?limit_per_repeater=${limitPerRepeater}`
+    ),
+  getContactAdvertPaths: (publicKey: string, limit = 10) =>
+    fetchJson<ContactAdvertPath[]>(`/contacts/${publicKey}/advert-paths?limit=${limit}`),
+  getContactDetail: (publicKey: string) =>
+    fetchJson<ContactDetail>(`/contacts/${publicKey}/detail`),
   deleteContact: (publicKey: string) =>
     fetchJson<{ status: string }>(`/contacts/${publicKey}`, {
       method: 'DELETE',
@@ -105,11 +128,6 @@ export const api = {
     fetchJson<{ status: string; public_key: string }>(`/contacts/${publicKey}/mark-read`, {
       method: 'POST',
     }),
-  requestTelemetry: (publicKey: string, password: string) =>
-    fetchJson<TelemetryResponse>(`/contacts/${publicKey}/telemetry`, {
-      method: 'POST',
-      body: JSON.stringify({ password }),
-    }),
   sendRepeaterCommand: (publicKey: string, command: string) =>
     fetchJson<CommandResponse>(`/contacts/${publicKey}/command`, {
       method: 'POST',
@@ -119,6 +137,10 @@ export const api = {
     fetchJson<TraceResponse>(`/contacts/${publicKey}/trace`, {
       method: 'POST',
     }),
+  resetContactPath: (publicKey: string) =>
+    fetchJson<{ status: string; public_key: string }>(`/contacts/${publicKey}/reset-path`, {
+      method: 'POST',
+    }),
 
   // Channels
   getChannels: () => fetchJson<Channel[]>('/channels'),
@@ -129,6 +151,7 @@ export const api = {
     }),
   deleteChannel: (key: string) =>
     fetchJson<{ status: string }>(`/channels/${key}`, { method: 'DELETE' }),
+  getChannelDetail: (key: string) => fetchJson<ChannelDetail>(`/channels/${key}/detail`),
   markChannelRead: (key: string) =>
     fetchJson<{ status: string; key: string }>(`/channels/${key}/mark-read`, {
       method: 'POST',
@@ -143,19 +166,40 @@ export const api = {
       conversation_key?: string;
       before?: number;
       before_id?: number;
+      after?: number;
+      after_id?: number;
+      q?: string;
     },
     signal?: AbortSignal
   ) => {
     const searchParams = new URLSearchParams();
-    if (params?.limit) searchParams.set('limit', params.limit.toString());
-    if (params?.offset) searchParams.set('offset', params.offset.toString());
+    if (params?.limit !== undefined) searchParams.set('limit', params.limit.toString());
+    if (params?.offset !== undefined) searchParams.set('offset', params.offset.toString());
     if (params?.type) searchParams.set('type', params.type);
     if (params?.conversation_key) searchParams.set('conversation_key', params.conversation_key);
     if (params?.before !== undefined) searchParams.set('before', params.before.toString());
     if (params?.before_id !== undefined) searchParams.set('before_id', params.before_id.toString());
+    if (params?.after !== undefined) searchParams.set('after', params.after.toString());
+    if (params?.after_id !== undefined) searchParams.set('after_id', params.after_id.toString());
+    if (params?.q) searchParams.set('q', params.q);
     const query = searchParams.toString();
     return fetchJson<Message[]>(`/messages${query ? `?${query}` : ''}`, { signal });
   },
+  getMessagesAround: (
+    messageId: number,
+    type?: 'PRIV' | 'CHAN',
+    conversationKey?: string,
+    signal?: AbortSignal
+  ) => {
+    const searchParams = new URLSearchParams();
+    if (type) searchParams.set('type', type);
+    if (conversationKey) searchParams.set('conversation_key', conversationKey);
+    const query = searchParams.toString();
+    return fetchJson<MessagesAroundResponse>(
+      `/messages/around/${messageId}${query ? `?${query}` : ''}`,
+      { signal }
+    );
+  },
   sendDirectMessage: (destination: string, text: string) =>
     fetchJson<Message>('/messages/direct', {
       method: 'POST',
@@ -166,6 +210,11 @@ export const api = {
       method: 'POST',
       body: JSON.stringify({ channel_key: channelKey, text }),
     }),
+  resendChannelMessage: (messageId: number, newTimestamp?: boolean) =>
+    fetchJson<{ status: string; message_id: number }>(
+      `/messages/channel/${messageId}/resend${newTimestamp ? '?new_timestamp=true' : ''}`,
+      { method: 'POST' }
+    ),
 
   // Packets
   getUndecryptedPacketCount: () => fetchJson<{ count: number }>('/packets/undecrypted/count'),
@@ -178,17 +227,21 @@ export const api = {
       method: 'POST',
       body: JSON.stringify(params),
     }),
-  runMaintenance: (pruneUndecryptedDays: number) =>
+  runMaintenance: (options: { pruneUndecryptedDays?: number; purgeLinkedRawPackets?: boolean }) =>
     fetchJson<MaintenanceResult>('/packets/maintenance', {
       method: 'POST',
-      body: JSON.stringify({ prune_undecrypted_days: pruneUndecryptedDays }),
+      body: JSON.stringify({
+        ...(options.pruneUndecryptedDays !== undefined && {
+          prune_undecrypted_days: options.pruneUndecryptedDays,
+        }),
+        ...(options.purgeLinkedRawPackets !== undefined && {
+          purge_linked_raw_packets: options.purgeLinkedRawPackets,
+        }),
+      }),
     }),
 
   // Read State
-  getUnreads: (name?: string) => {
-    const params = name ? `?name=${encodeURIComponent(name)}` : '';
-    return fetchJson<UnreadCounts>(`/read-state/unreads${params}`);
-  },
+  getUnreads: () => fetchJson<UnreadCounts>('/read-state/unreads'),
   markAllRead: () =>
     fetchJson<{ status: string; timestamp: number }>('/read-state/mark-all-read', {
       method: 'POST',
@@ -202,6 +255,18 @@ export const api = {
       body: JSON.stringify(settings),
     }),
 
+  // Block lists
+  toggleBlockedKey: (key: string) =>
+    fetchJson<AppSettings>('/settings/blocked-keys/toggle', {
+      method: 'POST',
+      body: JSON.stringify({ key }),
+    }),
+  toggleBlockedName: (name: string) =>
+    fetchJson<AppSettings>('/settings/blocked-names/toggle', {
+      method: 'POST',
+      body: JSON.stringify({ name }),
+    }),
+
   // Favorites
   toggleFavorite: (type: Favorite['type'], id: string) =>
     fetchJson<AppSettings>('/settings/favorites/toggle', {
@@ -215,4 +280,73 @@ export const api = {
       method: 'POST',
       body: JSON.stringify(request),
     }),
+
+  // Fanout
+  getFanoutConfigs: () => fetchJson<FanoutConfig[]>('/fanout'),
+  createFanoutConfig: (config: {
+    type: string;
+    name: string;
+    config: Record<string, unknown>;
+    scope: Record<string, unknown>;
+    enabled?: boolean;
+  }) =>
+    fetchJson<FanoutConfig>('/fanout', {
+      method: 'POST',
+      body: JSON.stringify(config),
+    }),
+  updateFanoutConfig: (
+    id: string,
+    update: {
+      name?: string;
+      config?: Record<string, unknown>;
+      scope?: Record<string, unknown>;
+      enabled?: boolean;
+    }
+  ) =>
+    fetchJson<FanoutConfig>(`/fanout/${id}`, {
+      method: 'PATCH',
+      body: JSON.stringify(update),
+    }),
+  deleteFanoutConfig: (id: string) =>
+    fetchJson<{ deleted: boolean }>(`/fanout/${id}`, {
+      method: 'DELETE',
+    }),
+
+  // Statistics
+  getStatistics: () => fetchJson<StatisticsResponse>('/statistics'),
+
+  // Granular repeater endpoints
+  repeaterLogin: (publicKey: string, password: string) =>
+    fetchJson<RepeaterLoginResponse>(`/contacts/${publicKey}/repeater/login`, {
+      method: 'POST',
+      body: JSON.stringify({ password }),
+    }),
+  repeaterStatus: (publicKey: string) =>
+    fetchJson<RepeaterStatusResponse>(`/contacts/${publicKey}/repeater/status`, {
+      method: 'POST',
+    }),
+  repeaterNeighbors: (publicKey: string) =>
+    fetchJson<RepeaterNeighborsResponse>(`/contacts/${publicKey}/repeater/neighbors`, {
+      method: 'POST',
+    }),
+  repeaterAcl: (publicKey: string) =>
+    fetchJson<RepeaterAclResponse>(`/contacts/${publicKey}/repeater/acl`, {
+      method: 'POST',
+    }),
+  repeaterRadioSettings: (publicKey: string) =>
+    fetchJson<RepeaterRadioSettingsResponse>(`/contacts/${publicKey}/repeater/radio-settings`, {
+      method: 'POST',
+    }),
+  repeaterAdvertIntervals: (publicKey: string) =>
+    fetchJson<RepeaterAdvertIntervalsResponse>(`/contacts/${publicKey}/repeater/advert-intervals`, {
+      method: 'POST',
+    }),
+  repeaterOwnerInfo: (publicKey: string) =>
+    fetchJson<RepeaterOwnerInfoResponse>(`/contacts/${publicKey}/repeater/owner-info`, {
+      method: 'POST',
+    }),
+  repeaterLppTelemetry: (publicKey: string) =>
+    fetchJson<RepeaterLppTelemetryResponse>(`/contacts/${publicKey}/repeater/lpp-telemetry`, {
+      method: 'POST',
+    }),
 };

frontend/src/components/AGENTS_packet_visualizer.md

@@ -1,20 +1,18 @@
-# PacketVisualizer Architecture
+# PacketVisualizer3D Architecture
 
-This document explains the architecture and design of the PacketVisualizer component, which renders a real-time force-directed graph visualization of mesh network packet traffic.
+This document explains the architecture and design of the `PacketVisualizer3D` component, which renders a real-time 3D force-directed graph visualization of mesh network packet traffic using Three.js and `d3-force-3d`.
 
 ## Overview
 
-The PacketVisualizer displays:
+The visualizer displays:
 
-- **Nodes**: Network participants (self, repeaters, clients)
+- **Nodes**: Network participants (self, repeaters, clients) as colored spheres
 - **Links**: Connections between nodes based on observed packet paths
-- **Particles**: Animated dots traveling along links representing packets in transit
+- **Particles**: Animated colored dots traveling along links representing packets in transit
 
-## Architecture: Data Layer vs Rendering Layer
+## Architecture
 
-The component is split into two distinct layers to enable future rendering engine swaps (e.g., WebGL, Three.js):
-
-### Data Layer (`useVisualizerData` hook)
+### Data Layer (`useVisualizerData3D` hook)
 
 The custom hook manages all graph state and simulation logic:
 
@@ -25,7 +23,7 @@ Packets → Parse → Aggregate by key → Observation window → Publish → An
 **Key responsibilities:**
 
 - Maintains node and link maps (`nodesRef`, `linksRef`)
-- Runs D3 force simulation for layout
+- Runs `d3-force-3d` simulation for 3D layout (`.numDimensions(3)`)
 - Processes incoming packets with deduplication
 - Aggregates packet repeats across multiple paths
 - Manages particle queue and animation timing
@@ -35,19 +33,32 @@ Packets → Parse → Aggregate by key → Observation window → Publish → An
 - `nodesRef`: Map of node ID → GraphNode
 - `linksRef`: Map of link key → GraphLink
 - `particlesRef`: Array of active Particle objects
-- `simulationRef`: D3 force simulation instance
+- `simulationRef`: d3-force-3d simulation instance
 - `pendingRef`: Packets in observation window awaiting animation
 - `timersRef`: Per-packet publish timers
 
-### Rendering Layer (canvas drawing functions)
+### Rendering Layer (Three.js)
 
-Separate pure functions handle all canvas rendering:
+- `THREE.WebGLRenderer` + `CSS2DRenderer` (text labels overlaid on 3D scene)
+- `OrbitControls` for camera interaction (orbit, pan, zoom)
+- `THREE.Mesh` with `SphereGeometry` per node + `CSS2DObject` labels
+- `THREE.LineSegments` for links (persistent geometries; position buffers updated in-place each frame)
+- `THREE.Points` with vertex colors for particles (persistent geometry + circular sprite texture)
+- `THREE.Raycaster` for hover/click detection on node spheres
 
-- `renderLinks()`: Draws connections between nodes
-- `renderParticles()`: Draws animated packets with labels
-- `renderNodes()`: Draws node circles with emojis/text
+### Shared Utilities (`utils/visualizerUtils.ts`)
 
-The main component orchestrates rendering via `requestAnimationFrame`.
+Types, constants, and pure functions shared across the codebase:
+
+- Types: `NodeType`, `PacketLabel`, `Particle`, `ObservedPath`, `PendingPacket`, `ParsedPacket`, `TrafficObservation`, `RepeaterTrafficData`, `RepeaterSplitAnalysis`
+- Constants: `COLORS`, `PARTICLE_COLOR_MAP`, `PARTICLE_SPEED`, `DEFAULT_OBSERVATION_WINDOW_SEC`, traffic thresholds, `PACKET_LEGEND_ITEMS`
+- Functions: `hashString` (from `utils/contactAvatar.ts`), `parsePacket`, `getPacketLabel`, `generatePacketKey`, `getLinkId`, `getNodeType`, `dedupeConsecutive`, `analyzeRepeaterTraffic`, `recordTrafficObservation`
+
+`GraphNode` and `GraphLink` are defined locally in the component — they extend `SimulationNodeDatum3D` and `SimulationLinkDatum` from `d3-force-3d`.
+
+### Type Declarations (`types/d3-force-3d.d.ts`)
+
+Minimal `.d.ts` file for `d3-force-3d` which has no bundled TypeScript types. Declares `SimulationNodeDatum3D` extending `SimulationNodeDatum` with `z`/`vz`/`fz` properties.
 
 ## Packet Processing Pipeline
 
@@ -70,12 +81,14 @@ packets.forEach((packet) => {
 
 Packets are grouped by a unique key to aggregate repeats:
 
-| Packet Type    | Key Format                                |
-| -------------- | ----------------------------------------- |
-| Advertisement  | `ad:{pubkey_prefix_12}`                   |
-| Group Text     | `gt:{channel}:{sender}:{content_hash}`    |
-| Direct Message | `dm:{src_hash}:{dst_hash}:{content_hash}` |
-| Other          | `other:{data_hash}`                       |
+| Packet Type    | Key Format                                             |
+| -------------- | ------------------------------------------------------ |
+| Advertisement  | `ad:{pubkey_prefix_12}`                                |
+| Group Text     | `gt:{channel}:{sender}:{message_hash_or_data_hash}`    |
+| Direct Message | `dm:{src_hash}:{dst_hash}:{message_hash_or_data_hash}` |
+| Other          | `other:{message_hash_or_data_hash}`                    |
+
+`parsePacket()` exposes decoder `messageHash` (path-insensitive). `generatePacketKey()` prefers that hash, falling back to a local data hash for malformed/unsupported packets.
 
 ### 3. Observation Window
 
@@ -86,7 +99,7 @@ if (existing && now < existing.expiresAt) {
   // Append path to existing entry
   existing.paths.push({ nodes: path, snr: packet.snr, timestamp: now });
 } else {
-  // Create new pending entry with 2-second observation window
+  // Create new pending entry with observation window
   pendingPacketsRef.current.set(key, {
     key,
     label,
@@ -120,25 +133,28 @@ function publishPacket(pending: PendingPacket) {
 
 **Key insight:** Particles start with negative progress. This creates smooth flow through multi-hop paths without pausing at intermediate nodes.
 
-## D3 Force Simulation
+## D3 Force Simulation (3D)
 
-The layout uses D3's force simulation with these forces:
+The layout uses `d3-force-3d` with `.numDimensions(3)`:
 
-| Force         | Purpose                                              |
-| ------------- | ---------------------------------------------------- |
-| `link`        | Pulls connected nodes together                       |
-| `charge`      | Repels nodes from each other (self node 6x stronger) |
-| `center`      | Gently pulls graph toward center                     |
-| `collide`     | Prevents node overlap                                |
-| `selfX/selfY` | Anchors self node near center                        |
+| Force               | Purpose                                        |
+| ------------------- | ---------------------------------------------- |
+| `link`              | Pulls connected nodes together (distance: 120) |
+| `charge`            | Repels nodes (self node 6x stronger, max: 800) |
+| `center`            | Gently pulls graph toward origin (0, 0, 0)     |
+| `selfX/selfY/selfZ` | Anchors self node near origin                  |
 
 ### Shuffle Layout
 
-The "Shuffle layout" button randomizes all node positions (except self, which stays centered) and reheats the simulation to alpha=1. This lets users try different random starting configurations to find a cleaner layout.
+The "Shuffle layout" button randomizes all node positions in a 3D sphere (radius 200, except self stays at origin) and reheats the simulation to alpha=1.
 
 ### Continuous Drift
 
-When "Let 'em drift" is enabled, `alphaTarget(0.05)` keeps the simulation running indefinitely, allowing the graph to continuously reorganize into better layouts.
+When "Let 'em drift" is enabled, `alphaTarget(0.05)` keeps the simulation running indefinitely, allowing the graph to continuously reorganize.
+
+### Expand/Contract ("Oooh Big Stretch!")
+
+Temporarily increases repulsion to push nodes apart, then relaxes back. Useful for untangling dense graphs.
 
 ## Node Resolution
 
@@ -147,7 +163,7 @@ Nodes are resolved from various sources:
 ```typescript
 function resolveNode(source, isRepeater, showAmbiguous): string | null {
   // source.type can be: 'pubkey', 'prefix', or 'name'
-  // Try to find matching contact
+  // Use precomputed contact indexes (by 12-char prefix, by name, by shorter prefixes)
   // If found: use full 12-char prefix as node ID
   // If not found and showAmbiguous: create "?prefix" node
   // Otherwise: return null (path terminates)
@@ -156,7 +172,24 @@ function resolveNode(source, isRepeater, showAmbiguous): string | null {
 
 ### Ambiguous Nodes
 
-When only a 1-byte prefix is known (from packet path bytes), the node is marked ambiguous and shown with a `?` prefix and gray styling.
+When only a 1-byte prefix is known (from packet path bytes), the node is marked ambiguous and shown with a `?` prefix and gray styling. However, if the node is identified as a repeater (via advert or path hop), it shows blue regardless of ambiguity.
+
+### Advert-Path Identity Hints
+
+**Problem:** When multiple repeaters share a 1-byte prefix, the visualizer can't tell which physical repeater a path hop refers to.
+
+**Solution:** The backend tracks recent unique advertisement paths per contact in `contact_advert_paths` (see root `AGENTS.md` § "Contact Advert Path Memory"). On mount (and when new contacts appear), the visualizer fetches this data via `GET /api/contacts/repeaters/advert-paths` and builds an index keyed by 12-char prefix.
+
+**Scoring:** `pickLikelyRepeaterByAdvertPath(candidates, nextPrefix)` scores each candidate repeater by how often its stored advert paths' `next_hop` matches the packet's actual next-hop prefix. It requires:
+
+- At least 2 matching observations (stronger-than-trivial evidence)
+- The top candidate's match score must be at least 2x the runner-up's
+
+When a winner is found, the ambiguous node gets a `probableIdentity` label (the likely repeater's name) and the display name updates accordingly. The remaining candidates are listed as "Other possible" in the tooltip.
+
+**Interaction with traffic splitting:** Advert-path hints run first. If a probable identity is found, the display name is set. Traffic splitting can still produce separate node IDs (`?XX:>YY`), but won't overwrite the advert-path display name.
+
+**Toggle:** "Use repeater advert-path identity hints" checkbox (enabled by default, disabled when ambiguous repeaters are hidden).
 
 ### Traffic Pattern Splitting (Experimental)
 
@@ -198,7 +231,6 @@ Here source `ae` routes through `32` to BOTH `ba` and `60`. This proves `32` is
    - Source sets are completely disjoint (no source appears in multiple groups)
    - Each group has at least 20 unique sources (conservative threshold)
 4. **Final repeaters** (no next hop, connects directly to self): Never split
-   - Rationale: The last repeater before you is clearly a single physical node
 
 **Node ID format:**
 
@@ -206,12 +238,6 @@ Here source `ae` routes through `32` to BOTH `ba` and `60`. This proves `32` is
 - With splitting (after evidence threshold met): `?XX:>YY` (e.g., `?32:>ba`)
 - Final repeater: `?XX` (unchanged, no suffix)
 
-**Implementation Notes:**
-
-- Observations are stored with timestamps and pruned after 30 minutes
-- Maximum 200 observations per prefix to limit memory
-- Once split, nodes cannot be un-split (be conservative before splitting)
-
 ## Path Building
 
 Paths are constructed from packet data:
@@ -243,8 +269,6 @@ function buildPath(parsed, packet, myPrefix): string[] {
 
 ### Sender Extraction by Packet Type
 
-Different packet types provide different levels of sender identification:
-
 | Packet Type    | Sender Info Available          | Resolution                     |
 | -------------- | ------------------------------ | ------------------------------ |
 | Advertisement  | Full 32-byte public key        | Exact contact match            |
@@ -254,106 +278,86 @@ Different packet types provide different levels of sender identification:
 | Request        | 1-byte source hash             | Ambiguous                      |
 | Other          | None                           | Path bytes only                |
 
-**AnonRequest packets** are particularly useful because they include the sender's full public key (unlike regular Request packets which only have a 1-byte hash). This allows exact identification of who is making the request.
+## Node Colors
 
-## Canvas Rendering
-
-### Coordinate Transformation
-
-Pan and zoom are applied via transform matrix:
-
-```typescript
-ctx.setTransform(dpr * scale, 0, 0, dpr * scale, dpr * (x + panX), dpr * (y + panY));
-```
-
-### Render Order
-
-1. Clear canvas with background
-2. Draw links (gray lines)
-3. Draw particles (colored dots with labels)
-4. Draw nodes (circles with emojis)
-5. Draw hover tooltip if applicable
+| Color   | Hex       | Meaning                                        |
+| ------- | --------- | ---------------------------------------------- |
+| Green   | `#22c55e` | Self node (larger sphere)                      |
+| Blue    | `#3b82f6` | Repeater                                       |
+| White   | `#ffffff` | Client                                         |
+| Gray    | `#9ca3af` | Unknown/ambiguous (not identified as repeater) |
+| Gold    | `#ffd700` | Active (hovered or pinned) node                |
+| Lt Gold | `#fff0b3` | Neighbors of active node                       |
 
 ## Mouse Interactions
 
-| Action                     | Behavior                                         |
-| -------------------------- | ------------------------------------------------ |
-| Click + drag on node       | Move node to new position (temporarily fixes it) |
-| Release dragged node       | Node returns to force-directed layout            |
-| Click + drag on empty area | Pan the canvas                                   |
-| Scroll wheel               | Zoom in/out                                      |
-| Hover over node            | Shows node details, cursor changes to pointer    |
+| Action                     | Behavior                                    |
+| -------------------------- | ------------------------------------------- |
+| Left-click on node         | Pin: highlight node + links + neighbors     |
+| Left-click pinned node     | Unpin: remove highlights                    |
+| Left-click empty space     | Unpin any pinned node                       |
+| Hover over node            | Shows tooltip with node details + neighbors |
+| Orbit (left-drag on space) | Rotate camera around scene                  |
+| Pan (right-drag)           | Pan the camera                              |
+| Scroll wheel               | Zoom in/out                                 |
 
-**Node Dragging Implementation:**
-
-- On mouse down over a node, sets `fx`/`fy` (D3 fixed position) to lock it
-- On mouse move, updates the fixed position to follow cursor
-- On mouse up, clears `fx`/`fy` so node rejoins the simulation
-- Simulation is slightly reheated during drag for responsive feedback
+**Click-to-pin:** When a node is pinned, hovering other nodes does not change the highlight. The tooltip shows "Traffic exchanged with:" listing all connected neighbors with their possible names.
 
 ## Configuration Options
 
 | Option                     | Default | Description                                               |
 | -------------------------- | ------- | --------------------------------------------------------- |
-| Ambiguous path repeaters   | On      | Show nodes when only partial prefix known                 |
+| Ambiguous repeaters        | On      | Show nodes when only partial prefix known                 |
 | Ambiguous sender/recipient | Off     | Show placeholder nodes for unknown senders                |
+| Advert-path identity hints | On      | Use stored advert paths to label ambiguous repeaters      |
 | Split by traffic pattern   | Off     | Split ambiguous repeaters by next-hop routing (see above) |
-| Hide repeaters >48hrs      | Off     | Filter out old repeaters                                  |
 | Observation window         | 15 sec  | Wait time for duplicate packets before animating (1-60s)  |
 | Let 'em drift              | On      | Continuous layout optimization                            |
 | Repulsion                  | 200     | Force strength (50-2500)                                  |
 | Packet speed               | 2x      | Particle animation speed multiplier (1x-5x)               |
 | Shuffle layout             | -       | Button to randomize node positions and reheat sim         |
 | Oooh Big Stretch!          | -       | Button to temporarily increase repulsion then relax       |
+| Clear & Reset              | -       | Button to clear all nodes, links, and packets             |
 | Hide UI                    | Off     | Hide legends and most controls for cleaner view           |
 | Full screen                | Off     | Hide the packet feed panel (desktop only)                 |
 
 ## File Structure
 
 ```
-PacketVisualizer.tsx
-├── TYPES (GraphNode, GraphLink, Particle, etc.)
-├── CONSTANTS (colors, timing, legend items)
-├── UTILITY FUNCTIONS
-│   ├── simpleHash()
-│   ├── parsePacket()
-│   ├── getPacketLabel()
-│   ├── generatePacketKey()
-│   ├── findContactBy*()
-│   ├── dedupeConsecutive()
-│   ├── analyzeRepeaterTraffic()
-│   └── recordTrafficObservation()
-├── DATA LAYER HOOK (useVisualizerData)
-│   ├── Refs (nodes, links, particles, simulation, pending, timers, trafficPatterns)
-│   ├── Simulation initialization
+PacketVisualizer3D.tsx
+├── TYPES (GraphNode extends SimulationNodeDatum3D, GraphLink)
+├── CONSTANTS (NODE_COLORS, NODE_LEGEND_ITEMS)
+├── DATA LAYER HOOK (useVisualizerData3D)
+│   ├── Refs (nodes, links, particles, simulation, pending, timers, trafficPatterns, stretchRaf)
+│   ├── d3-force-3d simulation initialization (.numDimensions(3))
+│   ├── Contact indexing (byPrefix12 / byName / byPrefix)
 │   ├── Node/link management (addNode, addLink, syncSimulation)
 │   ├── Path building (resolveNode, buildPath)
 │   ├── Traffic pattern analysis (for repeater disambiguation)
 │   └── Packet processing & publishing
-├── RENDERING FUNCTIONS
-│   ├── renderLinks()
-│   ├── renderParticles()
-│   └── renderNodes()
-└── MAIN COMPONENT (PacketVisualizer)
-    ├── State (dimensions, options, transform, hover)
-    ├── Event handlers (mouse, wheel)
-    ├── Animation loop
-    └── JSX (canvas, legend, settings panel)
+└── MAIN COMPONENT (PacketVisualizer3D)
+    ├── Three.js scene setup (WebGLRenderer, CSS2DRenderer, OrbitControls)
+    ├── Node mesh management (SphereGeometry + CSS2DObject labels)
+    ├── Link rendering (persistent LineSegments + dynamic position buffer updates)
+    ├── Particle rendering (persistent Points + dynamic position/color buffer updates)
+    ├── Raycasting (hover detection, click-to-pin)
+    ├── State (options, pinned/hovered node, neighbors; change-detected UI updates)
+    └── JSX (container, legend overlay, options panel, tooltip)
+
+utils/visualizerUtils.ts
+├── Types (NodeType, PacketLabel, Particle, PendingPacket, ParsedPacket, etc.)
+├── Constants (COLORS, PARTICLE_COLOR_MAP, PARTICLE_SPEED, PACKET_LEGEND_ITEMS)
+└── Functions (parsePacket, generatePacketKey, analyzeRepeaterTraffic, etc.)
+
+types/d3-force-3d.d.ts
+└── Type declarations for d3-force-3d (SimulationNodeDatum3D, Simulation3D, forces)
 ```
 
 ## Performance Considerations
 
-- **Observation window**: 2 seconds balances latency vs. path aggregation
-- **Max links**: Capped at 100 to prevent graph explosion
+- **Observation window**: Configurable (default 15s) to balance latency vs. path aggregation
+- **Persistent geometries**: Links/highlights/particles are created once; buffers are updated per frame to reduce GC/GPU churn
 - **Particle culling**: Particles removed when progress > 1
-- **Node filtering**: Old repeaters can be hidden to reduce clutter
+- **Change-detected React updates**: Hover + neighbor UI state updates only when values change
 - **requestAnimationFrame**: Render loop tied to display refresh rate
-
-## Future Improvements
-
-The data/rendering split enables:
-
-- WebGL rendering for larger graphs
-- 3D visualization
-- Different layout algorithms
-- Export to other formats
+- **CSS2DRenderer z-index**: Set to 1 so UI overlays (z-10) render above node labels

frontend/src/components/BotCodeEditor.tsx

@@ -25,6 +25,7 @@ export function BotCodeEditor({ value, onChange, id, height = '256px' }: BotCode
         }}
         className="text-sm"
         id={id}
+        aria-label="Bot code editor"
       />
     </div>
   );

frontend/src/components/ChannelInfoPane.tsx

@@ -0,0 +1,227 @@
+import { useEffect, useState } from 'react';
+import { api } from '../api';
+import { formatTime } from '../utils/messageParser';
+import { isFavorite } from '../utils/favorites';
+import { handleKeyboardActivate } from '../utils/a11y';
+import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from './ui/sheet';
+import { toast } from './ui/sonner';
+import type { Channel, ChannelDetail, Favorite } from '../types';
+
+interface ChannelInfoPaneProps {
+  channelKey: string | null;
+  onClose: () => void;
+  channels: Channel[];
+  favorites: Favorite[];
+  onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
+}
+
+export function ChannelInfoPane({
+  channelKey,
+  onClose,
+  channels,
+  favorites,
+  onToggleFavorite,
+}: ChannelInfoPaneProps) {
+  const [detail, setDetail] = useState<ChannelDetail | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [showKey, setShowKey] = useState(false);
+
+  // Get live channel data from channels array (real-time via WS)
+  const liveChannel = channelKey ? (channels.find((c) => c.key === channelKey) ?? null) : null;
+
+  useEffect(() => {
+    setShowKey(false);
+    if (!channelKey) {
+      setDetail(null);
+      return;
+    }
+
+    let cancelled = false;
+    setLoading(true);
+    api
+      .getChannelDetail(channelKey)
+      .then((data) => {
+        if (!cancelled) setDetail(data);
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          console.error('Failed to fetch channel detail:', err);
+          toast.error('Failed to load channel info');
+        }
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [channelKey]);
+
+  // Use live channel data where available, fall back to detail snapshot
+  const channel = liveChannel ?? detail?.channel ?? null;
+
+  return (
+    <Sheet open={channelKey !== null} onOpenChange={(open) => !open && onClose()}>
+      <SheetContent side="right" className="w-full sm:max-w-[400px] p-0 flex flex-col">
+        <SheetHeader className="sr-only">
+          <SheetTitle>Channel Info</SheetTitle>
+          <SheetDescription>Channel details and statistics</SheetDescription>
+        </SheetHeader>
+
+        {loading && !detail ? (
+          <div className="flex-1 flex items-center justify-center text-muted-foreground">
+            Loading...
+          </div>
+        ) : channel ? (
+          <div className="flex-1 overflow-y-auto">
+            {/* Header */}
+            <div className="px-5 pt-5 pb-4 border-b border-border">
+              <h2 className="text-lg font-semibold truncate">
+                {channel.is_hashtag && !channel.name.startsWith('#')
+                  ? `#${channel.name}`
+                  : channel.name}
+              </h2>
+              {!channel.is_hashtag && !showKey ? (
+                <button
+                  className="text-xs font-mono text-muted-foreground hover:text-primary transition-colors"
+                  onClick={() => setShowKey(true)}
+                  title="Reveal channel key"
+                >
+                  Show Key
+                </button>
+              ) : (
+                <span
+                  className="text-xs font-mono text-muted-foreground cursor-pointer hover:text-primary transition-colors block truncate"
+                  role="button"
+                  tabIndex={0}
+                  onKeyDown={handleKeyboardActivate}
+                  onClick={() => {
+                    navigator.clipboard.writeText(channel.key);
+                    toast.success('Channel key copied!');
+                  }}
+                  title="Click to copy"
+                >
+                  {channel.key.toLowerCase()}
+                </span>
+              )}
+              <div className="flex items-center gap-2 mt-1.5">
+                <span className="text-[10px] uppercase tracking-wider px-1.5 py-0.5 rounded bg-muted text-muted-foreground font-medium">
+                  {channel.is_hashtag ? 'Hashtag' : 'Private Key'}
+                </span>
+                {channel.on_radio && (
+                  <span className="text-[10px] uppercase tracking-wider px-1.5 py-0.5 rounded bg-primary/10 text-primary font-medium">
+                    On Radio
+                  </span>
+                )}
+              </div>
+            </div>
+
+            {/* Favorite toggle */}
+            <div className="px-5 py-3 border-b border-border">
+              <button
+                type="button"
+                className="text-sm flex items-center gap-2 hover:text-primary transition-colors"
+                onClick={() => onToggleFavorite('channel', channel.key)}
+              >
+                {isFavorite(favorites, 'channel', channel.key) ? (
+                  <>
+                    <span className="text-favorite text-lg">&#9733;</span>
+                    <span>Remove from favorites</span>
+                  </>
+                ) : (
+                  <>
+                    <span className="text-muted-foreground text-lg">&#9734;</span>
+                    <span>Add to favorites</span>
+                  </>
+                )}
+              </button>
+            </div>
+
+            {/* Message Activity */}
+            {detail && detail.message_counts.all_time > 0 && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>Message Activity</SectionLabel>
+                <div className="grid grid-cols-2 gap-x-4 gap-y-1 text-sm">
+                  <InfoItem
+                    label="Last Hour"
+                    value={detail.message_counts.last_1h.toLocaleString()}
+                  />
+                  <InfoItem
+                    label="Last 24h"
+                    value={detail.message_counts.last_24h.toLocaleString()}
+                  />
+                  <InfoItem
+                    label="Last 48h"
+                    value={detail.message_counts.last_48h.toLocaleString()}
+                  />
+                  <InfoItem
+                    label="Last 7d"
+                    value={detail.message_counts.last_7d.toLocaleString()}
+                  />
+                  <InfoItem
+                    label="All Time"
+                    value={detail.message_counts.all_time.toLocaleString()}
+                  />
+                  <InfoItem
+                    label="Unique Senders"
+                    value={detail.unique_sender_count.toLocaleString()}
+                  />
+                </div>
+              </div>
+            )}
+
+            {/* First Message */}
+            {detail && detail.first_message_at && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>First Message</SectionLabel>
+                <p className="text-sm font-medium">{formatTime(detail.first_message_at)}</p>
+              </div>
+            )}
+
+            {/* Top Senders 24h */}
+            {detail && detail.top_senders_24h.length > 0 && (
+              <div className="px-5 py-3">
+                <SectionLabel>Top Senders (24h)</SectionLabel>
+                <div className="space-y-1">
+                  {detail.top_senders_24h.map((sender, idx) => (
+                    <div
+                      key={sender.sender_key ?? idx}
+                      className="flex justify-between items-center text-sm"
+                    >
+                      <span className="truncate">{sender.sender_name}</span>
+                      <span className="text-xs text-muted-foreground flex-shrink-0 ml-2">
+                        {sender.message_count.toLocaleString()} msg
+                        {sender.message_count !== 1 ? 's' : ''}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </div>
+        ) : (
+          <div className="flex-1 flex items-center justify-center text-muted-foreground">
+            Channel not found
+          </div>
+        )}
+      </SheetContent>
+    </Sheet>
+  );
+}
+
+function SectionLabel({ children }: { children: React.ReactNode }) {
+  return (
+    <h3 className="text-[10px] uppercase tracking-wider text-muted-foreground font-medium mb-1.5">
+      {children}
+    </h3>
+  );
+}
+
+function InfoItem({ label, value }: { label: string; value: string }) {
+  return (
+    <div>
+      <span className="text-muted-foreground text-xs">{label}</span>
+      <p className="font-medium text-sm leading-tight">{value}</p>
+    </div>
+  );
+}

frontend/src/components/ChatHeader.tsx

@@ -0,0 +1,195 @@
+import { useEffect, useState } from 'react';
+import { toast } from './ui/sonner';
+import { isFavorite } from '../utils/favorites';
+import { handleKeyboardActivate } from '../utils/a11y';
+import { ContactAvatar } from './ContactAvatar';
+import { ContactStatusInfo } from './ContactStatusInfo';
+import type { Channel, Contact, Conversation, Favorite, RadioConfig } from '../types';
+
+interface ChatHeaderProps {
+  conversation: Conversation;
+  contacts: Contact[];
+  channels: Channel[];
+  config: RadioConfig | null;
+  favorites: Favorite[];
+  onTrace: () => void;
+  onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
+  onDeleteChannel: (key: string) => void;
+  onDeleteContact: (publicKey: string) => void;
+  onOpenContactInfo?: (publicKey: string) => void;
+  onOpenChannelInfo?: (channelKey: string) => void;
+}
+
+export function ChatHeader({
+  conversation,
+  contacts,
+  channels,
+  config,
+  favorites,
+  onTrace,
+  onToggleFavorite,
+  onDeleteChannel,
+  onDeleteContact,
+  onOpenContactInfo,
+  onOpenChannelInfo,
+}: ChatHeaderProps) {
+  const [showKey, setShowKey] = useState(false);
+
+  useEffect(() => {
+    setShowKey(false);
+  }, [conversation.id]);
+
+  const isPrivateChannel =
+    conversation.type === 'channel' && !channels.find((c) => c.key === conversation.id)?.is_hashtag;
+
+  const titleClickable =
+    (conversation.type === 'contact' && onOpenContactInfo) ||
+    (conversation.type === 'channel' && onOpenChannelInfo);
+  return (
+    <header className="flex justify-between items-center px-4 py-2.5 border-b border-border gap-2">
+      <span className="flex flex-wrap items-baseline gap-x-2 min-w-0 flex-1">
+        {conversation.type === 'contact' && onOpenContactInfo && (
+          <span
+            className="flex-shrink-0 cursor-pointer"
+            role="button"
+            tabIndex={0}
+            onKeyDown={handleKeyboardActivate}
+            onClick={() => onOpenContactInfo(conversation.id)}
+            title="View contact info"
+            aria-label={`View info for ${conversation.name}`}
+          >
+            <ContactAvatar
+              name={conversation.name}
+              publicKey={conversation.id}
+              size={28}
+              contactType={contacts.find((c) => c.public_key === conversation.id)?.type}
+              clickable
+            />
+          </span>
+        )}
+        <h2
+          className={`flex-shrink-0 font-semibold text-base ${titleClickable ? 'cursor-pointer hover:text-primary transition-colors' : ''}`}
+          role={titleClickable ? 'button' : undefined}
+          tabIndex={titleClickable ? 0 : undefined}
+          aria-label={titleClickable ? `View info for ${conversation.name}` : undefined}
+          onKeyDown={titleClickable ? handleKeyboardActivate : undefined}
+          onClick={
+            titleClickable
+              ? () => {
+                  if (conversation.type === 'contact' && onOpenContactInfo) {
+                    onOpenContactInfo(conversation.id);
+                  } else if (conversation.type === 'channel' && onOpenChannelInfo) {
+                    onOpenChannelInfo(conversation.id);
+                  }
+                }
+              : undefined
+          }
+        >
+          {conversation.type === 'channel' &&
+          !conversation.name.startsWith('#') &&
+          channels.find((c) => c.key === conversation.id)?.is_hashtag
+            ? '#'
+            : ''}
+          {conversation.name}
+        </h2>
+        {isPrivateChannel && !showKey ? (
+          <button
+            className="font-normal text-[11px] text-muted-foreground font-mono hover:text-primary transition-colors"
+            onClick={(e) => {
+              e.stopPropagation();
+              setShowKey(true);
+            }}
+            title="Reveal channel key"
+          >
+            Show Key
+          </button>
+        ) : (
+          <span
+            className="font-normal text-[11px] text-muted-foreground font-mono truncate cursor-pointer hover:text-primary transition-colors"
+            role="button"
+            tabIndex={0}
+            onKeyDown={handleKeyboardActivate}
+            onClick={(e) => {
+              e.stopPropagation();
+              navigator.clipboard.writeText(conversation.id);
+              toast.success(
+                conversation.type === 'channel' ? 'Room key copied!' : 'Contact key copied!'
+              );
+            }}
+            title="Click to copy"
+            aria-label={conversation.type === 'channel' ? 'Copy channel key' : 'Copy contact key'}
+          >
+            {conversation.type === 'channel' ? conversation.id.toLowerCase() : conversation.id}
+          </span>
+        )}
+        {conversation.type === 'contact' &&
+          (() => {
+            const contact = contacts.find((c) => c.public_key === conversation.id);
+            if (!contact) return null;
+            return (
+              <ContactStatusInfo
+                contact={contact}
+                ourLat={config?.lat ?? null}
+                ourLon={config?.lon ?? null}
+              />
+            );
+          })()}
+      </span>
+      <div className="flex items-center gap-0.5 flex-shrink-0">
+        {/* Direct trace button (contacts only) */}
+        {conversation.type === 'contact' && (
+          <button
+            className="p-1.5 rounded hover:bg-accent text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={onTrace}
+            title="Direct Trace"
+            aria-label="Direct Trace"
+          >
+            <span aria-hidden="true">&#x1F6CE;</span>
+          </button>
+        )}
+        {/* Favorite button */}
+        {(conversation.type === 'channel' || conversation.type === 'contact') && (
+          <button
+            className="p-1.5 rounded hover:bg-accent text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={() =>
+              onToggleFavorite(conversation.type as 'channel' | 'contact', conversation.id)
+            }
+            title={
+              isFavorite(favorites, conversation.type as 'channel' | 'contact', conversation.id)
+                ? 'Remove from favorites'
+                : 'Add to favorites'
+            }
+            aria-label={
+              isFavorite(favorites, conversation.type as 'channel' | 'contact', conversation.id)
+                ? 'Remove from favorites'
+                : 'Add to favorites'
+            }
+          >
+            {isFavorite(favorites, conversation.type as 'channel' | 'contact', conversation.id) ? (
+              <span className="text-favorite">&#9733;</span>
+            ) : (
+              <span className="text-muted-foreground">&#9734;</span>
+            )}
+          </button>
+        )}
+        {/* Delete button */}
+        {!(conversation.type === 'channel' && conversation.name === 'Public') && (
+          <button
+            className="p-1.5 rounded hover:bg-destructive/10 text-muted-foreground hover:text-destructive text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={() => {
+              if (conversation.type === 'channel') {
+                onDeleteChannel(conversation.id);
+              } else {
+                onDeleteContact(conversation.id);
+              }
+            }}
+            title="Delete"
+            aria-label="Delete"
+          >
+            <span aria-hidden="true">&#128465;</span>
+          </button>
+        )}
+      </div>
+    </header>
+  );
+}

frontend/src/components/ContactAvatar.tsx

@@ -5,21 +5,29 @@ interface ContactAvatarProps {
   publicKey: string;
   size?: number;
   contactType?: number;
+  clickable?: boolean;
 }
 
-export function ContactAvatar({ name, publicKey, size = 28, contactType }: ContactAvatarProps) {
+export function ContactAvatar({
+  name,
+  publicKey,
+  size = 28,
+  contactType,
+  clickable,
+}: ContactAvatarProps) {
   const avatar = getContactAvatar(name, publicKey, contactType);
 
   return (
     <div
-      className="flex items-center justify-center rounded-full font-semibold flex-shrink-0 select-none ring-1 ring-white/5"
+      className={`flex items-center justify-center rounded-full font-semibold flex-shrink-0 select-none${clickable ? ' cursor-pointer' : ''}`}
       style={{
         backgroundColor: avatar.background,
         color: avatar.textColor,
         width: size,
         height: size,
-        fontSize: size * 0.42,
+        fontSize: size * 0.45,
       }}
+      aria-hidden="true"
     >
       {avatar.text}
     </div>

frontend/src/components/ContactInfoPane.tsx

@@ -0,0 +1,469 @@
+import { useEffect, useState } from 'react';
+import { api } from '../api';
+import { formatTime } from '../utils/messageParser';
+import {
+  isValidLocation,
+  calculateDistance,
+  formatDistance,
+  parsePathHops,
+} from '../utils/pathUtils';
+import { getMapFocusHash } from '../utils/urlHash';
+import { isFavorite } from '../utils/favorites';
+import { handleKeyboardActivate } from '../utils/a11y';
+import { ContactAvatar } from './ContactAvatar';
+import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from './ui/sheet';
+import { toast } from './ui/sonner';
+import type { Contact, ContactDetail, Favorite, RadioConfig } from '../types';
+
+const CONTACT_TYPE_LABELS: Record<number, string> = {
+  0: 'Unknown',
+  1: 'Client',
+  2: 'Repeater',
+  3: 'Room',
+  4: 'Sensor',
+};
+
+interface ContactInfoPaneProps {
+  contactKey: string | null;
+  fromChannel?: boolean;
+  onClose: () => void;
+  contacts: Contact[];
+  config: RadioConfig | null;
+  favorites: Favorite[];
+  onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
+  onNavigateToChannel?: (channelKey: string) => void;
+  blockedKeys?: string[];
+  blockedNames?: string[];
+  onToggleBlockedKey?: (key: string) => void;
+  onToggleBlockedName?: (name: string) => void;
+}
+
+export function ContactInfoPane({
+  contactKey,
+  fromChannel = false,
+  onClose,
+  contacts,
+  config,
+  favorites,
+  onToggleFavorite,
+  onNavigateToChannel,
+  blockedKeys = [],
+  blockedNames = [],
+  onToggleBlockedKey,
+  onToggleBlockedName,
+}: ContactInfoPaneProps) {
+  const isNameOnly = contactKey?.startsWith('name:') ?? false;
+  const nameOnlyValue = isNameOnly && contactKey ? contactKey.slice(5) : null;
+
+  const [detail, setDetail] = useState<ContactDetail | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  // Get live contact data from contacts array (real-time via WS)
+  const liveContact =
+    contactKey && !isNameOnly ? (contacts.find((c) => c.public_key === contactKey) ?? null) : null;
+
+  useEffect(() => {
+    if (!contactKey || isNameOnly) {
+      setDetail(null);
+      return;
+    }
+
+    let cancelled = false;
+    setLoading(true);
+    api
+      .getContactDetail(contactKey)
+      .then((data) => {
+        if (!cancelled) setDetail(data);
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          console.error('Failed to fetch contact detail:', err);
+          toast.error('Failed to load contact info');
+        }
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [contactKey, isNameOnly]);
+
+  // Use live contact data where available, fall back to detail snapshot
+  const contact = liveContact ?? detail?.contact ?? null;
+
+  const distFromUs =
+    contact &&
+    config &&
+    isValidLocation(config.lat, config.lon) &&
+    isValidLocation(contact.lat, contact.lon)
+      ? calculateDistance(config.lat, config.lon, contact.lat, contact.lon)
+      : null;
+
+  return (
+    <Sheet open={contactKey !== null} onOpenChange={(open) => !open && onClose()}>
+      <SheetContent side="right" className="w-full sm:max-w-[400px] p-0 flex flex-col">
+        <SheetHeader className="sr-only">
+          <SheetTitle>Contact Info</SheetTitle>
+          <SheetDescription>Contact details and actions</SheetDescription>
+        </SheetHeader>
+
+        {isNameOnly && nameOnlyValue ? (
+          <div className="flex-1 overflow-y-auto">
+            {/* Name-only header */}
+            <div className="px-5 pt-5 pb-4 border-b border-border">
+              <div className="flex items-start gap-4">
+                <ContactAvatar name={nameOnlyValue} publicKey={`name:${nameOnlyValue}`} size={56} />
+                <div className="flex-1 min-w-0">
+                  <h2 className="text-lg font-semibold truncate">{nameOnlyValue}</h2>
+                  <p className="text-xs text-muted-foreground mt-1">
+                    We have not heard an advertisement associated with this name, so we cannot
+                    identify their key.
+                  </p>
+                </div>
+              </div>
+            </div>
+
+            {fromChannel && <ChannelAttributionWarning />}
+
+            {/* Block by name toggle */}
+            {onToggleBlockedName && (
+              <div className="px-5 py-3 border-b border-border">
+                <button
+                  type="button"
+                  className="text-sm flex items-center gap-2 hover:text-primary transition-colors"
+                  onClick={() => onToggleBlockedName(nameOnlyValue)}
+                >
+                  {blockedNames.includes(nameOnlyValue) ? (
+                    <>
+                      <span className="text-destructive text-lg">&#x2718;</span>
+                      <span>Unblock this name</span>
+                    </>
+                  ) : (
+                    <>
+                      <span className="text-muted-foreground text-lg">&#x2718;</span>
+                      <span>Block this name</span>
+                    </>
+                  )}
+                </button>
+              </div>
+            )}
+          </div>
+        ) : loading && !detail ? (
+          <div className="flex-1 flex items-center justify-center text-muted-foreground">
+            Loading...
+          </div>
+        ) : contact ? (
+          <div className="flex-1 overflow-y-auto">
+            {/* Header */}
+            <div className="px-5 pt-5 pb-4 border-b border-border">
+              <div className="flex items-start gap-4">
+                <ContactAvatar
+                  name={contact.name}
+                  publicKey={contact.public_key}
+                  size={56}
+                  contactType={contact.type}
+                />
+                <div className="flex-1 min-w-0">
+                  <h2 className="text-lg font-semibold truncate">
+                    {contact.name || contact.public_key.slice(0, 12)}
+                  </h2>
+                  <span
+                    className="text-xs font-mono text-muted-foreground cursor-pointer hover:text-primary transition-colors block truncate"
+                    role="button"
+                    tabIndex={0}
+                    onKeyDown={handleKeyboardActivate}
+                    onClick={() => {
+                      navigator.clipboard.writeText(contact.public_key);
+                      toast.success('Public key copied!');
+                    }}
+                    title="Click to copy"
+                  >
+                    {contact.public_key}
+                  </span>
+                  <div className="flex items-center gap-2 mt-1.5">
+                    <span className="text-[10px] uppercase tracking-wider px-1.5 py-0.5 rounded bg-muted text-muted-foreground font-medium">
+                      {CONTACT_TYPE_LABELS[contact.type] ?? 'Unknown'}
+                    </span>
+                    {contact.on_radio && (
+                      <span className="text-[10px] uppercase tracking-wider px-1.5 py-0.5 rounded bg-primary/10 text-primary font-medium">
+                        On Radio
+                      </span>
+                    )}
+                  </div>
+                </div>
+              </div>
+            </div>
+
+            {fromChannel && <ChannelAttributionWarning />}
+
+            {/* Info grid */}
+            <div className="px-5 py-3 border-b border-border">
+              <div className="grid grid-cols-2 gap-x-4 gap-y-2 text-sm">
+                {contact.last_seen && (
+                  <InfoItem label="Last Seen" value={formatTime(contact.last_seen)} />
+                )}
+                {contact.first_seen && (
+                  <InfoItem label="First Heard" value={formatTime(contact.first_seen)} />
+                )}
+                {contact.last_contacted && (
+                  <InfoItem label="Last Contacted" value={formatTime(contact.last_contacted)} />
+                )}
+                {distFromUs !== null && (
+                  <InfoItem label="Distance" value={formatDistance(distFromUs)} />
+                )}
+                {contact.last_path_len >= 0 && (
+                  <InfoItem
+                    label="Hops"
+                    value={
+                      contact.last_path_len === 0
+                        ? 'Direct'
+                        : `${contact.last_path_len} hop${contact.last_path_len > 1 ? 's' : ''}`
+                    }
+                  />
+                )}
+                {contact.last_path_len === -1 && <InfoItem label="Routing" value="Flood" />}
+              </div>
+            </div>
+
+            {/* GPS */}
+            {isValidLocation(contact.lat, contact.lon) && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>Location</SectionLabel>
+                <span
+                  className="text-sm font-mono cursor-pointer hover:text-primary hover:underline transition-colors"
+                  role="button"
+                  tabIndex={0}
+                  onKeyDown={handleKeyboardActivate}
+                  onClick={() => {
+                    const url =
+                      window.location.origin +
+                      window.location.pathname +
+                      getMapFocusHash(contact.public_key);
+                    window.open(url, '_blank');
+                  }}
+                  title="View on map"
+                >
+                  {contact.lat!.toFixed(5)}, {contact.lon!.toFixed(5)}
+                </span>
+              </div>
+            )}
+
+            {/* Favorite toggle */}
+            <div className="px-5 py-3 border-b border-border">
+              <button
+                type="button"
+                className="text-sm flex items-center gap-2 hover:text-primary transition-colors"
+                onClick={() => onToggleFavorite('contact', contact.public_key)}
+              >
+                {isFavorite(favorites, 'contact', contact.public_key) ? (
+                  <>
+                    <span className="text-favorite text-lg">&#9733;</span>
+                    <span>Remove from favorites</span>
+                  </>
+                ) : (
+                  <>
+                    <span className="text-muted-foreground text-lg">&#9734;</span>
+                    <span>Add to favorites</span>
+                  </>
+                )}
+              </button>
+            </div>
+
+            {/* Block toggles */}
+            {(onToggleBlockedKey || onToggleBlockedName) && (
+              <div className="px-5 py-3 border-b border-border space-y-2">
+                {onToggleBlockedKey && (
+                  <button
+                    type="button"
+                    className="text-sm flex items-center gap-2 hover:text-primary transition-colors"
+                    onClick={() => onToggleBlockedKey(contact.public_key)}
+                  >
+                    {blockedKeys.includes(contact.public_key.toLowerCase()) ? (
+                      <>
+                        <span className="text-destructive text-lg">&#x2718;</span>
+                        <span>Unblock this key</span>
+                      </>
+                    ) : (
+                      <>
+                        <span className="text-muted-foreground text-lg">&#x2718;</span>
+                        <span>Block this key</span>
+                      </>
+                    )}
+                  </button>
+                )}
+                {onToggleBlockedName && contact.name && (
+                  <button
+                    type="button"
+                    className="text-sm flex items-center gap-2 hover:text-primary transition-colors"
+                    onClick={() => onToggleBlockedName(contact.name!)}
+                  >
+                    {blockedNames.includes(contact.name) ? (
+                      <>
+                        <span className="text-destructive text-lg">&#x2718;</span>
+                        <span>Unblock name &ldquo;{contact.name}&rdquo;</span>
+                      </>
+                    ) : (
+                      <>
+                        <span className="text-muted-foreground text-lg">&#x2718;</span>
+                        <span>Block name &ldquo;{contact.name}&rdquo;</span>
+                      </>
+                    )}
+                  </button>
+                )}
+              </div>
+            )}
+
+            {/* AKA (Name History) - only show if more than one name */}
+            {detail && detail.name_history.length > 1 && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>Also Known As</SectionLabel>
+                <div className="space-y-1">
+                  {detail.name_history.map((h) => (
+                    <div key={h.name} className="flex justify-between items-center text-sm">
+                      <span className="font-medium truncate">{h.name}</span>
+                      <span className="text-xs text-muted-foreground flex-shrink-0 ml-2">
+                        {formatTime(h.first_seen)} &ndash; {formatTime(h.last_seen)}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* Message Stats */}
+            {detail && (detail.dm_message_count > 0 || detail.channel_message_count > 0) && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>Messages</SectionLabel>
+                <div className="grid grid-cols-2 gap-x-4 gap-y-1 text-sm">
+                  {detail.dm_message_count > 0 && (
+                    <InfoItem
+                      label="Direct Messages"
+                      value={detail.dm_message_count.toLocaleString()}
+                    />
+                  )}
+                  {detail.channel_message_count > 0 && (
+                    <InfoItem
+                      label="Channel Messages"
+                      value={detail.channel_message_count.toLocaleString()}
+                    />
+                  )}
+                </div>
+              </div>
+            )}
+
+            {/* Most Active Rooms */}
+            {detail && detail.most_active_rooms.length > 0 && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>Most Active Rooms</SectionLabel>
+                <div className="space-y-1">
+                  {detail.most_active_rooms.map((room) => (
+                    <div
+                      key={room.channel_key}
+                      className="flex justify-between items-center text-sm"
+                    >
+                      <span
+                        className={
+                          onNavigateToChannel
+                            ? 'cursor-pointer hover:text-primary transition-colors truncate'
+                            : 'truncate'
+                        }
+                        role={onNavigateToChannel ? 'button' : undefined}
+                        tabIndex={onNavigateToChannel ? 0 : undefined}
+                        onKeyDown={onNavigateToChannel ? handleKeyboardActivate : undefined}
+                        onClick={() => onNavigateToChannel?.(room.channel_key)}
+                      >
+                        {room.channel_name.startsWith('#') || room.channel_name === 'Public'
+                          ? room.channel_name
+                          : `#${room.channel_name}`}
+                      </span>
+                      <span className="text-xs text-muted-foreground flex-shrink-0 ml-2">
+                        {room.message_count.toLocaleString()} msg
+                        {room.message_count !== 1 ? 's' : ''}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* Nearest Repeaters */}
+            {detail && detail.nearest_repeaters.length > 0 && (
+              <div className="px-5 py-3 border-b border-border">
+                <SectionLabel>Nearest Repeaters</SectionLabel>
+                <div className="space-y-1">
+                  {detail.nearest_repeaters.map((r) => (
+                    <div key={r.public_key} className="flex justify-between items-center text-sm">
+                      <span className="truncate">{r.name || r.public_key.slice(0, 12)}</span>
+                      <span className="text-xs text-muted-foreground flex-shrink-0 ml-2">
+                        {r.path_len === 0
+                          ? 'direct'
+                          : `${r.path_len} hop${r.path_len > 1 ? 's' : ''}`}{' '}
+                        · {r.heard_count}x
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* Advert Paths */}
+            {detail && detail.advert_paths.length > 0 && (
+              <div className="px-5 py-3">
+                <SectionLabel>Recent Advert Paths</SectionLabel>
+                <div className="space-y-1">
+                  {detail.advert_paths.map((p) => (
+                    <div
+                      key={p.path + p.first_seen}
+                      className="flex justify-between items-center text-sm"
+                    >
+                      <span className="font-mono text-xs truncate">
+                        {p.path ? parsePathHops(p.path, p.path_len).join(' → ') : '(direct)'}
+                      </span>
+                      <span className="text-xs text-muted-foreground flex-shrink-0 ml-2">
+                        {p.heard_count}x · {formatTime(p.last_seen)}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </div>
+        ) : (
+          <div className="flex-1 flex items-center justify-center text-muted-foreground">
+            Contact not found
+          </div>
+        )}
+      </SheetContent>
+    </Sheet>
+  );
+}
+
+function SectionLabel({ children }: { children: React.ReactNode }) {
+  return (
+    <h3 className="text-[10px] uppercase tracking-wider text-muted-foreground font-medium mb-1.5">
+      {children}
+    </h3>
+  );
+}
+
+function ChannelAttributionWarning() {
+  return (
+    <div className="mx-5 my-3 px-3 py-2 rounded-md bg-yellow-500/10 border border-yellow-500/20">
+      <p className="text-xs text-yellow-600 dark:text-yellow-400">
+        Channel sender identity is based on best-effort name matching. Different nodes using the
+        same name will be attributed to the same contact. Message counts and key-based statistics
+        may be inaccurate.
+      </p>
+    </div>
+  );
+}
+
+function InfoItem({ label, value }: { label: string; value: string }) {
+  return (
+    <div>
+      <span className="text-muted-foreground text-xs">{label}</span>
+      <p className="font-medium text-sm leading-tight">{value}</p>
+    </div>
+  );
+}

frontend/src/components/ContactStatusInfo.tsx

@@ -0,0 +1,118 @@
+import type { ReactNode } from 'react';
+import { toast } from './ui/sonner';
+import { api } from '../api';
+import { formatTime } from '../utils/messageParser';
+import { isValidLocation, calculateDistance, formatDistance } from '../utils/pathUtils';
+import { getMapFocusHash } from '../utils/urlHash';
+import { handleKeyboardActivate } from '../utils/a11y';
+import type { Contact } from '../types';
+
+interface ContactStatusInfoProps {
+  contact: Contact;
+  ourLat: number | null;
+  ourLon: number | null;
+}
+
+/**
+ * Renders the "(Last heard: ..., N hops, lat, lon (dist))" status line
+ * shared between ChatHeader and RepeaterDashboard.
+ */
+export function ContactStatusInfo({ contact, ourLat, ourLon }: ContactStatusInfoProps) {
+  const parts: ReactNode[] = [];
+
+  if (contact.last_seen) {
+    parts.push(`Last heard: ${formatTime(contact.last_seen)}`);
+  }
+
+  if (contact.last_path_len === -1) {
+    parts.push('flood');
+  } else if (contact.last_path_len === 0) {
+    parts.push(
+      <span
+        key="path"
+        className="cursor-pointer hover:text-primary hover:underline"
+        role="button"
+        tabIndex={0}
+        onKeyDown={handleKeyboardActivate}
+        onClick={(e) => {
+          e.stopPropagation();
+          if (window.confirm('Reset path to flood?')) {
+            api.resetContactPath(contact.public_key).then(
+              () => toast.success('Path reset to flood'),
+              () => toast.error('Failed to reset path')
+            );
+          }
+        }}
+        title="Click to reset path to flood"
+      >
+        direct
+      </span>
+    );
+  } else if (contact.last_path_len > 0) {
+    parts.push(
+      <span
+        key="path"
+        className="cursor-pointer hover:text-primary hover:underline"
+        role="button"
+        tabIndex={0}
+        onKeyDown={handleKeyboardActivate}
+        onClick={(e) => {
+          e.stopPropagation();
+          if (window.confirm('Reset path to flood?')) {
+            api.resetContactPath(contact.public_key).then(
+              () => toast.success('Path reset to flood'),
+              () => toast.error('Failed to reset path')
+            );
+          }
+        }}
+        title="Click to reset path to flood"
+      >
+        {contact.last_path_len} hop{contact.last_path_len > 1 ? 's' : ''}
+      </span>
+    );
+  }
+
+  if (isValidLocation(contact.lat, contact.lon)) {
+    const distFromUs =
+      ourLat != null && ourLon != null && isValidLocation(ourLat, ourLon)
+        ? calculateDistance(ourLat, ourLon, contact.lat, contact.lon)
+        : null;
+    parts.push(
+      <span key="coords">
+        <span
+          className="font-mono cursor-pointer hover:text-primary hover:underline"
+          role="button"
+          tabIndex={0}
+          onKeyDown={handleKeyboardActivate}
+          onClick={(e) => {
+            e.stopPropagation();
+            const url =
+              window.location.origin +
+              window.location.pathname +
+              getMapFocusHash(contact.public_key);
+            window.open(url, '_blank');
+          }}
+          title="View on map"
+        >
+          {contact.lat!.toFixed(3)}, {contact.lon!.toFixed(3)}
+        </span>
+        {distFromUs !== null && ` (${formatDistance(distFromUs)})`}
+      </span>
+    );
+  }
+
+  if (parts.length === 0) return null;
+
+  return (
+    <span className="font-normal text-sm text-muted-foreground flex-shrink-0">
+      (
+      {parts.map((part, i) => (
+        <span key={i}>
+          {i > 0 && ', '}
+          {part}
+        </span>
+      ))}
+      )
+    </span>
+  );
+}

frontend/src/components/CrackerPanel.tsx

@@ -1,46 +1,13 @@
+import '../utils/meshcoreDecoderPatch';
 import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 import { GroupTextCracker, type ProgressReport } from 'meshcore-hashtag-cracker';
 import NoSleep from 'nosleep.js';
 import type { RawPacket, Channel } from '../types';
 import { api } from '../api';
+import { extractRawPacketPayload } from '../utils/rawPacketPayload';
 import { toast } from './ui/sonner';
 import { cn } from '@/lib/utils';
 
-/**
- * Extract the payload from a raw packet hex string, skipping header and path.
- * Returns the payload as a hex string, or null if malformed.
- */
-function extractPayload(packetHex: string): string | null {
-  if (packetHex.length < 4) return null; // Need at least 2 bytes
-
-  try {
-    const header = parseInt(packetHex.slice(0, 2), 16);
-    const routeType = header & 0x03;
-    let offset = 2; // 1 byte = 2 hex chars
-
-    // Skip transport codes if present (TRANSPORT_FLOOD=0, TRANSPORT_DIRECT=3)
-    if (routeType === 0x00 || routeType === 0x03) {
-      if (packetHex.length < offset + 8) return null; // Need 4 more bytes
-      offset += 8; // 4 bytes = 8 hex chars
-    }
-
-    // Get path length
-    if (packetHex.length < offset + 2) return null;
-    const pathLength = parseInt(packetHex.slice(offset, offset + 2), 16);
-    offset += 2;
-
-    // Skip path data
-    const pathBytes = pathLength * 2; // hex chars
-    if (packetHex.length < offset + pathBytes) return null;
-    offset += pathBytes;
-
-    // Rest is payload
-    return packetHex.slice(offset);
-  } catch {
-    return null;
-  }
-}
-
 interface CrackedRoom {
   roomName: string;
   key: string;
@@ -98,6 +65,7 @@ export function CrackerPanel({
   const twoWordModeRef = useRef(false);
   const undecryptedIdsRef = useRef<Set<number>>(new Set());
   const seenPayloadsRef = useRef<Set<string>>(new Set());
+  const existingChannelKeysRef = useRef<Set<string>>(new Set());
 
   // Initialize cracker and NoSleep
   useEffect(() => {
@@ -155,6 +123,10 @@ export function CrackerPanel({
     [channels]
   );
 
+  useEffect(() => {
+    existingChannelKeysRef.current = existingChannelKeys;
+  }, [existingChannelKeys]);
+
   // Filter packets to only undecrypted GROUP_TEXT
   const undecryptedGroupText = packets.filter(
     (p) => p.payload_type === 'GROUP_TEXT' && !p.decrypted
@@ -172,7 +144,7 @@ export function CrackerPanel({
       for (const packet of undecryptedGroupText) {
         if (!newQueue.has(packet.id)) {
           // Extract payload and check for duplicates
-          const payload = extractPayload(packet.data);
+          const payload = extractRawPacketPayload(packet.data);
           if (payload && seenPayloadsRef.current.has(payload)) {
             // Skip - we already have a packet with this payload queued
             newSkipped++;
@@ -365,7 +337,7 @@ export function CrackerPanel({
 
         // Auto-add channel if not already exists
         const keyUpper = result.key.toUpperCase();
-        if (!existingChannelKeys.has(keyUpper)) {
+        if (!existingChannelKeysRef.current.has(keyUpper)) {
           try {
             const channelName = '#' + result.roomName;
             await onChannelCreate(channelName, result.key);
@@ -426,7 +398,7 @@ export function CrackerPanel({
     if (isRunningRef.current) {
       setTimeout(() => processNext(), 100);
     }
-  }, [existingChannelKeys, onChannelCreate]);
+  }, [onChannelCreate]);
 
   // Start/stop handlers
   const handleStart = () => {
@@ -455,8 +427,11 @@ export function CrackerPanel({
     <div className="flex flex-col h-full p-3 gap-3 bg-background border-t border-border overflow-auto">
       <div className="flex items-center gap-3 flex-wrap">
         <div className="flex items-center gap-2">
-          <label className="text-sm text-muted-foreground">Max Length:</label>
+          <label htmlFor="cracker-max-length" className="text-sm text-muted-foreground">
+            Max Length:
+          </label>
           <input
+            id="cracker-max-length"
             type="number"
             min={1}
             max={10}
@@ -518,7 +493,7 @@ export function CrackerPanel({
         onClick={isRunning ? handleStop : handleStart}
         disabled={!wordlistLoaded || gpuAvailable === false}
         className={cn(
-          'w-48 px-4 py-1.5 rounded text-sm font-medium',
+          'w-48 px-4 py-1.5 rounded text-sm font-medium focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
           isRunning
             ? 'bg-destructive text-destructive-foreground hover:bg-destructive/90'
             : 'bg-primary text-primary-foreground hover:bg-primary/90',
@@ -540,7 +515,7 @@ export function CrackerPanel({
           Pending: <span className="text-foreground font-medium">{pendingCount}</span>
         </span>
         <span className="text-muted-foreground">
-          Cracked: <span className="text-green-500 font-medium">{crackedCount}</span>
+          Cracked: <span className="text-success font-medium">{crackedCount}</span>
         </span>
         <span className="text-muted-foreground">
           Failed: <span className="text-destructive font-medium">{failedCount}</span>
@@ -578,7 +553,14 @@ export function CrackerPanel({
                 : `${Math.round(progress.etaSeconds / 60)}m`}
             </span>
           </div>
-          <div className="h-2 bg-muted rounded overflow-hidden">
+          <div
+            className="h-2 bg-muted rounded overflow-hidden"
+            role="progressbar"
+            aria-valuenow={Math.round(progress.percent)}
+            aria-valuemin={0}
+            aria-valuemax={100}
+            aria-label="Cracking progress"
+          >
             <div
               className="h-full bg-primary transition-all duration-200"
               style={{ width: `${progress.percent}%` }}
@@ -589,12 +571,14 @@ export function CrackerPanel({
 
       {/* GPU status */}
       {gpuAvailable === false && (
-        <div className="text-sm text-destructive">
+        <div className="text-sm text-destructive" role="alert">
           WebGPU not available. Cracking requires Chrome 113+ or Edge 113+.
         </div>
       )}
       {!wordlistLoaded && gpuAvailable !== false && (
-        <div className="text-sm text-muted-foreground">Loading wordlist...</div>
+        <div className="text-sm text-muted-foreground" role="status">
+          Loading wordlist...
+        </div>
       )}
 
       {/* Cracked rooms list */}
@@ -605,9 +589,9 @@ export function CrackerPanel({
             {crackedRooms.map((room, i) => (
               <div
                 key={i}
-                className="text-sm bg-green-950/30 border border-green-900/50 rounded px-2 py-1"
+                className="text-sm bg-success/10 border border-success/20 rounded px-2 py-1"
               >
-                <span className="text-green-400 font-medium">#{room.roomName}</span>
+                <span className="text-success font-medium">#{room.roomName}</span>
                 <span className="text-muted-foreground ml-2 text-xs">
                   "{room.message.slice(0, 50)}
                   {room.message.length > 50 ? '...' : ''}"

frontend/src/components/MapView.tsx

@@ -94,13 +94,16 @@ function MapBoundsHandler({
 }
 
 export function MapView({ contacts, focusedKey }: MapViewProps) {
-  // Filter to contacts with GPS coordinates, heard within the last 7 days
+  // Filter to contacts with GPS coordinates, heard within the last 7 days.
+  // Always include the focused contact so "view on map" links work for older nodes.
   const mappableContacts = useMemo(() => {
     const sevenDaysAgo = Date.now() / 1000 - 7 * 24 * 60 * 60;
     return contacts.filter(
-      (c) => isValidLocation(c.lat, c.lon) && c.last_seen != null && c.last_seen > sevenDaysAgo
+      (c) =>
+        isValidLocation(c.lat, c.lon) &&
+        (c.public_key === focusedKey || (c.last_seen != null && c.last_seen > sevenDaysAgo))
     );
-  }, [contacts]);
+  }, [contacts, focusedKey]);
 
   // Find the focused contact by key
   const focusedContact = useMemo(() => {
@@ -137,22 +140,27 @@ export function MapView({ contacts, focusedKey }: MapViewProps) {
         </span>
         <div className="flex items-center gap-3">
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#22c55e]" /> &lt;1h
+            <span className="w-3 h-3 rounded-full bg-[#22c55e]" aria-hidden="true" /> &lt;1h
           </span>
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#4ade80]" /> &lt;1d
+            <span className="w-3 h-3 rounded-full bg-[#4ade80]" aria-hidden="true" /> &lt;1d
           </span>
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#a3e635]" /> &lt;3d
+            <span className="w-3 h-3 rounded-full bg-[#a3e635]" aria-hidden="true" /> &lt;3d
           </span>
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#9ca3af]" /> older
+            <span className="w-3 h-3 rounded-full bg-[#9ca3af]" aria-hidden="true" /> older
           </span>
         </div>
       </div>
 
       {/* Map - z-index constrained to stay below modals/sheets */}
-      <div className="flex-1 relative" style={{ zIndex: 0 }}>
+      <div
+        className="flex-1 relative"
+        style={{ zIndex: 0 }}
+        role="img"
+        aria-label="Map showing mesh node locations"
+      >
         <MapContainer
           center={[20, 0]}
           zoom={2}
@@ -186,7 +194,11 @@ export function MapView({ contacts, focusedKey }: MapViewProps) {
                 <Popup>
                   <div className="text-sm">
                     <div className="font-medium flex items-center gap-1">
-                      {isRepeater && <span title="Repeater">🛜</span>}
+                      {isRepeater && (
+                        <span title="Repeater" aria-hidden="true">
+                          🛜
+                        </span>
+                      )}
                       {displayName}
                     </div>
                     <div className="text-xs text-gray-500 mt-1">

frontend/src/components/MessageInput.tsx

@@ -8,19 +8,23 @@ import {
   type FormEvent,
   type KeyboardEvent,
 } from 'react';
-import { motion, AnimatePresence } from 'framer-motion';
-import { Send, Lock } from 'lucide-react';
+import { Input } from './ui/input';
+import { Button } from './ui/button';
 import { toast } from './ui/sonner';
 import { cn } from '@/lib/utils';
 
 // MeshCore message size limits (empirically determined from LoRa packet constraints)
-const DM_HARD_LIMIT = 156;
-const DM_WARNING_THRESHOLD = 140;
-const CHANNEL_HARD_LIMIT = 156;
-const CHANNEL_WARNING_THRESHOLD = 120;
-const CHANNEL_DANGER_BUFFER = 8;
+// Direct delivery allows ~156 bytes; multi-hop requires buffer for path growth.
+// Channels include "sender: " prefix in the encrypted payload.
+// All limits are in bytes (UTF-8), not characters, since LoRa packets are byte-constrained.
+const DM_HARD_LIMIT = 156; // Max bytes for direct delivery
+const DM_WARNING_THRESHOLD = 140; // Conservative for multi-hop
+const CHANNEL_HARD_LIMIT = 156; // Base byte limit before sender overhead
+const CHANNEL_WARNING_THRESHOLD = 120; // Conservative for multi-hop
+const CHANNEL_DANGER_BUFFER = 8; // Red zone starts this many bytes before hard limit
 
 const textEncoder = new TextEncoder();
+/** Get UTF-8 byte length of a string (LoRa packets are byte-constrained, not character-constrained). */
 function byteLen(s: string): number {
   return textEncoder.encode(s).length;
 }
@@ -29,8 +33,9 @@ interface MessageInputProps {
   onSend: (text: string) => Promise<void>;
   disabled: boolean;
   placeholder?: string;
-  isRepeaterMode?: boolean;
+  /** Conversation type for character limit calculation */
   conversationType?: 'contact' | 'channel' | 'raw';
+  /** Sender name (radio name) for channel message limit calculation */
   senderName?: string;
 }
 
@@ -41,7 +46,7 @@ export interface MessageInputHandle {
 }
 
 export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(function MessageInput(
-  { onSend, disabled, placeholder, isRepeaterMode, conversationType, senderName },
+  { onSend, disabled, placeholder, conversationType, senderName },
   ref
 ) {
   const [text, setText] = useState('');
@@ -51,18 +56,21 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
   useImperativeHandle(ref, () => ({
     appendText: (appendedText: string) => {
       setText((prev) => prev + appendedText);
+      // Focus the input after appending
       inputRef.current?.focus();
     },
   }));
 
+  // Calculate character limits based on conversation type
   const limits = useMemo(() => {
     if (conversationType === 'contact') {
       return {
         warningAt: DM_WARNING_THRESHOLD,
-        dangerAt: DM_HARD_LIMIT,
+        dangerAt: DM_HARD_LIMIT, // Same as hard limit for DMs (no intermediate red zone)
         hardLimit: DM_HARD_LIMIT,
       };
     } else if (conversationType === 'channel') {
+      // Channel hard limit = 156 bytes - senderName bytes - 2 (for ": " separator)
       const nameByteLen = senderName ? byteLen(senderName) : 10;
       const hardLimit = Math.max(1, CHANNEL_HARD_LIMIT - nameByteLen - 2);
       return {
@@ -71,11 +79,13 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
         hardLimit,
       };
     }
-    return null;
+    return null; // Raw/other - no limits
   }, [conversationType, senderName]);
 
+  // UTF-8 byte length of the current text (LoRa packets are byte-constrained)
   const textByteLen = useMemo(() => byteLen(text), [text]);
 
+  // Determine current limit state
   const { limitState, warningMessage } = useMemo((): {
     limitState: LimitState;
     warningMessage: string | null;
@@ -83,13 +93,13 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
     if (!limits) return { limitState: 'normal', warningMessage: null };
 
     if (textByteLen >= limits.hardLimit) {
-      return { limitState: 'error', warningMessage: 'likely truncated' };
+      return { limitState: 'error', warningMessage: 'likely truncated by radio' };
     }
     if (textByteLen >= limits.dangerAt) {
-      return { limitState: 'danger', warningMessage: 'multi-hop risk' };
+      return { limitState: 'danger', warningMessage: 'may impact multi-repeater hop delivery' };
     }
     if (textByteLen >= limits.warningAt) {
-      return { limitState: 'warning', warningMessage: 'multi-hop risk' };
+      return { limitState: 'warning', warningMessage: 'may impact multi-repeater hop delivery' };
     }
     return { limitState: 'normal', warningMessage: null };
   }, [textByteLen, limits]);
@@ -100,42 +110,25 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
     async (e: FormEvent) => {
       e.preventDefault();
       const trimmed = text.trim();
+      if (!trimmed || sending || disabled) return;
 
-      if (isRepeaterMode) {
-        if (sending || disabled) return;
-        setSending(true);
-        try {
-          await onSend(trimmed);
-          setText('');
-        } catch (err) {
-          console.error('Failed to request telemetry:', err);
-          toast.error('Failed to request telemetry', {
-            description: err instanceof Error ? err.message : 'Check radio connection',
-          });
-          return;
-        } finally {
-          setSending(false);
-        }
-        setTimeout(() => inputRef.current?.focus(), 0);
-      } else {
-        if (!trimmed || sending || disabled) return;
-        setSending(true);
-        try {
-          await onSend(trimmed);
-          setText('');
-        } catch (err) {
-          console.error('Failed to send message:', err);
-          toast.error('Failed to send message', {
-            description: err instanceof Error ? err.message : 'Check radio connection',
-          });
-          return;
-        } finally {
-          setSending(false);
-        }
-        setTimeout(() => inputRef.current?.focus(), 0);
+      setSending(true);
+      try {
+        await onSend(trimmed);
+        setText('');
+      } catch (err) {
+        console.error('Failed to send message:', err);
+        toast.error('Failed to send message', {
+          description: err instanceof Error ? err.message : 'Check radio connection',
+        });
+        return;
+      } finally {
+        setSending(false);
       }
+      // Refocus after React re-enables the input
+      setTimeout(() => inputRef.current?.focus(), 0);
     },
-    [text, sending, disabled, onSend, isRepeaterMode]
+    [text, sending, disabled, onSend]
   );
 
   const handleKeyDown = useCallback(
@@ -148,111 +141,93 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
     [handleSubmit]
   );
 
-  const canSubmit = isRepeaterMode ? true : text.trim().length > 0;
-  const showCharCounter = !isRepeaterMode && limits !== null && textByteLen > 0;
+  const canSubmit = text.trim().length > 0;
+
+  // Show counter for messages (not raw).
+  // Desktop: always visible. Mobile: only show count after 100 characters.
+  const showCharCounter = limits !== null;
+  const showMobileCounterValue = text.length > 100;
 
   return (
-    <div className="px-4 py-3 border-t border-border/50">
-      <form onSubmit={handleSubmit} className="flex flex-col gap-1.5">
-        <div className="flex items-center gap-2">
-          {/* Input container with glow */}
-          <div
-            className={cn(
-              'flex-1 relative rounded-xl border transition-all duration-200',
-              disabled
-                ? 'bg-muted/30 border-border/30'
-                : text.length > 0
-                  ? 'bg-secondary/40 border-primary/25 shadow-glow-amber-sm'
-                  : 'bg-secondary/30 border-border/50 focus-within:border-primary/30 focus-within:shadow-glow-amber-sm'
-            )}
-          >
-            {isRepeaterMode && (
-              <Lock className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground/40" />
-            )}
-            <input
-              ref={inputRef}
-              type={isRepeaterMode ? 'password' : 'text'}
-              autoComplete={isRepeaterMode ? 'off' : undefined}
-              value={text}
-              onChange={(e) => setText(e.target.value)}
-              onKeyDown={handleKeyDown}
-              placeholder={
-                placeholder ||
-                (isRepeaterMode ? 'Enter password for admin login...' : 'Type a message...')
-              }
-              disabled={disabled || sending}
+    <form
+      className="px-4 py-2.5 border-t border-border flex flex-col gap-1"
+      onSubmit={handleSubmit}
+      autoComplete="off"
+    >
+      <div className="flex gap-2">
+        <Input
+          ref={inputRef}
+          type="text"
+          autoComplete="off"
+          name="chat-message-input"
+          aria-label={placeholder || 'Type a message'}
+          data-lpignore="true"
+          data-1p-ignore="true"
+          data-bwignore="true"
+          value={text}
+          onChange={(e) => setText(e.target.value)}
+          onKeyDown={handleKeyDown}
+          placeholder={placeholder || 'Type a message...'}
+          disabled={disabled || sending}
+          className="flex-1 min-w-0"
+        />
+        <Button
+          type="submit"
+          disabled={disabled || sending || !canSubmit}
+          className="flex-shrink-0"
+        >
+          {sending ? 'Sending...' : 'Send'}
+        </Button>
+      </div>
+      {showCharCounter && (
+        <>
+          <div className="hidden sm:flex items-center justify-end gap-2 text-xs">
+            <span
               className={cn(
-                'w-full h-10 bg-transparent rounded-xl text-sm placeholder:text-muted-foreground/40 focus:outline-none disabled:cursor-not-allowed disabled:opacity-40',
-                isRepeaterMode ? 'pl-9 pr-3' : 'px-4'
+                'tabular-nums',
+                limitState === 'error' || limitState === 'danger'
+                  ? 'text-destructive font-medium'
+                  : limitState === 'warning'
+                    ? 'text-warning'
+                    : 'text-muted-foreground'
               )}
-            />
+            >
+              {textByteLen}/{limits!.hardLimit}
+              {remaining < 0 && ` (${remaining})`}
+            </span>
+            {warningMessage && (
+              <span className={cn(limitState === 'error' ? 'text-destructive' : 'text-warning')}>
+                — {warningMessage}
+              </span>
+            )}
           </div>
 
-          {/* Send button */}
-          <motion.button
-            type="submit"
-            disabled={disabled || sending || !canSubmit}
-            whileTap={{ scale: 0.92 }}
-            className={cn(
-              'h-10 rounded-xl flex items-center justify-center gap-2 font-medium text-sm transition-all duration-200 disabled:opacity-30 disabled:cursor-not-allowed flex-shrink-0',
-              isRepeaterMode
-                ? 'px-4 bg-accent/15 text-accent border border-accent/25 hover:bg-accent/25'
-                : canSubmit && !disabled
-                  ? 'px-4 bg-primary text-primary-foreground shadow-glow-amber-sm hover:shadow-glow-amber active:shadow-none'
-                  : 'px-4 bg-secondary text-muted-foreground'
-            )}
-          >
-            {sending ? (
-              <div className="w-4 h-4 border-2 border-current/30 border-t-current rounded-full animate-spin" />
-            ) : isRepeaterMode ? (
-              <>
-                <Lock className="h-4 w-4" />
-                <span className="hidden sm:inline">{text.trim() ? 'Login' : 'Guest'}</span>
-              </>
-            ) : (
-              <>
-                <Send className="h-4 w-4" />
-                <span className="hidden sm:inline">Send</span>
-              </>
-            )}
-          </motion.button>
-        </div>
-
-        {/* Character counter */}
-        <AnimatePresence>
-          {showCharCounter && (
-            <motion.div
-              initial={{ opacity: 0, height: 0 }}
-              animate={{ opacity: 1, height: 'auto' }}
-              exit={{ opacity: 0, height: 0 }}
-              className="flex items-center justify-end gap-2 text-xs overflow-hidden"
-            >
-              <span
-                className={cn(
-                  'tabular-nums font-mono text-[11px]',
-                  limitState === 'error' || limitState === 'danger'
-                    ? 'text-red-400 font-medium'
-                    : limitState === 'warning'
-                      ? 'text-amber-400'
-                      : 'text-muted-foreground/50'
-                )}
-              >
-                {textByteLen}/{limits!.hardLimit}b{remaining < 0 && ` (${remaining})`}
-              </span>
-              {warningMessage && (
+          {(showMobileCounterValue || warningMessage) && (
+            <div className="flex sm:hidden items-center justify-end gap-2 text-xs">
+              {showMobileCounterValue && (
                 <span
                   className={cn(
-                    'text-[11px]',
-                    limitState === 'error' ? 'text-red-400' : 'text-amber-400/70'
+                    'tabular-nums',
+                    limitState === 'error' || limitState === 'danger'
+                      ? 'text-destructive font-medium'
+                      : limitState === 'warning'
+                        ? 'text-warning'
+                        : 'text-muted-foreground'
                   )}
                 >
-                  {warningMessage}
+                  {textByteLen}/{limits!.hardLimit}
+                  {remaining < 0 && ` (${remaining})`}
                 </span>
               )}
-            </motion.div>
+              {warningMessage && (
+                <span className={cn(limitState === 'error' ? 'text-destructive' : 'text-warning')}>
+                  — {warningMessage}
+                </span>
+              )}
+            </div>
           )}
-        </AnimatePresence>
-      </form>
-    </div>
+        </>
+      )}
+    </form>
   );
 });

frontend/src/components/MessageList.tsx

@@ -7,14 +7,13 @@ import {
   useState,
   type ReactNode,
 } from 'react';
-import { motion, AnimatePresence } from 'framer-motion';
-import { ChevronDown } from 'lucide-react';
 import type { Contact, Message, MessagePath, RadioConfig } from '../types';
 import { CONTACT_TYPE_REPEATER } from '../types';
 import { formatTime, parseSenderFromText } from '../utils/messageParser';
 import { formatHopCounts, type SenderInfo } from '../utils/pathUtils';
 import { ContactAvatar } from './ContactAvatar';
 import { PathModal } from './PathModal';
+import { handleKeyboardActivate } from '../utils/a11y';
 import { cn } from '@/lib/utils';
 
 interface MessageListProps {
@@ -25,8 +24,16 @@ interface MessageListProps {
   hasOlderMessages?: boolean;
   onSenderClick?: (sender: string) => void;
   onLoadOlder?: () => void;
+  onResendChannelMessage?: (messageId: number, newTimestamp?: boolean) => void;
   radioName?: string;
   config?: RadioConfig | null;
+  onOpenContactInfo?: (publicKey: string, fromChannel?: boolean) => void;
+  targetMessageId?: number | null;
+  onTargetReached?: () => void;
+  hasNewerMessages?: boolean;
+  loadingNewer?: boolean;
+  onLoadNewer?: () => void;
+  onJumpToBottom?: () => void;
 }
 
 // URL regex for linkifying plain text
@@ -51,7 +58,7 @@ function linkifyText(text: string, keyPrefix: string): ReactNode[] {
         href={match[0]}
         target="_blank"
         rel="noopener noreferrer"
-        className="text-accent underline decoration-accent/40 hover:decoration-accent hover:text-accent/80 transition-colors"
+        className="text-primary underline hover:text-primary/80"
       >
         {match[0]}
       </a>
@@ -75,6 +82,7 @@ function renderTextWithMentions(text: string, radioName?: string): ReactNode {
   let keyIndex = 0;
 
   while ((match = mentionPattern.exec(text)) !== null) {
+    // Add text before the match (with linkification)
     if (match.index > lastIndex) {
       parts.push(...linkifyText(text.slice(lastIndex, match.index), `pre-${keyIndex}`));
     }
@@ -86,19 +94,18 @@ function renderTextWithMentions(text: string, radioName?: string): ReactNode {
       <span
         key={`mention-${keyIndex++}`}
         className={cn(
-          'rounded-md px-1 py-0.5 text-[13px]',
-          isOwnMention
-            ? 'bg-primary/20 text-primary font-semibold ring-1 ring-primary/30'
-            : 'bg-accent/10 text-accent/80'
+          'rounded px-0.5',
+          isOwnMention ? 'bg-primary/30 text-primary font-medium' : 'bg-muted-foreground/20'
         )}
       >
-        @{mentionedName}
+        @[{mentionedName}]
       </span>
     );
 
     lastIndex = match.index + match[0].length;
   }
 
+  // Add remaining text after last match (with linkification)
   if (lastIndex < text.length) {
     parts.push(...linkifyText(text.slice(lastIndex), `post-${keyIndex}`));
   }
@@ -106,7 +113,7 @@ function renderTextWithMentions(text: string, radioName?: string): ReactNode {
   return parts.length > 0 ? parts : text;
 }
 
-// Clickable hop count badge
+// Clickable hop count badge that opens the path modal
 interface HopCountBadgeProps {
   paths: MessagePath[];
   onClick: () => void;
@@ -115,27 +122,33 @@ interface HopCountBadgeProps {
 
 function HopCountBadge({ paths, onClick, variant }: HopCountBadgeProps) {
   const hopInfo = formatHopCounts(paths);
-  const label = hopInfo.display;
+  const label = `(${hopInfo.display})`;
+
+  const className =
+    variant === 'header'
+      ? 'font-normal text-muted-foreground ml-1 text-[11px] cursor-pointer hover:text-primary hover:underline'
+      : 'text-[10px] text-muted-foreground ml-1 cursor-pointer hover:text-primary hover:underline';
 
   return (
     <span
-      className={cn(
-        'cursor-pointer transition-colors',
-        variant === 'header'
-          ? 'ml-1.5 text-[10px] px-1.5 py-0.5 rounded-full bg-accent/10 text-accent/60 hover:text-accent hover:bg-accent/15'
-          : 'ml-1.5 text-[10px] px-1.5 py-0.5 rounded-full bg-muted text-muted-foreground/50 hover:text-accent hover:bg-accent/10'
-      )}
+      className={className}
+      role="button"
+      tabIndex={0}
+      onKeyDown={handleKeyboardActivate}
       onClick={(e) => {
         e.stopPropagation();
         onClick();
       }}
       title="View message path"
+      aria-label={`${hopInfo.display}, view path`}
     >
       {label}
     </span>
   );
 }
 
+const RESEND_WINDOW_SECONDS = 30;
+
 export function MessageList({
   messages,
   contacts,
@@ -144,8 +157,16 @@ export function MessageList({
   hasOlderMessages = false,
   onSenderClick,
   onLoadOlder,
+  onResendChannelMessage,
   radioName,
   config,
+  onOpenContactInfo,
+  targetMessageId,
+  onTargetReached,
+  hasNewerMessages = false,
+  loadingNewer = false,
+  onLoadNewer,
+  onJumpToBottom,
 }: MessageListProps) {
   const listRef = useRef<HTMLDivElement>(null);
   const prevMessagesLengthRef = useRef<number>(0);
@@ -154,37 +175,55 @@ export function MessageList({
   const [selectedPath, setSelectedPath] = useState<{
     paths: MessagePath[];
     senderInfo: SenderInfo;
+    messageId?: number;
+    isOutgoingChan?: boolean;
   } | null>(null);
+  const [resendableIds, setResendableIds] = useState<Set<number>>(new Set());
+  const resendTimersRef = useRef<Map<number, ReturnType<typeof setTimeout>>>(new Map());
+  const [highlightedMessageId, setHighlightedMessageId] = useState<number | null>(null);
+  const targetScrolledRef = useRef(false);
 
+  // Capture scroll state in the scroll handler BEFORE any state updates
   const scrollStateRef = useRef({
     scrollTop: 0,
     scrollHeight: 0,
     clientHeight: 0,
     wasNearTop: false,
-    wasNearBottom: true,
+    wasNearBottom: true, // Default to true so initial messages scroll to bottom
   });
 
+  // Track conversation key to detect when entire message set changes
   const prevConvKeyRef = useRef<string | null>(null);
 
+  // Handle scroll position AFTER render
   useLayoutEffect(() => {
     if (!listRef.current) return;
 
     const list = listRef.current;
     const messagesAdded = messages.length - prevMessagesLengthRef.current;
 
+    // Detect if messages are from a different conversation (handles the case where
+    // the key prop remount consumes isInitialLoadRef on stale data from the previous
+    // conversation before the cache restore effect sets the correct messages)
     const convKey = messages.length > 0 ? messages[0].conversation_key : null;
     const conversationChanged = convKey !== null && convKey !== prevConvKeyRef.current;
     if (convKey !== null) prevConvKeyRef.current = convKey;
 
     if ((isInitialLoadRef.current || conversationChanged) && messages.length > 0) {
+      // Initial load or conversation switch - scroll to bottom
       list.scrollTop = list.scrollHeight;
       isInitialLoadRef.current = false;
     } else if (messagesAdded > 0 && prevMessagesLengthRef.current > 0) {
+      // Messages were added - use scroll state captured before the update
       const scrollHeightDiff = list.scrollHeight - scrollStateRef.current.scrollHeight;
 
       if (scrollStateRef.current.wasNearTop && scrollHeightDiff > 0) {
+        // User was near top (loading older) - preserve position by adding the height diff
         list.scrollTop = scrollStateRef.current.scrollTop + scrollHeightDiff;
-      } else if (scrollStateRef.current.wasNearBottom) {
+      } else if (scrollStateRef.current.wasNearBottom && !hasNewerMessagesRef.current) {
+        // User was near bottom - scroll to bottom for new messages (including sent).
+        // Skip when browsing mid-history (hasNewerMessages) so that forward-pagination
+        // appends in place instead of chasing the bottom in an infinite load loop.
         list.scrollTop = list.scrollHeight;
       }
     }
@@ -192,6 +231,26 @@ export function MessageList({
     prevMessagesLengthRef.current = messages.length;
   }, [messages]);
 
+  // Scroll to target message and highlight it
+  useLayoutEffect(() => {
+    if (!targetMessageId || targetScrolledRef.current || messages.length === 0) return;
+    const el = listRef.current?.querySelector(`[data-message-id="${targetMessageId}"]`);
+    if (!el) return;
+
+    // Prevent the initial-load layout effect from overriding our scroll
+    isInitialLoadRef.current = false;
+    el.scrollIntoView({ block: 'center' });
+    setHighlightedMessageId(targetMessageId);
+    targetScrolledRef.current = true;
+    onTargetReached?.();
+  }, [messages, targetMessageId, onTargetReached]);
+
+  // Reset target scroll tracking when targetMessageId changes
+  useEffect(() => {
+    targetScrolledRef.current = false;
+  }, [targetMessageId]);
+
+  // Reset initial load flag when conversation changes (messages becomes empty then filled)
   useEffect(() => {
     if (messages.length === 0) {
       isInitialLoadRef.current = true;
@@ -207,12 +266,66 @@ export function MessageList({
     }
   }, [messages.length]);
 
+  // Track resendable outgoing CHAN messages (within 30s window)
+  useEffect(() => {
+    if (!onResendChannelMessage) return;
+
+    const now = Math.floor(Date.now() / 1000);
+    const newResendable = new Set<number>();
+    const timers = resendTimersRef.current;
+
+    for (const msg of messages) {
+      if (!msg.outgoing || msg.type !== 'CHAN' || msg.sender_timestamp === null) continue;
+      const remaining = RESEND_WINDOW_SECONDS - (now - msg.sender_timestamp);
+      if (remaining <= 0) continue;
+
+      newResendable.add(msg.id);
+
+      // Schedule removal if not already tracked
+      if (!timers.has(msg.id)) {
+        const timer = setTimeout(() => {
+          setResendableIds((prev) => {
+            const next = new Set(prev);
+            next.delete(msg.id);
+            return next;
+          });
+          timers.delete(msg.id);
+        }, remaining * 1000);
+        timers.set(msg.id, timer);
+      }
+    }
+
+    setResendableIds(newResendable);
+
+    return () => {
+      for (const timer of timers.values()) clearTimeout(timer);
+      timers.clear();
+    };
+  }, [messages, onResendChannelMessage]);
+
+  // Refs for scroll handler to read without causing callback recreation
+  const onLoadOlderRef = useRef(onLoadOlder);
+  const loadingOlderRef = useRef(loadingOlder);
+  const hasOlderMessagesRef = useRef(hasOlderMessages);
+  const onLoadNewerRef = useRef(onLoadNewer);
+  const loadingNewerRef = useRef(loadingNewer);
+  const hasNewerMessagesRef = useRef(hasNewerMessages);
+  onLoadOlderRef.current = onLoadOlder;
+  loadingOlderRef.current = loadingOlder;
+  hasOlderMessagesRef.current = hasOlderMessages;
+  onLoadNewerRef.current = onLoadNewer;
+  loadingNewerRef.current = loadingNewer;
+  hasNewerMessagesRef.current = hasNewerMessages;
+
+  // Handle scroll - capture state and detect when user is near top/bottom
+  // Stable callback: reads changing values from refs, never recreated.
   const handleScroll = useCallback(() => {
     if (!listRef.current) return;
 
     const { scrollTop, scrollHeight, clientHeight } = listRef.current;
     const distanceFromBottom = scrollHeight - scrollTop - clientHeight;
 
+    // Always capture current scroll state (needed for scroll preservation)
     scrollStateRef.current = {
       scrollTop,
       scrollHeight,
@@ -221,35 +334,72 @@ export function MessageList({
       wasNearBottom: distanceFromBottom < 100,
     };
 
+    // Show scroll-to-bottom button when not near the bottom (more than 100px away)
     setShowScrollToBottom(distanceFromBottom > 100);
 
-    if (!onLoadOlder || loadingOlder || !hasOlderMessages) return;
-
-    if (scrollTop < 100) {
-      onLoadOlder();
+    if (!onLoadOlderRef.current || loadingOlderRef.current || !hasOlderMessagesRef.current) {
+      // skip older load
+    } else if (scrollTop < 100) {
+      onLoadOlderRef.current();
     }
-  }, [onLoadOlder, loadingOlder, hasOlderMessages]);
 
-  const scrollToBottom = useCallback(() => {
-    if (listRef.current) {
-      listRef.current.scrollTop = listRef.current.scrollHeight;
+    // Trigger load newer when within 100px of bottom
+    if (
+      onLoadNewerRef.current &&
+      !loadingNewerRef.current &&
+      hasNewerMessagesRef.current &&
+      distanceFromBottom < 100
+    ) {
+      onLoadNewerRef.current();
     }
   }, []);
 
+  // Scroll to bottom handler (or jump to bottom if viewing historical messages)
+  const scrollToBottom = useCallback(() => {
+    if (hasNewerMessages && onJumpToBottom) {
+      onJumpToBottom();
+      return;
+    }
+    if (listRef.current) {
+      listRef.current.scrollTop = listRef.current.scrollHeight;
+    }
+  }, [hasNewerMessages, onJumpToBottom]);
+
+  // Sort messages by received_at ascending (oldest first)
+  // Note: Deduplication is handled by useConversationMessages.addMessageIfNew()
+  // and the database UNIQUE constraint on (type, conversation_key, text, sender_timestamp)
   const sortedMessages = useMemo(
-    () => [...messages].sort((a, b) => a.received_at - b.received_at),
+    () => [...messages].sort((a, b) => a.received_at - b.received_at || a.id - b.id),
     [messages]
   );
 
+  // Sender info for outgoing messages (used by path modal on own messages)
+  const selfSenderInfo = useMemo<SenderInfo>(
+    () => ({
+      name: config?.name || 'Unknown',
+      publicKeyOrPrefix: config?.public_key || '',
+      lat: config?.lat ?? null,
+      lon: config?.lon ?? null,
+    }),
+    [config?.name, config?.public_key, config?.lat, config?.lon]
+  );
+
+  // Derive live so the byte-perfect button disables if the 30s window expires while modal is open
+  const isSelectedMessageResendable =
+    selectedPath?.messageId !== undefined && resendableIds.has(selectedPath.messageId);
+
+  // Look up contact by public key
   const getContact = (conversationKey: string | null): Contact | null => {
     if (!conversationKey) return null;
     return contacts.find((c) => c.public_key === conversationKey) || null;
   };
 
+  // Look up contact by name (for channel messages where we parse sender from text)
   const getContactByName = (name: string): Contact | null => {
     return contacts.find((c) => c.name === name) || null;
   };
 
+  // Build sender info for path modal
   const getSenderInfo = (
     msg: Message,
     contact: Contact | null,
@@ -263,6 +413,7 @@ export function MessageList({
         lon: contact.lon,
       };
     }
+    // For channel messages, try to find contact by parsed sender name
     if (parsedSender) {
       const senderContact = getContactByName(parsedSender);
       if (senderContact) {
@@ -274,6 +425,7 @@ export function MessageList({
         };
       }
     }
+    // Fallback: unknown sender
     return {
       name: parsedSender || 'Unknown',
       publicKeyOrPrefix: msg.conversation_key || '',
@@ -284,26 +436,21 @@ export function MessageList({
 
   if (loading) {
     return (
-      <div className="flex-1 flex items-center justify-center">
-        <div className="flex flex-col items-center gap-3">
-          <div className="w-8 h-8 border-2 border-primary/30 border-t-primary rounded-full animate-spin" />
-          <span className="text-sm text-muted-foreground">Loading messages...</span>
-        </div>
+      <div className="flex-1 overflow-y-auto p-5 text-center text-muted-foreground" role="status">
+        Loading messages...
       </div>
     );
   }
 
   if (messages.length === 0) {
     return (
-      <div className="flex-1 flex items-center justify-center">
-        <div className="text-center">
-          <div className="text-3xl mb-2 opacity-20">💬</div>
-          <span className="text-sm text-muted-foreground/60">No messages yet</span>
-        </div>
+      <div className="flex-1 overflow-y-auto p-5 text-center text-muted-foreground">
+        No messages yet
       </div>
     );
   }
 
+  // Helper to get a unique sender key for grouping messages
   const getSenderKey = (msg: Message, sender: string | null): string => {
     if (msg.outgoing) return '__outgoing__';
     if (msg.type === 'PRIV' && msg.conversation_key) return msg.conversation_key;
@@ -313,24 +460,26 @@ export function MessageList({
   return (
     <div className="flex-1 overflow-hidden relative">
       <div
-        className="h-full overflow-y-auto px-4 py-3 flex flex-col gap-0.5"
+        className="h-full overflow-y-auto p-4 flex flex-col gap-0.5"
         ref={listRef}
         onScroll={handleScroll}
       >
         {loadingOlder && (
-          <div className="flex justify-center py-3">
-            <div className="w-5 h-5 border-2 border-primary/30 border-t-primary rounded-full animate-spin" />
+          <div className="text-center py-2 text-muted-foreground text-sm" role="status">
+            Loading older messages...
           </div>
         )}
         {!loadingOlder && hasOlderMessages && (
-          <div className="text-center py-2 text-muted-foreground/40 text-xs">
+          <div className="text-center py-2 text-muted-foreground text-xs">
             Scroll up for older messages
           </div>
         )}
         {sortedMessages.map((msg, index) => {
+          // For DMs, look up contact; for channel messages, use parsed sender
           const contact = msg.type === 'PRIV' ? getContact(msg.conversation_key) : null;
           const isRepeater = contact?.type === CONTACT_TYPE_REPEATER;
 
+          // Skip sender parsing for repeater messages (CLI responses often have colons)
           const { sender, content } = isRepeater
             ? { sender: null, content: msg.text }
             : parseSenderFromText(msg.text);
@@ -340,21 +489,26 @@ export function MessageList({
 
           const canClickSender = !msg.outgoing && onSenderClick && displaySender !== 'Unknown';
 
+          // Determine if we should show avatar (first message in a chunk from same sender)
           const currentSenderKey = getSenderKey(msg, sender);
           const prevMsg = sortedMessages[index - 1];
           const prevSenderKey = prevMsg
             ? getSenderKey(prevMsg, parseSenderFromText(prevMsg.text).sender)
             : null;
-          const showAvatar = !msg.outgoing && currentSenderKey !== prevSenderKey;
+          const isFirstInGroup = currentSenderKey !== prevSenderKey;
+          const showAvatar = !msg.outgoing && isFirstInGroup;
           const isFirstMessage = index === 0;
 
+          // Get avatar info for incoming messages
           let avatarName: string | null = null;
           let avatarKey: string = '';
           if (!msg.outgoing) {
             if (msg.type === 'PRIV' && msg.conversation_key) {
+              // DM: use conversation_key (sender's public key)
               avatarName = contact?.name || null;
               avatarKey = msg.conversation_key;
             } else if (sender) {
+              // Channel message: try to find contact by name, or use sender name as pseudo-key
               const senderContact = getContactByName(sender);
               avatarName = sender;
               avatarKey = senderContact?.public_key || `name:${sender}`;
@@ -364,43 +518,60 @@ export function MessageList({
           return (
             <div
               key={msg.id}
+              data-message-id={msg.id}
               className={cn(
                 'flex items-start max-w-[85%]',
                 msg.outgoing && 'flex-row-reverse self-end',
-                showAvatar && !isFirstMessage && 'mt-4'
+                isFirstInGroup && !isFirstMessage && 'mt-3'
               )}
             >
               {!msg.outgoing && (
-                <div className="w-9 flex-shrink-0 flex items-start pt-0.5">
+                <div className="w-10 flex-shrink-0 flex items-start pt-0.5">
                   {showAvatar && avatarKey && (
-                    <ContactAvatar name={avatarName} publicKey={avatarKey} size={30} />
+                    <span
+                      role={onOpenContactInfo ? 'button' : undefined}
+                      tabIndex={onOpenContactInfo ? 0 : undefined}
+                      onKeyDown={onOpenContactInfo ? handleKeyboardActivate : undefined}
+                      onClick={
+                        onOpenContactInfo
+                          ? () => onOpenContactInfo(avatarKey, msg.type === 'CHAN')
+                          : undefined
+                      }
+                    >
+                      <ContactAvatar
+                        name={avatarName}
+                        publicKey={avatarKey}
+                        size={32}
+                        clickable={!!onOpenContactInfo}
+                      />
+                    </span>
                   )}
                 </div>
               )}
               <div
                 className={cn(
-                  'py-2 px-3 rounded-2xl min-w-0 relative',
-                  msg.outgoing
-                    ? 'bg-gradient-to-br from-primary/20 to-primary/10 border border-primary/15'
-                    : 'bg-secondary/60 border border-border/30'
+                  'py-1.5 px-3 rounded-lg min-w-0',
+                  msg.outgoing ? 'bg-msg-outgoing' : 'bg-msg-incoming',
+                  highlightedMessageId === msg.id && 'message-highlight'
                 )}
               >
                 {showAvatar && (
-                  <div className="flex items-center gap-1.5 mb-1">
-                    <span className="text-[13px] font-semibold">
-                      {canClickSender ? (
-                        <span
-                          className="cursor-pointer hover:text-primary transition-colors"
-                          onClick={() => onSenderClick(displaySender)}
-                          title={`Mention ${displaySender}`}
-                        >
-                          {displaySender}
-                        </span>
-                      ) : (
-                        <span className="text-muted-foreground">{displaySender}</span>
-                      )}
-                    </span>
-                    <span className="text-[10px] text-muted-foreground/40">
+                  <div className="text-[13px] font-semibold text-foreground mb-0.5">
+                    {canClickSender ? (
+                      <span
+                        className="cursor-pointer hover:text-primary transition-colors"
+                        role="button"
+                        tabIndex={0}
+                        onKeyDown={handleKeyboardActivate}
+                        onClick={() => onSenderClick(displaySender)}
+                        title={`Mention ${displaySender}`}
+                      >
+                        {displaySender}
+                      </span>
+                    ) : (
+                      displaySender
+                    )}
+                    <span className="font-normal text-muted-foreground ml-2 text-[11px]">
                       {formatTime(msg.sender_timestamp || msg.received_at)}
                     </span>
                     {!msg.outgoing && msg.paths && msg.paths.length > 0 && (
@@ -417,7 +588,7 @@ export function MessageList({
                     )}
                   </div>
                 )}
-                <div className="break-words whitespace-pre-wrap text-[14px] leading-relaxed">
+                <div className="break-words whitespace-pre-wrap">
                   {content.split('\n').map((line, i, arr) => (
                     <span key={i}>
                       {renderTextWithMentions(line, radioName)}
@@ -426,7 +597,7 @@ export function MessageList({
                   ))}
                   {!showAvatar && (
                     <>
-                      <span className="text-[10px] text-muted-foreground/30 ml-2">
+                      <span className="text-[10px] text-muted-foreground ml-2">
                         {formatTime(msg.sender_timestamp || msg.received_at)}
                       </span>
                       {!msg.outgoing && msg.paths && msg.paths.length > 0 && (
@@ -447,59 +618,93 @@ export function MessageList({
                     (msg.acked > 0 ? (
                       msg.paths && msg.paths.length > 0 ? (
                         <span
-                          className="ml-1.5 text-[11px] text-emerald-400/70 cursor-pointer hover:text-emerald-400 transition-colors"
+                          className="text-muted-foreground cursor-pointer hover:text-primary"
+                          role="button"
+                          tabIndex={0}
+                          onKeyDown={handleKeyboardActivate}
                           onClick={(e) => {
                             e.stopPropagation();
                             setSelectedPath({
                               paths: msg.paths!,
-                              senderInfo: {
-                                name: config?.name || 'Unknown',
-                                publicKeyOrPrefix: config?.public_key || '',
-                                lat: config?.lat ?? null,
-                                lon: config?.lon ?? null,
-                              },
+                              senderInfo: selfSenderInfo,
+                              messageId: msg.id,
+                              isOutgoingChan: msg.type === 'CHAN' && !!onResendChannelMessage,
                             });
                           }}
                           title="View echo paths"
-                        >
-                          {` ✓${msg.acked > 1 ? msg.acked : ''}`}
-                        </span>
+                          aria-label={`Acknowledged, ${msg.acked} echo${msg.acked !== 1 ? 's' : ''} — view paths`}
+                        >{` ✓${msg.acked > 1 ? msg.acked : ''}`}</span>
                       ) : (
-                        <span className="ml-1.5 text-[11px] text-emerald-400/70">
-                          {` ✓${msg.acked > 1 ? msg.acked : ''}`}
-                        </span>
+                        <span className="text-muted-foreground">{` ✓${msg.acked > 1 ? msg.acked : ''}`}</span>
                       )
-                    ) : (
+                    ) : onResendChannelMessage && msg.type === 'CHAN' ? (
                       <span
-                        className="ml-1.5 text-[11px] text-muted-foreground/30"
-                        title="No repeats heard yet"
+                        className="text-muted-foreground cursor-pointer hover:text-primary"
+                        role="button"
+                        tabIndex={0}
+                        onKeyDown={handleKeyboardActivate}
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setSelectedPath({
+                            paths: [],
+                            senderInfo: selfSenderInfo,
+                            messageId: msg.id,
+                            isOutgoingChan: true,
+                          });
+                        }}
+                        title="Message status"
+                        aria-label="No echoes yet — view message status"
                       >
                         {' '}
                         ?
                       </span>
+                    ) : (
+                      <span className="text-muted-foreground" title="No repeats heard yet">
+                        {' '}
+                        ?
+                      </span>
                     ))}
                 </div>
               </div>
             </div>
           );
         })}
+        {loadingNewer && (
+          <div className="text-center py-2 text-muted-foreground text-sm" role="status">
+            Loading newer messages...
+          </div>
+        )}
+        {!loadingNewer && hasNewerMessages && (
+          <div className="text-center py-2 text-muted-foreground text-xs">
+            Scroll down for newer messages
+          </div>
+        )}
       </div>
 
       {/* Scroll to bottom button */}
-      <AnimatePresence>
-        {showScrollToBottom && (
-          <motion.button
-            initial={{ opacity: 0, y: 10, scale: 0.9 }}
-            animate={{ opacity: 1, y: 0, scale: 1 }}
-            exit={{ opacity: 0, y: 10, scale: 0.9 }}
-            onClick={scrollToBottom}
-            className="absolute bottom-4 right-4 w-10 h-10 rounded-full bg-card border border-border/50 flex items-center justify-center shadow-lg hover:bg-secondary transition-all hover:border-primary/30"
-            title="Scroll to bottom"
+      {showScrollToBottom && (
+        <button
+          onClick={scrollToBottom}
+          className="absolute bottom-4 right-4 w-9 h-9 rounded-full bg-card hover:bg-accent border border-border flex items-center justify-center shadow-lg transition-all hover:scale-105 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          title="Scroll to bottom"
+          aria-label="Scroll to bottom"
+        >
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="18"
+            height="18"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+            className="text-muted-foreground"
           >
-            <ChevronDown className="h-5 w-5 text-muted-foreground" />
-          </motion.button>
-        )}
-      </AnimatePresence>
+            <polyline points="6 9 12 15 18 9" />
+          </svg>
+        </button>
+      )}
 
       {/* Path modal */}
       {selectedPath && (
@@ -510,6 +715,10 @@ export function MessageList({
           senderInfo={selectedPath.senderInfo}
           contacts={contacts}
           config={config ?? null}
+          messageId={selectedPath.messageId}
+          isOutgoingChan={selectedPath.isOutgoingChan}
+          isResendable={isSelectedMessageResendable}
+          onResend={onResendChannelMessage}
         />
       )}
     </div>

frontend/src/components/NeighborsMiniMap.tsx

@@ -0,0 +1,102 @@
+import { MapContainer, TileLayer, CircleMarker, Popup, Polyline } from 'react-leaflet';
+import 'leaflet/dist/leaflet.css';
+
+interface Neighbor {
+  lat: number | null;
+  lon: number | null;
+  name: string | null;
+  pubkey_prefix: string;
+  snr: number;
+}
+
+interface Props {
+  neighbors: Neighbor[];
+  radioLat?: number | null;
+  radioLon?: number | null;
+  radioName?: string | null;
+}
+
+export function NeighborsMiniMap({ neighbors, radioLat, radioLon, radioName }: Props) {
+  const valid = neighbors.filter(
+    (n): n is Neighbor & { lat: number; lon: number } => n.lat != null && n.lon != null
+  );
+
+  const hasRadio = radioLat != null && radioLon != null && !(radioLat === 0 && radioLon === 0);
+
+  if (valid.length === 0 && !hasRadio) return null;
+
+  // Center on radio if available, otherwise first neighbor
+  const center: [number, number] = hasRadio ? [radioLat!, radioLon!] : [valid[0].lat, valid[0].lon];
+
+  return (
+    <div
+      className="min-h-48 flex-1 rounded border border-border overflow-hidden"
+      role="img"
+      aria-label="Map showing repeater neighbor locations"
+    >
+      <MapContainer
+        center={center}
+        zoom={10}
+        className="h-full w-full"
+        style={{ background: '#1a1a2e' }}
+      >
+        <TileLayer
+          attribution='&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+          url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
+        />
+        {/* Dotted lines from radio to each neighbor */}
+        {hasRadio &&
+          valid.map((n, i) => (
+            <Polyline
+              key={`line-${i}`}
+              positions={[
+                [radioLat!, radioLon!],
+                [n.lat, n.lon],
+              ]}
+              pathOptions={{
+                color: '#3b82f6',
+                weight: 1.5,
+                opacity: 0.5,
+                dashArray: '6 4',
+              }}
+            />
+          ))}
+        {/* Radio node (bright blue) */}
+        {hasRadio && (
+          <CircleMarker
+            center={[radioLat!, radioLon!]}
+            radius={8}
+            pathOptions={{
+              color: '#1d4ed8',
+              fillColor: '#3b82f6',
+              fillOpacity: 1,
+              weight: 2,
+            }}
+          >
+            <Popup>
+              <span className="text-sm font-medium">{radioName || 'Our Radio'}</span>
+            </Popup>
+          </CircleMarker>
+        )}
+        {/* Neighbor nodes (SNR-colored) */}
+        {valid.map((n, i) => (
+          <CircleMarker
+            key={i}
+            center={[n.lat, n.lon]}
+            radius={6}
+            pathOptions={{
+              color: '#000',
+              fillColor: n.snr >= 6 ? '#22c55e' : n.snr >= 0 ? '#eab308' : '#ef4444',
+              fillOpacity: 0.8,
+              weight: 1,
+            }}
+          >
+            <Popup>
+              <span className="text-sm">{n.name || n.pubkey_prefix}</span>
+            </Popup>
+          </CircleMarker>
+        ))}
+      </MapContainer>
+    </div>
+  );
+}

frontend/src/components/NewMessageModal.tsx

@@ -48,6 +48,15 @@ export function NewMessageModal({
   const [loading, setLoading] = useState(false);
   const hashtagInputRef = useRef<HTMLInputElement>(null);
 
+  const resetForm = () => {
+    setName('');
+    setContactKey('');
+    setRoomKey('');
+    setTryHistorical(false);
+    setPermitCapitals(false);
+    setError('');
+  };
+
   const handleCreate = async () => {
     setError('');
     setLoading(true);
@@ -77,6 +86,7 @@ export function NewMessageModal({
         const normalizedName = permitCapitals ? channelName : channelName.toLowerCase();
         await onCreateHashtagChannel(`#${normalizedName}`, tryHistorical);
       }
+      resetForm();
       onClose();
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Failed to create');
@@ -121,7 +131,15 @@ export function NewMessageModal({
   const showHistoricalOption = tab !== 'existing' && undecryptedCount > 0;
 
   return (
-    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+    <Dialog
+      open={open}
+      onOpenChange={(isOpen) => {
+        if (!isOpen) {
+          resetForm();
+          onClose();
+        }
+      }}
+    >
       <DialogContent className="sm:max-w-[500px]">
         <DialogHeader>
           <DialogTitle>New Conversation</DialogTitle>
@@ -133,7 +151,14 @@ export function NewMessageModal({
           </DialogDescription>
         </DialogHeader>
 
-        <Tabs value={tab} onValueChange={(v) => setTab(v as Tab)} className="w-full">
+        <Tabs
+          value={tab}
+          onValueChange={(v) => {
+            setTab(v as Tab);
+            resetForm();
+          }}
+          className="w-full"
+        >
           <TabsList className="grid w-full grid-cols-4">
             <TabsTrigger value="existing">Existing</TabsTrigger>
             <TabsTrigger value="new-contact">Contact</TabsTrigger>
@@ -149,13 +174,22 @@ export function NewMessageModal({
                 contacts.map((contact) => (
                   <div
                     key={contact.public_key}
-                    className="cursor-pointer px-4 py-2 hover:bg-accent"
+                    className="cursor-pointer px-4 py-2 hover:bg-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset"
+                    role="button"
+                    tabIndex={0}
+                    onKeyDown={(e) => {
+                      if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        (e.currentTarget as HTMLElement).click();
+                      }
+                    }}
                     onClick={() => {
                       onSelectConversation({
                         type: 'contact',
                         id: contact.public_key,
                         name: getContactDisplayName(contact.name, contact.public_key),
                       });
+                      resetForm();
                       onClose();
                     }}
                   >
@@ -220,8 +254,9 @@ export function NewMessageModal({
                     setRoomKey(hex);
                   }}
                   title="Generate random key"
+                  aria-label="Generate random key"
                 >
-                  🎲
+                  <span aria-hidden="true">🎲</span>
                 </Button>
               </div>
             </div>
@@ -283,10 +318,20 @@ export function NewMessageModal({
           </div>
         )}
 
-        {error && <div className="text-sm text-destructive">{error}</div>}
+        {error && (
+          <div className="text-sm text-destructive" role="alert">
+            {error}
+          </div>
+        )}
 
         <DialogFooter>
-          <Button variant="outline" onClick={onClose}>
+          <Button
+            variant="outline"
+            onClick={() => {
+              resetForm();
+              onClose();
+            }}
+          >
             Cancel
           </Button>
           {tab === 'hashtag' && (

frontend/src/components/PathModal.tsx

@@ -1,12 +1,6 @@
+import { useState, lazy, Suspense } from 'react';
 import type { Contact, RadioConfig, MessagePath } from '../types';
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogDescription,
-  DialogFooter,
-} from './ui/dialog';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from './ui/dialog';
 import { Button } from './ui/button';
 import {
   resolvePath,
@@ -21,6 +15,10 @@ import {
 import { formatTime } from '../utils/messageParser';
 import { getMapFocusHash } from '../utils/urlHash';
 
+const PathRouteMap = lazy(() =>
+  import('./PathRouteMap').then((m) => ({ default: m.PathRouteMap }))
+);
+
 interface PathModalProps {
   open: boolean;
   onClose: () => void;
@@ -28,14 +26,35 @@ interface PathModalProps {
   senderInfo: SenderInfo;
   contacts: Contact[];
   config: RadioConfig | null;
+  messageId?: number;
+  isOutgoingChan?: boolean;
+  isResendable?: boolean;
+  onResend?: (messageId: number, newTimestamp?: boolean) => void;
 }
 
-export function PathModal({ open, onClose, paths, senderInfo, contacts, config }: PathModalProps) {
+export function PathModal({
+  open,
+  onClose,
+  paths,
+  senderInfo,
+  contacts,
+  config,
+  messageId,
+  isOutgoingChan,
+  isResendable,
+  onResend,
+}: PathModalProps) {
+  const [expandedMaps, setExpandedMaps] = useState<Set<number>>(new Set());
+  const hasResendActions = isOutgoingChan && messageId !== undefined && onResend;
+  const hasPaths = paths.length > 0;
+
   // Resolve all paths
-  const resolvedPaths = paths.map((p) => ({
-    ...p,
-    resolved: resolvePath(p.path, senderInfo, contacts, config),
-  }));
+  const resolvedPaths = hasPaths
+    ? paths.map((p) => ({
+        ...p,
+        resolved: resolvePath(p.path, senderInfo, contacts, config, p.path_len),
+      }))
+    : [];
 
   const hasSinglePath = paths.length === 1;
 
@@ -43,81 +62,163 @@ export function PathModal({ open, onClose, paths, senderInfo, contacts, config }
     <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
       <DialogContent className="max-w-md max-h-[80vh] flex flex-col">
         <DialogHeader>
-          <DialogTitle>Message Path{!hasSinglePath && `s (${paths.length})`}</DialogTitle>
+          <DialogTitle>
+            {hasPaths
+              ? `Message Path${!hasSinglePath ? `s (${paths.length})` : ''}`
+              : 'Message Status'}
+          </DialogTitle>
           <DialogDescription>
-            {hasSinglePath ? (
+            {!hasPaths ? (
+              <>No echoes heard yet. Echoes appear when repeaters re-broadcast your message.</>
+            ) : hasSinglePath ? (
               <>
                 This shows <em>one route</em> that this message traveled through the mesh network.
-                Routers may be incorrectly identified due to prefix collisions between heard and
-                non-heard router advertisements.
+                Repeaters may be incorrectly identified due to prefix collisions between heard and
+                non-heard repeater advertisements.
               </>
             ) : (
               <>
                 This message was received via <strong>{paths.length} different routes</strong>.
-                Routers may be incorrectly identified due to prefix collisions.
+                Repeaters may be incorrectly identified due to prefix collisions.
               </>
             )}
           </DialogDescription>
         </DialogHeader>
 
-        <div className="flex-1 overflow-y-auto py-2 space-y-4">
-          {/* Raw path summary */}
-          <div className="text-sm">
-            {paths.map((p, index) => {
-              const hops = parsePathHops(p.path);
-              const rawPath = hops.length > 0 ? hops.join('->') : 'direct';
+        {hasPaths && (
+          <div className="flex-1 overflow-y-auto py-2 space-y-4">
+            {/* Raw path summary */}
+            <div className="text-sm">
+              {paths.map((p, index) => {
+                const hops = parsePathHops(p.path, p.path_len);
+                const rawPath = hops.length > 0 ? hops.join('->') : 'direct';
+                return (
+                  <div key={index}>
+                    <span className="text-foreground/70 font-semibold">Path {index + 1}:</span>{' '}
+                    <span className="font-mono text-muted-foreground">{rawPath}</span>
+                  </div>
+                );
+              })}
+            </div>
+
+            {/* Straight-line distance (sender to receiver, same for all routes) */}
+            {resolvedPaths.length > 0 &&
+              isValidLocation(
+                resolvedPaths[0].resolved.sender.lat,
+                resolvedPaths[0].resolved.sender.lon
+              ) &&
+              isValidLocation(
+                resolvedPaths[0].resolved.receiver.lat,
+                resolvedPaths[0].resolved.receiver.lon
+              ) && (
+                <div className="text-sm pb-2 border-b border-border">
+                  <span className="text-muted-foreground">Straight-line distance: </span>
+                  <span className="font-medium">
+                    {formatDistance(
+                      calculateDistance(
+                        resolvedPaths[0].resolved.sender.lat,
+                        resolvedPaths[0].resolved.sender.lon,
+                        resolvedPaths[0].resolved.receiver.lat,
+                        resolvedPaths[0].resolved.receiver.lon
+                      )!
+                    )}
+                  </span>
+                </div>
+              )}
+
+            {resolvedPaths.map((pathData, index) => {
+              const mapExpanded = expandedMaps.has(index);
+              const toggleMap = () =>
+                setExpandedMaps((prev) => {
+                  const next = new Set(prev);
+                  if (next.has(index)) next.delete(index);
+                  else next.add(index);
+                  return next;
+                });
+
               return (
                 <div key={index}>
-                  <span className="text-foreground/70 font-semibold">Path {index + 1}:</span>{' '}
-                  <span className="font-mono text-muted-foreground/70">{rawPath}</span>
+                  <div className="flex items-center justify-between mb-2 pb-1 border-b border-border">
+                    {!hasSinglePath ? (
+                      <div className="text-sm text-foreground/70 font-semibold">
+                        Path {index + 1}{' '}
+                        <span className="font-normal text-muted-foreground">
+                          — received {formatTime(pathData.received_at)}
+                        </span>
+                      </div>
+                    ) : (
+                      <div />
+                    )}
+                    <button
+                      onClick={toggleMap}
+                      aria-expanded={mapExpanded}
+                      className="text-xs text-primary hover:underline cursor-pointer shrink-0 ml-2"
+                    >
+                      {mapExpanded ? 'Hide map' : 'Map route'}
+                    </button>
+                  </div>
+                  {mapExpanded && (
+                    <div className="mb-2">
+                      <Suspense
+                        fallback={
+                          <div
+                            className="rounded border border-border bg-muted/30 animate-pulse"
+                            style={{ height: 220 }}
+                          />
+                        }
+                      >
+                        <PathRouteMap resolved={pathData.resolved} senderInfo={senderInfo} />
+                      </Suspense>
+                    </div>
+                  )}
+                  <PathVisualization resolved={pathData.resolved} senderInfo={senderInfo} />
                 </div>
               );
             })}
           </div>
+        )}
 
-          {/* Straight-line distance (sender to receiver, same for all routes) */}
-          {resolvedPaths.length > 0 &&
-            isValidLocation(
-              resolvedPaths[0].resolved.sender.lat,
-              resolvedPaths[0].resolved.sender.lon
-            ) &&
-            isValidLocation(
-              resolvedPaths[0].resolved.receiver.lat,
-              resolvedPaths[0].resolved.receiver.lon
-            ) && (
-              <div className="text-sm pb-2 border-b border-border">
-                <span className="text-muted-foreground">Straight-line distance: </span>
-                <span className="font-medium">
-                  {formatDistance(
-                    calculateDistance(
-                      resolvedPaths[0].resolved.sender.lat,
-                      resolvedPaths[0].resolved.sender.lon,
-                      resolvedPaths[0].resolved.receiver.lat,
-                      resolvedPaths[0].resolved.receiver.lon
-                    )!
-                  )}
-                </span>
-              </div>
-            )}
-
-          {resolvedPaths.map((pathData, index) => (
-            <div key={index}>
-              {!hasSinglePath && (
-                <div className="text-sm text-foreground/70 font-semibold mb-2 pb-1 border-b border-border">
-                  Path {index + 1}{' '}
-                  <span className="font-normal text-muted-foreground">
-                    — received {formatTime(pathData.received_at)}
+        <div className="flex flex-col gap-2 pt-2">
+          {hasResendActions && (
+            <div className="flex gap-2">
+              {isResendable && (
+                <Button
+                  variant="outline"
+                  className="flex-1 min-w-0 h-auto py-2"
+                  onClick={() => {
+                    onResend(messageId);
+                    onClose();
+                  }}
+                >
+                  <span className="flex flex-col items-center leading-tight">
+                    <span>↻ Resend</span>
+                    <span className="text-[10px] font-normal opacity-80">
+                      Only repeated by new repeaters
+                    </span>
                   </span>
-                </div>
+                </Button>
               )}
-              <PathVisualization resolved={pathData.resolved} senderInfo={senderInfo} />
+              <Button
+                variant="destructive"
+                className="flex-1 min-w-0 h-auto py-2"
+                onClick={() => {
+                  onResend(messageId, true);
+                  onClose();
+                }}
+              >
+                <span className="flex flex-col items-center leading-tight">
+                  <span>↻ Resend as new</span>
+                  <span className="text-[10px] font-normal opacity-80">
+                    Will appear as duplicate to receivers
+                  </span>
+                </span>
+              </Button>
             </div>
-          ))}
+          )}
+          <Button variant="secondary" className="h-auto py-2" onClick={onClose}>
+            Close
+          </Button>
         </div>
-
-        <DialogFooter>
-          <Button onClick={onClose}>Close</Button>
-        </DialogFooter>
       </DialogContent>
     </Dialog>
   );
@@ -301,11 +402,11 @@ function HopNode({ hop, hopNumber, prevLocation }: HopNodeProps) {
         <div className="text-sm font-semibold">
           <span className="text-foreground/80">Hop {hopNumber}:</span>{' '}
           <span className="text-primary font-mono">{hop.prefix}</span>
-          {isAmbiguous && <span className="text-yellow-500 ml-1 font-normal">(ambiguous)</span>}
+          {isAmbiguous && <span className="text-warning ml-1 font-normal">(ambiguous)</span>}
         </div>
 
         {isUnknown ? (
-          <div className="font-medium text-muted-foreground/70">&lt;UNKNOWN&gt;</div>
+          <div className="font-medium text-muted-foreground">&lt;UNKNOWN&gt;</div>
         ) : isAmbiguous ? (
           <div>
             {hop.matches.map((contact) => {
@@ -366,7 +467,15 @@ function CoordinateLink({ lat, lon, publicKey }: { lat: number; lon: number; pub
 
   return (
     <span
-      className="text-xs text-muted-foreground/70 font-mono cursor-pointer hover:text-primary hover:underline ml-1"
+      className="text-xs text-muted-foreground font-mono cursor-pointer hover:text-primary hover:underline ml-1"
+      role="button"
+      tabIndex={0}
+      onKeyDown={(e) => {
+        if (e.key === 'Enter' || e.key === ' ') {
+          e.preventDefault();
+          (e.currentTarget as HTMLElement).click();
+        }
+      }}
       onClick={handleClick}
       title="View on map"
     >

frontend/src/components/PathRouteMap.tsx

@@ -0,0 +1,183 @@
+import { useEffect, useRef } from 'react';
+import { MapContainer, TileLayer, Marker, Tooltip, useMap } from 'react-leaflet';
+import L from 'leaflet';
+import 'leaflet/dist/leaflet.css';
+import { isValidLocation } from '../utils/pathUtils';
+import type { ResolvedPath, SenderInfo } from '../utils/pathUtils';
+
+interface PathRouteMapProps {
+  resolved: ResolvedPath;
+  senderInfo: SenderInfo;
+}
+
+// Colors for hop markers (indexed by hop number - 1)
+const HOP_COLORS = [
+  '#f97316', // Hop 1: orange
+  '#eab308', // Hop 2: yellow
+  '#22c55e', // Hop 3: green
+  '#06b6d4', // Hop 4: cyan
+  '#ec4899', // Hop 5: pink
+  '#f43f5e', // Hop 6: rose
+  '#a855f7', // Hop 7: purple
+  '#64748b', // Hop 8: slate
+];
+
+const SENDER_COLOR = '#3b82f6'; // blue
+const RECEIVER_COLOR = '#8b5cf6'; // violet
+
+function makeIcon(label: string, color: string): L.DivIcon {
+  return L.divIcon({
+    className: '',
+    iconSize: [24, 24],
+    iconAnchor: [12, 12],
+    html: `<div style="
+      width:24px;height:24px;border-radius:50%;
+      background:${color};color:#fff;
+      display:flex;align-items:center;justify-content:center;
+      font-size:11px;font-weight:700;
+      border:2px solid rgba(255,255,255,0.8);
+      box-shadow:0 1px 4px rgba(0,0,0,0.4);
+    ">${label}</div>`,
+  });
+}
+
+function getHopColor(hopIndex: number): string {
+  return HOP_COLORS[hopIndex % HOP_COLORS.length];
+}
+
+/** Collect all valid [lat, lon] points for bounds fitting */
+function collectPoints(resolved: ResolvedPath): [number, number][] {
+  const pts: [number, number][] = [];
+  if (isValidLocation(resolved.sender.lat, resolved.sender.lon)) {
+    pts.push([resolved.sender.lat!, resolved.sender.lon!]);
+  }
+  for (const hop of resolved.hops) {
+    for (const m of hop.matches) {
+      if (isValidLocation(m.lat, m.lon)) {
+        pts.push([m.lat!, m.lon!]);
+      }
+    }
+  }
+  if (isValidLocation(resolved.receiver.lat, resolved.receiver.lon)) {
+    pts.push([resolved.receiver.lat!, resolved.receiver.lon!]);
+  }
+  return pts;
+}
+
+/** Fit map bounds once on mount, then let the user pan/zoom freely */
+function RouteMapBounds({ points }: { points: [number, number][] }) {
+  const map = useMap();
+  const fitted = useRef(false);
+
+  useEffect(() => {
+    if (fitted.current || points.length === 0) return;
+    fitted.current = true;
+    if (points.length === 1) {
+      map.setView(points[0], 12);
+    } else {
+      map.fitBounds(points as L.LatLngBoundsExpression, { padding: [30, 30], maxZoom: 14 });
+    }
+  }, [map, points]);
+
+  return null;
+}
+
+export function PathRouteMap({ resolved, senderInfo }: PathRouteMapProps) {
+  const points = collectPoints(resolved);
+  const hasAnyGps = points.length > 0;
+
+  // Check if some nodes are missing GPS
+  let totalNodes = 2; // sender + receiver
+  let nodesWithGps = 0;
+  if (isValidLocation(resolved.sender.lat, resolved.sender.lon)) nodesWithGps++;
+  if (isValidLocation(resolved.receiver.lat, resolved.receiver.lon)) nodesWithGps++;
+  for (const hop of resolved.hops) {
+    if (hop.matches.length === 0) {
+      totalNodes++;
+    } else {
+      totalNodes += hop.matches.length;
+      nodesWithGps += hop.matches.filter((m) => isValidLocation(m.lat, m.lon)).length;
+    }
+  }
+  const someMissingGps = hasAnyGps && nodesWithGps < totalNodes;
+
+  if (!hasAnyGps) {
+    return (
+      <div className="h-14 rounded border border-border bg-muted/30 flex items-center justify-center text-sm text-muted-foreground">
+        No nodes in this route have GPS coordinates
+      </div>
+    );
+  }
+
+  const center: [number, number] = points[0];
+
+  return (
+    <div>
+      <div
+        className="rounded border border-border overflow-hidden"
+        role="img"
+        aria-label="Map showing message route between nodes"
+        style={{ height: 220 }}
+      >
+        <MapContainer
+          center={center}
+          zoom={10}
+          className="h-full w-full"
+          style={{ background: '#1a1a2e' }}
+        >
+          <TileLayer
+            attribution='&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+            url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
+          />
+          <RouteMapBounds points={points} />
+
+          {/* Sender marker */}
+          {isValidLocation(resolved.sender.lat, resolved.sender.lon) && (
+            <Marker
+              position={[resolved.sender.lat!, resolved.sender.lon!]}
+              icon={makeIcon('S', SENDER_COLOR)}
+            >
+              <Tooltip direction="top" offset={[0, -14]}>
+                {senderInfo.name || 'Sender'}
+              </Tooltip>
+            </Marker>
+          )}
+
+          {/* Hop markers */}
+          {resolved.hops.map((hop, hopIdx) =>
+            hop.matches
+              .filter((m) => isValidLocation(m.lat, m.lon))
+              .map((m, mIdx) => (
+                <Marker
+                  key={`hop-${hopIdx}-${mIdx}`}
+                  position={[m.lat!, m.lon!]}
+                  icon={makeIcon(String(hopIdx + 1), getHopColor(hopIdx))}
+                >
+                  <Tooltip direction="top" offset={[0, -14]}>
+                    {m.name || m.public_key.slice(0, 12)}
+                  </Tooltip>
+                </Marker>
+              ))
+          )}
+
+          {/* Receiver marker */}
+          {isValidLocation(resolved.receiver.lat, resolved.receiver.lon) && (
+            <Marker
+              position={[resolved.receiver.lat!, resolved.receiver.lon!]}
+              icon={makeIcon('R', RECEIVER_COLOR)}
+            >
+              <Tooltip direction="top" offset={[0, -14]}>
+                {resolved.receiver.name || 'Receiver'}
+              </Tooltip>
+            </Marker>
+          )}
+        </MapContainer>
+      </div>
+      {someMissingGps && (
+        <p className="text-xs text-muted-foreground mt-1">
+          Some nodes in this route have no GPS and are not shown
+        </p>
+      )}
+    </div>
+  );
+}

frontend/src/components/RawPacketList.tsx

@@ -1,6 +1,9 @@
+import '../utils/meshcoreDecoderPatch';
 import { useEffect, useRef, useMemo } from 'react';
 import { MeshCoreDecoder, PayloadType, Utils } from '@michaelhart/meshcore-decoder';
 import type { RawPacket } from '../types';
+import { getRawPacketObservationKey } from '../utils/rawPacketIdentity';
+import { cn } from '@/lib/utils';
 
 interface RawPacketListProps {
   packets: RawPacket[];
@@ -147,15 +150,15 @@ function decodePacketSummary(
 function getRouteTypeColor(routeType: string): string {
   switch (routeType) {
     case 'Flood':
-      return 'bg-blue-500/20 text-blue-400';
+      return 'bg-info/20 text-info';
     case 'Direct':
-      return 'bg-green-500/20 text-green-400';
+      return 'bg-success/20 text-success';
     case 'Transport Flood':
       return 'bg-purple-500/20 text-purple-400';
     case 'Transport Direct':
       return 'bg-orange-500/20 text-orange-400';
     default:
-      return 'bg-gray-500/20 text-gray-400';
+      return 'bg-muted text-muted-foreground';
   }
 }
 
@@ -186,6 +189,12 @@ export function RawPacketList({ packets }: RawPacketListProps) {
     }));
   }, [packets]);
 
+  // Sort packets by timestamp ascending (oldest first)
+  const sortedPackets = useMemo(
+    () => [...decodedPackets].sort((a, b) => a.packet.timestamp - b.packet.timestamp),
+    [decodedPackets]
+  );
+
   useEffect(() => {
     if (listRef.current) {
       listRef.current.scrollTop = listRef.current.scrollHeight;
@@ -200,13 +209,13 @@ export function RawPacketList({ packets }: RawPacketListProps) {
     );
   }
 
-  // Sort packets by timestamp ascending (oldest first)
-  const sortedPackets = [...decodedPackets].sort((a, b) => a.packet.timestamp - b.packet.timestamp);
-
   return (
-    <div className="h-full overflow-y-auto p-4 flex flex-col gap-3" ref={listRef}>
+    <div className="h-full overflow-y-auto p-4 flex flex-col gap-2" ref={listRef}>
       {sortedPackets.map(({ packet, decoded }) => (
-        <div key={packet.id} className="py-2 px-3 bg-muted rounded">
+        <div
+          key={getRawPacketObservationKey(packet)}
+          className="py-2 px-3 bg-card rounded-md border border-border/50"
+        >
           <div className="flex items-center gap-2">
             {/* Route type badge */}
             <span
@@ -217,28 +226,35 @@ export function RawPacketList({ packets }: RawPacketListProps) {
             </span>
 
             {/* Encryption status */}
-            {!packet.decrypted && <span title="Encrypted">🔒</span>}
+            {!packet.decrypted && (
+              <>
+                <span aria-hidden="true">🔒</span>
+                <span className="sr-only">Encrypted</span>
+              </>
+            )}
 
             {/* Summary */}
-            <span className={packet.decrypted ? 'text-primary' : 'text-foreground'}>
+            <span
+              className={cn('text-[13px]', packet.decrypted ? 'text-primary' : 'text-foreground')}
+            >
               {decoded.summary}
             </span>
 
             {/* Time */}
-            <span className="text-muted-foreground ml-auto text-sm">
+            <span className="text-muted-foreground ml-auto text-[12px] tabular-nums">
               {formatTime(packet.timestamp)}
             </span>
           </div>
 
           {/* Signal info */}
           {(packet.snr !== null || packet.rssi !== null) && (
-            <div className="text-[11px] text-muted-foreground mt-0.5">
+            <div className="text-[11px] text-muted-foreground mt-0.5 tabular-nums">
               {formatSignalInfo(packet)}
             </div>
           )}
 
           {/* Raw hex data (always visible) */}
-          <div className="font-mono text-[10px] break-all text-muted-foreground/70 mt-1 p-1 bg-background/50 rounded">
+          <div className="font-mono text-[10px] break-all text-muted-foreground mt-1.5 p-1.5 bg-background/60 rounded">
             {packet.data.toUpperCase()}
           </div>
         </div>

frontend/src/components/RepeaterDashboard.tsx

@@ -0,0 +1,218 @@
+import { toast } from './ui/sonner';
+import { Button } from './ui/button';
+import { RepeaterLogin } from './RepeaterLogin';
+import { useRepeaterDashboard } from '../hooks/useRepeaterDashboard';
+import { isFavorite } from '../utils/favorites';
+import { handleKeyboardActivate } from '../utils/a11y';
+import { ContactStatusInfo } from './ContactStatusInfo';
+import type { Contact, Conversation, Favorite } from '../types';
+import { TelemetryPane } from './repeater/RepeaterTelemetryPane';
+import { NeighborsPane } from './repeater/RepeaterNeighborsPane';
+import { AclPane } from './repeater/RepeaterAclPane';
+import { RadioSettingsPane } from './repeater/RepeaterRadioSettingsPane';
+import { LppTelemetryPane } from './repeater/RepeaterLppTelemetryPane';
+import { OwnerInfoPane } from './repeater/RepeaterOwnerInfoPane';
+import { ActionsPane } from './repeater/RepeaterActionsPane';
+import { ConsolePane } from './repeater/RepeaterConsolePane';
+
+// Re-export for backwards compatibility (used by repeaterFormatters.test.ts)
+export { formatDuration, formatClockDrift } from './repeater/repeaterPaneShared';
+
+// --- Main Dashboard ---
+
+interface RepeaterDashboardProps {
+  conversation: Conversation;
+  contacts: Contact[];
+  favorites: Favorite[];
+  radioLat: number | null;
+  radioLon: number | null;
+  radioName: string | null;
+  onTrace: () => void;
+  onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
+  onDeleteContact: (publicKey: string) => void;
+}
+
+export function RepeaterDashboard({
+  conversation,
+  contacts,
+  favorites,
+  radioLat,
+  radioLon,
+  radioName,
+  onTrace,
+  onToggleFavorite,
+  onDeleteContact,
+}: RepeaterDashboardProps) {
+  const {
+    loggedIn,
+    loginLoading,
+    loginError,
+    paneData,
+    paneStates,
+    consoleHistory,
+    consoleLoading,
+    login,
+    loginAsGuest,
+    refreshPane,
+    loadAll,
+    sendConsoleCommand,
+    sendAdvert,
+    rebootRepeater,
+    syncClock,
+  } = useRepeaterDashboard(conversation);
+
+  const contact = contacts.find((c) => c.public_key === conversation.id);
+  const isFav = isFavorite(favorites, 'contact', conversation.id);
+
+  // Loading all panes indicator
+  const anyLoading = Object.values(paneStates).some((s) => s.loading);
+
+  return (
+    <div className="flex-1 flex flex-col min-h-0">
+      {/* Header */}
+      <header className="flex justify-between items-center px-4 py-2.5 border-b border-border gap-2">
+        <span className="flex flex-wrap items-baseline gap-x-2 min-w-0 flex-1">
+          <span className="flex-shrink-0 font-semibold text-base">{conversation.name}</span>
+          <span
+            className="font-normal text-[11px] text-muted-foreground font-mono truncate cursor-pointer hover:text-primary transition-colors"
+            role="button"
+            tabIndex={0}
+            onKeyDown={handleKeyboardActivate}
+            onClick={() => {
+              navigator.clipboard.writeText(conversation.id);
+              toast.success('Contact key copied!');
+            }}
+            title="Click to copy"
+          >
+            {conversation.id}
+          </span>
+          {contact && <ContactStatusInfo contact={contact} ourLat={radioLat} ourLon={radioLon} />}
+        </span>
+        <div className="flex items-center gap-0.5 flex-shrink-0">
+          {loggedIn && (
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={loadAll}
+              disabled={anyLoading}
+              className="text-xs border-success text-success hover:bg-success/10 hover:text-success"
+            >
+              {anyLoading ? 'Loading...' : 'Load All'}
+            </Button>
+          )}
+          <button
+            className="p-1.5 rounded hover:bg-accent text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={onTrace}
+            title="Direct Trace"
+            aria-label="Direct Trace"
+          >
+            <span aria-hidden="true">&#x1F6CE;</span>
+          </button>
+          <button
+            className="p-1.5 rounded hover:bg-accent text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={() => onToggleFavorite('contact', conversation.id)}
+            title={isFav ? 'Remove from favorites' : 'Add to favorites'}
+            aria-label={isFav ? 'Remove from favorites' : 'Add to favorites'}
+          >
+            {isFav ? (
+              <span className="text-favorite">&#9733;</span>
+            ) : (
+              <span className="text-muted-foreground">&#9734;</span>
+            )}
+          </button>
+          <button
+            className="p-1.5 rounded hover:bg-destructive/10 text-muted-foreground hover:text-destructive text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={() => onDeleteContact(conversation.id)}
+            title="Delete"
+            aria-label="Delete"
+          >
+            <span aria-hidden="true">&#128465;</span>
+          </button>
+        </div>
+      </header>
+
+      {/* Body */}
+      <div className="flex-1 overflow-y-auto p-4">
+        {!loggedIn ? (
+          <RepeaterLogin
+            repeaterName={conversation.name}
+            loading={loginLoading}
+            error={loginError}
+            onLogin={login}
+            onLoginAsGuest={loginAsGuest}
+          />
+        ) : (
+          <div className="space-y-4">
+            {/* Top row: Telemetry + Radio Settings | Neighbors (with expanding map) */}
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <div className="flex flex-col gap-4">
+                <TelemetryPane
+                  data={paneData.status}
+                  state={paneStates.status}
+                  onRefresh={() => refreshPane('status')}
+                  disabled={anyLoading}
+                />
+                <RadioSettingsPane
+                  data={paneData.radioSettings}
+                  state={paneStates.radioSettings}
+                  onRefresh={() => refreshPane('radioSettings')}
+                  disabled={anyLoading}
+                  advertData={paneData.advertIntervals}
+                  advertState={paneStates.advertIntervals}
+                  onRefreshAdvert={() => refreshPane('advertIntervals')}
+                />
+                <LppTelemetryPane
+                  data={paneData.lppTelemetry}
+                  state={paneStates.lppTelemetry}
+                  onRefresh={() => refreshPane('lppTelemetry')}
+                  disabled={anyLoading}
+                />
+              </div>
+              <NeighborsPane
+                data={paneData.neighbors}
+                state={paneStates.neighbors}
+                onRefresh={() => refreshPane('neighbors')}
+                disabled={anyLoading}
+                contacts={contacts}
+                radioLat={radioLat}
+                radioLon={radioLon}
+                radioName={radioName}
+              />
+            </div>
+
+            {/* Remaining panes: ACL | Owner Info + Actions */}
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <AclPane
+                data={paneData.acl}
+                state={paneStates.acl}
+                onRefresh={() => refreshPane('acl')}
+                disabled={anyLoading}
+              />
+              <div className="flex flex-col gap-4">
+                <OwnerInfoPane
+                  data={paneData.ownerInfo}
+                  state={paneStates.ownerInfo}
+                  onRefresh={() => refreshPane('ownerInfo')}
+                  disabled={anyLoading}
+                />
+                <ActionsPane
+                  onSendAdvert={sendAdvert}
+                  onSyncClock={syncClock}
+                  onReboot={rebootRepeater}
+                  consoleLoading={consoleLoading}
+                />
+              </div>
+            </div>
+
+            {/* Console — full width */}
+            <ConsolePane
+              history={consoleHistory}
+              loading={consoleLoading}
+              onSend={sendConsoleCommand}
+            />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/components/RepeaterLogin.tsx

@@ -0,0 +1,79 @@
+import { useState, useCallback, type FormEvent } from 'react';
+import { Input } from './ui/input';
+import { Button } from './ui/button';
+
+interface RepeaterLoginProps {
+  repeaterName: string;
+  loading: boolean;
+  error: string | null;
+  onLogin: (password: string) => Promise<void>;
+  onLoginAsGuest: () => Promise<void>;
+}
+
+export function RepeaterLogin({
+  repeaterName,
+  loading,
+  error,
+  onLogin,
+  onLoginAsGuest,
+}: RepeaterLoginProps) {
+  const [password, setPassword] = useState('');
+
+  const handleSubmit = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault();
+      if (loading) return;
+      await onLogin(password.trim());
+    },
+    [password, loading, onLogin]
+  );
+
+  return (
+    <div className="flex-1 flex items-center justify-center p-4">
+      <div className="w-full max-w-sm space-y-6">
+        <div className="text-center space-y-1">
+          <h2 className="text-lg font-semibold">{repeaterName}</h2>
+          <p className="text-sm text-muted-foreground">Log in to access repeater dashboard</p>
+        </div>
+
+        <form onSubmit={handleSubmit} className="space-y-4" autoComplete="off">
+          <Input
+            type="password"
+            autoComplete="off"
+            name="repeater-password"
+            data-lpignore="true"
+            data-1p-ignore="true"
+            data-bwignore="true"
+            value={password}
+            onChange={(e) => setPassword(e.target.value)}
+            placeholder="Repeater password..."
+            aria-label="Repeater password"
+            disabled={loading}
+            autoFocus
+          />
+
+          {error && (
+            <p className="text-sm text-destructive text-center" role="alert">
+              {error}
+            </p>
+          )}
+
+          <div className="flex flex-col gap-2">
+            <Button type="submit" disabled={loading} className="w-full">
+              {loading ? 'Logging in...' : 'Login with Password'}
+            </Button>
+            <Button
+              type="button"
+              variant="outline"
+              disabled={loading}
+              className="w-full"
+              onClick={onLoginAsGuest}
+            >
+              Login as Guest / ACLs
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}

frontend/src/components/SearchView.tsx

@@ -0,0 +1,272 @@
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { api, isAbortError } from '../api';
+import type { Contact, Channel } from '../types';
+import { formatTime } from '../utils/messageParser';
+import { Input } from './ui/input';
+import { Button } from './ui/button';
+import { cn } from '@/lib/utils';
+
+const SEARCH_PAGE_SIZE = 50;
+const DEBOUNCE_MS = 300;
+
+interface SearchResult {
+  id: number;
+  type: 'PRIV' | 'CHAN';
+  conversation_key: string;
+  text: string;
+  received_at: number;
+  outgoing: boolean;
+  sender_name: string | null;
+}
+
+export interface SearchNavigateTarget {
+  id: number;
+  type: 'PRIV' | 'CHAN';
+  conversation_key: string;
+  conversation_name: string;
+}
+
+interface SearchViewProps {
+  contacts: Contact[];
+  channels: Channel[];
+  onNavigateToMessage: (target: SearchNavigateTarget) => void;
+}
+
+function highlightMatch(text: string, query: string): React.ReactNode[] {
+  if (!query) return [text];
+  const parts: React.ReactNode[] = [];
+  const regex = new RegExp(`(${query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'gi');
+  const segments = text.split(regex);
+  for (let i = 0; i < segments.length; i++) {
+    if (regex.test(segments[i])) {
+      parts.push(
+        <mark key={i} className="bg-primary/30 text-foreground rounded-sm px-0.5">
+          {segments[i]}
+        </mark>
+      );
+    } else {
+      parts.push(segments[i]);
+    }
+    // Reset lastIndex since we're using test() in a loop
+    regex.lastIndex = 0;
+  }
+  return parts;
+}
+
+export function SearchView({ contacts, channels, onNavigateToMessage }: SearchViewProps) {
+  const [query, setQuery] = useState('');
+  const [debouncedQuery, setDebouncedQuery] = useState('');
+  const [results, setResults] = useState<SearchResult[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [hasMore, setHasMore] = useState(false);
+  const [offset, setOffset] = useState(0);
+  const abortRef = useRef<AbortController | null>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  // Debounce query
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedQuery(query.trim());
+    }, DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [query]);
+
+  // Reset results when query changes
+  useEffect(() => {
+    setResults([]);
+    setOffset(0);
+    setHasMore(false);
+  }, [debouncedQuery]);
+
+  // Fetch search results
+  useEffect(() => {
+    if (!debouncedQuery) {
+      setResults([]);
+      setHasMore(false);
+      return;
+    }
+
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+
+    setLoading(true);
+    api
+      .getMessages({ q: debouncedQuery, limit: SEARCH_PAGE_SIZE, offset: 0 }, controller.signal)
+      .then((data) => {
+        setResults(data as SearchResult[]);
+        setHasMore(data.length >= SEARCH_PAGE_SIZE);
+        setOffset(data.length);
+      })
+      .catch((err) => {
+        if (!isAbortError(err)) {
+          console.error('Search failed:', err);
+        }
+      })
+      .finally(() => {
+        setLoading(false);
+      });
+
+    return () => controller.abort();
+  }, [debouncedQuery]);
+
+  const loadMore = useCallback(() => {
+    if (!debouncedQuery || loading) return;
+
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+
+    setLoading(true);
+    api
+      .getMessages({ q: debouncedQuery, limit: SEARCH_PAGE_SIZE, offset }, controller.signal)
+      .then((data) => {
+        setResults((prev) => [...prev, ...(data as SearchResult[])]);
+        setHasMore(data.length >= SEARCH_PAGE_SIZE);
+        setOffset((prev) => prev + data.length);
+      })
+      .catch((err) => {
+        if (!isAbortError(err)) {
+          console.error('Search load more failed:', err);
+        }
+      })
+      .finally(() => {
+        setLoading(false);
+      });
+  }, [debouncedQuery, loading, offset]);
+
+  // Resolve conversation name from contacts/channels
+  const getConversationName = useCallback(
+    (result: SearchResult): string => {
+      if (result.type === 'CHAN') {
+        const channel = channels.find(
+          (c) => c.key.toUpperCase() === result.conversation_key.toUpperCase()
+        );
+        return channel?.name || result.conversation_key.slice(0, 8);
+      }
+      const contact = contacts.find(
+        (c) => c.public_key.toLowerCase() === result.conversation_key.toLowerCase()
+      );
+      return contact?.name || result.conversation_key.slice(0, 12);
+    },
+    [contacts, channels]
+  );
+
+  const handleResultClick = useCallback(
+    (result: SearchResult) => {
+      onNavigateToMessage({
+        id: result.id,
+        type: result.type,
+        conversation_key: result.conversation_key,
+        conversation_name: getConversationName(result),
+      });
+    },
+    [onNavigateToMessage, getConversationName]
+  );
+
+  // Focus input on mount
+  useEffect(() => {
+    inputRef.current?.focus();
+  }, []);
+
+  return (
+    <div className="flex flex-col h-full">
+      {/* Header */}
+      <h2 className="flex justify-between items-center px-4 py-2.5 border-b border-border font-semibold text-base">
+        Message Search
+      </h2>
+
+      {/* Search input */}
+      <div className="px-4 py-3 border-b border-border">
+        <Input
+          ref={inputRef}
+          type="text"
+          placeholder="Search all messages..."
+          value={query}
+          onChange={(e) => setQuery(e.target.value)}
+          className="h-9 text-sm"
+          aria-label="Search messages"
+        />
+      </div>
+
+      {/* Results */}
+      <div className="flex-1 overflow-y-auto">
+        {!debouncedQuery && (
+          <div className="p-8 text-center text-muted-foreground text-sm">
+            Type to search across all messages
+          </div>
+        )}
+
+        {debouncedQuery && results.length === 0 && !loading && (
+          <div className="p-8 text-center text-muted-foreground text-sm">
+            No messages found for &ldquo;{debouncedQuery}&rdquo;
+          </div>
+        )}
+
+        {results.map((result) => {
+          const convName = getConversationName(result);
+          const typeBadge = result.type === 'CHAN' ? 'Channel' : 'DM';
+
+          return (
+            <div
+              key={result.id}
+              className="px-4 py-3 border-b border-border/50 cursor-pointer hover:bg-accent/50 transition-colors"
+              role="button"
+              tabIndex={0}
+              onClick={() => handleResultClick(result)}
+              onKeyDown={(e) => {
+                if (e.key === 'Enter' || e.key === ' ') {
+                  e.preventDefault();
+                  handleResultClick(result);
+                }
+              }}
+            >
+              <div className="flex items-center gap-2 mb-1">
+                <span
+                  className={cn(
+                    'text-[10px] font-medium px-1.5 py-0.5 rounded',
+                    result.type === 'CHAN'
+                      ? 'bg-primary/20 text-primary'
+                      : 'bg-secondary text-secondary-foreground'
+                  )}
+                >
+                  {typeBadge}
+                </span>
+                <span className="text-[12px] font-medium text-foreground truncate">{convName}</span>
+                <span className="text-[11px] text-muted-foreground ml-auto flex-shrink-0">
+                  {formatTime(result.received_at)}
+                </span>
+              </div>
+              <div className="text-[13px] text-foreground/80 line-clamp-2 break-words">
+                {result.sender_name && !result.outgoing && (
+                  <span className="text-muted-foreground">{result.sender_name}: </span>
+                )}
+                {result.outgoing && <span className="text-muted-foreground">You: </span>}
+                {highlightMatch(
+                  result.sender_name && result.text.startsWith(`${result.sender_name}: `)
+                    ? result.text.slice(result.sender_name.length + 2)
+                    : result.text,
+                  debouncedQuery
+                )}
+              </div>
+            </div>
+          );
+        })}
+
+        {loading && (
+          <div className="p-4 text-center text-muted-foreground text-sm" role="status">
+            Searching...
+          </div>
+        )}
+
+        {hasMore && !loading && (
+          <div className="p-4 text-center">
+            <Button variant="outline" size="sm" onClick={loadMore}>
+              Load more results
+            </Button>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/components/StatusBar.tsx

@@ -1,9 +1,10 @@
 import { useState } from 'react';
-import { motion, AnimatePresence } from 'framer-motion';
-import { Menu, Radio, Settings, MessageSquare, Wifi, WifiOff } from 'lucide-react';
+import { Menu } from 'lucide-react';
 import type { HealthStatus, RadioConfig } from '../types';
 import { api } from '../api';
 import { toast } from './ui/sonner';
+import { handleKeyboardActivate } from '../utils/a11y';
+import { cn } from '@/lib/utils';
 
 interface StatusBarProps {
   health: HealthStatus | null;
@@ -40,111 +41,91 @@ export function StatusBar({
   };
 
   return (
-    <div className="relative flex items-center gap-3 px-4 py-2.5 border-b border-border/50 bg-card/80 backdrop-blur-sm">
-      {/* Subtle gradient overlay */}
-      <div className="absolute inset-0 bg-gradient-to-r from-primary/[0.03] via-transparent to-accent/[0.03] pointer-events-none" />
-
-      {/* Mobile menu button */}
+    <header className="flex items-center gap-3 px-4 py-2.5 bg-card border-b border-border text-xs">
+      {/* Mobile menu button - only visible on small screens */}
       {onMenuClick && (
         <button
           onClick={onMenuClick}
-          className="md:hidden p-1.5 rounded-lg bg-transparent text-muted-foreground hover:text-foreground hover:bg-secondary transition-colors"
+          className="md:hidden p-1 bg-transparent border-none text-muted-foreground hover:text-foreground cursor-pointer transition-colors"
           aria-label="Open menu"
         >
           <Menu className="h-5 w-5" />
         </button>
       )}
 
-      {/* Logo / Title */}
-      <div className="flex items-center gap-2 mr-auto">
-        <div className="relative">
-          <Radio className="h-5 w-5 text-primary" />
-          {connected && (
-            <motion.div
-              className="absolute -top-0.5 -right-0.5 w-2 h-2 rounded-full bg-emerald-400"
-              animate={{ scale: [1, 1.3, 1] }}
-              transition={{ duration: 2, repeat: Infinity, ease: 'easeInOut' }}
-            />
+      <h1 className="text-base font-semibold tracking-tight mr-auto text-foreground flex items-center gap-1.5">
+        <svg
+          className="h-5 w-5 shrink-0 text-white"
+          viewBox="0 0 512 512"
+          fill="currentColor"
+          aria-hidden="true"
+        >
+          <path d="m455.68 85.902c-31.289 0-56.32 25.031-56.32 56.32 0 11.379 3.4141 21.617 8.5352 30.152l-106.38 135.39c12.516 6.2578 23.895 15.359 32.996 25.602l107.52-136.54c4.5508 1.1367 9.1016 1.707 13.652 1.707 31.289 0 56.32-25.031 56.32-56.32 0-30.719-25.031-56.32-56.32-56.32z" />
+          <path d="m256 343.04c-5.6875 0-10.809 0.57031-15.93 2.2773l-106.38-135.96c-9.1016 10.809-20.48 19.344-32.996 25.602l106.38 135.96c-5.1211 8.5352-7.3945 18.203-7.3945 28.445 0 31.289 25.031 56.32 56.32 56.32s56.32-25.031 56.32-56.32c0-31.293-25.031-56.324-56.32-56.324z" />
+          <path d="m356.69 114.91c3.9805-13.652 10.238-26.738 19.344-37.547-38.113-13.652-78.508-21.047-120.04-21.047-59.164 0-115.48 14.789-166.12 42.668-9.1016-6.8281-21.051-10.809-33.562-10.809-31.289-0.57031-56.32 25.027-56.32 55.75 0 31.289 25.031 56.32 56.32 56.32 31.289 0 56.32-25.031 56.32-56.32 0-3.4141-0.57031-6.8281-1.1367-9.6719 44.371-23.895 93.297-36.41 144.5-36.41 34.703 0 68.836 5.6914 100.69 17.066z" />
+        </svg>
+        RemoteTerm
+      </h1>
+
+      <div
+        className="flex items-center gap-1.5"
+        role="status"
+        aria-label={connected ? 'Connected' : 'Disconnected'}
+      >
+        <div
+          className={cn(
+            'w-2 h-2 rounded-full transition-colors',
+            connected
+              ? 'bg-status-connected shadow-[0_0_6px_hsl(var(--status-connected)/0.5)]'
+              : 'bg-status-disconnected'
           )}
-        </div>
-        <h1 className="text-base font-bold tracking-tight text-gradient-amber">RemoteTerm</h1>
+          aria-hidden="true"
+        />
+        <span className="hidden lg:inline text-muted-foreground">
+          {connected ? 'Connected' : 'Disconnected'}
+        </span>
       </div>
 
-      {/* Connection status */}
-      <div className="flex items-center gap-2">
-        <AnimatePresence mode="wait">
-          {connected ? (
-            <motion.div
-              key="connected"
-              initial={{ opacity: 0, scale: 0.8 }}
-              animate={{ opacity: 1, scale: 1 }}
-              exit={{ opacity: 0, scale: 0.8 }}
-              className="flex items-center gap-1.5 px-2.5 py-1 rounded-full bg-emerald-500/10 border border-emerald-500/20"
-            >
-              <Wifi className="h-3.5 w-3.5 text-emerald-400" />
-              <span className="hidden lg:inline text-xs font-medium text-emerald-400">
-                Connected
-              </span>
-            </motion.div>
-          ) : (
-            <motion.div
-              key="disconnected"
-              initial={{ opacity: 0, scale: 0.8 }}
-              animate={{ opacity: 1, scale: 1 }}
-              exit={{ opacity: 0, scale: 0.8 }}
-              className="flex items-center gap-1.5 px-2.5 py-1 rounded-full bg-destructive/10 border border-destructive/20"
-            >
-              <WifiOff className="h-3.5 w-3.5 text-destructive/70" />
-              <span className="hidden lg:inline text-xs font-medium text-destructive/70">
-                Offline
-              </span>
-            </motion.div>
-          )}
-        </AnimatePresence>
-      </div>
-
-      {/* Radio info */}
       {config && (
-        <div className="hidden lg:flex items-center gap-2">
-          <span className="text-xs font-medium text-foreground/80">{config.name || 'Unnamed'}</span>
+        <div className="hidden lg:flex items-center gap-2 text-muted-foreground">
+          <span className="text-foreground font-medium">{config.name || 'Unnamed'}</span>
           <span
             className="font-mono text-[11px] text-muted-foreground cursor-pointer hover:text-primary transition-colors"
+            role="button"
+            tabIndex={0}
+            onKeyDown={handleKeyboardActivate}
             onClick={() => {
               navigator.clipboard.writeText(config.public_key);
               toast.success('Public key copied!');
             }}
             title="Click to copy public key"
+            aria-label="Copy public key"
           >
-            {config.public_key.toLowerCase().slice(0, 16)}...
+            {config.public_key.toLowerCase()}
           </span>
         </div>
       )}
 
-      {/* Action buttons */}
-      <div className="flex items-center gap-1.5">
-        {!connected && (
-          <motion.button
-            initial={{ opacity: 0, x: 10 }}
-            animate={{ opacity: 1, x: 0 }}
-            onClick={handleReconnect}
-            disabled={reconnecting}
-            className="px-3 py-1.5 text-xs font-medium rounded-lg bg-amber-500/10 border border-amber-500/30 text-amber-400 hover:bg-amber-500/20 transition-all disabled:opacity-40 disabled:cursor-not-allowed"
-          >
-            {reconnecting ? 'Reconnecting...' : 'Reconnect'}
-          </motion.button>
-        )}
+      {!connected && (
         <button
-          onClick={onSettingsClick}
-          className={`p-2 rounded-lg transition-all ${
-            settingsMode
-              ? 'bg-primary/15 text-primary border border-primary/30'
-              : 'text-muted-foreground hover:text-foreground hover:bg-secondary'
-          }`}
-          title={settingsMode ? 'Back to Chat' : 'Settings'}
+          onClick={handleReconnect}
+          disabled={reconnecting}
+          className="px-3 py-1 bg-warning/10 border border-warning/20 text-warning rounded-md text-xs cursor-pointer hover:bg-warning/15 transition-colors disabled:opacity-50 disabled:cursor-not-allowed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
         >
-          {settingsMode ? <MessageSquare className="h-4 w-4" /> : <Settings className="h-4 w-4" />}
+          {reconnecting ? 'Reconnecting...' : 'Reconnect'}
         </button>
-      </div>
-    </div>
+      )}
+      <button
+        onClick={onSettingsClick}
+        className={cn(
+          'px-3 py-1.5 rounded-md text-xs cursor-pointer transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',
+          settingsMode
+            ? 'bg-status-connected/15 border border-status-connected/30 text-status-connected hover:bg-status-connected/25'
+            : 'bg-secondary border border-border text-muted-foreground hover:bg-accent hover:text-foreground'
+        )}
+      >
+        {settingsMode ? 'Back to Chat' : 'Settings'}
+      </button>
+    </header>
   );
 }

frontend/src/components/VisualizerView.tsx

@@ -1,25 +1,63 @@
-import { useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Maximize2, Minimize2 } from 'lucide-react';
 import type { Contact, RawPacket, RadioConfig } from '../types';
-import { PacketVisualizer } from './PacketVisualizer';
+import { PacketVisualizer3D } from './PacketVisualizer3D';
 import { RawPacketList } from './RawPacketList';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from './ui/tabs';
 import { cn } from '@/lib/utils';
+import { getVisualizerSettings, saveVisualizerSettings } from '../utils/visualizerSettings';
 
 interface VisualizerViewProps {
   packets: RawPacket[];
   contacts: Contact[];
   config: RadioConfig | null;
-  onClearPackets?: () => void;
 }
 
-export function VisualizerView({ packets, contacts, config, onClearPackets }: VisualizerViewProps) {
-  const [fullScreen, setFullScreen] = useState(false);
+export function VisualizerView({ packets, contacts, config }: VisualizerViewProps) {
+  const [fullScreen, setFullScreen] = useState(() => getVisualizerSettings().hidePacketFeed);
+  const [paneFullScreen, setPaneFullScreen] = useState(false);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  // Persist packet feed visibility to localStorage
+  useEffect(() => {
+    const current = getVisualizerSettings();
+    if (current.hidePacketFeed !== fullScreen) {
+      saveVisualizerSettings({ ...current, hidePacketFeed: fullScreen });
+    }
+  }, [fullScreen]);
+
+  // Sync state when browser exits fullscreen (Escape, F11, etc.)
+  useEffect(() => {
+    const handler = () => {
+      if (!document.fullscreenElement) setPaneFullScreen(false);
+    };
+    document.addEventListener('fullscreenchange', handler);
+    return () => document.removeEventListener('fullscreenchange', handler);
+  }, []);
+
+  const toggleFullScreen = useCallback(() => {
+    if (!document.fullscreenElement) {
+      containerRef.current?.requestFullscreen();
+      setPaneFullScreen(true);
+    } else {
+      document.exitFullscreen();
+      // State synced via fullscreenchange handler
+    }
+  }, []);
 
   return (
-    <div className="flex flex-col h-full">
+    <div ref={containerRef} className="flex flex-col h-full bg-background">
       {/* Header */}
       <div className="flex justify-between items-center px-4 py-3 border-b border-border font-medium text-lg">
-        <span>Mesh Visualizer</span>
+        <span>{paneFullScreen ? 'RemoteTerm MeshCore Visualizer' : 'Mesh Visualizer'}</span>
+        <button
+          className="hidden md:inline-flex items-center justify-center rounded-md p-1.5 text-muted-foreground hover:text-foreground transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          onClick={toggleFullScreen}
+          title={paneFullScreen ? 'Exit fullscreen' : 'Fullscreen'}
+          aria-label={paneFullScreen ? 'Exit fullscreen' : 'Enter fullscreen'}
+        >
+          {paneFullScreen ? <Minimize2 size={18} /> : <Maximize2 size={18} />}
+        </button>
       </div>
 
       {/* Mobile: Tabbed interface */}
@@ -30,12 +68,7 @@ export function VisualizerView({ packets, contacts, config, onClearPackets }: Vi
             <TabsTrigger value="packets">Packet Feed</TabsTrigger>
           </TabsList>
           <TabsContent value="visualizer" className="flex-1 m-0 overflow-hidden">
-            <PacketVisualizer
-              packets={packets}
-              contacts={contacts}
-              config={config}
-              onClearPackets={onClearPackets}
-            />
+            <PacketVisualizer3D packets={packets} contacts={contacts} config={config} />
           </TabsContent>
           <TabsContent value="packets" className="flex-1 m-0 overflow-hidden">
             <RawPacketList packets={packets} />
@@ -52,13 +85,12 @@ export function VisualizerView({ packets, contacts, config, onClearPackets }: Vi
             fullScreen ? 'flex-1' : 'flex-1 border-r border-border'
           )}
         >
-          <PacketVisualizer
+          <PacketVisualizer3D
             packets={packets}
             contacts={contacts}
             config={config}
             fullScreen={fullScreen}
             onFullScreenChange={setFullScreen}
-            onClearPackets={onClearPackets}
           />
         </div>
 

frontend/src/components/repeater/RepeaterAclPane.tsx

@@ -0,0 +1,58 @@
+import { cn } from '@/lib/utils';
+import { RepeaterPane, NotFetched } from './repeaterPaneShared';
+import type { RepeaterAclResponse, PaneState } from '../../types';
+
+export function AclPane({
+  data,
+  state,
+  onRefresh,
+  disabled,
+}: {
+  data: RepeaterAclResponse | null;
+  state: PaneState;
+  onRefresh: () => void;
+  disabled?: boolean;
+}) {
+  const permColor: Record<number, string> = {
+    0: 'bg-muted text-muted-foreground',
+    1: 'bg-info/10 text-info',
+    2: 'bg-success/10 text-success',
+    3: 'bg-warning/10 text-warning',
+  };
+
+  return (
+    <RepeaterPane title="ACL" state={state} onRefresh={onRefresh} disabled={disabled}>
+      {!data ? (
+        <NotFetched />
+      ) : data.acl.length === 0 ? (
+        <p className="text-sm text-muted-foreground">No ACL entries</p>
+      ) : (
+        <table className="w-full text-sm">
+          <thead>
+            <tr className="text-left text-muted-foreground text-xs">
+              <th className="pb-1 font-medium">Name</th>
+              <th className="pb-1 font-medium text-right">Permission</th>
+            </tr>
+          </thead>
+          <tbody>
+            {data.acl.map((entry, i) => (
+              <tr key={i} className="border-t border-border/50">
+                <td className="py-1">{entry.name || entry.pubkey_prefix}</td>
+                <td className="py-1 text-right">
+                  <span
+                    className={cn(
+                      'text-xs px-1.5 py-0.5 rounded',
+                      permColor[entry.permission] ?? 'bg-muted text-muted-foreground'
+                    )}
+                  >
+                    {entry.permission_name}
+                  </span>
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+    </RepeaterPane>
+  );
+}

frontend/src/components/repeater/RepeaterActionsPane.tsx

@@ -0,0 +1,56 @@
+import { useState, useCallback, useEffect } from 'react';
+import { Button } from '../ui/button';
+
+export function ActionsPane({
+  onSendAdvert,
+  onSyncClock,
+  onReboot,
+  consoleLoading,
+}: {
+  onSendAdvert: () => void;
+  onSyncClock: () => void;
+  onReboot: () => void;
+  consoleLoading: boolean;
+}) {
+  const [confirmReboot, setConfirmReboot] = useState(false);
+
+  const handleReboot = useCallback(() => {
+    if (!confirmReboot) {
+      setConfirmReboot(true);
+      return;
+    }
+    setConfirmReboot(false);
+    onReboot();
+  }, [confirmReboot, onReboot]);
+
+  // Reset confirmation after 3 seconds
+  useEffect(() => {
+    if (!confirmReboot) return;
+    const timer = setTimeout(() => setConfirmReboot(false), 3000);
+    return () => clearTimeout(timer);
+  }, [confirmReboot]);
+
+  return (
+    <div className="border border-border rounded-lg overflow-hidden">
+      <div className="px-3 py-2 bg-muted/50 border-b border-border">
+        <h3 className="text-sm font-medium">Actions</h3>
+      </div>
+      <div className="p-3 flex flex-wrap gap-2">
+        <Button variant="outline" size="sm" onClick={onSendAdvert} disabled={consoleLoading}>
+          Send Advert
+        </Button>
+        <Button variant="outline" size="sm" onClick={onSyncClock} disabled={consoleLoading}>
+          Sync Clock
+        </Button>
+        <Button
+          variant={confirmReboot ? 'destructive' : 'outline'}
+          size="sm"
+          onClick={handleReboot}
+          disabled={consoleLoading}
+        >
+          {confirmReboot ? 'Confirm Reboot' : 'Reboot'}
+        </Button>
+      </div>
+    </div>
+  );
+}