Updating changelog + build for 3.5.0

Allow basic room server usage

.gitattributes

@@ -0,0 +1 @@
+frontend/prebuilt/** -diff

.gitignore

@@ -12,8 +12,12 @@ frontend/test-results/
 
 # Frontend build output (built from source by end users)
 frontend/dist/
+frontend/prebuilt/
 frontend/.eslintcache
 
+# Release artifacts
+remoteterm-prebuilt-frontend-v*.zip
+
 # reference libraries
 references/
 

AGENTS.md

@@ -10,7 +10,7 @@ If instructed to "run all tests" or "get ready for a commit" or other summative,
 ./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.
+This is the repo's end-to-end quality gate. It runs backend/frontend autofixers first, then type checking, tests, and the standard frontend build. All checks must pass green, and the script may leave formatting/lint edits behind.
 
 ## Overview
 
@@ -22,7 +22,7 @@ A web interface for MeshCore mesh radio networks. The backend connects to a Mesh
 
 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, SQS)
-- `frontend/src/components/AGENTS_packet_visualizer.md` - Packet visualizer (force-directed graph, advert-path identity, layout engine)
+- `frontend/src/components/visualizer/AGENTS_packet_visualizer.md` - Packet visualizer (force-directed graph, advert-path identity, layout engine)
 
 ## Architecture Overview
 
@@ -129,7 +129,7 @@ To improve repeater disambiguation in the network visualizer, the backend stores
 - This is independent of raw-packet payload deduplication.
 - Paths are keyed per contact + path + hop count, 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.
+- See `frontend/src/components/visualizer/AGENTS_packet_visualizer.md` § "Advert-Path Identity Hints" for how the visualizer consumes this data.
 
 ## Path Hash Modes
 
@@ -138,8 +138,12 @@ MeshCore firmware can encode path hops as 1-byte, 2-byte, or 3-byte identifiers.
 - `path_hash_mode` values are `0` = 1-byte, `1` = 2-byte, `2` = 3-byte.
 - `GET /api/radio/config` exposes both the current `path_hash_mode` and `path_hash_mode_supported`.
 - `PATCH /api/radio/config` may update `path_hash_mode` only when the connected firmware supports it.
-- Contacts persist `out_path_hash_mode` separately from `last_path` so contact sync and DM send paths can round-trip correctly even when hop bytes are ambiguous.
-- Contacts may also persist an explicit routing override (`route_override_*`). When set, radio-bound operations use the override instead of the learned `last_path*`, but learned paths still keep updating from adverts.
+- Contact routing now uses canonical route fields: `direct_path`, `direct_path_len`, `direct_path_hash_mode`, plus optional `route_override_*`.
+- The contact/API surface also exposes backend-computed `effective_route`, `effective_route_source`, `direct_route`, and `route_override` so send logic and UI do not reimplement precedence rules independently.
+- Legacy `last_path`, `last_path_len`, and `out_path_hash_mode` are no longer part of the contact model or API contract.
+- Route precedence for direct-message sends is: explicit override, then learned direct route, then flood.
+- The learned direct route is sourced from radio contact sync (`out_path`) and PATH/path-discovery updates, matching how firmware updates `ContactInfo.out_path`.
+- Advertisement paths are informational only. They are retained in `contact_advert_paths` for the contact pane and visualizer, but they are not used as DM send routes.
 - `path_len` in API payloads is always hop count, not byte count. The actual path byte length is `hop_count * hash_size`.
 
 ## Data Flow
@@ -159,10 +163,22 @@ MeshCore firmware can encode path hops as 1-byte, 2-byte, or 3-byte identifiers.
 4. Message stored in database with `outgoing=true`
 5. For direct messages: ACK tracked; for channel: repeat detection
 
+Direct-message send behavior intentionally mirrors the firmware/library `send_msg_with_retry(...)` flow:
+- We push the contact's effective route to the radio via `add_contact(...)` before sending.
+- If the initial `MSG_SENT` result includes an expected ACK code, background retries are armed.
+- Non-final retry attempts use the effective route (`override > direct > flood`).
+- Retry timing follows the radio's `suggested_timeout`.
+- The final retry is sent as flood by resetting the path on the radio first, even if an override or direct route exists.
+- Path math is always hop-count based; hop bytes are interpreted using the stored `path_hash_mode`.
+
 ### ACK and Repeat Detection
 
 **Direct messages**: Expected ACK code is tracked. When ACK event arrives, message marked as acked.
 
+Outgoing DMs send once immediately, then may retry up to 2 more times in the background only when the initial `MSG_SENT` result includes an expected ACK code and the message remains unacked. Retry timing follows the radio's `suggested_timeout` from `PACKET_MSG_SENT`, and the final retry is sent as flood even when a routing override is configured. DM ACK state is terminal on first ACK: sibling retry ACK codes are cleared so one DM should not accumulate multiple delivery confirmations from different retry attempts.
+
+ACKs are not a contact-route source. They drive message delivery state and may appear in analytics/detail surfaces, but they do not update `direct_path*` or otherwise influence route selection for future sends.
+
 **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.
@@ -193,12 +209,13 @@ This message-layer echo/path handling is independent of raw-packet storage dedup
 │   │       ├── MapView.tsx       # Leaflet map showing node locations
 │   │       └── ...
 │   └── vite.config.ts
-├── scripts/
-│   ├── all_quality.sh      # Run all lint, format, typecheck, tests, build (sequential)
+├── scripts/                # Quality / release helpers (listing below is representative, not exhaustive)
+│   ├── all_quality.sh      # Repo-standard autofix + validate gate
 │   ├── 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
+├── README_ADVANCED.md      # Advanced setup, troubleshooting, and service guidance
+├── CONTRIBUTING.md         # Contributor workflow and testing guidance
 ├── tests/                  # Backend tests (pytest)
 ├── data/                   # SQLite database (runtime)
 └── pyproject.toml          # Python dependencies
@@ -223,7 +240,7 @@ MESHCORE_SERIAL_PORT=/dev/cu.usbserial-0001 uv run uvicorn app.main:app --reload
 
 ```bash
 cd frontend
-npm ci
+npm install
 npm run dev    # http://localhost:5173, proxies /api to :8000
 ```
 
@@ -237,13 +254,13 @@ Terminal 2: `cd frontend && npm run dev`
 In production, the FastAPI backend serves the compiled frontend. Build the frontend first:
 
 ```bash
-cd frontend && npm ci && npm run build && cd ..
+cd frontend && npm install && npm run build && cd ..
 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
 ```
 
 Access at `http://localhost:8000`. All API routes are prefixed with `/api`.
 
-If `frontend/dist` (or `frontend/dist/index.html`) is missing, backend startup now logs an explicit error and continues serving API routes. In that case, frontend static routes are not mounted until a frontend build is present.
+If `frontend/dist` is missing, the backend falls back to `frontend/prebuilt` when present (for example from the release zip artifact). If neither build directory is available, startup logs an explicit error and continues serving API routes without frontend static routes mounted.
 
 ## Testing
 
@@ -281,7 +298,7 @@ npm run test:run
 
 ### Before Completing Changes
 
-**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.
+**Always run `./scripts/all_quality.sh` before finishing any changes that have modified code or tests.** It is the standard repo gate: autofix first, then type checks, tests, and the standard frontend build. This is not necessary for docs-only changes.
 
 ## API Summary
 
@@ -290,41 +307,39 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | Method | Endpoint | Description |
 |--------|----------|-------------|
 | GET | `/api/health` | Connection status, fanout statuses, bots_disabled flag |
-| GET | `/api/radio/config` | Radio configuration, including `path_hash_mode` and `path_hash_mode_supported` |
-| PATCH | `/api/radio/config` | Update name, location, radio params, and `path_hash_mode` when supported |
+| GET | `/api/debug` | Support snapshot: recent logs, live radio probe, contact/channel drift audit, and running version/git info |
+| GET | `/api/radio/config` | Radio configuration, including `path_hash_mode`, `path_hash_mode_supported`, advert-location on/off, and `multi_acks_enabled` |
+| PATCH | `/api/radio/config` | Update name, location, advert-location on/off, `multi_acks_enabled`, radio params, and `path_hash_mode` when supported |
 | PUT | `/api/radio/private-key` | Import private key to radio |
-| POST | `/api/radio/advertise` | Send advertisement |
+| POST | `/api/radio/advertise` | Send advertisement (`mode`: `flood` or `zero_hop`, default `flood`) |
+| POST | `/api/radio/discover` | Run a short mesh discovery sweep for nearby repeaters/sensors |
 | POST | `/api/radio/reboot` | Reboot radio or reconnect if disconnected |
+| POST | `/api/radio/disconnect` | Disconnect from radio and pause automatic reconnect attempts |
 | POST | `/api/radio/reconnect` | Manual radio reconnection |
 | GET | `/api/contacts` | List contacts |
+| GET | `/api/contacts/analytics` | Unified keyed-or-name contact analytics payload |
 | 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/{public_key}` | Delete contact |
-| POST | `/api/contacts/sync` | Pull from radio |
-| 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}/routing-override` | Set or clear a forced routing override |
 | POST | `/api/contacts/{public_key}/trace` | Trace route to contact |
+| POST | `/api/contacts/{public_key}/path-discovery` | Discover forward/return paths and persist the learned direct route |
 | 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/node-info` | Fetch repeater name, location, and clock via CLI |
+| POST | `/api/contacts/{public_key}/repeater/radio-settings` | Fetch repeater radio config 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}/flood-scope-override` | Set or clear a per-channel regional flood-scope override |
 | POST | `/api/channels/{key}/mark-read` | Mark channel as read |
 | GET | `/api/messages` | List with filters (`q`, `after`/`after_id` for forward pagination) |
@@ -335,7 +350,7 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | 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 |
-| GET | `/api/read-state/unreads` | Server-computed unread counts, mentions, last message times |
+| GET | `/api/read-state/unreads` | Server-computed unread counts, mentions, last message times, and `last_read_ats` boundaries |
 | POST | `/api/read-state/mark-all-read` | Mark all conversations as read |
 | GET | `/api/settings` | Get app settings |
 | PATCH | `/api/settings` | Update app settings |
@@ -385,7 +400,7 @@ Read state (`last_read_at`) is tracked **server-side** for consistency across de
 - Stored as Unix timestamp in `contacts.last_read_at` and `channels.last_read_at`
 - 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)
+- Aggregated counts via `GET /api/read-state/unreads` (server-side computation of counts, mention flags, `last_message_times`, and `last_read_ats`)
 
 **State Tracking Keys (Frontend)**: Generated by `getStateKey()` for message times (sidebar sorting):
 - Channels: `channel-{channel_key}`
@@ -442,11 +457,12 @@ mc.subscribe(EventType.ACK, handler)
 | `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) |
-| `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK` | `false` | Switch the always-on message audit task from hourly checks to aggressive 10-second `get_msg()` fallback polling |
 | `MESHCORE_BASIC_AUTH_USERNAME` | *(none)* | Optional app-wide HTTP Basic auth username; must be set together with `MESHCORE_BASIC_AUTH_PASSWORD` |
 | `MESHCORE_BASIC_AUTH_PASSWORD` | *(none)* | Optional app-wide HTTP Basic auth password; must be set together with `MESHCORE_BASIC_AUTH_USERNAME` |
+| `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK` | `false` | Switch the always-on radio audit task from hourly checks to aggressive 10-second polling; the audit checks both missed message drift and channel-slot cache drift |
+| `MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE` | `false` | Disable channel-slot reuse and force `set_channel(...)` before every channel send, even on serial/BLE |
 
-**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`. `max_radio_contacts` is the configured radio contact capacity baseline used by background maintenance: favorites reload first, non-favorite fill targets about 80% of that value, and full offload/reload triggers around 95% occupancy. They are configured via `GET/PATCH /api/settings`. MQTT, bot, webhook, Apprise, and SQS configs are stored in the `fanout_configs` table, managed via `/api/fanout`.
+**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`. `max_radio_contacts` is the configured radio contact capacity baseline used by background maintenance: favorites reload first, non-favorite fill targets about 80% of that value, and full offload/reload triggers around 95% occupancy. They are configured via `GET/PATCH /api/settings`. The backend still carries `sidebar_sort_order` for compatibility and migration, but the current frontend sidebar stores sort order per section (`Channels`, `Contacts`, `Repeaters`) in localStorage rather than treating it as one shared server-backed preference. MQTT, bot, webhook, Apprise, and SQS configs are stored in the `fanout_configs` table, managed via `/api/fanout`. If the radio's channel slots appear unstable or another client is mutating them underneath this app, operators can force the old always-reconfigure send path with `MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE=true`.
 
 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.
 
@@ -459,3 +475,9 @@ Byte-perfect channel retries are user-triggered via `POST /api/messages/channel/
 The vendored MeshCore Python reader's `LOG_DATA` advert path assumes the decoded advert payload always contains at least 101 bytes of advert body and reads the flags byte with `pk_buf.read(1)[0]` without a length guard. If a malformed or truncated RF log frame slips through, `MessageReader.handle_rx()` can fail with `IndexError: index out of range` from `meshcore/reader.py` while parsing payload type `0x04` (advert).
 
 This does not indicate database corruption or a message-store bug. It is a parser-hardening gap in `meshcore_py`: the reader does not fully mirror firmware-side packet/path validation before attempting advert decode. The practical effect is usually a one-off asyncio task failure for that packet while later packets continue processing normally.
+
+### Channel-message dedup intentionally treats same-name/same-text/same-second channel sends as indistinguishable because they are
+
+Channel message storage deduplicates on `(type, conversation_key, text, sender_timestamp)`. Reviewers often flag this as "missing sender identity," but for channel messages the stored `text` already includes the displayed sender label (for example `Alice: hello`). That means two different users only collide when they produce the same rendered sender name, the same body text, and the same sender timestamp.
+
+In that case, RemoteTerm usually does not have enough information to distinguish "two independent same-name sends" from "one message observed again as an echo/repeat." Without a reliable sender identity at ingest, treating those packets as the same message is an accepted limitation of the observable data model, not an obvious correctness bug.

CHANGELOG.md

@@ -1,3 +1,76 @@
+## [3.5.0] - 2026-03-19
+
+Feature: Add room server alpha support
+Feature: Add option to force-reset node clock when it's too far ahead
+Feature: DMs auto-retry before resorting to flood
+Feature: Add impulse zero-hop advert
+Feature: Utilize PATH packets to correctly source a contact's route
+Feature: Metrics view on raw packet pane
+Feature: Metric, Imperial, and Smoots are now selectable for distance display
+Feature: Allow favorites to be sorted
+Feature: Add multi-ack support
+Feature: Password-remember checkbox on repeaters + room servers
+Bugfix: Serialize radio disconnect in a lock
+Bugfix: Fix contact bar layout issues
+Bugfix: Fix sidebar ordering for contacts by advert recency
+Bugfix: Fix version reporting in community MQTT
+Bugfix: Fix Apprise duplicate names
+Bugfix: Be better about identity resolution in the stats pane
+Misc: Docs, test, and performance enhancements
+Misc: Don't prompt "Are you sure" when leaving an unedited interation
+Misc: Log node time on startup
+Misc: Improve community MQTT error bubble-up
+Misc: Unread DMs always have a red unread counter
+Misc: Improve information in the debug view to show DB status
+
+## [3.4.1] - 2026-03-16
+
+Bugfix: Improve handling of version information on prebuilt bundles
+Bugfix: Improve frontend usability on disconnected radio
+Misc: Docs and readme updates
+Misc: Overhaul DM ingest and frontend state handling
+
+## [3.4.0] - 2026-03-16
+
+Feature: Add radio model and stats display
+Feature: Add prebuilt frontends, then deleted that and moved to prebuilt release artifacts
+Bugfix: Misc. frontend performance and correctness fixes
+Bugfix: Fix same-second same-content DM send collition
+Bugfix: Discard clearly-wrong GPS data
+Bugfix: Prevent repeater clock skew drift on page nav
+Misc: Use repeater's advertised location if we haven't loaded one from repeater admin
+Misc: Don't permit invalid fanout configs to be saved ever`
+
+## [3.3.0] - 2026-03-13
+
+Feature: Use dashed lines to show collapsed ambiguous router results
+Feature: Jump to unred
+Feature: Local channel management to prevent need to reload channel every time
+Feature: Debug endpoint
+Feature: Force-singleton channel management
+Feature: Local node discovery
+Feature: Node routing discovery
+Bugfix: Don't tell users to us npm ci
+Bugfix: Fallback polling dm message persistence
+Bugfix: All native-JS inputs are now modals
+Bugfix: Same-second send collision resolution
+Bugfix: Proper browser updates on resend
+Bugfix: Don't use last-heard when we actually want last-advert for path discovery for nodes
+Bugfix: Don't treat prefix-matching DM echoes as acks like we do for channel messages
+Misc: Visualizer data layer overhaul for future map work
+Misc: Parallelize docker tests
+
+## [3.2.0] - 2026-03-12
+
+Feature: Improve ambiguous-sender DM handling and visibility
+Feature: Allow for toggling of node GPS broadcast
+Feature: Add path width to bot and move example to full kwargs
+Feature: Improve node map color contrast
+Bugfix: More accurate tracking of contact data
+Bugfix: Misc. frontend performance and bugfixes
+Misc: Clearer warnings on user-key linkage
+Misc: Documentation improvements
+
 ## [3.1.1] - 2026-03-11
 
 Feature: Add basic auth

CONTRIBUTING.md

@@ -0,0 +1,108 @@
+# Contributing
+
+## Guiding Principles
+
+- In all your interactions with developers, maintainers, and users, be kind.
+- Prefer small, comprehensible changes over large sweeping ones. Individual commits should be meaningful atomic chunks of work. Pull requests with many, many commits instead of a phased approach may be declined.
+- Pull requests must be fully understood and explicitly endorsed by a human before merge. AI assistance is great, and this repo is optimized for it, but we keep quality by keeping our agents on track to write clear code, useful (not useless) tests, good architecture, and big-picture thinking.
+- No pull request should introduce new failing lint, typecheck, test, or build results.
+- Every pull request should have an associated issue or discussion thread; a brand new feature appearing first in a PR is an antipattern.
+- No truly automated radio traffic. Bot replies are already the practical edge of what this project wants to automate; any kind of traffic that would be intervalized or automated is not what this project is about.
+- No ingestion from the internet onto the mesh. This project is a radio client, not a bridge for outside traffic to enter the network. The mesh is strong because it is a radio mesh, not the internet with some weird wireless links.
+
+## Local Development
+
+### Backend
+
+```bash
+uv sync
+uv run uvicorn app.main:app --reload
+```
+
+With an explicit serial port:
+
+```bash
+MESHCORE_SERIAL_PORT=/dev/ttyUSB0 uv run uvicorn app.main:app --reload
+```
+
+On Windows (PowerShell):
+
+```powershell
+uv sync
+$env:MESHCORE_SERIAL_PORT="COM8"
+uv run uvicorn app.main:app --reload
+```
+
+### Frontend
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+Run both the backend and `npm run dev` for hot-reloading frontend development.
+
+## Quality Checks
+
+Run the full quality suite before proposing or handing off code changes:
+
+```bash
+./scripts/all_quality.sh
+```
+
+That runs linting, formatting, type checking, tests, and builds for both backend and frontend.
+
+If you need targeted commands while iterating:
+
+```bash
+# backend
+uv run ruff check app/ tests/ --fix
+uv run ruff format app/ tests/
+uv run pyright app/
+PYTHONPATH=. uv run pytest tests/ -v
+
+# frontend
+cd frontend
+npm run lint:fix
+npm run format
+npm run test:run
+npm run build
+```
+
+## E2E Testing
+
+E2E coverage exists, but it is intentionally not part of the normal development path.
+
+These tests are only guaranteed to run correctly in a narrow subset of environments; they require a busy mesh with messages arriving constantly, an available autodetect-able radio, and 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 # you can probably guess
+```
+
+## Pull Request Expectations
+
+- Keep scope tight.
+- Explain why the change is needed.
+- Link the issue or discussion where the behavior was agreed on.
+- Call out any follow-up work left intentionally undone.
+- Do not treat code review as the place where the app's direction is first introduced or debated
+
+## Notes For Agent-Assisted Work
+
+Before making non-trivial changes, read:
+
+- `./AGENTS.md`
+- `./app/AGENTS.md`
+- `./frontend/AGENTS.md`
+
+Read these only when working in those areas:
+
+- `./app/fanout/AGENTS_fanout.md`
+- `./frontend/src/components/visualizer/AGENTS_packet_visualizer.md`
+
+- Agent output is welcome, but human review is mandatory.
+- Agents should start with the AGENTS files above before making architectural changes.
+- If a change touches advanced areas like fanout or the visualizer, read the area-specific AGENTS file before editing.

Dockerfile

@@ -15,8 +15,12 @@ RUN VITE_COMMIT_HASH=${COMMIT_HASH} npm run build
 # Stage 2: Python runtime
 FROM python:3.12-slim
 
+ARG COMMIT_HASH=unknown
+
 WORKDIR /app
 
+ENV COMMIT_HASH=${COMMIT_HASH}
+
 # Install uv
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 

LICENSES.md

@@ -330,7 +330,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
 </details>
 
-### meshcore (2.2.29) — MIT
+### meshcore (2.3.1) — MIT
 
 <details>
 <summary>Full license text</summary>

README.md

@@ -8,8 +8,8 @@ Backend server + browser interface for MeshCore mesh radio networks. Connect you
 * Monitor unlimited contacts and channels (radio limits don't apply -- packets are decrypted server-side)
 * Access your radio remotely over your network or VPN
 * 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)
-* Use the more recent 1.14 firmwares which support multibyte pathing in all traffic and display systems within the app
+* Forward packets to MQTT, LetsMesh, MeshRank, SQS, Apprise, etc.
+* Use the more recent 1.14 firmwares which support multibyte pathing
 * Visualize the mesh as a map or node set, view repeater stats, and more!
 
 **Warning:** This app is for trusted environments only. _Do not put this on an untrusted network, or open it to the public._ You can optionally set `MESHCORE_BASIC_AUTH_USERNAME` and `MESHCORE_BASIC_AUTH_PASSWORD` for app-wide HTTP Basic auth, but that is only a coarse gate and must be paired with HTTPS. The bots can execute arbitrary Python code which means anyone who gets access to the app 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 stronger access control, consider using a reverse proxy like Nginx, or extending FastAPI; full access control and user management are outside the scope of this app.
@@ -22,13 +22,27 @@ This is developed with very heavy agentic assistance -- there is no warranty of
 
 If extending, have your LLM read the three `AGENTS.md` files: `./AGENTS.md`, `./frontend/AGENTS.md`, and `./app/AGENTS.md`.
 
+## Start Here
+
+Most users should choose one of these paths:
+
+1. Clone and build from source.
+2. Download the prebuilt release zip if you are on a resource-constrained system and do not want to build the frontend locally.
+3. Use Docker if that better matches how you deploy.
+
+For advanced setup, troubleshooting, HTTPS, systemd service setup, and remediation environment variables, see [README_ADVANCED.md](README_ADVANCED.md).
+
+If you plan to contribute, read [CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## Requirements
 
 - Python 3.10+
-- Node.js LTS or current (20, 22, 24, 25)
+- Node.js LTS or current (20, 22, 24, 25) if you're not using a prebuilt release
 - [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
 
+If you are on a low-resource system and do not want to build the frontend locally, download the release zip named `remoteterm-prebuilt-frontend-vX.X.X-<short hash>.zip`. That bundle includes `frontend/prebuilt`, so you can run the app without doing a frontend build from source.
+
 <details>
 <summary>Finding your serial port</summary>
 
@@ -65,7 +79,7 @@ usbipd attach --wsl --busid 3-8
 ```
 </details>
 
-## Quick Start
+## Path 1: Clone And Build
 
 **This approach is recommended over Docker due to intermittent serial communications issues I've seen on \*nix systems.**
 
@@ -73,43 +87,33 @@ usbipd attach --wsl --busid 3-8
 git clone https://github.com/jkingsman/Remote-Terminal-for-MeshCore.git
 cd Remote-Terminal-for-MeshCore
 
-# Install backend dependencies
 uv sync
+cd frontend && npm install && npm run build && cd ..
 
-# Build frontend
-cd frontend && npm ci && npm run build && cd ..
-
-# Run server
 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
 ```
 
-The server auto-detects the serial port. To specify a transport manually:
+Access the app at http://localhost:8000.
+
+Source checkouts expect a normal frontend build in `frontend/dist`.
+
+## Path 1.5: Use The Prebuilt Release Zip
+
+Release zips can be found as an asset within the [releases listed here](https://github.com/jkingsman/Remote-Terminal-for-MeshCore/releases). This can be beneficial on resource constrained systems that cannot cope with the RAM-hungry frontend build process.
+
+If you downloaded the release zip instead of cloning the repo, unpack it and run:
+
 ```bash
-# Serial (explicit port)
-MESHCORE_SERIAL_PORT=/dev/ttyUSB0 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
-
-# TCP (e.g. via wifi-enabled firmware)
-MESHCORE_TCP_HOST=192.168.1.100 MESHCORE_TCP_PORT=4000 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
-
-# BLE (address and PIN both required)
-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
+cd Remote-Terminal-for-MeshCore
+uv sync
 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
 ```
 
-Access at http://localhost:8000
+The release bundle includes `frontend/prebuilt`, so it does not require a local frontend build.
 
-> **Note:** WebGPU cracking requires HTTPS when not on localhost. See the HTTPS section under Additional Setup.
+## Path 2: 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.
+> **Warning:** Docker has had reports intermittent issues with serial event subscriptions. The native method above is more reliable.
 
 Edit `docker-compose.yaml` to set a serial device for passthrough, or uncomment your transport (serial or TCP). Then:
 
@@ -142,7 +146,7 @@ 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.
+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 serial 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:
 
@@ -150,68 +154,9 @@ To stop:
 docker compose down
 ```
 
-## Development
+## Standard Environment Variables
 
-### Backend
-
-```bash
-uv sync
-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
-cd frontend
-npm ci
-npm run dev      # Dev server at http://localhost:5173 (proxies API to :8000)
-npm run build    # Production build to dist/
-```
-
-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 backend, and a lint + autoformat on the frontend.
-
-Run everything at once:
-
-```bash
-./scripts/all_quality.sh
-```
-
-<details>
-<summary>Or run individual checks</summary>
-
-```bash
-# python
-uv run ruff check app/ tests/ --fix  # lint + auto-fix
-uv run ruff format app/ tests/       # format (always writes)
-uv run pyright app/                  # type checking
-PYTHONPATH=. uv run pytest tests/ -v # backend tests
-
-# frontend
-cd frontend
-npm run lint:fix                     # esLint + auto-fix
-npm run test:run                     # run tests
-npm run format                       # prettier (always writes)
-npm run build                        # build the frontend
-```
-</details>
-
-## Configuration
+Only one transport may be active at a time. If multiple are set, the server will refuse to start.
 
 | Variable | Default | Description |
 |----------|---------|-------------|
@@ -221,127 +166,36 @@ npm run build                        # build the frontend
 | `MESHCORE_TCP_PORT` | 4000 | TCP port |
 | `MESHCORE_BLE_ADDRESS` | | BLE device address (mutually exclusive with serial/TCP) |
 | `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_DISABLE_BOTS` | false | Disable bot system entirely (blocks execution and config) |
-| `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK` | false | Run aggressive 10-second `get_msg()` fallback polling instead of the default hourly audit task |
+| `MESHCORE_LOG_LEVEL` | INFO | `DEBUG`, `INFO`, `WARNING`, `ERROR` |
+| `MESHCORE_DATABASE_PATH` | `data/meshcore.db` | SQLite database path |
+| `MESHCORE_DISABLE_BOTS` | false | Disable bot system entirely (blocks execution and config; an intermediate security precaution, but not as good as basic auth) |
 | `MESHCORE_BASIC_AUTH_USERNAME` | | Optional app-wide HTTP Basic auth username; must be set together with `MESHCORE_BASIC_AUTH_PASSWORD` |
 | `MESHCORE_BASIC_AUTH_PASSWORD` | | Optional app-wide HTTP Basic auth password; must be set together with `MESHCORE_BASIC_AUTH_USERNAME` |
 
-Only one transport may be active at a time. If multiple are set, the server will refuse to start.
+Common launch patterns:
+
+```bash
+# Serial (explicit port)
+MESHCORE_SERIAL_PORT=/dev/ttyUSB0 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
+
+# TCP
+MESHCORE_TCP_HOST=192.168.1.100 MESHCORE_TCP_PORT=4000 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
+
+# BLE
+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
+```
 
 If you enable Basic Auth, protect the app with HTTPS. HTTP Basic credentials are not safe on plain HTTP.
 
-By default the app relies on radio events plus MeshCore auto-fetch for incoming messages, and also runs a low-frequency hourly audit poll. If that audit ever finds radio data that was not surfaced through event subscription, the backend logs an error and the UI shows a toast telling the operator to check the logs. If you see that warning, or if messages on the radio never show up in the app, try `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK=true` to switch that task into a more aggressive 10-second `get_msg()` safety net.
+## Where To Go Next
 
-## Additional Setup
-
-<details>
-<summary>HTTPS (Required for WebGPU room-finding outside localhost)</summary>
-
-WebGPU requires a secure context. When not on `localhost`, serve over HTTPS:
-
-```bash
-openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'
-uv run uvicorn app.main:app --host 0.0.0.0 --port 8000 --ssl-keyfile=key.pem --ssl-certfile=cert.pem
-```
-
-For Docker Compose, generate the cert and add the volume mounts and command override to `docker-compose.yaml`:
-
-```bash
-# generate snakeoil TLS cert
-openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'
-```
-
-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.
-</details>
-
-<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
-
-# Install to /opt/remoteterm
-sudo mkdir -p /opt/remoteterm
-sudo cp -r . /opt/remoteterm/
-sudo chown -R remoteterm:remoteterm /opt/remoteterm
-
-# Install dependencies
-cd /opt/remoteterm
-sudo -u remoteterm uv venv
-sudo -u remoteterm uv sync
-
-# Build frontend (required for the backend to serve the web UI)
-cd /opt/remoteterm/frontend
-sudo -u remoteterm npm ci
-sudo -u remoteterm npm run build
-
-# Install and start service
-sudo cp /opt/remoteterm/remoteterm.service /etc/systemd/system/
-sudo systemctl daemon-reload
-sudo systemctl enable --now remoteterm
-
-# Check status
-sudo systemctl status remoteterm
-sudo journalctl -u remoteterm -f
-```
-
-Edit `/etc/systemd/system/remoteterm.service` to set `MESHCORE_SERIAL_PORT` if needed.
-</details>
-
-<details>
-<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.
+- Advanced setup, troubleshooting, HTTPS, systemd, remediation variables, and debug logging: [README_ADVANCED.md](README_ADVANCED.md)
+- Contributing, tests, linting, E2E notes, and important AGENTS files: [CONTRIBUTING.md](CONTRIBUTING.md)
+- Live API docs after the backend is running: http://localhost:8000/docs

README_ADVANCED.md

@@ -0,0 +1,118 @@
+# Advanced Setup And Troubleshooting
+
+## Remediation Environment Variables
+
+These are intended for diagnosing or working around radios that behave oddly.
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK` | false | Run aggressive 10-second `get_msg()` fallback polling to check for messages |
+| `MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE` | false | Disable channel-slot reuse and force `set_channel(...)` before every channel send |
+| `__CLOWNTOWN_DO_CLOCK_WRAPAROUND` | false | Highly experimental: if the radio clock is ahead of system time, try forcing the clock to `0xFFFFFFFF`, wait for uint32 wraparound, and then retry normal time sync before falling back to reboot |
+
+By default the app relies on radio events plus MeshCore auto-fetch for incoming messages, and also runs a low-frequency hourly audit poll. That audit checks both:
+
+- whether messages were left on the radio without reaching the app through event subscription
+- whether the app's channel-slot expectations still match the radio's actual channel listing
+
+If the audit finds a mismatch, you'll see an error in the application UI and your logs. If you see that warning, or if messages on the radio never show up in the app, try `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK=true` to switch that task into a more aggressive 10-second safety net. If room sends appear to be using the wrong channel slot or another client is changing slots underneath this app, try `MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE=true` to force the radio to validate the channel slot is valid before sending (will delay sending by ~500ms).
+
+`__CLOWNTOWN_DO_CLOCK_WRAPAROUND=true` is a last-resort clock remediation for nodes whose RTC is stuck in the future and where rescue-mode time setting or GPS-based time is not available. It intentionally relies on the clock rolling past the 32-bit epoch boundary, which is board-specific behavior and may not be safe or effective on all MeshCore targets. Treat it as highly experimental.
+
+## HTTPS
+
+WebGPU room-finding requires a secure context when you are not on `localhost`.
+
+Generate a local cert and start the backend with TLS:
+
+```bash
+openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'
+uv run uvicorn app.main:app --host 0.0.0.0 --port 8000 --ssl-keyfile=key.pem --ssl-certfile=cert.pem
+```
+
+For Docker Compose, generate the cert, mount it into the container, and override the launch command:
+
+```yaml
+services:
+  remoteterm:
+    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.
+
+## Systemd Service
+
+Assumes you are running from `/opt/remoteterm`; adjust paths if you deploy elsewhere.
+
+```bash
+# Create service user
+sudo useradd -r -m -s /bin/false remoteterm
+
+# Install to /opt/remoteterm
+sudo mkdir -p /opt/remoteterm
+sudo cp -r . /opt/remoteterm/
+sudo chown -R remoteterm:remoteterm /opt/remoteterm
+
+# Install dependencies
+cd /opt/remoteterm
+sudo -u remoteterm uv venv
+sudo -u remoteterm uv sync
+
+# If deploying from a source checkout, build the frontend first
+sudo -u remoteterm bash -lc 'cd /opt/remoteterm/frontend && npm install && npm run build'
+
+# If deploying from the release zip artifact, frontend/prebuilt is already present
+```
+
+Create `/etc/systemd/system/remoteterm.service` with:
+
+```ini
+[Unit]
+Description=RemoteTerm for MeshCore
+After=network.target
+
+[Service]
+Type=simple
+User=remoteterm
+Group=remoteterm
+WorkingDirectory=/opt/remoteterm
+ExecStart=/opt/remoteterm/.venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8000
+Restart=always
+RestartSec=5
+Environment=MESHCORE_DATABASE_PATH=/opt/remoteterm/data/meshcore.db
+# Uncomment and set if auto-detection doesn't work:
+# Environment=MESHCORE_SERIAL_PORT=/dev/ttyUSB0
+SupplementaryGroups=dialout
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Then install and start it:
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable --now remoteterm
+sudo systemctl status remoteterm
+sudo journalctl -u remoteterm -f
+```
+
+## Debug Logging And 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.
+
+```bash
+MESHCORE_LOG_LEVEL=DEBUG uv run uvicorn app.main:app --host 0.0.0.0 --port 8000
+```
+
+You can also navigate to `/api/debug` (or go to Settings -> About -> "Open debug support snapshot" at the bottom). This debug block contains information about the operating environment, expectations around keys and channels, and radio status. It also includes the most recent logs. **Non-log information reveals no keys, channel names, or other privilege information beyond the names of your bots. The logs, however, may contain channel names or keys (but never your private key).** If you do not wish to include this information, copy up to the `STOP COPYING HERE` marker in the debug body.
+
+## Development Notes
+
+For day-to-day development, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+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.

app/AGENTS.md

@@ -32,6 +32,7 @@ app/
 ├── services/            # Shared orchestration/domain services
 │   ├── messages.py              # Shared message creation, dedup, ACK application
 │   ├── message_send.py          # Direct send, channel send, resend workflows
+│   ├── dm_ingest.py             # Shared direct-message ingest / dedup seam for packet + fallback paths
 │   ├── dm_ack_tracker.py        # Pending DM ACK state
 │   ├── contact_reconciliation.py # Prefix-claim, sender-key backfill, name-history wiring
 │   ├── radio_lifecycle.py       # Post-connect setup and reconnect/setup helpers
@@ -48,10 +49,12 @@ app/
 ├── fanout/              # Fanout bus: MQTT, bots, webhooks, Apprise, SQS (see fanout/AGENTS_fanout.md)
 ├── dependencies.py      # Shared FastAPI dependency providers
 ├── path_utils.py        # Path hex rendering and hop-width helpers
+├── region_scope.py      # Normalize/validate regional flood-scope values
 ├── keystore.py          # Ephemeral private/public key storage for DM decryption
 ├── frontend_static.py   # Mount/serve built frontend (production)
 └── routers/
     ├── health.py
+    ├── debug.py
     ├── radio.py
     ├── contacts.py
     ├── channels.py
@@ -72,7 +75,7 @@ app/
 1. Radio emits events.
 2. `on_rx_log_data` stores raw packet and tries decrypt/pipeline handling.
 3. Shared message-domain services create/update `messages` and shape WS payloads.
-4. `CONTACT_MSG_RECV` is a fallback DM path when packet pipeline cannot decrypt.
+4. Direct-message storage is centralized in `services/dm_ingest.py`; packet-processor DMs and `CONTACT_MSG_RECV` fallback events both route through that seam.
 
 ### Outgoing messages
 
@@ -88,7 +91,7 @@ app/
 - `RadioManager.post_connect_setup()` delegates to `services/radio_lifecycle.py`.
 - Routers, startup/lifespan code, fanout helpers, and `radio_sync.py` should reach radio state through `services/radio_runtime.py`, not by importing `app.radio.radio_manager` directly.
 - Shared reconnect/setup helpers in `services/radio_lifecycle.py` are used by startup, the monitor, and manual reconnect/reboot flows before broadcasting healthy state.
-- Setup still includes handler registration, key export, time sync, contact/channel sync, and advertisement tasks. The message-poll task always starts: by default it runs as a low-frequency hourly audit, and `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK=true` switches it to aggressive 10-second polling.
+- Setup still includes handler registration, key export, time sync, contact/channel sync, and advertisement tasks. The message-poll task always starts: by default it runs as a low-frequency hourly audit, and `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK=true` switches it to aggressive 10-second polling. That audit checks both missed-radio-message drift and channel-slot cache drift; cache mismatches are logged, toasted, and the send-slot cache is reset.
 - Post-connect setup is timeout-bounded. If initial radio offload/setup hangs too long, the backend logs the failure and broadcasts an `error` toast telling the operator to reboot the radio and restart the server.
 
 ## Important Behaviors
@@ -97,19 +100,37 @@ app/
 
 - Packet `path_len` values are hop counts, not byte counts.
 - Hop width comes from the packet or radio `path_hash_mode`: `0` = 1-byte, `1` = 2-byte, `2` = 3-byte.
-- Contacts persist `out_path_hash_mode` in the database so contact sync and outbound DM routing reuse the exact stored mode instead of inferring from path bytes.
-- Contacts may also persist `route_override_path`, `route_override_len`, and `route_override_hash_mode`. `Contact.to_radio_dict()` gives these override fields precedence over learned `last_path*`, while advert processing still updates the learned route for telemetry/fallback.
+- Channel slot count comes from firmware-reported `DEVICE_INFO.max_channels`; do not hardcode `40` when scanning/offloading channel slots.
+- Channel sends use a session-local LRU slot cache after startup channel offload clears the radio. Repeated sends to the same room reuse the loaded slot; new rooms fill free slots up to the discovered channel capacity, then evict the least recently used cached room.
+- TCP radios do not reuse cached slot contents. For TCP, channel sends still force `set_channel(...)` before every send because this backend does not have exclusive device access.
+- `MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE=true` disables slot reuse on all transports and forces the old always-`set_channel(...)` behavior before every channel send.
+- Contacts persist canonical direct-route fields (`direct_path`, `direct_path_len`, `direct_path_hash_mode`) so contact sync and outbound DM routing reuse the exact stored hop width instead of inferring from path bytes.
+- Direct-route sources are limited to radio contact sync (`out_path`) and PATH/path-discovery updates. This mirrors firmware `onContactPathRecv(...)`, which replaces `ContactInfo.out_path` when a new returned path is heard.
+- `route_override_path`, `route_override_len`, and `route_override_hash_mode` take precedence over the learned direct route for radio-bound sends.
+- Advertisement paths are stored only in `contact_advert_paths` for analytics/visualization. They are not part of `Contact.to_radio_dict()` or DM route selection.
 - `contact_advert_paths` identity is `(public_key, path_hex, path_len)` because the same hex bytes can represent different routes at different hop widths.
 
 ### Read/unread state
 
 - Server is source of truth (`contacts.last_read_at`, `channels.last_read_at`).
-- `GET /api/read-state/unreads` returns counts, mention flags, and `last_message_times`.
+- `GET /api/read-state/unreads` returns counts, mention flags, `last_message_times`, and `last_read_ats`.
+
+### DM ingest + ACKs
+
+- `services/dm_ingest.py` is the one place that should decide fallback-context resolution, DM dedup/reconciliation, and packet-linked vs. content-based storage behavior.
+- `CONTACT_MSG_RECV` is a fallback path, not a parallel source of truth. If you change DM storage behavior, trace both `event_handlers.py` and `packet_processor.py`.
+- DM ACK tracking is an in-memory pending/buffered map in `services/dm_ack_tracker.py`, with periodic expiry from `radio_sync.py`.
+- Outgoing DMs send once inline, store/broadcast immediately after the first successful `MSG_SENT`, then may retry up to 2 more times in the background only when the initial `MSG_SENT` result includes an expected ACK code and the message remains unacked.
+- DM retry timing follows the firmware-provided `suggested_timeout` from `PACKET_MSG_SENT`; do not replace it with a fixed app timeout unless you intentionally want more aggressive duplicate-prone retries.
+- Direct-message send behavior is intended to emulate `meshcore_py.commands.send_msg_with_retry(...)` when the radio provides an expected ACK code: stage the effective contact route on the radio, send, wait for ACK, and on the final retry force flood via `reset_path(...)`.
+- Non-final DM attempts use the contact's effective route (`override > direct > flood`). The final retry is intentionally sent as flood even when a routing override exists.
+- DM ACK state is terminal on first ACK. Retry attempts may register multiple expected ACK codes for the same message, but sibling pending codes are cleared once one ACK wins so a DM should not accrue multiple delivery confirmations from retries.
+- ACKs are delivery state, not routing state. Bundled ACKs inside PATH packets still satisfy pending DM sends, but ACK history does not feed contact route learning.
 
 ### Echo/repeat dedup
 
 - Message uniqueness: `(type, conversation_key, text, sender_timestamp)`.
-- 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.
+- Duplicate insert is treated as an echo/repeat: the new path (if any) is appended, and the ACK count is incremented only for outgoing channel messages. Incoming direct messages with the same conversation/text/sender timestamp also collapse onto one stored row, with later observations merging path data instead of creating a second DM.
 
 ### Raw packet dedup policy
 
@@ -144,34 +165,36 @@ app/
 ### Health
 - `GET /health`
 
+### Debug
+- `GET /debug` — support snapshot with recent logs, live radio probe, slot/contact audits, and version/git info
+
 ### Radio
-- `GET /radio/config` — includes `path_hash_mode` and `path_hash_mode_supported`
-- `PATCH /radio/config` — may update `path_hash_mode` (`0..2`) when firmware supports it
+- `GET /radio/config` — includes `path_hash_mode`, `path_hash_mode_supported`, advert-location on/off, and `multi_acks_enabled`
+- `PATCH /radio/config` — may update `path_hash_mode` (`0..2`) when firmware supports it, and `multi_acks_enabled`
 - `PUT /radio/private-key`
-- `POST /radio/advertise`
+- `POST /radio/advertise` — manual advert send; request body may set `mode` to `flood` or `zero_hop` (defaults to `flood`)
+- `POST /radio/discover` — short mesh discovery sweep for nearby repeaters/sensors
+- `POST /radio/disconnect`
 - `POST /radio/reboot`
 - `POST /radio/reconnect`
 
 ### Contacts
 - `GET /contacts`
+- `GET /contacts/analytics` — unified keyed-or-name analytics payload
 - `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}/command`
 - `POST /contacts/{public_key}/routing-override`
 - `POST /contacts/{public_key}/trace`
+- `POST /contacts/{public_key}/path-discovery` — discover forward/return paths, persist the learned direct route, and sync it back to the radio best-effort
 - `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/node-info`
 - `POST /contacts/{public_key}/repeater/radio-settings`
 - `POST /contacts/{public_key}/repeater/advert-intervals`
 - `POST /contacts/{public_key}/repeater/owner-info`
@@ -179,10 +202,8 @@ app/
 ### Channels
 - `GET /channels`
 - `GET /channels/{key}/detail`
-- `GET /channels/{key}`
 - `POST /channels`
 - `DELETE /channels/{key}`
-- `POST /channels/sync`
 - `POST /channels/{key}/flood-scope-override`
 - `POST /channels/{key}/mark-read`
 
@@ -199,7 +220,7 @@ app/
 - `POST /packets/maintenance`
 
 ### Read state
-- `GET /read-state/unreads`
+- `GET /read-state/unreads` — counts, mention flags, `last_message_times`, and `last_read_ats`
 - `POST /read-state/mark-all-read`
 
 ### Settings
@@ -226,6 +247,7 @@ app/
 
 - `health` — radio connection status (broadcast on change, personal on connect)
 - `contact` — single contact upsert (from advertisements and radio sync)
+- `contact_resolved` — prefix contact reconciled to a full contact row (payload: `{ previous_public_key, contact }`)
 - `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)
@@ -241,7 +263,7 @@ Client sends `"ping"` text; server replies `{"type":"pong"}`.
 ## Data Model Notes
 
 Main tables:
-- `contacts` (includes `first_seen` for contact age tracking and `out_path_hash_mode` for route round-tripping)
+- `contacts` (includes `first_seen` for contact age tracking and `direct_path_hash_mode` / `route_override_*` for DM routing)
 - `channels`
   Includes optional `flood_scope_override` for channel-specific regional sends.
 - `messages` (includes `sender_name`, `sender_key` for per-contact channel message attribution)
@@ -250,6 +272,13 @@ Main tables:
 - `contact_name_history` (tracks name changes over time)
 - `app_settings`
 
+Contact route state is canonicalized on the backend:
+- stored route inputs: `direct_path`, `direct_path_len`, `direct_path_hash_mode`, `direct_path_updated_at`, plus optional `route_override_*`
+- computed route surface: `effective_route`, `effective_route_source`, `direct_route`, `route_override`
+- removed legacy names: `last_path`, `last_path_len`, `out_path_hash_mode`
+
+Frontend and send paths should consume the canonical route surface rather than reconstructing precedence from raw fields.
+
 Repository writes should prefer typed models such as `ContactUpsert` over ad hoc dict payloads when adding or updating schema-coupled data.
 
 `max_radio_contacts` is the configured radio contact capacity baseline. Favorites reload first, the app refills non-favorite working-set contacts to about 80% of that capacity, and periodic offload triggers once occupancy reaches about 95%.
@@ -266,11 +295,13 @@ Repository writes should prefer typed models such as `ContactUpsert` over ad hoc
 - `flood_scope`
 - `blocked_keys`, `blocked_names`
 
+Note: `sidebar_sort_order` remains in the backend model for compatibility and migration, but the current frontend sidebar uses per-section localStorage sort preferences instead of a single shared server-backed sort mode.
+
 Note: MQTT, community MQTT, and bot configs were migrated to the `fanout_configs` table (migrations 36-38).
 
 ## Security Posture (intentional)
 
-- No authn/authz.
+- No per-user authn/authz model; optionally, operators may enable app-wide HTTP Basic auth for both HTTP and WS entrypoints.
 - No CORS restriction (`*`).
 - Bot code executes user-provided Python via `exec()`.
 
@@ -293,16 +324,20 @@ tests/
 ├── test_api.py                 # REST endpoint integration tests
 ├── test_bot.py                 # Bot execution and sandboxing
 ├── test_channels_router.py     # Channels router endpoints
+├── test_channel_sender_backfill.py # Sender-key backfill uniqueness rules for channel messages
 ├── test_config.py              # Configuration validation
+├── test_contact_reconciliation_service.py # Prefix/contact reconciliation service helpers
 ├── 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_fanout_hitlist.py      # Fanout-related hitlist regression 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_http_quality.py        # Cache-control / gzip / basic-auth HTTP quality checks
 ├── test_key_normalization.py   # Public key normalization
 ├── test_keystore.py            # Ephemeral keystore
 ├── test_message_pagination.py  # Cursor-based message pagination
@@ -315,6 +350,7 @@ tests/
 ├── test_radio.py               # RadioManager, serial detection
 ├── test_radio_commands_service.py # Radio config/private-key service workflows
 ├── test_radio_lifecycle_service.py # Reconnect/setup orchestration helpers
+├── test_radio_runtime_service.py # radio_runtime seam behavior and helpers
 ├── test_real_crypto.py         # Real cryptographic operations
 ├── test_radio_operation.py     # radio_operation() context manager
 ├── test_radio_router.py        # Radio router endpoints
@@ -324,11 +360,10 @@ tests/
 ├── 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_security.py            # Optional Basic Auth middleware / config behavior
 ├── test_send_messages.py       # Outgoing messages, bot triggers, concurrent sends
 ├── test_settings_router.py     # Settings endpoints, advert validation
 ├── test_statistics.py          # Statistics aggregation
-├── test_channel_sender_backfill.py # Sender key backfill for channel messages
-├── test_fanout_hitlist.py      # Fanout-related hitlist regression tests
 ├── test_main_startup.py        # App startup and lifespan
 ├── test_path_utils.py          # Path hex rendering helpers
 ├── test_websocket.py           # WS manager broadcast/cleanup
@@ -341,7 +376,7 @@ tests/
 
 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")`.
+**Consequence:** Message dedup still operates at 1-second granularity because the radio protocol only provides second-resolution `sender_timestamp`. 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")`. Incoming DMs now share the same second-resolution content identity tradeoff as channel echoes: same-contact same-text same-second observations collapse onto one stored row.
 
 ### Outgoing DM echoes remain undecrypted
 

app/channel_constants.py

@@ -0,0 +1,10 @@
+PUBLIC_CHANNEL_KEY = "8B3387E9C5CDEA6AC9E5EDBAA115CD72"
+PUBLIC_CHANNEL_NAME = "Public"
+
+
+def is_public_channel_key(key: str) -> bool:
+    return key.upper() == PUBLIC_CHANNEL_KEY
+
+
+def is_public_channel_name(name: str) -> bool:
+    return name.casefold() == PUBLIC_CHANNEL_NAME.casefold()

app/config.py

@@ -1,8 +1,10 @@
 import logging
 import logging.config
+from collections import deque
+from threading import Lock
 from typing import Literal
 
-from pydantic import model_validator
+from pydantic import Field, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -19,6 +21,11 @@ class Settings(BaseSettings):
     database_path: str = "data/meshcore.db"
     disable_bots: bool = False
     enable_message_poll_fallback: bool = False
+    force_channel_slot_reconfigure: bool = False
+    clowntown_do_clock_wraparound: bool = Field(
+        default=False,
+        validation_alias="__CLOWNTOWN_DO_CLOCK_WRAPAROUND",
+    )
     basic_auth_username: str = ""
     basic_auth_password: str = ""
 
@@ -66,6 +73,47 @@ class Settings(BaseSettings):
 settings = Settings()
 
 
+class _RingBufferLogHandler(logging.Handler):
+    """Keep a bounded in-memory tail of formatted log lines."""
+
+    def __init__(self, max_lines: int = 1000) -> None:
+        super().__init__()
+        self._buffer: deque[str] = deque(maxlen=max_lines)
+        self._lock = Lock()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            line = self.format(record)
+        except Exception:
+            self.handleError(record)
+            return
+        with self._lock:
+            self._buffer.append(line)
+
+    def get_lines(self, limit: int = 1000) -> list[str]:
+        with self._lock:
+            if limit <= 0:
+                return []
+            return list(self._buffer)[-limit:]
+
+    def clear(self) -> None:
+        with self._lock:
+            self._buffer.clear()
+
+
+_recent_log_handler = _RingBufferLogHandler(max_lines=1000)
+
+
+def get_recent_log_lines(limit: int = 1000) -> list[str]:
+    """Return recent formatted log lines from the in-memory ring buffer."""
+    return _recent_log_handler.get_lines(limit)
+
+
+def clear_recent_log_lines() -> None:
+    """Clear the in-memory log ring buffer."""
+    _recent_log_handler.clear()
+
+
 class _RepeatSquelch(logging.Filter):
     """Suppress rapid-fire identical messages and emit a summary instead.
 
@@ -151,6 +199,19 @@ def setup_logging() -> None:
             },
         }
     )
+
+    _recent_log_handler.setLevel(logging.DEBUG)
+    _recent_log_handler.setFormatter(
+        logging.Formatter(
+            fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    )
+    for logger_name in ("", "uvicorn", "uvicorn.error", "uvicorn.access"):
+        target = logging.getLogger(logger_name)
+        if _recent_log_handler not in target.handlers:
+            target.addHandler(_recent_log_handler)
+
     # 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

@@ -13,9 +13,10 @@ CREATE TABLE IF NOT EXISTS contacts (
     name TEXT,
     type INTEGER DEFAULT 0,
     flags INTEGER DEFAULT 0,
-    last_path TEXT,
-    last_path_len INTEGER DEFAULT -1,
-    out_path_hash_mode INTEGER DEFAULT 0,
+    direct_path TEXT,
+    direct_path_len INTEGER,
+    direct_path_hash_mode INTEGER,
+    direct_path_updated_at INTEGER,
     route_override_path TEXT,
     route_override_len INTEGER,
     route_override_hash_mode INTEGER,
@@ -25,7 +26,8 @@ CREATE TABLE IF NOT EXISTS contacts (
     last_seen INTEGER,
     on_radio INTEGER DEFAULT 0,
     last_contacted INTEGER,
-    first_seen INTEGER
+    first_seen INTEGER,
+    last_read_at INTEGER
 );
 
 CREATE TABLE IF NOT EXISTS channels (
@@ -33,7 +35,8 @@ CREATE TABLE IF NOT EXISTS channels (
     name TEXT NOT NULL,
     is_hashtag INTEGER DEFAULT 0,
     on_radio INTEGER DEFAULT 0,
-    flood_scope_override TEXT
+    flood_scope_override TEXT,
+    last_read_at INTEGER
 );
 
 CREATE TABLE IF NOT EXISTS messages (
@@ -50,10 +53,9 @@ CREATE TABLE IF NOT EXISTS messages (
     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.
+    -- Deduplication: channel echoes/repeats use a content/time unique index so
+    -- duplicate observations reconcile onto a single stored row. Legacy
+    -- databases may also gain an incoming-DM content index via migration 44.
     -- 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.
 );
@@ -91,11 +93,13 @@ CREATE TABLE IF NOT EXISTS contact_name_history (
 
 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));
+    ON messages(type, conversation_key, text, COALESCE(sender_timestamp, 0))
+    WHERE type = 'CHAN';
 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)
+-- idx_messages_incoming_priv_dedup is created by migration 44 after legacy rows are reconciled
 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

app/decoder.py

@@ -58,6 +58,28 @@ class DecryptedDirectMessage:
     message: str
     dest_hash: str  # First byte of destination pubkey as hex
     src_hash: str  # First byte of sender pubkey as hex
+    signed_sender_prefix: str | None = None
+
+    @property
+    def txt_type(self) -> int:
+        return self.flags >> 2
+
+    @property
+    def attempt(self) -> int:
+        return self.flags & 0x03
+
+
+@dataclass
+class DecryptedPathPayload:
+    """Result of decrypting a PATH payload."""
+
+    dest_hash: str
+    src_hash: str
+    returned_path: bytes
+    returned_path_len: int
+    returned_path_hash_mode: int
+    extra_type: int
+    extra: bytes
 
 
 @dataclass
@@ -85,13 +107,8 @@ class PacketInfo:
     path_hash_size: int = 1  # Bytes per hop: 1, 2, or 3
 
 
-def calculate_channel_hash(channel_key: bytes) -> str:
-    """
-    Calculate the channel hash from a 16-byte channel key.
-    Returns the first byte of SHA256(key) as hex.
-    """
-    hash_bytes = hashlib.sha256(channel_key).digest()
-    return format(hash_bytes[0], "02x")
+def _is_valid_advert_location(lat: float, lon: float) -> bool:
+    return -90 <= lat <= 90 and -180 <= lon <= 180
 
 
 def extract_payload(raw_packet: bytes) -> bytes | None:
@@ -233,7 +250,7 @@ def try_decrypt_packet_with_channel_key(
         return None
 
     packet_channel_hash = format(packet_info.payload[0], "02x")
-    expected_hash = calculate_channel_hash(channel_key)
+    expected_hash = format(hashlib.sha256(channel_key).digest()[0], "02x")
 
     if packet_channel_hash != expected_hash:
         return None
@@ -252,7 +269,9 @@ def get_packet_payload_type(raw_packet: bytes) -> PayloadType | None:
         return None
 
 
-def parse_advertisement(payload: bytes) -> ParsedAdvertisement | None:
+def parse_advertisement(
+    payload: bytes, raw_packet: bytes | None = None
+) -> ParsedAdvertisement | None:
     """
     Parse an advertisement payload.
 
@@ -308,6 +327,16 @@ def parse_advertisement(payload: bytes) -> ParsedAdvertisement | None:
         lon_raw = int.from_bytes(payload[offset + 4 : offset + 8], byteorder="little", signed=True)
         lat = lat_raw / 1_000_000
         lon = lon_raw / 1_000_000
+        if not _is_valid_advert_location(lat, lon):
+            packet_hex = (raw_packet if raw_packet is not None else payload).hex().upper()
+            logger.warning(
+                "Dropping location data for nonsensical packet -- packet %s implies lat/lon %s/%s. Outta this world!",
+                packet_hex,
+                lat,
+                lon,
+            )
+            lat = None
+            lon = None
         offset += 8
 
     # Skip feature fields if present
@@ -478,6 +507,13 @@ def decrypt_direct_message(payload: bytes, shared_secret: bytes) -> DecryptedDir
 
     # Extract message text (UTF-8, null-padded)
     message_bytes = decrypted[5:]
+    signed_sender_prefix: str | None = None
+    txt_type = flags >> 2
+    if txt_type == 2:
+        if len(message_bytes) < 4:
+            return None
+        signed_sender_prefix = message_bytes[:4].hex()
+        message_bytes = message_bytes[4:]
     try:
         message_text = message_bytes.decode("utf-8")
         # Truncate at first null terminator (consistent with channel message handling)
@@ -493,6 +529,7 @@ def decrypt_direct_message(payload: bytes, shared_secret: bytes) -> DecryptedDir
         message=message_text,
         dest_hash=dest_hash,
         src_hash=src_hash,
+        signed_sender_prefix=signed_sender_prefix,
     )
 
 
@@ -556,3 +593,88 @@ def try_decrypt_dm(
         return None
 
     return decrypt_direct_message(packet_info.payload, shared_secret)
+
+
+def decrypt_path_payload(payload: bytes, shared_secret: bytes) -> DecryptedPathPayload | None:
+    """Decrypt a PATH payload using the ECDH shared secret."""
+    if len(payload) < 4:
+        return None
+
+    dest_hash = format(payload[0], "02x")
+    src_hash = format(payload[1], "02x")
+    mac = payload[2:4]
+    ciphertext = payload[4:]
+
+    if len(ciphertext) == 0 or len(ciphertext) % 16 != 0:
+        return None
+
+    calculated_mac = hmac.new(shared_secret, ciphertext, hashlib.sha256).digest()[:2]
+    if calculated_mac != mac:
+        return None
+
+    try:
+        cipher = AES.new(shared_secret[:16], AES.MODE_ECB)
+        decrypted = cipher.decrypt(ciphertext)
+    except Exception as e:
+        logger.debug("AES decryption failed for PATH payload: %s", e)
+        return None
+
+    if len(decrypted) < 2:
+        return None
+
+    from app.path_utils import decode_path_byte
+
+    packed_len = decrypted[0]
+    try:
+        returned_path_len, hash_size = decode_path_byte(packed_len)
+    except ValueError:
+        return None
+
+    path_byte_len = returned_path_len * hash_size
+    if len(decrypted) < 1 + path_byte_len + 1:
+        return None
+
+    offset = 1
+    returned_path = decrypted[offset : offset + path_byte_len]
+    offset += path_byte_len
+    extra_type = decrypted[offset] & 0x0F
+    offset += 1
+    extra = decrypted[offset:]
+
+    return DecryptedPathPayload(
+        dest_hash=dest_hash,
+        src_hash=src_hash,
+        returned_path=returned_path,
+        returned_path_len=returned_path_len,
+        returned_path_hash_mode=hash_size - 1,
+        extra_type=extra_type,
+        extra=extra,
+    )
+
+
+def try_decrypt_path(
+    raw_packet: bytes,
+    our_private_key: bytes,
+    their_public_key: bytes,
+    our_public_key: bytes,
+) -> DecryptedPathPayload | None:
+    """Try to decrypt a raw packet as a PATH packet."""
+    packet_info = parse_packet(raw_packet)
+    if packet_info is None or packet_info.payload_type != PayloadType.PATH:
+        return None
+
+    if len(packet_info.payload) < 4:
+        return None
+
+    dest_hash = packet_info.payload[0]
+    src_hash = packet_info.payload[1]
+    if dest_hash != our_public_key[0] or src_hash != their_public_key[0]:
+        return None
+
+    try:
+        shared_secret = derive_shared_secret(our_private_key, their_public_key)
+    except Exception as e:
+        logger.debug("Failed to derive shared secret for PATH payload: %s", e)
+        return None
+
+    return decrypt_path_payload(packet_info.payload, shared_secret)

app/event_handlers.py

@@ -4,18 +4,22 @@ from typing import TYPE_CHECKING
 
 from meshcore import EventType
 
-from app.models import CONTACT_TYPE_REPEATER, Contact, ContactUpsert
+from app.models import CONTACT_TYPE_ROOM, Contact, ContactUpsert
 from app.packet_processor import process_raw_packet
 from app.repository import (
-    AmbiguousPublicKeyPrefixError,
     ContactRepository,
 )
 from app.services import dm_ack_tracker
 from app.services.contact_reconciliation import (
-    claim_prefix_messages_for_contact,
+    promote_prefix_contacts_for_contact,
     record_contact_name_and_reconcile,
 )
-from app.services.messages import create_fallback_direct_message, increment_ack_and_broadcast
+from app.services.dm_ack_apply import apply_dm_ack_code
+from app.services.dm_ingest import (
+    ingest_fallback_direct_message,
+    resolve_direct_message_sender_metadata,
+    resolve_fallback_direct_message_context,
+)
 from app.websocket import broadcast_event
 
 if TYPE_CHECKING:
@@ -27,11 +31,12 @@ logger = logging.getLogger(__name__)
 # This prevents handler duplication after reconnects
 _active_subscriptions: list["Subscription"] = []
 _pending_acks = dm_ack_tracker._pending_acks
+_buffered_acks = dm_ack_tracker._buffered_acks
 
 
-def track_pending_ack(expected_ack: str, message_id: int, timeout_ms: int) -> None:
+def track_pending_ack(expected_ack: str, message_id: int, timeout_ms: int) -> bool:
     """Compatibility wrapper for pending DM ACK tracking."""
-    dm_ack_tracker.track_pending_ack(expected_ack, message_id, timeout_ms)
+    return dm_ack_tracker.track_pending_ack(expected_ack, message_id, timeout_ms)
 
 
 def cleanup_expired_acks() -> None:
@@ -49,8 +54,8 @@ async def on_contact_message(event: "Event") -> None:
     2. The packet processor couldn't match the sender to a known contact
 
     The packet processor handles: decryption, storage, broadcast, bot trigger.
-    This handler only stores if the packet processor didn't already handle it
-    (detected via INSERT OR IGNORE returning None for duplicates).
+    This handler adapts CONTACT_MSG_RECV payloads into the shared DM ingest
+    workflow, which reconciles duplicates against the packet pipeline when possible.
     """
     payload = event.payload
 
@@ -64,64 +69,69 @@ async def on_contact_message(event: "Event") -> None:
     sender_pubkey = payload.get("public_key") or payload.get("pubkey_prefix", "")
     received_at = int(time.time())
 
-    # Look up contact from database - use prefix lookup only if needed
-    # (get_by_key_or_prefix does exact match first, then prefix fallback)
-    try:
-        contact = await ContactRepository.get_by_key_or_prefix(sender_pubkey)
-    except AmbiguousPublicKeyPrefixError:
-        logger.warning(
-            "DM sender prefix '%s' is ambiguous; storing under prefix until full key is known",
-            sender_pubkey,
+    context = await resolve_fallback_direct_message_context(
+        sender_public_key=sender_pubkey,
+        received_at=received_at,
+        broadcast_fn=broadcast_event,
+        contact_repository=ContactRepository,
+        log=logger,
+    )
+    if context.skip_storage:
+        logger.debug(
+            "Skipping message from repeater %s (not stored in chat history)",
+            context.conversation_key[:12],
         )
-        contact = None
-    if contact:
-        sender_pubkey = contact.public_key.lower()
+        return
 
-        # Promote any prefix-stored messages to this full key
-        await claim_prefix_messages_for_contact(public_key=sender_pubkey, log=logger)
-
-        # Skip messages from repeaters - they only send CLI responses, not chat messages.
-        # CLI responses are handled by the command endpoint and txt_type filter above.
-        if contact.type == CONTACT_TYPE_REPEATER:
-            logger.debug(
-                "Skipping message from repeater %s (not stored in chat history)",
-                sender_pubkey[:12],
-            )
-            return
-
-    # Try to create message - INSERT OR IGNORE handles duplicates atomically
-    # If the packet processor already stored this message, this returns None
+    # Try to create or reconcile the message via the shared DM ingest service.
     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")
     path_len = payload.get("path_len")
-    message = await create_fallback_direct_message(
-        conversation_key=sender_pubkey,
+    sender_name = context.sender_name
+    sender_key = context.sender_key
+    signature = payload.get("signature")
+    if (
+        context.contact is not None
+        and context.contact.type == CONTACT_TYPE_ROOM
+        and txt_type == 2
+        and isinstance(signature, str)
+        and signature
+    ):
+        sender_name, sender_key = await resolve_direct_message_sender_metadata(
+            sender_public_key=signature,
+            received_at=received_at,
+            broadcast_fn=broadcast_event,
+            contact_repository=ContactRepository,
+            log=logger,
+        )
+    message = await ingest_fallback_direct_message(
+        conversation_key=context.conversation_key,
         text=payload.get("text", ""),
         sender_timestamp=sender_timestamp,
         received_at=received_at,
         path=path,
         path_len=path_len,
         txt_type=txt_type,
-        signature=payload.get("signature"),
+        signature=signature,
         sender_name=sender_name,
-        sender_key=sender_pubkey,
+        sender_key=sender_key,
         broadcast_fn=broadcast_event,
+        update_last_contacted_key=context.contact.public_key.lower() if context.contact else None,
     )
 
     if message is None:
         # Already handled by packet processor (or exact duplicate) - nothing more to do
-        logger.debug("DM from %s already processed by packet processor", sender_pubkey[:12])
+        logger.debug(
+            "DM from %s already processed by packet processor", context.conversation_key[:12]
+        )
         return
 
     # If we get here, the packet processor didn't handle this message
     # (likely because private key export is not available)
-    logger.debug("DM from %s handled by event handler (fallback path)", sender_pubkey[:12])
-
-    # Update contact last_contacted (contact was already fetched above)
-    if contact:
-        await ContactRepository.update_last_contacted(sender_pubkey, received_at)
+    logger.debug(
+        "DM from %s handled by event handler (fallback path)", context.conversation_key[:12]
+    )
 
 
 async def on_rx_log_data(event: "Event") -> None:
@@ -205,11 +215,12 @@ async def on_path_update(event: "Event") -> None:
             )
             normalized_path_hash_mode = None
 
-    await ContactRepository.update_path(
+    await ContactRepository.update_direct_path(
         contact.public_key,
         str(path),
         normalized_path_len,
         normalized_path_hash_mode,
+        updated_at=int(time.time()),
     )
 
 
@@ -228,9 +239,13 @@ async def on_new_contact(event: "Event") -> None:
 
     logger.debug("New contact: %s", public_key[:12])
 
-    contact_upsert = ContactUpsert.from_radio_dict(public_key.lower(), payload, on_radio=True)
+    contact_upsert = ContactUpsert.from_radio_dict(public_key.lower(), payload, on_radio=False)
     contact_upsert.last_seen = int(time.time())
     await ContactRepository.upsert(contact_upsert)
+    promoted_keys = await promote_prefix_contacts_for_contact(
+        public_key=public_key,
+        log=logger,
+    )
 
     adv_name = payload.get("adv_name")
     await record_contact_name_and_reconcile(
@@ -251,6 +266,15 @@ async def on_new_contact(event: "Event") -> None:
             else Contact(**contact_upsert.model_dump(exclude_none=True)).model_dump()
         ),
     )
+    if db_contact:
+        for old_key in promoted_keys:
+            broadcast_event(
+                "contact_resolved",
+                {
+                    "previous_public_key": old_key,
+                    "contact": db_contact.model_dump(),
+                },
+            )
 
 
 async def on_ack(event: "Event") -> None:
@@ -263,16 +287,9 @@ async def on_ack(event: "Event") -> None:
         return
 
     logger.debug("Received ACK with code %s", ack_code)
-
-    cleanup_expired_acks()
-
-    message_id = dm_ack_tracker.pop_pending_ack(ack_code)
-    if message_id is not None:
-        logger.info("ACK received for message %d", 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.
-        await increment_ack_and_broadcast(message_id=message_id, broadcast_fn=broadcast_event)
+    matched = await apply_dm_ack_code(ack_code, broadcast_fn=broadcast_event)
+    if matched:
+        logger.info("ACK received for code %s", ack_code)
     else:
         logger.debug("ACK code %s does not match any pending messages", ack_code)
 

app/events.py

@@ -16,6 +16,7 @@ WsEventType = Literal[
     "health",
     "message",
     "contact",
+    "contact_resolved",
     "channel",
     "contact_deleted",
     "channel_deleted",
@@ -30,6 +31,11 @@ class ContactDeletedPayload(TypedDict):
     public_key: str
 
 
+class ContactResolvedPayload(TypedDict):
+    previous_public_key: str
+    contact: Contact
+
+
 class ChannelDeletedPayload(TypedDict):
     key: str
 
@@ -49,6 +55,7 @@ WsEventPayload = (
     HealthResponse
     | Message
     | Contact
+    | ContactResolvedPayload
     | Channel
     | ContactDeletedPayload
     | ChannelDeletedPayload
@@ -61,6 +68,7 @@ _PAYLOAD_ADAPTERS: dict[WsEventType, TypeAdapter[Any]] = {
     "health": TypeAdapter(HealthResponse),
     "message": TypeAdapter(Message),
     "contact": TypeAdapter(Contact),
+    "contact_resolved": TypeAdapter(ContactResolvedPayload),
     "channel": TypeAdapter(Channel),
     "contact_deleted": TypeAdapter(ContactDeletedPayload),
     "channel_deleted": TypeAdapter(ChannelDeletedPayload),

app/fanout/AGENTS_fanout.md

@@ -65,6 +65,7 @@ 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
+- Channel `message_text` passed to bot code is normalized for human readability by stripping a leading `"{sender_name}: "` prefix when it matches the payload sender.
 
 ### webhook (webhook.py)
 HTTP webhook delivery. Config blob:
@@ -78,11 +79,12 @@ 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
+- Channel notifications normalize stored message text by stripping a leading `"{sender_name}: "` prefix when it matches the payload sender so alerts do not duplicate the name.
 
 ### sqs (sqs.py)
 Amazon SQS delivery. Config blob:
 - `queue_url` — target queue URL
-- `region_name` (optional), `endpoint_url` (optional)
+- `region_name` (optional; inferred from standard AWS SQS queue URLs when omitted), `endpoint_url` (optional)
 - `access_key_id`, `secret_access_key`, `session_token` (all optional; blank uses the normal AWS credential chain)
 - Publishes a JSON envelope of the form `{"event_type":"message"|"raw_packet","data":...}`
 - Supports both decoded messages and raw packets via normal scope selection

app/fanout/apprise_mod.py

@@ -6,7 +6,7 @@ import asyncio
 import logging
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
-from app.fanout.base import FanoutModule
+from app.fanout.base import FanoutModule, get_fanout_message_text
 from app.path_utils import split_path_hex
 
 logger = logging.getLogger(__name__)
@@ -39,7 +39,7 @@ def _normalize_discord_url(url: str) -> str:
 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", "")
+    text = get_fanout_message_text(data)
     sender_name = data.get("sender_name") or "Unknown"
 
     via = ""

app/fanout/base.py

@@ -33,3 +33,30 @@ class FanoutModule:
     def status(self) -> str:
         """Return 'connected', 'disconnected', or 'error'."""
         raise NotImplementedError
+
+
+def get_fanout_message_text(data: dict) -> str:
+    """Return the best human-readable message body for fanout consumers.
+
+    Channel messages are stored with the rendered sender label embedded in the
+    text (for example ``"Alice: hello"``). Human-facing integrations that also
+    carry ``sender_name`` should strip that duplicated prefix when it matches
+    the payload sender exactly.
+    """
+
+    text = data.get("text", "")
+    if not isinstance(text, str):
+        return ""
+
+    if data.get("type") != "CHAN":
+        return text
+
+    sender_name = data.get("sender_name")
+    if not isinstance(sender_name, str) or not sender_name:
+        return text
+
+    prefix, separator, remainder = text.partition(": ")
+    if separator and prefix == sender_name:
+        return remainder
+
+    return text

app/fanout/bot.py

@@ -10,6 +10,36 @@ from app.fanout.base import FanoutModule
 logger = logging.getLogger(__name__)
 
 
+def _derive_path_bytes_per_hop(paths: object, path_value: str | None) -> int | None:
+    """Derive hop width from the first serialized message path when possible."""
+    if not isinstance(path_value, str) or not path_value:
+        return None
+    if not isinstance(paths, list) or not paths:
+        return None
+
+    first_path = paths[0]
+    if not isinstance(first_path, dict):
+        return None
+
+    path_hops = first_path.get("path_len")
+    if not isinstance(path_hops, int) or path_hops <= 0:
+        return None
+
+    path_hex_chars = len(path_value)
+    if path_hex_chars % 2 != 0:
+        return None
+
+    path_bytes = path_hex_chars // 2
+    if path_bytes % path_hops != 0:
+        return None
+
+    hop_width = path_bytes // path_hops
+    if hop_width not in (1, 2, 3):
+        return None
+
+    return hop_width
+
+
 class BotModule(FanoutModule):
     """Wraps a single bot's code execution and response routing.
 
@@ -101,11 +131,11 @@ class BotModule(FanoutModule):
 
         sender_timestamp = data.get("sender_timestamp")
         path_value = data.get("path")
+        paths = data.get("paths")
         # 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
+        if path_value is None and paths and isinstance(paths, list) and len(paths) > 0:
+            path_value = paths[0].get("path") if isinstance(paths[0], dict) else None
+        path_bytes_per_hop = _derive_path_bytes_per_hop(paths, path_value)
 
         # Wait for message to settle (allows retransmissions to be deduped)
         await asyncio.sleep(2)
@@ -130,6 +160,7 @@ class BotModule(FanoutModule):
                         sender_timestamp,
                         path_value,
                         is_outgoing,
+                        path_bytes_per_hop,
                     ),
                     timeout=BOT_EXECUTION_TIMEOUT,
                 )

app/fanout/bot_exec.py

@@ -15,6 +15,7 @@ import inspect
 import logging
 import time
 from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
 from typing import Any
 
 from fastapi import HTTPException
@@ -39,6 +40,102 @@ _bot_send_lock = asyncio.Lock()
 _last_bot_send_time: float = 0.0
 
 
+@dataclass(frozen=True)
+class BotCallPlan:
+    """How to call a validated bot() function."""
+
+    call_style: str
+    keyword_args: tuple[str, ...] = ()
+
+
+def _analyze_bot_signature(bot_func_or_sig) -> BotCallPlan:
+    """Validate bot() signature and return a supported call plan."""
+    try:
+        sig = (
+            bot_func_or_sig
+            if isinstance(bot_func_or_sig, inspect.Signature)
+            else inspect.signature(bot_func_or_sig)
+        )
+    except (ValueError, TypeError) as exc:
+        raise ValueError("Bot function signature could not be inspected") from exc
+
+    params = sig.parameters
+    param_values = tuple(params.values())
+    positional_params = [
+        p
+        for p in param_values
+        if p.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+    ]
+    has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in param_values)
+    has_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in param_values)
+    explicit_optional_names = tuple(
+        name for name in ("is_outgoing", "path_bytes_per_hop") if name in params
+    )
+    unsupported_required_kwonly = [
+        p.name
+        for p in param_values
+        if p.kind == inspect.Parameter.KEYWORD_ONLY
+        and p.default is inspect.Parameter.empty
+        and p.name not in {"is_outgoing", "path_bytes_per_hop"}
+    ]
+    if unsupported_required_kwonly:
+        raise ValueError(
+            "Bot function signature is not supported. Unsupported required keyword-only "
+            "parameters: " + ", ".join(unsupported_required_kwonly)
+        )
+
+    positional_capacity = len(positional_params)
+    base_args = [object()] * 8
+    base_keyword_args: dict[str, object] = {
+        "sender_name": object(),
+        "sender_key": object(),
+        "message_text": object(),
+        "is_dm": object(),
+        "channel_key": object(),
+        "channel_name": object(),
+        "sender_timestamp": object(),
+        "path": object(),
+    }
+    candidate_specs: list[tuple[str, list[object], dict[str, object]]] = []
+    keyword_args = dict(base_keyword_args)
+    if has_kwargs or "is_outgoing" in params:
+        keyword_args["is_outgoing"] = False
+    if has_kwargs or "path_bytes_per_hop" in params:
+        keyword_args["path_bytes_per_hop"] = 1
+    candidate_specs.append(("keyword", [], keyword_args))
+
+    if not has_kwargs and explicit_optional_names:
+        kwargs: dict[str, object] = {}
+        if has_kwargs or "is_outgoing" in params:
+            kwargs["is_outgoing"] = False
+        if has_kwargs or "path_bytes_per_hop" in params:
+            kwargs["path_bytes_per_hop"] = 1
+        candidate_specs.append(("mixed_keyword", base_args, kwargs))
+
+    if has_varargs or positional_capacity >= 10:
+        candidate_specs.append(("positional_10", base_args + [False, 1], {}))
+    if has_varargs or positional_capacity >= 9:
+        candidate_specs.append(("positional_9", base_args + [False], {}))
+    if has_varargs or positional_capacity >= 8:
+        candidate_specs.append(("legacy", base_args, {}))
+
+    for call_style, args, kwargs in candidate_specs:
+        try:
+            sig.bind(*args, **kwargs)
+        except TypeError:
+            continue
+        if call_style in {"keyword", "mixed_keyword"}:
+            return BotCallPlan(call_style="keyword", keyword_args=tuple(kwargs.keys()))
+        return BotCallPlan(call_style=call_style)
+
+    raise ValueError(
+        "Bot function signature is not supported. Use the default bot template as a reference. "
+        "Supported trailing parameters are: path; path + is_outgoing; "
+        "path + path_bytes_per_hop; path + is_outgoing + path_bytes_per_hop; "
+        "or use **kwargs for forward compatibility."
+    )
+
+
 def execute_bot_code(
     code: str,
     sender_name: str | None,
@@ -50,17 +147,19 @@ def execute_bot_code(
     sender_timestamp: int | None,
     path: str | None,
     is_outgoing: bool = False,
+    path_bytes_per_hop: int | None = None,
 ) -> 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, is_outgoing)`
+    `bot(sender_name, sender_key, message_text, is_dm, channel_key, channel_name, sender_timestamp, path, is_outgoing, path_bytes_per_hop)`
+    or use named parameters / `**kwargs`.
     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.
+    Legacy bot functions with older signatures are detected via inspect and
+    called without the newer parameters for backward compatibility.
 
     Args:
         code: Python code defining the bot function
@@ -73,6 +172,7 @@ def execute_bot_code(
         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
+        path_bytes_per_hop: Number of bytes per routing hop (1, 2, or 3), if known
 
     Returns:
         Response string, list of strings, or None.
@@ -100,30 +200,28 @@ def execute_bot_code(
         return None
 
     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:
-        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
+        call_plan = _analyze_bot_signature(bot_func)
+    except ValueError as exc:
+        logger.error("%s", exc)
+        return None
 
     try:
         # Call the bot function with appropriate signature
-        if call_style == "positional":
+        if call_plan.call_style == "positional_10":
+            result = bot_func(
+                sender_name,
+                sender_key,
+                message_text,
+                is_dm,
+                channel_key,
+                channel_name,
+                sender_timestamp,
+                path,
+                is_outgoing,
+                path_bytes_per_hop,
+            )
+        elif call_plan.call_style == "positional_9":
             result = bot_func(
                 sender_name,
                 sender_key,
@@ -135,18 +233,29 @@ def execute_bot_code(
                 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,
-            )
+        elif call_plan.call_style == "keyword":
+            keyword_args: dict[str, Any] = {}
+            if "sender_name" in call_plan.keyword_args:
+                keyword_args["sender_name"] = sender_name
+            if "sender_key" in call_plan.keyword_args:
+                keyword_args["sender_key"] = sender_key
+            if "message_text" in call_plan.keyword_args:
+                keyword_args["message_text"] = message_text
+            if "is_dm" in call_plan.keyword_args:
+                keyword_args["is_dm"] = is_dm
+            if "channel_key" in call_plan.keyword_args:
+                keyword_args["channel_key"] = channel_key
+            if "channel_name" in call_plan.keyword_args:
+                keyword_args["channel_name"] = channel_name
+            if "sender_timestamp" in call_plan.keyword_args:
+                keyword_args["sender_timestamp"] = sender_timestamp
+            if "path" in call_plan.keyword_args:
+                keyword_args["path"] = path
+            if "is_outgoing" in call_plan.keyword_args:
+                keyword_args["is_outgoing"] = is_outgoing
+            if "path_bytes_per_hop" in call_plan.keyword_args:
+                keyword_args["path_bytes_per_hop"] = path_bytes_per_hop
+            result = bot_func(**keyword_args)
         else:
             result = bot_func(
                 sender_name,

app/fanout/community_mqtt.py

@@ -12,7 +12,6 @@ from __future__ import annotations
 import asyncio
 import base64
 import hashlib
-import importlib.metadata
 import json
 import logging
 import ssl
@@ -25,12 +24,13 @@ import nacl.bindings
 
 from app.fanout.mqtt_base import BaseMqttPublisher
 from app.path_utils import parse_packet_envelope, split_path_hex
+from app.version_info import get_app_build_info
 
 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)"
+_CLIENT_ID = "RemoteTerm"
 
 # Proactive JWT renewal: reconnect 1 hour before the 24h token expires
 _TOKEN_LIFETIME = 86400  # 24 hours (must match _generate_jwt_token exp)
@@ -115,7 +115,7 @@ def _generate_jwt_token(
         "exp": now + _TOKEN_LIFETIME,
         "aud": audience,
         "owner": pubkey_hex,
-        "client": _CLIENT_ID,
+        "client": _get_client_version(),
     }
     if email:
         payload["email"] = email
@@ -260,12 +260,10 @@ def _build_radio_info() -> str:
 
 
 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"
+    """Return the canonical client/version identifier for community MQTT."""
+    build = get_app_build_info()
+    commit_hash = build.commit_hash or "unknown"
+    return f"{_CLIENT_ID}/{build.version}-{commit_hash}"
 
 
 class CommunityMqttPublisher(BaseMqttPublisher):

app/fanout/mqtt_base.py

@@ -54,6 +54,17 @@ class BaseMqttPublisher(ABC):
         self._settings_version: int = 0
         self._version_event: asyncio.Event = asyncio.Event()
         self.connected: bool = False
+        self.integration_name: str = ""
+
+    def set_integration_name(self, name: str) -> None:
+        """Attach the configured fanout-module name for operator-facing logs."""
+        self.integration_name = name.strip()
+
+    def _integration_label(self) -> str:
+        """Return a concise label for logs, including the configured module name."""
+        if self.integration_name:
+            return f"{self._log_prefix} [{self.integration_name}]"
+        return self._log_prefix
 
     # ── Lifecycle ──────────────────────────────────────────────────────
 
@@ -90,8 +101,9 @@ class BaseMqttPublisher(ABC):
             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,
+                "%s publish failed on %s. This is usually transient network noise; "
+                "if it self-resolves and reconnects, it is generally not a concern: %s",
+                self._integration_label(),
                 topic,
                 e,
                 exc_info=True,
@@ -225,8 +237,10 @@ class BaseMqttPublisher(ABC):
                 broadcast_error(title, detail)
                 _broadcast_health()
                 logger.warning(
-                    "%s connection error: %s (reconnecting in %ds)",
-                    self._log_prefix,
+                    "%s connection error. This is usually transient network noise; "
+                    "if it self-resolves, it is generally not a concern: %s "
+                    "(reconnecting in %ds)",
+                    self._integration_label(),
                     e,
                     backoff,
                     exc_info=True,

app/fanout/mqtt_community.py

@@ -77,6 +77,7 @@ class MqttCommunityModule(FanoutModule):
     def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
         super().__init__(config_id, config, name=name)
         self._publisher = CommunityMqttPublisher()
+        self._publisher.set_integration_name(name or config_id)
 
     async def start(self) -> None:
         settings = _config_to_settings(self.config)

app/fanout/mqtt_private.py

@@ -32,6 +32,7 @@ class MqttPrivateModule(FanoutModule):
     def __init__(self, config_id: str, config: dict, *, name: str = "") -> None:
         super().__init__(config_id, config, name=name)
         self._publisher = MqttPublisher()
+        self._publisher.set_integration_name(name or config_id)
 
     async def start(self) -> None:
         settings = _config_to_settings(self.config)

app/fanout/sqs.py

@@ -7,6 +7,7 @@ import hashlib
 import json
 import logging
 from functools import partial
+from urllib.parse import urlparse
 
 import boto3
 from botocore.exceptions import BotoCoreError, ClientError
@@ -28,6 +29,24 @@ def _build_payload(data: dict, *, event_type: str) -> str:
     )
 
 
+def _infer_region_from_queue_url(queue_url: str) -> str | None:
+    """Infer AWS region from a standard SQS queue URL host when possible."""
+    host = urlparse(queue_url).hostname or ""
+    if not host:
+        return None
+
+    parts = host.split(".")
+    if len(parts) < 4 or parts[0] != "sqs":
+        return None
+    if parts[2] != "amazonaws":
+        return None
+    if parts[3] not in {"com", "com.cn"}:
+        return None
+
+    region = parts[1].strip()
+    return region or None
+
+
 def _is_fifo_queue(queue_url: str) -> bool:
     """Return True when the configured queue URL points at an SQS FIFO queue."""
     return queue_url.rstrip("/").endswith(".fifo")
@@ -69,12 +88,15 @@ class SqsModule(FanoutModule):
 
     async def start(self) -> None:
         kwargs: dict[str, str] = {}
+        queue_url = str(self.config.get("queue_url", "")).strip()
         region_name = str(self.config.get("region_name", "")).strip()
         endpoint_url = str(self.config.get("endpoint_url", "")).strip()
         access_key_id = str(self.config.get("access_key_id", "")).strip()
         secret_access_key = str(self.config.get("secret_access_key", "")).strip()
         session_token = str(self.config.get("session_token", "")).strip()
 
+        if not region_name:
+            region_name = _infer_region_from_queue_url(queue_url) or ""
         if region_name:
             kwargs["region_name"] = region_name
         if endpoint_url:

app/frontend_static.py

@@ -10,6 +10,10 @@ logger = logging.getLogger(__name__)
 INDEX_CACHE_CONTROL = "no-store"
 ASSET_CACHE_CONTROL = "public, max-age=31536000, immutable"
 STATIC_FILE_CACHE_CONTROL = "public, max-age=3600"
+FRONTEND_BUILD_INSTRUCTIONS = (
+    "Run 'cd frontend && npm install && npm run build', "
+    "or use a release zip that includes frontend/prebuilt."
+)
 
 
 class CacheControlStaticFiles(StaticFiles):
@@ -48,40 +52,38 @@ def _resolve_request_origin(request: Request) -> str:
     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.
-
-    Returns True when routes are registered, False when frontend files are
-    missing/incomplete. Missing frontend files are logged but are not fatal.
-    """
+def _validate_frontend_dir(frontend_dir: Path, *, log_failures: bool = True) -> tuple[bool, Path]:
+    """Resolve and validate a built frontend directory."""
     frontend_dir = frontend_dir.resolve()
     index_file = frontend_dir / "index.html"
-    assets_dir = frontend_dir / "assets"
 
     if not frontend_dir.exists():
-        logger.error(
-            "Frontend build directory not found at %s. "
-            "Run 'cd frontend && npm run build'. API will continue without frontend routes.",
-            frontend_dir,
-        )
-        return False
+        if log_failures:
+            logger.error("Frontend build directory not found at %s.", frontend_dir)
+        return False, frontend_dir
 
     if not frontend_dir.is_dir():
-        logger.error(
-            "Frontend build path is not a directory: %s. "
-            "API will continue without frontend routes.",
-            frontend_dir,
-        )
-        return False
+        if log_failures:
+            logger.error("Frontend build path is not a directory: %s.", frontend_dir)
+        return False, frontend_dir
 
     if not index_file.exists():
-        logger.error(
-            "Frontend index file not found at %s. "
-            "Run 'cd frontend && npm run build'. API will continue without frontend routes.",
-            index_file,
-        )
+        if log_failures:
+            logger.error("Frontend index file not found at %s.", index_file)
+        return False, frontend_dir
+
+    return True, frontend_dir
+
+
+def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
+    """Register frontend static file routes if a built frontend is available."""
+    valid, frontend_dir = _validate_frontend_dir(frontend_dir)
+    if not valid:
         return False
 
+    index_file = frontend_dir / "index.html"
+    assets_dir = frontend_dir / "assets"
+
     if assets_dir.exists() and assets_dir.is_dir():
         app.mount(
             "/assets",
@@ -157,6 +159,30 @@ def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
     return True
 
 
+def register_first_available_frontend_static_routes(
+    app: FastAPI, frontend_dirs: list[Path]
+) -> Path | None:
+    """Register frontend routes from the first valid build directory."""
+    for i, candidate in enumerate(frontend_dirs):
+        valid, resolved_candidate = _validate_frontend_dir(candidate, log_failures=False)
+        if not valid:
+            continue
+
+        if register_frontend_static_routes(app, resolved_candidate):
+            logger.info("Selected frontend build directory %s", resolved_candidate)
+            return resolved_candidate
+
+        if i < len(frontend_dirs) - 1:
+            logger.warning("Frontend build at %s was unusable; trying fallback", resolved_candidate)
+
+    logger.error(
+        "No usable frontend build found. Searched: %s. %s API will continue without frontend routes.",
+        ", ".join(str(path.resolve()) for path in frontend_dirs),
+        FRONTEND_BUILD_INSTRUCTIONS,
+    )
+    return None
+
+
 def register_frontend_missing_fallback(app: FastAPI) -> None:
     """Register a fallback route that tells the user to build the frontend."""
 
@@ -164,5 +190,5 @@ def register_frontend_missing_fallback(app: FastAPI) -> None:
     async def frontend_not_built():
         return JSONResponse(
             status_code=404,
-            content={"detail": "Frontend not built. Run: cd frontend && npm ci && npm run build"},
+            content={"detail": f"Frontend not built. {FRONTEND_BUILD_INSTRUCTIONS}"},
         )

app/keystore.py

@@ -30,6 +30,16 @@ _private_key: bytes | None = None
 _public_key: bytes | None = None
 
 
+def clear_keys() -> None:
+    """Clear any stored private/public key material from memory."""
+    global _private_key, _public_key
+    had_key = _private_key is not None or _public_key is not None
+    _private_key = None
+    _public_key = None
+    if had_key:
+        logger.info("Cleared in-memory keystore")
+
+
 def set_private_key(key: bytes) -> None:
     """Store the private key in memory and derive the public key.
 

app/main.py

@@ -11,7 +11,10 @@ from fastapi.responses import JSONResponse
 from app.config import settings as server_settings
 from app.config import setup_logging
 from app.database import db
-from app.frontend_static import register_frontend_missing_fallback, register_frontend_static_routes
+from app.frontend_static import (
+    register_first_available_frontend_static_routes,
+    register_frontend_missing_fallback,
+)
 from app.radio import RadioDisconnectedError
 from app.radio_sync import (
     stop_message_polling,
@@ -21,6 +24,7 @@ from app.radio_sync import (
 from app.routers import (
     channels,
     contacts,
+    debug,
     fanout,
     health,
     messages,
@@ -28,12 +32,14 @@ from app.routers import (
     radio,
     read_state,
     repeaters,
+    rooms,
     settings,
     statistics,
     ws,
 )
 from app.security import add_optional_basic_auth_middleware
 from app.services.radio_runtime import radio_runtime as radio_manager
+from app.version_info import get_app_build_info
 
 setup_logging()
 logger = logging.getLogger(__name__)
@@ -98,22 +104,10 @@ 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=_get_version(),
+    version=get_app_build_info().version,
     lifespan=lifespan,
 )
 
@@ -136,10 +130,12 @@ async def radio_disconnected_handler(request: Request, exc: RadioDisconnectedErr
 
 # API routes - all prefixed with /api for production compatibility
 app.include_router(health.router, prefix="/api")
+app.include_router(debug.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(rooms.router, prefix="/api")
 app.include_router(channels.router, prefix="/api")
 app.include_router(messages.router, prefix="/api")
 app.include_router(packets.router, prefix="/api")
@@ -149,6 +145,9 @@ 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"
-if not register_frontend_static_routes(app, FRONTEND_DIR):
+FRONTEND_DIST_DIR = Path(__file__).parent.parent / "frontend" / "dist"
+FRONTEND_PREBUILT_DIR = Path(__file__).parent.parent / "frontend" / "prebuilt"
+if not register_first_available_frontend_static_routes(
+    app, [FRONTEND_DIST_DIR, FRONTEND_PREBUILT_DIR]
+):
     register_frontend_missing_fallback(app)

app/migrations.py

@@ -8,6 +8,7 @@ This approach is safe for existing users - their databases have user_version=0,
 so all migrations run in order on first startup after upgrade.
 """
 
+import json
 import logging
 from hashlib import sha256
 
@@ -331,6 +332,34 @@ async def run_migrations(conn: aiosqlite.Connection) -> int:
         await set_version(conn, 42)
         applied += 1
 
+    # Migration 43: Limit message dedup index to channel messages only
+    if version < 43:
+        logger.info("Applying migration 43: narrow message dedup index to channels")
+        await _migrate_043_split_message_dedup_by_type(conn)
+        await set_version(conn, 43)
+        applied += 1
+
+    # Migration 44: Deduplicate incoming direct messages by content/timestamp
+    if version < 44:
+        logger.info("Applying migration 44: dedupe incoming direct messages")
+        await _migrate_044_dedupe_incoming_direct_messages(conn)
+        await set_version(conn, 44)
+        applied += 1
+
+    # Migration 45: Replace legacy contact route columns with direct-route columns
+    if version < 45:
+        logger.info("Applying migration 45: rebuild contacts direct-route columns")
+        await _migrate_045_rebuild_contacts_direct_route_columns(conn)
+        await set_version(conn, 45)
+        applied += 1
+
+    # Migration 46: Clean orphaned contact child rows left by old prefix promotion
+    if version < 46:
+        logger.info("Applying migration 46: clean orphaned contact child rows")
+        await _migrate_046_cleanup_orphaned_contact_child_rows(conn)
+        await set_version(conn, 46)
+        applied += 1
+
     if applied > 0:
         logger.info(
             "Applied %d migration(s), schema now at version %d", applied, await get_version(conn)
@@ -2443,3 +2472,399 @@ async def _migrate_042_add_channel_flood_scope_override(conn: aiosqlite.Connecti
             raise
 
     await conn.commit()
+
+
+async def _migrate_043_split_message_dedup_by_type(conn: aiosqlite.Connection) -> None:
+    """Restrict the message dedup index to channel messages."""
+    cursor = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='messages'"
+    )
+    if await cursor.fetchone() is None:
+        await conn.commit()
+        return
+
+    cursor = await conn.execute("PRAGMA table_info(messages)")
+    columns = {row[1] for row in await cursor.fetchall()}
+    required_columns = {"type", "conversation_key", "text", "sender_timestamp"}
+    if not required_columns.issubset(columns):
+        logger.debug("messages table missing dedup-index columns, skipping migration 43")
+        await conn.commit()
+        return
+
+    await conn.execute("DROP INDEX IF EXISTS idx_messages_dedup_null_safe")
+    await conn.execute(
+        """CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_dedup_null_safe
+           ON messages(type, conversation_key, text, COALESCE(sender_timestamp, 0))
+           WHERE type = 'CHAN'"""
+    )
+    await conn.commit()
+
+
+def _merge_message_paths(paths_json_values: list[str | None]) -> str | None:
+    """Merge multiple message path arrays into one exact-observation list."""
+    merged: list[dict[str, object]] = []
+    seen: set[tuple[object | None, object | None, object | None]] = set()
+
+    for paths_json in paths_json_values:
+        if not paths_json:
+            continue
+        try:
+            parsed = json.loads(paths_json)
+        except (TypeError, json.JSONDecodeError):
+            continue
+        if not isinstance(parsed, list):
+            continue
+        for entry in parsed:
+            if not isinstance(entry, dict):
+                continue
+            key = (
+                entry.get("path"),
+                entry.get("received_at"),
+                entry.get("path_len"),
+            )
+            if key in seen:
+                continue
+            seen.add(key)
+            merged.append(entry)
+
+    return json.dumps(merged) if merged else None
+
+
+async def _migrate_044_dedupe_incoming_direct_messages(conn: aiosqlite.Connection) -> None:
+    """Collapse same-contact same-text same-second incoming DMs into one row."""
+    cursor = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='messages'"
+    )
+    if await cursor.fetchone() is None:
+        await conn.commit()
+        return
+
+    cursor = await conn.execute("PRAGMA table_info(messages)")
+    columns = {row[1] for row in await cursor.fetchall()}
+    required_columns = {
+        "id",
+        "type",
+        "conversation_key",
+        "text",
+        "sender_timestamp",
+        "received_at",
+        "paths",
+        "txt_type",
+        "signature",
+        "outgoing",
+        "acked",
+        "sender_name",
+        "sender_key",
+    }
+    if not required_columns.issubset(columns):
+        logger.debug("messages table missing incoming-DM dedup columns, skipping migration 44")
+        await conn.commit()
+        return
+
+    raw_packets_cursor = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='raw_packets'"
+    )
+    raw_packets_exists = await raw_packets_cursor.fetchone() is not None
+
+    duplicate_groups_cursor = await conn.execute(
+        """
+        SELECT conversation_key, text,
+               COALESCE(sender_timestamp, 0) AS normalized_sender_timestamp,
+               COUNT(*) AS duplicate_count
+        FROM messages
+        WHERE type = 'PRIV' AND outgoing = 0
+        GROUP BY conversation_key, text, COALESCE(sender_timestamp, 0)
+        HAVING COUNT(*) > 1
+        """
+    )
+    duplicate_groups = await duplicate_groups_cursor.fetchall()
+
+    for group in duplicate_groups:
+        normalized_sender_timestamp = group["normalized_sender_timestamp"]
+        rows_cursor = await conn.execute(
+            """
+            SELECT *
+            FROM messages
+            WHERE type = 'PRIV' AND outgoing = 0
+              AND conversation_key = ? AND text = ?
+              AND COALESCE(sender_timestamp, 0) = ?
+            ORDER BY id ASC
+            """,
+            (
+                group["conversation_key"],
+                group["text"],
+                normalized_sender_timestamp,
+            ),
+        )
+        rows = list(await rows_cursor.fetchall())
+        if len(rows) < 2:
+            continue
+
+        keeper = rows[0]
+        duplicate_ids = [row["id"] for row in rows[1:]]
+        merged_paths = _merge_message_paths([row["paths"] for row in rows])
+        merged_received_at = min(row["received_at"] for row in rows)
+        merged_txt_type = next((row["txt_type"] for row in rows if row["txt_type"] != 0), 0)
+        merged_signature = next((row["signature"] for row in rows if row["signature"]), None)
+        merged_sender_name = next((row["sender_name"] for row in rows if row["sender_name"]), None)
+        merged_sender_key = next((row["sender_key"] for row in rows if row["sender_key"]), None)
+        merged_acked = max(int(row["acked"] or 0) for row in rows)
+
+        await conn.execute(
+            """
+            UPDATE messages
+            SET received_at = ?, paths = ?, txt_type = ?, signature = ?,
+                acked = ?, sender_name = ?, sender_key = ?
+            WHERE id = ?
+            """,
+            (
+                merged_received_at,
+                merged_paths,
+                merged_txt_type,
+                merged_signature,
+                merged_acked,
+                merged_sender_name,
+                merged_sender_key,
+                keeper["id"],
+            ),
+        )
+
+        if raw_packets_exists:
+            for duplicate_id in duplicate_ids:
+                await conn.execute(
+                    "UPDATE raw_packets SET message_id = ? WHERE message_id = ?",
+                    (keeper["id"], duplicate_id),
+                )
+
+        placeholders = ",".join("?" for _ in duplicate_ids)
+        await conn.execute(
+            f"DELETE FROM messages WHERE id IN ({placeholders})",
+            duplicate_ids,
+        )
+
+    await conn.execute("DROP INDEX IF EXISTS idx_messages_incoming_priv_dedup")
+    await conn.execute(
+        """CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_incoming_priv_dedup
+           ON messages(type, conversation_key, text, COALESCE(sender_timestamp, 0))
+           WHERE type = 'PRIV' AND outgoing = 0"""
+    )
+    await conn.commit()
+
+
+async def _migrate_045_rebuild_contacts_direct_route_columns(conn: aiosqlite.Connection) -> None:
+    """Replace legacy contact route columns with canonical direct-route columns."""
+    cursor = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='contacts'"
+    )
+    if await cursor.fetchone() is None:
+        await conn.commit()
+        return
+
+    cursor = await conn.execute("PRAGMA table_info(contacts)")
+    columns = {row[1] for row in await cursor.fetchall()}
+
+    target_columns = {
+        "public_key",
+        "name",
+        "type",
+        "flags",
+        "direct_path",
+        "direct_path_len",
+        "direct_path_hash_mode",
+        "direct_path_updated_at",
+        "route_override_path",
+        "route_override_len",
+        "route_override_hash_mode",
+        "last_advert",
+        "lat",
+        "lon",
+        "last_seen",
+        "on_radio",
+        "last_contacted",
+        "first_seen",
+        "last_read_at",
+    }
+    if (
+        target_columns.issubset(columns)
+        and "last_path" not in columns
+        and "out_path_hash_mode" not in columns
+    ):
+        await conn.commit()
+        return
+
+    await conn.execute(
+        """
+        CREATE TABLE contacts_new (
+            public_key TEXT PRIMARY KEY,
+            name TEXT,
+            type INTEGER DEFAULT 0,
+            flags INTEGER DEFAULT 0,
+            direct_path TEXT,
+            direct_path_len INTEGER,
+            direct_path_hash_mode INTEGER,
+            direct_path_updated_at INTEGER,
+            route_override_path TEXT,
+            route_override_len INTEGER,
+            route_override_hash_mode INTEGER,
+            last_advert INTEGER,
+            lat REAL,
+            lon REAL,
+            last_seen INTEGER,
+            on_radio INTEGER DEFAULT 0,
+            last_contacted INTEGER,
+            first_seen INTEGER,
+            last_read_at INTEGER
+        )
+        """
+    )
+
+    select_expr = {
+        "public_key": "public_key",
+        "name": "NULL",
+        "type": "0",
+        "flags": "0",
+        "direct_path": "NULL",
+        "direct_path_len": "NULL",
+        "direct_path_hash_mode": "NULL",
+        "direct_path_updated_at": "NULL",
+        "route_override_path": "NULL",
+        "route_override_len": "NULL",
+        "route_override_hash_mode": "NULL",
+        "last_advert": "NULL",
+        "lat": "NULL",
+        "lon": "NULL",
+        "last_seen": "NULL",
+        "on_radio": "0",
+        "last_contacted": "NULL",
+        "first_seen": "NULL",
+        "last_read_at": "NULL",
+    }
+    for name in ("name", "type", "flags"):
+        if name in columns:
+            select_expr[name] = name
+
+    if "direct_path" in columns:
+        select_expr["direct_path"] = "direct_path"
+
+    if "direct_path_len" in columns:
+        select_expr["direct_path_len"] = "direct_path_len"
+
+    if "direct_path_hash_mode" in columns:
+        select_expr["direct_path_hash_mode"] = "direct_path_hash_mode"
+
+    for name in (
+        "route_override_path",
+        "route_override_len",
+        "route_override_hash_mode",
+        "last_advert",
+        "lat",
+        "lon",
+        "last_seen",
+        "on_radio",
+        "last_contacted",
+        "first_seen",
+        "last_read_at",
+    ):
+        if name in columns:
+            select_expr[name] = name
+
+    ordered_columns = list(select_expr.keys())
+    await conn.execute(
+        f"""
+        INSERT INTO contacts_new ({", ".join(ordered_columns)})
+        SELECT {", ".join(select_expr[name] for name in ordered_columns)}
+        FROM contacts
+        """
+    )
+
+    await conn.execute("DROP TABLE contacts")
+    await conn.execute("ALTER TABLE contacts_new RENAME TO contacts")
+    await conn.commit()
+
+
+async def _migrate_046_cleanup_orphaned_contact_child_rows(conn: aiosqlite.Connection) -> None:
+    """Move uniquely resolvable orphan contact child rows onto full contacts, drop the rest."""
+    existing_tables_cursor = await conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    existing_tables = {row[0] for row in await existing_tables_cursor.fetchall()}
+    if "contacts" not in existing_tables:
+        await conn.commit()
+        return
+
+    child_tables = [
+        table
+        for table in ("contact_name_history", "contact_advert_paths")
+        if table in existing_tables
+    ]
+    if not child_tables:
+        await conn.commit()
+        return
+
+    orphan_keys: set[str] = set()
+
+    for table in child_tables:
+        cursor = await conn.execute(
+            f"""
+            SELECT DISTINCT child.public_key
+            FROM {table} child
+            LEFT JOIN contacts c ON c.public_key = child.public_key
+            WHERE c.public_key IS NULL
+            """
+        )
+        orphan_keys.update(row[0] for row in await cursor.fetchall())
+
+    for orphan_key in sorted(orphan_keys, key=len, reverse=True):
+        match_cursor = await conn.execute(
+            """
+            SELECT public_key
+            FROM contacts
+            WHERE length(public_key) = 64
+              AND public_key LIKE ? || '%'
+            ORDER BY public_key
+            """,
+            (orphan_key.lower(),),
+        )
+        matches = [row[0] for row in await match_cursor.fetchall()]
+        resolved_key = matches[0] if len(matches) == 1 else None
+
+        if resolved_key is not None:
+            if "contact_name_history" in child_tables:
+                await conn.execute(
+                    """
+                    INSERT INTO contact_name_history (public_key, name, first_seen, last_seen)
+                    SELECT ?, name, first_seen, last_seen
+                    FROM contact_name_history
+                    WHERE public_key = ?
+                    ON CONFLICT(public_key, name) DO UPDATE SET
+                        first_seen = MIN(contact_name_history.first_seen, excluded.first_seen),
+                        last_seen = MAX(contact_name_history.last_seen, excluded.last_seen)
+                    """,
+                    (resolved_key, orphan_key),
+                )
+            if "contact_advert_paths" in child_tables:
+                await conn.execute(
+                    """
+                    INSERT INTO contact_advert_paths
+                        (public_key, path_hex, path_len, first_seen, last_seen, heard_count)
+                    SELECT ?, path_hex, path_len, first_seen, last_seen, heard_count
+                    FROM contact_advert_paths
+                    WHERE public_key = ?
+                    ON CONFLICT(public_key, path_hex, path_len) DO UPDATE SET
+                        first_seen = MIN(contact_advert_paths.first_seen, excluded.first_seen),
+                        last_seen = MAX(contact_advert_paths.last_seen, excluded.last_seen),
+                        heard_count = contact_advert_paths.heard_count + excluded.heard_count
+                    """,
+                    (resolved_key, orphan_key),
+                )
+
+        if "contact_name_history" in child_tables:
+            await conn.execute(
+                "DELETE FROM contact_name_history WHERE public_key = ?",
+                (orphan_key,),
+            )
+        if "contact_advert_paths" in child_tables:
+            await conn.execute(
+                "DELETE FROM contact_advert_paths WHERE public_key = ?",
+                (orphan_key,),
+            )
+
+    await conn.commit()

app/models.py

@@ -2,7 +2,17 @@ from typing import Literal
 
 from pydantic import BaseModel, Field
 
-from app.path_utils import normalize_contact_route
+from app.path_utils import normalize_contact_route, normalize_route_override
+
+
+class ContactRoute(BaseModel):
+    """A normalized contact route."""
+
+    path: str = Field(description="Hex-encoded path bytes (empty string for direct/flood)")
+    path_len: int = Field(description="Hop count (-1=flood, 0=direct, >0=explicit route)")
+    path_hash_mode: int = Field(
+        description="Path hash mode (-1=flood, 0=1-byte, 1=2-byte, 2=3-byte hop identifiers)"
+    )
 
 
 class ContactUpsert(BaseModel):
@@ -12,9 +22,10 @@ class ContactUpsert(BaseModel):
     name: str | None = None
     type: int = 0
     flags: int = 0
-    last_path: str | None = None
-    last_path_len: int = -1
-    out_path_hash_mode: int | None = None
+    direct_path: str | None = None
+    direct_path_len: int | None = None
+    direct_path_hash_mode: int | None = None
+    direct_path_updated_at: int | None = None
     route_override_path: str | None = None
     route_override_len: int | None = None
     route_override_hash_mode: int | None = None
@@ -40,7 +51,7 @@ class ContactUpsert(BaseModel):
         cls, public_key: str, radio_data: dict, on_radio: bool = False
     ) -> "ContactUpsert":
         """Convert radio contact data to the contact-row write shape."""
-        last_path, last_path_len, out_path_hash_mode = normalize_contact_route(
+        direct_path, direct_path_len, direct_path_hash_mode = normalize_contact_route(
             radio_data.get("out_path"),
             radio_data.get("out_path_len", -1),
             radio_data.get(
@@ -53,9 +64,9 @@ class ContactUpsert(BaseModel):
             name=radio_data.get("adv_name"),
             type=radio_data.get("type", 0),
             flags=radio_data.get("flags", 0),
-            last_path=last_path,
-            last_path_len=last_path_len,
-            out_path_hash_mode=out_path_hash_mode,
+            direct_path=direct_path,
+            direct_path_len=direct_path_len,
+            direct_path_hash_mode=direct_path_hash_mode,
             lat=radio_data.get("adv_lat"),
             lon=radio_data.get("adv_lon"),
             last_advert=radio_data.get("last_advert"),
@@ -68,9 +79,10 @@ class Contact(BaseModel):
     name: str | None = None
     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 = 0
+    direct_path: str | None = None
+    direct_path_len: int = -1
+    direct_path_hash_mode: int = -1
+    direct_path_updated_at: int | None = None
     route_override_path: str | None = None
     route_override_len: int | None = None
     route_override_hash_mode: int | None = None
@@ -82,38 +94,99 @@ class Contact(BaseModel):
     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
+    effective_route: ContactRoute | None = None
+    effective_route_source: Literal["override", "direct", "flood"] = "flood"
+    direct_route: ContactRoute | None = None
+    route_override: ContactRoute | None = None
+
+    def model_post_init(self, __context) -> None:
+        direct_path, direct_path_len, direct_path_hash_mode = normalize_contact_route(
+            self.direct_path,
+            self.direct_path_len,
+            self.direct_path_hash_mode,
+        )
+        self.direct_path = direct_path or None
+        self.direct_path_len = direct_path_len
+        self.direct_path_hash_mode = direct_path_hash_mode
+
+        route_override_path, route_override_len, route_override_hash_mode = (
+            normalize_route_override(
+                self.route_override_path,
+                self.route_override_len,
+                self.route_override_hash_mode,
+            )
+        )
+        self.route_override_path = route_override_path or None
+        self.route_override_len = route_override_len
+        self.route_override_hash_mode = route_override_hash_mode
+        if (
+            route_override_path is not None
+            and route_override_len is not None
+            and route_override_hash_mode is not None
+        ):
+            self.route_override = ContactRoute(
+                path=route_override_path,
+                path_len=route_override_len,
+                path_hash_mode=route_override_hash_mode,
+            )
+        else:
+            self.route_override = None
+
+        if direct_path_len >= 0:
+            self.direct_route = ContactRoute(
+                path=direct_path,
+                path_len=direct_path_len,
+                path_hash_mode=direct_path_hash_mode,
+            )
+        else:
+            self.direct_route = None
+
+        path, path_len, path_hash_mode = self.effective_route_tuple()
+        if self.has_route_override():
+            self.effective_route_source = "override"
+        elif self.direct_route is not None:
+            self.effective_route_source = "direct"
+        else:
+            self.effective_route_source = "flood"
+        self.effective_route = ContactRoute(
+            path=path,
+            path_len=path_len,
+            path_hash_mode=path_hash_mode,
+        )
 
     def has_route_override(self) -> bool:
         return self.route_override_len is not None
 
-    def effective_route(self) -> tuple[str, int, int]:
+    def effective_route_tuple(self) -> tuple[str, int, int]:
         if self.has_route_override():
             return normalize_contact_route(
                 self.route_override_path,
                 self.route_override_len,
                 self.route_override_hash_mode,
             )
-        return normalize_contact_route(
-            self.last_path,
-            self.last_path_len,
-            self.out_path_hash_mode,
-        )
+        if self.direct_path_len >= 0:
+            return normalize_contact_route(
+                self.direct_path,
+                self.direct_path_len,
+                self.direct_path_hash_mode,
+            )
+        return "", -1, -1
 
     def to_radio_dict(self) -> dict:
         """Convert to the dict format expected by meshcore radio commands.
 
         The radio API uses different field names (adv_name, out_path, etc.)
-        than our database schema (name, last_path, etc.).
+        than our database schema (name, direct_path, etc.).
         """
-        last_path, last_path_len, out_path_hash_mode = self.effective_route()
+        effective_path, effective_path_len, effective_path_hash_mode = self.effective_route_tuple()
         return {
             "public_key": self.public_key,
             "adv_name": self.name or "",
             "type": self.type,
             "flags": self.flags,
-            "out_path": last_path,
-            "out_path_len": last_path_len,
-            "out_path_hash_mode": out_path_hash_mode,
+            "out_path": effective_path,
+            "out_path_len": effective_path_len,
+            "out_path_hash_mode": effective_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,
@@ -149,7 +222,7 @@ class ContactRoutingOverrideRequest(BaseModel):
 
     route: str = Field(
         description=(
-            "Blank clears the override and resets learned routing to flood, "
+            "Blank clears the override, "
             '"-1" forces flood, "0" forces direct, and explicit routes are '
             "comma-separated 1/2/3-byte hop hex values"
         )
@@ -158,6 +231,7 @@ class ContactRoutingOverrideRequest(BaseModel):
 
 # Contact type constants
 CONTACT_TYPE_REPEATER = 2
+CONTACT_TYPE_ROOM = 3
 
 
 class ContactAdvertPath(BaseModel):
@@ -347,6 +421,12 @@ class MessagesAroundResponse(BaseModel):
     has_newer: bool
 
 
+class ResendChannelMessageResponse(BaseModel):
+    status: str
+    message_id: int
+    message: Message | None = None
+
+
 class RawPacketDecryptedInfo(BaseModel):
     """Decryption info for a raw packet (when successfully decrypted)."""
 
@@ -404,6 +484,11 @@ class RepeaterLoginResponse(BaseModel):
     """Response from repeater login."""
 
     status: str = Field(description="Login result status")
+    authenticated: bool = Field(description="Whether repeater authentication was confirmed")
+    message: str | None = Field(
+        default=None,
+        description="Optional warning or error message when authentication was not confirmed",
+    )
 
 
 class RepeaterStatusResponse(BaseModel):
@@ -428,8 +513,17 @@ class RepeaterStatusResponse(BaseModel):
     full_events: int = Field(description="Full event queue count")
 
 
+class RepeaterNodeInfoResponse(BaseModel):
+    """Identity/location info from a repeater (small CLI batch)."""
+
+    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 RepeaterRadioSettingsResponse(BaseModel):
-    """Radio settings from a repeater (batch CLI get commands)."""
+    """Radio settings from a repeater (radio/config CLI batch)."""
 
     firmware_version: str | None = Field(default=None, description="Firmware version string")
     radio: str | None = Field(default=None, description="Radio settings (freq,bw,sf,cr)")
@@ -437,10 +531,6 @@ class RepeaterRadioSettingsResponse(BaseModel):
     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):
@@ -519,6 +609,30 @@ class TraceResponse(BaseModel):
     path_len: int = Field(description="Number of hops in the trace path")
 
 
+class PathDiscoveryRoute(BaseModel):
+    """One resolved route returned by contact path discovery."""
+
+    path: str = Field(description="Hex-encoded path bytes")
+    path_len: int = Field(description="Hop count for this route")
+    path_hash_mode: int = Field(
+        description="Path hash mode (0=1-byte, 1=2-byte, 2=3-byte hop identifiers)"
+    )
+
+
+class PathDiscoveryResponse(BaseModel):
+    """Round-trip routing data for a contact path discovery request."""
+
+    contact: Contact = Field(
+        description="Updated contact row after saving the learned forward path"
+    )
+    forward_path: PathDiscoveryRoute = Field(
+        description="Route used from the local radio to the target contact"
+    )
+    return_path: PathDiscoveryRoute = Field(
+        description="Route used from the target contact back to the local radio"
+    )
+
+
 class CommandRequest(BaseModel):
     """Request to send a CLI command to a repeater."""
 
@@ -535,6 +649,48 @@ class CommandResponse(BaseModel):
     )
 
 
+class RadioDiscoveryRequest(BaseModel):
+    """Request to discover nearby mesh nodes from the local radio."""
+
+    target: Literal["repeaters", "sensors", "all"] = Field(
+        default="all",
+        description="Which node classes to discover over the mesh",
+    )
+
+
+class RadioDiscoveryResult(BaseModel):
+    """One mesh node heard during a discovery sweep."""
+
+    public_key: str = Field(description="Discovered node public key as hex")
+    node_type: Literal["repeater", "sensor"] = Field(description="Discovered node class")
+    heard_count: int = Field(default=1, description="How many responses were heard from this node")
+    local_snr: float | None = Field(
+        default=None,
+        description="SNR at which the local radio heard the response (dB)",
+    )
+    local_rssi: int | None = Field(
+        default=None,
+        description="RSSI at which the local radio heard the response (dBm)",
+    )
+    remote_snr: float | None = Field(
+        default=None,
+        description="SNR reported by the remote node while hearing our discovery request (dB)",
+    )
+
+
+class RadioDiscoveryResponse(BaseModel):
+    """Response payload for a mesh discovery sweep."""
+
+    target: Literal["repeaters", "sensors", "all"] = Field(
+        description="Which node classes were requested"
+    )
+    duration_seconds: float = Field(description="How long the sweep listened for responses")
+    results: list[RadioDiscoveryResult] = Field(
+        default_factory=list,
+        description="Deduplicated discovery responses heard during the sweep",
+    )
+
+
 class Favorite(BaseModel):
     """A favorite conversation."""
 
@@ -554,6 +710,9 @@ class UnreadCounts(BaseModel):
     last_message_times: dict[str, int] = Field(
         default_factory=dict, description="Map of stateKey -> last message timestamp"
     )
+    last_read_ats: dict[str, int | None] = Field(
+        default_factory=dict, description="Map of stateKey -> server-side last_read_at boundary"
+    )
 
 
 class AppSettings(BaseModel):

app/packet_processor.py

@@ -26,6 +26,7 @@ from app.decoder import (
     parse_packet,
     try_decrypt_dm,
     try_decrypt_packet_with_channel_key,
+    try_decrypt_path,
 )
 from app.keystore import get_private_key, get_public_key, has_private_key
 from app.models import (
@@ -40,7 +41,11 @@ from app.repository import (
     ContactRepository,
     RawPacketRepository,
 )
-from app.services.contact_reconciliation import record_contact_name_and_reconcile
+from app.services.contact_reconciliation import (
+    promote_prefix_contacts_for_contact,
+    record_contact_name_and_reconcile,
+)
+from app.services.dm_ack_apply import apply_dm_ack_code
 from app.services.messages import (
     create_dm_message_from_decrypted as _create_dm_message_from_decrypted,
 )
@@ -315,8 +320,7 @@ async def process_raw_packet(
 
     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.
+        # advert-history table retains recent path observations.
         await _process_advertisement(raw_bytes, ts, packet_info)
 
     elif payload_type == PayloadType.TEXT_MESSAGE:
@@ -325,6 +329,9 @@ async def process_raw_packet(
         if decrypt_result:
             result.update(decrypt_result)
 
+    elif payload_type == PayloadType.PATH:
+        await _process_path_packet(raw_bytes, ts, packet_info)
+
     # Always broadcast raw packet for the packet feed UI (even duplicates)
     # This enables the frontend cracker to see all incoming packets in real-time
     broadcast_payload = RawPacketBroadcast(
@@ -422,60 +429,30 @@ async def _process_advertisement(
         logger.debug("Failed to parse advertisement packet")
         return
 
-    advert = parse_advertisement(packet_info.payload)
+    advert = parse_advertisement(packet_info.payload, raw_packet=raw_bytes)
     if not advert:
         logger.debug("Failed to parse advertisement payload")
         return
 
-    # Extract path info from packet
     new_path_len = packet_info.path_length
     new_path_hex = packet_info.path.hex() if packet_info.path else ""
 
     # Try to find existing contact
     existing = await ContactRepository.get_by_key(advert.public_key.lower())
 
-    # Determine which path to use: keep shorter path if heard recently (within 60s)
-    # This handles advertisement echoes through different routes
-    PATH_FRESHNESS_SECONDS = 60
-    use_existing_path = False
-
-    if existing and existing.last_seen:
-        path_age = timestamp - existing.last_seen
-        existing_path_len = existing.last_path_len if existing.last_path_len >= 0 else float("inf")
-
-        # Keep existing path if it's fresh and shorter (or equal)
-        if path_age <= PATH_FRESHNESS_SECONDS and existing_path_len <= new_path_len:
-            use_existing_path = True
-            logger.debug(
-                "Keeping existing shorter path for %s (existing=%d, new=%d, age=%ds)",
-                advert.public_key[:12],
-                existing_path_len,
-                new_path_len,
-                path_age,
-            )
-
-    if use_existing_path:
-        assert existing is not None  # Guaranteed by the conditions that set use_existing_path
-        path_len = existing.last_path_len if existing.last_path_len is not None else -1
-        path_hex = existing.last_path or ""
-        out_path_hash_mode = existing.out_path_hash_mode
-    else:
-        path_len = new_path_len
-        path_hex = new_path_hex
-        out_path_hash_mode = packet_info.path_hash_size - 1
-
     logger.debug(
-        "Parsed advertisement from %s: %s (role=%d, lat=%s, lon=%s, path_len=%d)",
+        "Parsed advertisement from %s: %s (role=%d, lat=%s, lon=%s, advert_path_len=%d)",
         advert.public_key[:12],
         advert.name,
         advert.device_role,
         advert.lat,
         advert.lon,
-        path_len,
+        new_path_len,
     )
 
-    # Use device_role from advertisement for contact type (1=Chat, 2=Repeater, 3=Room, 4=Sensor)
-    # Use advert.timestamp for last_advert (sender's timestamp), receive timestamp for last_seen
+    # Use device_role from advertisement for contact type (1=Chat, 2=Repeater, 3=Room, 4=Sensor).
+    # Persist advert freshness fields using the server receive wall clock so
+    # route selection is not affected by sender clock skew.
     contact_type = (
         advert.device_role if advert.device_role > 0 else (existing.type if existing else 0)
     )
@@ -495,15 +472,16 @@ async def _process_advertisement(
         type=contact_type,
         lat=advert.lat,
         lon=advert.lon,
-        last_advert=advert.timestamp if advert.timestamp > 0 else timestamp,
+        last_advert=timestamp,
         last_seen=timestamp,
-        last_path=path_hex,
-        last_path_len=path_len,
-        out_path_hash_mode=out_path_hash_mode,
         first_seen=timestamp,  # COALESCE in upsert preserves existing value
     )
 
     await ContactRepository.upsert(contact_upsert)
+    promoted_keys = await promote_prefix_contacts_for_contact(
+        public_key=advert.public_key,
+        log=logger,
+    )
     await record_contact_name_and_reconcile(
         public_key=advert.public_key,
         contact_name=advert.name,
@@ -516,6 +494,14 @@ async def _process_advertisement(
     db_contact = await ContactRepository.get_by_key(advert.public_key.lower())
     if db_contact:
         broadcast_event("contact", db_contact.model_dump())
+        for old_key in promoted_keys:
+            broadcast_event(
+                "contact_resolved",
+                {
+                    "previous_public_key": old_key,
+                    "contact": db_contact.model_dump(),
+                },
+            )
     else:
         broadcast_event(
             "contact",
@@ -651,3 +637,90 @@ async def _process_direct_message(
     # Couldn't decrypt with any known contact
     logger.debug("Could not decrypt DM with any of %d candidate contacts", len(candidate_contacts))
     return None
+
+
+async def _process_path_packet(
+    raw_bytes: bytes,
+    timestamp: int,
+    packet_info: PacketInfo | None,
+) -> None:
+    """Process a PATH packet and update the learned direct route."""
+    if not has_private_key():
+        return
+
+    private_key = get_private_key()
+    our_public_key = get_public_key()
+    if private_key is None or our_public_key is None:
+        return
+
+    if packet_info is None:
+        packet_info = parse_packet(raw_bytes)
+    if packet_info is None or packet_info.payload is None or len(packet_info.payload) < 4:
+        return
+
+    dest_hash = format(packet_info.payload[0], "02x").lower()
+    src_hash = format(packet_info.payload[1], "02x").lower()
+    our_first_byte = format(our_public_key[0], "02x").lower()
+    if dest_hash != our_first_byte:
+        return
+
+    candidate_contacts = await ContactRepository.get_by_pubkey_first_byte(src_hash)
+    if not candidate_contacts:
+        logger.debug("No contacts found matching hash %s for PATH decryption", src_hash)
+        return
+
+    for contact in candidate_contacts:
+        if len(contact.public_key) != 64:
+            continue
+        try:
+            contact_public_key = bytes.fromhex(contact.public_key)
+        except ValueError:
+            continue
+
+        result = try_decrypt_path(
+            raw_packet=raw_bytes,
+            our_private_key=private_key,
+            their_public_key=contact_public_key,
+            our_public_key=our_public_key,
+        )
+        if result is None:
+            continue
+
+        await ContactRepository.update_direct_path(
+            contact.public_key,
+            result.returned_path.hex(),
+            result.returned_path_len,
+            result.returned_path_hash_mode,
+            updated_at=timestamp,
+        )
+
+        if result.extra_type == PayloadType.ACK and len(result.extra) >= 4:
+            ack_code = result.extra[:4].hex()
+            matched = await apply_dm_ack_code(ack_code, broadcast_fn=broadcast_event)
+            if matched:
+                logger.info(
+                    "Applied bundled PATH ACK for %s via contact %s",
+                    ack_code,
+                    contact.public_key[:12],
+                )
+            else:
+                logger.debug(
+                    "Buffered bundled PATH ACK %s via contact %s",
+                    ack_code,
+                    contact.public_key[:12],
+                )
+        elif result.extra_type == PayloadType.RESPONSE and len(result.extra) > 0:
+            logger.debug(
+                "Observed bundled PATH RESPONSE from %s (%d bytes)",
+                contact.public_key[:12],
+                len(result.extra),
+            )
+
+        refreshed_contact = await ContactRepository.get_by_key(contact.public_key)
+        if refreshed_contact is not None:
+            broadcast_event("contact", refreshed_contact.model_dump())
+        return
+
+    logger.debug(
+        "Could not decrypt PATH packet with any of %d candidate contacts", len(candidate_contacts)
+    )

app/path_utils.py

@@ -153,12 +153,12 @@ def first_hop_hex(path_hex: str, hop_count: int) -> str | None:
 def normalize_contact_route(
     path_hex: str | None,
     path_len: int | None,
-    out_path_hash_mode: int | None,
+    path_hash_mode: int | None,
 ) -> tuple[str, int, int]:
     """Normalize stored contact route fields.
 
     Handles legacy/bad rows where the packed wire path byte was stored directly
-    in `last_path_len` (sometimes as a signed byte, e.g. `-125` for `0x83`).
+    in the hop-count column (sometimes as a signed byte, e.g. `-125` for `0x83`).
     Returns `(path_hex, hop_count, hash_mode)`.
     """
     normalized_path = path_hex or ""
@@ -169,7 +169,7 @@ def normalize_contact_route(
         normalized_len = -1
 
     try:
-        normalized_mode = int(out_path_hash_mode) if out_path_hash_mode is not None else None
+        normalized_mode = int(path_hash_mode) if path_hash_mode is not None else None
     except (TypeError, ValueError):
         normalized_mode = None
 
@@ -207,7 +207,7 @@ def normalize_contact_route(
 def normalize_route_override(
     path_hex: str | None,
     path_len: int | None,
-    out_path_hash_mode: int | None,
+    path_hash_mode: int | None,
 ) -> tuple[str | None, int | None, int | None]:
     """Normalize optional route-override fields while preserving the unset state."""
     if path_len is None:
@@ -216,7 +216,7 @@ def normalize_route_override(
     normalized_path, normalized_len, normalized_mode = normalize_contact_route(
         path_hex,
         path_len,
-        out_path_hash_mode,
+        path_hash_mode,
     )
     return normalized_path, normalized_len, normalized_mode
 

app/radio.py

@@ -2,14 +2,20 @@ import asyncio
 import glob
 import logging
 import platform
+import re
+from collections import OrderedDict
 from contextlib import asynccontextmanager, nullcontext
 from pathlib import Path
 
 from meshcore import MeshCore
+from serial.serialutil import SerialException
 
 from app.config import settings
+from app.keystore import clear_keys
 
 logger = logging.getLogger(__name__)
+MAX_FRONTEND_RECONNECT_ERROR_BROADCASTS = 3
+_SERIAL_PORT_ERROR_RE = re.compile(r"could not open port (?P<port>.+?):")
 
 
 class RadioOperationError(RuntimeError):
@@ -66,6 +72,36 @@ def detect_serial_devices() -> list[str]:
     return devices
 
 
+def _extract_serial_port_from_error(exc: Exception) -> str | None:
+    """Best-effort extraction of a serial port path from a pyserial error."""
+    message = str(exc)
+    match = _SERIAL_PORT_ERROR_RE.search(message)
+    if match:
+        return match.group("port")
+    return None
+
+
+def _format_reconnect_failure(exc: Exception) -> tuple[str, str, bool]:
+    """Return log message, frontend detail, and whether to log a traceback."""
+    if settings.connection_type == "serial":
+        if isinstance(exc, RuntimeError) and str(exc).startswith("No MeshCore radio found"):
+            message = (
+                "Could not find a MeshCore radio on any serial port. "
+                "Did the radio get disconnected or change serial ports?"
+            )
+            return (message, message, False)
+
+        if isinstance(exc, SerialException):
+            port = settings.serial_port or _extract_serial_port_from_error(exc) or "the serial port"
+            message = (
+                f"Could not connect to serial port {port}. "
+                "Did the radio get disconnected or change serial ports?"
+            )
+            return (message, message, False)
+
+    return (f"Reconnection failed: {exc}", str(exc), True)
+
+
 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
@@ -129,8 +165,18 @@ class RadioManager:
         self._setup_lock: asyncio.Lock | None = None
         self._setup_in_progress: bool = False
         self._setup_complete: bool = False
+        self._frontend_reconnect_error_broadcasts: int = 0
+        self.device_info_loaded: bool = False
+        self.max_contacts: int | None = None
+        self.device_model: str | None = None
+        self.firmware_build: str | None = None
+        self.firmware_version: str | None = None
+        self.max_channels: int = 40
         self.path_hash_mode: int = 0
         self.path_hash_mode_supported: bool = False
+        self._channel_slot_by_key: OrderedDict[str, int] = OrderedDict()
+        self._channel_key_by_slot: dict[int, str] = {}
+        self._pending_message_channel_key_by_slot: dict[int, str] = {}
 
     async def _acquire_operation_lock(
         self,
@@ -160,6 +206,20 @@ class RadioManager:
         else:
             logger.error("Attempted to release unlocked radio operation lock (%s)", name)
 
+    def _reset_connected_runtime_state(self) -> None:
+        """Clear cached runtime state after a transport teardown completes."""
+        self._setup_complete = False
+        self.device_info_loaded = False
+        self.max_contacts = None
+        self.device_model = None
+        self.firmware_build = None
+        self.firmware_version = None
+        self.max_channels = 40
+        self.path_hash_mode = 0
+        self.path_hash_mode_supported = False
+        self.reset_channel_send_cache()
+        self.clear_pending_message_channel_slots()
+
     @asynccontextmanager
     async def radio_operation(
         self,
@@ -223,6 +283,121 @@ class RadioManager:
 
         await run_post_connect_setup(self)
 
+    def reset_channel_send_cache(self) -> None:
+        """Forget any session-local channel-slot reuse state."""
+        self._channel_slot_by_key.clear()
+        self._channel_key_by_slot.clear()
+
+    def remember_pending_message_channel_slot(self, channel_key: str, slot: int) -> None:
+        """Remember a channel key for later queued-message recovery."""
+        self._pending_message_channel_key_by_slot[slot] = channel_key.upper()
+
+    def get_pending_message_channel_key(self, slot: int) -> str | None:
+        """Return the last remembered channel key for a radio slot."""
+        return self._pending_message_channel_key_by_slot.get(slot)
+
+    def clear_pending_message_channel_slots(self) -> None:
+        """Drop any queued-message recovery slot metadata."""
+        self._pending_message_channel_key_by_slot.clear()
+
+    def channel_slot_reuse_enabled(self) -> bool:
+        """Return whether this transport can safely reuse cached channel slots."""
+        if settings.force_channel_slot_reconfigure:
+            return False
+        if self._connection_info:
+            return not self._connection_info.startswith("TCP:")
+        return settings.connection_type != "tcp"
+
+    def get_channel_send_cache_capacity(self) -> int:
+        """Return the app-managed channel cache capacity for the current session."""
+        try:
+            return max(1, int(self.max_channels))
+        except (TypeError, ValueError):
+            return 1
+
+    def get_cached_channel_slot(self, channel_key: str) -> int | None:
+        """Return the cached radio slot for a channel key, if present."""
+        return self._channel_slot_by_key.get(channel_key.upper())
+
+    def plan_channel_send_slot(
+        self,
+        channel_key: str,
+        *,
+        preferred_slot: int = 0,
+    ) -> tuple[int, bool, str | None]:
+        """Choose a radio slot for a channel send.
+
+        Returns `(slot, needs_configure, evicted_channel_key)`.
+        """
+        if not self.channel_slot_reuse_enabled():
+            return preferred_slot, True, None
+
+        normalized_key = channel_key.upper()
+        cached_slot = self._channel_slot_by_key.get(normalized_key)
+        if cached_slot is not None:
+            return cached_slot, False, None
+
+        capacity = self.get_channel_send_cache_capacity()
+        if len(self._channel_slot_by_key) < capacity:
+            slot = self._find_first_free_channel_slot(capacity, preferred_slot)
+            return slot, True, None
+
+        evicted_key, slot = next(iter(self._channel_slot_by_key.items()))
+        return slot, True, evicted_key
+
+    def note_channel_slot_loaded(self, channel_key: str, slot: int) -> None:
+        """Record that a channel is now resident in the given radio slot."""
+        if not self.channel_slot_reuse_enabled():
+            return
+
+        normalized_key = channel_key.upper()
+        previous_slot = self._channel_slot_by_key.pop(normalized_key, None)
+        if previous_slot is not None and previous_slot != slot:
+            self._channel_key_by_slot.pop(previous_slot, None)
+
+        displaced_key = self._channel_key_by_slot.get(slot)
+        if displaced_key is not None and displaced_key != normalized_key:
+            self._channel_slot_by_key.pop(displaced_key, None)
+
+        self._channel_key_by_slot[slot] = normalized_key
+        self._channel_slot_by_key[normalized_key] = slot
+
+    def note_channel_slot_used(self, channel_key: str) -> None:
+        """Refresh LRU order for a previously loaded channel slot."""
+        if not self.channel_slot_reuse_enabled():
+            return
+
+        normalized_key = channel_key.upper()
+        slot = self._channel_slot_by_key.get(normalized_key)
+        if slot is None:
+            return
+        self._channel_slot_by_key.move_to_end(normalized_key)
+        self._channel_key_by_slot[slot] = normalized_key
+
+    def invalidate_cached_channel_slot(self, channel_key: str) -> None:
+        """Drop any cached slot assignment for a channel key."""
+        normalized_key = channel_key.upper()
+        slot = self._channel_slot_by_key.pop(normalized_key, None)
+        if slot is None:
+            return
+        if self._channel_key_by_slot.get(slot) == normalized_key:
+            self._channel_key_by_slot.pop(slot, None)
+
+    def get_channel_send_cache_snapshot(self) -> list[tuple[str, int]]:
+        """Return the current channel send cache contents in LRU order."""
+        return list(self._channel_slot_by_key.items())
+
+    def _find_first_free_channel_slot(self, capacity: int, preferred_slot: int) -> int:
+        """Pick the first unclaimed app-managed slot, preferring the requested slot."""
+        if preferred_slot < capacity and preferred_slot not in self._channel_key_by_slot:
+            return preferred_slot
+
+        for slot in range(capacity):
+            if slot not in self._channel_key_by_slot:
+                return slot
+
+        return preferred_slot
+
     @property
     def meshcore(self) -> MeshCore | None:
         return self._meshcore
@@ -261,6 +436,21 @@ class RadioManager:
         self._last_connected = False
         await self.disconnect()
 
+    def _reset_reconnect_error_broadcasts(self) -> None:
+        self._frontend_reconnect_error_broadcasts = 0
+
+    def _broadcast_reconnect_error_if_needed(self, details: str) -> None:
+        from app.websocket import broadcast_error
+
+        self._frontend_reconnect_error_broadcasts += 1
+        if self._frontend_reconnect_error_broadcasts > MAX_FRONTEND_RECONNECT_ERROR_BROADCASTS:
+            return
+
+        if self._frontend_reconnect_error_broadcasts == MAX_FRONTEND_RECONNECT_ERROR_BROADCASTS:
+            details = f"{details} Further reconnect failures will be logged only until a connection succeeds."
+
+        broadcast_error("Reconnection failed", details)
+
     async def _disable_meshcore_auto_reconnect(self, mc: MeshCore) -> None:
         """Disable library-managed reconnects so manual teardown fully releases transport."""
         connection_manager = getattr(mc, "connection_manager", None)
@@ -358,17 +548,30 @@ class RadioManager:
 
     async def disconnect(self) -> None:
         """Disconnect from the radio."""
-        if self._meshcore is not None:
-            logger.debug("Disconnecting from radio")
+        clear_keys()
+        self._reset_reconnect_error_broadcasts()
+        if self._meshcore is None:
+            return
+
+        await self._acquire_operation_lock("disconnect", blocking=True)
+        try:
             mc = self._meshcore
+            if mc is None:
+                return
+
+            logger.debug("Disconnecting from radio")
             await self._disable_meshcore_auto_reconnect(mc)
-            await mc.disconnect()
-            await self._disable_meshcore_auto_reconnect(mc)
-            self._meshcore = None
-            self._setup_complete = False
-            self.path_hash_mode = 0
-            self.path_hash_mode_supported = False
+            try:
+                await mc.disconnect()
+            finally:
+                await self._disable_meshcore_auto_reconnect(mc)
+
+            if self._meshcore is mc:
+                self._meshcore = None
+            self._reset_connected_runtime_state()
             logger.debug("Radio disconnected")
+        finally:
+            self._release_operation_lock("disconnect")
 
     async def reconnect(self, *, broadcast_on_success: bool = True) -> bool:
         """Attempt to reconnect to the radio.
@@ -376,7 +579,7 @@ class RadioManager:
         Returns True if reconnection was successful, False otherwise.
         Uses a lock to prevent concurrent reconnection attempts.
         """
-        from app.websocket import broadcast_error, broadcast_health
+        from app.websocket import broadcast_health
 
         # Lazily initialize lock (can't create in __init__ before event loop exists)
         if self._reconnect_lock is None:
@@ -399,10 +602,9 @@ class RadioManager:
                 # Disconnect if we have a stale connection
                 if self._meshcore is not None:
                     try:
-                        await self._meshcore.disconnect()
+                        await self.disconnect()
                     except Exception:
                         pass
-                    self._meshcore = None
 
                 # Try to connect (will auto-detect if no port specified)
                 await self.connect()
@@ -414,6 +616,7 @@ class RadioManager:
 
                 if self.is_connected:
                     logger.info("Radio reconnected successfully at %s", self._connection_info)
+                    self._reset_reconnect_error_broadcasts()
                     if broadcast_on_success:
                         broadcast_health(True, self._connection_info)
                     return True
@@ -422,8 +625,9 @@ class RadioManager:
                     return False
 
             except Exception as e:
-                logger.warning("Reconnection failed: %s", e, exc_info=True)
-                broadcast_error("Reconnection failed", str(e))
+                log_message, frontend_detail, include_traceback = _format_reconnect_failure(e)
+                logger.warning(log_message, exc_info=include_traceback)
+                self._broadcast_reconnect_error_if_needed(frontend_detail)
                 return False
 
     async def start_connection_monitor(self) -> None:

app/radio_sync.py

@@ -14,9 +14,11 @@ import logging
 import math
 import time
 from contextlib import asynccontextmanager
+from typing import Literal
 
 from meshcore import EventType, MeshCore
 
+from app.channel_constants import PUBLIC_CHANNEL_KEY, PUBLIC_CHANNEL_NAME
 from app.config import settings
 from app.event_handlers import cleanup_expired_acks
 from app.models import Contact, ContactUpsert
@@ -28,27 +30,32 @@ from app.repository import (
     ContactRepository,
 )
 from app.services.contact_reconciliation import reconcile_contact_messages
+from app.services.messages import create_fallback_channel_message
 from app.services.radio_runtime import radio_runtime as radio_manager
-from app.websocket import broadcast_error
+from app.websocket import broadcast_error, broadcast_event
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_MAX_CHANNELS = 40
+
+AdvertMode = Literal["flood", "zero_hop"]
+
 
 def _contact_sync_debug_fields(contact: Contact) -> dict[str, object]:
     """Return key contact fields for sync failure diagnostics."""
     return {
         "type": contact.type,
         "flags": contact.flags,
-        "last_path": contact.last_path,
-        "last_path_len": contact.last_path_len,
-        "out_path_hash_mode": contact.out_path_hash_mode,
+        "direct_path": contact.direct_path,
+        "direct_path_len": contact.direct_path_len,
+        "direct_path_hash_mode": contact.direct_path_hash_mode,
+        "direct_path_updated_at": contact.direct_path_updated_at,
         "route_override_path": contact.route_override_path,
         "route_override_len": contact.route_override_len,
         "route_override_hash_mode": contact.route_override_hash_mode,
         "last_advert": contact.last_advert,
         "lat": contact.lat,
         "lon": contact.lon,
-        "on_radio": contact.on_radio,
     }
 
 
@@ -98,6 +105,20 @@ async def upsert_channel_from_radio_slot(payload: dict, *, on_radio: bool) -> st
     return key_hex
 
 
+def get_radio_channel_limit(max_channels: int | None = None) -> int:
+    """Return the effective channel-slot limit for the connected firmware."""
+    discovered = getattr(radio_manager, "max_channels", DEFAULT_MAX_CHANNELS)
+    try:
+        limit = max(1, int(discovered))
+    except (TypeError, ValueError):
+        limit = DEFAULT_MAX_CHANNELS
+
+    if max_channels is not None:
+        return min(limit, max(1, int(max_channels)))
+
+    return limit
+
+
 # Message poll task handle
 _message_poll_task: asyncio.Task | None = None
 
@@ -285,7 +306,7 @@ async def sync_and_offload_contacts(mc: MeshCore) -> dict:
     return {"synced": synced, "removed": removed}
 
 
-async def sync_and_offload_channels(mc: MeshCore) -> dict:
+async def sync_and_offload_channels(mc: MeshCore, max_channels: int | None = None) -> dict:
     """
     Sync channels from radio to database, then clear them from radio.
     Returns counts of synced and cleared channels.
@@ -294,8 +315,11 @@ async def sync_and_offload_channels(mc: MeshCore) -> dict:
     cleared = 0
 
     try:
-        # Check all 40 channel slots
-        for idx in range(40):
+        radio_manager.reset_channel_send_cache()
+        channel_limit = get_radio_channel_limit(max_channels)
+
+        # Check all available channel slots for this firmware variant
+        for idx in range(channel_limit):
             result = await mc.commands.get_channel(idx)
 
             if result.type != EventType.CHANNEL_INFO:
@@ -308,6 +332,7 @@ async def sync_and_offload_channels(mc: MeshCore) -> dict:
             if key_hex is None:
                 continue
 
+            radio_manager.remember_pending_message_channel_slot(key_hex, idx)
             synced += 1
             logger.debug("Synced channel %s: %s", key_hex[:8], result.payload.get("channel_name"))
 
@@ -334,23 +359,102 @@ async def sync_and_offload_channels(mc: MeshCore) -> dict:
     return {"synced": synced, "cleared": cleared}
 
 
+def _split_channel_sender_and_text(text: str) -> tuple[str | None, str]:
+    """Parse the canonical MeshCore "<sender>: <message>" channel text format."""
+    sender = None
+    message_text = text
+    colon_idx = text.find(": ")
+    if 0 < colon_idx < 50:
+        potential_sender = text[:colon_idx]
+        if not any(char in potential_sender for char in ":[]\x00"):
+            sender = potential_sender
+            message_text = text[colon_idx + 2 :]
+    return sender, message_text
+
+
+async def _resolve_channel_for_pending_message(
+    mc: MeshCore,
+    channel_idx: int,
+) -> tuple[str | None, str | None]:
+    """Resolve a pending channel message's slot to a channel key and name."""
+    try:
+        result = await mc.commands.get_channel(channel_idx)
+    except Exception as exc:
+        logger.debug("Failed to fetch channel slot %s for pending message: %s", channel_idx, exc)
+    else:
+        if result.type == EventType.CHANNEL_INFO:
+            key_hex = await upsert_channel_from_radio_slot(result.payload, on_radio=False)
+            if key_hex is not None:
+                radio_manager.remember_pending_message_channel_slot(key_hex, channel_idx)
+                return key_hex, result.payload.get("channel_name") or None
+
+    current_slot_map = getattr(radio_manager, "_channel_key_by_slot", {})
+    cached_key = current_slot_map.get(channel_idx)
+    if cached_key is None:
+        cached_key = radio_manager.get_pending_message_channel_key(channel_idx)
+    if cached_key is None:
+        return None, None
+
+    channel = await ChannelRepository.get_by_key(cached_key)
+    return cached_key, channel.name if channel else None
+
+
+async def _store_pending_channel_message(mc: MeshCore, payload: dict) -> None:
+    """Persist a CHANNEL_MSG_RECV event pulled via get_msg()."""
+    channel_idx = payload.get("channel_idx")
+    if channel_idx is None:
+        logger.warning("Pending channel message missing channel_idx; dropping payload")
+        return
+
+    try:
+        normalized_channel_idx = int(channel_idx)
+    except (TypeError, ValueError):
+        logger.warning("Pending channel message had invalid channel_idx=%r", channel_idx)
+        return
+
+    channel_key, channel_name = await _resolve_channel_for_pending_message(
+        mc, normalized_channel_idx
+    )
+    if channel_key is None:
+        logger.warning(
+            "Could not resolve channel slot %d for pending message; message cannot be stored",
+            normalized_channel_idx,
+        )
+        return
+
+    received_at = int(time.time())
+    sender_timestamp = payload.get("sender_timestamp") or received_at
+    sender_name, message_text = _split_channel_sender_and_text(payload.get("text", ""))
+
+    await create_fallback_channel_message(
+        conversation_key=channel_key,
+        message_text=message_text,
+        sender_timestamp=sender_timestamp,
+        received_at=received_at,
+        path=payload.get("path"),
+        path_len=payload.get("path_len"),
+        txt_type=payload.get("txt_type", 0),
+        sender_name=sender_name,
+        channel_name=channel_name,
+        broadcast_fn=broadcast_event,
+    )
+
+
 async def ensure_default_channels() -> None:
     """
     Ensure default channels exist in the database.
     These will be configured on the radio when needed for sending.
 
-    The Public channel is protected - it always exists with the canonical name.
+    This seeds the canonical Public channel row in the database if it is missing
+    or misnamed. It does not make the channel undeletable through the router.
     """
-    # Public channel - no hashtag, specific well-known key
-    PUBLIC_CHANNEL_KEY_HEX = "8B3387E9C5CDEA6AC9E5EDBAA115CD72"
-
     # Check by KEY (not name) since that's what's fixed
-    existing = await ChannelRepository.get_by_key(PUBLIC_CHANNEL_KEY_HEX)
-    if not existing or existing.name != "Public":
+    existing = await ChannelRepository.get_by_key(PUBLIC_CHANNEL_KEY)
+    if not existing or existing.name != PUBLIC_CHANNEL_NAME:
         logger.info("Ensuring default Public channel exists with correct name")
         await ChannelRepository.upsert(
-            key=PUBLIC_CHANNEL_KEY_HEX,
-            name="Public",
+            key=PUBLIC_CHANNEL_KEY,
+            name=PUBLIC_CHANNEL_NAME,
             is_hashtag=False,
             on_radio=existing.on_radio if existing else False,
         )
@@ -360,16 +464,19 @@ 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")
 
+    # Contact on_radio is legacy/stale metadata. Clear it during the offload/reload
+    # cycle so old rows stop claiming radio residency we do not actively track.
+    await ContactRepository.clear_on_radio_except([])
+
     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 plus a working-set fill back onto the radio immediately
-    # so they do not stay in on_radio=False limbo after offload. Pass mc directly
-    # since the caller already holds the radio operation lock (asyncio.Lock is not
-    # reentrant).
+    # Reload favorites plus a working-set fill back onto the radio immediately.
+    # 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 {
@@ -399,6 +506,8 @@ async def drain_pending_messages(mc: MeshCore) -> int:
                 logger.debug("Error during message drain: %s", result.payload)
                 break
             elif result.type in (EventType.CONTACT_MSG_RECV, EventType.CHANNEL_MSG_RECV):
+                if result.type == EventType.CHANNEL_MSG_RECV:
+                    await _store_pending_channel_message(mc, result.payload)
                 count += 1
 
             # Small delay between fetches
@@ -434,6 +543,8 @@ async def poll_for_messages(mc: MeshCore) -> int:
         elif result.type == EventType.ERROR:
             return 0
         elif result.type in (EventType.CONTACT_MSG_RECV, EventType.CHANNEL_MSG_RECV):
+            if result.type == EventType.CHANNEL_MSG_RECV:
+                await _store_pending_channel_message(mc, result.payload)
             count += 1
             # If we got a message, there might be more - drain them
             count += await drain_pending_messages(mc)
@@ -446,6 +557,63 @@ async def poll_for_messages(mc: MeshCore) -> int:
     return count
 
 
+def _normalize_channel_secret(payload: dict) -> bytes:
+    """Return a normalized bytes representation of a radio channel secret."""
+    secret = payload.get("channel_secret", b"")
+    if isinstance(secret, bytes):
+        return secret
+    return bytes(secret)
+
+
+async def audit_channel_send_cache(mc: MeshCore) -> bool:
+    """Verify cached send-slot expectations still match radio channel contents.
+
+    If a mismatch is detected, the app's send-slot cache is reset so future sends
+    fall back to reloading channels before reuse resumes.
+    """
+    if not radio_manager.channel_slot_reuse_enabled():
+        return True
+
+    cached_slots = radio_manager.get_channel_send_cache_snapshot()
+    if not cached_slots:
+        return True
+
+    mismatches: list[str] = []
+    for channel_key, slot in cached_slots:
+        result = await mc.commands.get_channel(slot)
+        if result.type != EventType.CHANNEL_INFO:
+            mismatches.append(
+                f"slot {slot}: expected {channel_key[:8]} but radio returned {result.type}"
+            )
+            continue
+
+        observed_name = result.payload.get("channel_name") or ""
+        observed_key = _normalize_channel_secret(result.payload).hex().upper()
+        expected_channel = await ChannelRepository.get_by_key(channel_key)
+        expected_name = expected_channel.name if expected_channel is not None else None
+
+        if observed_key != channel_key or expected_name is None or observed_name != expected_name:
+            mismatches.append(
+                f"slot {slot}: expected {expected_name or '(missing db row)'} "
+                f"{channel_key[:8]}, got {observed_name or '(empty)'} {observed_key[:8]}"
+            )
+
+    if not mismatches:
+        return True
+
+    logger.error(
+        "[RADIO SYNC ERROR] A periodic radio audit discovered that the channel send-slot cache fell out of sync with radio state. This indicates that some other system, internal or external to the radio, has updated the channel slots on the radio (which the app assumes it has exclusive rights to, except on TCP-linked devices). The cache is resetting now, but you should review the README.md and consider using the environment variable MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE=true to make the radio use non-optimistic channel management and force-write the channel to radio before each send. This is a minor performance hit, but guarantees consistency. Mismatches found: %s",
+        "; ".join(mismatches),
+    )
+    radio_manager.reset_channel_send_cache()
+    broadcast_error(
+        "A periodic poll task has discovered radio inconsistencies.",
+        "Please check the logs for recommendations (search "
+        "'MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE').",
+    )
+    return False
+
+
 async def _message_poll_loop():
     """Background task that periodically polls for messages."""
     while True:
@@ -463,6 +631,7 @@ async def _message_poll_loop():
                         suspend_auto_fetch=True,
                     ) as mc:
                         count = await poll_for_messages(mc)
+                        await audit_channel_send_cache(mc)
                         if count > 0:
                             if aggressive_fallback:
                                 logger.warning(
@@ -471,10 +640,10 @@ async def _message_poll_loop():
                                 )
                             else:
                                 logger.error(
-                                    "Periodic radio audit caught %d message(s) that were not "
-                                    "surfaced via event subscription. See README and consider "
+                                    "[RADIO SYNC ERROR] Periodic radio audit caught %d message(s) that were not "
+                                    "surfaced via event subscription. This means that the method of event (new contacts, messages, etc.) awareness we want isn't giving us everything. There is a fallback method available; see README.md and consider "
                                     "setting MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK=true to "
-                                    "enable more frequent polling.",
+                                    "enable active radio polling every few seconds.",
                                     count,
                                 )
                                 broadcast_error(
@@ -521,7 +690,12 @@ async def stop_message_polling():
         logger.info("Stopped periodic message polling")
 
 
-async def send_advertisement(mc: MeshCore, *, force: bool = False) -> bool:
+async def send_advertisement(
+    mc: MeshCore,
+    *,
+    force: bool = False,
+    mode: AdvertMode = "flood",
+) -> bool:
     """Send an advertisement to announce presence on the mesh.
 
     Respects the configured advert_interval - won't send if not enough time
@@ -530,11 +704,15 @@ async def send_advertisement(mc: MeshCore, *, force: bool = False) -> bool:
     Args:
         mc: The MeshCore instance to use for the advertisement.
         force: If True, send immediately regardless of interval.
+        mode: Advertisement mode. Flood adverts use the persisted flood-advert
+            throttle state; zero-hop adverts currently send immediately.
 
     Returns True if successful, False otherwise (including if throttled).
     """
-    # Check if enough time has elapsed (unless forced)
-    if not force:
+    use_flood = mode == "flood"
+
+    # Only flood adverts currently participate in persisted throttle state.
+    if use_flood and not force:
         settings = await AppSettingsRepository.get()
         interval = settings.advert_interval
         last_time = settings.last_advert_time
@@ -561,18 +739,19 @@ async def send_advertisement(mc: MeshCore, *, force: bool = False) -> bool:
             return False
 
     try:
-        result = await mc.commands.send_advert(flood=True)
+        result = await mc.commands.send_advert(flood=use_flood)
         if result.type == EventType.OK:
-            # Update last_advert_time in database
-            now = int(time.time())
-            await AppSettingsRepository.update(last_advert_time=now)
-            logger.info("Advertisement sent successfully")
+            if use_flood:
+                # Track flood advert timing for periodic/startup throttling.
+                now = int(time.time())
+                await AppSettingsRepository.update(last_advert_time=now)
+            logger.info("%s advertisement sent successfully", mode.replace("_", "-"))
             return True
         else:
-            logger.warning("Failed to send advertisement: %s", result.payload)
+            logger.warning("Failed to send %s advertisement: %s", mode, result.payload)
             return False
     except Exception as e:
-        logger.warning("Error sending advertisement: %s", e, exc_info=True)
+        logger.warning("Error sending %s advertisement: %s", mode, e, exc_info=True)
         return False
 
 
@@ -604,7 +783,6 @@ async def _periodic_advert_loop():
             break
         except Exception as e:
             logger.error("Error in periodic advertisement loop: %s", e, exc_info=True)
-            await asyncio.sleep(ADVERT_CHECK_INTERVAL)
 
 
 def start_periodic_advert():
@@ -632,16 +810,177 @@ async def stop_periodic_advert():
         logger.info("Stopped periodic advertisement")
 
 
+# Prevents reboot-loop: once we've rebooted to fix clock skew this session,
+# don't do it again (the hardware RTC case can't be fixed by reboot).
+_clock_reboot_attempted: bool = False
+_CLOCK_WRAP_TARGET = 0xFFFFFFFF
+_CLOCK_WRAP_POLL_INTERVAL = 0.2
+_CLOCK_WRAP_TIMEOUT = 3.0
+
+
+async def _query_radio_time(mc: MeshCore) -> int | None:
+    """Return the radio's current epoch, or None if it can't be read."""
+    try:
+        result = await mc.commands.get_time()
+    except Exception:
+        return None
+    if result.payload is None:
+        return None
+    value = result.payload.get("time")
+    if isinstance(value, int):
+        return value
+    return None
+
+
+async def _attempt_clock_wraparound(mc: MeshCore, *, now: int, observed_radio_time: int) -> bool:
+    """Try the experimental uint32 wraparound trick, then retry normal time sync."""
+    logger.warning(
+        "Experimental __CLOWNTOWN_DO_CLOCK_WRAPAROUND enabled: attempting uint32 "
+        "clock wraparound before normal time sync (radio=%d, system=%d).",
+        observed_radio_time,
+        now,
+    )
+    result = await mc.commands.set_time(_CLOCK_WRAP_TARGET)
+    if result.type != EventType.OK:
+        logger.warning(
+            "Clock wraparound pre-step failed: set_time(%d) returned %s.",
+            _CLOCK_WRAP_TARGET,
+            result.type,
+        )
+        return False
+
+    deadline = time.monotonic() + _CLOCK_WRAP_TIMEOUT
+    wrapped_time: int | None = None
+    while time.monotonic() < deadline:
+        await asyncio.sleep(_CLOCK_WRAP_POLL_INTERVAL)
+        wrapped_time = await _query_radio_time(mc)
+        if wrapped_time is not None and wrapped_time < 60:
+            break
+    else:
+        wrapped_time = None
+
+    if wrapped_time is None:
+        logger.warning(
+            "Clock wraparound experiment did not observe a wrapped epoch within %.1f "
+            "seconds; falling back to normal recovery.",
+            _CLOCK_WRAP_TIMEOUT,
+        )
+        return False
+
+    logger.warning(
+        "Clock wraparound experiment observed wrapped epoch %d; retrying normal time sync.",
+        wrapped_time,
+    )
+    retry = await mc.commands.set_time(now)
+    if retry.type == EventType.OK:
+        logger.warning("Clock sync succeeded after experimental wraparound.")
+        return True
+
+    logger.warning(
+        "Clock sync still failed after experimental wraparound: set_time(%d) returned %s.",
+        now,
+        retry.type,
+    )
+    return False
+
+
 async def sync_radio_time(mc: MeshCore) -> bool:
     """Sync the radio's clock with the system time.
 
-    Returns True if successful, False otherwise.
+    The firmware only accepts forward time adjustments (new >= current).
+    If the radio's clock is already ahead, set_time is silently rejected
+    with an ERROR response.  We detect this by checking the response and,
+    on failure, querying the radio's actual time so we can log the skew.
+
+    When significant forward skew is detected for the first time in a
+    session, the radio is rebooted so that boards with a volatile clock
+    (most companion radios) reset to their default epoch and accept the
+    correct time on the next connection setup.  The reboot is attempted
+    only once; if it doesn't help (hardware RTC persists the wrong time),
+    the skew is logged as a warning on subsequent syncs.
+
+    Returns True if the radio accepted the new time, False otherwise.
     """
+    global _clock_reboot_attempted  # noqa: PLW0603
     try:
         now = int(time.time())
-        await mc.commands.set_time(now)
-        logger.debug("Synced radio time to %d", now)
-        return True
+        preflight_radio_time: int | None = None
+        wraparound_attempted = False
+
+        if settings.clowntown_do_clock_wraparound:
+            preflight_radio_time = await _query_radio_time(mc)
+            if preflight_radio_time is not None and preflight_radio_time > now:
+                wraparound_attempted = True
+                if await _attempt_clock_wraparound(
+                    mc,
+                    now=now,
+                    observed_radio_time=preflight_radio_time,
+                ):
+                    return True
+
+        result = await mc.commands.set_time(now)
+
+        if result.type == EventType.OK:
+            logger.debug("Synced radio time to %d", now)
+            return True
+
+        # Firmware rejected the time (most likely radio clock is ahead).
+        # Query actual radio time so we can report the delta.
+        radio_time = await _query_radio_time(mc)
+
+        if radio_time is not None:
+            delta = radio_time - now
+            logger.warning(
+                "Radio rejected time sync: radio clock is %+d seconds "
+                "(%+.1f hours) from system time (radio=%d, system=%d).",
+                delta,
+                delta / 3600.0,
+                radio_time,
+                now,
+            )
+        else:
+            delta = None
+            logger.warning(
+                "Radio rejected time sync (set_time returned %s) "
+                "and get_time query failed; cannot determine clock skew.",
+                result.type,
+            )
+
+        if (
+            settings.clowntown_do_clock_wraparound
+            and not wraparound_attempted
+            and radio_time is not None
+            and radio_time > now
+            and await _attempt_clock_wraparound(
+                mc,
+                now=now,
+                observed_radio_time=radio_time,
+            )
+        ):
+            return True
+
+        # If the clock is significantly ahead and we haven't already tried
+        # a corrective reboot this session, reboot the radio.  Boards with
+        # a volatile RTC (most companion radios) will reset their clock on
+        # reboot, allowing the next post-connect sync to succeed.
+        if not _clock_reboot_attempted and (delta is None or delta > 30):
+            _clock_reboot_attempted = True
+            logger.warning(
+                "Rebooting radio to reset clock skew.  Boards with a "
+                "volatile RTC will accept the correct time after restart."
+            )
+            try:
+                await mc.commands.reboot()
+            except Exception:
+                logger.warning("Reboot command failed", exc_info=True)
+        elif _clock_reboot_attempted:
+            logger.warning(
+                "Clock skew persists after reboot — the radio likely has a "
+                "hardware RTC that preserved the wrong time.  A manual "
+                "'clkreboot' CLI command is needed to reset it."
+            )
+
+        return False
     except Exception as e:
         logger.warning("Failed to sync radio time: %s", e, exc_info=True)
         return False
@@ -699,20 +1038,8 @@ _last_contact_sync: float = 0.0
 CONTACT_SYNC_THROTTLE_SECONDS = 30  # Don't sync more than once per 30 seconds
 
 
-async def _sync_contacts_to_radio_inner(mc: MeshCore) -> dict:
-    """
-    Core logic for loading contacts onto the radio.
-
-    Fill order is:
-    1. Favorite contacts
-    2. Most recently interacted-with non-repeaters
-    3. Most recently advert-heard non-repeaters without interaction history
-
-    Favorite contacts are always reloaded first, up to the configured capacity.
-    Additional non-favorite fill stops at the refill target (80% of capacity).
-
-    Caller must hold the radio operation lock and pass a valid MeshCore instance.
-    """
+async def get_contacts_selected_for_radio_sync() -> list[Contact]:
+    """Return the contacts that would be loaded onto the radio right now."""
     app_settings = await AppSettingsRepository.get()
     max_contacts = app_settings.max_radio_contacts
     refill_target, _full_sync_trigger = _compute_radio_contact_limits(max_contacts)
@@ -733,6 +1060,12 @@ async def _sync_contacts_to_radio_inner(mc: MeshCore) -> dict:
             continue
         if not contact:
             continue
+        if len(contact.public_key) < 64:
+            logger.debug(
+                "Skipping unresolved prefix-only favorite contact '%s' for radio sync",
+                favorite.id,
+            )
+            continue
         key = contact.public_key.lower()
         if key in selected_keys:
             continue
@@ -773,6 +1106,24 @@ async def _sync_contacts_to_radio_inner(mc: MeshCore) -> dict:
         refill_target,
         max_contacts,
     )
+    return selected_contacts
+
+
+async def _sync_contacts_to_radio_inner(mc: MeshCore) -> dict:
+    """
+    Core logic for loading contacts onto the radio.
+
+    Fill order is:
+    1. Favorite contacts
+    2. Most recently interacted-with non-repeaters
+    3. Most recently advert-heard non-repeaters without interaction history
+
+    Favorite contacts are always reloaded first, up to the configured capacity.
+    Additional non-favorite fill stops at the refill target (80% of capacity).
+
+    Caller must hold the radio operation lock and pass a valid MeshCore instance.
+    """
+    selected_contacts = await get_contacts_selected_for_radio_sync()
     return await _load_contacts_to_radio(mc, selected_contacts)
 
 
@@ -802,6 +1153,9 @@ async def ensure_contact_on_radio(
     if not contact:
         logger.debug("Cannot sync favorite contact %s: not found", public_key[:12])
         return {"loaded": 0, "error": "Contact not found"}
+    if len(contact.public_key) < 64:
+        logger.debug("Cannot sync unresolved prefix-only contact %s to radio", public_key)
+        return {"loaded": 0, "error": "Full contact key not yet known"}
 
     if mc is not None:
         _last_contact_sync = now
@@ -834,11 +1188,14 @@ async def _load_contacts_to_radio(mc: MeshCore, contacts: list[Contact]) -> dict
     failed = 0
 
     for contact in contacts:
+        if len(contact.public_key) < 64:
+            logger.debug(
+                "Skipping unresolved prefix-only contact %s during radio load", contact.public_key
+            )
+            continue
         radio_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
         if radio_contact:
             already_on_radio += 1
-            if not contact.on_radio:
-                await ContactRepository.set_on_radio(contact.public_key, True)
             continue
 
         try:
@@ -846,7 +1203,6 @@ async def _load_contacts_to_radio(mc: MeshCore, contacts: list[Contact]) -> dict
             result = await mc.commands.add_contact(radio_contact_payload)
             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

app/repository/channels.py

@@ -66,6 +66,30 @@ class ChannelRepository:
             for row in rows
         ]
 
+    @staticmethod
+    async def get_on_radio() -> list[Channel]:
+        """Return channels currently marked as resident on the radio in the database."""
+        cursor = await db.conn.execute(
+            """
+            SELECT key, name, is_hashtag, on_radio, flood_scope_override, last_read_at
+            FROM channels
+            WHERE on_radio = 1
+            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"]),
+                flood_scope_override=row["flood_scope_override"],
+                last_read_at=row["last_read_at"],
+            )
+            for row in rows
+        ]
+
     @staticmethod
     async def delete(key: str) -> None:
         """Delete a channel by key."""

app/repository/contacts.py

@@ -36,11 +36,20 @@ class ContactRepository:
     @staticmethod
     async def upsert(contact: ContactUpsert | Contact | Mapping[str, Any]) -> None:
         contact_row = ContactRepository._coerce_contact_upsert(contact)
-        last_path, last_path_len, out_path_hash_mode = normalize_contact_route(
-            contact_row.last_path,
-            contact_row.last_path_len,
-            contact_row.out_path_hash_mode,
-        )
+        if (
+            contact_row.direct_path is None
+            and contact_row.direct_path_len is None
+            and contact_row.direct_path_hash_mode is None
+        ):
+            direct_path = None
+            direct_path_len = None
+            direct_path_hash_mode = None
+        else:
+            direct_path, direct_path_len, direct_path_hash_mode = normalize_contact_route(
+                contact_row.direct_path,
+                contact_row.direct_path_len,
+                contact_row.direct_path_hash_mode,
+            )
         route_override_path, route_override_len, route_override_hash_mode = (
             normalize_route_override(
                 contact_row.route_override_path,
@@ -51,20 +60,25 @@ class ContactRepository:
 
         await db.conn.execute(
             """
-            INSERT INTO contacts (public_key, name, type, flags, last_path, last_path_len,
-                                  out_path_hash_mode,
+            INSERT INTO contacts (public_key, name, type, flags, direct_path, direct_path_len,
+                                  direct_path_hash_mode, direct_path_updated_at,
                                   route_override_path, route_override_len,
                                   route_override_hash_mode,
                                   last_advert, lat, lon, last_seen,
                                   on_radio, last_contacted, first_seen)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            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 = excluded.out_path_hash_mode,
+                direct_path = COALESCE(excluded.direct_path, contacts.direct_path),
+                direct_path_len = COALESCE(excluded.direct_path_len, contacts.direct_path_len),
+                direct_path_hash_mode = COALESCE(
+                    excluded.direct_path_hash_mode, contacts.direct_path_hash_mode
+                ),
+                direct_path_updated_at = COALESCE(
+                    excluded.direct_path_updated_at, contacts.direct_path_updated_at
+                ),
                 route_override_path = COALESCE(
                     excluded.route_override_path, contacts.route_override_path
                 ),
@@ -87,9 +101,10 @@ class ContactRepository:
                 contact_row.name,
                 contact_row.type,
                 contact_row.flags,
-                last_path,
-                last_path_len,
-                out_path_hash_mode,
+                direct_path,
+                direct_path_len,
+                direct_path_hash_mode,
+                contact_row.direct_path_updated_at,
                 route_override_path,
                 route_override_len,
                 route_override_hash_mode,
@@ -107,12 +122,12 @@ class ContactRepository:
     @staticmethod
     def _row_to_contact(row) -> Contact:
         """Convert a database row to a Contact model."""
-        last_path, last_path_len, out_path_hash_mode = normalize_contact_route(
-            row["last_path"],
-            row["last_path_len"],
-            row["out_path_hash_mode"],
-        )
         available_columns = set(row.keys())
+        direct_path, direct_path_len, direct_path_hash_mode = normalize_contact_route(
+            row["direct_path"] if "direct_path" in available_columns else None,
+            row["direct_path_len"] if "direct_path_len" in available_columns else None,
+            row["direct_path_hash_mode"] if "direct_path_hash_mode" in available_columns else None,
+        )
         route_override_path = (
             row["route_override_path"] if "route_override_path" in available_columns else None
         )
@@ -136,9 +151,14 @@ class ContactRepository:
             name=row["name"],
             type=row["type"],
             flags=row["flags"],
-            last_path=last_path,
-            last_path_len=last_path_len,
-            out_path_hash_mode=out_path_hash_mode,
+            direct_path=direct_path,
+            direct_path_len=direct_path_len,
+            direct_path_hash_mode=direct_path_hash_mode,
+            direct_path_updated_at=(
+                row["direct_path_updated_at"]
+                if "direct_path_updated_at" in available_columns
+                else None
+            ),
             route_override_path=route_override_path,
             route_override_len=route_override_len,
             route_override_hash_mode=route_override_hash_mode,
@@ -168,6 +188,9 @@ class ContactRepository:
         the prefix (to avoid silently selecting the wrong contact).
         """
         normalized_prefix = prefix.lower()
+        exact = await ContactRepository.get_by_key(normalized_prefix)
+        if exact:
+            return exact
         cursor = await db.conn.execute(
             "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT 2",
             (f"{normalized_prefix}%",),
@@ -258,7 +281,7 @@ class ContactRepository:
         cursor = await db.conn.execute(
             """
             SELECT * FROM contacts
-            WHERE type != 2 AND last_contacted IS NOT NULL
+            WHERE type != 2 AND last_contacted IS NOT NULL AND length(public_key) = 64
             ORDER BY last_contacted DESC
             LIMIT ?
             """,
@@ -273,7 +296,7 @@ class ContactRepository:
         cursor = await db.conn.execute(
             """
             SELECT * FROM contacts
-            WHERE type != 2 AND last_advert IS NOT NULL
+            WHERE type != 2 AND last_advert IS NOT NULL AND length(public_key) = 64
             ORDER BY last_advert DESC
             LIMIT ?
             """,
@@ -283,26 +306,30 @@ class ContactRepository:
         return [ContactRepository._row_to_contact(row) for row in rows]
 
     @staticmethod
-    async def update_path(
+    async def update_direct_path(
         public_key: str,
         path: str,
         path_len: int,
-        out_path_hash_mode: int | None = None,
+        path_hash_mode: int | None = None,
+        updated_at: int | None = None,
     ) -> None:
         normalized_path, normalized_path_len, normalized_hash_mode = normalize_contact_route(
             path,
             path_len,
-            out_path_hash_mode,
+            path_hash_mode,
         )
+        ts = updated_at if updated_at is not None else int(time.time())
         await db.conn.execute(
-            """UPDATE contacts SET last_path = ?, last_path_len = ?,
-               out_path_hash_mode = COALESCE(?, out_path_hash_mode),
+            """UPDATE contacts SET direct_path = ?, direct_path_len = ?,
+               direct_path_hash_mode = COALESCE(?, direct_path_hash_mode),
+               direct_path_updated_at = ?,
                last_seen = ? WHERE public_key = ?""",
             (
                 normalized_path,
                 normalized_path_len,
                 normalized_hash_mode,
-                int(time.time()),
+                ts,
+                ts,
                 public_key.lower(),
             ),
         )
@@ -313,12 +340,12 @@ class ContactRepository:
         public_key: str,
         path: str | None,
         path_len: int | None,
-        out_path_hash_mode: int | None = None,
+        path_hash_mode: int | None = None,
     ) -> None:
         normalized_path, normalized_len, normalized_hash_mode = normalize_route_override(
             path,
             path_len,
-            out_path_hash_mode,
+            path_hash_mode,
         )
         await db.conn.execute(
             """
@@ -349,14 +376,6 @@ class ContactRepository:
         )
         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."""
@@ -406,6 +425,142 @@ class ContactRepository:
         await db.conn.commit()
         return cursor.rowcount > 0
 
+    @staticmethod
+    async def promote_prefix_placeholders(full_key: str) -> list[str]:
+        """Promote prefix-only placeholder contacts to a resolved full key.
+
+        Returns the placeholder public keys that were merged into the full key.
+        """
+
+        async def migrate_child_rows(old_key: str, new_key: str) -> None:
+            await db.conn.execute(
+                """
+                INSERT INTO contact_name_history (public_key, name, first_seen, last_seen)
+                SELECT ?, name, first_seen, last_seen
+                FROM contact_name_history
+                WHERE public_key = ?
+                ON CONFLICT(public_key, name) DO UPDATE SET
+                    first_seen = MIN(contact_name_history.first_seen, excluded.first_seen),
+                    last_seen = MAX(contact_name_history.last_seen, excluded.last_seen)
+                """,
+                (new_key, old_key),
+            )
+            await db.conn.execute(
+                """
+                INSERT INTO contact_advert_paths
+                    (public_key, path_hex, path_len, first_seen, last_seen, heard_count)
+                SELECT ?, path_hex, path_len, first_seen, last_seen, heard_count
+                FROM contact_advert_paths
+                WHERE public_key = ?
+                ON CONFLICT(public_key, path_hex, path_len) DO UPDATE SET
+                    first_seen = MIN(contact_advert_paths.first_seen, excluded.first_seen),
+                    last_seen = MAX(contact_advert_paths.last_seen, excluded.last_seen),
+                    heard_count = contact_advert_paths.heard_count + excluded.heard_count
+                """,
+                (new_key, old_key),
+            )
+            await db.conn.execute(
+                "DELETE FROM contact_name_history WHERE public_key = ?",
+                (old_key,),
+            )
+            await db.conn.execute(
+                "DELETE FROM contact_advert_paths WHERE public_key = ?",
+                (old_key,),
+            )
+
+        normalized_full_key = full_key.lower()
+        cursor = await db.conn.execute(
+            """
+            SELECT public_key, last_seen, last_contacted, first_seen, last_read_at
+            FROM contacts
+            WHERE length(public_key) < 64
+              AND ? LIKE public_key || '%'
+            ORDER BY length(public_key) DESC, public_key
+            """,
+            (normalized_full_key,),
+        )
+        rows = list(await cursor.fetchall())
+        if not rows:
+            return []
+
+        promoted_keys: list[str] = []
+        full_exists = await ContactRepository.get_by_key(normalized_full_key) is not None
+
+        for row in rows:
+            old_key = row["public_key"]
+            if old_key == normalized_full_key:
+                continue
+
+            match_cursor = await db.conn.execute(
+                """
+                SELECT COUNT(*) AS match_count
+                FROM contacts
+                WHERE length(public_key) = 64
+                  AND public_key LIKE ? || '%'
+                """,
+                (old_key,),
+            )
+            match_row = await match_cursor.fetchone()
+            if (match_row["match_count"] if match_row is not None else 0) != 1:
+                continue
+
+            await migrate_child_rows(old_key, normalized_full_key)
+
+            if full_exists:
+                await db.conn.execute(
+                    """
+                    UPDATE contacts
+                    SET last_seen = CASE
+                            WHEN contacts.last_seen IS NULL THEN ?
+                            WHEN ? IS NULL THEN contacts.last_seen
+                            WHEN ? > contacts.last_seen THEN ?
+                            ELSE contacts.last_seen
+                        END,
+                        last_contacted = CASE
+                            WHEN contacts.last_contacted IS NULL THEN ?
+                            WHEN ? IS NULL THEN contacts.last_contacted
+                            WHEN ? > contacts.last_contacted THEN ?
+                            ELSE contacts.last_contacted
+                        END,
+                        first_seen = CASE
+                            WHEN contacts.first_seen IS NULL THEN ?
+                            WHEN ? IS NULL THEN contacts.first_seen
+                            WHEN ? < contacts.first_seen THEN ?
+                            ELSE contacts.first_seen
+                        END,
+                        last_read_at = COALESCE(contacts.last_read_at, ?)
+                    WHERE public_key = ?
+                    """,
+                    (
+                        row["last_seen"],
+                        row["last_seen"],
+                        row["last_seen"],
+                        row["last_seen"],
+                        row["last_contacted"],
+                        row["last_contacted"],
+                        row["last_contacted"],
+                        row["last_contacted"],
+                        row["first_seen"],
+                        row["first_seen"],
+                        row["first_seen"],
+                        row["first_seen"],
+                        row["last_read_at"],
+                        normalized_full_key,
+                    ),
+                )
+                await db.conn.execute("DELETE FROM contacts WHERE public_key = ?", (old_key,))
+            else:
+                await db.conn.execute(
+                    "UPDATE contacts SET public_key = ? WHERE public_key = ?",
+                    (normalized_full_key, old_key),
+                )
+                full_exists = True
+
+            promoted_keys.append(old_key)
+
+        await db.conn.commit()
+        return promoted_keys
+
     @staticmethod
     async def mark_all_read(timestamp: int) -> None:
         """Mark all contacts as read at the given timestamp."""

app/repository/messages.py

@@ -66,9 +66,10 @@ class MessageRepository:
     ) -> 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.
+        Uses INSERT OR IGNORE to handle the message dedup indexes:
+        - channel messages dedupe by content/timestamp for echo reconciliation
+        - incoming direct messages dedupe by conversation/text/timestamp so
+          raw-packet and fallback observations merge onto one row
 
         The path parameter is converted to the paths JSON array format.
         """
@@ -162,7 +163,8 @@ class MessageRepository:
                AND ? LIKE conversation_key || '%'
                AND (
                    SELECT COUNT(*) FROM contacts
-                   WHERE public_key LIKE messages.conversation_key || '%'
+                   WHERE length(public_key) = 64
+                     AND public_key LIKE messages.conversation_key || '%'
                ) = 1""",
             (lower_key, lower_key),
         )
@@ -179,8 +181,16 @@ class MessageRepository:
         """
         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),
+               WHERE type = 'CHAN' AND sender_name = ? AND sender_key IS NULL
+               AND (
+                   SELECT COUNT(*) FROM contacts
+                   WHERE name = ?
+               ) = 1
+               AND EXISTS (
+                   SELECT 1 FROM contacts
+                   WHERE public_key = ? AND name = ?
+               )""",
+            (public_key.lower(), name, name, public_key.lower(), name),
         )
         await db.conn.commit()
         return cursor.rowcount
@@ -284,6 +294,40 @@ class MessageRepository:
         clause += ")"
         return clause, params
 
+    @staticmethod
+    def _build_blocked_incoming_clause(
+        message_alias: str = "",
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
+    ) -> tuple[str, list[Any]]:
+        prefix = f"{message_alias}." if message_alias else ""
+        blocked_matchers: list[str] = []
+        params: list[Any] = []
+
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            blocked_matchers.append(
+                f"({prefix}type = 'PRIV' AND LOWER({prefix}conversation_key) IN ({placeholders}))"
+            )
+            params.extend(blocked_keys)
+            blocked_matchers.append(
+                f"({prefix}type = 'CHAN' AND {prefix}sender_key IS NOT NULL"
+                f" AND LOWER({prefix}sender_key) IN ({placeholders}))"
+            )
+            params.extend(blocked_keys)
+
+        if blocked_names:
+            placeholders = ",".join("?" for _ in blocked_names)
+            blocked_matchers.append(
+                f"({prefix}sender_name IS NOT NULL AND {prefix}sender_name IN ({placeholders}))"
+            )
+            params.extend(blocked_names)
+
+        if not blocked_matchers:
+            return "", []
+
+        return f"NOT ({prefix}outgoing = 0 AND ({' OR '.join(blocked_matchers)}))", params
+
     @staticmethod
     def _row_to_message(row: Any) -> Message:
         """Convert a database row to a Message model."""
@@ -328,25 +372,12 @@ class MessageRepository:
         )
         params: list[Any] = []
 
-        if blocked_keys:
-            placeholders = ",".join("?" for _ in blocked_keys)
-            query += (
-                f" AND NOT (messages.outgoing=0 AND ("
-                f"(messages.type='PRIV' AND LOWER(messages.conversation_key) IN ({placeholders}))"
-                f" OR (messages.type='CHAN' AND messages.sender_key IS NOT NULL"
-                f" AND LOWER(messages.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 (messages.outgoing=0 AND messages.sender_name IS NOT NULL"
-                f" AND messages.sender_name IN ({placeholders}))"
-            )
-            params.extend(blocked_names)
+        blocked_clause, blocked_params = MessageRepository._build_blocked_incoming_clause(
+            "messages", blocked_keys, blocked_names
+        )
+        if blocked_clause:
+            query += f" AND {blocked_clause}"
+            params.extend(blocked_params)
 
         if msg_type:
             query += " AND messages.type = ?"
@@ -428,23 +459,12 @@ class MessageRepository:
             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)
+        blocked_clause, blocked_params = MessageRepository._build_blocked_incoming_clause(
+            blocked_keys=blocked_keys, blocked_names=blocked_names
+        )
+        if blocked_clause:
+            where_parts.append(blocked_clause)
+            base_params.extend(blocked_params)
 
         where_sql = " AND ".join(["1=1", *where_parts])
 
@@ -534,22 +554,32 @@ class MessageRepository:
 
         return MessageRepository._row_to_message(row)
 
+    @staticmethod
+    async def delete_by_id(message_id: int) -> None:
+        """Delete a message row by ID."""
+        await db.conn.execute("DELETE FROM messages WHERE id = ?", (message_id,))
+        await db.conn.commit()
+
     @staticmethod
     async def get_by_content(
         msg_type: str,
         conversation_key: str,
         text: str,
         sender_timestamp: int | None,
+        outgoing: bool | None = None,
     ) -> "Message | None":
         """Look up a message by its unique content fields."""
-        cursor = await db.conn.execute(
-            """
+        query = """
             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),
-        )
+        """
+        params: list[Any] = [msg_type, conversation_key, text, sender_timestamp, sender_timestamp]
+        if outgoing is not None:
+            query += " AND outgoing = ?"
+            params.append(1 if outgoing else 0)
+        query += " ORDER BY id ASC"
+        cursor = await db.conn.execute(query, params)
         row = await cursor.fetchone()
         if not row:
             return None
@@ -570,29 +600,19 @@ class MessageRepository:
             blocked_names: Display names whose messages should be excluded from counts.
 
         Returns:
-            Dict with 'counts', 'mentions', and 'last_message_times' keys.
+            Dict with 'counts', 'mentions', 'last_message_times', and 'last_read_ats' keys.
         """
         counts: dict[str, int] = {}
         mention_flags: dict[str, bool] = {}
         last_message_times: dict[str, int] = {}
+        last_read_ats: dict[str, int | None] = {}
 
         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)
+        blocked_clause, blocked_params = MessageRepository._build_blocked_incoming_clause(
+            "m", blocked_keys, blocked_names
+        )
+        blocked_sql = f" AND {blocked_clause}" if blocked_clause else ""
 
         # Channel unreads
         cursor = await db.conn.execute(
@@ -607,10 +627,10 @@ class MessageRepository:
             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}
+              {blocked_sql}
             GROUP BY m.conversation_key
             """,
-            (mention_token or "", mention_token or "", *chan_block_params),
+            (mention_token or "", mention_token or "", *blocked_params),
         )
         rows = await cursor.fetchall()
         for row in rows:
@@ -619,14 +639,6 @@ class MessageRepository:
             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"""
@@ -640,10 +652,10 @@ class MessageRepository:
             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}
+              {blocked_sql}
             GROUP BY m.conversation_key
             """,
-            (mention_token or "", mention_token or "", *contact_block_params),
+            (mention_token or "", mention_token or "", *blocked_params),
         )
         rows = await cursor.fetchall()
         for row in rows:
@@ -652,13 +664,41 @@ class MessageRepository:
             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 key, last_read_at
+            FROM channels
+            """
+        )
+        rows = await cursor.fetchall()
+        for row in rows:
+            last_read_ats[f"channel-{row['key']}"] = row["last_read_at"]
+
+        cursor = await db.conn.execute(
+            """
+            SELECT public_key, last_read_at
+            FROM contacts
+            """
+        )
+        rows = await cursor.fetchall()
+        for row in rows:
+            last_read_ats[f"contact-{row['public_key']}"] = row["last_read_at"]
+
+        # Last message times for all conversations (including read ones),
+        # excluding blocked incoming traffic so refresh matches live WS behavior.
+        last_time_clause, last_time_params = MessageRepository._build_blocked_incoming_clause(
+            blocked_keys=blocked_keys, blocked_names=blocked_names
+        )
+        last_time_where_sql = f"WHERE {last_time_clause}" if last_time_clause else ""
+
+        cursor = await db.conn.execute(
+            f"""
             SELECT type, conversation_key, MAX(received_at) as last_message_time
             FROM messages
+            {last_time_where_sql}
             GROUP BY type, conversation_key
-            """
+            """,
+            last_time_params,
         )
         rows = await cursor.fetchall()
         for row in rows:
@@ -670,6 +710,7 @@ class MessageRepository:
             "counts": counts,
             "mentions": mention_flags,
             "last_message_times": last_message_times,
+            "last_read_ats": last_read_ats,
         }
 
     @staticmethod
@@ -778,6 +819,19 @@ class MessageRepository:
             "top_senders_24h": top_senders,
         }
 
+    @staticmethod
+    async def count_channels_with_incoming_messages() -> int:
+        """Count distinct channel conversations with at least one incoming message."""
+        cursor = await db.conn.execute(
+            """
+            SELECT COUNT(DISTINCT conversation_key) AS cnt
+            FROM messages
+            WHERE type = 'CHAN' AND outgoing = 0
+            """
+        )
+        row = await cursor.fetchone()
+        return int(row["cnt"]) if row and row["cnt"] is not None else 0
+
     @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.

app/repository/raw_packets.py

@@ -109,6 +109,18 @@ class RawPacketRepository:
         )
         await db.conn.commit()
 
+    @staticmethod
+    async def get_linked_message_id(packet_id: int) -> int | None:
+        """Return the linked message ID for a raw packet, if any."""
+        cursor = await db.conn.execute(
+            "SELECT message_id FROM raw_packets WHERE id = ?",
+            (packet_id,),
+        )
+        row = await cursor.fetchone()
+        if not row:
+            return None
+        return row["message_id"]
+
     @staticmethod
     async def prune_old_undecrypted(max_age_days: int) -> int:
         """Delete undecrypted packets older than max_age_days. Returns count deleted."""

app/routers/channels.py

@@ -1,22 +1,28 @@
 import logging
 from hashlib import sha256
 
-from fastapi import APIRouter, HTTPException, Query
-from meshcore import EventType
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from app.dependencies import require_connected
+from app.channel_constants import (
+    PUBLIC_CHANNEL_KEY,
+    PUBLIC_CHANNEL_NAME,
+    is_public_channel_key,
+    is_public_channel_name,
+)
 from app.models import Channel, ChannelDetail, ChannelMessageCounts, ChannelTopSender
-from app.radio_sync import upsert_channel_from_radio_slot
 from app.region_scope import normalize_region_scope
 from app.repository import ChannelRepository, MessageRepository
-from app.services.radio_runtime import radio_runtime as radio_manager
 from app.websocket import broadcast_event
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/channels", tags=["channels"])
 
 
+def _broadcast_channel_update(channel: Channel) -> None:
+    broadcast_event("channel", channel.model_dump())
+
+
 class CreateChannelRequest(BaseModel):
     name: str = Field(min_length=1, max_length=32)
     key: str | None = Field(
@@ -55,15 +61,6 @@ async def get_channel_detail(key: str) -> ChannelDetail:
     )
 
 
-@router.get("/{key}", response_model=Channel)
-async def get_channel(key: str) -> Channel:
-    """Get a specific channel by key (32-char hex string)."""
-    channel = await ChannelRepository.get_by_key(key)
-    if not channel:
-        raise HTTPException(status_code=404, detail="Channel not found")
-    return channel
-
-
 @router.post("", response_model=Channel)
 async def create_channel(request: CreateChannelRequest) -> Channel:
     """Create a channel in the database.
@@ -71,10 +68,31 @@ async def create_channel(request: CreateChannelRequest) -> Channel:
     Channels are NOT pushed to radio on creation. They are loaded to the radio
     automatically when sending a message (see messages.py send_channel_message).
     """
-    is_hashtag = request.name.startswith("#")
+    requested_name = request.name
+    is_hashtag = requested_name.startswith("#")
 
-    # Determine the channel secret
-    if request.key and not is_hashtag:
+    # Reserve the canonical Public room so it cannot drift to another key,
+    # and the well-known Public key cannot be renamed to something else.
+    if is_public_channel_name(requested_name):
+        if request.key:
+            try:
+                key_bytes = bytes.fromhex(request.key)
+                if len(key_bytes) != 16:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Channel key must be exactly 16 bytes (32 hex chars)",
+                    )
+            except ValueError:
+                raise HTTPException(status_code=400, detail="Invalid hex string for key") from None
+            if key_bytes.hex().upper() != PUBLIC_CHANNEL_KEY:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f'"{PUBLIC_CHANNEL_NAME}" must use the canonical Public key',
+                )
+        key_hex = PUBLIC_CHANNEL_KEY
+        channel_name = PUBLIC_CHANNEL_NAME
+        is_hashtag = False
+    elif request.key and not is_hashtag:
         try:
             key_bytes = bytes.fromhex(request.key)
             if len(key_bytes) != 16:
@@ -83,52 +101,35 @@ async def create_channel(request: CreateChannelRequest) -> Channel:
                 )
         except ValueError:
             raise HTTPException(status_code=400, detail="Invalid hex string for key") from None
+        key_hex = key_bytes.hex().upper()
+        if is_public_channel_key(key_hex):
+            raise HTTPException(
+                status_code=400,
+                detail=f'The canonical Public key may only be used for "{PUBLIC_CHANNEL_NAME}"',
+            )
+        channel_name = requested_name
     else:
         # Derive key from name hash (same as meshcore library does)
-        key_bytes = sha256(request.name.encode("utf-8")).digest()[:16]
+        key_bytes = sha256(requested_name.encode("utf-8")).digest()[:16]
+        key_hex = key_bytes.hex().upper()
+        channel_name = requested_name
 
-    key_hex = key_bytes.hex().upper()
-    logger.info("Creating channel %s: %s (hashtag=%s)", key_hex, request.name, is_hashtag)
+    logger.info("Creating channel %s: %s (hashtag=%s)", key_hex, channel_name, is_hashtag)
 
     # Store in database only - radio sync happens at send time
     await ChannelRepository.upsert(
         key=key_hex,
-        name=request.name,
+        name=channel_name,
         is_hashtag=is_hashtag,
         on_radio=False,
     )
 
-    return Channel(
-        key=key_hex,
-        name=request.name,
-        is_hashtag=is_hashtag,
-        on_radio=False,
-        flood_scope_override=None,
-    )
+    stored = await ChannelRepository.get_by_key(key_hex)
+    if stored is None:
+        raise HTTPException(status_code=500, detail="Channel was created but could not be reloaded")
 
-
-@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."""
-    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") as mc:
-        for idx in range(max_channels):
-            result = await mc.commands.get_channel(idx)
-
-            if result.type == EventType.CHANNEL_INFO:
-                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}
+    _broadcast_channel_update(stored)
+    return stored
 
 
 @router.post("/{key}/mark-read")
@@ -174,6 +175,11 @@ async def delete_channel(key: str) -> dict:
     Note: This does not clear the channel from the radio. The radio's channel
     slots are managed separately (channels are loaded temporarily when sending).
     """
+    if is_public_channel_key(key):
+        raise HTTPException(
+            status_code=400, detail="The canonical Public channel cannot be deleted"
+        )
+
     logger.info("Deleting channel %s from database", key)
     await ChannelRepository.delete(key)
 

app/routers/contacts.py

@@ -1,5 +1,7 @@
+import asyncio
 import logging
 import random
+from contextlib import suppress
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Query
 from meshcore import EventType
@@ -8,15 +10,14 @@ from app.dependencies import require_connected
 from app.models import (
     Contact,
     ContactActiveRoom,
-    ContactAdvertPath,
     ContactAdvertPathSummary,
     ContactAnalytics,
-    ContactDetail,
     ContactRoutingOverrideRequest,
     ContactUpsert,
     CreateContactRequest,
-    NameOnlyContactDetail,
     NearestRepeater,
+    PathDiscoveryResponse,
+    PathDiscoveryRoute,
     TraceResponse,
 )
 from app.packet_processor import start_historical_dm_decryption
@@ -28,7 +29,10 @@ from app.repository import (
     ContactRepository,
     MessageRepository,
 )
-from app.services.contact_reconciliation import reconcile_contact_messages
+from app.services.contact_reconciliation import (
+    promote_prefix_contacts_for_contact,
+    reconcile_contact_messages,
+)
 from app.services.radio_runtime import radio_runtime as radio_manager
 
 logger = logging.getLogger(__name__)
@@ -66,8 +70,8 @@ async def _ensure_on_radio(mc, contact: Contact) -> None:
 
 
 async def _best_effort_push_contact_to_radio(contact: Contact, operation_name: str) -> None:
-    """Push the current effective route to the radio when the contact is already loaded."""
-    if not radio_manager.is_connected or not contact.on_radio:
+    """Best-effort push the current effective route to the radio when connected."""
+    if not radio_manager.is_connected:
         return
 
     try:
@@ -93,6 +97,25 @@ async def _broadcast_contact_update(contact: Contact) -> None:
     broadcast_event("contact", contact.model_dump())
 
 
+async def _broadcast_contact_resolution(previous_public_keys: list[str], contact: Contact) -> None:
+    from app.websocket import broadcast_event
+
+    for old_key in previous_public_keys:
+        broadcast_event(
+            "contact_resolved",
+            {
+                "previous_public_key": old_key,
+                "contact": contact.model_dump(),
+            },
+        )
+
+
+def _path_hash_mode_from_hop_width(hop_width: object) -> int:
+    if not isinstance(hop_width, int):
+        return 0
+    return max(0, min(hop_width - 1, 2))
+
+
 async def _build_keyed_contact_analytics(contact: Contact) -> ContactAnalytics:
     name_history = await ContactNameHistoryRepository.get_history(contact.public_key)
     dm_count = await MessageRepository.count_dm_messages(contact.public_key)
@@ -257,12 +280,23 @@ async def create_contact(
             if refreshed is not None:
                 existing = refreshed
 
+        promoted_keys = await promote_prefix_contacts_for_contact(
+            public_key=request.public_key,
+            log=logger,
+        )
+        if promoted_keys:
+            refreshed = await ContactRepository.get_by_key(request.public_key)
+            if refreshed is not None:
+                existing = refreshed
+                await _broadcast_contact_resolution(promoted_keys, existing)
+
         # Trigger historical decryption if requested (even for existing contacts)
         if request.try_historical:
             await start_historical_dm_decryption(
                 background_tasks, request.public_key, request.name or existing.name
             )
 
+        await _broadcast_contact_update(existing)
         return existing
 
     # Create new contact
@@ -270,11 +304,14 @@ async def create_contact(
     contact_upsert = ContactUpsert(
         public_key=lower_key,
         name=request.name,
-        out_path_hash_mode=-1,
         on_radio=False,
     )
     await ContactRepository.upsert(contact_upsert)
     logger.info("Created contact %s", lower_key[:12])
+    promoted_keys = await promote_prefix_contacts_for_contact(
+        public_key=lower_key,
+        log=logger,
+    )
 
     await reconcile_contact_messages(
         public_key=lower_key,
@@ -286,150 +323,12 @@ async def create_contact(
     if request.try_historical:
         await start_historical_dm_decryption(background_tasks, lower_key, request.name)
 
-    return Contact(**contact_upsert.model_dump())
-
-
-@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)
-    analytics = await _build_keyed_contact_analytics(contact)
-    assert analytics.contact is not None
-    return ContactDetail(
-        contact=analytics.contact,
-        name_history=analytics.name_history,
-        dm_message_count=analytics.dm_message_count,
-        channel_message_count=analytics.channel_message_count,
-        most_active_rooms=analytics.most_active_rooms,
-        advert_paths=analytics.advert_paths,
-        advert_frequency=analytics.advert_frequency,
-        nearest_repeaters=analytics.nearest_repeaters,
-    )
-
-
-@router.get("/name-detail", response_model=NameOnlyContactDetail)
-async def get_name_only_contact_detail(
-    name: str = Query(min_length=1, max_length=200),
-) -> NameOnlyContactDetail:
-    """Get channel activity summary for a sender name without a resolved key."""
-    normalized_name = name.strip()
-    if not normalized_name:
-        raise HTTPException(status_code=400, detail="name is required")
-    analytics = await _build_name_only_contact_analytics(normalized_name)
-    return NameOnlyContactDetail(
-        name=analytics.name,
-        channel_message_count=analytics.channel_message_count,
-        most_active_rooms=analytics.most_active_rooms,
-    )
-
-
-@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."""
-    require_connected()
-
-    logger.info("Syncing contacts from radio")
-
-    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}")
-
-    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(
-            ContactUpsert.from_radio_dict(lower_key, contact_data, on_radio=True)
-        )
-        synced_keys.append(lower_key)
-        await reconcile_contact_messages(
-            public_key=lower_key,
-            contact_name=contact_data.get("adv_name"),
-            log=logger,
-        )
-        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}
-
-
-@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)."""
-    require_connected()
-
-    contact = await _resolve_contact_or_404(public_key)
-
-    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])
-
-        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}"
-            )
-
-    await ContactRepository.set_on_radio(contact.public_key, False)
-    return {"status": "ok"}
-
-
-@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."""
-    require_connected()
-
-    contact = await _resolve_contact_or_404(public_key, "Contact not found in database")
-
-    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])
-
-        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}")
-
-    await ContactRepository.set_on_radio(contact.public_key, True)
-    return {"status": "ok"}
+    stored = await ContactRepository.get_by_key(lower_key)
+    if stored is None:
+        raise HTTPException(status_code=500, detail="Contact was created but could not be reloaded")
+    await _broadcast_contact_update(stored)
+    await _broadcast_contact_resolution(promoted_keys, stored)
+    return stored
 
 
 @router.post("/{public_key}/mark-read")
@@ -530,6 +429,90 @@ 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}/path-discovery", response_model=PathDiscoveryResponse)
+async def request_path_discovery(public_key: str) -> PathDiscoveryResponse:
+    """Discover the current forward and return paths to a known contact."""
+    require_connected()
+
+    contact = await _resolve_contact_or_404(public_key)
+    pubkey_prefix = contact.public_key[:12]
+
+    async with radio_manager.radio_operation("request_path_discovery", pause_polling=True) as mc:
+        await _ensure_on_radio(mc, contact)
+
+        response_task = asyncio.create_task(
+            mc.wait_for_event(
+                EventType.PATH_RESPONSE,
+                attribute_filters={"pubkey_pre": pubkey_prefix},
+                timeout=15,
+            )
+        )
+        try:
+            result = await mc.commands.send_path_discovery(contact.public_key)
+            if result.type == EventType.ERROR:
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Failed to send path discovery: {result.payload}",
+                )
+
+            event = await response_task
+        finally:
+            if not response_task.done():
+                response_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await response_task
+
+        if event is None:
+            raise HTTPException(status_code=504, detail="No path discovery response heard")
+
+        payload = event.payload
+        forward_path = str(payload.get("out_path") or "")
+        forward_len = int(payload.get("out_path_len") or 0)
+        forward_mode = _path_hash_mode_from_hop_width(payload.get("out_path_hash_len"))
+        return_path = str(payload.get("in_path") or "")
+        return_len = int(payload.get("in_path_len") or 0)
+        return_mode = _path_hash_mode_from_hop_width(payload.get("in_path_hash_len"))
+
+        await ContactRepository.update_direct_path(
+            contact.public_key,
+            forward_path,
+            forward_len,
+            forward_mode,
+        )
+        refreshed_contact = await _resolve_contact_or_404(contact.public_key)
+
+        try:
+            sync_result = await mc.commands.add_contact(refreshed_contact.to_radio_dict())
+            if sync_result is not None and sync_result.type == EventType.ERROR:
+                logger.warning(
+                    "Failed to sync discovered path back to radio for %s: %s",
+                    refreshed_contact.public_key[:12],
+                    sync_result.payload,
+                )
+        except Exception:
+            logger.warning(
+                "Failed to sync discovered path back to radio for %s",
+                refreshed_contact.public_key[:12],
+                exc_info=True,
+            )
+
+    await _broadcast_contact_update(refreshed_contact)
+
+    return PathDiscoveryResponse(
+        contact=refreshed_contact,
+        forward_path=PathDiscoveryRoute(
+            path=forward_path,
+            path_len=forward_len,
+            path_hash_mode=forward_mode,
+        ),
+        return_path=PathDiscoveryRoute(
+            path=return_path,
+            path_len=return_len,
+            path_hash_mode=return_mode,
+        ),
+    )
+
+
 @router.post("/{public_key}/routing-override")
 async def set_contact_routing_override(
     public_key: str, request: ContactRoutingOverrideRequest
@@ -540,9 +523,8 @@ async def set_contact_routing_override(
     route_text = request.route.strip()
     if route_text == "":
         await ContactRepository.clear_routing_override(contact.public_key)
-        await ContactRepository.update_path(contact.public_key, "", -1, -1)
         logger.info(
-            "Cleared routing override and reset learned path to flood for %s",
+            "Cleared routing override for %s",
             contact.public_key[:12],
         )
     elif route_text == "-1":

app/routers/debug.py

@@ -0,0 +1,300 @@
+import hashlib
+import logging
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+from fastapi import APIRouter
+from meshcore import EventType
+from pydantic import BaseModel, Field
+
+from app.config import get_recent_log_lines, settings
+from app.radio_sync import get_contacts_selected_for_radio_sync, get_radio_channel_limit
+from app.repository import MessageRepository, StatisticsRepository
+from app.routers.health import HealthResponse, build_health_data
+from app.services.radio_runtime import radio_runtime
+from app.version_info import get_app_build_info, git_output
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["debug"])
+
+LOG_COPY_BOUNDARY_MESSAGE = "STOP COPYING HERE IF YOU DO NOT WANT TO INCLUDE LOGS BELOW"
+LOG_COPY_BOUNDARY_LINE = "-" * 64
+LOG_COPY_BOUNDARY_PREFIX = [
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_MESSAGE,
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_LINE,
+    LOG_COPY_BOUNDARY_LINE,
+]
+
+
+class DebugApplicationInfo(BaseModel):
+    version: str
+    version_source: str
+    commit_hash: str | None = None
+    commit_source: str | None = None
+    git_branch: str | None = None
+    git_dirty: bool | None = None
+    python_version: str
+
+
+class DebugRuntimeInfo(BaseModel):
+    connection_info: str | None = None
+    connection_desired: bool
+    setup_in_progress: bool
+    setup_complete: bool
+    channels_with_incoming_messages: int
+    max_channels: int
+    path_hash_mode: int
+    path_hash_mode_supported: bool
+    channel_slot_reuse_enabled: bool
+    channel_send_cache_capacity: int
+    remediation_flags: dict[str, bool]
+
+
+class DebugContactAudit(BaseModel):
+    expected_and_found: int
+    expected_but_not_found: list[str]
+    found_but_not_expected: list[str]
+
+
+class DebugChannelSlotMismatch(BaseModel):
+    slot_number: int
+    expected_sha256_of_room_key: str | None = None
+    actual_sha256_of_room_key: str | None = None
+
+
+class DebugChannelAudit(BaseModel):
+    matched_slots: int
+    wrong_slots: list[DebugChannelSlotMismatch]
+
+
+class DebugRadioProbe(BaseModel):
+    performed: bool
+    errors: list[str] = Field(default_factory=list)
+    multi_acks_enabled: bool | None = None
+    self_info: dict[str, Any] | None = None
+    device_info: dict[str, Any] | None = None
+    stats_core: dict[str, Any] | None = None
+    stats_radio: dict[str, Any] | None = None
+    contacts: DebugContactAudit | None = None
+    channels: DebugChannelAudit | None = None
+
+
+class DebugDatabaseInfo(BaseModel):
+    total_dms: int
+    total_channel_messages: int
+    total_outgoing: int
+
+
+class DebugSnapshotResponse(BaseModel):
+    captured_at: str
+    application: DebugApplicationInfo
+    health: HealthResponse
+    runtime: DebugRuntimeInfo
+    database: DebugDatabaseInfo
+    radio_probe: DebugRadioProbe
+    logs: list[str]
+
+
+def _build_application_info() -> DebugApplicationInfo:
+    build_info = get_app_build_info()
+    dirty_output = git_output("status", "--porcelain")
+    return DebugApplicationInfo(
+        version=build_info.version,
+        version_source=build_info.version_source,
+        commit_hash=build_info.commit_hash,
+        commit_source=build_info.commit_source,
+        git_branch=git_output("rev-parse", "--abbrev-ref", "HEAD"),
+        git_dirty=(dirty_output is not None and dirty_output != ""),
+        python_version=sys.version.split()[0],
+    )
+
+
+def _event_type_name(event: Any) -> str:
+    event_type = getattr(event, "type", None)
+    return getattr(event_type, "name", str(event_type))
+
+
+def _sha256_hex(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _normalize_channel_secret(payload: dict[str, Any]) -> bytes:
+    secret = payload.get("channel_secret", b"")
+    if isinstance(secret, bytes):
+        return secret
+    return bytes(secret)
+
+
+def _is_empty_channel_payload(payload: dict[str, Any]) -> bool:
+    name = payload.get("channel_name", "")
+    return not name or name == "\x00" * len(name)
+
+
+def _observed_channel_key(event: Any) -> str | None:
+    if getattr(event, "type", None) != EventType.CHANNEL_INFO:
+        return None
+
+    payload = event.payload or {}
+    if _is_empty_channel_payload(payload):
+        return None
+
+    return _normalize_channel_secret(payload).hex().upper()
+
+
+def _coerce_live_max_channels(device_info: dict[str, Any] | None) -> int | None:
+    if not device_info or "max_channels" not in device_info:
+        return None
+    try:
+        return int(device_info["max_channels"])
+    except (TypeError, ValueError):
+        return None
+
+
+async def _build_contact_audit(
+    observed_contacts_payload: dict[str, dict[str, Any]],
+) -> DebugContactAudit:
+    expected_contacts = await get_contacts_selected_for_radio_sync()
+    expected_keys = {contact.public_key.lower() for contact in expected_contacts}
+    observed_keys = {public_key.lower() for public_key in observed_contacts_payload}
+
+    return DebugContactAudit(
+        expected_and_found=len(expected_keys & observed_keys),
+        expected_but_not_found=sorted(_sha256_hex(key) for key in (expected_keys - observed_keys)),
+        found_but_not_expected=sorted(_sha256_hex(key) for key in (observed_keys - expected_keys)),
+    )
+
+
+async def _build_channel_audit(mc: Any, max_channels: int | None = None) -> DebugChannelAudit:
+    cache_key_by_slot = {
+        slot: channel_key for channel_key, slot in radio_runtime.get_channel_send_cache_snapshot()
+    }
+
+    matched_slots = 0
+    wrong_slots: list[DebugChannelSlotMismatch] = []
+    for slot in range(get_radio_channel_limit(max_channels)):
+        event = await mc.commands.get_channel(slot)
+        expected_key = cache_key_by_slot.get(slot)
+        observed_key = _observed_channel_key(event)
+        if expected_key == observed_key:
+            matched_slots += 1
+            continue
+        wrong_slots.append(
+            DebugChannelSlotMismatch(
+                slot_number=slot,
+                expected_sha256_of_room_key=_sha256_hex(expected_key) if expected_key else None,
+                actual_sha256_of_room_key=_sha256_hex(observed_key) if observed_key else None,
+            )
+        )
+
+    return DebugChannelAudit(
+        matched_slots=matched_slots,
+        wrong_slots=wrong_slots,
+    )
+
+
+async def _probe_radio() -> DebugRadioProbe:
+    if not radio_runtime.is_connected:
+        return DebugRadioProbe(performed=False, errors=["Radio not connected"])
+
+    errors: list[str] = []
+    try:
+        async with radio_runtime.radio_operation(
+            "debug_support_snapshot",
+            suspend_auto_fetch=True,
+        ) as mc:
+            device_info = None
+            stats_core = None
+            stats_radio = None
+
+            device_event = await mc.commands.send_device_query()
+            if getattr(device_event, "type", None) == EventType.DEVICE_INFO:
+                device_info = device_event.payload
+            else:
+                errors.append(f"send_device_query returned {_event_type_name(device_event)}")
+
+            core_event = await mc.commands.get_stats_core()
+            if getattr(core_event, "type", None) == EventType.STATS_CORE:
+                stats_core = core_event.payload
+            else:
+                errors.append(f"get_stats_core returned {_event_type_name(core_event)}")
+
+            radio_event = await mc.commands.get_stats_radio()
+            if getattr(radio_event, "type", None) == EventType.STATS_RADIO:
+                stats_radio = radio_event.payload
+            else:
+                errors.append(f"get_stats_radio returned {_event_type_name(radio_event)}")
+
+            contacts_event = await mc.commands.get_contacts()
+            observed_contacts_payload: dict[str, dict[str, Any]] = {}
+            if getattr(contacts_event, "type", None) != EventType.ERROR:
+                observed_contacts_payload = contacts_event.payload or {}
+            else:
+                errors.append(f"get_contacts returned {_event_type_name(contacts_event)}")
+
+            return DebugRadioProbe(
+                performed=True,
+                errors=errors,
+                multi_acks_enabled=bool(mc.self_info.get("multi_acks", 0))
+                if mc.self_info is not None
+                else None,
+                self_info=dict(mc.self_info or {}),
+                device_info=device_info,
+                stats_core=stats_core,
+                stats_radio=stats_radio,
+                contacts=await _build_contact_audit(observed_contacts_payload),
+                channels=await _build_channel_audit(
+                    mc,
+                    max_channels=_coerce_live_max_channels(device_info),
+                ),
+            )
+    except Exception as exc:
+        logger.warning("Debug support snapshot radio probe failed: %s", exc, exc_info=True)
+        errors.append(str(exc))
+        return DebugRadioProbe(performed=False, errors=errors)
+
+
+@router.get("/debug", response_model=DebugSnapshotResponse)
+async def debug_support_snapshot() -> DebugSnapshotResponse:
+    """Return a support/debug snapshot with recent logs and live radio state."""
+    health_data = await build_health_data(radio_runtime.is_connected, radio_runtime.connection_info)
+    statistics = await StatisticsRepository.get_all()
+    radio_probe = await _probe_radio()
+    channels_with_incoming_messages = (
+        await MessageRepository.count_channels_with_incoming_messages()
+    )
+    return DebugSnapshotResponse(
+        captured_at=datetime.now(timezone.utc).isoformat(),
+        application=_build_application_info(),
+        health=HealthResponse(**health_data),
+        runtime=DebugRuntimeInfo(
+            connection_info=radio_runtime.connection_info,
+            connection_desired=radio_runtime.connection_desired,
+            setup_in_progress=radio_runtime.is_setup_in_progress,
+            setup_complete=radio_runtime.is_setup_complete,
+            channels_with_incoming_messages=channels_with_incoming_messages,
+            max_channels=radio_runtime.max_channels,
+            path_hash_mode=radio_runtime.path_hash_mode,
+            path_hash_mode_supported=radio_runtime.path_hash_mode_supported,
+            channel_slot_reuse_enabled=radio_runtime.channel_slot_reuse_enabled(),
+            channel_send_cache_capacity=radio_runtime.get_channel_send_cache_capacity(),
+            remediation_flags={
+                "enable_message_poll_fallback": settings.enable_message_poll_fallback,
+                "force_channel_slot_reconfigure": settings.force_channel_slot_reconfigure,
+            },
+        ),
+        database=DebugDatabaseInfo(
+            total_dms=statistics["total_dms"],
+            total_channel_messages=statistics["total_channel_messages"],
+            total_outgoing=statistics["total_outgoing"],
+        ),
+        radio_probe=radio_probe,
+        logs=[*LOG_COPY_BOUNDARY_PREFIX, *get_recent_log_lines(limit=1000)],
+    )

app/routers/fanout.py

@@ -1,5 +1,7 @@
 """REST API for fanout config CRUD."""
 
+import ast
+import inspect
 import logging
 import re
 import string
@@ -8,6 +10,7 @@ from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
 from app.config import settings as server_settings
+from app.fanout.bot_exec import _analyze_bot_signature
 from app.repository.fanout import FanoutConfigRepository
 
 logger = logging.getLogger(__name__)
@@ -75,6 +78,26 @@ class FanoutConfigUpdate(BaseModel):
     enabled: bool | None = Field(default=None, description="Enable/disable toggle")
 
 
+def _validate_and_normalize_config(config_type: str, config: dict) -> dict:
+    """Validate a config blob and return the canonical persisted form."""
+    normalized = dict(config)
+
+    if config_type == "mqtt_private":
+        _validate_mqtt_private_config(normalized)
+    elif config_type == "mqtt_community":
+        _validate_mqtt_community_config(normalized)
+    elif config_type == "bot":
+        _validate_bot_config(normalized)
+    elif config_type == "webhook":
+        _validate_webhook_config(normalized)
+    elif config_type == "apprise":
+        _validate_apprise_config(normalized)
+    elif config_type == "sqs":
+        _validate_sqs_config(normalized)
+
+    return normalized
+
+
 def _validate_mqtt_private_config(config: dict) -> None:
     """Validate mqtt_private config blob."""
     if not config.get("broker_host"):
@@ -144,18 +167,78 @@ def _validate_mqtt_community_config(config: dict) -> None:
 
 
 def _validate_bot_config(config: dict) -> None:
-    """Validate bot config blob (syntax-check the code)."""
+    """Validate bot config blob (syntax-check the code and supported signature)."""
     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")
+        tree = ast.parse(code, filename="<bot_code>", mode="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
 
+    bot_def = next(
+        (
+            node
+            for node in tree.body
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == "bot"
+        ),
+        None,
+    )
+    if bot_def is None:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "Bot code must define a callable bot() function. "
+                "Use the default bot template as a reference."
+            ),
+        )
+
+    try:
+        parameters: list[inspect.Parameter] = []
+        positional_args = [
+            *((arg, inspect.Parameter.POSITIONAL_ONLY) for arg in bot_def.args.posonlyargs),
+            *((arg, inspect.Parameter.POSITIONAL_OR_KEYWORD) for arg in bot_def.args.args),
+        ]
+        positional_defaults_start = len(positional_args) - len(bot_def.args.defaults)
+        sentinel_default = object()
+
+        for index, (arg, kind) in enumerate(positional_args):
+            has_default = index >= positional_defaults_start
+            parameters.append(
+                inspect.Parameter(
+                    arg.arg,
+                    kind=kind,
+                    default=sentinel_default if has_default else inspect.Parameter.empty,
+                )
+            )
+        if bot_def.args.vararg is not None:
+            parameters.append(
+                inspect.Parameter(bot_def.args.vararg.arg, kind=inspect.Parameter.VAR_POSITIONAL)
+            )
+        for kwonly_arg, kw_default in zip(
+            bot_def.args.kwonlyargs, bot_def.args.kw_defaults, strict=True
+        ):
+            parameters.append(
+                inspect.Parameter(
+                    kwonly_arg.arg,
+                    kind=inspect.Parameter.KEYWORD_ONLY,
+                    default=(
+                        sentinel_default if kw_default is not None else inspect.Parameter.empty
+                    ),
+                )
+            )
+        if bot_def.args.kwarg is not None:
+            parameters.append(
+                inspect.Parameter(bot_def.args.kwarg.arg, kind=inspect.Parameter.VAR_KEYWORD)
+            )
+
+        _analyze_bot_signature(inspect.Signature(parameters))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from None
+
 
 def _validate_apprise_config(config: dict) -> None:
     """Validate apprise config blob."""
@@ -260,28 +343,13 @@ async def create_fanout_config(body: FanoutConfigCreate) -> dict:
     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)
-        elif body.type == "sqs":
-            _validate_sqs_config(body.config)
-
+    normalized_config = _validate_and_normalize_config(body.type, body.config)
     scope = _enforce_scope(body.type, body.scope)
 
     cfg = await FanoutConfigRepository.create(
         config_type=body.type,
         name=body.name,
-        config=body.config,
+        config=normalized_config,
         scope=scope,
         enabled=body.enabled,
     )
@@ -311,27 +379,11 @@ async def update_fanout_config(config_id: str, body: FanoutConfigUpdate) -> dict
         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)
-        elif existing["type"] == "sqs":
-            _validate_sqs_config(config_to_validate)
+    config_to_validate = body.config if body.config is not None else existing["config"]
+    kwargs["config"] = _validate_and_normalize_config(existing["type"], config_to_validate)
 
     updated = await FanoutConfigRepository.update(config_id, **kwargs)
     if updated is None:

app/routers/health.py

@@ -7,24 +7,48 @@ from pydantic import BaseModel
 from app.config import settings
 from app.repository import RawPacketRepository
 from app.services.radio_runtime import radio_runtime as radio_manager
+from app.version_info import get_app_build_info
 
 router = APIRouter(tags=["health"])
 
 
+class RadioDeviceInfoResponse(BaseModel):
+    model: str | None = None
+    firmware_build: str | None = None
+    firmware_version: str | None = None
+    max_contacts: int | None = None
+    max_channels: int | None = None
+
+
+class AppInfoResponse(BaseModel):
+    version: str
+    commit_hash: str | None = None
+
+
 class HealthResponse(BaseModel):
     status: str
     radio_connected: bool
     radio_initializing: bool = False
     radio_state: str = "disconnected"
     connection_info: str | None
+    app_info: AppInfoResponse | None = None
+    radio_device_info: RadioDeviceInfoResponse | None = None
     database_size_mb: float
     oldest_undecrypted_timestamp: int | None
     fanout_statuses: dict[str, dict[str, str]] = {}
     bots_disabled: bool = False
 
 
+def _clean_optional_str(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    cleaned = value.strip()
+    return cleaned or None
+
+
 async def build_health_data(radio_connected: bool, connection_info: str | None) -> dict:
     """Build the health status payload used by REST endpoint and WebSocket broadcasts."""
+    app_build_info = get_app_build_info()
     db_size_mb = 0.0
     try:
         db_size_bytes = os.path.getsize(settings.database_path)
@@ -48,22 +72,12 @@ async def build_health_data(radio_connected: bool, connection_info: str | None)
         pass
 
     setup_in_progress = getattr(radio_manager, "is_setup_in_progress", False)
-    if not isinstance(setup_in_progress, bool):
-        setup_in_progress = False
-
     setup_complete = getattr(radio_manager, "is_setup_complete", radio_connected)
-    if not isinstance(setup_complete, bool):
-        setup_complete = radio_connected
     if not radio_connected:
         setup_complete = False
 
     connection_desired = getattr(radio_manager, "connection_desired", True)
-    if not isinstance(connection_desired, bool):
-        connection_desired = True
-
     is_reconnecting = getattr(radio_manager, "is_reconnecting", False)
-    if not isinstance(is_reconnecting, bool):
-        is_reconnecting = False
 
     radio_initializing = bool(radio_connected and (setup_in_progress or not setup_complete))
     if not connection_desired:
@@ -77,12 +91,30 @@ async def build_health_data(radio_connected: bool, connection_info: str | None)
     else:
         radio_state = "disconnected"
 
+    radio_device_info = None
+    device_info_loaded = getattr(radio_manager, "device_info_loaded", False)
+    if radio_connected and device_info_loaded:
+        radio_device_info = {
+            "model": _clean_optional_str(getattr(radio_manager, "device_model", None)),
+            "firmware_build": _clean_optional_str(getattr(radio_manager, "firmware_build", None)),
+            "firmware_version": _clean_optional_str(
+                getattr(radio_manager, "firmware_version", None)
+            ),
+            "max_contacts": getattr(radio_manager, "max_contacts", None),
+            "max_channels": getattr(radio_manager, "max_channels", None),
+        }
+
     return {
         "status": "ok" if radio_connected and not radio_initializing else "degraded",
         "radio_connected": radio_connected,
         "radio_initializing": radio_initializing,
         "radio_state": radio_state,
         "connection_info": connection_info,
+        "app_info": {
+            "version": app_build_info.version,
+            "commit_hash": app_build_info.commit_hash,
+        },
+        "radio_device_info": radio_device_info,
         "database_size_mb": db_size_mb,
         "oldest_undecrypted_timestamp": oldest_ts,
         "fanout_statuses": fanout_statuses,

app/routers/messages.py

@@ -8,6 +8,7 @@ from app.event_handlers import track_pending_ack
 from app.models import (
     Message,
     MessagesAroundResponse,
+    ResendChannelMessageResponse,
     SendChannelMessageRequest,
     SendDirectMessageRequest,
 )
@@ -108,6 +109,11 @@ async def send_direct_message(request: SendDirectMessageRequest) -> Message:
         raise HTTPException(
             status_code=404, detail=f"Contact not found in database: {request.destination}"
         )
+    if len(db_contact.public_key) < 64:
+        raise HTTPException(
+            status_code=409,
+            detail="Cannot send to an unresolved prefix-only contact until a full key is known",
+        )
 
     return await send_direct_message_to_contact(
         contact=db_contact,
@@ -121,7 +127,9 @@ async def send_direct_message(request: SendDirectMessageRequest) -> Message:
     )
 
 
-# Temporary radio slot used for sending channel messages
+# Preferred first radio slot used for sending channel messages.
+# The send service may reuse/load other app-managed slots depending on transport
+# and session cache state.
 TEMP_RADIO_SLOT = 0
 
 
@@ -131,7 +139,6 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
     require_connected()
 
     # Get channel info from our database
-    from app.decoder import calculate_channel_hash
     from app.repository import ChannelRepository
 
     db_channel = await ChannelRepository.get_by_key(request.channel_key)
@@ -148,14 +155,6 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
             status_code=400, detail=f"Invalid channel key format: {request.channel_key}"
         ) from None
 
-    expected_hash = calculate_channel_hash(key_bytes)
-    logger.info(
-        "Sending to channel %s (%s) via radio slot %d, key hash: %s",
-        request.channel_key,
-        db_channel.name,
-        TEMP_RADIO_SLOT,
-        expected_hash,
-    )
     return await send_channel_message_to_channel(
         channel=db_channel,
         channel_key_upper=request.channel_key.upper(),
@@ -173,11 +172,15 @@ async def send_channel_message(request: SendChannelMessageRequest) -> Message:
 RESEND_WINDOW_SECONDS = 30
 
 
-@router.post("/channel/{message_id}/resend")
+@router.post(
+    "/channel/{message_id}/resend",
+    response_model=ResendChannelMessageResponse,
+    response_model_exclude_none=True,
+)
 async def resend_channel_message(
     message_id: int,
     new_timestamp: bool = Query(default=False),
-) -> dict:
+) -> ResendChannelMessageResponse:
     """Resend a channel message.
 
     When new_timestamp=False (default): byte-perfect resend using the original timestamp.

app/routers/packets.py

@@ -3,7 +3,7 @@ from hashlib import sha256
 from sqlite3 import OperationalError
 
 import aiosqlite
-from fastapi import APIRouter, BackgroundTasks
+from fastapi import APIRouter, BackgroundTasks, HTTPException, Response, status
 from pydantic import BaseModel, Field
 
 from app.database import db
@@ -40,6 +40,10 @@ class DecryptResult(BaseModel):
     message: str
 
 
+def _bad_request(detail: str) -> HTTPException:
+    return HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=detail)
+
+
 async def _run_historical_channel_decryption(
     channel_key_bytes: bytes, channel_key_hex: str, display_name: str | None = None
 ) -> None:
@@ -100,7 +104,7 @@ async def get_undecrypted_count() -> dict:
 
 @router.post("/decrypt/historical", response_model=DecryptResult)
 async def decrypt_historical_packets(
-    request: DecryptRequest, background_tasks: BackgroundTasks
+    request: DecryptRequest, background_tasks: BackgroundTasks, response: Response
 ) -> DecryptResult:
     """
     Attempt to decrypt historical packets with the provided key.
@@ -112,27 +116,15 @@ async def decrypt_historical_packets(
             try:
                 channel_key_bytes = bytes.fromhex(request.channel_key)
                 if len(channel_key_bytes) != 16:
-                    return DecryptResult(
-                        started=False,
-                        total_packets=0,
-                        message="Channel key must be 16 bytes (32 hex chars)",
-                    )
+                    raise _bad_request("Channel key must be 16 bytes (32 hex chars)")
                 channel_key_hex = request.channel_key.upper()
             except ValueError:
-                return DecryptResult(
-                    started=False,
-                    total_packets=0,
-                    message="Invalid hex string for channel key",
-                )
+                raise _bad_request("Invalid hex string for channel key") from None
         elif request.channel_name:
             channel_key_bytes = sha256(request.channel_name.encode("utf-8")).digest()[:16]
             channel_key_hex = channel_key_bytes.hex().upper()
         else:
-            return DecryptResult(
-                started=False,
-                total_packets=0,
-                message="Must provide channel_key or channel_name",
-            )
+            raise _bad_request("Must provide channel_key or channel_name")
 
         # Get count and lookup channel name for display
         count = await RawPacketRepository.get_undecrypted_count()
@@ -148,6 +140,7 @@ async def decrypt_historical_packets(
         background_tasks.add_task(
             _run_historical_channel_decryption, channel_key_bytes, channel_key_hex, display_name
         )
+        response.status_code = status.HTTP_202_ACCEPTED
 
         return DecryptResult(
             started=True,
@@ -158,48 +151,24 @@ async def decrypt_historical_packets(
     elif request.key_type == "contact":
         # DM decryption
         if not request.private_key:
-            return DecryptResult(
-                started=False,
-                total_packets=0,
-                message="Must provide private_key for contact decryption",
-            )
+            raise _bad_request("Must provide private_key for contact decryption")
         if not request.contact_public_key:
-            return DecryptResult(
-                started=False,
-                total_packets=0,
-                message="Must provide contact_public_key for contact decryption",
-            )
+            raise _bad_request("Must provide contact_public_key for contact decryption")
 
         try:
             private_key_bytes = bytes.fromhex(request.private_key)
             if len(private_key_bytes) != 64:
-                return DecryptResult(
-                    started=False,
-                    total_packets=0,
-                    message="Private key must be 64 bytes (128 hex chars)",
-                )
+                raise _bad_request("Private key must be 64 bytes (128 hex chars)")
         except ValueError:
-            return DecryptResult(
-                started=False,
-                total_packets=0,
-                message="Invalid hex string for private key",
-            )
+            raise _bad_request("Invalid hex string for private key") from None
 
         try:
             contact_public_key_bytes = bytes.fromhex(request.contact_public_key)
             if len(contact_public_key_bytes) != 32:
-                return DecryptResult(
-                    started=False,
-                    total_packets=0,
-                    message="Contact public key must be 32 bytes (64 hex chars)",
-                )
+                raise _bad_request("Contact public key must be 32 bytes (64 hex chars)")
             contact_public_key_hex = request.contact_public_key.lower()
         except ValueError:
-            return DecryptResult(
-                started=False,
-                total_packets=0,
-                message="Invalid hex string for contact public key",
-            )
+            raise _bad_request("Invalid hex string for contact public key") from None
 
         packets = await RawPacketRepository.get_undecrypted_text_messages()
         count = len(packets)
@@ -223,6 +192,7 @@ async def decrypt_historical_packets(
             contact_public_key_hex,
             display_name,
         )
+        response.status_code = status.HTTP_202_ACCEPTED
 
         return DecryptResult(
             started=True,
@@ -230,11 +200,7 @@ async def decrypt_historical_packets(
             message=f"Started DM decryption of {count} TEXT_MESSAGE packets in background",
         )
 
-    return DecryptResult(
-        started=False,
-        total_packets=0,
-        message="key_type must be 'channel' or 'contact'",
-    )
+    raise _bad_request("key_type must be 'channel' or 'contact'")
 
 
 class MaintenanceRequest(BaseModel):

app/routers/radio.py

@@ -1,11 +1,23 @@
+import asyncio
 import logging
+import random
+import time
+from typing import Literal, TypeAlias
 
 from fastapi import APIRouter, HTTPException
+from meshcore import EventType
 from pydantic import BaseModel, Field
 
 from app.dependencies import require_connected
+from app.models import (
+    ContactUpsert,
+    RadioDiscoveryRequest,
+    RadioDiscoveryResponse,
+    RadioDiscoveryResult,
+)
 from app.radio_sync import send_advertisement as do_send_advertisement
 from app.radio_sync import sync_radio_time
+from app.repository import ContactRepository
 from app.services.radio_commands import (
     KeystoreRefreshError,
     PathHashModeUnsupportedError,
@@ -14,11 +26,25 @@ from app.services.radio_commands import (
     import_private_key_and_refresh_keystore,
 )
 from app.services.radio_runtime import radio_runtime as radio_manager
-from app.websocket import broadcast_health
+from app.websocket import broadcast_event, broadcast_health
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/radio", tags=["radio"])
 
+AdvertLocationSource = Literal["off", "current"]
+RadioAdvertMode = Literal["flood", "zero_hop"]
+DiscoveryNodeType: TypeAlias = Literal["repeater", "sensor"]
+DISCOVERY_WINDOW_SECONDS = 8.0
+_DISCOVERY_TARGET_BITS = {
+    "repeaters": 1 << 2,
+    "sensors": 1 << 4,
+    "all": (1 << 2) | (1 << 4),
+}
+_DISCOVERY_NODE_TYPES: dict[int, DiscoveryNodeType] = {
+    2: "repeater",
+    4: "sensor",
+}
+
 
 async def _prepare_connected(*, broadcast_on_success: bool) -> bool:
     return await radio_manager.prepare_connected(broadcast_on_success=broadcast_on_success)
@@ -51,6 +77,14 @@ class RadioConfigResponse(BaseModel):
     path_hash_mode_supported: bool = Field(
         default=False, description="Whether firmware supports path hash mode setting"
     )
+    advert_location_source: AdvertLocationSource = Field(
+        default="current",
+        description="Whether adverts include the node's current location state",
+    )
+    multi_acks_enabled: bool = Field(
+        default=False,
+        description="Whether the radio sends an extra direct ACK transmission",
+    )
 
 
 class RadioConfigUpdate(BaseModel):
@@ -65,12 +99,109 @@ class RadioConfigUpdate(BaseModel):
         le=2,
         description="Path hash mode (0=1-byte, 1=2-byte, 2=3-byte)",
     )
+    advert_location_source: AdvertLocationSource | None = Field(
+        default=None,
+        description="Whether adverts include the node's current location state",
+    )
+    multi_acks_enabled: bool | None = Field(
+        default=None,
+        description="Whether the radio sends an extra direct ACK transmission",
+    )
 
 
 class PrivateKeyUpdate(BaseModel):
     private_key: str = Field(description="Private key as hex string")
 
 
+class RadioAdvertiseRequest(BaseModel):
+    mode: RadioAdvertMode = Field(
+        default="flood",
+        description="Advertisement mode: flood through repeaters or zero-hop local only",
+    )
+
+
+def _monotonic() -> float:
+    return time.monotonic()
+
+
+def _better_signal(first: float | None, second: float | None) -> float | None:
+    if first is None:
+        return second
+    if second is None:
+        return first
+    return second if second > first else first
+
+
+def _coerce_float(value: object) -> float | None:
+    if isinstance(value, (int, float)):
+        return float(value)
+    return None
+
+
+def _coerce_int(value: object) -> int | None:
+    if isinstance(value, int):
+        return value
+    return None
+
+
+def _merge_discovery_result(
+    existing: RadioDiscoveryResult | None, event_payload: dict[str, object]
+) -> RadioDiscoveryResult | None:
+    public_key = event_payload.get("pubkey")
+    node_type_code = event_payload.get("node_type")
+    if not isinstance(public_key, str) or not public_key:
+        return existing
+    if not isinstance(node_type_code, int):
+        return existing
+
+    node_type = _DISCOVERY_NODE_TYPES.get(node_type_code)
+    if node_type is None:
+        return existing
+
+    if existing is None:
+        return RadioDiscoveryResult(
+            public_key=public_key,
+            node_type=node_type,
+            heard_count=1,
+            local_snr=_coerce_float(event_payload.get("SNR")),
+            local_rssi=_coerce_int(event_payload.get("RSSI")),
+            remote_snr=_coerce_float(event_payload.get("SNR_in")),
+        )
+
+    existing.heard_count += 1
+    existing.local_snr = _better_signal(existing.local_snr, _coerce_float(event_payload.get("SNR")))
+    current_rssi = _coerce_int(event_payload.get("RSSI"))
+    if existing.local_rssi is None or (
+        current_rssi is not None and current_rssi > existing.local_rssi
+    ):
+        existing.local_rssi = current_rssi
+    existing.remote_snr = _better_signal(
+        existing.remote_snr,
+        _coerce_float(event_payload.get("SNR_in")),
+    )
+    return existing
+
+
+async def _persist_new_discovery_contacts(results: list[RadioDiscoveryResult]) -> None:
+    now = int(time.time())
+    for result in results:
+        existing = await ContactRepository.get_by_key(result.public_key)
+        if existing is not None:
+            continue
+
+        contact = ContactUpsert(
+            public_key=result.public_key,
+            type=2 if result.node_type == "repeater" else 4,
+            last_seen=now,
+            first_seen=now,
+            on_radio=False,
+        )
+        await ContactRepository.upsert(contact)
+        created = await ContactRepository.get_by_key(result.public_key)
+        if created is not None:
+            broadcast_event("contact", created.model_dump())
+
+
 @router.get("/config", response_model=RadioConfigResponse)
 async def get_radio_config() -> RadioConfigResponse:
     """Get the current radio configuration."""
@@ -80,6 +211,9 @@ async def get_radio_config() -> RadioConfigResponse:
     if not info:
         raise HTTPException(status_code=503, detail="Radio info not available")
 
+    adv_loc_policy = info.get("adv_loc_policy", 1)
+    advert_location_source: AdvertLocationSource = "off" if adv_loc_policy == 0 else "current"
+
     return RadioConfigResponse(
         public_key=info.get("public_key", ""),
         name=info.get("name", ""),
@@ -95,6 +229,8 @@ async def get_radio_config() -> RadioConfigResponse:
         ),
         path_hash_mode=radio_manager.path_hash_mode,
         path_hash_mode_supported=radio_manager.path_hash_mode_supported,
+        advert_location_source=advert_location_source,
+        multi_acks_enabled=bool(info.get("multi_acks", 0)),
     )
 
 
@@ -147,28 +283,95 @@ async def set_private_key(update: PrivateKeyUpdate) -> dict:
 
 
 @router.post("/advertise")
-async def send_advertisement() -> dict:
-    """Send a flood advertisement to announce presence on the mesh.
+async def send_advertisement(request: RadioAdvertiseRequest | None = None) -> dict:
+    """Send an advertisement to announce presence on the mesh.
 
-    Manual advertisement requests always send immediately, updating the
-    last_advert_time which affects when the next periodic/startup advert
-    can occur.
+    Manual advertisement requests always send immediately. Flood adverts update
+    the shared flood-advert timing state used by periodic/startup advertising;
+    zero-hop adverts currently do not.
 
     Returns:
         status: "ok" if sent successfully
     """
     require_connected()
+    mode: RadioAdvertMode = request.mode if request is not None else "flood"
 
-    logger.info("Sending flood advertisement")
+    logger.info("Sending %s advertisement", mode.replace("_", "-"))
     async with radio_manager.radio_operation("manual_advertisement") as mc:
-        success = await do_send_advertisement(mc, force=True)
+        success = await do_send_advertisement(mc, force=True, mode=mode)
 
     if not success:
-        raise HTTPException(status_code=500, detail="Failed to send advertisement")
+        raise HTTPException(status_code=500, detail=f"Failed to send {mode} advertisement")
 
     return {"status": "ok"}
 
 
+@router.post("/discover", response_model=RadioDiscoveryResponse)
+async def discover_mesh(request: RadioDiscoveryRequest) -> RadioDiscoveryResponse:
+    """Run a short node-discovery sweep from the local radio."""
+    require_connected()
+
+    target_bits = _DISCOVERY_TARGET_BITS[request.target]
+    tag = random.randint(1, 0xFFFFFFFF)
+    tag_hex = tag.to_bytes(4, "little", signed=False).hex()
+    events: asyncio.Queue = asyncio.Queue()
+
+    async with radio_manager.radio_operation(
+        "discover_mesh",
+        pause_polling=True,
+        suspend_auto_fetch=True,
+    ) as mc:
+        subscription = mc.subscribe(
+            EventType.DISCOVER_RESPONSE,
+            lambda event: events.put_nowait(event),
+            {"tag": tag_hex},
+        )
+        try:
+            send_result = await mc.commands.send_node_discover_req(
+                target_bits,
+                prefix_only=False,
+                tag=tag,
+            )
+            if send_result is None or send_result.type == EventType.ERROR:
+                raise HTTPException(status_code=500, detail="Failed to start mesh discovery")
+
+            deadline = _monotonic() + DISCOVERY_WINDOW_SECONDS
+            results_by_key: dict[str, RadioDiscoveryResult] = {}
+
+            while True:
+                remaining = deadline - _monotonic()
+                if remaining <= 0:
+                    break
+                try:
+                    event = await asyncio.wait_for(events.get(), timeout=remaining)
+                except asyncio.TimeoutError:
+                    break
+
+                merged = _merge_discovery_result(
+                    results_by_key.get(event.payload.get("pubkey")),
+                    event.payload,
+                )
+                if merged is not None:
+                    results_by_key[merged.public_key] = merged
+        finally:
+            subscription.unsubscribe()
+
+    results = sorted(
+        results_by_key.values(),
+        key=lambda item: (
+            item.node_type,
+            -(item.local_snr if item.local_snr is not None else -999.0),
+            item.public_key,
+        ),
+    )
+    await _persist_new_discovery_contacts(results)
+    return RadioDiscoveryResponse(
+        target=request.target,
+        duration_seconds=DISCOVERY_WINDOW_SECONDS,
+        results=results,
+    )
+
+
 async def _attempt_reconnect() -> dict:
     """Shared reconnection logic for reboot and reconnect endpoints."""
     radio_manager.resume_connection()

app/routers/repeaters.py

@@ -1,6 +1,5 @@
 import asyncio
 import logging
-import time
 from typing import TYPE_CHECKING
 
 from fastapi import APIRouter, HTTPException
@@ -21,12 +20,21 @@ from app.models import (
     RepeaterLoginResponse,
     RepeaterLppTelemetryResponse,
     RepeaterNeighborsResponse,
+    RepeaterNodeInfoResponse,
     RepeaterOwnerInfoResponse,
     RepeaterRadioSettingsResponse,
     RepeaterStatusResponse,
 )
 from app.repository import ContactRepository
 from app.routers.contacts import _ensure_on_radio, _resolve_contact_or_404
+from app.routers.server_control import (
+    _monotonic,
+    batch_cli_fetch,
+    extract_response_text,
+    prepare_authenticated_contact_connection,
+    require_server_capable_contact,
+    send_contact_cli_command,
+)
 from app.services.radio_runtime import radio_runtime as radio_manager
 
 if TYPE_CHECKING:
@@ -42,26 +50,11 @@ ACL_PERMISSION_NAMES = {
     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()
+REPEATER_LOGIN_RESPONSE_TIMEOUT_SECONDS = 5.0
 
 
 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
+    return extract_response_text(event)
 
 
 async def _fetch_repeater_response(
@@ -69,21 +62,6 @@ async def _fetch_repeater_response(
     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:
@@ -91,13 +69,12 @@ async def _fetch_repeater_response(
             result = await mc.commands.get_msg(timeout=2.0)
         except asyncio.TimeoutError:
             continue
-        except Exception as e:
-            logger.debug("get_msg() exception: %s", e)
+        except Exception as exc:
+            logger.debug("get_msg() exception: %s", exc)
             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
 
@@ -111,8 +88,6 @@ async def _fetch_repeater_response(
             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,
@@ -122,7 +97,6 @@ async def _fetch_repeater_response(
             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"),
@@ -135,31 +109,14 @@ async def _fetch_repeater_response(
     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)
+async def prepare_repeater_connection(mc, contact: Contact, password: str) -> RepeaterLoginResponse:
+    return await prepare_authenticated_contact_connection(
+        mc,
+        contact,
+        password,
+        label="repeater",
+        response_timeout=REPEATER_LOGIN_RESPONSE_TIMEOUT_SECONDS,
+    )
 
 
 def _require_repeater(contact: Contact) -> None:
@@ -179,7 +136,7 @@ def _require_repeater(contact: Contact) -> None:
 
 @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."""
+    """Attempt repeater login and report whether auth was confirmed."""
     require_connected()
     contact = await _resolve_contact_or_404(public_key)
     _require_repeater(contact)
@@ -189,9 +146,7 @@ async def repeater_login(public_key: str, request: RepeaterLoginRequest) -> Repe
         pause_polling=True,
         suspend_auto_fetch=True,
     ) as mc:
-        await prepare_repeater_connection(mc, contact, request.password)
-
-    return RepeaterLoginResponse(status="ok")
+        return await prepare_repeater_connection(mc, contact, request.password)
 
 
 @router.post("/{public_key}/repeater/status", response_model=RepeaterStatusResponse)
@@ -334,48 +289,32 @@ async def _batch_cli_fetch(
     operation_name: str,
     commands: list[tuple[str, str]],
 ) -> dict[str, str | None]:
-    """Send a batch of CLI commands to a repeater and collect responses.
+    return await batch_cli_fetch(contact, operation_name, commands)
 
-    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}
+@router.post("/{public_key}/repeater/node-info", response_model=RepeaterNodeInfoResponse)
+async def repeater_node_info(public_key: str) -> RepeaterNodeInfoResponse:
+    """Fetch repeater identity/location info via a small CLI batch."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_repeater(contact)
 
-    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
+    results = await _batch_cli_fetch(
+        contact,
+        "repeater_node_info",
+        [
+            ("get name", "name"),
+            ("get lat", "lat"),
+            ("get lon", "lon"),
+            ("clock", "clock_utc"),
+        ],
+    )
+    return RepeaterNodeInfoResponse(**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."""
+    """Fetch radio settings from a repeater via radio/config CLI commands."""
     require_connected()
     contact = await _resolve_contact_or_404(public_key)
     _require_repeater(contact)
@@ -390,10 +329,6 @@ async def repeater_radio_settings(public_key: str) -> RepeaterRadioSettingsRespo
             ("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)
@@ -439,72 +374,13 @@ async def repeater_owner_info(public_key: str) -> RepeaterOwnerInfoResponse:
 
 @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, time <epoch_seconds>
-    - reboot
-    - ver
-    """
+    """Send a CLI command to a repeater or room server."""
     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,
-        )
+    require_server_capable_contact(contact)
+    return await send_contact_cli_command(
+        contact,
+        request.command,
+        operation_name="send_repeater_command",
+    )

app/routers/rooms.py

@@ -0,0 +1,145 @@
+from fastapi import APIRouter, HTTPException
+
+from app.dependencies import require_connected
+from app.models import (
+    CONTACT_TYPE_ROOM,
+    AclEntry,
+    LppSensor,
+    RepeaterAclResponse,
+    RepeaterLoginRequest,
+    RepeaterLoginResponse,
+    RepeaterLppTelemetryResponse,
+    RepeaterStatusResponse,
+)
+from app.routers.contacts import _ensure_on_radio, _resolve_contact_or_404
+from app.routers.server_control import (
+    prepare_authenticated_contact_connection,
+    require_server_capable_contact,
+)
+from app.services.radio_runtime import radio_runtime as radio_manager
+
+router = APIRouter(prefix="/contacts", tags=["rooms"])
+
+
+def _require_room(contact) -> None:
+    require_server_capable_contact(contact, allowed_types=(CONTACT_TYPE_ROOM,))
+
+
+@router.post("/{public_key}/room/login", response_model=RepeaterLoginResponse)
+async def room_login(public_key: str, request: RepeaterLoginRequest) -> RepeaterLoginResponse:
+    """Attempt room-server login and report whether auth was confirmed."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_room(contact)
+
+    async with radio_manager.radio_operation(
+        "room_login",
+        pause_polling=True,
+        suspend_auto_fetch=True,
+    ) as mc:
+        return await prepare_authenticated_contact_connection(
+            mc,
+            contact,
+            request.password,
+            label="room server",
+        )
+
+
+@router.post("/{public_key}/room/status", response_model=RepeaterStatusResponse)
+async def room_status(public_key: str) -> RepeaterStatusResponse:
+    """Fetch status telemetry from a room server."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_room(contact)
+
+    async with radio_manager.radio_operation(
+        "room_status", pause_polling=True, suspend_auto_fetch=True
+    ) as mc:
+        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 room server")
+
+    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}/room/lpp-telemetry", response_model=RepeaterLppTelemetryResponse)
+async def room_lpp_telemetry(public_key: str) -> RepeaterLppTelemetryResponse:
+    """Fetch CayenneLPP telemetry from a room server."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_room(contact)
+
+    async with radio_manager.radio_operation(
+        "room_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 room server")
+
+    sensors = [
+        LppSensor(
+            channel=entry.get("channel", 0),
+            type_name=str(entry.get("type", "unknown")),
+            value=entry.get("value", 0),
+        )
+        for entry in telemetry
+    ]
+    return RepeaterLppTelemetryResponse(sensors=sensors)
+
+
+@router.post("/{public_key}/room/acl", response_model=RepeaterAclResponse)
+async def room_acl(public_key: str) -> RepeaterAclResponse:
+    """Fetch ACL entries from a room server."""
+    require_connected()
+    contact = await _resolve_contact_or_404(public_key)
+    _require_room(contact)
+
+    async with radio_manager.radio_operation(
+        "room_acl", pause_polling=True, suspend_auto_fetch=True
+    ) as mc:
+        await _ensure_on_radio(mc, contact)
+        acl_data = await mc.commands.req_acl_sync(contact.public_key, timeout=10, min_timeout=5)
+
+    acl_entries = []
+    if acl_data and isinstance(acl_data, list):
+        from app.repository import ContactRepository
+        from app.routers.repeaters import ACL_PERMISSION_NAMES
+
+        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)

app/routers/server_control.py

@@ -0,0 +1,317 @@
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from fastapi import HTTPException
+from meshcore import EventType
+
+from app.models import (
+    CONTACT_TYPE_REPEATER,
+    CONTACT_TYPE_ROOM,
+    CommandResponse,
+    Contact,
+    RepeaterLoginResponse,
+)
+from app.routers.contacts import _ensure_on_radio
+from app.services.radio_runtime import radio_runtime as radio_manager
+
+if TYPE_CHECKING:
+    from meshcore.events import Event
+
+logger = logging.getLogger(__name__)
+
+SERVER_LOGIN_RESPONSE_TIMEOUT_SECONDS = 5.0
+
+
+def _monotonic() -> float:
+    """Wrapper around time.monotonic() for testability."""
+    return time.monotonic()
+
+
+def get_server_contact_label(contact: Contact) -> str:
+    """Return a user-facing label for server-capable contacts."""
+    if contact.type == CONTACT_TYPE_REPEATER:
+        return "repeater"
+    if contact.type == CONTACT_TYPE_ROOM:
+        return "room server"
+    return "server"
+
+
+def require_server_capable_contact(
+    contact: Contact,
+    *,
+    allowed_types: tuple[int, ...] = (CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM),
+) -> None:
+    """Raise 400 if the contact does not support server control/login features."""
+    if contact.type not in allowed_types:
+        expected = ", ".join(str(value) for value in allowed_types)
+        raise HTTPException(
+            status_code=400,
+            detail=f"Contact is not a supported server contact (type={contact.type}, expected one of {expected})",
+        )
+
+
+def _login_rejected_message(label: str) -> str:
+    return (
+        f"The {label} replied but did not confirm this login. "
+        f"Existing access may still allow some {label} operations, but privileged actions may fail."
+    )
+
+
+def _login_send_failed_message(label: str) -> str:
+    return (
+        f"The login request could not be sent to the {label}. "
+        f"The control panel is still available, but authenticated actions may fail until a login succeeds."
+    )
+
+
+def _login_timeout_message(label: str) -> str:
+    return (
+        f"No login confirmation was heard from the {label}. "
+        "That can mean the password was wrong or the reply was missed in transit. "
+        "The control panel is still available; try logging in again if authenticated actions fail."
+    )
+
+
+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_contact_cli_response(
+    mc,
+    target_pubkey_prefix: str,
+    timeout: float = 20.0,
+) -> "Event | None":
+    """Fetch a CLI response from a specific contact via a validated get_msg() loop."""
+    deadline = _monotonic() + timeout
+
+    while _monotonic() < deadline:
+        try:
+            result = await mc.commands.get_msg(timeout=2.0)
+        except asyncio.TimeoutError:
+            continue
+        except Exception as exc:
+            logger.debug("get_msg() exception: %s", exc)
+            await asyncio.sleep(1.0)
+            continue
+
+        if result.type == EventType.NO_MORE_MSGS:
+            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
+            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:
+            logger.debug(
+                "Skipping channel message (channel_idx=%s) during CLI fetch",
+                result.payload.get("channel_idx"),
+            )
+            continue
+
+        logger.debug("Unexpected event type %s during CLI fetch, skipping", result.type)
+
+    logger.warning("No CLI response from contact %s within %.1fs", target_pubkey_prefix, timeout)
+    return None
+
+
+async def prepare_authenticated_contact_connection(
+    mc,
+    contact: Contact,
+    password: str,
+    *,
+    label: str | None = None,
+    response_timeout: float = SERVER_LOGIN_RESPONSE_TIMEOUT_SECONDS,
+) -> RepeaterLoginResponse:
+    """Prepare connection to a server-capable contact by adding it to the radio and logging in."""
+    pubkey_prefix = contact.public_key[:12].lower()
+    contact_label = label or get_server_contact_label(contact)
+    loop = asyncio.get_running_loop()
+    login_future = loop.create_future()
+
+    def _resolve_login(event_type: EventType, message: str | None = None) -> None:
+        if login_future.done():
+            return
+        login_future.set_result(
+            RepeaterLoginResponse(
+                status="ok" if event_type == EventType.LOGIN_SUCCESS else "error",
+                authenticated=event_type == EventType.LOGIN_SUCCESS,
+                message=message,
+            )
+        )
+
+    success_subscription = mc.subscribe(
+        EventType.LOGIN_SUCCESS,
+        lambda _event: _resolve_login(EventType.LOGIN_SUCCESS),
+        attribute_filters={"pubkey_prefix": pubkey_prefix},
+    )
+    failed_subscription = mc.subscribe(
+        EventType.LOGIN_FAILED,
+        lambda _event: _resolve_login(
+            EventType.LOGIN_FAILED,
+            _login_rejected_message(contact_label),
+        ),
+        attribute_filters={"pubkey_prefix": pubkey_prefix},
+    )
+
+    try:
+        logger.info("Adding %s %s to radio", contact_label, contact.public_key[:12])
+        await _ensure_on_radio(mc, contact)
+
+        logger.info("Sending login to %s %s", contact_label, contact.public_key[:12])
+        login_result = await mc.commands.send_login(contact.public_key, password)
+
+        if login_result.type == EventType.ERROR:
+            return RepeaterLoginResponse(
+                status="error",
+                authenticated=False,
+                message=f"{_login_send_failed_message(contact_label)} ({login_result.payload})",
+            )
+
+        try:
+            return await asyncio.wait_for(
+                login_future,
+                timeout=response_timeout,
+            )
+        except asyncio.TimeoutError:
+            logger.warning(
+                "No login response from %s %s within %.1fs",
+                contact_label,
+                contact.public_key[:12],
+                response_timeout,
+            )
+            return RepeaterLoginResponse(
+                status="timeout",
+                authenticated=False,
+                message=_login_timeout_message(contact_label),
+            )
+    except HTTPException as exc:
+        logger.warning(
+            "%s login setup failed for %s: %s",
+            contact_label.capitalize(),
+            contact.public_key[:12],
+            exc.detail,
+        )
+        return RepeaterLoginResponse(
+            status="error",
+            authenticated=False,
+            message=f"{_login_send_failed_message(contact_label)} ({exc.detail})",
+        )
+    finally:
+        success_subscription.unsubscribe()
+        failed_subscription.unsubscribe()
+
+
+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 server-capable contact and collect responses."""
+    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 index, (cmd, field) in enumerate(commands):
+            if index > 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_contact_cli_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
+
+
+async def send_contact_cli_command(
+    contact: Contact,
+    command: str,
+    *,
+    operation_name: str,
+) -> CommandResponse:
+    """Send a CLI command to a server-capable contact and return the text response."""
+    label = get_server_contact_label(contact)
+
+    async with radio_manager.radio_operation(
+        operation_name,
+        pause_polling=True,
+        suspend_auto_fetch=True,
+    ) as mc:
+        logger.info("Adding %s %s to radio", label, contact.public_key[:12])
+        await _ensure_on_radio(mc, contact)
+        await asyncio.sleep(1.0)
+
+        logger.info("Sending command to %s %s: %s", label, contact.public_key[:12], command)
+        send_result = await mc.commands.send_cmd(contact.public_key, command)
+
+        if send_result.type == EventType.ERROR:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to send command: {send_result.payload}"
+            )
+
+        response_event = await fetch_contact_cli_response(mc, contact.public_key[:12])
+
+        if response_event is None:
+            logger.warning(
+                "No response from %s %s for command: %s",
+                label,
+                contact.public_key[:12],
+                command,
+            )
+            return CommandResponse(
+                command=command,
+                response="(no response - command may have been processed)",
+            )
+
+        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: %s",
+            label,
+            contact.public_key[:12],
+            response_text,
+        )
+
+        return CommandResponse(
+            command=command,
+            response=response_text,
+            sender_timestamp=sender_timestamp,
+        )

app/services/contact_reconciliation.py

@@ -2,11 +2,29 @@
 
 import logging
 
-from app.repository import ContactNameHistoryRepository, MessageRepository
+from app.repository import ContactNameHistoryRepository, ContactRepository, MessageRepository
 
 logger = logging.getLogger(__name__)
 
 
+async def promote_prefix_contacts_for_contact(
+    *,
+    public_key: str,
+    contact_repository=ContactRepository,
+    log: logging.Logger | None = None,
+) -> list[str]:
+    """Promote prefix-only placeholder contacts once a full key is known."""
+    normalized_key = public_key.lower()
+    promoted = await contact_repository.promote_prefix_placeholders(normalized_key)
+    if promoted:
+        (log or logger).info(
+            "Promoted %d prefix contact placeholder(s) for %s",
+            len(promoted),
+            normalized_key[:12],
+        )
+    return promoted
+
+
 async def claim_prefix_messages_for_contact(
     *,
     public_key: str,

app/services/dm_ack_apply.py

@@ -0,0 +1,26 @@
+"""Shared direct-message ACK application logic."""
+
+from collections.abc import Callable
+from typing import Any
+
+from app.services import dm_ack_tracker
+from app.services.messages import increment_ack_and_broadcast
+
+BroadcastFn = Callable[..., Any]
+
+
+async def apply_dm_ack_code(ack_code: str, *, broadcast_fn: BroadcastFn) -> bool:
+    """Apply a DM ACK code using the shared pending/buffered state machine.
+
+    Returns True when the ACK matched a pending message, False when it was buffered.
+    """
+    dm_ack_tracker.cleanup_expired_acks()
+
+    message_id = dm_ack_tracker.pop_pending_ack(ack_code)
+    if message_id is None:
+        dm_ack_tracker.buffer_unmatched_ack(ack_code)
+        return False
+
+    dm_ack_tracker.clear_pending_acks_for_message(message_id)
+    await increment_ack_and_broadcast(message_id=message_id, broadcast_fn=broadcast_fn)
+    return True

app/services/dm_ack_tracker.py

@@ -6,12 +6,26 @@ import time
 logger = logging.getLogger(__name__)
 
 PendingAck = tuple[int, float, int]
+BUFFERED_ACK_TTL_SECONDS = 30.0
 
 _pending_acks: dict[str, PendingAck] = {}
+_buffered_acks: dict[str, float] = {}
 
 
-def track_pending_ack(expected_ack: str, message_id: int, timeout_ms: int) -> None:
-    """Track an expected ACK code for an outgoing direct message."""
+def track_pending_ack(expected_ack: str, message_id: int, timeout_ms: int) -> bool:
+    """Track an expected ACK code for an outgoing direct message.
+
+    Returns True when the ACK was already observed and buffered before registration.
+    """
+    buffered_at = _buffered_acks.pop(expected_ack, None)
+    if buffered_at is not None:
+        logger.debug(
+            "Matched buffered ACK %s immediately for message %d",
+            expected_ack,
+            message_id,
+        )
+        return True
+
     _pending_acks[expected_ack] = (message_id, time.time(), timeout_ms)
     logger.debug(
         "Tracking pending ACK %s for message %d (timeout %dms)",
@@ -19,6 +33,13 @@ def track_pending_ack(expected_ack: str, message_id: int, timeout_ms: int) -> No
         message_id,
         timeout_ms,
     )
+    return False
+
+
+def buffer_unmatched_ack(ack_code: str) -> None:
+    """Remember an ACK that arrived before its message registration."""
+    _buffered_acks[ack_code] = time.time()
+    logger.debug("Buffered unmatched ACK %s for late registration", ack_code)
 
 
 def cleanup_expired_acks() -> None:
@@ -33,6 +54,15 @@ def cleanup_expired_acks() -> None:
         del _pending_acks[code]
         logger.debug("Expired pending ACK %s", code)
 
+    expired_buffered_codes = [
+        code
+        for code, buffered_at in _buffered_acks.items()
+        if now - buffered_at > BUFFERED_ACK_TTL_SECONDS
+    ]
+    for code in expired_buffered_codes:
+        del _buffered_acks[code]
+        logger.debug("Expired buffered ACK %s", code)
+
 
 def pop_pending_ack(ack_code: str) -> int | None:
     """Claim the tracked message ID for an ACK code if present."""
@@ -41,3 +71,15 @@ def pop_pending_ack(ack_code: str) -> int | None:
         return None
     message_id, _, _ = pending
     return message_id
+
+
+def clear_pending_acks_for_message(message_id: int) -> None:
+    """Remove any still-pending ACK codes for a message once one ACK wins."""
+    sibling_codes = [
+        code
+        for code, (pending_message_id, _created_at, _timeout_ms) in _pending_acks.items()
+        if pending_message_id == message_id
+    ]
+    for code in sibling_codes:
+        del _pending_acks[code]
+        logger.debug("Cleared sibling pending ACK %s for message %d", code, message_id)

app/services/dm_ingest.py

@@ -0,0 +1,371 @@
+import asyncio
+import logging
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from app.models import CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM, Contact, ContactUpsert, Message
+from app.repository import (
+    AmbiguousPublicKeyPrefixError,
+    ContactRepository,
+    MessageRepository,
+    RawPacketRepository,
+)
+from app.services.contact_reconciliation import claim_prefix_messages_for_contact
+from app.services.messages import (
+    broadcast_message,
+    build_message_model,
+    build_message_paths,
+    format_contact_log_target,
+    handle_duplicate_message,
+    reconcile_duplicate_message,
+    truncate_for_log,
+)
+
+if TYPE_CHECKING:
+    from app.decoder import DecryptedDirectMessage
+
+logger = logging.getLogger(__name__)
+
+BroadcastFn = Callable[..., Any]
+_decrypted_dm_store_lock = asyncio.Lock()
+
+
+@dataclass(frozen=True)
+class FallbackDirectMessageContext:
+    conversation_key: str
+    contact: Contact | None
+    sender_name: str | None
+    sender_key: str | None
+    skip_storage: bool = False
+
+
+async def _prepare_resolved_contact(
+    contact: Contact,
+    *,
+    log: logging.Logger | None = None,
+) -> tuple[str, bool]:
+    conversation_key = contact.public_key.lower()
+    await claim_prefix_messages_for_contact(public_key=conversation_key, log=log or logger)
+
+    if contact.type == CONTACT_TYPE_REPEATER:
+        return conversation_key, True
+
+    return conversation_key, False
+
+
+async def resolve_fallback_direct_message_context(
+    *,
+    sender_public_key: str,
+    received_at: int,
+    broadcast_fn: BroadcastFn,
+    contact_repository=ContactRepository,
+    log: logging.Logger | None = None,
+) -> FallbackDirectMessageContext:
+    normalized_sender = sender_public_key.lower()
+
+    try:
+        contact = await contact_repository.get_by_key_or_prefix(normalized_sender)
+    except AmbiguousPublicKeyPrefixError:
+        (log or logger).warning(
+            "DM sender prefix '%s' is ambiguous; storing under prefix until full key is known",
+            sender_public_key,
+        )
+        contact = None
+
+    if contact is not None:
+        conversation_key, skip_storage = await _prepare_resolved_contact(contact, log=log)
+        return FallbackDirectMessageContext(
+            conversation_key=conversation_key,
+            contact=contact,
+            sender_name=contact.name,
+            sender_key=conversation_key,
+            skip_storage=skip_storage,
+        )
+
+    if normalized_sender:
+        placeholder_upsert = ContactUpsert(
+            public_key=normalized_sender,
+            type=0,
+            last_seen=received_at,
+            last_contacted=received_at,
+            first_seen=received_at,
+            on_radio=False,
+        )
+        await contact_repository.upsert(placeholder_upsert)
+        contact = await contact_repository.get_by_key(normalized_sender)
+        if contact is not None:
+            broadcast_fn("contact", contact.model_dump())
+
+    return FallbackDirectMessageContext(
+        conversation_key=normalized_sender,
+        contact=contact,
+        sender_name=contact.name if contact else None,
+        sender_key=normalized_sender or None,
+    )
+
+
+async def resolve_direct_message_sender_metadata(
+    *,
+    sender_public_key: str,
+    received_at: int,
+    broadcast_fn: BroadcastFn,
+    contact_repository=ContactRepository,
+    log: logging.Logger | None = None,
+) -> tuple[str | None, str | None]:
+    """Resolve sender attribution for direct-message variants such as room-server posts."""
+    normalized_sender = sender_public_key.lower()
+
+    try:
+        contact = await contact_repository.get_by_key_or_prefix(normalized_sender)
+    except AmbiguousPublicKeyPrefixError:
+        (log or logger).warning(
+            "Sender prefix '%s' is ambiguous; preserving prefix-only attribution",
+            sender_public_key,
+        )
+        contact = None
+
+    if contact is not None:
+        await claim_prefix_messages_for_contact(
+            public_key=contact.public_key.lower(), log=log or logger
+        )
+        return contact.name, contact.public_key.lower()
+
+    return None, normalized_sender or None
+
+
+async def _store_direct_message(
+    *,
+    packet_id: int | None,
+    conversation_key: str,
+    text: str,
+    sender_timestamp: int,
+    received_at: int,
+    path: str | None,
+    path_len: int | None,
+    outgoing: bool,
+    txt_type: int,
+    signature: str | None,
+    sender_name: str | None,
+    sender_key: str | None,
+    realtime: bool,
+    broadcast_fn: BroadcastFn,
+    update_last_contacted_key: str | None,
+    best_effort_content_dedup: bool,
+    linked_packet_dedup: bool,
+    message_repository=MessageRepository,
+    contact_repository=ContactRepository,
+    raw_packet_repository=RawPacketRepository,
+) -> Message | None:
+    async def store() -> Message | None:
+        if linked_packet_dedup and packet_id is not None:
+            linked_message_id = await raw_packet_repository.get_linked_message_id(packet_id)
+            if linked_message_id is not None:
+                existing_msg = await message_repository.get_by_id(linked_message_id)
+                if existing_msg is not None:
+                    await reconcile_duplicate_message(
+                        existing_msg=existing_msg,
+                        packet_id=packet_id,
+                        path=path,
+                        received_at=received_at,
+                        path_len=path_len,
+                        broadcast_fn=broadcast_fn,
+                    )
+                    return None
+
+        if best_effort_content_dedup:
+            existing_msg = await message_repository.get_by_content(
+                msg_type="PRIV",
+                conversation_key=conversation_key,
+                text=text,
+                sender_timestamp=sender_timestamp,
+                outgoing=outgoing,
+            )
+            if existing_msg is not None:
+                await reconcile_duplicate_message(
+                    existing_msg=existing_msg,
+                    packet_id=packet_id,
+                    path=path,
+                    received_at=received_at,
+                    path_len=path_len,
+                    broadcast_fn=broadcast_fn,
+                )
+                return None
+
+        msg_id = await message_repository.create(
+            msg_type="PRIV",
+            text=text,
+            conversation_key=conversation_key,
+            sender_timestamp=sender_timestamp,
+            received_at=received_at,
+            path=path,
+            path_len=path_len,
+            txt_type=txt_type,
+            signature=signature,
+            outgoing=outgoing,
+            sender_key=sender_key,
+            sender_name=sender_name,
+        )
+        if msg_id is None:
+            await handle_duplicate_message(
+                packet_id=packet_id,
+                msg_type="PRIV",
+                conversation_key=conversation_key,
+                text=text,
+                sender_timestamp=sender_timestamp,
+                outgoing=outgoing,
+                path=path,
+                received_at=received_at,
+                path_len=path_len,
+                broadcast_fn=broadcast_fn,
+            )
+            return None
+
+        if packet_id is not None:
+            await raw_packet_repository.mark_decrypted(packet_id, msg_id)
+
+        message = build_message_model(
+            message_id=msg_id,
+            msg_type="PRIV",
+            conversation_key=conversation_key,
+            text=text,
+            sender_timestamp=sender_timestamp,
+            received_at=received_at,
+            paths=build_message_paths(path, received_at, path_len),
+            txt_type=txt_type,
+            signature=signature,
+            sender_key=sender_key,
+            outgoing=outgoing,
+            sender_name=sender_name,
+        )
+        broadcast_message(message=message, broadcast_fn=broadcast_fn, realtime=realtime)
+
+        if update_last_contacted_key:
+            await contact_repository.update_last_contacted(update_last_contacted_key, received_at)
+
+        return message
+
+    if linked_packet_dedup:
+        async with _decrypted_dm_store_lock:
+            return await store()
+    return await store()
+
+
+async def ingest_decrypted_direct_message(
+    *,
+    packet_id: int,
+    decrypted: "DecryptedDirectMessage",
+    their_public_key: str,
+    received_at: int | None = None,
+    path: str | None = None,
+    path_len: int | None = None,
+    outgoing: bool = False,
+    realtime: bool = True,
+    broadcast_fn: BroadcastFn,
+    contact_repository=ContactRepository,
+) -> Message | None:
+    conversation_key = their_public_key.lower()
+
+    if not outgoing and decrypted.txt_type == 1:
+        logger.debug(
+            "Skipping CLI response from %s (txt_type=1): %s",
+            conversation_key[:12],
+            (decrypted.message or "")[:50],
+        )
+        return None
+
+    contact = await contact_repository.get_by_key(conversation_key)
+    sender_name: str | None = None
+    sender_key: str | None = conversation_key if not outgoing else None
+    signature: str | None = None
+    if contact is not None:
+        conversation_key, skip_storage = await _prepare_resolved_contact(contact, log=logger)
+        if skip_storage:
+            logger.debug(
+                "Skipping message from repeater %s (CLI responses not stored): %s",
+                conversation_key[:12],
+                (decrypted.message or "")[:50],
+            )
+            return None
+        if not outgoing:
+            if contact.type == CONTACT_TYPE_ROOM and decrypted.signed_sender_prefix:
+                sender_name, sender_key = await resolve_direct_message_sender_metadata(
+                    sender_public_key=decrypted.signed_sender_prefix,
+                    received_at=received_at or int(time.time()),
+                    broadcast_fn=broadcast_fn,
+                    contact_repository=contact_repository,
+                    log=logger,
+                )
+                signature = decrypted.signed_sender_prefix
+            else:
+                sender_name = contact.name
+
+    received = received_at or int(time.time())
+    message = await _store_direct_message(
+        packet_id=packet_id,
+        conversation_key=conversation_key,
+        text=decrypted.message,
+        sender_timestamp=decrypted.timestamp,
+        received_at=received,
+        path=path,
+        path_len=path_len,
+        outgoing=outgoing,
+        txt_type=decrypted.txt_type,
+        signature=signature,
+        sender_name=sender_name,
+        sender_key=sender_key,
+        realtime=realtime,
+        broadcast_fn=broadcast_fn,
+        update_last_contacted_key=conversation_key,
+        best_effort_content_dedup=outgoing,
+        linked_packet_dedup=True,
+    )
+    if message is None:
+        return None
+
+    logger.info(
+        'Stored direct message "%s" for %r (msg ID %d in contact ID %s, outgoing=%s)',
+        truncate_for_log(decrypted.message),
+        format_contact_log_target(contact.name if contact else None, conversation_key),
+        message.id,
+        conversation_key,
+        outgoing,
+    )
+    return message
+
+
+async def ingest_fallback_direct_message(
+    *,
+    conversation_key: str,
+    text: str,
+    sender_timestamp: int,
+    received_at: int,
+    path: str | None,
+    path_len: int | None,
+    txt_type: int,
+    signature: str | None,
+    sender_name: str | None,
+    sender_key: str | None,
+    broadcast_fn: BroadcastFn,
+    update_last_contacted_key: str | None = None,
+) -> Message | None:
+    return await _store_direct_message(
+        packet_id=None,
+        conversation_key=conversation_key,
+        text=text,
+        sender_timestamp=sender_timestamp,
+        received_at=received_at,
+        path=path,
+        path_len=path_len,
+        outgoing=False,
+        txt_type=txt_type,
+        signature=signature,
+        sender_name=sender_name,
+        sender_key=sender_key,
+        realtime=True,
+        broadcast_fn=broadcast_fn,
+        update_last_contacted_key=update_last_contacted_key,
+        best_effort_content_dedup=True,
+        linked_packet_dedup=False,
+    )

app/services/message_send.py

@@ -1,5 +1,6 @@
 """Shared send/resend orchestration for outgoing messages."""
 
+import asyncio
 import logging
 from collections.abc import Callable
 from typing import Any
@@ -7,29 +8,116 @@ from typing import Any
 from fastapi import HTTPException
 from meshcore import EventType
 
+from app.models import ResendChannelMessageResponse
 from app.region_scope import normalize_region_scope
 from app.repository import AppSettingsRepository, ContactRepository, MessageRepository
+from app.services import dm_ack_tracker
 from app.services.messages import (
-    build_message_model,
+    broadcast_message,
+    build_stored_outgoing_channel_message,
     create_outgoing_channel_message,
     create_outgoing_direct_message,
+    increment_ack_and_broadcast,
 )
 
 logger = logging.getLogger(__name__)
 
+NO_RADIO_RESPONSE_AFTER_SEND_DETAIL = (
+    "Send command was issued to the radio, but no response was heard back. "
+    "The message may or may not have sent successfully."
+)
+
 BroadcastFn = Callable[..., Any]
-TrackAckFn = Callable[[str, int, int], None]
+TrackAckFn = Callable[[str, int, int], bool]
 NowFn = Callable[[], float]
+OutgoingReservationKey = tuple[str, str, str]
+RetryTaskScheduler = Callable[[Any], Any]
+
+_pending_outgoing_timestamp_reservations: dict[OutgoingReservationKey, set[int]] = {}
+_outgoing_timestamp_reservations_lock = asyncio.Lock()
+
+DM_SEND_MAX_ATTEMPTS = 3
+DEFAULT_DM_ACK_TIMEOUT_MS = 10000
+DM_RETRY_WAIT_MARGIN = 1.2
+
+
+async def allocate_outgoing_sender_timestamp(
+    *,
+    message_repository,
+    msg_type: str,
+    conversation_key: str,
+    text: str,
+    requested_timestamp: int,
+) -> int:
+    """Pick a sender timestamp that will not collide with an existing stored message."""
+    reservation_key = (msg_type, conversation_key, text)
+    candidate = requested_timestamp
+    while True:
+        async with _outgoing_timestamp_reservations_lock:
+            reserved = _pending_outgoing_timestamp_reservations.get(reservation_key, set())
+            is_reserved = candidate in reserved
+
+        if is_reserved:
+            candidate += 1
+            continue
+
+        existing = await message_repository.get_by_content(
+            msg_type=msg_type,
+            conversation_key=conversation_key,
+            text=text,
+            sender_timestamp=candidate,
+        )
+        if existing is not None:
+            candidate += 1
+            continue
+
+        async with _outgoing_timestamp_reservations_lock:
+            reserved = _pending_outgoing_timestamp_reservations.setdefault(reservation_key, set())
+            if candidate in reserved:
+                candidate += 1
+                continue
+            reserved.add(candidate)
+            break
+
+    if candidate != requested_timestamp:
+        logger.info(
+            "Bumped outgoing %s timestamp for %s from %d to %d to avoid same-content collision",
+            msg_type,
+            conversation_key[:12],
+            requested_timestamp,
+            candidate,
+        )
+
+    return candidate
+
+
+async def release_outgoing_sender_timestamp(
+    *,
+    msg_type: str,
+    conversation_key: str,
+    text: str,
+    sender_timestamp: int,
+) -> None:
+    reservation_key = (msg_type, conversation_key, text)
+    async with _outgoing_timestamp_reservations_lock:
+        reserved = _pending_outgoing_timestamp_reservations.get(reservation_key)
+        if not reserved:
+            return
+        reserved.discard(sender_timestamp)
+        if not reserved:
+            _pending_outgoing_timestamp_reservations.pop(reservation_key, None)
 
 
 async def send_channel_message_with_effective_scope(
     *,
     mc,
     channel,
+    channel_key: str,
     key_bytes: bytes,
     text: str,
     timestamp_bytes: bytes,
     action_label: str,
+    radio_manager,
     temp_radio_slot: int,
     error_broadcast_fn: BroadcastFn,
     app_settings_repository=AppSettingsRepository,
@@ -64,28 +152,71 @@ async def send_channel_message_with_effective_scope(
             )
 
     try:
-        set_result = await mc.commands.set_channel(
-            channel_idx=temp_radio_slot,
-            channel_name=channel.name,
-            channel_secret=key_bytes,
+        channel_slot, needs_configure, evicted_channel_key = radio_manager.plan_channel_send_slot(
+            channel_key,
+            preferred_slot=temp_radio_slot,
         )
-        if set_result.type == EventType.ERROR:
-            logger.warning(
-                "Failed to set channel on radio slot %d before %s: %s",
-                temp_radio_slot,
+        if needs_configure:
+            logger.debug(
+                "Loading channel %s into radio slot %d before %s%s",
+                channel.name,
+                channel_slot,
                 action_label,
-                set_result.payload,
+                (
+                    f" (evicting cached {evicted_channel_key[:8]})"
+                    if evicted_channel_key is not None
+                    else ""
+                ),
             )
-            raise HTTPException(
-                status_code=500,
-                detail=f"Failed to configure channel on radio before {action_label}",
+            try:
+                set_result = await mc.commands.set_channel(
+                    channel_idx=channel_slot,
+                    channel_name=channel.name,
+                    channel_secret=key_bytes,
+                )
+            except Exception:
+                if evicted_channel_key is not None:
+                    radio_manager.invalidate_cached_channel_slot(evicted_channel_key)
+                raise
+            if set_result.type == EventType.ERROR:
+                if evicted_channel_key is not None:
+                    radio_manager.invalidate_cached_channel_slot(evicted_channel_key)
+                logger.warning(
+                    "Failed to set channel on radio slot %d before %s: %s",
+                    channel_slot,
+                    action_label,
+                    set_result.payload,
+                )
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Failed to configure channel on radio before {action_label}",
+                )
+            radio_manager.note_channel_slot_loaded(channel_key, channel_slot)
+        else:
+            logger.debug(
+                "Reusing cached radio slot %d for channel %s before %s",
+                channel_slot,
+                channel.name,
+                action_label,
             )
 
-        return await mc.commands.send_chan_msg(
-            chan=temp_radio_slot,
+        send_result = await mc.commands.send_chan_msg(
+            chan=channel_slot,
             msg=text,
             timestamp=timestamp_bytes,
         )
+        if send_result is None:
+            logger.warning(
+                "No response from radio after %s for channel %s; send outcome is unknown",
+                action_label,
+                channel.name,
+            )
+            raise HTTPException(status_code=504, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
+        if send_result.type == EventType.ERROR:
+            radio_manager.invalidate_cached_channel_slot(channel_key)
+        else:
+            radio_manager.note_channel_slot_used(channel_key)
+        return send_result
     finally:
         if override_scope and override_scope != baseline_scope:
             try:
@@ -124,6 +255,183 @@ async def send_channel_message_with_effective_scope(
                 )
 
 
+def _extract_expected_ack_code(result: Any) -> str | None:
+    if result is None or result.type == EventType.ERROR:
+        return None
+    payload = result.payload or {}
+    expected_ack = payload.get("expected_ack")
+    if not expected_ack:
+        return None
+    return expected_ack.hex() if isinstance(expected_ack, bytes) else expected_ack
+
+
+def _get_ack_tracking_timeout_ms(result: Any) -> int:
+    if result is None or result.type == EventType.ERROR:
+        return DEFAULT_DM_ACK_TIMEOUT_MS
+    payload = result.payload or {}
+    suggested_timeout = payload.get("suggested_timeout")
+    if suggested_timeout is None:
+        return DEFAULT_DM_ACK_TIMEOUT_MS
+    try:
+        return max(1, int(suggested_timeout))
+    except (TypeError, ValueError):
+        return DEFAULT_DM_ACK_TIMEOUT_MS
+
+
+def _get_direct_message_retry_timeout_ms(result: Any) -> int:
+    """Return the ACK window to wait before retrying a DM.
+
+    The MeshCore firmware already computes and returns `suggested_timeout` in
+    `PACKET_MSG_SENT`, derived from estimated packet airtime and route mode.
+    We use that firmware-supplied window directly so retries do not fire before
+    the radio's own ACK timeout expires.
+
+    Sources:
+    - https://github.com/meshcore-dev/MeshCore/blob/main/src/helpers/BaseChatMesh.cpp
+    - https://github.com/meshcore-dev/MeshCore/blob/main/examples/companion_radio/MyMesh.cpp
+    - https://github.com/meshcore-dev/MeshCore/blob/main/docs/companion_protocol.md
+    """
+    return _get_ack_tracking_timeout_ms(result)
+
+
+async def _apply_direct_message_ack_tracking(
+    *,
+    result: Any,
+    message_id: int,
+    track_pending_ack_fn: TrackAckFn,
+    broadcast_fn: BroadcastFn,
+) -> int:
+    ack_code = _extract_expected_ack_code(result)
+    if not ack_code:
+        return 0
+
+    timeout_ms = _get_ack_tracking_timeout_ms(result)
+    matched_immediately = track_pending_ack_fn(ack_code, message_id, timeout_ms) is True
+    logger.debug("Tracking ACK %s for message %d", ack_code, message_id)
+    if matched_immediately:
+        dm_ack_tracker.clear_pending_acks_for_message(message_id)
+        return await increment_ack_and_broadcast(
+            message_id=message_id,
+            broadcast_fn=broadcast_fn,
+        )
+    return 0
+
+
+async def _is_message_acked(*, message_id: int, message_repository) -> bool:
+    acked_count, _paths = await message_repository.get_ack_and_paths(message_id)
+    return acked_count > 0
+
+
+async def _retry_direct_message_until_acked(
+    *,
+    contact,
+    text: str,
+    message_id: int,
+    sender_timestamp: int,
+    radio_manager,
+    track_pending_ack_fn: TrackAckFn,
+    broadcast_fn: BroadcastFn,
+    wait_timeout_ms: int,
+    sleep_fn,
+    message_repository,
+) -> None:
+    next_wait_timeout_ms = wait_timeout_ms
+    for attempt in range(1, DM_SEND_MAX_ATTEMPTS):
+        await sleep_fn((next_wait_timeout_ms / 1000) * DM_RETRY_WAIT_MARGIN)
+        if await _is_message_acked(message_id=message_id, message_repository=message_repository):
+            return
+
+        try:
+            async with radio_manager.radio_operation("retry_direct_message") as mc:
+                contact_data = contact.to_radio_dict()
+                add_result = await mc.commands.add_contact(contact_data)
+                if add_result.type == EventType.ERROR:
+                    logger.warning(
+                        "Failed to reload contact %s on radio before DM retry: %s",
+                        contact.public_key[:12],
+                        add_result.payload,
+                    )
+                cached_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+                if not cached_contact:
+                    cached_contact = contact_data
+
+                if attempt == DM_SEND_MAX_ATTEMPTS - 1:
+                    reset_result = await mc.commands.reset_path(contact.public_key)
+                    if reset_result is None:
+                        logger.warning(
+                            "No response from radio for reset_path to %s before final DM retry",
+                            contact.public_key[:12],
+                        )
+                    elif reset_result.type == EventType.ERROR:
+                        logger.warning(
+                            "Failed to reset path before final DM retry to %s: %s",
+                            contact.public_key[:12],
+                            reset_result.payload,
+                        )
+                    refreshed_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+                    if refreshed_contact:
+                        cached_contact = refreshed_contact
+
+                result = await mc.commands.send_msg(
+                    dst=cached_contact,
+                    msg=text,
+                    timestamp=sender_timestamp,
+                    attempt=attempt,
+                )
+        except Exception:
+            logger.exception(
+                "Background DM retry attempt %d/%d failed for %s",
+                attempt + 1,
+                DM_SEND_MAX_ATTEMPTS,
+                contact.public_key[:12],
+            )
+            continue
+
+        if result is None:
+            logger.warning(
+                "No response from radio after background DM retry attempt %d/%d to %s",
+                attempt + 1,
+                DM_SEND_MAX_ATTEMPTS,
+                contact.public_key[:12],
+            )
+            continue
+
+        if result.type == EventType.ERROR:
+            logger.warning(
+                "Background DM retry attempt %d/%d failed for %s: %s",
+                attempt + 1,
+                DM_SEND_MAX_ATTEMPTS,
+                contact.public_key[:12],
+                result.payload,
+            )
+            continue
+
+        if await _is_message_acked(message_id=message_id, message_repository=message_repository):
+            return
+
+        ack_code = _extract_expected_ack_code(result)
+        if not ack_code:
+            logger.warning(
+                "Background DM retry attempt %d/%d for %s returned no expected_ack; "
+                "stopping retries to avoid duplicate sends",
+                attempt + 1,
+                DM_SEND_MAX_ATTEMPTS,
+                contact.public_key[:12],
+            )
+            return
+
+        next_wait_timeout_ms = _get_direct_message_retry_timeout_ms(result)
+
+        ack_count = await _apply_direct_message_ack_tracking(
+            result=result,
+            message_id=message_id,
+            track_pending_ack_fn=track_pending_ack_fn,
+            broadcast_fn=broadcast_fn,
+        )
+        if ack_count > 0:
+            return
+
+
 async def send_direct_message_to_contact(
     *,
     contact,
@@ -132,63 +440,113 @@ async def send_direct_message_to_contact(
     broadcast_fn: BroadcastFn,
     track_pending_ack_fn: TrackAckFn,
     now_fn: NowFn,
+    retry_task_scheduler: RetryTaskScheduler | None = None,
+    retry_sleep_fn=None,
     message_repository=MessageRepository,
     contact_repository=ContactRepository,
 ) -> Any:
     """Send a direct message and persist/broadcast the outgoing row."""
+    if retry_task_scheduler is None:
+        retry_task_scheduler = asyncio.create_task
+    if retry_sleep_fn is None:
+        retry_sleep_fn = asyncio.sleep
+
     contact_data = contact.to_radio_dict()
-    contact_ensured_on_radio = False
-    async with radio_manager.radio_operation("send_direct_message") as mc:
-        logger.debug("Ensuring contact %s is on radio before sending", contact.public_key[:12])
-        add_result = await mc.commands.add_contact(contact_data)
-        if add_result.type == EventType.ERROR:
-            logger.warning("Failed to add contact to radio: %s", add_result.payload)
-        else:
-            contact_ensured_on_radio = True
+    sent_at: int | None = None
+    sender_timestamp: int | None = None
+    message = None
+    result = None
+    try:
+        async with radio_manager.radio_operation("send_direct_message") as mc:
+            logger.debug("Ensuring contact %s is on radio before sending", contact.public_key[:12])
+            add_result = await mc.commands.add_contact(contact_data)
+            if add_result.type == EventType.ERROR:
+                logger.warning("Failed to add contact to radio: %s", add_result.payload)
 
-        cached_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
-        if not cached_contact:
-            cached_contact = contact_data
-        else:
-            contact_ensured_on_radio = True
+            cached_contact = mc.get_contact_by_key_prefix(contact.public_key[:12])
+            if not cached_contact:
+                cached_contact = contact_data
 
-        logger.info("Sending direct message to %s", contact.public_key[:12])
-        now = int(now_fn())
-        result = await mc.commands.send_msg(
-            dst=cached_contact,
-            msg=text,
-            timestamp=now,
+            logger.info("Sending direct message to %s", contact.public_key[:12])
+            sent_at = int(now_fn())
+            sender_timestamp = await allocate_outgoing_sender_timestamp(
+                message_repository=message_repository,
+                msg_type="PRIV",
+                conversation_key=contact.public_key.lower(),
+                text=text,
+                requested_timestamp=sent_at,
+            )
+            result = await mc.commands.send_msg(
+                dst=cached_contact,
+                msg=text,
+                timestamp=sender_timestamp,
+            )
+
+        if result is None:
+            logger.warning(
+                "No response from radio after direct send to %s; send outcome is unknown",
+                contact.public_key[:12],
+            )
+            raise HTTPException(status_code=504, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
+
+        if result.type == EventType.ERROR:
+            raise HTTPException(status_code=500, detail=f"Failed to send message: {result.payload}")
+
+        message = await create_outgoing_direct_message(
+            conversation_key=contact.public_key.lower(),
+            text=text,
+            sender_timestamp=sender_timestamp,
+            received_at=sent_at,
+            broadcast_fn=broadcast_fn,
+            message_repository=message_repository,
         )
+        if message is None:
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to store outgoing message - unexpected duplicate",
+            )
+    finally:
+        if sender_timestamp is not None:
+            await release_outgoing_sender_timestamp(
+                msg_type="PRIV",
+                conversation_key=contact.public_key.lower(),
+                text=text,
+                sender_timestamp=sender_timestamp,
+            )
 
-    if result.type == EventType.ERROR:
-        raise HTTPException(status_code=500, detail=f"Failed to send message: {result.payload}")
+    if sent_at is None or sender_timestamp is None or message is None or result is None:
+        raise HTTPException(status_code=500, detail="Failed to store outgoing message")
 
-    if contact_ensured_on_radio and not contact.on_radio:
-        await contact_repository.set_on_radio(contact.public_key.lower(), True)
+    await contact_repository.update_last_contacted(contact.public_key.lower(), sent_at)
 
-    message = await create_outgoing_direct_message(
-        conversation_key=contact.public_key.lower(),
-        text=text,
-        sender_timestamp=now,
-        received_at=now,
+    ack_code = _extract_expected_ack_code(result)
+    retry_timeout_ms = _get_direct_message_retry_timeout_ms(result)
+    ack_count = await _apply_direct_message_ack_tracking(
+        result=result,
+        message_id=message.id,
+        track_pending_ack_fn=track_pending_ack_fn,
         broadcast_fn=broadcast_fn,
-        message_repository=message_repository,
     )
-    if message is None:
-        raise HTTPException(
-            status_code=500,
-            detail="Failed to store outgoing message - unexpected duplicate",
+    if ack_count > 0:
+        message.acked = ack_count
+        return message
+
+    if DM_SEND_MAX_ATTEMPTS > 1 and ack_code:
+        retry_task_scheduler(
+            _retry_direct_message_until_acked(
+                contact=contact,
+                text=text,
+                message_id=message.id,
+                sender_timestamp=sender_timestamp,
+                radio_manager=radio_manager,
+                track_pending_ack_fn=track_pending_ack_fn,
+                broadcast_fn=broadcast_fn,
+                wait_timeout_ms=retry_timeout_ms,
+                sleep_fn=retry_sleep_fn,
+                message_repository=message_repository,
+            )
         )
 
-    await contact_repository.update_last_contacted(contact.public_key.lower(), now)
-
-    expected_ack = result.payload.get("expected_ack")
-    suggested_timeout: int = result.payload.get("suggested_timeout", 10000)
-    if expected_ack:
-        ack_code = expected_ack.hex() if isinstance(expected_ack, bytes) else expected_ack
-        track_pending_ack_fn(ack_code, message.id, suggested_timeout)
-        logger.debug("Tracking ACK %s for message %d", ack_code, message.id)
-
     return message
 
 
@@ -206,71 +564,101 @@ async def send_channel_message_to_channel(
     message_repository=MessageRepository,
 ) -> Any:
     """Send a channel message and persist/broadcast the outgoing row."""
-    message_id: int | None = None
-    now: int | None = None
+    sent_at: int | None = None
+    sender_timestamp: int | None = None
     radio_name = ""
     our_public_key: str | None = None
     text_with_sender = text
+    outgoing_message = 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}: {text}" if radio_name else text
-        logger.info("Sending channel message to %s: %s", channel.name, text[:50])
+    try:
+        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}: {text}" if radio_name else text
+            logger.info("Sending channel message to %s: %s", channel.name, text[:50])
 
-        now = int(now_fn())
-        timestamp_bytes = now.to_bytes(4, "little")
-
-        result = await send_channel_message_with_effective_scope(
-            mc=mc,
-            channel=channel,
-            key_bytes=key_bytes,
-            text=text,
-            timestamp_bytes=timestamp_bytes,
-            action_label="sending message",
-            temp_radio_slot=temp_radio_slot,
-            error_broadcast_fn=error_broadcast_fn,
-        )
-
-        if result.type == EventType.ERROR:
-            raise HTTPException(status_code=500, detail=f"Failed to send message: {result.payload}")
-
-        outgoing_message = await create_outgoing_channel_message(
-            conversation_key=channel_key_upper,
-            text=text_with_sender,
-            sender_timestamp=now,
-            received_at=now,
-            sender_name=radio_name or None,
-            sender_key=our_public_key,
-            channel_name=channel.name,
-            broadcast_fn=broadcast_fn,
-            message_repository=message_repository,
-        )
-        if outgoing_message is None:
-            raise HTTPException(
-                status_code=500,
-                detail="Failed to store outgoing message - unexpected duplicate",
+            sent_at = int(now_fn())
+            sender_timestamp = await allocate_outgoing_sender_timestamp(
+                message_repository=message_repository,
+                msg_type="CHAN",
+                conversation_key=channel_key_upper,
+                text=text_with_sender,
+                requested_timestamp=sent_at,
             )
-        message_id = outgoing_message.id
+            timestamp_bytes = sender_timestamp.to_bytes(4, "little")
+            outgoing_message = await create_outgoing_channel_message(
+                conversation_key=channel_key_upper,
+                text=text_with_sender,
+                sender_timestamp=sender_timestamp,
+                received_at=sent_at,
+                sender_name=radio_name or None,
+                sender_key=our_public_key,
+                channel_name=channel.name,
+                broadcast_fn=broadcast_fn,
+                broadcast=False,
+                message_repository=message_repository,
+            )
+            if outgoing_message is None:
+                raise HTTPException(
+                    status_code=500,
+                    detail="Failed to store outgoing message - unexpected duplicate",
+                )
 
-    if message_id is None or now is None:
+            result = await send_channel_message_with_effective_scope(
+                mc=mc,
+                channel=channel,
+                channel_key=channel_key_upper,
+                key_bytes=key_bytes,
+                text=text,
+                timestamp_bytes=timestamp_bytes,
+                action_label="sending message",
+                radio_manager=radio_manager,
+                temp_radio_slot=temp_radio_slot,
+                error_broadcast_fn=error_broadcast_fn,
+            )
+
+            if result is None:
+                logger.warning(
+                    "No response from radio after channel send to %s; send outcome is unknown",
+                    channel.name,
+                )
+                raise HTTPException(status_code=504, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
+
+            if result.type == EventType.ERROR:
+                raise HTTPException(
+                    status_code=500, detail=f"Failed to send message: {result.payload}"
+                )
+    except Exception:
+        if outgoing_message is not None:
+            await message_repository.delete_by_id(outgoing_message.id)
+            outgoing_message = None
+        raise
+    finally:
+        if sender_timestamp is not None:
+            await release_outgoing_sender_timestamp(
+                msg_type="CHAN",
+                conversation_key=channel_key_upper,
+                text=text_with_sender,
+                sender_timestamp=sender_timestamp,
+            )
+
+    if sent_at is None or sender_timestamp is None or outgoing_message is None:
         raise HTTPException(status_code=500, detail="Failed to store outgoing message")
 
-    acked_count, paths = await message_repository.get_ack_and_paths(message_id)
-    return build_message_model(
-        message_id=message_id,
-        msg_type="CHAN",
+    outgoing_message = await build_stored_outgoing_channel_message(
+        message_id=outgoing_message.id,
         conversation_key=channel_key_upper,
         text=text_with_sender,
-        sender_timestamp=now,
-        received_at=now,
-        paths=paths,
-        outgoing=True,
-        acked=acked_count,
+        sender_timestamp=sender_timestamp,
+        received_at=sent_at,
         sender_name=radio_name or None,
         sender_key=our_public_key,
         channel_name=channel.name,
+        message_repository=message_repository,
     )
+    broadcast_message(message=outgoing_message, broadcast_fn=broadcast_fn)
+    return outgoing_message
 
 
 async def resend_channel_message_record(
@@ -284,7 +672,7 @@ async def resend_channel_message_record(
     now_fn: NowFn,
     temp_radio_slot: int,
     message_repository=MessageRepository,
-) -> dict[str, Any]:
+) -> ResendChannelMessageResponse:
     """Resend a stored outgoing channel message."""
     try:
         key_bytes = bytes.fromhex(message.conversation_key)
@@ -294,59 +682,103 @@ async def resend_channel_message_record(
             detail=f"Invalid channel key format: {message.conversation_key}",
         ) from None
 
-    now: int | None = None
-    if new_timestamp:
-        now = int(now_fn())
-        timestamp_bytes = now.to_bytes(4, "little")
-    else:
-        timestamp_bytes = message.sender_timestamp.to_bytes(4, "little")
+    sent_at: int | None = None
+    sender_timestamp = message.sender_timestamp
+    timestamp_bytes = message.sender_timestamp.to_bytes(4, "little")
 
     resend_public_key: str | None = None
     radio_name = ""
+    new_message = None
+    stored_text = message.text
 
-    async with radio_manager.radio_operation("resend_channel_message") as mc:
-        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 = message.text
-        if radio_name and text_to_send.startswith(f"{radio_name}: "):
-            text_to_send = text_to_send[len(f"{radio_name}: ") :]
+    try:
+        async with radio_manager.radio_operation("resend_channel_message") as mc:
+            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 = message.text
+            if radio_name and text_to_send.startswith(f"{radio_name}: "):
+                text_to_send = text_to_send[len(f"{radio_name}: ") :]
+            if new_timestamp:
+                sent_at = int(now_fn())
+                sender_timestamp = await allocate_outgoing_sender_timestamp(
+                    message_repository=message_repository,
+                    msg_type="CHAN",
+                    conversation_key=message.conversation_key,
+                    text=stored_text,
+                    requested_timestamp=sent_at,
+                )
+                timestamp_bytes = sender_timestamp.to_bytes(4, "little")
+                new_message = await create_outgoing_channel_message(
+                    conversation_key=message.conversation_key,
+                    text=message.text,
+                    sender_timestamp=sender_timestamp,
+                    received_at=sent_at,
+                    sender_name=radio_name or None,
+                    sender_key=resend_public_key,
+                    channel_name=channel.name,
+                    broadcast_fn=broadcast_fn,
+                    broadcast=False,
+                    message_repository=message_repository,
+                )
+                if new_message is None:
+                    raise HTTPException(
+                        status_code=500,
+                        detail="Failed to store resent message - unexpected duplicate",
+                    )
 
-        result = await send_channel_message_with_effective_scope(
-            mc=mc,
-            channel=channel,
-            key_bytes=key_bytes,
-            text=text_to_send,
-            timestamp_bytes=timestamp_bytes,
-            action_label="resending message",
-            temp_radio_slot=temp_radio_slot,
-            error_broadcast_fn=error_broadcast_fn,
-        )
-        if result.type == EventType.ERROR:
-            raise HTTPException(
-                status_code=500,
-                detail=f"Failed to resend message: {result.payload}",
+            result = await send_channel_message_with_effective_scope(
+                mc=mc,
+                channel=channel,
+                channel_key=message.conversation_key,
+                key_bytes=key_bytes,
+                text=text_to_send,
+                timestamp_bytes=timestamp_bytes,
+                action_label="resending message",
+                radio_manager=radio_manager,
+                temp_radio_slot=temp_radio_slot,
+                error_broadcast_fn=error_broadcast_fn,
+            )
+            if result is None:
+                logger.warning(
+                    "No response from radio after channel resend to %s; send outcome is unknown",
+                    channel.name,
+                )
+                raise HTTPException(status_code=504, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
+            if result.type == EventType.ERROR:
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Failed to resend message: {result.payload}",
+                )
+    except Exception:
+        if new_message is not None:
+            await message_repository.delete_by_id(new_message.id)
+            new_message = None
+        raise
+    finally:
+        if new_timestamp and sent_at is not None:
+            await release_outgoing_sender_timestamp(
+                msg_type="CHAN",
+                conversation_key=message.conversation_key,
+                text=stored_text,
+                sender_timestamp=sender_timestamp,
             )
 
     if new_timestamp:
-        if now is None:
+        if sent_at is None or new_message is None:
             raise HTTPException(status_code=500, detail="Failed to assign resend timestamp")
-        new_message = await create_outgoing_channel_message(
+
+        new_message = await build_stored_outgoing_channel_message(
+            message_id=new_message.id,
             conversation_key=message.conversation_key,
             text=message.text,
-            sender_timestamp=now,
-            received_at=now,
+            sender_timestamp=sender_timestamp,
+            received_at=sent_at,
             sender_name=radio_name or None,
             sender_key=resend_public_key,
             channel_name=channel.name,
-            broadcast_fn=broadcast_fn,
             message_repository=message_repository,
         )
-        if new_message is None:
-            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_message(message=new_message, broadcast_fn=broadcast_fn)
 
         logger.info(
             "Resent channel message %d as new message %d to %s",
@@ -354,7 +786,11 @@ async def resend_channel_message_record(
             new_message.id,
             channel.name,
         )
-        return {"status": "ok", "message_id": new_message.id}
+        return ResendChannelMessageResponse(
+            status="ok",
+            message_id=new_message.id,
+            message=new_message,
+        )
 
     logger.info("Resent channel message %d to %s", message.id, channel.name)
-    return {"status": "ok", "message_id": message.id}
+    return ResendChannelMessageResponse(status="ok", message_id=message.id)

app/services/messages.py

@@ -3,7 +3,7 @@ import time
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
-from app.models import CONTACT_TYPE_REPEATER, Message, MessagePath
+from app.models import Message, MessagePath
 from app.repository import ContactRepository, MessageRepository, RawPacketRepository
 
 if TYPE_CHECKING:
@@ -15,7 +15,7 @@ BroadcastFn = Callable[..., Any]
 LOG_MESSAGE_PREVIEW_LEN = 32
 
 
-def _truncate_for_log(text: str, max_chars: int = LOG_MESSAGE_PREVIEW_LEN) -> str:
+def truncate_for_log(text: str, max_chars: int = LOG_MESSAGE_PREVIEW_LEN) -> str:
     """Return a compact single-line message preview for log output."""
     normalized = " ".join(text.split())
     if len(normalized) <= max_chars:
@@ -28,7 +28,7 @@ def _format_channel_log_target(channel_name: str | None, channel_key: str) -> st
     return channel_name or channel_key
 
 
-def _format_contact_log_target(contact_name: str | None, public_key: str) -> str:
+def format_contact_log_target(contact_name: str | None, public_key: str) -> str:
     """Return a human-friendly DM target label for logs."""
     return contact_name or public_key[:12]
 
@@ -96,6 +96,36 @@ def broadcast_message(
         broadcast_fn("message", payload, realtime=realtime)
 
 
+async def build_stored_outgoing_channel_message(
+    *,
+    message_id: int,
+    conversation_key: str,
+    text: str,
+    sender_timestamp: int,
+    received_at: int,
+    sender_name: str | None,
+    sender_key: str | None,
+    channel_name: str | None,
+    message_repository=MessageRepository,
+) -> Message:
+    """Build the current payload for a stored outgoing channel message."""
+    acked_count, paths = await message_repository.get_ack_and_paths(message_id)
+    return build_message_model(
+        message_id=message_id,
+        msg_type="CHAN",
+        conversation_key=conversation_key,
+        text=text,
+        sender_timestamp=sender_timestamp,
+        received_at=received_at,
+        paths=paths,
+        outgoing=True,
+        acked=acked_count,
+        sender_name=sender_name,
+        sender_key=sender_key,
+        channel_name=channel_name,
+    )
+
+
 def broadcast_message_acked(
     *,
     message_id: int,
@@ -125,38 +155,19 @@ async def increment_ack_and_broadcast(
     return ack_count
 
 
-async def handle_duplicate_message(
+async def reconcile_duplicate_message(
     *,
-    packet_id: int,
-    msg_type: str,
-    conversation_key: str,
-    text: str,
-    sender_timestamp: int,
+    existing_msg: Message,
+    packet_id: int | None,
     path: str | None,
     received_at: int,
-    path_len: int | None = None,
+    path_len: int | None,
     broadcast_fn: BroadcastFn,
 ) -> None:
-    """Handle a duplicate message by updating paths/acks on the existing record."""
-    existing_msg = await MessageRepository.get_by_content(
-        msg_type=msg_type,
-        conversation_key=conversation_key,
-        text=text,
-        sender_timestamp=sender_timestamp,
-    )
-    if not existing_msg:
-        label = "message" if msg_type == "CHAN" else "DM"
-        logger.warning(
-            "Duplicate %s for %s but couldn't find existing",
-            label,
-            conversation_key[:12],
-        )
-        return
-
     logger.debug(
         "Duplicate %s for %s (msg_id=%d, outgoing=%s) - adding path",
-        msg_type,
-        conversation_key[:12],
+        existing_msg.type,
+        existing_msg.conversation_key[:12],
         existing_msg.id,
         existing_msg.outgoing,
     )
@@ -166,7 +177,7 @@ async def handle_duplicate_message(
     else:
         paths = existing_msg.paths or []
 
-    if existing_msg.outgoing:
+    if existing_msg.outgoing and existing_msg.type == "CHAN":
         ack_count = await MessageRepository.increment_ack_count(existing_msg.id)
     else:
         ack_count = existing_msg.acked
@@ -179,7 +190,48 @@ async def handle_duplicate_message(
             broadcast_fn=broadcast_fn,
         )
 
-    await RawPacketRepository.mark_decrypted(packet_id, existing_msg.id)
+    if packet_id is not None:
+        await RawPacketRepository.mark_decrypted(packet_id, existing_msg.id)
+
+
+async def handle_duplicate_message(
+    *,
+    packet_id: int | None,
+    msg_type: str,
+    conversation_key: str,
+    text: str,
+    sender_timestamp: int,
+    outgoing: bool | None = None,
+    path: str | None,
+    received_at: int,
+    path_len: int | None = None,
+    broadcast_fn: BroadcastFn,
+) -> None:
+    """Handle a duplicate message by updating paths/acks on the existing record."""
+    existing_msg = await MessageRepository.get_by_content(
+        msg_type=msg_type,
+        conversation_key=conversation_key,
+        text=text,
+        sender_timestamp=sender_timestamp,
+        outgoing=outgoing,
+    )
+    if not existing_msg:
+        label = "message" if msg_type == "CHAN" else "DM"
+        logger.warning(
+            "Duplicate %s for %s but couldn't find existing",
+            label,
+            conversation_key[:12],
+        )
+        return
+
+    await reconcile_duplicate_message(
+        existing_msg=existing_msg,
+        packet_id=packet_id,
+        path=path,
+        received_at=received_at,
+        path_len=path_len,
+        broadcast_fn=broadcast_fn,
+    )
 
 
 async def create_message_from_decrypted(
@@ -226,6 +278,7 @@ async def create_message_from_decrypted(
             conversation_key=channel_key_normalized,
             text=text,
             sender_timestamp=timestamp,
+            outgoing=None,
             path=path,
             received_at=received,
             path_len=path_len,
@@ -235,7 +288,7 @@ async def create_message_from_decrypted(
 
     logger.info(
         'Stored channel message "%s" for %r (msg ID %d in chan ID %s)',
-        _truncate_for_log(text),
+        truncate_for_log(text),
         _format_channel_log_target(channel_name, channel_key_normalized),
         msg_id,
         channel_key_normalized,
@@ -276,121 +329,85 @@ async def create_dm_message_from_decrypted(
     broadcast_fn: BroadcastFn,
 ) -> int | None:
     """Store and broadcast a decrypted direct message."""
-    contact = await ContactRepository.get_by_key(their_public_key)
-    if contact and contact.type == CONTACT_TYPE_REPEATER:
-        logger.debug(
-            "Skipping message from repeater %s (CLI responses not stored): %s",
-            their_public_key[:12],
-            (decrypted.message or "")[:50],
-        )
-        return None
+    from app.services.dm_ingest import ingest_decrypted_direct_message
 
-    received = received_at or int(time.time())
-    conversation_key = their_public_key.lower()
-    sender_name = contact.name if contact and not outgoing else None
-
-    msg_id = await MessageRepository.create(
-        msg_type="PRIV",
-        text=decrypted.message,
-        conversation_key=conversation_key,
-        sender_timestamp=decrypted.timestamp,
-        received_at=received,
+    message = await ingest_decrypted_direct_message(
+        packet_id=packet_id,
+        decrypted=decrypted,
+        their_public_key=their_public_key,
+        received_at=received_at,
         path=path,
         path_len=path_len,
         outgoing=outgoing,
-        sender_key=conversation_key if not outgoing else None,
-        sender_name=sender_name,
-    )
-
-    if msg_id is None:
-        await handle_duplicate_message(
-            packet_id=packet_id,
-            msg_type="PRIV",
-            conversation_key=conversation_key,
-            text=decrypted.message,
-            sender_timestamp=decrypted.timestamp,
-            path=path,
-            received_at=received,
-            path_len=path_len,
-            broadcast_fn=broadcast_fn,
-        )
-        return None
-
-    logger.info(
-        'Stored direct message "%s" for %r (msg ID %d in contact ID %s, outgoing=%s)',
-        _truncate_for_log(decrypted.message),
-        _format_contact_log_target(contact.name if contact else None, conversation_key),
-        msg_id,
-        conversation_key,
-        outgoing,
-    )
-    await RawPacketRepository.mark_decrypted(packet_id, msg_id)
-
-    broadcast_message(
-        message=build_message_model(
-            message_id=msg_id,
-            msg_type="PRIV",
-            conversation_key=conversation_key,
-            text=decrypted.message,
-            sender_timestamp=decrypted.timestamp,
-            received_at=received,
-            paths=build_message_paths(path, received, path_len),
-            outgoing=outgoing,
-            sender_name=sender_name,
-            sender_key=conversation_key if not outgoing else None,
-        ),
-        broadcast_fn=broadcast_fn,
         realtime=realtime,
+        broadcast_fn=broadcast_fn,
     )
-
-    await ContactRepository.update_last_contacted(conversation_key, received)
-    return msg_id
+    return message.id if message is not None else None
 
 
-async def create_fallback_direct_message(
+async def create_fallback_channel_message(
     *,
     conversation_key: str,
-    text: str,
+    message_text: str,
     sender_timestamp: int,
     received_at: int,
     path: str | None,
     path_len: int | None,
     txt_type: int,
-    signature: str | None,
     sender_name: str | None,
-    sender_key: str | None,
+    channel_name: str | None,
     broadcast_fn: BroadcastFn,
     message_repository=MessageRepository,
 ) -> Message | None:
-    """Store and broadcast a CONTACT_MSG_RECV fallback direct message."""
+    """Store and broadcast a CHANNEL_MSG_RECV fallback channel message."""
+    conversation_key_normalized = conversation_key.upper()
+    text = f"{sender_name}: {message_text}" if sender_name else message_text
+
+    resolved_sender_key: str | None = None
+    if sender_name:
+        candidates = await ContactRepository.get_by_name(sender_name)
+        if len(candidates) == 1:
+            resolved_sender_key = candidates[0].public_key
+
     msg_id = await message_repository.create(
-        msg_type="PRIV",
+        msg_type="CHAN",
         text=text,
-        conversation_key=conversation_key,
+        conversation_key=conversation_key_normalized,
         sender_timestamp=sender_timestamp,
         received_at=received_at,
         path=path,
         path_len=path_len,
         txt_type=txt_type,
-        signature=signature,
-        sender_key=sender_key,
         sender_name=sender_name,
+        sender_key=resolved_sender_key,
     )
     if msg_id is None:
+        await handle_duplicate_message(
+            packet_id=None,
+            msg_type="CHAN",
+            conversation_key=conversation_key_normalized,
+            text=text,
+            sender_timestamp=sender_timestamp,
+            outgoing=None,
+            path=path,
+            received_at=received_at,
+            path_len=path_len,
+            broadcast_fn=broadcast_fn,
+        )
         return None
 
     message = build_message_model(
         message_id=msg_id,
-        msg_type="PRIV",
-        conversation_key=conversation_key,
+        msg_type="CHAN",
+        conversation_key=conversation_key_normalized,
         text=text,
         sender_timestamp=sender_timestamp,
         received_at=received_at,
         paths=build_message_paths(path, received_at, path_len),
         txt_type=txt_type,
-        signature=signature,
-        sender_key=sender_key,
         sender_name=sender_name,
+        sender_key=resolved_sender_key,
+        channel_name=channel_name,
     )
     broadcast_message(message=message, broadcast_fn=broadcast_fn)
     return message
@@ -441,6 +458,7 @@ async def create_outgoing_channel_message(
     sender_key: str | None,
     channel_name: str | None,
     broadcast_fn: BroadcastFn,
+    broadcast: bool = True,
     message_repository=MessageRepository,
 ) -> Message | None:
     """Store and broadcast an outgoing channel message."""
@@ -457,18 +475,17 @@ async def create_outgoing_channel_message(
     if msg_id is None:
         return None
 
-    message = build_message_model(
+    message = await build_stored_outgoing_channel_message(
         message_id=msg_id,
-        msg_type="CHAN",
         conversation_key=conversation_key,
         text=text,
         sender_timestamp=sender_timestamp,
         received_at=received_at,
-        outgoing=True,
-        acked=0,
         sender_name=sender_name,
         sender_key=sender_key,
         channel_name=channel_name,
+        message_repository=message_repository,
     )
-    broadcast_message(message=message, broadcast_fn=broadcast_fn)
+    if broadcast:
+        broadcast_message(message=message, broadcast_fn=broadcast_fn)
     return message

app/services/radio_commands.py

@@ -32,6 +32,25 @@ async def apply_radio_config_update(
     sync_radio_time_fn: Callable[[Any], Awaitable[Any]],
 ) -> None:
     """Apply a validated radio-config update to the connected radio."""
+    if update.advert_location_source is not None:
+        advert_loc_policy = 0 if update.advert_location_source == "off" else 1
+        logger.info(
+            "Setting advert location policy to %s",
+            update.advert_location_source,
+        )
+        result = await mc.commands.set_advert_loc_policy(advert_loc_policy)
+        if result is not None and result.type == EventType.ERROR:
+            raise RadioCommandRejectedError(
+                f"Failed to set advert location policy: {result.payload}"
+            )
+
+    if update.multi_acks_enabled is not None:
+        multi_acks = 1 if update.multi_acks_enabled else 0
+        logger.info("Setting multi ACKs to %d", multi_acks)
+        result = await mc.commands.set_multi_acks(multi_acks)
+        if result is not None and result.type == EventType.ERROR:
+            raise RadioCommandRejectedError(f"Failed to set multi ACKs: {result.payload}")
+
     if update.name is not None:
         logger.info("Setting radio name to %s", update.name)
         await mc.commands.set_name(update.name)

app/services/radio_lifecycle.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from datetime import datetime, timezone
 
 logger = logging.getLogger(__name__)
 
@@ -7,6 +8,21 @@ POST_CONNECT_SETUP_TIMEOUT_SECONDS = 300
 POST_CONNECT_SETUP_MAX_ATTEMPTS = 2
 
 
+def _clean_device_string(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    cleaned = value.strip()
+    return cleaned or None
+
+
+def _decode_fixed_string(raw: bytes, start: int, length: int) -> str | None:
+    if len(raw) < start:
+        return None
+    return _clean_device_string(
+        raw[start : start + length].decode("utf-8", "ignore").replace("\0", "")
+    )
+
+
 async def run_post_connect_setup(radio_manager) -> None:
     """Run shared radio initialization after a transport connection succeeds."""
     from app.event_handlers import register_event_handlers
@@ -32,16 +48,19 @@ async def run_post_connect_setup(radio_manager) -> None:
             return
         radio_manager._setup_in_progress = True
         radio_manager._setup_complete = False
-        mc = radio_manager.meshcore
         try:
-            # Register event handlers (no radio I/O, just callback setup)
-            register_event_handlers(mc)
-
             # 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 radio_manager._acquire_operation_lock("post_connect_setup", blocking=True)
             try:
+                mc = radio_manager.meshcore
+                if not mc:
+                    return
+
+                # Register event handlers against the locked, current transport.
+                register_event_handlers(mc)
+
                 await export_and_store_private_key(mc)
 
                 # Sync radio clock with system time
@@ -75,18 +94,66 @@ async def run_post_connect_setup(radio_manager) -> None:
                     return await _original_handle_rx(data)
 
                 reader.handle_rx = _capture_handle_rx
+                radio_manager.device_info_loaded = False
+                radio_manager.max_contacts = None
+                radio_manager.device_model = None
+                radio_manager.firmware_build = None
+                radio_manager.firmware_version = None
+                radio_manager.max_channels = 40
                 radio_manager.path_hash_mode = 0
                 radio_manager.path_hash_mode_supported = False
                 try:
                     device_query = await mc.commands.send_device_query()
-                    if device_query and "path_hash_mode" in device_query.payload:
-                        radio_manager.path_hash_mode = device_query.payload["path_hash_mode"]
+                    payload = (
+                        device_query.payload
+                        if device_query is not None and isinstance(device_query.payload, dict)
+                        else {}
+                    )
+
+                    payload_max_contacts = payload.get("max_contacts")
+                    if isinstance(payload_max_contacts, int):
+                        radio_manager.max_contacts = max(1, payload_max_contacts)
+
+                    payload_max_channels = payload.get("max_channels")
+                    if isinstance(payload_max_channels, int):
+                        radio_manager.max_channels = max(1, payload_max_channels)
+
+                    radio_manager.device_model = _clean_device_string(payload.get("model"))
+                    radio_manager.firmware_build = _clean_device_string(payload.get("fw_build"))
+                    radio_manager.firmware_version = _clean_device_string(payload.get("ver"))
+
+                    fw_ver = payload.get("fw ver")
+                    payload_reports_device_info = isinstance(fw_ver, int) and fw_ver >= 3
+                    if payload_reports_device_info:
+                        radio_manager.device_info_loaded = True
+
+                    if "path_hash_mode" in payload and isinstance(payload["path_hash_mode"], int):
+                        radio_manager.path_hash_mode = payload["path_hash_mode"]
                         radio_manager.path_hash_mode_supported = True
-                    elif _captured_frame:
-                        # Raw-frame fallback: byte 1 = fw_ver, byte 81 = path_hash_mode
+
+                    if _captured_frame:
+                        # Raw-frame fallback / completion:
+                        # byte 1 = fw_ver, byte 2 = max_contacts/2, byte 3 = max_channels,
+                        # bytes 8:20 = fw_build, 20:60 = model, 60:80 = ver, byte 81 = path_hash_mode
                         raw = _captured_frame[-1]
                         fw_ver = raw[1] if len(raw) > 1 else 0
-                        if fw_ver >= 10 and len(raw) >= 82:
+                        if fw_ver >= 3:
+                            radio_manager.device_info_loaded = True
+                            if radio_manager.max_contacts is None and len(raw) >= 3:
+                                radio_manager.max_contacts = max(1, raw[2] * 2)
+                            if len(raw) >= 4 and not isinstance(payload_max_channels, int):
+                                radio_manager.max_channels = max(1, raw[3])
+                            if radio_manager.firmware_build is None:
+                                radio_manager.firmware_build = _decode_fixed_string(raw, 8, 12)
+                            if radio_manager.device_model is None:
+                                radio_manager.device_model = _decode_fixed_string(raw, 20, 40)
+                            if radio_manager.firmware_version is None:
+                                radio_manager.firmware_version = _decode_fixed_string(raw, 60, 20)
+                        if (
+                            not radio_manager.path_hash_mode_supported
+                            and fw_ver >= 10
+                            and len(raw) >= 82
+                        ):
                             radio_manager.path_hash_mode = raw[81]
                             radio_manager.path_hash_mode_supported = True
                             logger.warning(
@@ -103,8 +170,37 @@ async def run_post_connect_setup(radio_manager) -> None:
                         logger.info("Path hash mode: %d (supported)", radio_manager.path_hash_mode)
                     else:
                         logger.debug("Firmware does not report path_hash_mode")
+                    if radio_manager.device_info_loaded:
+                        logger.info(
+                            "Radio device info: model=%s build=%s version=%s max_contacts=%s max_channels=%d",
+                            radio_manager.device_model or "unknown",
+                            radio_manager.firmware_build or "unknown",
+                            radio_manager.firmware_version or "unknown",
+                            radio_manager.max_contacts
+                            if radio_manager.max_contacts is not None
+                            else "unknown",
+                            radio_manager.max_channels,
+                        )
+                        try:
+                            time_result = await mc.commands.get_time()
+                            radio_time = (
+                                time_result.payload.get("time")
+                                if time_result is not None and time_result.payload
+                                else None
+                            )
+                            if isinstance(radio_time, int):
+                                logger.info(
+                                    "Radio clock at connect: epoch=%d utc=%s",
+                                    radio_time,
+                                    datetime.fromtimestamp(radio_time, timezone.utc).strftime(
+                                        "%Y-%m-%d %H:%M:%S UTC"
+                                    ),
+                                )
+                        except Exception as exc:
+                            logger.debug("Failed to query radio clock after device info: %s", exc)
+                    logger.info("Max channel slots: %d", radio_manager.max_channels)
                 except Exception as exc:
-                    logger.debug("Failed to query path_hash_mode: %s", exc)
+                    logger.debug("Failed to query device info capabilities: %s", exc)
                 finally:
                     reader.handle_rx = _original_handle_rx
 
@@ -125,6 +221,7 @@ async def run_post_connect_setup(radio_manager) -> None:
                 drained = await drain_pending_messages(mc)
                 if drained > 0:
                     logger.info("Drained %d pending message(s)", drained)
+                radio_manager.clear_pending_message_channel_slots()
 
                 await mc.start_auto_message_fetching()
                 logger.info("Auto message fetching started")

app/version_info.py

@@ -0,0 +1,149 @@
+"""Unified application version/build metadata resolution.
+
+Resolution order:
+- version: installed package metadata, ``APP_VERSION`` env, ``build_info.json``, ``pyproject.toml``
+- commit: local git, ``COMMIT_HASH``/``VITE_COMMIT_HASH`` env, ``build_info.json``
+
+This keeps backend surfaces, release bundles, and Docker builds aligned.
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+import json
+import os
+import subprocess
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import tomllib
+
+RELEASE_BUILD_INFO_FILENAME = "build_info.json"
+PROJECT_NAME = "remoteterm-meshcore"
+
+
+@dataclass(frozen=True)
+class AppBuildInfo:
+    version: str
+    version_source: str
+    commit_hash: str | None
+    commit_source: str | None
+
+
+def repo_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _read_build_info(root: Path) -> dict[str, Any] | None:
+    build_info_path = root / RELEASE_BUILD_INFO_FILENAME
+    try:
+        data = json.loads(build_info_path.read_text())
+    except Exception:
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _package_metadata_version() -> str | None:
+    try:
+        return importlib.metadata.version(PROJECT_NAME)
+    except Exception:
+        return None
+
+
+def _env_version() -> str | None:
+    value = os.getenv("APP_VERSION")
+    return value.strip() if value and value.strip() else None
+
+
+def _build_info_version(build_info: dict[str, Any] | None) -> str | None:
+    if not build_info:
+        return None
+    value = build_info.get("version")
+    return value.strip() if isinstance(value, str) and value.strip() else None
+
+
+def _pyproject_version(root: Path) -> str | None:
+    try:
+        pyproject = tomllib.loads((root / "pyproject.toml").read_text())
+        project = pyproject.get("project")
+        if isinstance(project, dict):
+            version = project.get("version")
+            if isinstance(version, str) and version.strip():
+                return version.strip()
+    except Exception:
+        return None
+    return None
+
+
+def _git_output(root: Path, *args: str) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=root,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except Exception:
+        return None
+    output = result.stdout.strip()
+    return output or None
+
+
+def _env_commit_hash() -> str | None:
+    for name in ("COMMIT_HASH", "VITE_COMMIT_HASH"):
+        value = os.getenv(name)
+        if value and value.strip():
+            return value.strip()[:8]
+    return None
+
+
+def _build_info_commit_hash(build_info: dict[str, Any] | None) -> str | None:
+    if not build_info:
+        return None
+    value = build_info.get("commit_hash")
+    return value.strip()[:8] if isinstance(value, str) and value.strip() else None
+
+
+@lru_cache(maxsize=1)
+def get_app_build_info() -> AppBuildInfo:
+    root = repo_root()
+    build_info = _read_build_info(root)
+
+    version = _package_metadata_version()
+    version_source = "package_metadata"
+    if version is None:
+        version = _env_version()
+        version_source = "env"
+    if version is None:
+        version = _build_info_version(build_info)
+        version_source = "build_info"
+    if version is None:
+        version = _pyproject_version(root)
+        version_source = "pyproject"
+    if version is None:
+        version = "0.0.0"
+        version_source = "fallback"
+
+    commit_hash = _git_output(root, "rev-parse", "--short", "HEAD")
+    commit_source: str | None = "git" if commit_hash else None
+    if commit_hash is None:
+        commit_hash = _env_commit_hash()
+        commit_source = "env" if commit_hash else None
+    if commit_hash is None:
+        commit_hash = _build_info_commit_hash(build_info)
+        commit_source = "build_info" if commit_hash else None
+
+    return AppBuildInfo(
+        version=version,
+        version_source=version_source,
+        commit_hash=commit_hash,
+        commit_source=commit_source,
+    )
+
+
+def git_output(*args: str) -> str | None:
+    """Shared git helper for debug surfaces that still need live repo state."""
+    return _git_output(repo_root(), *args)

frontend/AGENTS.md

@@ -35,7 +35,6 @@ frontend/src/
 ├── types.ts                # Shared TS contracts
 ├── useWebSocket.ts         # WS lifecycle + event dispatch
 ├── wsEvents.ts             # Typed WS event parsing / discriminated union
-├── 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
@@ -51,7 +50,7 @@ frontend/src/
 │   ├── useRealtimeAppState.ts      # WebSocket event application and reconnect recovery
 │   ├── useAppShell.ts              # App-shell view state (settings/sidebar/modals/cracker)
 │   ├── useRepeaterDashboard.ts      # Repeater dashboard state (login, panes, console, retries)
-│   ├── useRadioControl.ts          # Radio health/config state, reconnection
+│   ├── useRadioControl.ts          # Radio health/config state, reconnection, mesh discovery sweeps
 │   ├── useAppSettings.ts           # Settings, favorites, preferences migration
 │   ├── useConversationRouter.ts    # URL hash → active conversation routing
 │   └── useContactsAndChannels.ts   # Contact/channel loading, creation, deletion
@@ -74,6 +73,7 @@ frontend/src/
 │   ├── pubkey.ts               # getContactDisplayName (12-char prefix fallback)
 │   ├── contactAvatar.ts        # Avatar color derivation from public key
 │   ├── rawPacketIdentity.ts    # observation_id vs id dedup helpers
+│   ├── regionScope.ts          # Regional flood-scope label/normalization helpers
 │   ├── visualizerUtils.ts      # 3D visualizer node types, colors, particles
 │   ├── visualizerSettings.ts   # LocalStorage persistence for visualizer options
 │   ├── a11y.ts                 # Keyboard accessibility helper
@@ -105,10 +105,11 @@ frontend/src/
 │   ├── RepeaterDashboard.tsx   # Layout shell — delegates to repeater/ panes
 │   ├── RepeaterLogin.tsx       # Repeater login form (password + guest)
 │   ├── ChannelInfoPane.tsx     # Channel detail sheet (stats, top senders)
+│   ├── DirectTraceIcon.tsx     # Shared direct-trace glyph used in header/dashboard
 │   ├── 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
+│   │   ├── SettingsRadioSection.tsx      # Name, keys, advert interval, max contacts, radio preset, freq/bw/sf/cr, txPower, lat/lon, reboot, mesh discovery
 │   │   ├── 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
@@ -120,15 +121,15 @@ frontend/src/
 │   │   ├── RepeaterTelemetryPane.tsx    # Battery, airtime, packet counts
 │   │   ├── RepeaterNeighborsPane.tsx    # Neighbor table + lazy mini-map
 │   │   ├── RepeaterAclPane.tsx          # Permission table
-│   │   ├── RepeaterRadioSettingsPane.tsx # Radio settings + advert intervals
+│   │   ├── RepeaterNodeInfoPane.tsx      # Repeater name, coords, clock drift
+│   │   ├── RepeaterRadioSettingsPane.tsx # Radio config + 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__)
+│   └── d3-force-3d.d.ts       # Type declarations for d3-force-3d
 └── test/
     ├── setup.ts
     ├── fixtures/websocket_events.json
@@ -136,9 +137,13 @@ frontend/src/
     ├── appFavorites.test.tsx
     ├── appStartupHash.test.tsx
     ├── contactAvatar.test.ts
+    ├── contactInfoPane.test.tsx
     ├── integration.test.ts
+    ├── mapView.test.tsx
     ├── messageCache.test.ts
+    ├── messageList.test.tsx
     ├── messageParser.test.ts
+    ├── rawPacketList.test.tsx
     ├── pathUtils.test.ts
     ├── prefetch.test.ts
     ├── radioPresets.test.ts
@@ -152,12 +157,14 @@ frontend/src/
     ├── newMessageModal.test.tsx
     ├── settingsModal.test.tsx
     ├── sidebar.test.tsx
+    ├── statusBar.test.tsx
     ├── unreadCounts.test.ts
     ├── urlHash.test.ts
     ├── appSearchJump.test.tsx
     ├── channelInfoKeyVisibility.test.tsx
     ├── chatHeaderKeyVisibility.test.tsx
     ├── searchView.test.tsx
+    ├── useConversationActions.test.ts
     ├── useConversationMessages.test.ts
     ├── useConversationMessages.race.test.ts
     ├── useConversationNavigation.test.ts
@@ -191,9 +198,9 @@ High-level state is delegated to hooks:
 - `useContactsAndChannels`: contact/channel lists, creation, deletion
 - `useConversationRouter`: URL hash → active conversation routing
 - `useConversationNavigation`: search target, conversation selection reset, and info-pane state
-- `useConversationActions`: send/resend/trace/block handlers and channel override updates
-- `useConversationMessages`: conversation switch loading, cache restore, jump-target loading, pagination, dedup/update helpers, and pending ACK buffering
-- `useUnreadCounts`: unread counters, mention tracking, recent-sort timestamps
+- `useConversationActions`: send/resend/trace/path-discovery/block handlers and channel override updates
+- `useConversationMessages`: conversation switch loading, embedded conversation-scoped cache, jump-target loading, pagination, dedup/update helpers, reconnect reconciliation, and pending ACK buffering
+- `useUnreadCounts`: unread counters, mention tracking, recent-sort timestamps, and server `last_read_ats` boundaries
 - `useRealtimeAppState`: typed WS event application, reconnect recovery, cache/unread coordination
 - `useRepeaterDashboard`: repeater dashboard state (login, pane data/retries, console, actions)
 
@@ -224,6 +231,8 @@ High-level state is delegated to hooks:
 - 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`.
+- Conversation-scoped message caching now lives inside `useConversationMessages.ts` rather than a standalone `messageCache.ts` module. If you touch message timeline restore/dedup/reconnect behavior, start there.
+- `contact_resolved` is a real-time identity migration event, not just a contact-list update. Changes in that area need to consider active conversation state, cached messages, unread state keys, and reconnect reconciliation together.
 
 ### Visualizer behavior
 
@@ -236,18 +245,23 @@ High-level state is delegated to hooks:
   - `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).
+- The dedicated raw packet feed view now includes a frontend-only stats drawer. It tracks a separate lightweight per-observation session history for charts/rankings, so its windows are not limited by the visible packet list cap. Coverage messaging should stay honest when detailed in-memory stats history has been trimmed or the selected window predates the current browser session.
 
 ### Radio settings behavior
 
 - `SettingsRadioSection.tsx` surfaces `path_hash_mode` only when `config.path_hash_mode_supported` is true.
+- `SettingsRadioSection.tsx` also exposes `multi_acks_enabled` as a checkbox for the radio's extra direct-ACK transmission behavior.
+- Advert-location control is intentionally only `off` vs `include node location`. Companion-radio firmware does not reliably distinguish saved coordinates from live GPS in this path.
+- The advert action is mode-aware: the radio settings section exposes both flood and zero-hop manual advert buttons, both routed through the same `onAdvertise(mode)` seam.
+- Mesh discovery in the radio section is limited to node classes that currently answer discovery control-data requests in firmware: repeaters and sensors.
 - Frontend `path_len` fields are hop counts, not raw byte lengths; multibyte path rendering must use the accompanying metadata before splitting hop identifiers.
 
 ## WebSocket (`useWebSocket.ts`)
 
 - Auto reconnect (3s) with cleanup guard on unmount.
 - Heartbeat ping every 30s.
-- Incoming JSON is parsed through `wsEvents.ts`, which returns a typed discriminated union for known events and a centralized `unknown` fallback.
-- Event handlers: `health`, `message`, `contact`, `raw_packet`, `message_acked`, `contact_deleted`, `channel_deleted`, `error`, `success`, `pong` (ignored).
+- Incoming JSON is parsed through `wsEvents.ts`, which validates the top-level envelope and known event type strings, then casts payloads at the handler boundary. It does not schema-validate per-event payload shapes.
+- Event handlers: `health`, `message`, `contact`, `contact_resolved`, `channel`, `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`)
@@ -307,6 +321,8 @@ LocalStorage migration helpers for favorites; canonical favorites are server-sid
 - `flood_scope`
 - `blocked_keys`, `blocked_names`
 
+The backend still carries `sidebar_sort_order` for compatibility and old preference migration, but the current sidebar UI stores sort order per section (`Channels`, `Contacts`, `Repeaters`) in frontend localStorage rather than treating it as one global server-backed setting.
+
 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`.
 
 `HealthStatus` includes `fanout_statuses: Record<string, FanoutStatusEntry>` mapping config IDs to `{name, type, status}`. Also includes `bots_disabled: boolean`.
@@ -315,9 +331,11 @@ Note: MQTT, bot, and community MQTT settings were migrated to the `fanout_config
 
 `RawPacket.decrypted_info` includes `channel_key` and `contact_key` for MQTT topic routing.
 
+`UnreadCounts` includes `counts`, `mentions`, `last_message_times`, and `last_read_ats`. The unread-boundary/jump-to-unread behavior uses the server-provided `last_read_ats` map keyed by `getStateKey(...)`.
+
 ## 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`:
+Clicking a contact's avatar in `ChatHeader` or `MessageList` opens a `ContactInfoPane` sheet (right drawer) showing comprehensive contact details fetched from `GET /api/contacts/analytics` using either `?public_key=...` or `?name=...`:
 
 - Header: avatar, name, public key, type badge, on-radio badge
 - Info grid: last seen, first heard, last contacted, distance, hops
@@ -326,9 +344,10 @@ Clicking a contact's avatar in `ChatHeader` or `MessageList` opens a `ContactInf
 - 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)
+- Route details from the canonical backend surface (`effective_route`, `effective_route_source`, `direct_route`, `route_override`)
 - Advert observation rate
 - Nearest repeaters (resolved from first-hop path prefixes)
-- Recent advert paths
+- Recent advert paths (informational only; not part of DM route selection)
 
 State: `useConversationNavigation` controls open/close via `infoPaneContactKey`. Live contact data from WebSocket updates is preferred over the initial detail snapshot.
 
@@ -350,7 +369,7 @@ For repeater contacts (`type=2`), `ConversationPane.tsx` renders `RepeaterDashbo
 
 **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).
+**Dashboard panes** (after login): Telemetry, Node Info, 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. `Neighbors` depends on the smaller `node-info` fetch for repeater GPS, not the heavier radio-settings batch. "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`.
 
@@ -396,6 +415,10 @@ npm run test:run
 npm run build
 ```
 
+`npm run packaged-build` is release-only. It writes the fallback `frontend/prebuilt`
+directory used by the downloadable prebuilt release zip; normal development and
+validation should stick to `npm run build`.
+
 When touching cross-layer contracts, also run backend tests from repo root:
 
 ```bash
@@ -404,6 +427,10 @@ PYTHONPATH=. uv run pytest tests/ -v
 
 ## Errata & Known Non-Issues
 
+### Contacts use mention styling for unread DMs
+
+This is intentional. In the sidebar, unread direct messages for actual contact conversations are treated as mention-equivalent for badge styling. That means both the Contacts section header and contact unread badges themselves use the highlighted mention-style colors for unread DMs, including when those contacts appear in Favorites. Repeaters do not inherit this rule, and channel badges still use mention styling only for real `@[name]` mentions.
+
 ### 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.

frontend/package.json

@@ -1,11 +1,12 @@
 {
   "name": "remoteterm-meshcore-frontend",
   "private": true,
-  "version": "3.1.1",
+  "version": "3.5.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "packaged-build": "vite build --outDir prebuilt",
     "preview": "vite preview",
     "test": "vitest",
     "test:run": "vitest run",

frontend/src/App.tsx

@@ -14,11 +14,57 @@ import {
   useConversationNavigation,
   useRealtimeAppState,
   useBrowserNotifications,
+  useRawPacketStatsSession,
 } from './hooks';
 import { AppShell } from './components/AppShell';
 import type { MessageInputHandle } from './components/MessageInput';
+import { DistanceUnitProvider } from './contexts/DistanceUnitContext';
 import { messageContainsMention } from './utils/messageParser';
-import type { Conversation, RawPacket } from './types';
+import { getStateKey } from './utils/conversationState';
+import type { Conversation, Message, RawPacket } from './types';
+
+interface ChannelUnreadMarker {
+  channelId: string;
+  lastReadAt: number | null;
+}
+
+interface UnreadBoundaryBackfillParams {
+  activeConversation: Conversation | null;
+  unreadMarker: ChannelUnreadMarker | null;
+  messages: Message[];
+  messagesLoading: boolean;
+  loadingOlder: boolean;
+  hasOlderMessages: boolean;
+}
+
+export function getUnreadBoundaryBackfillKey({
+  activeConversation,
+  unreadMarker,
+  messages,
+  messagesLoading,
+  loadingOlder,
+  hasOlderMessages,
+}: UnreadBoundaryBackfillParams): string | null {
+  if (activeConversation?.type !== 'channel') return null;
+  if (!unreadMarker || unreadMarker.channelId !== activeConversation.id) return null;
+  if (unreadMarker.lastReadAt === null) return null;
+  if (messagesLoading || loadingOlder || !hasOlderMessages || messages.length === 0) return null;
+
+  const oldestLoadedMessage = messages.reduce(
+    (oldest, msg) => {
+      if (!oldest) return msg;
+      if (msg.received_at < oldest.received_at) return msg;
+      if (msg.received_at === oldest.received_at && msg.id < oldest.id) return msg;
+      return oldest;
+    },
+    null as Message | null
+  );
+
+  if (!oldestLoadedMessage) return null;
+  if (oldestLoadedMessage.received_at <= unreadMarker.lastReadAt) return null;
+
+  return `${activeConversation.id}:${unreadMarker.lastReadAt}:${oldestLoadedMessage.id}`;
+}
 
 export function App() {
   const quoteSearchOperatorValue = useCallback((value: string) => {
@@ -27,6 +73,9 @@ export function App() {
 
   const messageInputRef = useRef<MessageInputHandle>(null);
   const [rawPackets, setRawPackets] = useState<RawPacket[]>([]);
+  const [channelUnreadMarker, setChannelUnreadMarker] = useState<ChannelUnreadMarker | null>(null);
+  const [visibilityVersion, setVisibilityVersion] = useState(0);
+  const lastUnreadBackfillAttemptRef = useRef<string | null>(null);
   const {
     notificationsSupported,
     notificationsPermission,
@@ -34,6 +83,7 @@ export function App() {
     toggleConversationNotifications,
     notifyIncomingMessage,
   } = useBrowserNotifications();
+  const { rawPacketStatsSession, recordRawPacketObservation } = useRawPacketStatsSession();
   const {
     showNewMessage,
     showSettings,
@@ -42,10 +92,12 @@ export function App() {
     showCracker,
     crackerRunning,
     localLabel,
+    distanceUnit,
     setSettingsSection,
     setSidebarOpen,
     setCrackerRunning,
     setLocalLabel,
+    setDistanceUnit,
     handleCloseSettingsView,
     handleToggleSettingsView,
     handleOpenNewMessage,
@@ -61,6 +113,7 @@ export function App() {
   // useConversationRouter, but useConversationRouter needs channels/contacts from
   // useContactsAndChannels. We break the cycle with a ref-based indirection.
   const setActiveConversationRef = useRef<(conv: Conversation | null) => void>(() => {});
+  const removeConversationMessagesRef = useRef<(conversationId: string) => void>(() => {});
 
   // --- Extracted hooks ---
 
@@ -76,6 +129,9 @@ export function App() {
     handleDisconnect,
     handleReconnect,
     handleAdvertise,
+    meshDiscovery,
+    meshDiscoveryLoadingTarget,
+    handleDiscoverMesh,
     handleHealthRefresh,
   } = useRadioControl();
 
@@ -84,7 +140,6 @@ export function App() {
     favorites,
     fetchAppSettings,
     handleSaveAppSettings,
-    handleSortOrderChange,
     handleToggleFavorite,
     handleToggleBlockedKey,
     handleToggleBlockedName,
@@ -130,6 +185,8 @@ export function App() {
     setActiveConversation: (conv) => setActiveConversationRef.current(conv),
     pendingDeleteFallbackRef,
     hasSetDefaultConversation,
+    removeConversationMessages: (conversationId) =>
+      removeConversationMessagesRef.current(conversationId),
   });
 
   // useConversationRouter is called second — it receives channels/contacts as inputs
@@ -142,6 +199,7 @@ export function App() {
     channels,
     contacts,
     contactsLoaded,
+    suspendHashSync: showSettings,
     setSidebarOpen,
     pendingDeleteFallbackRef,
     hasSetDefaultConversation,
@@ -178,31 +236,89 @@ export function App() {
     hasOlderMessages,
     hasNewerMessages,
     loadingNewer,
-    hasNewerMessagesRef,
     fetchOlderMessages,
     fetchNewerMessages,
     jumpToBottom,
-    addMessageIfNew,
-    updateMessageAck,
-    triggerReconcile,
+    reloadCurrentConversation,
+    observeMessage,
+    receiveMessageAck,
+    reconcileOnReconnect,
+    renameConversationMessages,
+    removeConversationMessages,
+    clearConversationMessages,
   } = useConversationMessages(activeConversation, targetMessageId);
+  removeConversationMessagesRef.current = removeConversationMessages;
 
   const {
     unreadCounts,
     mentions,
     lastMessageTimes,
-    incrementUnread,
+    unreadLastReadAts,
+    recordMessageEvent,
+    renameConversationState,
     markAllRead,
-    trackNewMessage,
     refreshUnreads,
   } = useUnreadCounts(channels, contacts, activeConversation);
 
+  useEffect(() => {
+    if (activeConversation?.type !== 'channel') {
+      setChannelUnreadMarker(null);
+      return;
+    }
+
+    const activeChannelId = activeConversation.id;
+    const activeChannelUnreadCount = unreadCounts[getStateKey('channel', activeChannelId)] ?? 0;
+
+    setChannelUnreadMarker((prev) => {
+      if (prev?.channelId === activeChannelId) {
+        return prev;
+      }
+      if (activeChannelUnreadCount <= 0) {
+        return null;
+      }
+      return {
+        channelId: activeChannelId,
+        lastReadAt: unreadLastReadAts[getStateKey('channel', activeChannelId)] ?? null,
+      };
+    });
+  }, [activeConversation, unreadCounts, unreadLastReadAts]);
+
+  useEffect(() => {
+    lastUnreadBackfillAttemptRef.current = null;
+  }, [activeConversation?.id, channelUnreadMarker?.channelId, channelUnreadMarker?.lastReadAt]);
+
+  useEffect(() => {
+    const backfillKey = getUnreadBoundaryBackfillKey({
+      activeConversation,
+      unreadMarker: channelUnreadMarker,
+      messages,
+      messagesLoading,
+      loadingOlder,
+      hasOlderMessages,
+    });
+
+    if (!backfillKey || lastUnreadBackfillAttemptRef.current === backfillKey) {
+      return;
+    }
+
+    lastUnreadBackfillAttemptRef.current = backfillKey;
+    void fetchOlderMessages();
+  }, [
+    activeConversation,
+    channelUnreadMarker,
+    messages,
+    messagesLoading,
+    loadingOlder,
+    hasOlderMessages,
+    fetchOlderMessages,
+  ]);
+
   const wsHandlers = useRealtimeAppState({
     prevHealthRef,
     setHealth,
     fetchConfig,
     setRawPackets,
-    triggerReconcile,
+    reconcileOnReconnect,
     refreshUnreads,
     setChannels,
     fetchAllContacts,
@@ -210,32 +326,53 @@ export function App() {
     blockedKeysRef,
     blockedNamesRef,
     activeConversationRef,
-    hasNewerMessagesRef,
-    addMessageIfNew,
-    trackNewMessage,
-    incrementUnread,
+    observeMessage,
+    recordMessageEvent,
+    renameConversationState,
     checkMention,
     pendingDeleteFallbackRef,
     setActiveConversation,
-    updateMessageAck,
+    renameConversationMessages,
+    removeConversationMessages,
+    receiveMessageAck,
     notifyIncomingMessage,
+    recordRawPacketObservation,
   });
+  const handleVisibilityPolicyChanged = useCallback(() => {
+    clearConversationMessages();
+    reloadCurrentConversation();
+    void refreshUnreads();
+    setVisibilityVersion((current) => current + 1);
+  }, [clearConversationMessages, refreshUnreads, reloadCurrentConversation]);
+
+  const handleBlockKey = useCallback(
+    async (key: string) => {
+      await handleToggleBlockedKey(key);
+      handleVisibilityPolicyChanged();
+    },
+    [handleToggleBlockedKey, handleVisibilityPolicyChanged]
+  );
+
+  const handleBlockName = useCallback(
+    async (name: string) => {
+      await handleToggleBlockedName(name);
+      handleVisibilityPolicyChanged();
+    },
+    [handleToggleBlockedName, handleVisibilityPolicyChanged]
+  );
   const {
     handleSendMessage,
     handleResendChannelMessage,
     handleSetChannelFloodScopeOverride,
     handleSenderClick,
     handleTrace,
-    handleBlockKey,
-    handleBlockName,
+    handlePathDiscovery,
   } = useConversationActions({
     activeConversation,
     activeConversationRef,
+    setContacts,
     setChannels,
-    addMessageIfNew,
-    jumpToBottom,
-    handleToggleBlockedKey,
-    handleToggleBlockedName,
+    observeMessage,
     messageInputRef,
   });
   const handleCreateCrackedChannel = useCallback(
@@ -274,10 +411,7 @@ export function App() {
       void markAllRead();
     },
     favorites,
-    sortOrder: appSettings?.sidebar_sort_order ?? 'recent',
-    onSortOrderChange: (sortOrder: 'recent' | 'alpha') => {
-      void handleSortOrderChange(sortOrder);
-    },
+    legacySortOrder: appSettings?.sidebar_sort_order,
     isConversationNotificationsEnabled,
   };
   const conversationPaneProps = {
@@ -285,6 +419,7 @@ export function App() {
     contacts,
     channels,
     rawPackets,
+    rawPacketStatsSession,
     config,
     health,
     favorites,
@@ -292,11 +427,17 @@ export function App() {
     messagesLoading,
     loadingOlder,
     hasOlderMessages,
+    unreadMarkerLastReadAt:
+      activeConversation?.type === 'channel' &&
+      channelUnreadMarker?.channelId === activeConversation.id
+        ? channelUnreadMarker.lastReadAt
+        : undefined,
     targetMessageId,
     hasNewerMessages,
     loadingNewer,
     messageInputRef,
     onTrace: handleTrace,
+    onPathDiscovery: handlePathDiscovery,
     onToggleFavorite: handleToggleFavorite,
     onDeleteContact: handleDeleteContact,
     onDeleteChannel: handleDeleteChannel,
@@ -310,6 +451,7 @@ export function App() {
     onLoadNewer: fetchNewerMessages,
     onJumpToBottom: jumpToBottom,
     onSendMessage: handleSendMessage,
+    onDismissUnreadMarker: () => setChannelUnreadMarker(null),
     notificationsSupported,
     notificationsPermission,
     notificationsEnabled:
@@ -329,6 +471,7 @@ export function App() {
   const searchProps = {
     contacts,
     channels,
+    visibilityVersion,
     onNavigateToMessage: handleNavigateToMessage,
     prefillRequest: searchPrefillRequest,
   };
@@ -343,6 +486,9 @@ export function App() {
     onDisconnect: handleDisconnect,
     onReconnect: handleReconnect,
     onAdvertise: handleAdvertise,
+    meshDiscovery,
+    meshDiscoveryLoadingTarget,
+    onDiscoverMesh: handleDiscoverMesh,
     onHealthRefresh: handleHealthRefresh,
     onRefreshAppSettings: fetchAppSettings,
     blockedKeys: appSettings?.blocked_keys,
@@ -421,29 +567,31 @@ export function App() {
     setContactsLoaded,
   ]);
   return (
-    <AppShell
-      localLabel={localLabel}
-      showNewMessage={showNewMessage}
-      showSettings={showSettings}
-      settingsSection={settingsSection}
-      sidebarOpen={sidebarOpen}
-      showCracker={showCracker}
-      onSettingsSectionChange={setSettingsSection}
-      onSidebarOpenChange={setSidebarOpen}
-      onCrackerRunningChange={setCrackerRunning}
-      onToggleSettingsView={handleToggleSettingsView}
-      onCloseSettingsView={handleCloseSettingsView}
-      onCloseNewMessage={handleCloseNewMessage}
-      onLocalLabelChange={setLocalLabel}
-      statusProps={statusProps}
-      sidebarProps={sidebarProps}
-      conversationPaneProps={conversationPaneProps}
-      searchProps={searchProps}
-      settingsProps={settingsProps}
-      crackerProps={crackerProps}
-      newMessageModalProps={newMessageModalProps}
-      contactInfoPaneProps={contactInfoPaneProps}
-      channelInfoPaneProps={channelInfoPaneProps}
-    />
+    <DistanceUnitProvider distanceUnit={distanceUnit} setDistanceUnit={setDistanceUnit}>
+      <AppShell
+        localLabel={localLabel}
+        showNewMessage={showNewMessage}
+        showSettings={showSettings}
+        settingsSection={settingsSection}
+        sidebarOpen={sidebarOpen}
+        showCracker={showCracker}
+        onSettingsSectionChange={setSettingsSection}
+        onSidebarOpenChange={setSidebarOpen}
+        onCrackerRunningChange={setCrackerRunning}
+        onToggleSettingsView={handleToggleSettingsView}
+        onCloseSettingsView={handleCloseSettingsView}
+        onCloseNewMessage={handleCloseNewMessage}
+        onLocalLabelChange={setLocalLabel}
+        statusProps={statusProps}
+        sidebarProps={sidebarProps}
+        conversationPaneProps={conversationPaneProps}
+        searchProps={searchProps}
+        settingsProps={settingsProps}
+        crackerProps={crackerProps}
+        newMessageModalProps={newMessageModalProps}
+        contactInfoPaneProps={contactInfoPaneProps}
+        channelInfoPaneProps={channelInfoPaneProps}
+      />
+    </DistanceUnitProvider>
   );
 }

frontend/src/api.ts

@@ -6,9 +6,7 @@ import type {
   CommandResponse,
   Contact,
   ContactAnalytics,
-  ContactAdvertPath,
   ContactAdvertPathSummary,
-  ContactDetail,
   FanoutConfig,
   Favorite,
   HealthStatus,
@@ -17,14 +15,19 @@ import type {
   MessagesAroundResponse,
   MigratePreferencesRequest,
   MigratePreferencesResponse,
-  NameOnlyContactDetail,
+  RadioAdvertMode,
   RadioConfig,
   RadioConfigUpdate,
+  RadioDiscoveryResponse,
+  RadioDiscoveryTarget,
+  PathDiscoveryResponse,
+  ResendChannelMessageResponse,
   RepeaterAclResponse,
   RepeaterAdvertIntervalsResponse,
   RepeaterLoginResponse,
   RepeaterLppTelemetryResponse,
   RepeaterNeighborsResponse,
+  RepeaterNodeInfoResponse,
   RepeaterOwnerInfoResponse,
   RepeaterRadioSettingsResponse,
   RepeaterStatusResponse,
@@ -93,9 +96,15 @@ export const api = {
       method: 'PUT',
       body: JSON.stringify({ private_key: privateKey }),
     }),
-  sendAdvertisement: () =>
+  sendAdvertisement: (mode: RadioAdvertMode = 'flood') =>
     fetchJson<{ status: string }>('/radio/advertise', {
       method: 'POST',
+      body: JSON.stringify({ mode }),
+    }),
+  discoverMesh: (target: RadioDiscoveryTarget) =>
+    fetchJson<RadioDiscoveryResponse>('/radio/discover', {
+      method: 'POST',
+      body: JSON.stringify({ target }),
     }),
   rebootRadio: () =>
     fetchJson<{ status: string; message: string }>('/radio/reboot', {
@@ -120,18 +129,12 @@ export const api = {
     fetchJson<ContactAdvertPathSummary[]>(
       `/contacts/repeaters/advert-paths?limit_per_repeater=${limitPerRepeater}`
     ),
-  getContactAdvertPaths: (publicKey: string, limit = 10) =>
-    fetchJson<ContactAdvertPath[]>(`/contacts/${publicKey}/advert-paths?limit=${limit}`),
   getContactAnalytics: (params: { publicKey?: string; name?: string }) => {
     const searchParams = new URLSearchParams();
     if (params.publicKey) searchParams.set('public_key', params.publicKey);
     if (params.name) searchParams.set('name', params.name);
     return fetchJson<ContactAnalytics>(`/contacts/analytics?${searchParams.toString()}`);
   },
-  getContactDetail: (publicKey: string) =>
-    fetchJson<ContactDetail>(`/contacts/${publicKey}/detail`),
-  getNameOnlyContactDetail: (name: string) =>
-    fetchJson<NameOnlyContactDetail>(`/contacts/name-detail?name=${encodeURIComponent(name)}`),
   deleteContact: (publicKey: string) =>
     fetchJson<{ status: string }>(`/contacts/${publicKey}`, {
       method: 'DELETE',
@@ -154,6 +157,10 @@ export const api = {
     fetchJson<TraceResponse>(`/contacts/${publicKey}/trace`, {
       method: 'POST',
     }),
+  requestPathDiscovery: (publicKey: string) =>
+    fetchJson<PathDiscoveryResponse>(`/contacts/${publicKey}/path-discovery`, {
+      method: 'POST',
+    }),
   setContactRoutingOverride: (publicKey: string, route: string) =>
     fetchJson<{ status: string; public_key: string }>(`/contacts/${publicKey}/routing-override`, {
       method: 'POST',
@@ -234,7 +241,7 @@ export const api = {
       body: JSON.stringify({ channel_key: channelKey, text }),
     }),
   resendChannelMessage: (messageId: number, newTimestamp?: boolean) =>
-    fetchJson<{ status: string; message_id: number }>(
+    fetchJson<ResendChannelMessageResponse>(
       `/messages/channel/${messageId}/resend${newTimestamp ? '?new_timestamp=true' : ''}`,
       { method: 'POST' }
     ),
@@ -352,6 +359,10 @@ export const api = {
     fetchJson<RepeaterNeighborsResponse>(`/contacts/${publicKey}/repeater/neighbors`, {
       method: 'POST',
     }),
+  repeaterNodeInfo: (publicKey: string) =>
+    fetchJson<RepeaterNodeInfoResponse>(`/contacts/${publicKey}/repeater/node-info`, {
+      method: 'POST',
+    }),
   repeaterAcl: (publicKey: string) =>
     fetchJson<RepeaterAclResponse>(`/contacts/${publicKey}/repeater/acl`, {
       method: 'POST',
@@ -372,4 +383,21 @@ export const api = {
     fetchJson<RepeaterLppTelemetryResponse>(`/contacts/${publicKey}/repeater/lpp-telemetry`, {
       method: 'POST',
     }),
+  roomLogin: (publicKey: string, password: string) =>
+    fetchJson<RepeaterLoginResponse>(`/contacts/${publicKey}/room/login`, {
+      method: 'POST',
+      body: JSON.stringify({ password }),
+    }),
+  roomStatus: (publicKey: string) =>
+    fetchJson<RepeaterStatusResponse>(`/contacts/${publicKey}/room/status`, {
+      method: 'POST',
+    }),
+  roomAcl: (publicKey: string) =>
+    fetchJson<RepeaterAclResponse>(`/contacts/${publicKey}/room/acl`, {
+      method: 'POST',
+    }),
+  roomLppTelemetry: (publicKey: string) =>
+    fetchJson<RepeaterLppTelemetryResponse>(`/contacts/${publicKey}/room/lpp-telemetry`, {
+      method: 'POST',
+    }),
 };

frontend/src/components/AppShell.tsx

@@ -41,6 +41,7 @@ interface AppShellProps {
   settingsSection: SettingsSection;
   sidebarOpen: boolean;
   showCracker: boolean;
+  disabledSettingsSections?: SettingsSection[];
   onSettingsSectionChange: (section: SettingsSection) => void;
   onSidebarOpenChange: (open: boolean) => void;
   onCrackerRunningChange: (running: boolean) => void;
@@ -69,6 +70,7 @@ export function AppShell({
   settingsSection,
   sidebarOpen,
   showCracker,
+  disabledSettingsSections = [],
   onSettingsSectionChange,
   onSidebarOpenChange,
   onCrackerRunningChange,
@@ -118,13 +120,16 @@ export function AppShell({
       <div className="flex-1 min-h-0 overflow-y-auto py-1 [contain:layout_paint]">
         {SETTINGS_SECTION_ORDER.map((section) => {
           const Icon = SETTINGS_SECTION_ICONS[section];
+          const disabled = disabledSettingsSections.includes(section);
           return (
             <button
               key={section}
               type="button"
+              disabled={disabled}
               className={cn(
-                'w-full px-3 py-2 text-left text-[13px] border-l-2 border-transparent hover:bg-accent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset',
-                settingsSection === section && 'bg-accent border-l-primary'
+                'w-full px-3 py-2 text-left text-[13px] border-l-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset disabled:cursor-not-allowed disabled:opacity-50',
+                !disabled && 'hover:bg-accent',
+                settingsSection === section && !disabled && 'bg-accent border-l-primary'
               )}
               aria-current={settingsSection === section ? 'true' : undefined}
               onClick={() => onSettingsSectionChange(section)}
@@ -178,7 +183,14 @@ export function AppShell({
         <div className="hidden md:block min-h-0 overflow-hidden">{activeSidebarContent}</div>
 
         <Sheet open={sidebarOpen} onOpenChange={onSidebarOpenChange}>
-          <SheetContent side="left" className="w-[280px] p-0 flex flex-col" hideCloseButton>
+          <SheetContent
+            side="left"
+            className="w-[280px] p-0 flex flex-col"
+            hideCloseButton
+            onOpenAutoFocus={(event) => {
+              event.preventDefault();
+            }}
+          >
             <SheetHeader className="sr-only">
               <SheetTitle>Navigation</SheetTitle>
               <SheetDescription>Sidebar navigation</SheetDescription>
@@ -245,14 +257,6 @@ export function AppShell({
       </div>
 
       <div
-        ref={(el) => {
-          if (showCracker && el) {
-            const focusable = el.querySelector<HTMLElement>('input, button:not([disabled])');
-            if (focusable) {
-              setTimeout(() => focusable.focus(), 210);
-            }
-          }
-        }}
         className={cn(
           'border-t border-border bg-background transition-all duration-200 overflow-hidden',
           showCracker ? 'h-[275px]' : 'h-0'

frontend/src/components/ChannelFloodScopeOverrideModal.tsx

@@ -0,0 +1,105 @@
+import { useEffect, useState } from 'react';
+
+import { stripRegionScopePrefix } from '../utils/regionScope';
+import { Button } from './ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from './ui/dialog';
+import { Input } from './ui/input';
+import { Label } from './ui/label';
+
+interface ChannelFloodScopeOverrideModalProps {
+  open: boolean;
+  onClose: () => void;
+  roomName: string;
+  currentOverride: string | null;
+  onSetOverride: (value: string) => void;
+}
+
+export function ChannelFloodScopeOverrideModal({
+  open,
+  onClose,
+  roomName,
+  currentOverride,
+  onSetOverride,
+}: ChannelFloodScopeOverrideModalProps) {
+  const [region, setRegion] = useState('');
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    setRegion(stripRegionScopePrefix(currentOverride));
+  }, [currentOverride, open]);
+
+  const trimmedRegion = region.trim();
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <DialogContent className="sm:max-w-[520px]">
+        <DialogHeader>
+          <DialogTitle>Regional Override</DialogTitle>
+          <DialogDescription>
+            Room-level regional routing temporarily changes the radio flood scope before send and
+            restores it after. This can noticeably slow room sends.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <div className="rounded-md border border-border bg-muted/20 p-3 text-sm">
+            <div className="font-medium">{roomName}</div>
+            <div className="mt-1 text-muted-foreground">
+              Current regional override:{' '}
+              {currentOverride ? stripRegionScopePrefix(currentOverride) : 'none'}
+            </div>
+          </div>
+
+          <div className="space-y-2">
+            <Label htmlFor="channel-region-input">Region</Label>
+            <Input
+              id="channel-region-input"
+              value={region}
+              onChange={(event) => setRegion(event.target.value)}
+              placeholder="Esperance"
+              autoFocus
+            />
+          </div>
+        </div>
+
+        <DialogFooter className="gap-2 sm:block sm:space-x-0">
+          <div className="space-y-2">
+            <Button
+              type="button"
+              className="w-full"
+              disabled={trimmedRegion.length === 0}
+              onClick={() => {
+                onSetOverride(trimmedRegion);
+                onClose();
+              }}
+            >
+              {trimmedRegion.length > 0
+                ? `Use ${trimmedRegion} region for ${roomName}`
+                : `Use region for ${roomName}`}
+            </Button>
+            <Button
+              type="button"
+              variant="outline"
+              className="w-full"
+              onClick={() => {
+                onSetOverride('');
+                onClose();
+              }}
+            >
+              Do not use region routing for {roomName}
+            </Button>
+          </div>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend/src/components/ChatHeader.tsx

@@ -1,12 +1,26 @@
 import { useEffect, useState } from 'react';
 import { Bell, Globe2, Info, Route, Star, Trash2 } from 'lucide-react';
 import { toast } from './ui/sonner';
+import { DirectTraceIcon } from './DirectTraceIcon';
+import { ContactPathDiscoveryModal } from './ContactPathDiscoveryModal';
+import { ChannelFloodScopeOverrideModal } from './ChannelFloodScopeOverrideModal';
 import { isFavorite } from '../utils/favorites';
 import { handleKeyboardActivate } from '../utils/a11y';
+import { isPublicChannelKey } from '../utils/publicChannel';
 import { stripRegionScopePrefix } from '../utils/regionScope';
+import { isPrefixOnlyContact } from '../utils/pubkey';
+import { cn } from '../lib/utils';
 import { ContactAvatar } from './ContactAvatar';
 import { ContactStatusInfo } from './ContactStatusInfo';
-import type { Channel, Contact, Conversation, Favorite, RadioConfig } from '../types';
+import type {
+  Channel,
+  Contact,
+  Conversation,
+  Favorite,
+  PathDiscoveryResponse,
+  RadioConfig,
+} from '../types';
+import { CONTACT_TYPE_ROOM } from '../types';
 
 interface ChatHeaderProps {
   conversation: Conversation;
@@ -18,6 +32,7 @@ interface ChatHeaderProps {
   notificationsEnabled: boolean;
   notificationsPermission: NotificationPermission | 'unsupported';
   onTrace: () => void;
+  onPathDiscovery: (publicKey: string) => Promise<PathDiscoveryResponse>;
   onToggleNotifications: () => void;
   onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
   onSetChannelFloodScopeOverride?: (key: string, floodScopeOverride: string) => void;
@@ -37,6 +52,7 @@ export function ChatHeader({
   notificationsEnabled,
   notificationsPermission,
   onTrace,
+  onPathDiscovery,
   onToggleNotifications,
   onToggleFavorite,
   onSetChannelFloodScopeOverride,
@@ -46,9 +62,13 @@ export function ChatHeader({
   onOpenChannelInfo,
 }: ChatHeaderProps) {
   const [showKey, setShowKey] = useState(false);
+  const [pathDiscoveryOpen, setPathDiscoveryOpen] = useState(false);
+  const [channelOverrideOpen, setChannelOverrideOpen] = useState(false);
 
   useEffect(() => {
     setShowKey(false);
+    setPathDiscoveryOpen(false);
+    setChannelOverrideOpen(false);
   }, [conversation.id]);
 
   const activeChannel =
@@ -62,6 +82,14 @@ export function ChatHeader({
     : null;
   const activeFloodScopeDisplay = activeFloodScopeOverride ? activeFloodScopeOverride : null;
   const isPrivateChannel = conversation.type === 'channel' && !activeChannel?.is_hashtag;
+  const activeContact =
+    conversation.type === 'contact'
+      ? contacts.find((contact) => contact.public_key === conversation.id)
+      : null;
+  const activeContactIsRoomServer = activeContact?.type === CONTACT_TYPE_ROOM;
+  const activeContactIsPrefixOnly = activeContact
+    ? isPrefixOnlyContact(activeContact.public_key)
+    : false;
 
   const titleClickable =
     (conversation.type === 'contact' && onOpenContactInfo) ||
@@ -77,23 +105,33 @@ export function ChatHeader({
 
   const handleEditFloodScopeOverride = () => {
     if (conversation.type !== 'channel' || !onSetChannelFloodScopeOverride) return;
-    const nextValue = window.prompt(
-      'Enter regional override flood scope for this room. This temporarily changes the radio flood scope before send and restores it after, which significantly slows room sends. Leave blank to clear.',
-      activeFloodScopeLabel ?? ''
-    );
-    if (nextValue === null) return;
-    onSetChannelFloodScopeOverride(conversation.id, nextValue);
+    setChannelOverrideOpen(true);
+  };
+
+  const handleOpenConversationInfo = () => {
+    if (conversation.type === 'contact' && onOpenContactInfo) {
+      onOpenContactInfo(conversation.id);
+      return;
+    }
+    if (conversation.type === 'channel' && onOpenChannelInfo) {
+      onOpenChannelInfo(conversation.id);
+    }
   };
 
   return (
-    <header className="flex justify-between items-start px-4 py-2.5 border-b border-border gap-2">
-      <span className="flex min-w-0 flex-1 items-start gap-2">
+    <header
+      className={cn(
+        'conversation-header grid items-start gap-x-2 gap-y-0.5 border-b border-border px-4 py-2.5',
+        conversation.type === 'contact' && activeContact
+          ? 'grid-cols-[minmax(0,1fr)_auto] min-[1100px]:grid-cols-[minmax(0,1fr)_auto_auto]'
+          : 'grid-cols-[minmax(0,1fr)_auto]'
+      )}
+    >
+      <span className="flex min-w-0 items-start gap-2">
         {conversation.type === 'contact' && onOpenContactInfo && (
-          <span
-            className="flex-shrink-0 cursor-pointer"
-            role="button"
-            tabIndex={0}
-            onKeyDown={handleKeyboardActivate}
+          <button
+            type="button"
+            className="avatar-action-button flex-shrink-0 cursor-pointer rounded-full border-none bg-transparent p-0 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
             onClick={() => onOpenContactInfo(conversation.id)}
             title="View contact info"
             aria-label={`View info for ${conversation.name}`}
@@ -105,42 +143,41 @@ export function ChatHeader({
               contactType={contacts.find((c) => c.public_key === conversation.id)?.type}
               clickable
             />
-          </span>
+          </button>
         )}
         <span className="flex min-w-0 flex-1 flex-col">
           <span className="flex min-w-0 flex-wrap items-baseline gap-x-2 gap-y-0.5">
-            <span className="flex min-w-0 flex-1 items-baseline gap-2">
-              <h2
-                className={`flex shrink min-w-0 items-center gap-1.5 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
-                }
-              >
-                <span className="truncate">
-                  {conversation.type === 'channel' &&
-                  !conversation.name.startsWith('#') &&
-                  activeChannel?.is_hashtag
-                    ? '#'
-                    : ''}
-                  {conversation.name}
-                </span>
-                {titleClickable && (
-                  <Info
-                    className="h-3.5 w-3.5 flex-shrink-0 text-muted-foreground/80"
-                    aria-hidden="true"
-                  />
+            <span className="flex min-w-0 flex-1 items-baseline gap-2 whitespace-nowrap">
+              <h2 className="min-w-0 flex-shrink font-semibold text-base">
+                {titleClickable ? (
+                  <button
+                    type="button"
+                    className="flex max-w-full min-w-0 items-center gap-1.5 overflow-hidden rounded-sm text-left transition-colors hover:text-primary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                    aria-label={`View info for ${conversation.name}`}
+                    onClick={handleOpenConversationInfo}
+                  >
+                    <span className="truncate">
+                      {conversation.type === 'channel' &&
+                      !conversation.name.startsWith('#') &&
+                      activeChannel?.is_hashtag
+                        ? '#'
+                        : ''}
+                      {conversation.name}
+                    </span>
+                    <Info
+                      className="h-3.5 w-3.5 flex-shrink-0 text-muted-foreground/80"
+                      aria-hidden="true"
+                    />
+                  </button>
+                ) : (
+                  <span className="truncate">
+                    {conversation.type === 'channel' &&
+                    !conversation.name.startsWith('#') &&
+                    activeChannel?.is_hashtag
+                      ? '#'
+                      : ''}
+                    {conversation.name}
+                  </span>
                 )}
               </h2>
               {isPrivateChannel && !showKey ? (
@@ -178,51 +215,66 @@ export function ChatHeader({
                 </span>
               )}
             </span>
-            {conversation.type === 'contact' &&
-              (() => {
-                const contact = contacts.find((c) => c.public_key === conversation.id);
-                if (!contact) return null;
-                return (
-                  <span className="min-w-0 flex-none text-[11px] text-muted-foreground max-sm:basis-full">
-                    <ContactStatusInfo
-                      contact={contact}
-                      ourLat={config?.lat ?? null}
-                      ourLon={config?.lon ?? null}
-                    />
-                  </span>
-                );
-              })()}
+            {conversation.type === 'channel' && activeFloodScopeDisplay && (
+              <button
+                className="mt-0.5 flex basis-full items-center gap-1 text-left sm:hidden"
+                onClick={handleEditFloodScopeOverride}
+                title="Set regional override"
+                aria-label="Set regional override"
+              >
+                <Globe2
+                  className="h-3.5 w-3.5 flex-shrink-0 text-[hsl(var(--region-override))]"
+                  aria-hidden="true"
+                />
+                <span className="min-w-0 truncate text-[11px] font-medium text-[hsl(var(--region-override))]">
+                  {activeFloodScopeDisplay}
+                </span>
+              </button>
+            )}
           </span>
-          {conversation.type === 'channel' && activeFloodScopeDisplay && (
-            <button
-              className="mt-0.5 flex items-center gap-1 text-left sm:hidden"
-              onClick={handleEditFloodScopeOverride}
-              title="Set regional override"
-              aria-label="Set regional override"
-            >
-              <Globe2
-                className="h-3.5 w-3.5 flex-shrink-0 text-[hsl(var(--region-override))]"
-                aria-hidden="true"
-              />
-              <span className="min-w-0 truncate text-[11px] font-medium text-[hsl(var(--region-override))]">
-                {activeFloodScopeDisplay}
-              </span>
-            </button>
-          )}
         </span>
       </span>
-      <div className="flex items-center justify-end gap-0.5 flex-shrink-0">
-        {conversation.type === 'contact' && (
+      {conversation.type === 'contact' && activeContact && (
+        <div className="col-span-2 row-start-2 min-w-0 text-[11px] text-muted-foreground min-[1100px]:col-span-1 min-[1100px]:col-start-2 min-[1100px]:row-start-1">
+          <ContactStatusInfo
+            contact={activeContact}
+            ourLat={config?.lat ?? null}
+            ourLon={config?.lon ?? null}
+          />
+        </div>
+      )}
+      <div className="flex items-center justify-end gap-0.5">
+        {conversation.type === 'contact' && !activeContactIsRoomServer && (
           <button
-            className="p-1 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"
+            className="p-1 rounded hover:bg-accent text-lg leading-none transition-colors disabled:cursor-not-allowed disabled:opacity-50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={() => setPathDiscoveryOpen(true)}
+            title={
+              activeContactIsPrefixOnly
+                ? 'Path Discovery unavailable until the full contact key is known'
+                : 'Path Discovery. Send a routed probe and inspect the forward and return paths'
+            }
+            aria-label="Path Discovery"
+            disabled={activeContactIsPrefixOnly}
           >
-            <Route className="h-4 w-4" aria-hidden="true" />
+            <Route className="h-4 w-4 text-muted-foreground" aria-hidden="true" />
           </button>
         )}
-        {notificationsSupported && (
+        {conversation.type === 'contact' && !activeContactIsRoomServer && (
+          <button
+            className="p-1 rounded hover:bg-accent text-lg leading-none transition-colors disabled:cursor-not-allowed disabled:opacity-50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            onClick={onTrace}
+            title={
+              activeContactIsPrefixOnly
+                ? 'Direct Trace unavailable until the full contact key is known'
+                : 'Direct Trace. Send a zero-hop packet to this contact and display out and back SNR'
+            }
+            aria-label="Direct Trace"
+            disabled={activeContactIsPrefixOnly}
+          >
+            <DirectTraceIcon className="h-4 w-4 text-muted-foreground" />
+          </button>
+        )}
+        {notificationsSupported && !activeContactIsRoomServer && (
           <button
             className="flex items-center gap-1 rounded px-1 py-1 hover:bg-accent text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
             onClick={onToggleNotifications}
@@ -289,7 +341,7 @@ export function ChatHeader({
             )}
           </button>
         )}
-        {!(conversation.type === 'channel' && conversation.name === 'Public') && (
+        {!(conversation.type === 'channel' && isPublicChannelKey(conversation.id)) && (
           <button
             className="p-1 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={() => {
@@ -306,6 +358,25 @@ export function ChatHeader({
           </button>
         )}
       </div>
+      {conversation.type === 'contact' && activeContact && (
+        <ContactPathDiscoveryModal
+          open={pathDiscoveryOpen}
+          onClose={() => setPathDiscoveryOpen(false)}
+          contact={activeContact}
+          contacts={contacts}
+          radioName={config?.name ?? null}
+          onDiscover={onPathDiscovery}
+        />
+      )}
+      {conversation.type === 'channel' && onSetChannelFloodScopeOverride && (
+        <ChannelFloodScopeOverrideModal
+          open={channelOverrideOpen}
+          onClose={() => setChannelOverrideOpen(false)}
+          roomName={conversation.name}
+          currentOverride={activeFloodScopeDisplay}
+          onSetOverride={(value) => onSetChannelFloodScopeOverride(conversation.id, value)}
+        />
+      )}
     </header>
   );
 }

frontend/src/components/ContactInfoPane.tsx

@@ -2,21 +2,29 @@ import { type ReactNode, useEffect, useState } from 'react';
 import { Ban, Search, Star } from 'lucide-react';
 import { api } from '../api';
 import { formatTime } from '../utils/messageParser';
+import {
+  getContactDisplayName,
+  isPrefixOnlyContact,
+  isUnknownFullKeyContact,
+} from '../utils/pubkey';
 import {
   isValidLocation,
   calculateDistance,
   formatDistance,
   formatRouteLabel,
+  getDirectContactRoute,
   getEffectiveContactRoute,
   hasRoutingOverride,
   parsePathHops,
 } from '../utils/pathUtils';
+import { isPublicChannelKey } from '../utils/publicChannel';
 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 { useDistanceUnit } from '../contexts/DistanceUnitContext';
 import type {
   Contact,
   ContactActiveRoom,
@@ -75,6 +83,7 @@ export function ContactInfoPane({
   onToggleBlockedKey,
   onToggleBlockedName,
 }: ContactInfoPaneProps) {
+  const { distanceUnit } = useDistanceUnit();
   const isNameOnly = contactKey?.startsWith('name:') ?? false;
   const nameOnlyValue = isNameOnly && contactKey ? contactKey.slice(5) : null;
 
@@ -128,11 +137,17 @@ export function ContactInfoPane({
       ? calculateDistance(config.lat, config.lon, contact.lat, contact.lon)
       : null;
   const effectiveRoute = contact ? getEffectiveContactRoute(contact) : null;
+  const directRoute = contact ? getDirectContactRoute(contact) : null;
   const pathHashModeLabel =
     effectiveRoute && effectiveRoute.pathLen >= 0
       ? formatPathHashMode(effectiveRoute.pathHashMode)
       : null;
-  const learnedRouteLabel = contact ? formatRouteLabel(contact.last_path_len, true) : null;
+  const learnedRouteLabel = directRoute ? formatRouteLabel(directRoute.path_len, true) : null;
+  const isPrefixOnlyResolvedContact = contact ? isPrefixOnlyContact(contact.public_key) : false;
+  const isUnknownFullKeyResolvedContact =
+    contact !== null &&
+    !isPrefixOnlyResolvedContact &&
+    isUnknownFullKeyContact(contact.public_key, contact.last_advert);
 
   return (
     <Sheet open={contactKey !== null} onOpenChange={(open) => !open && onClose()}>
@@ -249,7 +264,7 @@ export function ContactInfoPane({
                 />
                 <div className="flex-1 min-w-0">
                   <h2 className="text-lg font-semibold truncate">
-                    {contact.name || contact.public_key.slice(0, 12)}
+                    {getContactDisplayName(contact.name, contact.public_key, contact.last_advert)}
                   </h2>
                   <span
                     className="text-xs font-mono text-muted-foreground cursor-pointer hover:text-primary transition-colors block truncate"
@@ -268,16 +283,27 @@ export function ContactInfoPane({
                     <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>
 
+            {isPrefixOnlyResolvedContact && (
+              <div className="mx-5 mt-4 rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+                We only know a key prefix for this sender, which can happen when a fallback DM
+                arrives before we hear an advertisement. This contact stays read-only until the full
+                key resolves from a later advertisement.
+              </div>
+            )}
+
+            {isUnknownFullKeyResolvedContact && (
+              <div className="mx-5 mt-4 rounded-md border border-warning/30 bg-warning/10 px-3 py-2 text-sm text-warning">
+                We know this sender&apos;s full key, but we have not yet heard an advertisement that
+                fills in their identity details. Those details will appear automatically when an
+                advertisement arrives.
+              </div>
+            )}
+
             {/* 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">
@@ -291,7 +317,7 @@ export function ContactInfoPane({
                   <InfoItem label="Last Contacted" value={formatTime(contact.last_contacted)} />
                 )}
                 {distFromUs !== null && (
-                  <InfoItem label="Distance" value={formatDistance(distFromUs)} />
+                  <InfoItem label="Distance" value={formatDistance(distFromUs, distanceUnit)} />
                 )}
                 {effectiveRoute && (
                   <InfoItem
@@ -308,7 +334,7 @@ export function ContactInfoPane({
                     }
                   />
                 )}
-                {contact && hasRoutingOverride(contact) && learnedRouteLabel && (
+                {hasRoutingOverride(contact) && learnedRouteLabel && (
                   <InfoItem label="Learned Route" value={learnedRouteLabel} />
                 )}
                 {pathHashModeLabel && <InfoItem label="Hop Width" value={pathHashModeLabel} />}
@@ -590,7 +616,7 @@ function MostActiveRoomsSection({
               onKeyDown={onNavigateToChannel ? handleKeyboardActivate : undefined}
               onClick={() => onNavigateToChannel?.(room.channel_key)}
             >
-              {room.channel_name.startsWith('#') || room.channel_name === 'Public'
+              {room.channel_name.startsWith('#') || isPublicChannelKey(room.channel_key)
                 ? room.channel_name
                 : `#${room.channel_name}`}
             </span>

frontend/src/components/ContactPathDiscoveryModal.tsx

@@ -0,0 +1,215 @@
+import { useMemo, useState } from 'react';
+
+import type { Contact, PathDiscoveryResponse, PathDiscoveryRoute } from '../types';
+import {
+  findContactsByPrefix,
+  formatRouteLabel,
+  getDirectContactRoute,
+  getEffectiveContactRoute,
+  hasRoutingOverride,
+  parsePathHops,
+} from '../utils/pathUtils';
+import { Button } from './ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from './ui/dialog';
+
+interface ContactPathDiscoveryModalProps {
+  open: boolean;
+  onClose: () => void;
+  contact: Contact;
+  contacts: Contact[];
+  radioName: string | null;
+  onDiscover: (publicKey: string) => Promise<PathDiscoveryResponse>;
+}
+
+function formatPathHashMode(mode: number): string {
+  if (mode === 0) return '1-byte hops';
+  if (mode === 1) return '2-byte hops';
+  if (mode === 2) return '3-byte hops';
+  return 'Unknown hop width';
+}
+
+function renderRouteNodes(
+  route: PathDiscoveryRoute,
+  startLabel: string,
+  endLabel: string,
+  contacts: Contact[]
+): string {
+  if (route.path_len <= 0 || !route.path) {
+    return `${startLabel} -> ${endLabel}`;
+  }
+
+  const hops = parsePathHops(route.path, route.path_len).map((prefix) => {
+    const matches = findContactsByPrefix(prefix, contacts, true);
+    if (matches.length === 1) {
+      return matches[0].name || `${matches[0].public_key.slice(0, prefix.length)}…`;
+    }
+    if (matches.length > 1) {
+      return `${prefix}…?`;
+    }
+    return `${prefix}…`;
+  });
+
+  return [startLabel, ...hops, endLabel].join(' -> ');
+}
+
+function RouteCard({
+  label,
+  route,
+  chain,
+}: {
+  label: string;
+  route: PathDiscoveryRoute;
+  chain: string;
+}) {
+  const rawPath = parsePathHops(route.path, route.path_len).join(' -> ') || 'direct';
+
+  return (
+    <div className="rounded-md border border-border bg-muted/20 p-3">
+      <div className="flex items-center justify-between gap-3">
+        <h4 className="text-sm font-semibold">{label}</h4>
+        <span className="text-[11px] text-muted-foreground">
+          {formatRouteLabel(route.path_len, true)}
+        </span>
+      </div>
+      <p className="mt-2 text-sm">{chain}</p>
+      <div className="mt-2 flex flex-wrap gap-x-3 gap-y-1 text-[11px] text-muted-foreground">
+        <span>Raw: {rawPath}</span>
+        <span>{formatPathHashMode(route.path_hash_mode)}</span>
+      </div>
+    </div>
+  );
+}
+
+export function ContactPathDiscoveryModal({
+  open,
+  onClose,
+  contact,
+  contacts,
+  radioName,
+  onDiscover,
+}: ContactPathDiscoveryModalProps) {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [result, setResult] = useState<PathDiscoveryResponse | null>(null);
+
+  const effectiveRoute = useMemo(() => getEffectiveContactRoute(contact), [contact]);
+  const directRoute = useMemo(() => getDirectContactRoute(contact), [contact]);
+  const hasForcedRoute = hasRoutingOverride(contact);
+  const learnedRouteSummary = useMemo(() => {
+    if (!directRoute) {
+      return 'Flood';
+    }
+    const hops = parsePathHops(directRoute.path, directRoute.path_len);
+    return hops.length > 0
+      ? `${formatRouteLabel(directRoute.path_len, true)} (${hops.join(' -> ')})`
+      : formatRouteLabel(directRoute.path_len, true);
+  }, [directRoute]);
+  const forcedRouteSummary = useMemo(() => {
+    if (!hasForcedRoute) {
+      return null;
+    }
+    if (effectiveRoute.pathLen === -1) {
+      return 'Flood';
+    }
+    const hops = parsePathHops(effectiveRoute.path, effectiveRoute.pathLen);
+    return hops.length > 0
+      ? `${formatRouteLabel(effectiveRoute.pathLen, true)} (${hops.join(' -> ')})`
+      : formatRouteLabel(effectiveRoute.pathLen, true);
+  }, [effectiveRoute, hasForcedRoute]);
+
+  const forwardChain = result
+    ? renderRouteNodes(
+        result.forward_path,
+        radioName || 'Local radio',
+        contact.name || contact.public_key.slice(0, 12),
+        contacts
+      )
+    : null;
+  const returnChain = result
+    ? renderRouteNodes(
+        result.return_path,
+        contact.name || contact.public_key.slice(0, 12),
+        radioName || 'Local radio',
+        contacts
+      )
+    : null;
+
+  const handleDiscover = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const discovered = await onDiscover(contact.public_key);
+      setResult(discovered);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Unknown error');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <DialogContent className="sm:max-w-[560px]">
+        <DialogHeader>
+          <DialogTitle>Path Discovery</DialogTitle>
+          <DialogDescription>
+            Send a routed probe to this contact and wait for the round-trip path response. The
+            learned forward route will be saved back onto the contact if a response comes back.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <div className="rounded-md border border-border bg-muted/20 p-3 text-sm">
+            <div className="font-medium">{contact.name || contact.public_key.slice(0, 12)}</div>
+            <div className="mt-1 text-muted-foreground">
+              Current learned route: {learnedRouteSummary}
+            </div>
+            {forcedRouteSummary && (
+              <div className="mt-1 text-destructive">
+                Current forced route: {forcedRouteSummary}
+              </div>
+            )}
+          </div>
+
+          {hasForcedRoute && (
+            <div className="rounded-md border border-warning/30 bg-warning/10 px-3 py-2 text-sm text-warning">
+              A forced route override is currently set for this contact. Path discovery will update
+              the learned route data, but it will not replace the forced path. Clearing the forced
+              route afterward is enough to make the newly discovered learned path take effect. You
+              only need to rerun path discovery if you want a fresher route sample.
+            </div>
+          )}
+
+          {error && (
+            <div className="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          {result && forwardChain && returnChain && (
+            <div className="space-y-3">
+              <RouteCard label="Forward Path" route={result.forward_path} chain={forwardChain} />
+              <RouteCard label="Return Path" route={result.return_path} chain={returnChain} />
+            </div>
+          )}
+        </div>
+
+        <DialogFooter className="gap-2 sm:justify-between">
+          <Button variant="secondary" onClick={onClose}>
+            Close
+          </Button>
+          <Button onClick={handleDiscover} disabled={loading}>
+            {loading ? 'Running...' : 'Run path discovery'}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend/src/components/ContactRoutingOverrideModal.tsx

@@ -0,0 +1,180 @@
+import { useEffect, useMemo, useState } from 'react';
+
+import { api } from '../api';
+import type { Contact } from '../types';
+import {
+  formatRouteLabel,
+  formatRoutingOverrideInput,
+  getDirectContactRoute,
+  hasRoutingOverride,
+} from '../utils/pathUtils';
+import { Button } from './ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from './ui/dialog';
+import { Input } from './ui/input';
+import { Label } from './ui/label';
+
+interface ContactRoutingOverrideModalProps {
+  open: boolean;
+  onClose: () => void;
+  contact: Contact;
+  onSaved: (message: string) => void;
+  onError: (message: string) => void;
+}
+
+function summarizeLearnedRoute(contact: Contact): string {
+  return formatRouteLabel(getDirectContactRoute(contact)?.path_len ?? -1, true);
+}
+
+function summarizeForcedRoute(contact: Contact): string | null {
+  if (!hasRoutingOverride(contact)) {
+    return null;
+  }
+  const routeOverrideLen = contact.route_override_len;
+  return routeOverrideLen == null ? null : formatRouteLabel(routeOverrideLen, true);
+}
+
+export function ContactRoutingOverrideModal({
+  open,
+  onClose,
+  contact,
+  onSaved,
+  onError,
+}: ContactRoutingOverrideModalProps) {
+  const [route, setRoute] = useState('');
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    setRoute(formatRoutingOverrideInput(contact));
+    setError(null);
+  }, [contact, open]);
+
+  const forcedRouteSummary = useMemo(() => summarizeForcedRoute(contact), [contact]);
+
+  const saveRoute = async (value: string) => {
+    setSaving(true);
+    setError(null);
+    try {
+      await api.setContactRoutingOverride(contact.public_key, value);
+      onSaved(value.trim() === '' ? 'Routing override cleared' : 'Routing override updated');
+      onClose();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Failed to update routing override';
+      setError(message);
+      onError(message);
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <DialogContent className="sm:max-w-[560px]">
+        <DialogHeader>
+          <DialogTitle>Routing Override</DialogTitle>
+          <DialogDescription>
+            Set a forced route for this contact. Leave the field blank to clear the override and
+            fall back to the learned route or flood until a new path is heard.
+          </DialogDescription>
+        </DialogHeader>
+
+        <form
+          className="space-y-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            void saveRoute(route);
+          }}
+        >
+          <div className="rounded-md border border-border bg-muted/20 p-3 text-sm">
+            <div className="font-medium">{contact.name || contact.public_key.slice(0, 12)}</div>
+            <div className="mt-1 text-muted-foreground">
+              Current learned route: {summarizeLearnedRoute(contact)}
+            </div>
+            {forcedRouteSummary && (
+              <div className="mt-1 text-destructive">
+                Current forced route: {forcedRouteSummary}
+              </div>
+            )}
+          </div>
+
+          <div className="space-y-2">
+            <Label htmlFor="routing-override-input">Forced route</Label>
+            <Input
+              id="routing-override-input"
+              value={route}
+              onChange={(event) => setRoute(event.target.value)}
+              placeholder='Examples: "ae,f1" or "ae92,f13e"'
+              autoFocus
+              disabled={saving}
+            />
+            <div className="space-y-1 text-xs text-muted-foreground">
+              <p>Use comma-separated 1, 2, or 3 byte hop IDs for an explicit path.</p>
+              <p>
+                Note: direct messages that do not see an ACK retry up to 3 times. The final retry is
+                sent as flood, even when forced routing is configured.
+              </p>
+            </div>
+          </div>
+
+          <div className="space-y-2">
+            <div className="grid grid-cols-2 gap-2">
+              <Button
+                type="button"
+                variant="outline"
+                className="w-full"
+                onClick={() => void saveRoute('-1')}
+                disabled={saving}
+              >
+                Force Flood
+              </Button>
+              <Button
+                type="button"
+                variant="outline"
+                className="w-full"
+                onClick={() => void saveRoute('0')}
+                disabled={saving}
+              >
+                Force Direct
+              </Button>
+            </div>
+            <Button type="submit" className="w-full" disabled={saving || route.trim().length === 0}>
+              {saving
+                ? 'Saving...'
+                : `Force ${route.trim() === '' ? 'custom' : route.trim()} routing`}
+            </Button>
+          </div>
+
+          {error && (
+            <div className="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          <DialogFooter className="gap-2 sm:justify-between">
+            <Button type="button" variant="secondary" onClick={onClose} disabled={saving}>
+              Cancel
+            </Button>
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => void saveRoute('')}
+              disabled={saving}
+            >
+              Clear override
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend/src/components/ContactStatusInfo.tsx

@@ -1,18 +1,18 @@
-import type { ReactNode } from 'react';
+import { useState, type ReactNode } from 'react';
 import { toast } from './ui/sonner';
-import { api } from '../api';
 import { formatTime } from '../utils/messageParser';
 import {
   isValidLocation,
   calculateDistance,
   formatDistance,
   formatRouteLabel,
-  formatRoutingOverrideInput,
   getEffectiveContactRoute,
 } from '../utils/pathUtils';
 import { getMapFocusHash } from '../utils/urlHash';
 import { handleKeyboardActivate } from '../utils/a11y';
 import type { Contact } from '../types';
+import { useDistanceUnit } from '../contexts/DistanceUnitContext';
+import { ContactRoutingOverrideModal } from './ContactRoutingOverrideModal';
 
 interface ContactStatusInfoProps {
   contact: Contact;
@@ -25,28 +25,11 @@ interface ContactStatusInfoProps {
  * shared between ChatHeader and RepeaterDashboard.
  */
 export function ContactStatusInfo({ contact, ourLat, ourLon }: ContactStatusInfoProps) {
+  const { distanceUnit } = useDistanceUnit();
+  const [routingModalOpen, setRoutingModalOpen] = useState(false);
   const parts: ReactNode[] = [];
   const effectiveRoute = getEffectiveContactRoute(contact);
 
-  const editRoutingOverride = () => {
-    const route = window.prompt(
-      'Enter explicit path as comma-separated 1, 2, or 3 byte hops (for example "ae,f1" or "ae92,f13e").\nEnter 0 to force direct always.\nEnter -1 to force flooding always.\nLeave blank to clear the override and reset to flood until a new path is heard.',
-      formatRoutingOverrideInput(contact)
-    );
-    if (route === null) {
-      return;
-    }
-
-    api.setContactRoutingOverride(contact.public_key, route).then(
-      () =>
-        toast.success(
-          route.trim() === '' ? 'Routing override cleared' : 'Routing override updated'
-        ),
-      (err: unknown) =>
-        toast.error(err instanceof Error ? err.message : 'Failed to update routing override')
-    );
-  };
-
   if (contact.last_seen) {
     parts.push(`Last heard: ${formatTime(contact.last_seen)}`);
   }
@@ -54,13 +37,13 @@ export function ContactStatusInfo({ contact, ourLat, ourLon }: ContactStatusInfo
   parts.push(
     <span
       key="path"
-      className="cursor-pointer hover:text-primary hover:underline"
+      className="cursor-pointer underline underline-offset-2 decoration-muted-foreground/50 hover:text-primary"
       role="button"
       tabIndex={0}
       onKeyDown={handleKeyboardActivate}
       onClick={(e) => {
         e.stopPropagation();
-        editRoutingOverride();
+        setRoutingModalOpen(true);
       }}
       title="Click to edit routing override"
     >
@@ -93,7 +76,7 @@ export function ContactStatusInfo({ contact, ourLat, ourLon }: ContactStatusInfo
         >
           {contact.lat!.toFixed(3)}, {contact.lon!.toFixed(3)}
         </span>
-        {distFromUs !== null && ` (${formatDistance(distFromUs)})`}
+        {distFromUs !== null && ` (${formatDistance(distFromUs, distanceUnit)})`}
       </span>
     );
   }
@@ -101,15 +84,24 @@ export function ContactStatusInfo({ contact, ourLat, ourLon }: ContactStatusInfo
   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>
+    <>
+      <span className="font-normal text-sm text-muted-foreground flex-shrink-0">
+        (
+        {parts.map((part, i) => (
+          <span key={i}>
+            {i > 0 && ', '}
+            {part}
+          </span>
+        ))}
+        )
+      </span>
+      <ContactRoutingOverrideModal
+        open={routingModalOpen}
+        onClose={() => setRoutingModalOpen(false)}
+        contact={contact}
+        onSaved={(message) => toast.success(message)}
+        onError={(message) => toast.error(message)}
+      />
+    </>
   );
 }

frontend/src/components/ConversationPane.tsx

@@ -1,9 +1,10 @@
-import { lazy, Suspense, useMemo, type Ref } from 'react';
+import { lazy, Suspense, useEffect, useMemo, useState, type Ref } from 'react';
 
 import { ChatHeader } from './ChatHeader';
 import { MessageInput, type MessageInputHandle } from './MessageInput';
 import { MessageList } from './MessageList';
-import { RawPacketList } from './RawPacketList';
+import { RawPacketFeedView } from './RawPacketFeedView';
+import { RoomServerPanel } from './RoomServerPanel';
 import type {
   Channel,
   Contact,
@@ -11,10 +12,13 @@ import type {
   Favorite,
   HealthStatus,
   Message,
+  PathDiscoveryResponse,
   RawPacket,
   RadioConfig,
 } from '../types';
-import { CONTACT_TYPE_REPEATER } from '../types';
+import type { RawPacketStatsSessionState } from '../utils/rawPacketStats';
+import { CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM } from '../types';
+import { isPrefixOnlyContact, isUnknownFullKeyContact } from '../utils/pubkey';
 
 const RepeaterDashboard = lazy(() =>
   import('./RepeaterDashboard').then((m) => ({ default: m.RepeaterDashboard }))
@@ -29,6 +33,7 @@ interface ConversationPaneProps {
   contacts: Contact[];
   channels: Channel[];
   rawPackets: RawPacket[];
+  rawPacketStatsSession: RawPacketStatsSessionState;
   config: RadioConfig | null;
   health: HealthStatus | null;
   notificationsSupported: boolean;
@@ -39,11 +44,13 @@ interface ConversationPaneProps {
   messagesLoading: boolean;
   loadingOlder: boolean;
   hasOlderMessages: boolean;
+  unreadMarkerLastReadAt?: number | null;
   targetMessageId: number | null;
   hasNewerMessages: boolean;
   loadingNewer: boolean;
   messageInputRef: Ref<MessageInputHandle>;
   onTrace: () => Promise<void>;
+  onPathDiscovery: (publicKey: string) => Promise<PathDiscoveryResponse>;
   onToggleFavorite: (type: 'channel' | 'contact', id: string) => Promise<void>;
   onDeleteContact: (publicKey: string) => Promise<void>;
   onDeleteChannel: (key: string) => Promise<void>;
@@ -56,6 +63,7 @@ interface ConversationPaneProps {
   onTargetReached: () => void;
   onLoadNewer: () => Promise<void>;
   onJumpToBottom: () => void;
+  onDismissUnreadMarker: () => void;
   onSendMessage: (text: string) => Promise<void>;
   onToggleNotifications: () => void;
 }
@@ -66,11 +74,31 @@ function LoadingPane({ label }: { label: string }) {
   );
 }
 
+function ContactResolutionBanner({ variant }: { variant: 'unknown-full-key' | 'prefix-only' }) {
+  if (variant === 'prefix-only') {
+    return (
+      <div className="mx-4 mt-3 rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+        We only know a key prefix for this sender, which can happen when a fallback DM arrives
+        before we learn their full identity. This conversation is read-only until we hear an
+        advertisement that resolves the full key.
+      </div>
+    );
+  }
+
+  return (
+    <div className="mx-4 mt-3 rounded-md border border-warning/30 bg-warning/10 px-3 py-2 text-sm text-warning">
+      A full identity profile is not yet available because we have not heard an advertisement from
+      this sender. The contact will fill in automatically when an advertisement arrives.
+    </div>
+  );
+}
+
 export function ConversationPane({
   activeConversation,
   contacts,
   channels,
   rawPackets,
+  rawPacketStatsSession,
   config,
   health,
   notificationsSupported,
@@ -81,11 +109,13 @@ export function ConversationPane({
   messagesLoading,
   loadingOlder,
   hasOlderMessages,
+  unreadMarkerLastReadAt,
   targetMessageId,
   hasNewerMessages,
   loadingNewer,
   messageInputRef,
   onTrace,
+  onPathDiscovery,
   onToggleFavorite,
   onDeleteContact,
   onDeleteChannel,
@@ -98,14 +128,31 @@ export function ConversationPane({
   onTargetReached,
   onLoadNewer,
   onJumpToBottom,
+  onDismissUnreadMarker,
   onSendMessage,
   onToggleNotifications,
 }: ConversationPaneProps) {
+  const [roomAuthenticated, setRoomAuthenticated] = useState(false);
   const activeContactIsRepeater = useMemo(() => {
     if (!activeConversation || activeConversation.type !== 'contact') return false;
     const contact = contacts.find((candidate) => candidate.public_key === activeConversation.id);
     return contact?.type === CONTACT_TYPE_REPEATER;
   }, [activeConversation, contacts]);
+  const activeContact = useMemo(() => {
+    if (!activeConversation || activeConversation.type !== 'contact') return null;
+    return contacts.find((candidate) => candidate.public_key === activeConversation.id) ?? null;
+  }, [activeConversation, contacts]);
+  const activeContactIsRoom = activeContact?.type === CONTACT_TYPE_ROOM;
+  useEffect(() => {
+    setRoomAuthenticated(false);
+  }, [activeConversation?.id]);
+  const isPrefixOnlyActiveContact = activeContact
+    ? isPrefixOnlyContact(activeContact.public_key)
+    : false;
+  const isUnknownFullKeyActiveContact =
+    activeContact !== null &&
+    !isPrefixOnlyActiveContact &&
+    isUnknownFullKeyContact(activeContact.public_key, activeContact.last_advert);
 
   if (!activeConversation) {
     return (
@@ -140,14 +187,12 @@ export function ConversationPane({
 
   if (activeConversation.type === 'raw') {
     return (
-      <>
-        <h2 className="flex justify-between items-center px-4 py-2.5 border-b border-border font-semibold text-base">
-          Raw Packet Feed
-        </h2>
-        <div className="flex-1 overflow-hidden">
-          <RawPacketList packets={rawPackets} />
-        </div>
-      </>
+      <RawPacketFeedView
+        packets={rawPackets}
+        rawPacketStatsSession={rawPacketStatsSession}
+        contacts={contacts}
+        channels={channels}
+      />
     );
   }
 
@@ -170,6 +215,7 @@ export function ConversationPane({
           radioLon={config?.lon ?? null}
           radioName={config?.name ?? null}
           onTrace={onTrace}
+          onPathDiscovery={onPathDiscovery}
           onToggleNotifications={onToggleNotifications}
           onToggleFavorite={onToggleFavorite}
           onDeleteContact={onDeleteContact}
@@ -178,6 +224,8 @@ export function ConversationPane({
     );
   }
 
+  const showRoomChat = !activeContactIsRoom || roomAuthenticated;
+
   return (
     <>
       <ChatHeader
@@ -190,6 +238,7 @@ export function ConversationPane({
         notificationsEnabled={notificationsEnabled}
         notificationsPermission={notificationsPermission}
         onTrace={onTrace}
+        onPathDiscovery={onPathDiscovery}
         onToggleNotifications={onToggleNotifications}
         onToggleFavorite={onToggleFavorite}
         onSetChannelFloodScopeOverride={onSetChannelFloodScopeOverride}
@@ -198,38 +247,59 @@ export function ConversationPane({
         onOpenContactInfo={onOpenContactInfo}
         onOpenChannelInfo={onOpenChannelInfo}
       />
-      <MessageList
-        key={activeConversation.id}
-        messages={messages}
-        contacts={contacts}
-        loading={messagesLoading}
-        loadingOlder={loadingOlder}
-        hasOlderMessages={hasOlderMessages}
-        onSenderClick={activeConversation.type === 'channel' ? onSenderClick : undefined}
-        onLoadOlder={onLoadOlder}
-        onResendChannelMessage={
-          activeConversation.type === 'channel' ? onResendChannelMessage : undefined
-        }
-        radioName={config?.name}
-        config={config}
-        onOpenContactInfo={onOpenContactInfo}
-        targetMessageId={targetMessageId}
-        onTargetReached={onTargetReached}
-        hasNewerMessages={hasNewerMessages}
-        loadingNewer={loadingNewer}
-        onLoadNewer={onLoadNewer}
-        onJumpToBottom={onJumpToBottom}
-      />
-      <MessageInput
-        ref={messageInputRef}
-        onSend={onSendMessage}
-        disabled={!health?.radio_connected}
-        conversationType={activeConversation.type}
-        senderName={config?.name}
-        placeholder={
-          !health?.radio_connected ? 'Radio not connected' : `Message ${activeConversation.name}...`
-        }
-      />
+      {activeConversation.type === 'contact' && isPrefixOnlyActiveContact && (
+        <ContactResolutionBanner variant="prefix-only" />
+      )}
+      {activeConversation.type === 'contact' && isUnknownFullKeyActiveContact && (
+        <ContactResolutionBanner variant="unknown-full-key" />
+      )}
+      {activeContactIsRoom && activeContact && (
+        <RoomServerPanel contact={activeContact} onAuthenticatedChange={setRoomAuthenticated} />
+      )}
+      {showRoomChat && (
+        <MessageList
+          key={activeConversation.id}
+          messages={messages}
+          contacts={contacts}
+          loading={messagesLoading}
+          loadingOlder={loadingOlder}
+          hasOlderMessages={hasOlderMessages}
+          unreadMarkerLastReadAt={
+            activeConversation.type === 'channel' ? unreadMarkerLastReadAt : undefined
+          }
+          onDismissUnreadMarker={
+            activeConversation.type === 'channel' ? onDismissUnreadMarker : undefined
+          }
+          onSenderClick={activeConversation.type === 'channel' ? onSenderClick : undefined}
+          onLoadOlder={onLoadOlder}
+          onResendChannelMessage={
+            activeConversation.type === 'channel' ? onResendChannelMessage : undefined
+          }
+          radioName={config?.name}
+          config={config}
+          onOpenContactInfo={onOpenContactInfo}
+          targetMessageId={targetMessageId}
+          onTargetReached={onTargetReached}
+          hasNewerMessages={hasNewerMessages}
+          loadingNewer={loadingNewer}
+          onLoadNewer={onLoadNewer}
+          onJumpToBottom={onJumpToBottom}
+        />
+      )}
+      {showRoomChat && !(activeConversation.type === 'contact' && isPrefixOnlyActiveContact) ? (
+        <MessageInput
+          ref={messageInputRef}
+          onSend={onSendMessage}
+          disabled={!health?.radio_connected}
+          conversationType={activeConversation.type}
+          senderName={config?.name}
+          placeholder={
+            !health?.radio_connected
+              ? 'Radio not connected'
+              : `Message ${activeConversation.name}...`
+          }
+        />
+      ) : null}
     </>
   );
 }

frontend/src/components/DirectTraceIcon.tsx

@@ -0,0 +1,22 @@
+interface DirectTraceIconProps {
+  className?: string;
+}
+
+export function DirectTraceIcon({ className }: DirectTraceIconProps) {
+  return (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      className={className}
+      aria-hidden="true"
+    >
+      <path d="M3 12h12" />
+      <circle cx="18" cy="12" r="3" />
+    </svg>
+  );
+}

frontend/src/components/MapView.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState, useMemo, useRef, useCallback } from 'react';
+import { Fragment, useEffect, useState, useMemo, useRef, useCallback } from 'react';
 import { MapContainer, TileLayer, CircleMarker, Popup, useMap } from 'react-leaflet';
 import type { LatLngBoundsExpression, CircleMarker as LeafletCircleMarker } from 'leaflet';
 import 'leaflet/dist/leaflet.css';
@@ -13,17 +13,27 @@ interface MapViewProps {
   focusedKey?: string | null;
 }
 
+const MAP_RECENCY_COLORS = {
+  recent: '#06b6d4',
+  today: '#2563eb',
+  stale: '#f59e0b',
+  old: '#64748b',
+} as const;
+const MAP_MARKER_STROKE = '#0f172a';
+const MAP_REPEATER_RING = '#f8fafc';
+
 // Calculate marker color based on how recently the contact was heard
-function getMarkerColor(lastSeen: number): string {
+function getMarkerColor(lastSeen: number | null | undefined): string {
+  if (lastSeen == null) return MAP_RECENCY_COLORS.old;
   const now = Date.now() / 1000;
   const age = now - lastSeen;
   const hour = 3600;
   const day = 86400;
 
-  if (age < hour) return '#22c55e'; // Bright green - less than 1 hour
-  if (age < day) return '#4ade80'; // Light green - less than 1 day
-  if (age < 3 * day) return '#a3e635'; // Yellow-green - less than 3 days
-  return '#9ca3af'; // Gray - older (up to 7 days)
+  if (age < hour) return MAP_RECENCY_COLORS.recent;
+  if (age < day) return MAP_RECENCY_COLORS.today;
+  if (age < 3 * day) return MAP_RECENCY_COLORS.stale;
+  return MAP_RECENCY_COLORS.old;
 }
 
 // Component to handle map bounds fitting
@@ -94,16 +104,17 @@ function MapBoundsHandler({
 }
 
 export function MapView({ contacts, focusedKey }: MapViewProps) {
+  const [sevenDaysAgo] = useState(() => Date.now() / 1000 - 7 * 24 * 60 * 60);
+
   // 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.public_key === focusedKey || (c.last_seen != null && c.last_seen > sevenDaysAgo))
     );
-  }, [contacts, focusedKey]);
+  }, [contacts, focusedKey, sevenDaysAgo]);
 
   // Find the focused contact by key
   const focusedContact = useMemo(() => {
@@ -111,6 +122,10 @@ export function MapView({ contacts, focusedKey }: MapViewProps) {
     return mappableContacts.find((c) => c.public_key === focusedKey) || null;
   }, [focusedKey, mappableContacts]);
 
+  const includesFocusedOutsideWindow =
+    focusedContact != null &&
+    (focusedContact.last_seen == null || focusedContact.last_seen <= sevenDaysAgo);
+
   // Track marker refs to open popup programmatically
   const markerRefs = useRef<Record<string, LeafletCircleMarker | null>>({});
 
@@ -137,19 +152,48 @@ export function MapView({ contacts, focusedKey }: MapViewProps) {
         <span>
           Showing {mappableContacts.length} contact{mappableContacts.length !== 1 ? 's' : ''} heard
           in the last 7 days
+          {includesFocusedOutsideWindow ? ' plus the focused contact' : ''}
         </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]" aria-hidden="true" /> &lt;1h
+            <span
+              className="w-3 h-3 rounded-full"
+              style={{ backgroundColor: MAP_RECENCY_COLORS.recent }}
+              aria-hidden="true"
+            />{' '}
+            &lt;1h
           </span>
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#4ade80]" aria-hidden="true" /> &lt;1d
+            <span
+              className="w-3 h-3 rounded-full"
+              style={{ backgroundColor: MAP_RECENCY_COLORS.today }}
+              aria-hidden="true"
+            />{' '}
+            &lt;1d
           </span>
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#a3e635]" aria-hidden="true" /> &lt;3d
+            <span
+              className="w-3 h-3 rounded-full"
+              style={{ backgroundColor: MAP_RECENCY_COLORS.stale }}
+              aria-hidden="true"
+            />{' '}
+            &lt;3d
           </span>
           <span className="flex items-center gap-1">
-            <span className="w-3 h-3 rounded-full bg-[#9ca3af]" aria-hidden="true" /> older
+            <span
+              className="w-3 h-3 rounded-full"
+              style={{ backgroundColor: MAP_RECENCY_COLORS.old }}
+              aria-hidden="true"
+            />{' '}
+            older
+          </span>
+          <span className="flex items-center gap-1">
+            <span
+              className="w-3 h-3 rounded-full border-2"
+              style={{ borderColor: MAP_REPEATER_RING, backgroundColor: MAP_RECENCY_COLORS.today }}
+              aria-hidden="true"
+            />{' '}
+            repeater
           </span>
         </div>
       </div>
@@ -175,41 +219,46 @@ export function MapView({ contacts, focusedKey }: MapViewProps) {
 
           {mappableContacts.map((contact) => {
             const isRepeater = contact.type === CONTACT_TYPE_REPEATER;
-            const color = getMarkerColor(contact.last_seen!);
+            const color = getMarkerColor(contact.last_seen);
             const displayName = contact.name || contact.public_key.slice(0, 12);
+            const lastHeardLabel =
+              contact.last_seen != null
+                ? formatTime(contact.last_seen)
+                : 'Never heard by this server';
+            const radius = isRepeater ? 10 : 7;
 
             return (
-              <CircleMarker
-                key={contact.public_key}
-                ref={(ref) => setMarkerRef(contact.public_key, ref)}
-                center={[contact.lat!, contact.lon!]}
-                radius={isRepeater ? 10 : 7}
-                pathOptions={{
-                  color: isRepeater ? color : '#000',
-                  fillColor: color,
-                  fillOpacity: 0.8,
-                  weight: isRepeater ? 0 : 1,
-                }}
-              >
-                <Popup>
-                  <div className="text-sm">
-                    <div className="font-medium flex items-center gap-1">
-                      {isRepeater && (
-                        <span title="Repeater" aria-hidden="true">
-                          🛜
-                        </span>
-                      )}
-                      {displayName}
+              <Fragment key={contact.public_key}>
+                <CircleMarker
+                  key={contact.public_key}
+                  ref={(ref) => setMarkerRef(contact.public_key, ref)}
+                  center={[contact.lat!, contact.lon!]}
+                  radius={radius}
+                  pathOptions={{
+                    color: isRepeater ? MAP_REPEATER_RING : MAP_MARKER_STROKE,
+                    fillColor: color,
+                    fillOpacity: 0.9,
+                    weight: isRepeater ? 3 : 2,
+                  }}
+                >
+                  <Popup>
+                    <div className="text-sm">
+                      <div className="font-medium flex items-center gap-1">
+                        {isRepeater && (
+                          <span title="Repeater" aria-hidden="true">
+                            🛜
+                          </span>
+                        )}
+                        {displayName}
+                      </div>
+                      <div className="text-xs text-gray-500 mt-1">Last heard: {lastHeardLabel}</div>
+                      <div className="text-xs text-gray-400 mt-1 font-mono">
+                        {contact.lat!.toFixed(5)}, {contact.lon!.toFixed(5)}
+                      </div>
                     </div>
-                    <div className="text-xs text-gray-500 mt-1">
-                      Last heard: {formatTime(contact.last_seen!)}
-                    </div>
-                    <div className="text-xs text-gray-400 mt-1 font-mono">
-                      {contact.lat!.toFixed(5)}, {contact.lon!.toFixed(5)}
-                    </div>
-                  </div>
-                </Popup>
-              </CircleMarker>
+                  </Popup>
+                </CircleMarker>
+              </Fragment>
             );
           })}
         </MapContainer>

frontend/src/components/MessageInput.tsx

@@ -24,6 +24,7 @@ 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();
+const RADIO_NO_RESPONSE_SNIPPET = 'no response was heard back';
 /** 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;
@@ -118,8 +119,11 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
         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',
+        const description = err instanceof Error ? err.message : 'Check radio connection';
+        const isRadioNoResponse =
+          err instanceof Error && err.message.toLowerCase().includes(RADIO_NO_RESPONSE_SNIPPET);
+        toast.error(isRadioNoResponse ? 'Radio did not confirm send' : 'Failed to send message', {
+          description,
         });
         return;
       } finally {
@@ -150,7 +154,7 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
 
   return (
     <form
-      className="px-4 py-2.5 border-t border-border flex flex-col gap-1"
+      className="message-input-shell px-4 py-2.5 border-t border-border flex flex-col gap-1"
       onSubmit={handleSubmit}
       autoComplete="off"
     >

frontend/src/components/MessageList.tsx

@@ -1,4 +1,5 @@
 import {
+  Fragment,
   useEffect,
   useLayoutEffect,
   useRef,
@@ -8,9 +9,10 @@ import {
   type ReactNode,
 } from 'react';
 import type { Contact, Message, MessagePath, RadioConfig } from '../types';
-import { CONTACT_TYPE_REPEATER } from '../types';
+import { CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM } from '../types';
 import { formatTime, parseSenderFromText } from '../utils/messageParser';
 import { formatHopCounts, type SenderInfo } from '../utils/pathUtils';
+import { getDirectContactRoute } from '../utils/pathUtils';
 import { ContactAvatar } from './ContactAvatar';
 import { PathModal } from './PathModal';
 import { handleKeyboardActivate } from '../utils/a11y';
@@ -22,6 +24,8 @@ interface MessageListProps {
   loading: boolean;
   loadingOlder?: boolean;
   hasOlderMessages?: boolean;
+  unreadMarkerLastReadAt?: number | null;
+  onDismissUnreadMarker?: () => void;
   onSenderClick?: (sender: string) => void;
   onLoadOlder?: () => void;
   onResendChannelMessage?: (messageId: number, newTimestamp?: boolean) => void;
@@ -172,6 +176,8 @@ export function MessageList({
   loading,
   loadingOlder = false,
   hasOlderMessages = false,
+  unreadMarkerLastReadAt,
+  onDismissUnreadMarker,
   onSenderClick,
   onLoadOlder,
   onResendChannelMessage,
@@ -198,7 +204,10 @@ export function MessageList({
   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 [showJumpToUnread, setShowJumpToUnread] = useState(false);
+  const [jumpToUnreadDismissed, setJumpToUnreadDismissed] = useState(false);
   const targetScrolledRef = useRef(false);
+  const unreadMarkerRef = useRef<HTMLButtonElement | HTMLDivElement | null>(null);
 
   // Capture scroll state in the scroll handler BEFORE any state updates
   const scrollStateRef = useRef({
@@ -320,6 +329,57 @@ export function MessageList({
     };
   }, [messages, onResendChannelMessage]);
 
+  // Sort messages by received_at ascending (oldest first)
+  // Note: Deduplication is handled by useConversationMessages.observeMessage()
+  // 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 || a.id - b.id),
+    [messages]
+  );
+  const unreadMarkerIndex = useMemo(() => {
+    if (unreadMarkerLastReadAt === undefined) {
+      return -1;
+    }
+
+    const boundary = unreadMarkerLastReadAt ?? 0;
+    return sortedMessages.findIndex((msg) => !msg.outgoing && msg.received_at > boundary);
+  }, [sortedMessages, unreadMarkerLastReadAt]);
+
+  const syncJumpToUnreadVisibility = useCallback(() => {
+    if (unreadMarkerIndex === -1 || jumpToUnreadDismissed) {
+      setShowJumpToUnread(false);
+      return;
+    }
+
+    const marker = unreadMarkerRef.current;
+    const list = listRef.current;
+    if (!marker || !list) {
+      setShowJumpToUnread(true);
+      return;
+    }
+
+    const markerRect = marker.getBoundingClientRect();
+    const listRect = list.getBoundingClientRect();
+
+    if (
+      markerRect.width === 0 ||
+      markerRect.height === 0 ||
+      listRect.width === 0 ||
+      listRect.height === 0
+    ) {
+      setShowJumpToUnread(true);
+      return;
+    }
+
+    const markerVisible =
+      markerRect.top >= listRect.top &&
+      markerRect.bottom <= listRect.bottom &&
+      markerRect.left >= listRect.left &&
+      markerRect.right <= listRect.right;
+
+    setShowJumpToUnread(!markerVisible);
+  }, [jumpToUnreadDismissed, unreadMarkerIndex]);
+
   // Refs for scroll handler to read without causing callback recreation
   const onLoadOlderRef = useRef(onLoadOlder);
   const loadingOlderRef = useRef(loadingOlder);
@@ -334,6 +394,22 @@ export function MessageList({
   loadingNewerRef.current = loadingNewer;
   hasNewerMessagesRef.current = hasNewerMessages;
 
+  const setUnreadMarkerElement = useCallback(
+    (node: HTMLButtonElement | HTMLDivElement | null) => {
+      unreadMarkerRef.current = node;
+      syncJumpToUnreadVisibility();
+    },
+    [syncJumpToUnreadVisibility]
+  );
+
+  useEffect(() => {
+    setJumpToUnreadDismissed(false);
+  }, [unreadMarkerIndex]);
+
+  useLayoutEffect(() => {
+    syncJumpToUnreadVisibility();
+  }, [messages, syncJumpToUnreadVisibility]);
+
   // Handle scroll - capture state and detect when user is near top/bottom
   // Stable callback: reads changing values from refs, never recreated.
   const handleScroll = useCallback(() => {
@@ -342,7 +418,6 @@ export function MessageList({
     const { scrollTop, scrollHeight, clientHeight } = listRef.current;
     const distanceFromBottom = scrollHeight - scrollTop - clientHeight;
 
-    // Always capture current scroll state (needed for scroll preservation)
     scrollStateRef.current = {
       scrollTop,
       scrollHeight,
@@ -351,7 +426,6 @@ export function MessageList({
       wasNearBottom: distanceFromBottom < 100,
     };
 
-    // Show scroll-to-bottom button when not near the bottom (more than 100px away)
     setShowScrollToBottom(distanceFromBottom > 100);
 
     if (!onLoadOlderRef.current || loadingOlderRef.current || !hasOlderMessagesRef.current) {
@@ -360,7 +434,6 @@ export function MessageList({
       onLoadOlderRef.current();
     }
 
-    // Trigger load newer when within 100px of bottom
     if (
       onLoadNewerRef.current &&
       !loadingNewerRef.current &&
@@ -369,7 +442,8 @@ export function MessageList({
     ) {
       onLoadNewerRef.current();
     }
-  }, []);
+    syncJumpToUnreadVisibility();
+  }, [syncJumpToUnreadVisibility]);
 
   // Scroll to bottom handler (or jump to bottom if viewing historical messages)
   const scrollToBottom = useCallback(() => {
@@ -382,14 +456,6 @@ export function MessageList({
     }
   }, [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 || a.id - b.id),
-    [messages]
-  );
-
   // Sender info for outgoing messages (used by path modal on own messages)
   const selfSenderInfo = useMemo<SenderInfo>(
     () => ({
@@ -434,13 +500,41 @@ export function MessageList({
     contact: Contact | null,
     parsedSender: string | null
   ): SenderInfo => {
+    if (
+      msg.type === 'PRIV' &&
+      contact?.type === CONTACT_TYPE_ROOM &&
+      (msg.sender_key || msg.sender_name)
+    ) {
+      const authorContact =
+        (msg.sender_key
+          ? contacts.find((candidate) => candidate.public_key === msg.sender_key)
+          : null) || (msg.sender_name ? getContactByName(msg.sender_name) : null);
+      if (authorContact) {
+        const directRoute = getDirectContactRoute(authorContact);
+        return {
+          name: authorContact.name || msg.sender_name || authorContact.public_key.slice(0, 12),
+          publicKeyOrPrefix: authorContact.public_key,
+          lat: authorContact.lat,
+          lon: authorContact.lon,
+          pathHashMode: directRoute?.path_hash_mode ?? null,
+        };
+      }
+      return {
+        name: msg.sender_name || msg.sender_key || 'Unknown',
+        publicKeyOrPrefix: msg.sender_key || '',
+        lat: null,
+        lon: null,
+        pathHashMode: null,
+      };
+    }
     if (msg.type === 'PRIV' && contact) {
+      const directRoute = getDirectContactRoute(contact);
       return {
         name: contact.name || contact.public_key.slice(0, 12),
         publicKeyOrPrefix: contact.public_key,
         lat: contact.lat,
         lon: contact.lon,
-        pathHashMode: contact.out_path_hash_mode,
+        pathHashMode: directRoute?.path_hash_mode ?? null,
       };
     }
     if (msg.type === 'CHAN') {
@@ -450,12 +544,13 @@ export function MessageList({
           ? contacts.find((candidate) => candidate.public_key === msg.sender_key)
           : null) || (senderName ? getContactByName(senderName) : null);
       if (senderContact) {
+        const directRoute = getDirectContactRoute(senderContact);
         return {
           name: senderContact.name || senderName || senderContact.public_key.slice(0, 12),
           publicKeyOrPrefix: senderContact.public_key,
           lat: senderContact.lat,
           lon: senderContact.lon,
-          pathHashMode: senderContact.out_path_hash_mode,
+          pathHashMode: directRoute?.path_hash_mode ?? null,
         };
       }
       if (senderName || msg.sender_key) {
@@ -473,12 +568,13 @@ export function MessageList({
     if (parsedSender) {
       const senderContact = getContactByName(parsedSender);
       if (senderContact) {
+        const directRoute = getDirectContactRoute(senderContact);
         return {
           name: parsedSender,
           publicKeyOrPrefix: senderContact.public_key,
           lat: senderContact.lat,
           lon: senderContact.lon,
-          pathHashMode: senderContact.out_path_hash_mode,
+          pathHashMode: directRoute?.path_hash_mode ?? null,
         };
       }
     }
@@ -515,6 +611,8 @@ export function MessageList({
     isCorruptChannelMessage: boolean
   ): string => {
     if (msg.outgoing) return '__outgoing__';
+    if (msg.type === 'PRIV' && msg.sender_key) return `key:${msg.sender_key}`;
+    if (msg.type === 'PRIV' && senderName) return `name:${senderName}`;
     if (msg.type === 'PRIV' && msg.conversation_key) return msg.conversation_key;
     if (msg.sender_key) return `key:${msg.sender_key}`;
     if (senderName) return `name:${senderName}`;
@@ -543,18 +641,24 @@ export function MessageList({
           // 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;
+          const isRoomServer = contact?.type === CONTACT_TYPE_ROOM;
 
           // Skip sender parsing for repeater messages (CLI responses often have colons)
-          const { sender, content } = isRepeater
-            ? { sender: null, content: msg.text }
-            : parseSenderFromText(msg.text);
+          const { sender, content } =
+            isRepeater || (isRoomServer && msg.type === 'PRIV')
+              ? { sender: null, content: msg.text }
+              : parseSenderFromText(msg.text);
+          const directSenderName =
+            msg.type === 'PRIV' && isRoomServer ? msg.sender_name || null : null;
           const channelSenderName = msg.type === 'CHAN' ? msg.sender_name || sender : null;
           const channelSenderContact =
             msg.type === 'CHAN' && channelSenderName ? getContactByName(channelSenderName) : null;
           const isCorruptChannelMessage = isCorruptUnnamedChannelMessage(msg, sender);
           const displaySender = msg.outgoing
             ? 'You'
-            : contact?.name ||
+            : directSenderName ||
+              (isRoomServer && msg.sender_key ? msg.sender_key.slice(0, 8) : null) ||
+              contact?.name ||
               channelSenderName ||
               (isCorruptChannelMessage
                 ? CORRUPT_SENDER_LABEL
@@ -567,15 +671,22 @@ export function MessageList({
             displaySender !== CORRUPT_SENDER_LABEL;
 
           // Determine if we should show avatar (first message in a chunk from same sender)
-          const currentSenderKey = getSenderKey(msg, channelSenderName, isCorruptChannelMessage);
+          const currentSenderKey = getSenderKey(
+            msg,
+            directSenderName || channelSenderName,
+            isCorruptChannelMessage
+          );
           const prevMsg = sortedMessages[index - 1];
           const prevParsedSender = prevMsg ? parseSenderFromText(prevMsg.text).sender : null;
           const prevSenderKey = prevMsg
             ? getSenderKey(
                 prevMsg,
-                prevMsg.type === 'CHAN'
-                  ? prevMsg.sender_name || prevParsedSender
-                  : prevParsedSender,
+                prevMsg.type === 'PRIV' &&
+                  getContact(prevMsg.conversation_key)?.type === CONTACT_TYPE_ROOM
+                  ? prevMsg.sender_name
+                  : prevMsg.type === 'CHAN'
+                    ? prevMsg.sender_name || prevParsedSender
+                    : prevParsedSender,
                 isCorruptUnnamedChannelMessage(prevMsg, prevParsedSender)
               )
             : null;
@@ -589,9 +700,14 @@ export function MessageList({
           let avatarVariant: 'default' | 'corrupt' = 'default';
           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;
+              if (isRoomServer) {
+                avatarName = directSenderName;
+                avatarKey =
+                  msg.sender_key || (avatarName ? `name:${avatarName}` : msg.conversation_key);
+              } else {
+                avatarName = contact?.name || null;
+                avatarKey = msg.conversation_key;
+              }
             } else if (isCorruptChannelMessage) {
               avatarName = CORRUPT_SENDER_LABEL;
               avatarKey = `corrupt:${msg.id}`;
@@ -606,110 +722,173 @@ export function MessageList({
                 (avatarName ? `name:${avatarName}` : `message:${msg.id}`);
             }
           }
+          const avatarActionLabel =
+            avatarName && avatarName !== 'Unknown'
+              ? `View info for ${avatarName}`
+              : `View info for ${avatarKey.slice(0, 12)}`;
 
           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',
-                isFirstInGroup && !isFirstMessage && 'mt-3'
-              )}
-            >
-              {!msg.outgoing && (
-                <div className="w-10 flex-shrink-0 flex items-start pt-0.5">
-                  {showAvatar && avatarKey && (
-                    <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}
-                        variant={avatarVariant}
-                      />
+            <Fragment key={msg.id}>
+              {unreadMarkerIndex === index &&
+                (onDismissUnreadMarker ? (
+                  <button
+                    ref={setUnreadMarkerElement}
+                    type="button"
+                    className="my-2 flex w-full items-center gap-3 text-left text-xs font-medium text-primary transition-colors hover:text-primary/80 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                    onClick={onDismissUnreadMarker}
+                  >
+                    <span className="h-px flex-1 bg-border" />
+                    <span className="rounded-full border border-primary/30 bg-primary/10 px-3 py-1">
+                      Unread messages
                     </span>
-                  )}
-                </div>
-              )}
+                    <span className="h-px flex-1 bg-border" />
+                  </button>
+                ) : (
+                  <div
+                    ref={setUnreadMarkerElement}
+                    className="my-2 flex w-full items-center gap-3 text-xs font-medium text-primary"
+                  >
+                    <span className="h-px flex-1 bg-border" />
+                    <span className="rounded-full border border-primary/30 bg-primary/10 px-3 py-1">
+                      Unread messages
+                    </span>
+                    <span className="h-px flex-1 bg-border" />
+                  </div>
+                ))}
               <div
+                data-message-id={msg.id}
                 className={cn(
-                  'py-1.5 px-3 rounded-lg min-w-0',
-                  msg.outgoing ? 'bg-msg-outgoing' : 'bg-msg-incoming',
-                  highlightedMessageId === msg.id && 'message-highlight'
+                  'flex items-start max-w-[85%]',
+                  msg.outgoing && 'flex-row-reverse self-end',
+                  isFirstInGroup && !isFirstMessage && 'mt-3'
                 )}
               >
-                {showAvatar && (
-                  <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 && (
-                      <HopCountBadge
-                        paths={msg.paths}
-                        variant="header"
-                        onClick={() =>
-                          setSelectedPath({
-                            paths: msg.paths!,
-                            senderInfo: getSenderInfo(msg, contact, sender),
-                          })
-                        }
-                      />
-                    )}
+                {!msg.outgoing && (
+                  <div className="w-10 flex-shrink-0 flex items-start pt-0.5">
+                    {showAvatar &&
+                      avatarKey &&
+                      (onOpenContactInfo ? (
+                        <button
+                          type="button"
+                          className="avatar-action-button rounded-full border-none bg-transparent p-0 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                          aria-label={avatarActionLabel}
+                          onClick={() =>
+                            onOpenContactInfo(
+                              avatarKey,
+                              msg.type === 'CHAN' || (msg.type === 'PRIV' && isRoomServer)
+                            )
+                          }
+                        >
+                          <ContactAvatar
+                            name={avatarName}
+                            publicKey={avatarKey}
+                            size={32}
+                            clickable
+                            variant={avatarVariant}
+                          />
+                        </button>
+                      ) : (
+                        <span>
+                          <ContactAvatar
+                            name={avatarName}
+                            publicKey={avatarKey}
+                            size={32}
+                            variant={avatarVariant}
+                          />
+                        </span>
+                      ))}
                   </div>
                 )}
-                <div className="break-words whitespace-pre-wrap">
-                  {content.split('\n').map((line, i, arr) => (
-                    <span key={i}>
-                      {renderTextWithMentions(line, radioName)}
-                      {i < arr.length - 1 && <br />}
-                    </span>
-                  ))}
-                  {!showAvatar && (
-                    <>
-                      <span className="text-[10px] text-muted-foreground ml-2">
+                <div
+                  className={cn(
+                    '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="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 && (
                         <HopCountBadge
                           paths={msg.paths}
-                          variant="inline"
+                          variant="header"
                           onClick={() =>
                             setSelectedPath({
                               paths: msg.paths!,
-                              senderInfo: getSenderInfo(msg, contact, sender),
+                              senderInfo: getSenderInfo(msg, contact, directSenderName || sender),
                             })
                           }
                         />
                       )}
-                    </>
+                    </div>
                   )}
-                  {msg.outgoing &&
-                    (msg.acked > 0 ? (
-                      msg.paths && msg.paths.length > 0 ? (
+                  <div className="break-words whitespace-pre-wrap">
+                    {content.split('\n').map((line, i, arr) => (
+                      <span key={i}>
+                        {renderTextWithMentions(line, radioName)}
+                        {i < arr.length - 1 && <br />}
+                      </span>
+                    ))}
+                    {!showAvatar && (
+                      <>
+                        <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 && (
+                          <HopCountBadge
+                            paths={msg.paths}
+                            variant="inline"
+                            onClick={() =>
+                              setSelectedPath({
+                                paths: msg.paths!,
+                                senderInfo: getSenderInfo(msg, contact, directSenderName || sender),
+                              })
+                            }
+                          />
+                        )}
+                      </>
+                    )}
+                    {msg.outgoing &&
+                      (msg.acked > 0 ? (
+                        msg.paths && msg.paths.length > 0 ? (
+                          <span
+                            className="text-muted-foreground cursor-pointer hover:text-primary"
+                            role="button"
+                            tabIndex={0}
+                            onKeyDown={handleKeyboardActivate}
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              setSelectedPath({
+                                paths: msg.paths!,
+                                senderInfo: selfSenderInfo,
+                                messageId: msg.id,
+                                isOutgoingChan: msg.type === 'CHAN' && !!onResendChannelMessage,
+                              });
+                            }}
+                            title="View echo paths"
+                            aria-label={`Acknowledged, ${msg.acked} echo${msg.acked !== 1 ? 's' : ''} — view paths`}
+                          >{` ✓${msg.acked > 1 ? msg.acked : ''}`}</span>
+                        ) : (
+                          <span className="text-muted-foreground">{` ✓${msg.acked > 1 ? msg.acked : ''}`}</span>
+                        )
+                      ) : onResendChannelMessage && msg.type === 'CHAN' ? (
                         <span
                           className="text-muted-foreground cursor-pointer hover:text-primary"
                           role="button"
@@ -718,48 +897,28 @@ export function MessageList({
                           onClick={(e) => {
                             e.stopPropagation();
                             setSelectedPath({
-                              paths: msg.paths!,
+                              paths: [],
                               senderInfo: selfSenderInfo,
                               messageId: msg.id,
-                              isOutgoingChan: msg.type === 'CHAN' && !!onResendChannelMessage,
+                              isOutgoingChan: true,
                             });
                           }}
-                          title="View echo paths"
-                          aria-label={`Acknowledged, ${msg.acked} echo${msg.acked !== 1 ? 's' : ''} — view paths`}
-                        >{` ✓${msg.acked > 1 ? msg.acked : ''}`}</span>
+                          title="Message status"
+                          aria-label="No echoes yet — view message status"
+                        >
+                          {' '}
+                          ?
+                        </span>
                       ) : (
-                        <span className="text-muted-foreground">{` ✓${msg.acked > 1 ? msg.acked : ''}`}</span>
-                      )
-                    ) : onResendChannelMessage && msg.type === 'CHAN' ? (
-                      <span
-                        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>
-                    ))}
+                        <span className="text-muted-foreground" title="No repeats heard yet">
+                          {' '}
+                          ?
+                        </span>
+                      ))}
+                  </div>
                 </div>
               </div>
-            </div>
+            </Fragment>
           );
         })}
         {loadingNewer && (
@@ -775,6 +934,35 @@ export function MessageList({
       </div>
 
       {/* Scroll to bottom button */}
+      {showJumpToUnread && (
+        <div className="pointer-events-none absolute bottom-4 left-1/2 -translate-x-1/2">
+          <div className="pointer-events-auto flex h-9 items-center overflow-hidden rounded-full border border-border bg-card shadow-lg transition-all hover:scale-105">
+            <button
+              type="button"
+              onClick={() => {
+                unreadMarkerRef.current?.scrollIntoView?.({ block: 'center' });
+                setJumpToUnreadDismissed(true);
+                setShowJumpToUnread(false);
+              }}
+              className="h-full px-3 text-sm font-medium hover:bg-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            >
+              Jump to unread
+            </button>
+            <button
+              type="button"
+              onClick={() => {
+                setJumpToUnreadDismissed(true);
+                setShowJumpToUnread(false);
+              }}
+              className="flex h-full w-9 items-center justify-center border-l border-border text-muted-foreground hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              aria-label="Dismiss jump to unread"
+              title="Dismiss jump to unread"
+            >
+              ×
+            </button>
+          </div>
+        </div>
+      )}
       {showScrollToBottom && (
         <button
           onClick={scrollToBottom}

frontend/src/components/NewMessageModal.tsx

@@ -15,6 +15,7 @@ import { Input } from './ui/input';
 import { Label } from './ui/label';
 import { Checkbox } from './ui/checkbox';
 import { Button } from './ui/button';
+import { toast } from './ui/sonner';
 
 type Tab = 'existing' | 'new-contact' | 'new-room' | 'hashtag';
 
@@ -90,6 +91,9 @@ export function NewMessageModal({
       resetForm();
       onClose();
     } catch (err) {
+      toast.error('Failed to create conversation', {
+        description: err instanceof Error ? err.message : undefined,
+      });
       setError(err instanceof Error ? err.message : 'Failed to create');
     } finally {
       setLoading(false);
@@ -123,6 +127,9 @@ export function NewMessageModal({
       setName('');
       hashtagInputRef.current?.focus();
     } catch (err) {
+      toast.error('Failed to create conversation', {
+        description: err instanceof Error ? err.message : undefined,
+      });
       setError(err instanceof Error ? err.message : 'Failed to create');
     } finally {
       setLoading(false);
@@ -169,34 +176,40 @@ export function NewMessageModal({
 
           <TabsContent value="existing" className="mt-4">
             <div className="max-h-[300px] overflow-y-auto rounded-md border">
-              {contacts.length === 0 ? (
+              {contacts.filter((contact) => contact.public_key.length === 64).length === 0 ? (
                 <div className="p-4 text-center text-muted-foreground">No contacts available</div>
               ) : (
-                contacts.map((contact) => (
-                  <div
-                    key={contact.public_key}
-                    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();
-                    }}
-                  >
-                    {getContactDisplayName(contact.name, contact.public_key)}
-                  </div>
-                ))
+                contacts
+                  .filter((contact) => contact.public_key.length === 64)
+                  .map((contact) => (
+                    <div
+                      key={contact.public_key}
+                      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,
+                            contact.last_advert
+                          ),
+                        });
+                        resetForm();
+                        onClose();
+                      }}
+                    >
+                      {getContactDisplayName(contact.name, contact.public_key, contact.last_advert)}
+                    </div>
+                  ))
               )}
             </div>
           </TabsContent>

frontend/src/components/PacketVisualizer3D.tsx

@@ -29,6 +29,9 @@ export function PacketVisualizer3D({
   const [showAmbiguousPaths, setShowAmbiguousPaths] = useState(savedSettings.showAmbiguousPaths);
   const [showAmbiguousNodes, setShowAmbiguousNodes] = useState(savedSettings.showAmbiguousNodes);
   const [useAdvertPathHints, setUseAdvertPathHints] = useState(savedSettings.useAdvertPathHints);
+  const [collapseLikelyKnownSiblingRepeaters, setCollapseLikelyKnownSiblingRepeaters] = useState(
+    savedSettings.collapseLikelyKnownSiblingRepeaters
+  );
   const [splitAmbiguousByTraffic, setSplitAmbiguousByTraffic] = useState(
     savedSettings.splitAmbiguousByTraffic
   );
@@ -52,6 +55,7 @@ export function PacketVisualizer3D({
       showAmbiguousPaths,
       showAmbiguousNodes,
       useAdvertPathHints,
+      collapseLikelyKnownSiblingRepeaters,
       splitAmbiguousByTraffic,
       chargeStrength,
       observationWindowSec,
@@ -66,6 +70,7 @@ export function PacketVisualizer3D({
     showAmbiguousPaths,
     showAmbiguousNodes,
     useAdvertPathHints,
+    collapseLikelyKnownSiblingRepeaters,
     splitAmbiguousByTraffic,
     chargeStrength,
     observationWindowSec,
@@ -108,6 +113,7 @@ export function PacketVisualizer3D({
     showAmbiguousPaths,
     showAmbiguousNodes,
     useAdvertPathHints,
+    collapseLikelyKnownSiblingRepeaters,
     splitAmbiguousByTraffic,
     chargeStrength,
     letEmDrift,
@@ -117,7 +123,7 @@ export function PacketVisualizer3D({
     pruneStaleMinutes,
   });
 
-  const { hoveredNodeId, hoveredNeighborIds, pinnedNodeId } = useVisualizer3DScene({
+  const { hoveredNodeId, pinnedNodeId } = useVisualizer3DScene({
     containerRef,
     data,
     autoOrbit,
@@ -143,6 +149,8 @@ export function PacketVisualizer3D({
         setShowAmbiguousNodes={setShowAmbiguousNodes}
         useAdvertPathHints={useAdvertPathHints}
         setUseAdvertPathHints={setUseAdvertPathHints}
+        collapseLikelyKnownSiblingRepeaters={collapseLikelyKnownSiblingRepeaters}
+        setCollapseLikelyKnownSiblingRepeaters={setCollapseLikelyKnownSiblingRepeaters}
         splitAmbiguousByTraffic={splitAmbiguousByTraffic}
         setSplitAmbiguousByTraffic={setSplitAmbiguousByTraffic}
         observationWindowSec={observationWindowSec}
@@ -167,8 +175,9 @@ export function PacketVisualizer3D({
 
       <VisualizerTooltip
         activeNodeId={tooltipNodeId}
-        nodes={data.nodes}
-        neighborIds={hoveredNeighborIds}
+        canonicalNodes={data.canonicalNodes}
+        canonicalNeighborIds={data.canonicalNeighborIds}
+        renderedNodeIds={data.renderedNodeIds}
       />
     </div>
   );

frontend/src/components/PathModal.tsx

@@ -14,6 +14,8 @@ import {
 } from '../utils/pathUtils';
 import { formatTime } from '../utils/messageParser';
 import { getMapFocusHash } from '../utils/urlHash';
+import { useDistanceUnit } from '../contexts/DistanceUnitContext';
+import type { DistanceUnit } from '../utils/distanceUnits';
 
 const PathRouteMap = lazy(() =>
   import('./PathRouteMap').then((m) => ({ default: m.PathRouteMap }))
@@ -44,6 +46,7 @@ export function PathModal({
   isResendable,
   onResend,
 }: PathModalProps) {
+  const { distanceUnit } = useDistanceUnit();
   const [expandedMaps, setExpandedMaps] = useState<Set<number>>(new Set());
   const hasResendActions = isOutgoingChan && messageId !== undefined && onResend;
   const hasPaths = paths.length > 0;
@@ -120,7 +123,8 @@ export function PathModal({
                         resolvedPaths[0].resolved.sender.lon,
                         resolvedPaths[0].resolved.receiver.lat,
                         resolvedPaths[0].resolved.receiver.lon
-                      )!
+                      )!,
+                      distanceUnit
                     )}
                   </span>
                 </div>
@@ -171,7 +175,11 @@ export function PathModal({
                       </Suspense>
                     </div>
                   )}
-                  <PathVisualization resolved={pathData.resolved} senderInfo={senderInfo} />
+                  <PathVisualization
+                    resolved={pathData.resolved}
+                    senderInfo={senderInfo}
+                    distanceUnit={distanceUnit}
+                  />
                 </div>
               );
             })}
@@ -227,9 +235,10 @@ export function PathModal({
 interface PathVisualizationProps {
   resolved: ResolvedPath;
   senderInfo: SenderInfo;
+  distanceUnit: DistanceUnit;
 }
 
-function PathVisualization({ resolved, senderInfo }: PathVisualizationProps) {
+function PathVisualization({ resolved, senderInfo, distanceUnit }: PathVisualizationProps) {
   // Track previous location for each hop to calculate distances
   // Returns null if previous hop was ambiguous or has invalid location
   const getPrevLocation = (hopIndex: number): { lat: number | null; lon: number | null } | null => {
@@ -264,6 +273,7 @@ function PathVisualization({ resolved, senderInfo }: PathVisualizationProps) {
         name={resolved.sender.name}
         prefix={resolved.sender.prefix}
         distance={null}
+        distanceUnit={distanceUnit}
         isFirst
         lat={resolved.sender.lat}
         lon={resolved.sender.lon}
@@ -277,6 +287,7 @@ function PathVisualization({ resolved, senderInfo }: PathVisualizationProps) {
           hop={hop}
           hopNumber={index + 1}
           prevLocation={getPrevLocation(index)}
+          distanceUnit={distanceUnit}
         />
       ))}
 
@@ -286,6 +297,7 @@ function PathVisualization({ resolved, senderInfo }: PathVisualizationProps) {
         name={resolved.receiver.name}
         prefix={resolved.receiver.prefix}
         distance={calculateReceiverDistance(resolved)}
+        distanceUnit={distanceUnit}
         isLast
         lat={resolved.receiver.lat}
         lon={resolved.receiver.lon}
@@ -300,7 +312,7 @@ function PathVisualization({ resolved, senderInfo }: PathVisualizationProps) {
           </span>
           <span className="text-sm font-medium">
             {resolved.hasGaps ? '>' : ''}
-            {formatDistance(resolved.totalDistances[0])}
+            {formatDistance(resolved.totalDistances[0], distanceUnit)}
           </span>
         </div>
       )}
@@ -313,6 +325,7 @@ interface PathNodeProps {
   name: string;
   prefix: string;
   distance: number | null;
+  distanceUnit: DistanceUnit;
   isFirst?: boolean;
   isLast?: boolean;
   /** Optional coordinates for map link */
@@ -327,6 +340,7 @@ function PathNode({
   name,
   prefix,
   distance,
+  distanceUnit,
   isFirst,
   isLast,
   lat,
@@ -353,7 +367,9 @@ function PathNode({
         <div className="font-medium truncate">
           {name}
           {distance !== null && (
-            <span className="text-xs text-muted-foreground ml-1">- {formatDistance(distance)}</span>
+            <span className="text-xs text-muted-foreground ml-1">
+              - {formatDistance(distance, distanceUnit)}
+            </span>
           )}
           {hasLocation && <CoordinateLink lat={lat!} lon={lon!} publicKey={publicKey!} />}
         </div>
@@ -366,9 +382,10 @@ interface HopNodeProps {
   hop: PathHop;
   hopNumber: number;
   prevLocation: { lat: number | null; lon: number | null } | null;
+  distanceUnit: DistanceUnit;
 }
 
-function HopNode({ hop, hopNumber, prevLocation }: HopNodeProps) {
+function HopNode({ hop, hopNumber, prevLocation, distanceUnit }: HopNodeProps) {
   const isAmbiguous = hop.matches.length > 1;
   const isUnknown = hop.matches.length === 0;
 
@@ -417,7 +434,7 @@ function HopNode({ hop, hopNumber, prevLocation }: HopNodeProps) {
                   {contact.name || contact.public_key.slice(0, 12)}
                   {dist !== null && (
                     <span className="text-xs text-muted-foreground ml-1">
-                      - {formatDistance(dist)}
+                      - {formatDistance(dist, distanceUnit)}
                     </span>
                   )}
                   {hasLocation && (
@@ -436,7 +453,7 @@ function HopNode({ hop, hopNumber, prevLocation }: HopNodeProps) {
             {hop.matches[0].name || hop.matches[0].public_key.slice(0, 12)}
             {hop.distanceFromPrev !== null && (
               <span className="text-xs text-muted-foreground ml-1">
-                - {formatDistance(hop.distanceFromPrev)}
+                - {formatDistance(hop.distanceFromPrev, distanceUnit)}
               </span>
             )}
             {isValidLocation(hop.matches[0].lat, hop.matches[0].lon) && (

frontend/src/components/RawPacketDetailModal.tsx

@@ -0,0 +1,644 @@
+import { useMemo, useState } from 'react';
+import { ChannelCrypto, PayloadType } from '@michaelhart/meshcore-decoder';
+
+import type { Channel, RawPacket } from '../types';
+import { cn } from '@/lib/utils';
+import {
+  createDecoderOptions,
+  inspectRawPacketWithOptions,
+  type PacketByteField,
+} from '../utils/rawPacketInspector';
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from './ui/dialog';
+
+interface RawPacketDetailModalProps {
+  packet: RawPacket | null;
+  channels: Channel[];
+  onClose: () => void;
+}
+
+interface FieldPaletteEntry {
+  box: string;
+  boxActive: string;
+  hex: string;
+  hexActive: string;
+}
+
+interface GroupTextResolutionCandidate {
+  key: string;
+  name: string;
+  hash: string;
+}
+
+const FIELD_PALETTE: FieldPaletteEntry[] = [
+  {
+    box: 'border-sky-500/30 bg-sky-500/10',
+    boxActive: 'border-sky-600 bg-sky-500/20 shadow-sm shadow-sky-500/20',
+    hex: 'bg-sky-500/20 ring-1 ring-inset ring-sky-500/35',
+    hexActive: 'bg-sky-500/40 ring-1 ring-inset ring-sky-600/70',
+  },
+  {
+    box: 'border-emerald-500/30 bg-emerald-500/10',
+    boxActive: 'border-emerald-600 bg-emerald-500/20 shadow-sm shadow-emerald-500/20',
+    hex: 'bg-emerald-500/20 ring-1 ring-inset ring-emerald-500/35',
+    hexActive: 'bg-emerald-500/40 ring-1 ring-inset ring-emerald-600/70',
+  },
+  {
+    box: 'border-amber-500/30 bg-amber-500/10',
+    boxActive: 'border-amber-600 bg-amber-500/20 shadow-sm shadow-amber-500/20',
+    hex: 'bg-amber-500/20 ring-1 ring-inset ring-amber-500/35',
+    hexActive: 'bg-amber-500/40 ring-1 ring-inset ring-amber-600/70',
+  },
+  {
+    box: 'border-rose-500/30 bg-rose-500/10',
+    boxActive: 'border-rose-600 bg-rose-500/20 shadow-sm shadow-rose-500/20',
+    hex: 'bg-rose-500/20 ring-1 ring-inset ring-rose-500/35',
+    hexActive: 'bg-rose-500/40 ring-1 ring-inset ring-rose-600/70',
+  },
+  {
+    box: 'border-violet-500/30 bg-violet-500/10',
+    boxActive: 'border-violet-600 bg-violet-500/20 shadow-sm shadow-violet-500/20',
+    hex: 'bg-violet-500/20 ring-1 ring-inset ring-violet-500/35',
+    hexActive: 'bg-violet-500/40 ring-1 ring-inset ring-violet-600/70',
+  },
+  {
+    box: 'border-cyan-500/30 bg-cyan-500/10',
+    boxActive: 'border-cyan-600 bg-cyan-500/20 shadow-sm shadow-cyan-500/20',
+    hex: 'bg-cyan-500/20 ring-1 ring-inset ring-cyan-500/35',
+    hexActive: 'bg-cyan-500/40 ring-1 ring-inset ring-cyan-600/70',
+  },
+  {
+    box: 'border-lime-500/30 bg-lime-500/10',
+    boxActive: 'border-lime-600 bg-lime-500/20 shadow-sm shadow-lime-500/20',
+    hex: 'bg-lime-500/20 ring-1 ring-inset ring-lime-500/35',
+    hexActive: 'bg-lime-500/40 ring-1 ring-inset ring-lime-600/70',
+  },
+  {
+    box: 'border-fuchsia-500/30 bg-fuchsia-500/10',
+    boxActive: 'border-fuchsia-600 bg-fuchsia-500/20 shadow-sm shadow-fuchsia-500/20',
+    hex: 'bg-fuchsia-500/20 ring-1 ring-inset ring-fuchsia-500/35',
+    hexActive: 'bg-fuchsia-500/40 ring-1 ring-inset ring-fuchsia-600/70',
+  },
+];
+
+function formatTimestamp(timestamp: number): string {
+  return new Date(timestamp * 1000).toLocaleString([], {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+}
+
+function formatSignal(packet: RawPacket): string {
+  const parts: string[] = [];
+  if (packet.rssi !== null) {
+    parts.push(`${packet.rssi} dBm RSSI`);
+  }
+  if (packet.snr !== null) {
+    parts.push(`${packet.snr.toFixed(1)} dB SNR`);
+  }
+  return parts.length > 0 ? parts.join(' · ') : 'No signal sample';
+}
+
+function formatByteRange(field: PacketByteField): string {
+  if (field.absoluteStartByte === field.absoluteEndByte) {
+    return `Byte ${field.absoluteStartByte}`;
+  }
+  return `Bytes ${field.absoluteStartByte}-${field.absoluteEndByte}`;
+}
+
+function formatPathMode(hashSize: number | undefined, hopCount: number): string {
+  if (hopCount === 0) {
+    return 'No path hops';
+  }
+  if (!hashSize) {
+    return `${hopCount} hop${hopCount === 1 ? '' : 's'}`;
+  }
+  return `${hopCount} hop${hopCount === 1 ? '' : 's'} · ${hashSize} byte hash${hashSize === 1 ? '' : 'es'}`;
+}
+
+function buildGroupTextResolutionCandidates(channels: Channel[]): GroupTextResolutionCandidate[] {
+  return channels.map((channel) => ({
+    key: channel.key,
+    name: channel.name,
+    hash: ChannelCrypto.calculateChannelHash(channel.key).toUpperCase(),
+  }));
+}
+
+function resolveGroupTextRoomName(
+  payload: {
+    channelHash?: string;
+    cipherMac?: string;
+    ciphertext?: string;
+    decrypted?: { message?: string };
+  },
+  candidates: GroupTextResolutionCandidate[]
+): string | null {
+  if (!payload.channelHash) {
+    return null;
+  }
+
+  const hashMatches = candidates.filter(
+    (candidate) => candidate.hash === payload.channelHash?.toUpperCase()
+  );
+  if (hashMatches.length === 1) {
+    return hashMatches[0].name;
+  }
+  if (
+    hashMatches.length <= 1 ||
+    !payload.cipherMac ||
+    !payload.ciphertext ||
+    !payload.decrypted?.message
+  ) {
+    return null;
+  }
+
+  const decryptMatches = hashMatches.filter(
+    (candidate) =>
+      ChannelCrypto.decryptGroupTextMessage(payload.ciphertext!, payload.cipherMac!, candidate.key)
+        .success
+  );
+  return decryptMatches.length === 1 ? decryptMatches[0].name : null;
+}
+
+function packetShowsDecryptedState(
+  packet: RawPacket,
+  inspection: ReturnType<typeof inspectRawPacketWithOptions>
+): boolean {
+  const payload = inspection.decoded?.payload.decoded as { decrypted?: unknown } | null | undefined;
+  return packet.decrypted || Boolean(packet.decrypted_info) || Boolean(payload?.decrypted);
+}
+
+function getPacketContext(
+  packet: RawPacket,
+  inspection: ReturnType<typeof inspectRawPacketWithOptions>,
+  groupTextCandidates: GroupTextResolutionCandidate[]
+) {
+  const fallbackSender = packet.decrypted_info?.sender ?? null;
+  const fallbackRoom = packet.decrypted_info?.channel_name ?? null;
+
+  if (!inspection.decoded?.payload.decoded) {
+    if (!fallbackSender && !fallbackRoom) {
+      return null;
+    }
+    return {
+      title: fallbackRoom ? 'Room' : 'Context',
+      primary: fallbackRoom ?? 'Sender metadata available',
+      secondary: fallbackSender ? `Sender: ${fallbackSender}` : null,
+    };
+  }
+
+  if (inspection.decoded.payloadType === PayloadType.GroupText) {
+    const payload = inspection.decoded.payload.decoded as {
+      channelHash?: string;
+      cipherMac?: string;
+      ciphertext?: string;
+      decrypted?: { sender?: string; message?: string };
+    };
+    const roomName = fallbackRoom ?? resolveGroupTextRoomName(payload, groupTextCandidates);
+    return {
+      title: roomName ? 'Room' : 'Channel',
+      primary:
+        roomName ?? (payload.channelHash ? `Channel hash ${payload.channelHash}` : 'GroupText'),
+      secondary: payload.decrypted?.sender
+        ? `Sender: ${payload.decrypted.sender}`
+        : fallbackSender
+          ? `Sender: ${fallbackSender}`
+          : null,
+    };
+  }
+
+  if (fallbackSender) {
+    return {
+      title: 'Context',
+      primary: fallbackSender,
+      secondary: null,
+    };
+  }
+
+  return null;
+}
+
+function buildDisplayFields(inspection: ReturnType<typeof inspectRawPacketWithOptions>) {
+  return [
+    ...inspection.packetFields.filter((field) => field.name !== 'Payload'),
+    ...inspection.payloadFields,
+  ];
+}
+
+function buildFieldColorMap(fields: PacketByteField[]) {
+  return new Map(
+    fields.map((field, index) => [field.id, FIELD_PALETTE[index % FIELD_PALETTE.length]])
+  );
+}
+
+function buildByteOwners(totalBytes: number, fields: PacketByteField[]) {
+  const owners = new Array<string | null>(totalBytes).fill(null);
+  for (const field of fields) {
+    for (let index = field.absoluteStartByte; index <= field.absoluteEndByte; index += 1) {
+      if (index >= 0 && index < owners.length) {
+        owners[index] = field.id;
+      }
+    }
+  }
+  return owners;
+}
+
+function buildByteRuns(bytes: string[], owners: Array<string | null>) {
+  const runs: Array<{ fieldId: string | null; text: string }> = [];
+
+  for (let index = 0; index < bytes.length; index += 1) {
+    const fieldId = owners[index];
+    const lastRun = runs[runs.length - 1];
+    if (lastRun && lastRun.fieldId === fieldId) {
+      lastRun.text += ` ${bytes[index]}`;
+      continue;
+    }
+
+    runs.push({
+      fieldId,
+      text: bytes[index],
+    });
+  }
+
+  return runs;
+}
+
+function CompactMetaCard({
+  label,
+  primary,
+  secondary,
+}: {
+  label: string;
+  primary: string;
+  secondary?: string | null;
+}) {
+  return (
+    <div className="rounded-lg border border-border/70 bg-card/70 p-2.5">
+      <div className="text-[10px] uppercase tracking-[0.18em] text-muted-foreground">{label}</div>
+      <div className="mt-1 text-sm font-medium leading-tight text-foreground">{primary}</div>
+      {secondary ? (
+        <div className="mt-1 text-xs leading-tight text-muted-foreground">{secondary}</div>
+      ) : null}
+    </div>
+  );
+}
+
+function FullPacketHex({
+  packetHex,
+  fields,
+  colorMap,
+  hoveredFieldId,
+  onHoverField,
+}: {
+  packetHex: string;
+  fields: PacketByteField[];
+  colorMap: Map<string, FieldPaletteEntry>;
+  hoveredFieldId: string | null;
+  onHoverField: (fieldId: string | null) => void;
+}) {
+  const normalized = packetHex.toUpperCase();
+  const bytes = useMemo(() => normalized.match(/.{1,2}/g) ?? [], [normalized]);
+  const byteOwners = useMemo(() => buildByteOwners(bytes.length, fields), [bytes.length, fields]);
+  const byteRuns = useMemo(() => buildByteRuns(bytes, byteOwners), [byteOwners, bytes]);
+
+  return (
+    <div className="font-mono text-[15px] leading-7 text-foreground">
+      {byteRuns.map((run, index) => {
+        const fieldId = run.fieldId;
+        const palette = fieldId ? colorMap.get(fieldId) : null;
+        const active = fieldId !== null && hoveredFieldId === fieldId;
+        return (
+          <span key={`${fieldId ?? 'plain'}-${index}`}>
+            <span
+              onMouseEnter={() => onHoverField(fieldId)}
+              onMouseLeave={() => onHoverField(null)}
+              className={cn(
+                'inline rounded-sm px-0.5 py-0.5 transition-colors',
+                palette ? (active ? palette.hexActive : palette.hex) : ''
+              )}
+            >
+              {run.text}
+            </span>
+            {index < byteRuns.length - 1 ? ' ' : ''}
+          </span>
+        );
+      })}
+    </div>
+  );
+}
+
+function renderFieldValue(field: PacketByteField) {
+  if (field.name !== 'Path Data') {
+    return field.value.toUpperCase();
+  }
+
+  const parts = field.value
+    .toUpperCase()
+    .split(' → ')
+    .filter((part) => part.length > 0);
+
+  if (parts.length <= 1) {
+    return field.value.toUpperCase();
+  }
+
+  return (
+    <span className="inline-flex flex-wrap justify-start gap-x-1 sm:justify-end">
+      {parts.map((part, index) => {
+        const isLast = index === parts.length - 1;
+        return (
+          <span key={`${field.id}-${part}-${index}`} className="whitespace-nowrap">
+            {isLast ? part : `${part} →`}
+          </span>
+        );
+      })}
+    </span>
+  );
+}
+
+function FieldBox({
+  field,
+  palette,
+  active,
+  onHoverField,
+}: {
+  field: PacketByteField;
+  palette: FieldPaletteEntry;
+  active: boolean;
+  onHoverField: (fieldId: string | null) => void;
+}) {
+  return (
+    <div
+      onMouseEnter={() => onHoverField(field.id)}
+      onMouseLeave={() => onHoverField(null)}
+      className={cn(
+        'rounded-lg border p-2.5 transition-colors',
+        active ? palette.boxActive : palette.box
+      )}
+    >
+      <div className="flex flex-col items-start gap-2 sm:flex-row sm:justify-between">
+        <div className="min-w-0">
+          <div className="text-base font-semibold leading-tight text-foreground">{field.name}</div>
+          <div className="mt-0.5 text-[11px] text-muted-foreground">{formatByteRange(field)}</div>
+        </div>
+        <div
+          className={cn(
+            'w-full font-mono text-sm leading-5 text-foreground sm:max-w-[14rem] sm:text-right',
+            field.name === 'Path Data' ? 'break-normal' : 'break-all'
+          )}
+        >
+          {renderFieldValue(field)}
+        </div>
+      </div>
+
+      <div className="mt-2 whitespace-pre-wrap text-sm leading-5 text-foreground">
+        {field.description}
+      </div>
+
+      {field.decryptedMessage ? (
+        <div className="mt-2 rounded border border-border/50 bg-background/40 p-2">
+          <div className="text-[10px] uppercase tracking-[0.16em] text-muted-foreground">
+            {field.name === 'Ciphertext' ? 'Plaintext' : 'Decoded value'}
+          </div>
+          <PlaintextContent text={field.decryptedMessage} />
+        </div>
+      ) : null}
+
+      {field.headerBreakdown ? (
+        <div className="mt-2 space-y-1.5">
+          <div className="font-mono text-xs tracking-[0.16em] text-muted-foreground">
+            {field.headerBreakdown.fullBinary}
+          </div>
+          {field.headerBreakdown.fields.map((part) => (
+            <div
+              key={`${field.id}-${part.bits}-${part.field}`}
+              className="rounded border border-border/50 bg-background/40 p-2"
+            >
+              <div className="flex items-start justify-between gap-2">
+                <div>
+                  <div className="text-sm font-medium leading-tight text-foreground">
+                    {part.field}
+                  </div>
+                  <div className="mt-0.5 text-[11px] text-muted-foreground">Bits {part.bits}</div>
+                </div>
+                <div className="text-right">
+                  <div className="font-mono text-sm text-foreground">{part.binary}</div>
+                  <div className="mt-0.5 text-[11px] text-muted-foreground">{part.value}</div>
+                </div>
+              </div>
+            </div>
+          ))}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+function PlaintextContent({ text }: { text: string }) {
+  const lines = text.split('\n');
+
+  return (
+    <div className="mt-1 space-y-1 text-sm leading-5 text-foreground">
+      {lines.map((line, index) => {
+        const separatorIndex = line.indexOf(': ');
+        if (separatorIndex === -1) {
+          return (
+            <div key={`${line}-${index}`} className="font-mono">
+              {line}
+            </div>
+          );
+        }
+
+        const label = line.slice(0, separatorIndex + 1);
+        const value = line.slice(separatorIndex + 2);
+
+        return (
+          <div key={`${line}-${index}`}>
+            <span>{label} </span>
+            <span className="font-mono">{value}</span>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function FieldSection({
+  title,
+  fields,
+  colorMap,
+  hoveredFieldId,
+  onHoverField,
+}: {
+  title: string;
+  fields: PacketByteField[];
+  colorMap: Map<string, FieldPaletteEntry>;
+  hoveredFieldId: string | null;
+  onHoverField: (fieldId: string | null) => void;
+}) {
+  return (
+    <section className="rounded-lg border border-border/70 bg-card/70 p-3">
+      <div className="mb-2 text-sm font-semibold text-foreground">{title}</div>
+      {fields.length === 0 ? (
+        <div className="text-sm text-muted-foreground">No decoded fields available.</div>
+      ) : (
+        <div className="grid gap-2">
+          {fields.map((field) => (
+            <FieldBox
+              key={field.id}
+              field={field}
+              palette={colorMap.get(field.id) ?? FIELD_PALETTE[0]}
+              active={hoveredFieldId === field.id}
+              onHoverField={onHoverField}
+            />
+          ))}
+        </div>
+      )}
+    </section>
+  );
+}
+
+export function RawPacketDetailModal({ packet, channels, onClose }: RawPacketDetailModalProps) {
+  const decoderOptions = useMemo(() => createDecoderOptions(channels), [channels]);
+  const groupTextCandidates = useMemo(
+    () => buildGroupTextResolutionCandidates(channels),
+    [channels]
+  );
+  const inspection = useMemo(
+    () => (packet ? inspectRawPacketWithOptions(packet, decoderOptions) : null),
+    [decoderOptions, packet]
+  );
+  const [hoveredFieldId, setHoveredFieldId] = useState<string | null>(null);
+
+  const packetDisplayFields = useMemo(
+    () => (inspection ? inspection.packetFields.filter((field) => field.name !== 'Payload') : []),
+    [inspection]
+  );
+  const fullPacketFields = useMemo(
+    () => (inspection ? buildDisplayFields(inspection) : []),
+    [inspection]
+  );
+  const colorMap = useMemo(() => buildFieldColorMap(fullPacketFields), [fullPacketFields]);
+  const packetContext = useMemo(
+    () => (packet && inspection ? getPacketContext(packet, inspection, groupTextCandidates) : null),
+    [groupTextCandidates, inspection, packet]
+  );
+  const packetIsDecrypted = useMemo(
+    () => (packet && inspection ? packetShowsDecryptedState(packet, inspection) : false),
+    [inspection, packet]
+  );
+
+  if (!packet || !inspection) {
+    return null;
+  }
+
+  return (
+    <Dialog open={packet !== null} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <DialogContent className="flex h-[92vh] max-w-[min(96vw,82rem)] flex-col gap-0 overflow-hidden p-0">
+        <DialogHeader className="border-b border-border px-5 py-3">
+          <DialogTitle>Packet Details</DialogTitle>
+          <DialogDescription className="sr-only">
+            Detailed byte and field breakdown for the selected raw packet.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="min-h-0 flex-1 overflow-y-auto p-3">
+          <div className="grid gap-2 lg:grid-cols-[minmax(0,1.45fr)_minmax(0,1fr)]">
+            <section className="rounded-lg border border-border/70 bg-card/70 p-3">
+              <div className="flex flex-wrap items-start justify-between gap-2">
+                <div className="min-w-0">
+                  <div className="text-[10px] uppercase tracking-[0.18em] text-muted-foreground">
+                    Summary
+                  </div>
+                  <div className="mt-1 text-base font-semibold leading-tight text-foreground">
+                    {inspection.summary.summary}
+                  </div>
+                </div>
+                <div className="shrink-0 text-xs text-muted-foreground">
+                  {formatTimestamp(packet.timestamp)}
+                </div>
+              </div>
+              {packetContext ? (
+                <div className="mt-2 rounded-md border border-border/60 bg-background/35 px-2.5 py-2">
+                  <div className="text-[10px] uppercase tracking-[0.18em] text-muted-foreground">
+                    {packetContext.title}
+                  </div>
+                  <div className="mt-1 text-sm font-medium leading-tight text-foreground">
+                    {packetContext.primary}
+                  </div>
+                  {packetContext.secondary ? (
+                    <div className="mt-1 text-xs leading-tight text-muted-foreground">
+                      {packetContext.secondary}
+                    </div>
+                  ) : null}
+                </div>
+              ) : null}
+            </section>
+
+            <section className="grid gap-2 sm:grid-cols-3 lg:grid-cols-1 xl:grid-cols-3">
+              <CompactMetaCard
+                label="Packet"
+                primary={`${packet.data.length / 2} bytes · ${packetIsDecrypted ? 'Decrypted' : 'Encrypted'}`}
+                secondary={`Storage #${packet.id}${packet.observation_id !== undefined ? ` · Observation #${packet.observation_id}` : ''}`}
+              />
+              <CompactMetaCard
+                label="Transport"
+                primary={`${inspection.routeTypeName} · ${inspection.payloadTypeName}`}
+                secondary={`${inspection.payloadVersionName} · ${formatPathMode(inspection.decoded?.pathHashSize, inspection.pathTokens.length)}`}
+              />
+              <CompactMetaCard
+                label="Signal"
+                primary={formatSignal(packet)}
+                secondary={packetContext ? null : undefined}
+              />
+            </section>
+          </div>
+
+          {inspection.validationErrors.length > 0 ? (
+            <div className="mt-3 rounded-lg border border-warning/40 bg-warning/10 p-2.5">
+              <div className="text-sm font-semibold text-foreground">Validation notes</div>
+              <div className="mt-1.5 space-y-1 text-sm text-foreground">
+                {inspection.validationErrors.map((error) => (
+                  <div key={error}>{error}</div>
+                ))}
+              </div>
+            </div>
+          ) : null}
+
+          <div className="mt-3 rounded-lg border border-border/70 bg-card/70 p-3">
+            <div className="text-xl font-semibold text-foreground">Full packet hex</div>
+            <div className="mt-2.5">
+              <FullPacketHex
+                packetHex={packet.data}
+                fields={fullPacketFields}
+                colorMap={colorMap}
+                hoveredFieldId={hoveredFieldId}
+                onHoverField={setHoveredFieldId}
+              />
+            </div>
+          </div>
+
+          <div className="mt-3 grid gap-3 xl:grid-cols-[minmax(0,0.85fr)_minmax(0,1.15fr)]">
+            <FieldSection
+              title="Packet fields"
+              fields={packetDisplayFields}
+              colorMap={colorMap}
+              hoveredFieldId={hoveredFieldId}
+              onHoverField={setHoveredFieldId}
+            />
+
+            <FieldSection
+              title="Payload fields"
+              fields={inspection.payloadFields}
+              colorMap={colorMap}
+              hoveredFieldId={hoveredFieldId}
+              onHoverField={setHoveredFieldId}
+            />
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend/src/components/RawPacketFeedView.tsx

@@ -0,0 +1,609 @@
+import { useEffect, useMemo, useState } from 'react';
+import { ChevronLeft, ChevronRight } from 'lucide-react';
+
+import { RawPacketList } from './RawPacketList';
+import { RawPacketDetailModal } from './RawPacketDetailModal';
+import type { Channel, Contact, RawPacket } from '../types';
+import {
+  RAW_PACKET_STATS_WINDOWS,
+  buildRawPacketStatsSnapshot,
+  type NeighborStat,
+  type PacketTimelineBin,
+  type RankedPacketStat,
+  type RawPacketStatsSessionState,
+  type RawPacketStatsWindow,
+} from '../utils/rawPacketStats';
+import { getContactDisplayName } from '../utils/pubkey';
+import { cn } from '@/lib/utils';
+
+interface RawPacketFeedViewProps {
+  packets: RawPacket[];
+  rawPacketStatsSession: RawPacketStatsSessionState;
+  contacts: Contact[];
+  channels: Channel[];
+}
+
+const WINDOW_LABELS: Record<RawPacketStatsWindow, string> = {
+  '1m': '1 min',
+  '5m': '5 min',
+  '10m': '10 min',
+  '30m': '30 min',
+  session: 'Session',
+};
+
+const TIMELINE_COLORS = [
+  'bg-sky-500/80',
+  'bg-emerald-500/80',
+  'bg-amber-500/80',
+  'bg-rose-500/80',
+  'bg-violet-500/80',
+];
+
+function formatTimestamp(timestampMs: number): string {
+  return new Date(timestampMs).toLocaleString([], {
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+}
+
+function formatDuration(seconds: number): string {
+  if (seconds < 60) {
+    return `${Math.max(1, Math.round(seconds))} sec`;
+  }
+  if (seconds < 3600) {
+    const minutes = Math.floor(seconds / 60);
+    const remainder = Math.round(seconds % 60);
+    return remainder > 0 ? `${minutes}m ${remainder}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.round((seconds % 3600) / 60);
+  return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+}
+
+function formatRate(value: number): string {
+  if (value >= 100) return value.toFixed(0);
+  if (value >= 10) return value.toFixed(1);
+  return value.toFixed(2);
+}
+
+function formatPercent(value: number): string {
+  return `${Math.round(value * 100)}%`;
+}
+
+function formatRssi(value: number | null): string {
+  return value === null ? '-' : `${Math.round(value)} dBm`;
+}
+
+function normalizeResolvableSourceKey(sourceKey: string): string {
+  return sourceKey.startsWith('hash1:') ? sourceKey.slice(6) : sourceKey;
+}
+
+function resolveContact(sourceKey: string | null, contacts: Contact[]): Contact | null {
+  if (!sourceKey || sourceKey.startsWith('name:')) {
+    return null;
+  }
+
+  const normalizedSourceKey = normalizeResolvableSourceKey(sourceKey).toLowerCase();
+  const matches = contacts.filter((contact) =>
+    contact.public_key.toLowerCase().startsWith(normalizedSourceKey)
+  );
+  if (matches.length !== 1) {
+    return null;
+  }
+
+  return matches[0];
+}
+
+function resolveContactLabel(sourceKey: string | null, contacts: Contact[]): string | null {
+  const contact = resolveContact(sourceKey, contacts);
+  if (!contact) {
+    return null;
+  }
+  return getContactDisplayName(contact.name, contact.public_key, contact.last_advert);
+}
+
+function resolveNeighbor(item: NeighborStat, contacts: Contact[]): NeighborStat {
+  return {
+    ...item,
+    label: resolveContactLabel(item.key, contacts) ?? item.label,
+  };
+}
+
+function mergeResolvedNeighbors(items: NeighborStat[], contacts: Contact[]): NeighborStat[] {
+  const merged = new Map<string, NeighborStat>();
+
+  for (const item of items) {
+    const contact = resolveContact(item.key, contacts);
+    const canonicalKey = contact?.public_key ?? item.key;
+    const resolvedLabel =
+      contact != null
+        ? getContactDisplayName(contact.name, contact.public_key, contact.last_advert)
+        : item.label;
+    const existing = merged.get(canonicalKey);
+
+    if (!existing) {
+      merged.set(canonicalKey, {
+        ...item,
+        key: canonicalKey,
+        label: resolvedLabel,
+      });
+      continue;
+    }
+
+    existing.count += item.count;
+    existing.lastSeen = Math.max(existing.lastSeen, item.lastSeen);
+    existing.bestRssi =
+      existing.bestRssi === null
+        ? item.bestRssi
+        : item.bestRssi === null
+          ? existing.bestRssi
+          : Math.max(existing.bestRssi, item.bestRssi);
+    existing.label = resolvedLabel;
+  }
+
+  return Array.from(merged.values());
+}
+
+function isNeighborIdentityResolvable(item: NeighborStat, contacts: Contact[]): boolean {
+  if (item.key.startsWith('name:')) {
+    return true;
+  }
+  return resolveContact(item.key, contacts) !== null;
+}
+
+function formatStrongestPacketDetail(
+  stats: ReturnType<typeof buildRawPacketStatsSnapshot>,
+  contacts: Contact[]
+): string | undefined {
+  if (!stats.strongestPacketPayloadType) {
+    return undefined;
+  }
+
+  const resolvedLabel =
+    resolveContactLabel(stats.strongestPacketSourceKey, contacts) ??
+    stats.strongestPacketSourceLabel;
+  if (resolvedLabel) {
+    return `${resolvedLabel} · ${stats.strongestPacketPayloadType}`;
+  }
+  if (stats.strongestPacketPayloadType === 'GroupText') {
+    return '<unknown sender> · GroupText';
+  }
+  return stats.strongestPacketPayloadType;
+}
+
+function getCoverageMessage(
+  stats: ReturnType<typeof buildRawPacketStatsSnapshot>,
+  session: RawPacketStatsSessionState
+): { tone: 'default' | 'warning'; message: string } {
+  if (session.trimmedObservationCount > 0 && stats.window === 'session') {
+    return {
+      tone: 'warning',
+      message: `Detailed session history was trimmed after ${session.totalObservedPackets.toLocaleString()} observations.`,
+    };
+  }
+
+  if (!stats.windowFullyCovered) {
+    return {
+      tone: 'warning',
+      message: `This window is only covered for ${formatDuration(stats.coverageSeconds)} of frontend-collected history.`,
+    };
+  }
+
+  return {
+    tone: 'default',
+    message: `Tracking ${session.observations.length.toLocaleString()} detailed observations from this browser session.`,
+  };
+}
+
+function StatTile({ label, value, detail }: { label: string; value: string; detail?: string }) {
+  return (
+    <div className="break-inside-avoid rounded-lg border border-border/70 bg-card/80 p-3">
+      <div className="text-[11px] uppercase tracking-wide text-muted-foreground">{label}</div>
+      <div className="mt-1 text-xl font-semibold tabular-nums text-foreground">{value}</div>
+      {detail ? <div className="mt-1 text-xs text-muted-foreground">{detail}</div> : null}
+    </div>
+  );
+}
+
+function RankedBars({
+  title,
+  items,
+  emptyLabel,
+  formatter,
+}: {
+  title: string;
+  items: RankedPacketStat[];
+  emptyLabel: string;
+  formatter?: (item: RankedPacketStat) => string;
+}) {
+  const maxCount = Math.max(...items.map((item) => item.count), 1);
+
+  return (
+    <section className="mb-4 break-inside-avoid rounded-lg border border-border/70 bg-card/70 p-3">
+      <h3 className="text-sm font-semibold text-foreground">{title}</h3>
+      {items.length === 0 ? (
+        <p className="mt-3 text-sm text-muted-foreground">{emptyLabel}</p>
+      ) : (
+        <div className="mt-3 space-y-2">
+          {items.map((item) => (
+            <div key={item.label}>
+              <div className="mb-1 flex items-center justify-between gap-3 text-xs">
+                <span className="truncate text-foreground">{item.label}</span>
+                <span className="shrink-0 tabular-nums text-muted-foreground">
+                  {formatter
+                    ? formatter(item)
+                    : `${item.count.toLocaleString()} · ${formatPercent(item.share)}`}
+                </span>
+              </div>
+              <div className="h-2 overflow-hidden rounded-full bg-muted">
+                <div
+                  className="h-full rounded-full bg-primary/80"
+                  style={{ width: `${(item.count / maxCount) * 100}%` }}
+                />
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </section>
+  );
+}
+
+function NeighborList({
+  title,
+  items,
+  emptyLabel,
+  mode,
+  contacts,
+}: {
+  title: string;
+  items: NeighborStat[];
+  emptyLabel: string;
+  mode: 'heard' | 'signal' | 'recent';
+  contacts: Contact[];
+}) {
+  const mergedItems = mergeResolvedNeighbors(items, contacts);
+  const sortedItems = [...mergedItems].sort((a, b) => {
+    if (mode === 'heard') {
+      return b.count - a.count || b.lastSeen - a.lastSeen || a.label.localeCompare(b.label);
+    }
+    if (mode === 'signal') {
+      return (
+        (b.bestRssi ?? Number.NEGATIVE_INFINITY) - (a.bestRssi ?? Number.NEGATIVE_INFINITY) ||
+        b.count - a.count ||
+        a.label.localeCompare(b.label)
+      );
+    }
+    return b.lastSeen - a.lastSeen || b.count - a.count || a.label.localeCompare(b.label);
+  });
+
+  return (
+    <section className="mb-4 break-inside-avoid rounded-lg border border-border/70 bg-card/70 p-3">
+      <h3 className="text-sm font-semibold text-foreground">{title}</h3>
+      {sortedItems.length === 0 ? (
+        <p className="mt-3 text-sm text-muted-foreground">{emptyLabel}</p>
+      ) : (
+        <div className="mt-3 space-y-2">
+          {sortedItems.map((item) => (
+            <div
+              key={item.key}
+              className="flex items-center justify-between gap-3 rounded-md bg-background/70 px-2 py-1.5"
+            >
+              <div className="min-w-0">
+                <div className="truncate text-sm text-foreground">{item.label}</div>
+                <div className="text-xs text-muted-foreground">
+                  {mode === 'heard'
+                    ? `${item.count.toLocaleString()} packets`
+                    : mode === 'signal'
+                      ? `${formatRssi(item.bestRssi)} best`
+                      : `Last seen ${new Date(item.lastSeen * 1000).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`}
+                </div>
+                {!isNeighborIdentityResolvable(item, contacts) ? (
+                  <div className="text-[11px] text-warning">Identity not resolvable</div>
+                ) : null}
+              </div>
+              {mode !== 'signal' ? (
+                <div className="shrink-0 text-xs tabular-nums text-muted-foreground">
+                  {mode === 'recent' ? formatRssi(item.bestRssi) : formatRssi(item.bestRssi)}
+                </div>
+              ) : null}
+            </div>
+          ))}
+        </div>
+      )}
+    </section>
+  );
+}
+
+function TimelineChart({ bins }: { bins: PacketTimelineBin[] }) {
+  const maxTotal = Math.max(...bins.map((bin) => bin.total), 1);
+  const typeOrder = Array.from(new Set(bins.flatMap((bin) => Object.keys(bin.countsByType)))).slice(
+    0,
+    TIMELINE_COLORS.length
+  );
+
+  return (
+    <section className="mb-4 break-inside-avoid rounded-lg border border-border/70 bg-card/70 p-3">
+      <div className="flex items-center justify-between gap-3">
+        <h3 className="text-sm font-semibold text-foreground">Traffic Timeline</h3>
+        <div className="flex flex-wrap justify-end gap-2 text-[11px] text-muted-foreground">
+          {typeOrder.map((type, index) => (
+            <span key={type} className="inline-flex items-center gap-1">
+              <span className={cn('h-2 w-2 rounded-full', TIMELINE_COLORS[index])} />
+              <span>{type}</span>
+            </span>
+          ))}
+        </div>
+      </div>
+
+      <div className="mt-3 flex items-start gap-1">
+        {bins.map((bin, index) => (
+          <div
+            key={`${bin.label}-${index}`}
+            className="flex min-w-0 flex-1 flex-col items-center gap-1"
+          >
+            <div className="flex h-24 w-full items-end overflow-hidden rounded-sm bg-muted/60">
+              <div className="flex h-full w-full flex-col justify-end">
+                {typeOrder.map((type, index) => {
+                  const count = bin.countsByType[type] ?? 0;
+                  if (count === 0) return null;
+                  return (
+                    <div
+                      key={type}
+                      className={cn('w-full', TIMELINE_COLORS[index])}
+                      style={{
+                        height: `${(count / maxTotal) * 100}%`,
+                      }}
+                      title={`${bin.label}: ${type} ${count.toLocaleString()}`}
+                    />
+                  );
+                })}
+              </div>
+            </div>
+            <div className="text-[10px] text-muted-foreground">{bin.label}</div>
+          </div>
+        ))}
+      </div>
+    </section>
+  );
+}
+
+export function RawPacketFeedView({
+  packets,
+  rawPacketStatsSession,
+  contacts,
+  channels,
+}: RawPacketFeedViewProps) {
+  const [statsOpen, setStatsOpen] = useState(() =>
+    typeof window !== 'undefined' && typeof window.matchMedia === 'function'
+      ? window.matchMedia('(min-width: 768px)').matches
+      : false
+  );
+  const [selectedWindow, setSelectedWindow] = useState<RawPacketStatsWindow>('10m');
+  const [nowSec, setNowSec] = useState(() => Math.floor(Date.now() / 1000));
+  const [selectedPacket, setSelectedPacket] = useState<RawPacket | null>(null);
+
+  useEffect(() => {
+    const interval = window.setInterval(() => {
+      setNowSec(Math.floor(Date.now() / 1000));
+    }, 30000);
+    return () => window.clearInterval(interval);
+  }, []);
+
+  useEffect(() => {
+    setNowSec(Math.floor(Date.now() / 1000));
+  }, [packets, rawPacketStatsSession]);
+
+  const stats = useMemo(
+    () => buildRawPacketStatsSnapshot(rawPacketStatsSession, selectedWindow, nowSec),
+    [nowSec, rawPacketStatsSession, selectedWindow]
+  );
+  const coverageMessage = getCoverageMessage(stats, rawPacketStatsSession);
+  const strongestPacketDetail = useMemo(
+    () => formatStrongestPacketDetail(stats, contacts),
+    [contacts, stats]
+  );
+  const strongestNeighbors = useMemo(
+    () => stats.strongestNeighbors.map((item) => resolveNeighbor(item, contacts)),
+    [contacts, stats.strongestNeighbors]
+  );
+  const mostActiveNeighbors = useMemo(
+    () => stats.mostActiveNeighbors.map((item) => resolveNeighbor(item, contacts)),
+    [contacts, stats.mostActiveNeighbors]
+  );
+  const newestNeighbors = useMemo(
+    () => stats.newestNeighbors.map((item) => resolveNeighbor(item, contacts)),
+    [contacts, stats.newestNeighbors]
+  );
+
+  return (
+    <>
+      <div className="flex items-center justify-between gap-3 border-b border-border px-4 py-2.5">
+        <div>
+          <h2 className="font-semibold text-base text-foreground">Raw Packet Feed</h2>
+          <p className="text-xs text-muted-foreground">
+            Collecting stats since {formatTimestamp(rawPacketStatsSession.sessionStartedAt)}
+          </p>
+        </div>
+        <button
+          type="button"
+          onClick={() => setStatsOpen((current) => !current)}
+          aria-expanded={statsOpen}
+          className="inline-flex items-center gap-1 rounded-md border border-border bg-card px-3 py-1.5 text-sm text-foreground transition-colors hover:bg-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+        >
+          {statsOpen ? <ChevronRight className="h-4 w-4" /> : <ChevronLeft className="h-4 w-4" />}
+          {statsOpen ? 'Hide Stats' : 'Show Stats'}
+        </button>
+      </div>
+
+      <div className="flex min-h-0 flex-1 flex-col md:flex-row">
+        <div className={cn('min-h-0 min-w-0 flex-1', statsOpen && 'md:border-r md:border-border')}>
+          <RawPacketList packets={packets} channels={channels} onPacketClick={setSelectedPacket} />
+        </div>
+
+        <aside
+          className={cn(
+            'shrink-0 overflow-hidden border-t border-border transition-all duration-300 md:border-l md:border-t-0',
+            statsOpen
+              ? 'max-h-[42rem] md:max-h-none md:w-1/2 md:min-w-[30rem]'
+              : 'max-h-0 md:w-0 md:min-w-0 border-transparent'
+          )}
+        >
+          {statsOpen ? (
+            <div className="h-full overflow-y-auto bg-background p-4 [contain:layout_paint]">
+              <div className="break-inside-avoid rounded-lg border border-border/70 bg-card/70 p-3">
+                <div className="flex flex-wrap items-center justify-between gap-3">
+                  <div>
+                    <div className="text-[11px] uppercase tracking-wide text-muted-foreground">
+                      Coverage
+                    </div>
+                    <div
+                      className={cn(
+                        'mt-1 text-sm',
+                        coverageMessage.tone === 'warning'
+                          ? 'text-warning'
+                          : 'text-muted-foreground'
+                      )}
+                    >
+                      {coverageMessage.message}
+                    </div>
+                  </div>
+                  <label className="flex items-center gap-2 text-sm text-foreground">
+                    <span className="text-muted-foreground">Window</span>
+                    <select
+                      value={selectedWindow}
+                      onChange={(event) =>
+                        setSelectedWindow(event.target.value as RawPacketStatsWindow)
+                      }
+                      className="rounded-md border border-input bg-background px-2 py-1 text-sm"
+                      aria-label="Stats window"
+                    >
+                      {RAW_PACKET_STATS_WINDOWS.map((option) => (
+                        <option key={option} value={option}>
+                          {WINDOW_LABELS[option]}
+                        </option>
+                      ))}
+                    </select>
+                  </label>
+                </div>
+                <div className="mt-2 text-xs text-muted-foreground">
+                  {stats.packetCount.toLocaleString()} packets in{' '}
+                  {WINDOW_LABELS[selectedWindow].toLowerCase()} window
+                  {' · '}
+                  {rawPacketStatsSession.totalObservedPackets.toLocaleString()} observed this
+                  session
+                </div>
+              </div>
+
+              <div className="mt-4 grid grid-cols-2 gap-3 md:grid-cols-3">
+                <StatTile
+                  label="Packets / min"
+                  value={formatRate(stats.packetsPerMinute)}
+                  detail={`${stats.packetCount.toLocaleString()} total in window`}
+                />
+                <StatTile
+                  label="Unique Sources"
+                  value={stats.uniqueSources.toLocaleString()}
+                  detail="Distinct identified senders"
+                />
+                <StatTile
+                  label="Decrypt Rate"
+                  value={formatPercent(stats.decryptRate)}
+                  detail={`${stats.decryptedCount.toLocaleString()} decrypted / ${stats.undecryptedCount.toLocaleString()} locked`}
+                />
+                <StatTile
+                  label="Path Diversity"
+                  value={stats.distinctPaths.toLocaleString()}
+                  detail={`${formatPercent(stats.pathBearingRate)} path-bearing packets`}
+                />
+                <StatTile
+                  label="Best RSSI"
+                  value={formatRssi(stats.bestRssi)}
+                  detail={strongestPacketDetail ?? 'No signal sample in window'}
+                />
+                <StatTile
+                  label="Median RSSI"
+                  value={formatRssi(stats.medianRssi)}
+                  detail={
+                    stats.averageRssi === null
+                      ? 'No signal sample in window'
+                      : `Average ${formatRssi(stats.averageRssi)}`
+                  }
+                />
+              </div>
+
+              <div className="mt-4">
+                <TimelineChart bins={stats.timeline} />
+              </div>
+
+              <div className="md:columns-2 md:gap-4">
+                <RankedBars
+                  title="Packet Types"
+                  items={stats.payloadBreakdown}
+                  emptyLabel="No packets in this window yet."
+                />
+
+                <RankedBars
+                  title="Route Mix"
+                  items={stats.routeBreakdown}
+                  emptyLabel="No packets in this window yet."
+                />
+
+                <RankedBars
+                  title="Hop Profile"
+                  items={stats.hopProfile}
+                  emptyLabel="No packets in this window yet."
+                />
+
+                <RankedBars
+                  title="Hop Byte Width"
+                  items={stats.hopByteWidthProfile}
+                  emptyLabel="No packets in this window yet."
+                />
+
+                <RankedBars
+                  title="Signal Distribution"
+                  items={stats.rssiBuckets}
+                  emptyLabel="No RSSI samples in this window yet."
+                />
+
+                <NeighborList
+                  title="Most-Heard Neighbors"
+                  items={mostActiveNeighbors}
+                  emptyLabel="No sender identities resolved in this window yet."
+                  mode="heard"
+                  contacts={contacts}
+                />
+
+                <NeighborList
+                  title="Strongest Recent Neighbors"
+                  items={strongestNeighbors}
+                  emptyLabel="No RSSI-tagged neighbors in this window yet."
+                  mode="signal"
+                  contacts={contacts}
+                />
+
+                <NeighborList
+                  title="Newest Heard Neighbors"
+                  items={newestNeighbors}
+                  emptyLabel="No newly identified neighbors in this window yet."
+                  mode="recent"
+                  contacts={contacts}
+                />
+              </div>
+            </div>
+          ) : null}
+        </aside>
+      </div>
+
+      <RawPacketDetailModal
+        packet={selectedPacket}
+        channels={channels}
+        onClose={() => setSelectedPacket(null)}
+      />
+    </>
+  );
+}

frontend/src/components/RawPacketList.tsx

@@ -1,11 +1,13 @@
 import { useEffect, useRef, useMemo } from 'react';
-import { MeshCoreDecoder, PayloadType, Utils } from '@michaelhart/meshcore-decoder';
-import type { RawPacket } from '../types';
+import type { Channel, RawPacket } from '../types';
 import { getRawPacketObservationKey } from '../utils/rawPacketIdentity';
+import { createDecoderOptions, decodePacketSummary } from '../utils/rawPacketInspector';
 import { cn } from '@/lib/utils';
 
 interface RawPacketListProps {
   packets: RawPacket[];
+  channels?: Channel[];
+  onPacketClick?: (packet: RawPacket) => void;
 }
 
 function formatTime(timestamp: number): string {
@@ -24,132 +26,6 @@ function formatSignalInfo(packet: RawPacket): string {
   return parts.join(' | ');
 }
 
-// Decrypted info from the packet (validated by backend)
-interface DecryptedInfo {
-  channel_name: string | null;
-  sender: string | null;
-}
-
-// Decode a packet and generate a human-readable summary
-// Uses backend's decrypted_info when available (validated), falls back to decoder
-function decodePacketSummary(
-  hexData: string,
-  decryptedInfo: DecryptedInfo | null
-): {
-  summary: string;
-  routeType: string;
-  details?: string;
-} {
-  try {
-    const decoded = MeshCoreDecoder.decode(hexData);
-
-    if (!decoded.isValid) {
-      return { summary: 'Invalid packet', routeType: 'Unknown' };
-    }
-
-    const routeType = Utils.getRouteTypeName(decoded.routeType);
-    const payloadTypeName = Utils.getPayloadTypeName(decoded.payloadType);
-    const tracePayload =
-      decoded.payloadType === PayloadType.Trace && decoded.payload.decoded
-        ? (decoded.payload.decoded as { pathHashes?: string[] })
-        : null;
-    const pathTokens = tracePayload?.pathHashes || decoded.path || [];
-
-    // Build path string if available
-    const pathStr = pathTokens.length > 0 ? ` via ${pathTokens.join('-')}` : '';
-
-    // Generate summary based on payload type
-    let summary = payloadTypeName;
-    let details: string | undefined;
-
-    switch (decoded.payloadType) {
-      case PayloadType.TextMessage: {
-        const payload = decoded.payload.decoded as {
-          destinationHash?: string;
-          sourceHash?: string;
-        } | null;
-        if (payload?.sourceHash && payload?.destinationHash) {
-          summary = `DM from ${payload.sourceHash} to ${payload.destinationHash}${pathStr}`;
-        } else {
-          summary = `DM${pathStr}`;
-        }
-        break;
-      }
-
-      case PayloadType.GroupText: {
-        const payload = decoded.payload.decoded as {
-          channelHash?: string;
-        } | null;
-        // Use backend's validated decrypted_info when available
-        if (decryptedInfo?.channel_name) {
-          if (decryptedInfo.sender) {
-            summary = `GT from ${decryptedInfo.sender} in ${decryptedInfo.channel_name}${pathStr}`;
-          } else {
-            summary = `GT in ${decryptedInfo.channel_name}${pathStr}`;
-          }
-        } else if (payload?.channelHash) {
-          // Fallback to showing channel hash when not decrypted
-          summary = `GT ch:${payload.channelHash}${pathStr}`;
-        } else {
-          summary = `GroupText${pathStr}`;
-        }
-        break;
-      }
-
-      case PayloadType.Advert: {
-        const payload = decoded.payload.decoded as {
-          publicKey?: string;
-          appData?: { name?: string; deviceRole?: number };
-        } | null;
-        if (payload?.appData?.name) {
-          const role =
-            payload.appData.deviceRole !== undefined
-              ? Utils.getDeviceRoleName(payload.appData.deviceRole)
-              : '';
-          summary = `Advert: ${payload.appData.name}${role ? ` (${role})` : ''}${pathStr}`;
-        } else if (payload?.publicKey) {
-          summary = `Advert: ${payload.publicKey.slice(0, 8)}...${pathStr}`;
-        } else {
-          summary = `Advert${pathStr}`;
-        }
-        break;
-      }
-
-      case PayloadType.Ack: {
-        summary = `ACK${pathStr}`;
-        break;
-      }
-
-      case PayloadType.Request: {
-        summary = `Request${pathStr}`;
-        break;
-      }
-
-      case PayloadType.Response: {
-        summary = `Response${pathStr}`;
-        break;
-      }
-
-      case PayloadType.Trace: {
-        summary = `Trace${pathStr}`;
-        break;
-      }
-
-      case PayloadType.Path: {
-        summary = `Path${pathStr}`;
-        break;
-      }
-
-      default:
-        summary = `${payloadTypeName}${pathStr}`;
-    }
-
-    return { summary, routeType, details };
-  } catch {
-    return { summary: 'Decode error', routeType: 'Unknown' };
-  }
-}
-
 // Get route type badge color
 function getRouteTypeColor(routeType: string): string {
   switch (routeType) {
@@ -182,16 +58,17 @@ function getRouteTypeLabel(routeType: string): string {
   }
 }
 
-export function RawPacketList({ packets }: RawPacketListProps) {
+export function RawPacketList({ packets, channels, onPacketClick }: RawPacketListProps) {
   const listRef = useRef<HTMLDivElement>(null);
+  const decoderOptions = useMemo(() => createDecoderOptions(channels), [channels]);
 
   // Decode all packets (memoized to avoid re-decoding on every render)
   const decodedPackets = useMemo(() => {
     return packets.map((packet) => ({
       packet,
-      decoded: decodePacketSummary(packet.data, packet.decrypted_info),
+      decoded: decodePacketSummary(packet, decoderOptions),
     }));
-  }, [packets]);
+  }, [decoderOptions, packets]);
 
   // Sort packets by timestamp ascending (oldest first)
   const sortedPackets = useMemo(
@@ -218,54 +95,78 @@ export function RawPacketList({ packets }: RawPacketListProps) {
       className="h-full overflow-y-auto p-4 flex flex-col gap-2 [contain:layout_paint]"
       ref={listRef}
     >
-      {sortedPackets.map(({ packet, decoded }) => (
-        <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
-              className={`text-[10px] font-mono px-1.5 py-0.5 rounded ${getRouteTypeColor(decoded.routeType)}`}
-              title={decoded.routeType}
-            >
-              {getRouteTypeLabel(decoded.routeType)}
-            </span>
+      {sortedPackets.map(({ packet, decoded }) => {
+        const cardContent = (
+          <>
+            <div className="flex items-center gap-2">
+              {/* Route type badge */}
+              <span
+                className={`text-[10px] font-mono px-1.5 py-0.5 rounded ${getRouteTypeColor(decoded.routeType)}`}
+                title={decoded.routeType}
+              >
+                {getRouteTypeLabel(decoded.routeType)}
+              </span>
 
-            {/* Encryption status */}
-            {!packet.decrypted && (
-              <>
-                <span aria-hidden="true">🔒</span>
-                <span className="sr-only">Encrypted</span>
-              </>
+              {/* Encryption status */}
+              {!packet.decrypted && (
+                <>
+                  <span aria-hidden="true">🔒</span>
+                  <span className="sr-only">Encrypted</span>
+                </>
+              )}
+
+              {/* Summary */}
+              <span
+                className={cn('text-[13px]', packet.decrypted ? 'text-primary' : 'text-foreground')}
+              >
+                {decoded.summary}
+              </span>
+
+              {/* Time */}
+              <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 tabular-nums">
+                {formatSignalInfo(packet)}
+              </div>
             )}
 
-            {/* Summary */}
-            <span
-              className={cn('text-[13px]', packet.decrypted ? 'text-primary' : 'text-foreground')}
-            >
-              {decoded.summary}
-            </span>
-
-            {/* Time */}
-            <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 tabular-nums">
-              {formatSignalInfo(packet)}
+            {/* Raw hex data (always visible) */}
+            <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>
-          )}
+          </>
+        );
 
-          {/* Raw hex data (always visible) */}
-          <div className="font-mono text-[10px] break-all text-muted-foreground mt-1.5 p-1.5 bg-background/60 rounded">
-            {packet.data.toUpperCase()}
+        const className = cn(
+          'rounded-md border border-border/50 bg-card px-3 py-2 text-left',
+          onPacketClick &&
+            'cursor-pointer transition-colors hover:bg-accent/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring'
+        );
+
+        if (onPacketClick) {
+          return (
+            <button
+              key={getRawPacketObservationKey(packet)}
+              type="button"
+              onClick={() => onPacketClick(packet)}
+              className={className}
+            >
+              {cardContent}
+            </button>
+          );
+        }
+
+        return (
+          <div key={getRawPacketObservationKey(packet)} className={className}>
+            {cardContent}
           </div>
-        </div>
-      ))}
+        );
+      })}
     </div>
   );
 }

frontend/src/components/RepeaterDashboard.tsx

@@ -1,20 +1,28 @@
+import { useState } from 'react';
+
 import { toast } from './ui/sonner';
 import { Button } from './ui/button';
 import { Bell, Route, Star, Trash2 } from 'lucide-react';
+import { DirectTraceIcon } from './DirectTraceIcon';
 import { RepeaterLogin } from './RepeaterLogin';
+import { useRememberedServerPassword } from '../hooks/useRememberedServerPassword';
 import { useRepeaterDashboard } from '../hooks/useRepeaterDashboard';
 import { isFavorite } from '../utils/favorites';
 import { handleKeyboardActivate } from '../utils/a11y';
+import { isValidLocation } from '../utils/pathUtils';
 import { ContactStatusInfo } from './ContactStatusInfo';
-import type { Contact, Conversation, Favorite } from '../types';
+import type { Contact, Conversation, Favorite, PathDiscoveryResponse } from '../types';
+import { cn } from '../lib/utils';
 import { TelemetryPane } from './repeater/RepeaterTelemetryPane';
 import { NeighborsPane } from './repeater/RepeaterNeighborsPane';
 import { AclPane } from './repeater/RepeaterAclPane';
+import { NodeInfoPane } from './repeater/RepeaterNodeInfoPane';
 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';
+import { ContactPathDiscoveryModal } from './ContactPathDiscoveryModal';
 
 // Re-export for backwards compatibility (used by repeaterFormatters.test.ts)
 export { formatDuration, formatClockDrift } from './repeater/repeaterPaneShared';
@@ -32,6 +40,7 @@ interface RepeaterDashboardProps {
   radioLon: number | null;
   radioName: string | null;
   onTrace: () => void;
+  onPathDiscovery: (publicKey: string) => Promise<PathDiscoveryResponse>;
   onToggleNotifications: () => void;
   onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
   onDeleteContact: (publicKey: string) => void;
@@ -48,10 +57,14 @@ export function RepeaterDashboard({
   radioLon,
   radioName,
   onTrace,
+  onPathDiscovery,
   onToggleNotifications,
   onToggleFavorite,
   onDeleteContact,
 }: RepeaterDashboardProps) {
+  const [pathDiscoveryOpen, setPathDiscoveryOpen] = useState(false);
+  const contact = contacts.find((c) => c.public_key === conversation.id) ?? null;
+  const hasAdvertLocation = isValidLocation(contact?.lat ?? null, contact?.lon ?? null);
   const {
     loggedIn,
     loginLoading,
@@ -69,10 +82,19 @@ export function RepeaterDashboard({
     sendFloodAdvert,
     rebootRepeater,
     syncClock,
-  } = useRepeaterDashboard(conversation);
+  } = useRepeaterDashboard(conversation, { hasAdvertLocation });
+  const { password, setPassword, rememberPassword, setRememberPassword, persistAfterLogin } =
+    useRememberedServerPassword('repeater', conversation.id);
 
-  const contact = contacts.find((c) => c.public_key === conversation.id);
   const isFav = isFavorite(favorites, 'contact', conversation.id);
+  const handleRepeaterLogin = async (nextPassword: string) => {
+    await login(nextPassword);
+    persistAfterLogin(nextPassword);
+  };
+  const handleRepeaterGuestLogin = async () => {
+    await loginAsGuest();
+    persistAfterLogin('');
+  };
 
   // Loading all panes indicator
   const anyLoading = Object.values(paneStates).some((s) => s.loading);
@@ -80,8 +102,15 @@ export function RepeaterDashboard({
   return (
     <div className="flex-1 flex flex-col min-h-0">
       {/* Header */}
-      <header className="flex justify-between items-start px-4 py-2.5 border-b border-border gap-2">
-        <span className="flex min-w-0 flex-1 flex-col">
+      <header
+        className={cn(
+          'grid items-start gap-x-2 gap-y-0.5 border-b border-border px-4 py-2.5',
+          contact
+            ? 'grid-cols-[minmax(0,1fr)_auto] min-[1100px]:grid-cols-[minmax(0,1fr)_auto_auto]'
+            : 'grid-cols-[minmax(0,1fr)_auto]'
+        )}
+      >
+        <span className="flex min-w-0 flex-col">
           <span className="flex min-w-0 flex-wrap items-baseline gap-x-2 gap-y-0.5">
             <span className="flex min-w-0 flex-1 items-baseline gap-2">
               <span className="min-w-0 flex-shrink truncate font-semibold text-base">
@@ -101,14 +130,14 @@ export function RepeaterDashboard({
                 {conversation.id}
               </span>
             </span>
-            {contact && (
-              <span className="min-w-0 flex-none text-[11px] text-muted-foreground max-sm:basis-full">
-                <ContactStatusInfo contact={contact} ourLat={radioLat} ourLon={radioLon} />
-              </span>
-            )}
           </span>
         </span>
-        <div className="flex items-center gap-0.5 flex-shrink-0">
+        {contact && (
+          <div className="col-span-2 row-start-2 min-w-0 text-[11px] text-muted-foreground min-[1100px]:col-span-1 min-[1100px]:col-start-2 min-[1100px]:row-start-1">
+            <ContactStatusInfo contact={contact} ourLat={radioLat} ourLon={radioLon} />
+          </div>
+        )}
+        <div className="flex items-center gap-0.5">
           {loggedIn && (
             <Button
               variant="outline"
@@ -120,13 +149,23 @@ export function RepeaterDashboard({
               {anyLoading ? 'Loading...' : 'Load All'}
             </Button>
           )}
+          {contact && (
+            <button
+              className="p-1 rounded hover:bg-accent text-lg leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              onClick={() => setPathDiscoveryOpen(true)}
+              title="Path Discovery. Send a routed probe and inspect the forward and return paths"
+              aria-label="Path Discovery"
+            >
+              <Route className="h-4 w-4 text-muted-foreground" aria-hidden="true" />
+            </button>
+          )}
           <button
             className="p-1 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"
           >
-            <Route className="h-4 w-4" aria-hidden="true" />
+            <DirectTraceIcon className="h-4 w-4 text-muted-foreground" />
           </button>
           {notificationsSupported && (
             <button
@@ -182,6 +221,16 @@ export function RepeaterDashboard({
             <Trash2 className="h-4 w-4" aria-hidden="true" />
           </button>
         </div>
+        {contact && (
+          <ContactPathDiscoveryModal
+            open={pathDiscoveryOpen}
+            onClose={() => setPathDiscoveryOpen(false)}
+            contact={contact}
+            contacts={contacts}
+            radioName={radioName}
+            onDiscover={onPathDiscovery}
+          />
+        )}
       </header>
 
       {/* Body */}
@@ -191,14 +240,24 @@ export function RepeaterDashboard({
             repeaterName={conversation.name}
             loading={loginLoading}
             error={loginError}
-            onLogin={login}
-            onLoginAsGuest={loginAsGuest}
+            password={password}
+            onPasswordChange={setPassword}
+            rememberPassword={rememberPassword}
+            onRememberPasswordChange={setRememberPassword}
+            onLogin={handleRepeaterLogin}
+            onLoginAsGuest={handleRepeaterGuestLogin}
           />
         ) : (
           <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">
+            {/* Top row: Telemetry + Radio Settings | Node Info + Neighbors */}
+            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
               <div className="flex flex-col gap-4">
+                <NodeInfoPane
+                  data={paneData.nodeInfo}
+                  state={paneStates.nodeInfo}
+                  onRefresh={() => refreshPane('nodeInfo')}
+                  disabled={anyLoading}
+                />
                 <TelemetryPane
                   data={paneData.status}
                   state={paneStates.status}
@@ -221,16 +280,19 @@ export function RepeaterDashboard({
                   disabled={anyLoading}
                 />
               </div>
-              <NeighborsPane
-                data={paneData.neighbors}
-                state={paneStates.neighbors}
-                onRefresh={() => refreshPane('neighbors')}
-                disabled={anyLoading}
-                contacts={contacts}
-                radioLat={radioLat}
-                radioLon={radioLon}
-                radioName={radioName}
-              />
+              <div className="flex min-h-0 flex-col gap-4">
+                <NeighborsPane
+                  data={paneData.neighbors}
+                  state={paneStates.neighbors}
+                  onRefresh={() => refreshPane('neighbors')}
+                  disabled={anyLoading}
+                  repeaterContact={contact}
+                  contacts={contacts}
+                  nodeInfo={paneData.nodeInfo}
+                  nodeInfoState={paneStates.nodeInfo}
+                  repeaterName={conversation.name}
+                />
+              </div>
             </div>
 
             {/* Remaining panes: ACL | Owner Info + Actions */}

frontend/src/components/RepeaterLogin.tsx

@@ -1,24 +1,39 @@
-import { useState, useCallback, type FormEvent } from 'react';
+import { useCallback, type FormEvent } from 'react';
 import { Input } from './ui/input';
 import { Button } from './ui/button';
+import { Checkbox } from './ui/checkbox';
 
 interface RepeaterLoginProps {
   repeaterName: string;
   loading: boolean;
   error: string | null;
+  password: string;
+  onPasswordChange: (password: string) => void;
+  rememberPassword: boolean;
+  onRememberPasswordChange: (checked: boolean) => void;
   onLogin: (password: string) => Promise<void>;
   onLoginAsGuest: () => Promise<void>;
+  description?: string;
+  passwordPlaceholder?: string;
+  loginLabel?: string;
+  guestLabel?: string;
 }
 
 export function RepeaterLogin({
   repeaterName,
   loading,
   error,
+  password,
+  onPasswordChange,
+  rememberPassword,
+  onRememberPasswordChange,
   onLogin,
   onLoginAsGuest,
+  description = 'Log in to access repeater dashboard',
+  passwordPlaceholder = 'Repeater password...',
+  loginLabel = 'Login with Password',
+  guestLabel = 'Login as Guest / ACLs',
 }: RepeaterLoginProps) {
-  const [password, setPassword] = useState('');
-
   const handleSubmit = useCallback(
     async (e: FormEvent) => {
       e.preventDefault();
@@ -33,7 +48,7 @@ export function RepeaterLogin({
       <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>
+          <p className="text-sm text-muted-foreground">{description}</p>
         </div>
 
         <form onSubmit={handleSubmit} className="space-y-4" autoComplete="off">
@@ -45,13 +60,34 @@ export function RepeaterLogin({
             data-1p-ignore="true"
             data-bwignore="true"
             value={password}
-            onChange={(e) => setPassword(e.target.value)}
-            placeholder="Repeater password..."
+            onChange={(e) => onPasswordChange(e.target.value)}
+            placeholder={passwordPlaceholder}
             aria-label="Repeater password"
             disabled={loading}
             autoFocus
           />
 
+          <label
+            htmlFor="remember-server-password"
+            className="flex items-center gap-2 text-sm text-muted-foreground"
+          >
+            <Checkbox
+              id="remember-server-password"
+              checked={rememberPassword}
+              disabled={loading}
+              onCheckedChange={(checked) => onRememberPasswordChange(checked === true)}
+            />
+            <span>Remember password</span>
+          </label>
+
+          {rememberPassword && (
+            <p className="text-xs text-muted-foreground">
+              Passwords are stored unencrypted in local browser storage for this domain. It is
+              highly recommended to login via ACLs after your first successful login; saving the
+              password is not recommended.
+            </p>
+          )}
+
           {error && (
             <p className="text-sm text-destructive text-center" role="alert">
               {error}
@@ -60,7 +96,7 @@ export function RepeaterLogin({
 
           <div className="flex flex-col gap-2">
             <Button type="submit" disabled={loading} className="w-full">
-              {loading ? 'Logging in...' : 'Login with Password'}
+              {loading ? 'Logging in...' : loginLabel}
             </Button>
             <Button
               type="button"
@@ -69,7 +105,7 @@ export function RepeaterLogin({
               className="w-full"
               onClick={onLoginAsGuest}
             >
-              Login as Guest / ACLs
+              {guestLabel}
             </Button>
           </div>
         </form>

frontend/src/components/RoomServerPanel.tsx

@@ -0,0 +1,312 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { api } from '../api';
+import { toast } from './ui/sonner';
+import { Button } from './ui/button';
+import type {
+  Contact,
+  PaneState,
+  RepeaterAclResponse,
+  RepeaterLppTelemetryResponse,
+  RepeaterStatusResponse,
+} from '../types';
+import { TelemetryPane } from './repeater/RepeaterTelemetryPane';
+import { AclPane } from './repeater/RepeaterAclPane';
+import { LppTelemetryPane } from './repeater/RepeaterLppTelemetryPane';
+import { ConsolePane } from './repeater/RepeaterConsolePane';
+import { RepeaterLogin } from './RepeaterLogin';
+import { useRememberedServerPassword } from '../hooks/useRememberedServerPassword';
+
+interface RoomServerPanelProps {
+  contact: Contact;
+  onAuthenticatedChange?: (authenticated: boolean) => void;
+}
+
+type RoomPaneKey = 'status' | 'acl' | 'lppTelemetry';
+
+type RoomPaneData = {
+  status: RepeaterStatusResponse | null;
+  acl: RepeaterAclResponse | null;
+  lppTelemetry: RepeaterLppTelemetryResponse | null;
+};
+
+type RoomPaneStates = Record<RoomPaneKey, PaneState>;
+
+type ConsoleEntry = {
+  command: string;
+  response: string;
+  timestamp: number;
+  outgoing: boolean;
+};
+
+const INITIAL_PANE_STATE: PaneState = {
+  loading: false,
+  attempt: 0,
+  error: null,
+  fetched_at: null,
+};
+
+function createInitialPaneStates(): RoomPaneStates {
+  return {
+    status: { ...INITIAL_PANE_STATE },
+    acl: { ...INITIAL_PANE_STATE },
+    lppTelemetry: { ...INITIAL_PANE_STATE },
+  };
+}
+
+export function RoomServerPanel({ contact, onAuthenticatedChange }: RoomServerPanelProps) {
+  const { password, setPassword, rememberPassword, setRememberPassword, persistAfterLogin } =
+    useRememberedServerPassword('room', contact.public_key);
+  const [loginLoading, setLoginLoading] = useState(false);
+  const [loginError, setLoginError] = useState<string | null>(null);
+  const [loginMessage, setLoginMessage] = useState<string | null>(null);
+  const [authenticated, setAuthenticated] = useState(false);
+  const [advancedOpen, setAdvancedOpen] = useState(false);
+  const [paneData, setPaneData] = useState<RoomPaneData>({
+    status: null,
+    acl: null,
+    lppTelemetry: null,
+  });
+  const [paneStates, setPaneStates] = useState<RoomPaneStates>(createInitialPaneStates);
+  const [consoleHistory, setConsoleHistory] = useState<ConsoleEntry[]>([]);
+  const [consoleLoading, setConsoleLoading] = useState(false);
+
+  useEffect(() => {
+    setLoginLoading(false);
+    setLoginError(null);
+    setLoginMessage(null);
+    setAuthenticated(false);
+    setAdvancedOpen(false);
+    setPaneData({
+      status: null,
+      acl: null,
+      lppTelemetry: null,
+    });
+    setPaneStates(createInitialPaneStates());
+    setConsoleHistory([]);
+    setConsoleLoading(false);
+  }, [contact.public_key]);
+
+  useEffect(() => {
+    onAuthenticatedChange?.(authenticated);
+  }, [authenticated, onAuthenticatedChange]);
+
+  const refreshPane = useCallback(
+    async <K extends RoomPaneKey>(pane: K, loader: () => Promise<RoomPaneData[K]>) => {
+      setPaneStates((prev) => ({
+        ...prev,
+        [pane]: {
+          ...prev[pane],
+          loading: true,
+          attempt: prev[pane].attempt + 1,
+          error: null,
+        },
+      }));
+
+      try {
+        const data = await loader();
+        setPaneData((prev) => ({ ...prev, [pane]: data }));
+        setPaneStates((prev) => ({
+          ...prev,
+          [pane]: {
+            loading: false,
+            attempt: prev[pane].attempt,
+            error: null,
+            fetched_at: Date.now(),
+          },
+        }));
+      } catch (err) {
+        setPaneStates((prev) => ({
+          ...prev,
+          [pane]: {
+            ...prev[pane],
+            loading: false,
+            error: err instanceof Error ? err.message : 'Unknown error',
+          },
+        }));
+      }
+    },
+    []
+  );
+
+  const performLogin = useCallback(
+    async (password: string) => {
+      if (loginLoading) return;
+
+      setLoginLoading(true);
+      setLoginError(null);
+      setLoginMessage(null);
+      try {
+        const result = await api.roomLogin(contact.public_key, password);
+        setAuthenticated(true);
+        setLoginMessage(
+          result.message ??
+            (result.authenticated
+              ? 'Login confirmed. You can now send room messages and open admin tools.'
+              : 'Login request sent, but authentication was not confirmed.')
+        );
+        if (result.authenticated) {
+          toast.success('Room login confirmed');
+        } else {
+          toast(result.message ?? 'Room login was not confirmed');
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        setAuthenticated(true);
+        setLoginError(message);
+        toast.error('Room login failed', { description: message });
+      } finally {
+        setLoginLoading(false);
+      }
+    },
+    [contact.public_key, loginLoading]
+  );
+
+  const handleLogin = useCallback(
+    async (password: string) => {
+      await performLogin(password);
+      persistAfterLogin(password);
+    },
+    [performLogin, persistAfterLogin]
+  );
+
+  const handleLoginAsGuest = useCallback(async () => {
+    await performLogin('');
+    persistAfterLogin('');
+  }, [performLogin, persistAfterLogin]);
+
+  const handleConsoleCommand = useCallback(
+    async (command: string) => {
+      setConsoleLoading(true);
+      const timestamp = Date.now();
+      setConsoleHistory((prev) => [
+        ...prev,
+        { command, response: command, timestamp, outgoing: true },
+      ]);
+      try {
+        const response = await api.sendRepeaterCommand(contact.public_key, command);
+        setConsoleHistory((prev) => [
+          ...prev,
+          {
+            command,
+            response: response.response,
+            timestamp: Date.now(),
+            outgoing: false,
+          },
+        ]);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        setConsoleHistory((prev) => [
+          ...prev,
+          {
+            command,
+            response: `(error) ${message}`,
+            timestamp: Date.now(),
+            outgoing: false,
+          },
+        ]);
+      } finally {
+        setConsoleLoading(false);
+      }
+    },
+    [contact.public_key]
+  );
+
+  const panelTitle = useMemo(() => contact.name || contact.public_key.slice(0, 12), [contact]);
+
+  if (!authenticated) {
+    return (
+      <div className="flex-1 overflow-y-auto p-4">
+        <div className="mx-auto flex w-full max-w-sm flex-col gap-4">
+          <div className="rounded-md border border-warning/30 bg-warning/10 px-4 py-3 text-sm text-warning">
+            Room server access is experimental and in public alpha. Please report any issues on{' '}
+            <a
+              href="https://github.com/jkingsman/Remote-Terminal-for-MeshCore/issues"
+              target="_blank"
+              rel="noreferrer"
+              className="font-medium underline underline-offset-2 hover:text-warning/80"
+            >
+              GitHub
+            </a>
+            .
+          </div>
+          <RepeaterLogin
+            repeaterName={panelTitle}
+            loading={loginLoading}
+            error={loginError}
+            password={password}
+            onPasswordChange={setPassword}
+            rememberPassword={rememberPassword}
+            onRememberPasswordChange={setRememberPassword}
+            onLogin={handleLogin}
+            onLoginAsGuest={handleLoginAsGuest}
+            description="Log in with the room password or use ACL/guest access to enter this room server"
+            passwordPlaceholder="Room server password..."
+            guestLabel="Login with ACL / Guest"
+          />
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <section className="border-b border-border bg-muted/20 px-4 py-3">
+      <div className="flex flex-col gap-3">
+        <div className="flex flex-col gap-2 lg:flex-row lg:items-center lg:justify-between">
+          <div className="space-y-1">
+            <div className="text-sm font-medium">Room Server Controls</div>
+            <p className="text-xs text-muted-foreground">
+              Room access is active. Use the chat history and message box below to participate, and
+              open admin tools when needed.
+            </p>
+            {loginMessage && <p className="text-xs text-muted-foreground">{loginMessage}</p>}
+          </div>
+          <div className="flex w-full flex-col gap-2 sm:flex-row lg:w-auto">
+            <Button
+              type="button"
+              variant="outline"
+              onClick={handleLoginAsGuest}
+              disabled={loginLoading}
+            >
+              Refresh ACL Login
+            </Button>
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => setAdvancedOpen((prev) => !prev)}
+            >
+              {advancedOpen ? 'Hide Tools' : 'Show Tools'}
+            </Button>
+          </div>
+        </div>
+
+        {advancedOpen && (
+          <div className="grid gap-3 xl:grid-cols-2">
+            <TelemetryPane
+              data={paneData.status}
+              state={paneStates.status}
+              onRefresh={() => refreshPane('status', () => api.roomStatus(contact.public_key))}
+            />
+            <AclPane
+              data={paneData.acl}
+              state={paneStates.acl}
+              onRefresh={() => refreshPane('acl', () => api.roomAcl(contact.public_key))}
+            />
+            <LppTelemetryPane
+              data={paneData.lppTelemetry}
+              state={paneStates.lppTelemetry}
+              onRefresh={() =>
+                refreshPane('lppTelemetry', () => api.roomLppTelemetry(contact.public_key))
+              }
+            />
+            <ConsolePane
+              history={consoleHistory}
+              loading={consoleLoading}
+              onSend={handleConsoleCommand}
+            />
+          </div>
+        )}
+      </div>
+    </section>
+  );
+}

frontend/src/components/SearchView.tsx

@@ -31,6 +31,7 @@ export interface SearchNavigateTarget {
 export interface SearchViewProps {
   contacts: Contact[];
   channels: Channel[];
+  visibilityVersion?: number;
   onNavigateToMessage: (target: SearchNavigateTarget) => void;
   prefillRequest?: {
     query: string;
@@ -84,6 +85,7 @@ function getHighlightQuery(query: string): string {
 export function SearchView({
   contacts,
   channels,
+  visibilityVersion = 0,
   onNavigateToMessage,
   prefillRequest = null,
 }: SearchViewProps) {
@@ -110,7 +112,7 @@ export function SearchView({
     setResults([]);
     setOffset(0);
     setHasMore(false);
-  }, [debouncedQuery]);
+  }, [debouncedQuery, visibilityVersion]);
 
   useEffect(() => {
     if (!prefillRequest) {
@@ -123,6 +125,12 @@ export function SearchView({
     inputRef.current?.focus();
   }, [prefillRequest]);
 
+  useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+
   // Fetch search results
   useEffect(() => {
     if (!debouncedQuery) {
@@ -153,7 +161,7 @@ export function SearchView({
       });
 
     return () => controller.abort();
-  }, [debouncedQuery]);
+  }, [debouncedQuery, visibilityVersion]);
 
   const loadMore = useCallback(() => {
     if (!debouncedQuery || loading) return;
@@ -243,6 +251,11 @@ export function SearchView({
               Tip: use <code>user:</code> or <code>channel:</code> for keys or names, and wrap names
               with spaces in them in quotes.
             </p>
+            <p className="mt-2 text-xs">
+              Warning: User-key linkage for group messages is best-effort and based on correlation
+              at advertise time. It does not account for multiple users with the same name, and
+              should be considered unreliable.
+            </p>
           </div>
         )}
 

frontend/src/components/SettingsModal.tsx

@@ -3,8 +3,11 @@ import type {
   AppSettings,
   AppSettingsUpdate,
   HealthStatus,
+  RadioAdvertMode,
   RadioConfig,
   RadioConfigUpdate,
+  RadioDiscoveryResponse,
+  RadioDiscoveryTarget,
 } from '../types';
 import type { LocalLabel } from '../utils/localLabel';
 import {
@@ -33,7 +36,10 @@ interface SettingsModalBaseProps {
   onReboot: () => Promise<void>;
   onDisconnect: () => Promise<void>;
   onReconnect: () => Promise<void>;
-  onAdvertise: () => Promise<void>;
+  onAdvertise: (mode: RadioAdvertMode) => Promise<void>;
+  meshDiscovery: RadioDiscoveryResponse | null;
+  meshDiscoveryLoadingTarget: RadioDiscoveryTarget | null;
+  onDiscoverMesh: (target: RadioDiscoveryTarget) => Promise<void>;
   onHealthRefresh: () => Promise<void>;
   onRefreshAppSettings: () => Promise<void>;
   onLocalLabelChange?: (label: LocalLabel) => void;
@@ -64,6 +70,9 @@ export function SettingsModal(props: SettingsModalProps) {
     onDisconnect,
     onReconnect,
     onAdvertise,
+    meshDiscovery,
+    meshDiscoveryLoadingTarget,
+    onDiscoverMesh,
     onHealthRefresh,
     onRefreshAppSettings,
     onLocalLabelChange,
@@ -169,30 +178,38 @@ export function SettingsModal(props: SettingsModalProps) {
     return null;
   }
 
-  return !config ? (
-    <div className="py-8 text-center text-muted-foreground">Loading configuration...</div>
-  ) : (
+  return (
     <div className={settingsContainerClass}>
       {shouldRenderSection('radio') && (
         <section className={sectionWrapperClass}>
           {renderSectionHeader('radio')}
-          {isSectionVisible('radio') && appSettings && (
-            <SettingsRadioSection
-              config={config}
-              health={health}
-              appSettings={appSettings}
-              pageMode={pageMode}
-              onSave={onSave}
-              onSaveAppSettings={onSaveAppSettings}
-              onSetPrivateKey={onSetPrivateKey}
-              onReboot={onReboot}
-              onDisconnect={onDisconnect}
-              onReconnect={onReconnect}
-              onAdvertise={onAdvertise}
-              onClose={onClose}
-              className={sectionContentClass}
-            />
-          )}
+          {isSectionVisible('radio') &&
+            (config && appSettings ? (
+              <SettingsRadioSection
+                config={config}
+                health={health}
+                appSettings={appSettings}
+                pageMode={pageMode}
+                onSave={onSave}
+                onSaveAppSettings={onSaveAppSettings}
+                onSetPrivateKey={onSetPrivateKey}
+                onReboot={onReboot}
+                onDisconnect={onDisconnect}
+                onReconnect={onReconnect}
+                onAdvertise={onAdvertise}
+                meshDiscovery={meshDiscovery}
+                meshDiscoveryLoadingTarget={meshDiscoveryLoadingTarget}
+                onDiscoverMesh={onDiscoverMesh}
+                onClose={onClose}
+                className={sectionContentClass}
+              />
+            ) : (
+              <div className={sectionContentClass}>
+                <div className="flex items-center justify-center py-12 text-sm text-muted-foreground">
+                  Radio is not available.
+                </div>
+              </div>
+            ))}
         </section>
       )}
 
@@ -211,19 +228,26 @@ export function SettingsModal(props: SettingsModalProps) {
       {shouldRenderSection('database') && (
         <section className={sectionWrapperClass}>
           {renderSectionHeader('database')}
-          {isSectionVisible('database') && appSettings && (
-            <SettingsDatabaseSection
-              appSettings={appSettings}
-              health={health}
-              onSaveAppSettings={onSaveAppSettings}
-              onHealthRefresh={onHealthRefresh}
-              blockedKeys={blockedKeys}
-              blockedNames={blockedNames}
-              onToggleBlockedKey={onToggleBlockedKey}
-              onToggleBlockedName={onToggleBlockedName}
-              className={sectionContentClass}
-            />
-          )}
+          {isSectionVisible('database') &&
+            (appSettings ? (
+              <SettingsDatabaseSection
+                appSettings={appSettings}
+                health={health}
+                onSaveAppSettings={onSaveAppSettings}
+                onHealthRefresh={onHealthRefresh}
+                blockedKeys={blockedKeys}
+                blockedNames={blockedNames}
+                onToggleBlockedKey={onToggleBlockedKey}
+                onToggleBlockedName={onToggleBlockedName}
+                className={sectionContentClass}
+              />
+            ) : (
+              <div className={sectionContentClass}>
+                <div className="rounded-md border border-input bg-muted/20 px-4 py-3 text-sm text-muted-foreground">
+                  Loading app settings...
+                </div>
+              </div>
+            ))}
         </section>
       )}
 
@@ -252,7 +276,9 @@ export function SettingsModal(props: SettingsModalProps) {
       {shouldRenderSection('about') && (
         <section className={sectionWrapperClass}>
           {renderSectionHeader('about')}
-          {isSectionVisible('about') && <SettingsAboutSection className={sectionContentClass} />}
+          {isSectionVisible('about') && (
+            <SettingsAboutSection health={health} className={sectionContentClass} />
+          )}
         </section>
       )}
     </div>

frontend/src/components/Sidebar.tsx

@@ -5,21 +5,33 @@ import {
   ChevronDown,
   ChevronRight,
   LockOpen,
+  Logs,
   Map,
   Search as SearchIcon,
-  Sparkles,
   SquarePen,
   Waypoints,
   X,
 } from 'lucide-react';
 import {
+  CONTACT_TYPE_ROOM,
   CONTACT_TYPE_REPEATER,
   type Contact,
   type Channel,
   type Conversation,
   type Favorite,
 } from '../types';
-import { getStateKey, type ConversationTimes, type SortOrder } from '../utils/conversationState';
+import {
+  buildSidebarSectionSortOrders,
+  getStateKey,
+  loadLegacyLocalStorageSortOrder,
+  loadLocalStorageSidebarSectionSortOrders,
+  saveLocalStorageSidebarSectionSortOrders,
+  type ConversationTimes,
+  type SidebarSectionSortOrders,
+  type SidebarSortableSection,
+  type SortOrder,
+} from '../utils/conversationState';
+import { isPublicChannelKey } from '../utils/publicChannel';
 import { getContactDisplayName } from '../utils/pubkey';
 import { handleKeyboardActivate } from '../utils/a11y';
 import { ContactAvatar } from './ContactAvatar';
@@ -46,6 +58,7 @@ type CollapseState = {
   favorites: boolean;
   channels: boolean;
   contacts: boolean;
+  rooms: boolean;
   repeaters: boolean;
 };
 
@@ -56,6 +69,7 @@ const DEFAULT_COLLAPSE_STATE: CollapseState = {
   favorites: false,
   channels: false,
   contacts: false,
+  rooms: false,
   repeaters: false,
 };
 
@@ -69,6 +83,7 @@ function loadCollapsedState(): CollapseState {
       favorites: parsed.favorites ?? DEFAULT_COLLAPSE_STATE.favorites,
       channels: parsed.channels ?? DEFAULT_COLLAPSE_STATE.channels,
       contacts: parsed.contacts ?? DEFAULT_COLLAPSE_STATE.contacts,
+      rooms: parsed.rooms ?? DEFAULT_COLLAPSE_STATE.rooms,
       repeaters: parsed.repeaters ?? DEFAULT_COLLAPSE_STATE.repeaters,
     };
   } catch {
@@ -91,13 +106,36 @@ interface SidebarProps {
   onToggleCracker: () => void;
   onMarkAllRead: () => void;
   favorites: Favorite[];
-  /** Sort order from server settings */
-  sortOrder?: SortOrder;
-  /** Callback when sort order changes */
-  onSortOrderChange?: (order: SortOrder) => void;
+  /** Legacy global sort order, used only to seed per-section local preferences. */
+  legacySortOrder?: SortOrder;
   isConversationNotificationsEnabled?: (type: 'channel' | 'contact', id: string) => boolean;
 }
 
+type InitialSectionSortState = {
+  orders: SidebarSectionSortOrders;
+  source: 'section' | 'legacy' | 'none';
+};
+
+function loadInitialSectionSortOrders(): InitialSectionSortState {
+  const storedOrders = loadLocalStorageSidebarSectionSortOrders();
+  if (storedOrders) {
+    return { orders: storedOrders, source: 'section' };
+  }
+
+  const legacyOrder = loadLegacyLocalStorageSortOrder();
+  if (legacyOrder) {
+    return {
+      orders: buildSidebarSectionSortOrders(legacyOrder),
+      source: 'legacy',
+    };
+  }
+
+  return {
+    orders: buildSidebarSectionSortOrders(),
+    source: 'none',
+  };
+}
+
 export function Sidebar({
   contacts,
   channels,
@@ -112,23 +150,45 @@ export function Sidebar({
   onToggleCracker,
   onMarkAllRead,
   favorites,
-  sortOrder: sortOrderProp = 'recent',
-  onSortOrderChange,
+  legacySortOrder,
   isConversationNotificationsEnabled,
 }: SidebarProps) {
-  const sortOrder = sortOrderProp;
   const [searchQuery, setSearchQuery] = useState('');
+  const initialSectionSortState = useMemo(loadInitialSectionSortOrders, []);
+  const [sectionSortOrders, setSectionSortOrders] = useState(initialSectionSortState.orders);
   const initialCollapsedState = useMemo(loadCollapsedState, []);
   const [toolsCollapsed, setToolsCollapsed] = useState(initialCollapsedState.tools);
   const [favoritesCollapsed, setFavoritesCollapsed] = useState(initialCollapsedState.favorites);
   const [channelsCollapsed, setChannelsCollapsed] = useState(initialCollapsedState.channels);
   const [contactsCollapsed, setContactsCollapsed] = useState(initialCollapsedState.contacts);
+  const [roomsCollapsed, setRoomsCollapsed] = useState(initialCollapsedState.rooms);
   const [repeatersCollapsed, setRepeatersCollapsed] = useState(initialCollapsedState.repeaters);
   const collapseSnapshotRef = useRef<CollapseState | null>(null);
+  const sectionSortSourceRef = useRef(initialSectionSortState.source);
 
-  const handleSortToggle = () => {
-    const newOrder = sortOrder === 'alpha' ? 'recent' : 'alpha';
-    onSortOrderChange?.(newOrder);
+  useEffect(() => {
+    if (sectionSortSourceRef.current === 'legacy') {
+      saveLocalStorageSidebarSectionSortOrders(sectionSortOrders);
+      sectionSortSourceRef.current = 'section';
+      return;
+    }
+
+    if (sectionSortSourceRef.current !== 'none' || legacySortOrder === undefined) return;
+
+    const seededOrders = buildSidebarSectionSortOrders(legacySortOrder);
+    setSectionSortOrders(seededOrders);
+    saveLocalStorageSidebarSectionSortOrders(seededOrders);
+    sectionSortSourceRef.current = 'section';
+  }, [legacySortOrder, sectionSortOrders]);
+
+  const handleSortToggle = (section: SidebarSortableSection) => {
+    setSectionSortOrders((prev) => {
+      const nextOrder = prev[section] === 'alpha' ? 'recent' : 'alpha';
+      const updated = { ...prev, [section]: nextOrder };
+      saveLocalStorageSidebarSectionSortOrders(updated);
+      sectionSortSourceRef.current = 'section';
+      return updated;
+    });
   };
 
   const handleSelectConversation = (conversation: Conversation) => {
@@ -161,6 +221,20 @@ export function Sidebar({
     [lastMessageTimes]
   );
 
+  const getContactHeardTime = useCallback((contact: Contact): number => {
+    return Math.max(contact.last_seen ?? 0, contact.last_advert ?? 0);
+  }, []);
+
+  const getContactRecentTime = useCallback(
+    (contact: Contact): number => {
+      if (contact.type === CONTACT_TYPE_REPEATER) {
+        return getContactHeardTime(contact);
+      }
+      return getLastMessageTime('contact', contact.public_key) || getContactHeardTime(contact);
+    },
+    [getContactHeardTime, getLastMessageTime]
+  );
+
   // Deduplicate channels by key only.
   // Channel names are not unique; distinct keys must remain visible.
   const uniqueChannels = useMemo(
@@ -200,10 +274,10 @@ export function Sidebar({
     () =>
       [...uniqueChannels].sort((a, b) => {
         // Public channel always sorts to the top
-        if (a.name === 'Public') return -1;
-        if (b.name === 'Public') return 1;
+        if (isPublicChannelKey(a.key)) return -1;
+        if (isPublicChannelKey(b.key)) return 1;
 
-        if (sortOrder === 'recent') {
+        if (sectionSortOrders.channels === 'recent') {
           const timeA = getLastMessageTime('channel', a.key);
           const timeB = getLastMessageTime('channel', b.key);
           if (timeA && timeB) return timeB - timeA;
@@ -212,33 +286,101 @@ export function Sidebar({
         }
         return a.name.localeCompare(b.name);
       }),
-    [uniqueChannels, sortOrder, getLastMessageTime]
+    [uniqueChannels, sectionSortOrders.channels, getLastMessageTime]
   );
 
   const sortContactsByOrder = useCallback(
-    (items: Contact[]) =>
+    (items: Contact[], order: SortOrder) =>
       [...items].sort((a, b) => {
-        if (sortOrder === 'recent') {
-          const timeA = getLastMessageTime('contact', a.public_key);
-          const timeB = getLastMessageTime('contact', b.public_key);
+        if (order === 'recent') {
+          const timeA = getContactRecentTime(a);
+          const timeB = getContactRecentTime(b);
           if (timeA && timeB) return timeB - timeA;
           if (timeA && !timeB) return -1;
           if (!timeA && timeB) return 1;
         }
         return (a.name || a.public_key).localeCompare(b.name || b.public_key);
       }),
-    [sortOrder, getLastMessageTime]
+    [getContactRecentTime]
+  );
+
+  const sortRepeatersByOrder = useCallback(
+    (items: Contact[], order: SortOrder) =>
+      [...items].sort((a, b) => {
+        if (order === 'recent') {
+          const timeA = getContactHeardTime(a);
+          const timeB = getContactHeardTime(b);
+          if (timeA && timeB) return timeB - timeA;
+          if (timeA && !timeB) return -1;
+          if (!timeA && timeB) return 1;
+        }
+        return (a.name || a.public_key).localeCompare(b.name || b.public_key);
+      }),
+    [getContactHeardTime]
+  );
+
+  const getFavoriteItemName = useCallback(
+    (item: FavoriteItem) =>
+      item.type === 'channel'
+        ? item.channel.name
+        : getContactDisplayName(
+            item.contact.name,
+            item.contact.public_key,
+            item.contact.last_advert
+          ),
+    []
+  );
+
+  const sortFavoriteItemsByOrder = useCallback(
+    (items: FavoriteItem[], order: SortOrder) =>
+      [...items].sort((a, b) => {
+        if (order === 'recent') {
+          const timeA =
+            a.type === 'channel'
+              ? getLastMessageTime('channel', a.channel.key)
+              : getContactRecentTime(a.contact);
+          const timeB =
+            b.type === 'channel'
+              ? getLastMessageTime('channel', b.channel.key)
+              : getContactRecentTime(b.contact);
+          if (timeA && timeB) return timeB - timeA;
+          if (timeA && !timeB) return -1;
+          if (!timeA && timeB) return 1;
+        }
+
+        return getFavoriteItemName(a).localeCompare(getFavoriteItemName(b));
+      }),
+    [getContactRecentTime, getFavoriteItemName, getLastMessageTime]
   );
 
   // Split non-repeater contacts and repeater contacts into separate sorted lists
   const sortedNonRepeaterContacts = useMemo(
-    () => sortContactsByOrder(uniqueContacts.filter((c) => c.type !== CONTACT_TYPE_REPEATER)),
-    [uniqueContacts, sortContactsByOrder]
+    () =>
+      sortContactsByOrder(
+        uniqueContacts.filter(
+          (c) => c.type !== CONTACT_TYPE_REPEATER && c.type !== CONTACT_TYPE_ROOM
+        ),
+        sectionSortOrders.contacts
+      ),
+    [uniqueContacts, sectionSortOrders.contacts, sortContactsByOrder]
+  );
+
+  const sortedRooms = useMemo(
+    () =>
+      sortContactsByOrder(
+        uniqueContacts.filter((c) => c.type === CONTACT_TYPE_ROOM),
+        sectionSortOrders.rooms
+      ),
+    [uniqueContacts, sectionSortOrders.rooms, sortContactsByOrder]
   );
 
   const sortedRepeaters = useMemo(
-    () => sortContactsByOrder(uniqueContacts.filter((c) => c.type === CONTACT_TYPE_REPEATER)),
-    [uniqueContacts, sortContactsByOrder]
+    () =>
+      sortRepeatersByOrder(
+        uniqueContacts.filter((c) => c.type === CONTACT_TYPE_REPEATER),
+        sectionSortOrders.repeaters
+      ),
+    [uniqueContacts, sectionSortOrders.repeaters, sortRepeatersByOrder]
   );
 
   // Filter by search query
@@ -266,6 +408,17 @@ export function Sidebar({
     [sortedNonRepeaterContacts, query]
   );
 
+  const filteredRooms = useMemo(
+    () =>
+      query
+        ? sortedRooms.filter(
+            (c) =>
+              c.name?.toLowerCase().includes(query) || c.public_key.toLowerCase().includes(query)
+          )
+        : sortedRooms,
+    [sortedRooms, query]
+  );
+
   const filteredRepeaters = useMemo(
     () =>
       query
@@ -286,6 +439,7 @@ export function Sidebar({
           favorites: favoritesCollapsed,
           channels: channelsCollapsed,
           contacts: contactsCollapsed,
+          rooms: roomsCollapsed,
           repeaters: repeatersCollapsed,
         };
       }
@@ -295,12 +449,14 @@ export function Sidebar({
         favoritesCollapsed ||
         channelsCollapsed ||
         contactsCollapsed ||
+        roomsCollapsed ||
         repeatersCollapsed
       ) {
         setToolsCollapsed(false);
         setFavoritesCollapsed(false);
         setChannelsCollapsed(false);
         setContactsCollapsed(false);
+        setRoomsCollapsed(false);
         setRepeatersCollapsed(false);
       }
       return;
@@ -313,6 +469,7 @@ export function Sidebar({
       setFavoritesCollapsed(prev.favorites);
       setChannelsCollapsed(prev.channels);
       setContactsCollapsed(prev.contacts);
+      setRoomsCollapsed(prev.rooms);
       setRepeatersCollapsed(prev.repeaters);
     }
   }, [
@@ -321,6 +478,7 @@ export function Sidebar({
     favoritesCollapsed,
     channelsCollapsed,
     contactsCollapsed,
+    roomsCollapsed,
     repeatersCollapsed,
   ]);
 
@@ -332,6 +490,7 @@ export function Sidebar({
       favorites: favoritesCollapsed,
       channels: channelsCollapsed,
       contacts: contactsCollapsed,
+      rooms: roomsCollapsed,
       repeaters: repeatersCollapsed,
     };
 
@@ -346,61 +505,56 @@ export function Sidebar({
     favoritesCollapsed,
     channelsCollapsed,
     contactsCollapsed,
+    roomsCollapsed,
     repeatersCollapsed,
   ]);
 
   // Separate favorites from regular items, and build combined favorites list
-  const { favoriteItems, nonFavoriteChannels, nonFavoriteContacts, nonFavoriteRepeaters } =
-    useMemo(() => {
-      const favChannels = filteredChannels.filter((c) => isFavorite(favorites, 'channel', c.key));
-      const favContacts = [...filteredNonRepeaterContacts, ...filteredRepeaters].filter((c) =>
-        isFavorite(favorites, 'contact', c.public_key)
-      );
-      const nonFavChannels = filteredChannels.filter(
-        (c) => !isFavorite(favorites, 'channel', c.key)
-      );
-      const nonFavContacts = filteredNonRepeaterContacts.filter(
-        (c) => !isFavorite(favorites, 'contact', c.public_key)
-      );
-      const nonFavRepeaters = filteredRepeaters.filter(
-        (c) => !isFavorite(favorites, 'contact', c.public_key)
-      );
+  const {
+    favoriteItems,
+    nonFavoriteChannels,
+    nonFavoriteContacts,
+    nonFavoriteRooms,
+    nonFavoriteRepeaters,
+  } = useMemo(() => {
+    const favChannels = filteredChannels.filter((c) => isFavorite(favorites, 'channel', c.key));
+    const favContacts = [
+      ...filteredNonRepeaterContacts,
+      ...filteredRooms,
+      ...filteredRepeaters,
+    ].filter((c) => isFavorite(favorites, 'contact', c.public_key));
+    const nonFavChannels = filteredChannels.filter((c) => !isFavorite(favorites, 'channel', c.key));
+    const nonFavContacts = filteredNonRepeaterContacts.filter(
+      (c) => !isFavorite(favorites, 'contact', c.public_key)
+    );
+    const nonFavRooms = filteredRooms.filter(
+      (c) => !isFavorite(favorites, 'contact', c.public_key)
+    );
+    const nonFavRepeaters = filteredRepeaters.filter(
+      (c) => !isFavorite(favorites, 'contact', c.public_key)
+    );
 
-      const items: FavoriteItem[] = [
-        ...favChannels.map((channel) => ({ type: 'channel' as const, channel })),
-        ...favContacts.map((contact) => ({ type: 'contact' as const, contact })),
-      ].sort((a, b) => {
-        const timeA =
-          a.type === 'channel'
-            ? getLastMessageTime('channel', a.channel.key)
-            : getLastMessageTime('contact', a.contact.public_key);
-        const timeB =
-          b.type === 'channel'
-            ? getLastMessageTime('channel', b.channel.key)
-            : getLastMessageTime('contact', b.contact.public_key);
-        if (timeA && timeB) return timeB - timeA;
-        if (timeA && !timeB) return -1;
-        if (!timeA && timeB) return 1;
-        const nameA =
-          a.type === 'channel' ? a.channel.name : a.contact.name || a.contact.public_key;
-        const nameB =
-          b.type === 'channel' ? b.channel.name : b.contact.name || b.contact.public_key;
-        return nameA.localeCompare(nameB);
-      });
+    const items: FavoriteItem[] = [
+      ...favChannels.map((channel) => ({ type: 'channel' as const, channel })),
+      ...favContacts.map((contact) => ({ type: 'contact' as const, contact })),
+    ];
 
-      return {
-        favoriteItems: items,
-        nonFavoriteChannels: nonFavChannels,
-        nonFavoriteContacts: nonFavContacts,
-        nonFavoriteRepeaters: nonFavRepeaters,
-      };
-    }, [
-      filteredChannels,
-      filteredNonRepeaterContacts,
-      filteredRepeaters,
-      favorites,
-      getLastMessageTime,
-    ]);
+    return {
+      favoriteItems: sortFavoriteItemsByOrder(items, sectionSortOrders.favorites),
+      nonFavoriteChannels: nonFavChannels,
+      nonFavoriteContacts: nonFavContacts,
+      nonFavoriteRooms: nonFavRooms,
+      nonFavoriteRepeaters: nonFavRepeaters,
+    };
+  }, [
+    filteredChannels,
+    filteredNonRepeaterContacts,
+    filteredRooms,
+    filteredRepeaters,
+    favorites,
+    sectionSortOrders.favorites,
+    sortFavoriteItemsByOrder,
+  ]);
 
   const buildChannelRow = (channel: Channel, keyPrefix: string): ConversationRow => ({
     key: `${keyPrefix}-${channel.key}`,
@@ -416,7 +570,7 @@ export function Sidebar({
     key: `${keyPrefix}-${contact.public_key}`,
     type: 'contact',
     id: contact.public_key,
-    name: getContactDisplayName(contact.name, contact.public_key),
+    name: getContactDisplayName(contact.name, contact.public_key, contact.last_advert),
     unreadCount: getUnreadCount('contact', contact.public_key),
     isMention: hasMention('contact', contact.public_key),
     notificationsEnabled:
@@ -424,57 +578,65 @@ export function Sidebar({
     contact,
   });
 
-  const renderConversationRow = (row: ConversationRow) => (
-    <div
-      key={row.key}
-      className={cn(
-        'px-3 py-2 cursor-pointer flex items-center gap-2 border-l-2 border-transparent hover:bg-accent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',
-        isActive(row.type, row.id) && 'bg-accent border-l-primary',
-        row.unreadCount > 0 && '[&_.name]:font-semibold [&_.name]:text-foreground'
-      )}
-      role="button"
-      tabIndex={0}
-      aria-current={isActive(row.type, row.id) ? 'page' : undefined}
-      onKeyDown={handleKeyboardActivate}
-      onClick={() =>
-        handleSelectConversation({
-          type: row.type,
-          id: row.id,
-          name: row.name,
-        })
-      }
-    >
-      {row.type === 'contact' && row.contact && (
-        <ContactAvatar
-          name={row.contact.name}
-          publicKey={row.contact.public_key}
-          size={24}
-          contactType={row.contact.type}
-        />
-      )}
-      <span className="name flex-1 truncate text-[13px]">{row.name}</span>
-      <span className="ml-auto flex items-center gap-1">
-        {row.notificationsEnabled && (
-          <span aria-label="Notifications enabled" title="Notifications enabled">
-            <Bell className="h-3.5 w-3.5 text-muted-foreground" />
-          </span>
+  const renderConversationRow = (row: ConversationRow) => {
+    const highlightUnread =
+      row.isMention ||
+      (row.type === 'contact' &&
+        row.contact?.type !== CONTACT_TYPE_REPEATER &&
+        row.unreadCount > 0);
+
+    return (
+      <div
+        key={row.key}
+        className={cn(
+          'px-3 py-2 cursor-pointer flex items-center gap-2 border-l-2 border-transparent hover:bg-accent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',
+          isActive(row.type, row.id) && 'bg-accent border-l-primary',
+          row.unreadCount > 0 && '[&_.name]:font-semibold [&_.name]:text-foreground'
         )}
-        {row.unreadCount > 0 && (
-          <span
-            className={cn(
-              'text-[10px] font-semibold px-1.5 py-0.5 rounded-full min-w-[18px] text-center',
-              row.isMention
-                ? 'bg-badge-mention text-badge-mention-foreground'
-                : 'bg-badge-unread/90 text-badge-unread-foreground'
-            )}
-            aria-label={`${row.unreadCount} unread message${row.unreadCount !== 1 ? 's' : ''}`}
-          >
-            {row.unreadCount}
-          </span>
+        role="button"
+        tabIndex={0}
+        aria-current={isActive(row.type, row.id) ? 'page' : undefined}
+        onKeyDown={handleKeyboardActivate}
+        onClick={() =>
+          handleSelectConversation({
+            type: row.type,
+            id: row.id,
+            name: row.name,
+          })
+        }
+      >
+        {row.type === 'contact' && row.contact && (
+          <ContactAvatar
+            name={row.contact.name}
+            publicKey={row.contact.public_key}
+            size={24}
+            contactType={row.contact.type}
+          />
         )}
-      </span>
-    </div>
-  );
+        <span className="name flex-1 truncate text-[13px]">{row.name}</span>
+        <span className="ml-auto flex items-center gap-1">
+          {row.notificationsEnabled && (
+            <span aria-label="Notifications enabled" title="Notifications enabled">
+              <Bell className="h-3.5 w-3.5 text-muted-foreground" />
+            </span>
+          )}
+          {row.unreadCount > 0 && (
+            <span
+              className={cn(
+                'text-[10px] font-semibold px-1.5 py-0.5 rounded-full min-w-[18px] text-center',
+                highlightUnread
+                  ? 'bg-badge-mention text-badge-mention-foreground'
+                  : 'bg-badge-unread/90 text-badge-unread-foreground'
+              )}
+              aria-label={`${row.unreadCount} unread message${row.unreadCount !== 1 ? 's' : ''}`}
+            >
+              {row.unreadCount}
+            </span>
+          )}
+        </span>
+      </div>
+    );
+  };
 
   const renderSidebarActionRow = ({
     key,
@@ -520,11 +682,13 @@ export function Sidebar({
   );
   const channelRows = nonFavoriteChannels.map((channel) => buildChannelRow(channel, 'chan'));
   const contactRows = nonFavoriteContacts.map((contact) => buildContactRow(contact, 'contact'));
+  const roomRows = nonFavoriteRooms.map((contact) => buildContactRow(contact, 'room'));
   const repeaterRows = nonFavoriteRepeaters.map((contact) => buildContactRow(contact, 'repeater'));
 
   const favoritesUnreadCount = getSectionUnreadCount(favoriteRows);
   const channelsUnreadCount = getSectionUnreadCount(channelRows);
   const contactsUnreadCount = getSectionUnreadCount(contactRows);
+  const roomsUnreadCount = getSectionUnreadCount(roomRows);
   const repeatersUnreadCount = getSectionUnreadCount(repeaterRows);
   const favoritesHasMention = sectionHasMention(favoriteRows);
   const channelsHasMention = sectionHasMention(channelRows);
@@ -533,7 +697,7 @@ export function Sidebar({
         renderSidebarActionRow({
           key: 'tool-raw',
           active: isActive('raw', 'raw'),
-          icon: <Waypoints className="h-4 w-4" />,
+          icon: <Logs className="h-4 w-4" />,
           label: 'Packet Feed',
           onClick: () =>
             handleSelectConversation({
@@ -557,7 +721,7 @@ export function Sidebar({
         renderSidebarActionRow({
           key: 'tool-visualizer',
           active: isActive('visualizer', 'visualizer'),
-          icon: <Sparkles className="h-4 w-4" />,
+          icon: <Waypoints className="h-4 w-4" />,
           label: 'Mesh Visualizer',
           onClick: () =>
             handleSelectConversation({
@@ -604,11 +768,12 @@ export function Sidebar({
     title: string,
     collapsed: boolean,
     onToggle: () => void,
-    showSortToggle = false,
+    sortSection: SidebarSortableSection | null = null,
     unreadCount = 0,
     highlightUnread = false
   ) => {
     const effectiveCollapsed = isSearching ? false : collapsed;
+    const sectionSortOrder = sortSection ? sectionSortOrders[sortSection] : null;
 
     return (
       <div className="flex justify-between items-center px-3 py-2 pt-3.5">
@@ -630,16 +795,24 @@ export function Sidebar({
           )}
           <span>{title}</span>
         </button>
-        {(showSortToggle || unreadCount > 0) && (
+        {(sortSection || unreadCount > 0) && (
           <div className="ml-auto flex items-center gap-1.5">
-            {showSortToggle && (
+            {sortSection && sectionSortOrder && (
               <button
                 className="bg-transparent text-muted-foreground/60 px-1 py-0.5 text-[10px] rounded hover:text-foreground transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-                onClick={handleSortToggle}
-                aria-label={sortOrder === 'alpha' ? 'Sort by recent' : 'Sort alphabetically'}
-                title={sortOrder === 'alpha' ? 'Sort by recent' : 'Sort alphabetically'}
+                onClick={() => handleSortToggle(sortSection)}
+                aria-label={
+                  sectionSortOrder === 'alpha'
+                    ? `Sort ${title} by recent`
+                    : `Sort ${title} alphabetically`
+                }
+                title={
+                  sectionSortOrder === 'alpha'
+                    ? `Sort ${title} by recent`
+                    : `Sort ${title} alphabetically`
+                }
               >
-                {sortOrder === 'alpha' ? 'A-Z' : '⏱'}
+                {sectionSortOrder === 'alpha' ? 'A-Z' : '⏱'}
               </button>
             )}
             {unreadCount > 0 && (
@@ -731,7 +904,7 @@ export function Sidebar({
               'Favorites',
               favoritesCollapsed,
               () => setFavoritesCollapsed((prev) => !prev),
-              false,
+              'favorites',
               favoritesUnreadCount,
               favoritesHasMention
             )}
@@ -747,7 +920,7 @@ export function Sidebar({
               'Channels',
               channelsCollapsed,
               () => setChannelsCollapsed((prev) => !prev),
-              true,
+              'channels',
               channelsUnreadCount,
               channelsHasMention
             )}
@@ -763,7 +936,7 @@ export function Sidebar({
               'Contacts',
               contactsCollapsed,
               () => setContactsCollapsed((prev) => !prev),
-              true,
+              'contacts',
               contactsUnreadCount,
               contactsUnreadCount > 0
             )}
@@ -772,6 +945,21 @@ export function Sidebar({
           </>
         )}
 
+        {/* Room Servers */}
+        {nonFavoriteRooms.length > 0 && (
+          <>
+            {renderSectionHeader(
+              'Room Servers',
+              roomsCollapsed,
+              () => setRoomsCollapsed((prev) => !prev),
+              'rooms',
+              roomsUnreadCount,
+              roomsUnreadCount > 0
+            )}
+            {(isSearching || !roomsCollapsed) && roomRows.map((row) => renderConversationRow(row))}
+          </>
+        )}
+
         {/* Repeaters */}
         {nonFavoriteRepeaters.length > 0 && (
           <>
@@ -779,7 +967,7 @@ export function Sidebar({
               'Repeaters',
               repeatersCollapsed,
               () => setRepeatersCollapsed((prev) => !prev),
-              true,
+              'repeaters',
               repeatersUnreadCount
             )}
             {(isSearching || !repeatersCollapsed) &&
@@ -789,6 +977,7 @@ export function Sidebar({
 
         {/* Empty state */}
         {nonFavoriteContacts.length === 0 &&
+          nonFavoriteRooms.length === 0 &&
           nonFavoriteChannels.length === 0 &&
           nonFavoriteRepeaters.length === 0 &&
           favoriteItems.length === 0 && (

frontend/src/components/repeater/RepeaterNeighborsPane.tsx

@@ -2,7 +2,14 @@ import { useMemo, lazy, Suspense } from 'react';
 import { cn } from '@/lib/utils';
 import { RepeaterPane, NotFetched, formatDuration } from './repeaterPaneShared';
 import { isValidLocation, calculateDistance, formatDistance } from '../../utils/pathUtils';
-import type { Contact, RepeaterNeighborsResponse, PaneState, NeighborInfo } from '../../types';
+import { useDistanceUnit } from '../../contexts/DistanceUnitContext';
+import type {
+  Contact,
+  RepeaterNeighborsResponse,
+  PaneState,
+  NeighborInfo,
+  RepeaterNodeInfoResponse,
+} from '../../types';
 
 const NeighborsMiniMap = lazy(() =>
   import('../NeighborsMiniMap').then((m) => ({ default: m.NeighborsMiniMap }))
@@ -13,20 +20,57 @@ export function NeighborsPane({
   state,
   onRefresh,
   disabled,
+  repeaterContact,
   contacts,
-  radioLat,
-  radioLon,
-  radioName,
+  nodeInfo,
+  nodeInfoState,
+  repeaterName,
 }: {
   data: RepeaterNeighborsResponse | null;
   state: PaneState;
   onRefresh: () => void;
   disabled?: boolean;
+  repeaterContact: Contact | null;
   contacts: Contact[];
-  radioLat: number | null;
-  radioLon: number | null;
-  radioName: string | null;
+  nodeInfo: RepeaterNodeInfoResponse | null;
+  nodeInfoState: PaneState;
+  repeaterName: string | null;
 }) {
+  const { distanceUnit } = useDistanceUnit();
+  const advertLat = repeaterContact?.lat ?? null;
+  const advertLon = repeaterContact?.lon ?? null;
+
+  const radioLat = useMemo(() => {
+    const parsed = nodeInfo?.lat != null ? parseFloat(nodeInfo.lat) : null;
+    return Number.isFinite(parsed) ? parsed : null;
+  }, [nodeInfo?.lat]);
+
+  const radioLon = useMemo(() => {
+    const parsed = nodeInfo?.lon != null ? parseFloat(nodeInfo.lon) : null;
+    return Number.isFinite(parsed) ? parsed : null;
+  }, [nodeInfo?.lon]);
+
+  const positionSource = useMemo(() => {
+    if (isValidLocation(radioLat, radioLon)) {
+      return { lat: radioLat, lon: radioLon, source: 'reported' as const };
+    }
+    if (isValidLocation(advertLat, advertLon)) {
+      return { lat: advertLat, lon: advertLon, source: 'advert' as const };
+    }
+    return { lat: null, lon: null, source: null };
+  }, [advertLat, advertLon, radioLat, radioLon]);
+
+  const radioName = nodeInfo?.name || repeaterContact?.name || repeaterName;
+  const hasValidRepeaterGps = positionSource.source !== null;
+  const headerNote =
+    positionSource.source === 'reported'
+      ? 'Using repeater-reported position'
+      : positionSource.source === 'advert'
+        ? 'Using advert position'
+        : nodeInfoState.loading
+          ? 'Waiting for repeater position'
+          : 'No repeater position available';
+
   // Resolve contact data for each neighbor in a single pass — used for
   // coords (mini-map), distances (table column), and sorted display order.
   const { neighborsWithCoords, sorted, hasDistances } = useMemo(() => {
@@ -48,10 +92,10 @@ export function NeighborsPane({
       const nLon = contact?.lon ?? null;
 
       let dist: string | null = null;
-      if (isValidLocation(radioLat, radioLon) && isValidLocation(nLat, nLon)) {
-        const distKm = calculateDistance(radioLat, radioLon, nLat, nLon);
+      if (hasValidRepeaterGps && isValidLocation(nLat, nLon)) {
+        const distKm = calculateDistance(positionSource.lat, positionSource.lon, nLat, nLon);
         if (distKm != null) {
-          dist = formatDistance(distKm);
+          dist = formatDistance(distKm, distanceUnit);
           anyDist = true;
         }
       }
@@ -69,24 +113,25 @@ export function NeighborsPane({
       sorted: enriched,
       hasDistances: anyDist,
     };
-  }, [data, contacts, radioLat, radioLon]);
+  }, [contacts, data, distanceUnit, hasValidRepeaterGps, positionSource.lat, positionSource.lon]);
 
   return (
     <RepeaterPane
       title="Neighbors"
+      headerNote={headerNote}
       state={state}
       onRefresh={onRefresh}
       disabled={disabled}
-      className="flex flex-col"
-      contentClassName="flex-1 flex flex-col"
+      className="flex min-h-0 flex-1 flex-col"
+      contentClassName="flex min-h-0 flex-1 flex-col"
     >
       {!data ? (
         <NotFetched />
       ) : sorted.length === 0 ? (
         <p className="text-sm text-muted-foreground">No neighbors reported</p>
       ) : (
-        <div className="flex-1 flex flex-col gap-2">
-          <div className="overflow-x-auto">
+        <div className="flex min-h-0 flex-1 flex-col gap-2">
+          <div className="shrink-0 overflow-x-auto">
             <table className="w-full text-sm">
               <thead>
                 <tr className="text-left text-muted-foreground text-xs">
@@ -120,10 +165,10 @@ export function NeighborsPane({
               </tbody>
             </table>
           </div>
-          {(neighborsWithCoords.length > 0 || isValidLocation(radioLat, radioLon)) && (
+          {hasValidRepeaterGps && (neighborsWithCoords.length > 0 || hasValidRepeaterGps) ? (
             <Suspense
               fallback={
-                <div className="h-48 flex items-center justify-center text-xs text-muted-foreground">
+                <div className="flex min-h-48 flex-1 items-center justify-center text-xs text-muted-foreground">
                   Loading map...
                 </div>
               }
@@ -131,11 +176,16 @@ export function NeighborsPane({
               <NeighborsMiniMap
                 key={neighborsWithCoords.map((n) => n.pubkey_prefix).join(',')}
                 neighbors={neighborsWithCoords}
-                radioLat={radioLat}
-                radioLon={radioLon}
+                radioLat={positionSource.lat}
+                radioLon={positionSource.lon}
                 radioName={radioName}
               />
             </Suspense>
+          ) : (
+            <div className="rounded border border-border/70 bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+              Map and distance data are unavailable until this repeater has a valid position from
+              either its advert or a Node Info fetch.
+            </div>
           )}
         </div>
       )}

frontend/src/components/repeater/RepeaterNodeInfoPane.tsx

@@ -0,0 +1,55 @@
+import { useMemo } from 'react';
+import { cn } from '@/lib/utils';
+import { RepeaterPane, NotFetched, KvRow, formatClockDrift } from './repeaterPaneShared';
+import type { RepeaterNodeInfoResponse, PaneState } from '../../types';
+
+export function NodeInfoPane({
+  data,
+  state,
+  onRefresh,
+  disabled,
+}: {
+  data: RepeaterNodeInfoResponse | null;
+  state: PaneState;
+  onRefresh: () => void;
+  disabled?: boolean;
+}) {
+  const clockDrift = useMemo(() => {
+    if (!data?.clock_utc) return null;
+    return formatClockDrift(data.clock_utc, state.fetched_at ?? undefined);
+  }, [data?.clock_utc, state.fetched_at]);
+
+  return (
+    <RepeaterPane title="Node Info" state={state} onRefresh={onRefresh} disabled={disabled}>
+      {!data ? (
+        <NotFetched />
+      ) : (
+        <div>
+          <KvRow label="Name" value={data.name ?? '—'} />
+          <KvRow
+            label="Lat / Lon"
+            value={
+              data.lat != null || data.lon != null ? `${data.lat ?? '—'}, ${data.lon ?? '—'}` : '—'
+            }
+          />
+          <div className="flex justify-between text-sm py-0.5">
+            <span className="text-muted-foreground">Clock (UTC)</span>
+            <span>
+              {data.clock_utc ?? '—'}
+              {clockDrift && (
+                <span
+                  className={cn(
+                    'ml-2 text-xs',
+                    clockDrift.isLarge ? 'text-destructive' : 'text-muted-foreground'
+                  )}
+                >
+                  (drift: {clockDrift.text})
+                </span>
+              )}
+            </span>
+          </div>
+        </div>
+      )}
+    </RepeaterPane>
+  );
+}

frontend/src/components/repeater/RepeaterRadioSettingsPane.tsx

@@ -1,4 +1,3 @@
-import { useMemo } from 'react';
 import { cn } from '@/lib/utils';
 import { Separator } from '../ui/separator';
 import {
@@ -6,7 +5,6 @@ import {
   RefreshIcon,
   NotFetched,
   KvRow,
-  formatClockDrift,
   formatAdvertInterval,
 } from './repeaterPaneShared';
 import type {
@@ -15,6 +13,35 @@ import type {
   PaneState,
 } from '../../types';
 
+function formatRadioTuple(radio: string | null): { display: string; raw: string | null } {
+  if (radio == null) {
+    return { display: '—', raw: null };
+  }
+
+  const trimmed = radio.trim();
+  const parts = trimmed.split(',').map((part) => part.trim());
+  if (parts.length !== 4) {
+    return { display: trimmed || '—', raw: trimmed || null };
+  }
+
+  const [freqRaw, bwRaw, sfRaw, crRaw] = parts;
+  const freq = Number.parseFloat(freqRaw);
+  const bw = Number.parseFloat(bwRaw);
+  const sf = Number.parseInt(sfRaw, 10);
+  const cr = Number.parseInt(crRaw, 10);
+
+  if (![freq, bw, sf, cr].every(Number.isFinite)) {
+    return { display: trimmed || '—', raw: trimmed || null };
+  }
+
+  const formattedFreq = Number(freq.toFixed(3)).toString();
+  const formattedBw = Number(bw.toFixed(3)).toString();
+  return {
+    display: `${formattedFreq} MHz, BW ${formattedBw} kHz, SF${sf}, CR${cr}`,
+    raw: trimmed,
+  };
+}
+
 export function RadioSettingsPane({
   data,
   state,
@@ -32,10 +59,7 @@ export function RadioSettingsPane({
   advertState: PaneState;
   onRefreshAdvert: () => void;
 }) {
-  const clockDrift = useMemo(() => {
-    if (!data?.clock_utc) return null;
-    return formatClockDrift(data.clock_utc);
-  }, [data?.clock_utc]);
+  const formattedRadio = formatRadioTuple(data?.radio ?? null);
 
   return (
     <RepeaterPane title="Radio Settings" state={state} onRefresh={onRefresh} disabled={disabled}>
@@ -44,36 +68,14 @@ export function RadioSettingsPane({
       ) : (
         <div>
           <KvRow label="Firmware" value={data.firmware_version ?? '—'} />
-          <KvRow label="Radio" value={data.radio ?? '—'} />
+          <KvRow
+            label="Radio"
+            value={<span title={formattedRadio.raw ?? undefined}>{formattedRadio.display}</span>}
+          />
           <KvRow label="TX Power" value={data.tx_power != null ? `${data.tx_power} dBm` : '—'} />
           <KvRow label="Airtime Factor" value={data.airtime_factor ?? '—'} />
           <KvRow label="Repeat Mode" value={data.repeat_enabled ?? '—'} />
           <KvRow label="Max Flood Hops" value={data.flood_max ?? '—'} />
-          <Separator className="my-1" />
-          <KvRow label="Name" value={data.name ?? '—'} />
-          <KvRow
-            label="Lat / Lon"
-            value={
-              data.lat != null || data.lon != null ? `${data.lat ?? '—'}, ${data.lon ?? '—'}` : '—'
-            }
-          />
-          <Separator className="my-1" />
-          <div className="flex justify-between text-sm py-0.5">
-            <span className="text-muted-foreground">Clock (UTC)</span>
-            <span>
-              {data.clock_utc ?? '—'}
-              {clockDrift && (
-                <span
-                  className={cn(
-                    'ml-2 text-xs',
-                    clockDrift.isLarge ? 'text-destructive' : 'text-muted-foreground'
-                  )}
-                >
-                  (drift: {clockDrift.text})
-                </span>
-              )}
-            </span>
-          </div>
         </div>
       )}
       {/* Advert Intervals sub-section */}

frontend/src/components/repeater/repeaterPaneShared.tsx

@@ -39,7 +39,10 @@ export function formatDuration(seconds: number): string {
   return `${mins}m`;
 }
 
-export function formatClockDrift(clockUtc: string): { text: string; isLarge: boolean } {
+export function formatClockDrift(
+  clockUtc: string,
+  referenceTimeMs: number = Date.now()
+): { text: string; isLarge: boolean } {
   // Firmware format: "HH:MM - D/M/YYYY UTC" or "HH:MM:SS - D/M/YYYY UTC"
   // Also handle ISO-like: "YYYY-MM-DD HH:MM:SS"
   let parsed: Date;
@@ -56,7 +59,7 @@ export function formatClockDrift(clockUtc: string): { text: string; isLarge: boo
   }
   if (isNaN(parsed.getTime())) return { text: '(invalid)', isLarge: false };
 
-  const driftMs = Math.abs(Date.now() - parsed.getTime());
+  const driftMs = Math.abs(referenceTimeMs - parsed.getTime());
   const driftSec = Math.floor(driftMs / 1000);
 
   if (driftSec >= 86400) return { text: '>24 hours!', isLarge: true };
@@ -106,6 +109,7 @@ function formatFetchedTime(fetchedAt: number): string {
 
 export function RepeaterPane({
   title,
+  headerNote,
   state,
   onRefresh,
   disabled,
@@ -114,6 +118,7 @@ export function RepeaterPane({
   contentClassName,
 }: {
   title: string;
+  headerNote?: ReactNode;
   state: PaneState;
   onRefresh?: () => void;
   disabled?: boolean;
@@ -128,6 +133,7 @@ export function RepeaterPane({
       <div className="flex items-center justify-between px-3 py-2 bg-muted/50 border-b border-border">
         <div className="min-w-0">
           <h3 className="text-sm font-medium">{title}</h3>
+          {headerNote && <p className="text-[11px] text-muted-foreground">{headerNote}</p>}
           {fetchedAt && (
             <p
               className="text-[11px] text-muted-foreground"

frontend/src/components/settings/SettingsAboutSection.tsx

@@ -1,10 +1,17 @@
+import type { HealthStatus } from '../../types';
 import { Separator } from '../ui/separator';
 
 const GITHUB_URL = 'https://github.com/jkingsman/Remote-Terminal-for-MeshCore';
 
-export function SettingsAboutSection({ className }: { className?: string }) {
-  const version = __APP_VERSION__;
-  const commit = __COMMIT_HASH__;
+export function SettingsAboutSection({
+  health,
+  className,
+}: {
+  health?: HealthStatus | null;
+  className?: string;
+}) {
+  const version = health?.app_info?.version ?? 'unknown';
+  const commit = health?.app_info?.commit_hash;
 
   return (
     <div className={className}>
@@ -14,8 +21,14 @@ export function SettingsAboutSection({ className }: { className?: string }) {
           <h3 className="text-lg font-semibold">RemoteTerm for MeshCore</h3>
           <div className="text-sm text-muted-foreground">
             v{version}
-            <span className="mx-1.5">·</span>
-            <span className="font-mono text-xs">{commit}</span>
+            {commit ? (
+              <>
+                <span className="mx-1.5">·</span>
+                <span className="font-mono text-xs" title={commit}>
+                  {commit}
+                </span>
+              </>
+            ) : null}
           </div>
         </div>
 
@@ -113,6 +126,19 @@ export function SettingsAboutSection({ className }: { className?: string }) {
             </a>
           </p>
         </div>
+
+        <Separator />
+
+        <div className="text-center">
+          <a
+            href="/api/debug"
+            target="_blank"
+            rel="noopener noreferrer"
+            className="text-xs text-muted-foreground hover:text-primary hover:underline"
+          >
+            Open debug support snapshot
+          </a>
+        </div>
       </div>
     </div>
   );

frontend/src/components/settings/SettingsDatabaseSection.tsx

@@ -173,7 +173,8 @@ export function SettingsDatabaseSection({
           Deletes archival copies of raw packet bytes for messages that are already decrypted and
           visible in your chat history.{' '}
           <em className="text-muted-foreground/80">
-            This will not affect any displayed messages or app functionality.
+            This will not affect any displayed messages or app functionality, nor impact your
+            ability to do historical decryption.
           </em>{' '}
           The raw bytes are only useful for manual packet analysis.
         </p>

frontend/src/components/settings/SettingsFanoutSection.tsx

@@ -14,16 +14,16 @@ const BotCodeEditor = lazy(() =>
 
 const TYPE_LABELS: Record<string, string> = {
   mqtt_private: 'Private MQTT',
-  mqtt_community: 'meshcoretomqtt/LetsMesh/MeshRank',
+  mqtt_community: 'Community MQTT',
   bot: 'Bot',
   webhook: 'Webhook',
   apprise: 'Apprise',
   sqs: 'Amazon SQS',
 };
 
-const TYPE_OPTIONS = [
+const LIST_TYPE_OPTIONS = [
   { value: 'mqtt_private', label: 'Private MQTT' },
-  { value: 'mqtt_community', label: 'meshcoretomqtt/LetsMesh/MeshRank' },
+  { value: 'mqtt_community', label: 'Community MQTT' },
   { value: 'bot', label: 'Bot' },
   { value: 'webhook', label: 'Webhook' },
   { value: 'apprise', label: 'Apprise' },
@@ -32,9 +32,313 @@ const TYPE_OPTIONS = [
 
 const DEFAULT_COMMUNITY_PACKET_TOPIC_TEMPLATE = 'meshcore/{IATA}/{PUBLIC_KEY}/packets';
 const DEFAULT_COMMUNITY_BROKER_HOST = 'mqtt-us-v1.letsmesh.net';
+const DEFAULT_COMMUNITY_BROKER_HOST_EU = 'mqtt-eu-v1.letsmesh.net';
 const DEFAULT_COMMUNITY_BROKER_PORT = 443;
 const DEFAULT_COMMUNITY_TRANSPORT = 'websockets';
 const DEFAULT_COMMUNITY_AUTH_MODE = 'token';
+const DEFAULT_MESHRANK_BROKER_HOST = 'meshrank.net';
+const DEFAULT_MESHRANK_BROKER_PORT = 8883;
+const DEFAULT_MESHRANK_TRANSPORT = 'tcp';
+const DEFAULT_MESHRANK_AUTH_MODE = 'none';
+const DEFAULT_MESHRANK_IATA = 'XYZ';
+
+const CREATE_TYPE_OPTIONS = [
+  { value: 'mqtt_private', label: 'Private MQTT' },
+  { value: 'mqtt_community_meshrank', label: 'MeshRank' },
+  { value: 'mqtt_community_letsmesh_us', label: 'LetsMesh (US)' },
+  { value: 'mqtt_community_letsmesh_eu', label: 'LetsMesh (EU)' },
+  { value: 'mqtt_community', label: 'Community MQTT/meshcoretomqtt' },
+  { value: 'bot', label: 'Bot' },
+  { value: 'webhook', label: 'Webhook' },
+  { value: 'apprise', label: 'Apprise' },
+  { value: 'sqs', label: 'Amazon SQS' },
+] as const;
+
+type DraftType = (typeof CREATE_TYPE_OPTIONS)[number]['value'];
+
+type DraftRecipe = {
+  savedType: string;
+  detailLabel: string;
+  defaultName: string;
+  defaults: {
+    config: Record<string, unknown>;
+    scope: Record<string, unknown>;
+  };
+};
+
+function createCommunityConfigDefaults(
+  overrides: Partial<Record<string, unknown>> = {}
+): Record<string, unknown> {
+  return {
+    broker_host: DEFAULT_COMMUNITY_BROKER_HOST,
+    broker_port: DEFAULT_COMMUNITY_BROKER_PORT,
+    transport: DEFAULT_COMMUNITY_TRANSPORT,
+    use_tls: true,
+    tls_verify: true,
+    auth_mode: DEFAULT_COMMUNITY_AUTH_MODE,
+    username: '',
+    password: '',
+    iata: '',
+    email: '',
+    token_audience: '',
+    topic_template: DEFAULT_COMMUNITY_PACKET_TOPIC_TEMPLATE,
+    ...overrides,
+  };
+}
+
+const DEFAULT_BOT_CODE = `def bot(**kwargs) -> str | list[str] | None:
+    """
+    Process messages and optionally return a reply.
+
+    Args:
+        kwargs keys currently provided:
+            sender_name: Display name of sender (may be None)
+            sender_key: 64-char hex public key (None for channel msgs)
+            message_text: The message content
+            is_dm: True for direct messages, False for channel
+            channel_key: 32-char hex key for channels, None for DMs
+            channel_name: Channel name with hash (e.g. "#bot"), None for DMs
+            sender_timestamp: Sender's timestamp (unix seconds, may be None)
+            path: Hex-encoded routing path (may be None)
+            is_outgoing: True if this is our own outgoing message
+            path_bytes_per_hop: Bytes per hop in path (1, 2, or 3) when known
+
+    Returns:
+        None for no reply, a string for a single reply,
+        or a list of strings to send multiple messages in order
+    """
+    sender_name = kwargs.get("sender_name")
+    message_text = kwargs.get("message_text", "")
+    channel_name = kwargs.get("channel_name")
+    is_outgoing = kwargs.get("is_outgoing", False)
+    path_bytes_per_hop = kwargs.get("path_bytes_per_hop")
+
+    # Don't reply to our own outgoing messages
+    if is_outgoing:
+        return None
+
+    # Example: Only respond in #bot channel to "!pling" command
+    if channel_name == "#bot" and "!pling" in message_text.lower():
+        return "[BOT] Plong!"
+    return None`;
+
+const DRAFT_RECIPES: Record<DraftType, DraftRecipe> = {
+  mqtt_private: {
+    savedType: 'mqtt_private',
+    detailLabel: 'Private MQTT',
+    defaultName: 'Private MQTT',
+    defaults: {
+      config: {
+        broker_host: '',
+        broker_port: 1883,
+        username: '',
+        password: '',
+        use_tls: false,
+        tls_insecure: false,
+        topic_prefix: 'meshcore',
+      },
+      scope: { messages: 'all', raw_packets: 'all' },
+    },
+  },
+  mqtt_community_meshrank: {
+    savedType: 'mqtt_community',
+    detailLabel: 'MeshRank',
+    defaultName: 'MeshRank',
+    defaults: {
+      config: createCommunityConfigDefaults({
+        broker_host: DEFAULT_MESHRANK_BROKER_HOST,
+        broker_port: DEFAULT_MESHRANK_BROKER_PORT,
+        transport: DEFAULT_MESHRANK_TRANSPORT,
+        auth_mode: DEFAULT_MESHRANK_AUTH_MODE,
+        iata: DEFAULT_MESHRANK_IATA,
+        email: '',
+        token_audience: '',
+        topic_template: '',
+      }),
+      scope: { messages: 'none', raw_packets: 'all' },
+    },
+  },
+  mqtt_community_letsmesh_us: {
+    savedType: 'mqtt_community',
+    detailLabel: 'LetsMesh (US)',
+    defaultName: 'LetsMesh (US)',
+    defaults: {
+      config: createCommunityConfigDefaults({
+        broker_host: DEFAULT_COMMUNITY_BROKER_HOST,
+        token_audience: DEFAULT_COMMUNITY_BROKER_HOST,
+      }),
+      scope: { messages: 'none', raw_packets: 'all' },
+    },
+  },
+  mqtt_community_letsmesh_eu: {
+    savedType: 'mqtt_community',
+    detailLabel: 'LetsMesh (EU)',
+    defaultName: 'LetsMesh (EU)',
+    defaults: {
+      config: createCommunityConfigDefaults({
+        broker_host: DEFAULT_COMMUNITY_BROKER_HOST_EU,
+        token_audience: DEFAULT_COMMUNITY_BROKER_HOST_EU,
+      }),
+      scope: { messages: 'none', raw_packets: 'all' },
+    },
+  },
+  mqtt_community: {
+    savedType: 'mqtt_community',
+    detailLabel: 'Community MQTT/meshcoretomqtt',
+    defaultName: 'Community MQTT',
+    defaults: {
+      config: createCommunityConfigDefaults(),
+      scope: { messages: 'none', raw_packets: 'all' },
+    },
+  },
+  bot: {
+    savedType: 'bot',
+    detailLabel: 'Bot',
+    defaultName: 'Bot',
+    defaults: {
+      config: {
+        code: DEFAULT_BOT_CODE,
+      },
+      scope: { messages: 'all', raw_packets: 'none' },
+    },
+  },
+  webhook: {
+    savedType: 'webhook',
+    detailLabel: 'Webhook',
+    defaultName: 'Webhook',
+    defaults: {
+      config: {
+        url: '',
+        method: 'POST',
+        headers: {},
+        hmac_secret: '',
+        hmac_header: '',
+      },
+      scope: { messages: 'all', raw_packets: 'none' },
+    },
+  },
+  apprise: {
+    savedType: 'apprise',
+    detailLabel: 'Apprise',
+    defaultName: 'Apprise',
+    defaults: {
+      config: {
+        urls: '',
+        preserve_identity: true,
+        include_path: true,
+      },
+      scope: { messages: 'all', raw_packets: 'none' },
+    },
+  },
+  sqs: {
+    savedType: 'sqs',
+    detailLabel: 'Amazon SQS',
+    defaultName: 'Amazon SQS',
+    defaults: {
+      config: {
+        queue_url: '',
+        region_name: '',
+        endpoint_url: '',
+        access_key_id: '',
+        secret_access_key: '',
+        session_token: '',
+      },
+      scope: { messages: 'all', raw_packets: 'none' },
+    },
+  },
+};
+
+function isDraftType(value: string): value is DraftType {
+  return value in DRAFT_RECIPES;
+}
+
+function normalizeDraftName(draftType: DraftType, name: string, configs: FanoutConfig[]) {
+  const recipe = DRAFT_RECIPES[draftType];
+  return name || getDefaultIntegrationName(recipe.savedType, configs);
+}
+
+function normalizeDraftConfig(draftType: DraftType, config: Record<string, unknown>) {
+  if (draftType === 'mqtt_community_meshrank') {
+    const topicTemplate = String(config.topic_template || '').trim();
+    if (!topicTemplate) {
+      throw new Error('MeshRank packet topic is required');
+    }
+
+    return {
+      ...config,
+      broker_host: DEFAULT_MESHRANK_BROKER_HOST,
+      broker_port: DEFAULT_MESHRANK_BROKER_PORT,
+      transport: DEFAULT_MESHRANK_TRANSPORT,
+      auth_mode: DEFAULT_MESHRANK_AUTH_MODE,
+      use_tls: true,
+      tls_verify: true,
+      iata: DEFAULT_MESHRANK_IATA,
+      email: '',
+      token_audience: '',
+      topic_template: topicTemplate,
+      username: '',
+      password: '',
+    };
+  }
+
+  if (draftType === 'mqtt_community_letsmesh_us' || draftType === 'mqtt_community_letsmesh_eu') {
+    const brokerHost =
+      draftType === 'mqtt_community_letsmesh_eu'
+        ? DEFAULT_COMMUNITY_BROKER_HOST_EU
+        : DEFAULT_COMMUNITY_BROKER_HOST;
+    return {
+      ...config,
+      broker_host: brokerHost,
+      broker_port: DEFAULT_COMMUNITY_BROKER_PORT,
+      transport: DEFAULT_COMMUNITY_TRANSPORT,
+      auth_mode: DEFAULT_COMMUNITY_AUTH_MODE,
+      use_tls: true,
+      tls_verify: true,
+      token_audience: brokerHost,
+      topic_template: (config.topic_template as string) || DEFAULT_COMMUNITY_PACKET_TOPIC_TEMPLATE,
+      username: '',
+      password: '',
+    };
+  }
+
+  return config;
+}
+
+function normalizeDraftScope(draftType: DraftType, scope: Record<string, unknown>) {
+  if (draftType.startsWith('mqtt_community_')) {
+    return { messages: 'none', raw_packets: 'all' };
+  }
+  return scope;
+}
+
+function cloneDraftDefaults(draftType: DraftType) {
+  const recipe = DRAFT_RECIPES[draftType];
+  return {
+    config: structuredClone(recipe.defaults.config),
+    scope: structuredClone(recipe.defaults.scope),
+  };
+}
+
+function getDetailTypeLabel(detailType: string) {
+  if (isDraftType(detailType)) return DRAFT_RECIPES[detailType].detailLabel;
+  return TYPE_LABELS[detailType] || detailType;
+}
+
+function fanoutDraftHasUnsavedChanges(
+  original: FanoutConfig | null,
+  current: {
+    name: string;
+    config: Record<string, unknown>;
+    scope: Record<string, unknown>;
+  }
+) {
+  if (!original) return false;
+  return (
+    current.name !== original.name ||
+    JSON.stringify(current.config) !== JSON.stringify(original.config) ||
+    JSON.stringify(current.scope) !== JSON.stringify(original.scope)
+  );
+}
 
 function formatBrokerSummary(
   config: Record<string, unknown>,
@@ -74,44 +378,6 @@ function getDefaultIntegrationName(type: string, configs: FanoutConfig[]) {
   return `${label} #${nextIndex}`;
 }
 
-const DEFAULT_BOT_CODE = `def bot(
-    sender_name: str | None,
-    sender_key: str | None,
-    message_text: str,
-    is_dm: bool,
-    channel_key: str | None,
-    channel_name: str | None,
-    sender_timestamp: int | None,
-    path: str | None,
-    is_outgoing: bool = False,
-) -> str | list[str] | None:
-    """
-    Process messages and optionally return a reply.
-
-    Args:
-        sender_name: Display name of sender (may be None)
-        sender_key: 64-char hex public key (None for channel msgs)
-        message_text: The message content
-        is_dm: True for direct messages, False for channel
-        channel_key: 32-char hex key for channels, None for DMs
-        channel_name: Channel name with hash (e.g. "#bot"), None for DMs
-        sender_timestamp: Sender's timestamp (unix seconds, may be None)
-        path: Hex-encoded routing path (may be None)
-        is_outgoing: True if this is our own outgoing message
-
-    Returns:
-        None for no reply, a string for a single reply,
-        or a list of strings to send multiple messages in order
-    """
-    # Don't reply to our own outgoing messages
-    if is_outgoing:
-        return None
-
-    # Example: Only respond in #bot channel to "!pling" command
-    if channel_name == "#bot" and "!pling" in message_text.lower():
-        return "[BOT] Plong!"
-    return None`;
-
 function getStatusLabel(status: string | undefined, type?: string) {
   if (status === 'connected')
     return type === 'bot' || type === 'webhook' || type === 'apprise' ? 'Active' : 'Connected';
@@ -253,8 +519,9 @@ function MqttCommunityConfigEditor({
   return (
     <div className="space-y-3">
       <p className="text-xs text-muted-foreground">
-        Share raw packet data with the MeshCore community for coverage mapping and network analysis.
-        Only raw RF packets are shared &mdash; never decrypted messages.
+        Advanced community MQTT editor. Use this for manual meshcoretomqtt-compatible setups or for
+        modifying a saved preset after creation. Only raw RF packets are shared &mdash; never
+        decrypted messages.
       </p>
 
       <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
@@ -426,6 +693,110 @@ function MqttCommunityConfigEditor({
   );
 }
 
+function MeshRankConfigEditor({
+  config,
+  onChange,
+}: {
+  config: Record<string, unknown>;
+  onChange: (config: Record<string, unknown>) => void;
+}) {
+  return (
+    <div className="space-y-3">
+      <p className="text-xs text-muted-foreground">
+        Pre-filled MeshRank setup. This saves as a regular Community MQTT integration once created,
+        but only asks for the MeshRank packet topic you were given.
+      </p>
+
+      <div className="rounded-md border border-input bg-muted/40 px-3 py-2 text-xs text-muted-foreground">
+        Broker <code>{DEFAULT_MESHRANK_BROKER_HOST}</code> on port{' '}
+        <code>{DEFAULT_MESHRANK_BROKER_PORT}</code> via <code>{DEFAULT_MESHRANK_TRANSPORT}</code>,
+        auth <code>{DEFAULT_MESHRANK_AUTH_MODE}</code>, TLS on, certificate verification on, region
+        code fixed to <code>{DEFAULT_MESHRANK_IATA}</code>.
+      </div>
+
+      <div className="space-y-2">
+        <Label htmlFor="fanout-meshrank-topic-template">Packet Topic Template</Label>
+        <Input
+          id="fanout-meshrank-topic-template"
+          type="text"
+          placeholder="meshrank/uplink/B435F6D5F7896B74C6B995FE221C2C1F/{PUBLIC_KEY}/packets"
+          value={(config.topic_template as string) || ''}
+          onChange={(e) =>
+            onChange({
+              ...config,
+              iata: DEFAULT_MESHRANK_IATA,
+              topic_template: e.target.value,
+            })
+          }
+        />
+        <p className="text-xs text-muted-foreground">
+          Paste the full topic template from your MeshRank config, for example{' '}
+          <code>meshrank/uplink/B435F6D5F7896B74C6B995FE221C2C1F/{'{PUBLIC_KEY}'}/packets</code>.
+        </p>
+      </div>
+    </div>
+  );
+}
+
+function LetsMeshConfigEditor({
+  config,
+  onChange,
+  brokerHost,
+}: {
+  config: Record<string, unknown>;
+  onChange: (config: Record<string, unknown>) => void;
+  brokerHost: string;
+}) {
+  return (
+    <div className="space-y-3">
+      <p className="text-xs text-muted-foreground">
+        Pre-filled LetsMesh setup. This saves as a regular Community MQTT integration once created,
+        but only asks for the values LetsMesh expects from you.
+      </p>
+
+      <div className="rounded-md border border-input bg-muted/40 px-3 py-2 text-xs text-muted-foreground">
+        Broker <code>{brokerHost}</code> on port <code>{DEFAULT_COMMUNITY_BROKER_PORT}</code> via{' '}
+        <code>{DEFAULT_COMMUNITY_TRANSPORT}</code>, auth <code>{DEFAULT_COMMUNITY_AUTH_MODE}</code>,
+        TLS on, certificate verification on, token audience fixed to <code>{brokerHost}</code>.
+      </div>
+
+      <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+        <div className="space-y-2">
+          <Label htmlFor="fanout-letsmesh-email">Email</Label>
+          <Input
+            id="fanout-letsmesh-email"
+            type="email"
+            placeholder="you@example.com"
+            value={(config.email as string) || ''}
+            onChange={(e) =>
+              onChange({ ...config, email: e.target.value, broker_host: brokerHost })
+            }
+          />
+        </div>
+        <div className="space-y-2">
+          <Label htmlFor="fanout-letsmesh-iata">Region Code (IATA)</Label>
+          <Input
+            id="fanout-letsmesh-iata"
+            type="text"
+            maxLength={3}
+            placeholder="e.g. DEN, LAX, NYC"
+            value={(config.iata as string) || ''}
+            onChange={(e) =>
+              onChange({
+                ...config,
+                broker_host: brokerHost,
+                token_audience: brokerHost,
+                iata: e.target.value.toUpperCase(),
+              })
+            }
+            className="w-32"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
+
 function BotConfigEditor({
   config,
   onChange,
@@ -1122,7 +1493,7 @@ export function SettingsFanoutSection({
 }) {
   const [configs, setConfigs] = useState<FanoutConfig[]>([]);
   const [editingId, setEditingId] = useState<string | null>(null);
-  const [draftType, setDraftType] = useState<string | null>(null);
+  const [draftType, setDraftType] = useState<DraftType | null>(null);
   const [editConfig, setEditConfig] = useState<Record<string, unknown>>({});
   const [editScope, setEditScope] = useState<Record<string, unknown>>({});
   const [editName, setEditName] = useState('');
@@ -1192,7 +1563,17 @@ export function SettingsFanoutSection({
   };
 
   const handleBackToList = () => {
-    if (!confirm('Leave without saving?')) return;
+    const shouldConfirm =
+      draftType !== null ||
+      fanoutDraftHasUnsavedChanges(
+        editingId ? (configs.find((c) => c.id === editingId) ?? null) : null,
+        {
+          name: editName,
+          config: editConfig,
+          scope: editScope,
+        }
+      );
+    if (shouldConfirm && !confirm('Leave without saving?')) return;
     setEditingId(null);
     setDraftType(null);
   };
@@ -1230,11 +1611,12 @@ export function SettingsFanoutSection({
     setBusy(true);
     try {
       if (currentDraftType) {
+        const recipe = DRAFT_RECIPES[currentDraftType];
         await api.createFanoutConfig({
-          type: currentDraftType,
-          name: editName,
-          config: editConfig,
-          scope: editScope,
+          type: recipe.savedType,
+          name: normalizeDraftName(currentDraftType, editName.trim(), configs),
+          config: normalizeDraftConfig(currentDraftType, editConfig),
+          scope: normalizeDraftScope(currentDraftType, editScope),
           enabled: enabled ?? true,
         });
       } else {
@@ -1282,74 +1664,26 @@ export function SettingsFanoutSection({
   };
 
   const handleAddCreate = async (type: string) => {
-    const defaults: Record<string, Record<string, unknown>> = {
-      mqtt_private: {
-        broker_host: '',
-        broker_port: 1883,
-        username: '',
-        password: '',
-        use_tls: false,
-        tls_insecure: false,
-        topic_prefix: 'meshcore',
-      },
-      mqtt_community: {
-        broker_host: 'mqtt-us-v1.letsmesh.net',
-        broker_port: DEFAULT_COMMUNITY_BROKER_PORT,
-        transport: DEFAULT_COMMUNITY_TRANSPORT,
-        use_tls: true,
-        tls_verify: true,
-        auth_mode: DEFAULT_COMMUNITY_AUTH_MODE,
-        username: '',
-        password: '',
-        iata: '',
-        email: '',
-        token_audience: '',
-        topic_template: DEFAULT_COMMUNITY_PACKET_TOPIC_TEMPLATE,
-      },
-      bot: {
-        code: DEFAULT_BOT_CODE,
-      },
-      webhook: {
-        url: '',
-        method: 'POST',
-        headers: {},
-        hmac_secret: '',
-        hmac_header: '',
-      },
-      apprise: {
-        urls: '',
-        preserve_identity: true,
-        include_path: true,
-      },
-      sqs: {
-        queue_url: '',
-        region_name: '',
-        endpoint_url: '',
-        access_key_id: '',
-        secret_access_key: '',
-        session_token: '',
-      },
-    };
-    const defaultScopes: Record<string, Record<string, unknown>> = {
-      mqtt_private: { messages: 'all', raw_packets: 'all' },
-      mqtt_community: { messages: 'none', raw_packets: 'all' },
-      bot: { messages: 'all', raw_packets: 'none' },
-      webhook: { messages: 'all', raw_packets: 'none' },
-      apprise: { messages: 'all', raw_packets: 'none' },
-      sqs: { messages: 'all', raw_packets: 'none' },
-    };
+    if (!isDraftType(type)) return;
+    const defaults = cloneDraftDefaults(type);
     setAddMenuOpen(false);
     setEditingId(null);
     setDraftType(type);
-    setEditName(getDefaultIntegrationName(type, configs));
-    setEditConfig(defaults[type] || {});
-    setEditScope(defaultScopes[type] || {});
+    setEditName(
+      type === 'mqtt_community_meshrank' ||
+        type === 'mqtt_community_letsmesh_us' ||
+        type === 'mqtt_community_letsmesh_eu'
+        ? DRAFT_RECIPES[type].defaultName
+        : getDefaultIntegrationName(DRAFT_RECIPES[type].savedType, configs)
+    );
+    setEditConfig(defaults.config);
+    setEditScope(defaults.scope);
   };
 
   const editingConfig = editingId ? configs.find((c) => c.id === editingId) : null;
   const detailType = draftType ?? editingConfig?.type ?? null;
   const isDraft = draftType !== null;
-  const configGroups = TYPE_OPTIONS.map((opt) => ({
+  const configGroups = LIST_TYPE_OPTIONS.map((opt) => ({
     type: opt.value,
     label: opt.label,
     configs: configs
@@ -1379,9 +1713,7 @@ export function SettingsFanoutSection({
           />
         </div>
 
-        <div className="text-xs text-muted-foreground">
-          Type: {TYPE_LABELS[detailType] || detailType}
-        </div>
+        <div className="text-xs text-muted-foreground">Type: {getDetailTypeLabel(detailType)}</div>
 
         <Separator />
 
@@ -1398,6 +1730,26 @@ export function SettingsFanoutSection({
           <MqttCommunityConfigEditor config={editConfig} onChange={setEditConfig} />
         )}
 
+        {detailType === 'mqtt_community_meshrank' && (
+          <MeshRankConfigEditor config={editConfig} onChange={setEditConfig} />
+        )}
+
+        {detailType === 'mqtt_community_letsmesh_us' && (
+          <LetsMeshConfigEditor
+            config={editConfig}
+            onChange={setEditConfig}
+            brokerHost={DEFAULT_COMMUNITY_BROKER_HOST}
+          />
+        )}
+
+        {detailType === 'mqtt_community_letsmesh_eu' && (
+          <LetsMeshConfigEditor
+            config={editConfig}
+            onChange={setEditConfig}
+            brokerHost={DEFAULT_COMMUNITY_BROKER_HOST_EU}
+          />
+        )}
+
         {detailType === 'bot' && <BotConfigEditor config={editConfig} onChange={setEditConfig} />}
 
         {detailType === 'apprise' && (
@@ -1459,7 +1811,8 @@ export function SettingsFanoutSection({
   return (
     <div className={cn('mx-auto w-full max-w-[800px] space-y-4', className)}>
       <div className="rounded-md border border-warning/50 bg-warning/10 px-4 py-3 text-sm text-warning">
-        Integrations are an experimental feature in open beta.
+        Integrations are an experimental feature in open beta, and allow you to fanout raw and
+        decrypted messages across multiple services for automation, analysis, or archiving.
       </div>
 
       {health?.bots_disabled && (
@@ -1482,9 +1835,9 @@ export function SettingsFanoutSection({
         {addMenuOpen && (
           <div
             role="menu"
-            className="absolute left-0 top-full z-10 mt-2 min-w-56 rounded-md border border-input bg-background p-1 shadow-md"
+            className="absolute left-0 top-full z-10 mt-2 min-w-72 rounded-md border border-input bg-background p-1 shadow-md"
           >
-            {TYPE_OPTIONS.filter((opt) => opt.value !== 'bot' || !health?.bots_disabled).map(
+            {CREATE_TYPE_OPTIONS.filter((opt) => opt.value !== 'bot' || !health?.bots_disabled).map(
               (opt) => (
                 <button
                   key={opt.value}

frontend/src/components/settings/SettingsLocalSection.tsx

@@ -1,7 +1,9 @@
 import { useState } from 'react';
+import { Logs, MessageSquare } from 'lucide-react';
 import { Input } from '../ui/input';
 import { Label } from '../ui/label';
 import { Separator } from '../ui/separator';
+import { ContactAvatar } from '../ContactAvatar';
 import {
   captureLastViewedConversationFromHash,
   getReopenLastConversationEnabled,
@@ -9,6 +11,12 @@ import {
 } from '../../utils/lastViewedConversation';
 import { ThemeSelector } from './ThemeSelector';
 import { getLocalLabel, setLocalLabel, type LocalLabel } from '../../utils/localLabel';
+import {
+  DISTANCE_UNIT_LABELS,
+  DISTANCE_UNITS,
+  setSavedDistanceUnit,
+} from '../../utils/distanceUnits';
+import { useDistanceUnit } from '../../contexts/DistanceUnitContext';
 
 export function SettingsLocalSection({
   onLocalLabelChange,
@@ -17,6 +25,7 @@ export function SettingsLocalSection({
   onLocalLabelChange?: (label: LocalLabel) => void;
   className?: string;
 }) {
+  const { distanceUnit, setDistanceUnit } = useDistanceUnit();
   const [reopenLastConversation, setReopenLastConversation] = useState(
     getReopenLastConversationEnabled
   );
@@ -80,6 +89,31 @@ export function SettingsLocalSection({
 
       <Separator />
 
+      <div className="space-y-3">
+        <Label htmlFor="distance-units">Distance Units</Label>
+        <select
+          id="distance-units"
+          value={distanceUnit}
+          onChange={(event) => {
+            const nextUnit = event.target.value as (typeof DISTANCE_UNITS)[number];
+            setSavedDistanceUnit(nextUnit);
+            setDistanceUnit(nextUnit);
+          }}
+          className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
+        >
+          {DISTANCE_UNITS.map((unit) => (
+            <option key={unit} value={unit}>
+              {DISTANCE_UNIT_LABELS[unit]}
+            </option>
+          ))}
+        </select>
+        <p className="text-xs text-muted-foreground">
+          Controls how distances are shown throughout the app.
+        </p>
+      </div>
+
+      <Separator />
+
       <label className="flex items-center gap-3 cursor-pointer">
         <input
           type="checkbox"
@@ -97,7 +131,7 @@ function ThemePreview({ className }: { className?: string }) {
   return (
     <div className={`rounded-lg border border-border bg-card p-3 ${className ?? ''}`}>
       <p className="text-xs text-muted-foreground mb-3">
-        Preview alert and message contrast for the selected theme.
+        Preview alert, message, sidebar, and badge contrast for the selected theme.
       </p>
 
       <div className="space-y-2">
@@ -125,6 +159,42 @@ function ThemePreview({ className }: { className?: string }) {
           text="Hi there! I'm using RemoteTerm."
         />
       </div>
+
+      <div className="mt-4 rounded-md border border-border bg-background p-2">
+        <p className="mb-2 text-[11px] font-medium text-muted-foreground">Sidebar preview</p>
+        <div className="space-y-1">
+          <PreviewSidebarRow
+            active
+            leading={
+              <span
+                className="flex h-6 w-6 items-center justify-center rounded-md bg-primary/10 text-primary"
+                aria-hidden="true"
+              >
+                <Logs className="h-3.5 w-3.5" />
+              </span>
+            }
+            label="Packet Feed"
+          />
+          <PreviewSidebarRow
+            leading={<ContactAvatar name="Alice" publicKey={'ab'.repeat(32)} size={24} />}
+            label="Alice"
+            badge={
+              <span className="rounded-full bg-badge-unread/90 px-1.5 py-0.5 text-[10px] font-semibold text-badge-unread-foreground">
+                3
+              </span>
+            }
+          />
+          <PreviewSidebarRow
+            leading={<ContactAvatar name="Mesh Ops" publicKey={'cd'.repeat(32)} size={24} />}
+            label="Mesh Ops"
+            badge={
+              <span className="rounded-full bg-badge-mention px-1.5 py-0.5 text-[10px] font-semibold text-badge-mention-foreground">
+                @2
+              </span>
+            }
+          />
+        </div>
+      </div>
     </div>
   );
 }
@@ -153,3 +223,34 @@ function PreviewMessage({
     </div>
   );
 }
+
+function PreviewSidebarRow({
+  leading,
+  label,
+  badge,
+  active = false,
+}: {
+  leading: React.ReactNode;
+  label: string;
+  badge?: React.ReactNode;
+  active?: boolean;
+}) {
+  return (
+    <div
+      className={`flex items-center gap-2 rounded-md border-l-2 px-3 py-2 text-[13px] ${
+        active ? 'border-l-primary bg-accent text-foreground' : 'border-l-transparent'
+      }`}
+    >
+      {leading}
+      <span className={`min-w-0 flex-1 truncate ${active ? 'font-medium' : 'text-foreground'}`}>
+        {label}
+      </span>
+      {badge}
+      {!badge && (
+        <span className="text-muted-foreground" aria-hidden="true">
+          <MessageSquare className="h-3.5 w-3.5" />
+        </span>
+      )}
+    </div>
+  );
+}

frontend/src/components/settings/SettingsRadioSection.tsx

@@ -5,14 +5,18 @@ import { Label } from '../ui/label';
 import { Button } from '../ui/button';
 import { Separator } from '../ui/separator';
 import { toast } from '../ui/sonner';
+import { Checkbox } from '../ui/checkbox';
 import { RADIO_PRESETS } from '../../utils/radioPresets';
 import { stripRegionScopePrefix } from '../../utils/regionScope';
 import type {
   AppSettings,
   AppSettingsUpdate,
   HealthStatus,
+  RadioAdvertMode,
   RadioConfig,
   RadioConfigUpdate,
+  RadioDiscoveryResponse,
+  RadioDiscoveryTarget,
 } from '../../types';
 
 export function SettingsRadioSection({
@@ -27,6 +31,9 @@ export function SettingsRadioSection({
   onDisconnect,
   onReconnect,
   onAdvertise,
+  meshDiscovery,
+  meshDiscoveryLoadingTarget,
+  onDiscoverMesh,
   onClose,
   className,
 }: {
@@ -40,7 +47,10 @@ export function SettingsRadioSection({
   onReboot: () => Promise<void>;
   onDisconnect: () => Promise<void>;
   onReconnect: () => Promise<void>;
-  onAdvertise: () => Promise<void>;
+  onAdvertise: (mode: RadioAdvertMode) => Promise<void>;
+  meshDiscovery: RadioDiscoveryResponse | null;
+  meshDiscoveryLoadingTarget: RadioDiscoveryTarget | null;
+  onDiscoverMesh: (target: RadioDiscoveryTarget) => Promise<void>;
   onClose: () => void;
   className?: string;
 }) {
@@ -54,6 +64,8 @@ export function SettingsRadioSection({
   const [sf, setSf] = useState('');
   const [cr, setCr] = useState('');
   const [pathHashMode, setPathHashMode] = useState('0');
+  const [advertLocationSource, setAdvertLocationSource] = useState<'off' | 'current'>('current');
+  const [multiAcksEnabled, setMultiAcksEnabled] = useState(false);
   const [gettingLocation, setGettingLocation] = useState(false);
   const [busy, setBusy] = useState(false);
   const [rebooting, setRebooting] = useState(false);
@@ -73,7 +85,8 @@ export function SettingsRadioSection({
   const [floodError, setFloodError] = useState<string | null>(null);
 
   // Advertise state
-  const [advertising, setAdvertising] = useState(false);
+  const [advertisingMode, setAdvertisingMode] = useState<RadioAdvertMode | null>(null);
+  const [discoverError, setDiscoverError] = useState<string | null>(null);
   const [connectionBusy, setConnectionBusy] = useState(false);
 
   useEffect(() => {
@@ -86,6 +99,8 @@ export function SettingsRadioSection({
     setSf(String(config.radio.sf));
     setCr(String(config.radio.cr));
     setPathHashMode(String(config.path_hash_mode));
+    setAdvertLocationSource(config.advert_location_source ?? 'current');
+    setMultiAcksEnabled(config.multi_acks_enabled ?? false);
   }, [config]);
 
   useEffect(() => {
@@ -175,6 +190,12 @@ export function SettingsRadioSection({
       lat: parsedLat,
       lon: parsedLon,
       tx_power: parsedTxPower,
+      ...(advertLocationSource !== (config.advert_location_source ?? 'current')
+        ? { advert_location_source: advertLocationSource }
+        : {}),
+      ...(multiAcksEnabled !== (config.multi_acks_enabled ?? false)
+        ? { multi_acks_enabled: multiAcksEnabled }
+        : {}),
       radio: {
         freq: parsedFreq,
         bw: parsedBw,
@@ -281,12 +302,21 @@ export function SettingsRadioSection({
     }
   };
 
-  const handleAdvertise = async () => {
-    setAdvertising(true);
+  const handleAdvertise = async (mode: RadioAdvertMode) => {
+    setAdvertisingMode(mode);
     try {
-      await onAdvertise();
+      await onAdvertise(mode);
     } finally {
-      setAdvertising(false);
+      setAdvertisingMode(null);
+    }
+  };
+
+  const handleDiscover = async (target: RadioDiscoveryTarget) => {
+    setDiscoverError(null);
+    try {
+      await onDiscoverMesh(target);
+    } catch (err) {
+      setDiscoverError(err instanceof Error ? err.message : 'Failed to run mesh discovery');
     }
   };
 
@@ -310,6 +340,35 @@ export function SettingsRadioSection({
             ? `Connection paused${health?.connection_info ? ` (${health.connection_info})` : ''}`
             : 'Not connected';
 
+  const deviceInfoLabel = useMemo(() => {
+    const info = health?.radio_device_info;
+    if (!info) {
+      return null;
+    }
+
+    const model = info.model?.trim() || null;
+    const firmwareParts = [info.firmware_build?.trim(), info.firmware_version?.trim()].filter(
+      (value): value is string => Boolean(value)
+    );
+    const capacityParts = [
+      typeof info.max_contacts === 'number' ? `${info.max_contacts} contacts` : null,
+      typeof info.max_channels === 'number' ? `${info.max_channels} channels` : null,
+    ].filter((value): value is string => value !== null);
+
+    if (!model && firmwareParts.length === 0 && capacityParts.length === 0) {
+      return null;
+    }
+
+    let label = model ?? 'Radio';
+    if (firmwareParts.length > 0) {
+      label += ` running ${firmwareParts.join('/')}`;
+    }
+    if (capacityParts.length > 0) {
+      label += ` (max: ${capacityParts.join(', ')})`;
+    }
+    return label;
+  }, [health?.radio_device_info]);
+
   const handleConnectionAction = async () => {
     setConnectionBusy(true);
     try {
@@ -354,6 +413,7 @@ export function SettingsRadioSection({
             {connectionStatusLabel}
           </span>
         </div>
+        {deviceInfoLabel && <p className="text-sm text-muted-foreground">{deviceInfoLabel}</p>}
         <Button
           type="button"
           variant="outline"
@@ -506,6 +566,43 @@ export function SettingsRadioSection({
             />
           </div>
         </div>
+        <div className="space-y-2">
+          <Label htmlFor="advert-location-source">Advert Location Source</Label>
+          <select
+            id="advert-location-source"
+            value={advertLocationSource}
+            onChange={(e) => setAdvertLocationSource(e.target.value as 'off' | 'current')}
+            className="w-full h-10 px-3 rounded-md border border-input bg-background text-sm ring-offset-background focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2"
+          >
+            <option value="off">Off</option>
+            <option value="current">Include Node Location</option>
+          </select>
+          <p className="text-xs text-muted-foreground">
+            Companion-radio firmware does not distinguish between saved coordinates and live GPS
+            here. When enabled, adverts include the node&apos;s current location state. That may be
+            the last coordinates you set from RemoteTerm or live GPS coordinates if the node itself
+            is already updating them. RemoteTerm cannot enable GPS on the node through the interface
+            library.
+          </p>
+        </div>
+        <div className="space-y-2">
+          <div className="flex items-start gap-3 rounded-md border border-border/60 p-3">
+            <Checkbox
+              id="multi-acks-enabled"
+              checked={multiAcksEnabled}
+              onCheckedChange={(checked) => setMultiAcksEnabled(checked === true)}
+              className="mt-0.5"
+            />
+            <div className="space-y-1">
+              <Label htmlFor="multi-acks-enabled">Extra Direct ACK Transmission</Label>
+              <p className="text-xs text-muted-foreground">
+                When enabled, the radio sends one extra direct ACK transmission before the normal
+                ACK for received direct messages. This is a firmware-level receive behavior, not a
+                RemoteTerm retry setting.
+              </p>
+            </div>
+          </div>
+        </div>
       </div>
 
       {config.path_hash_mode_supported && (
@@ -663,23 +760,111 @@ export function SettingsRadioSection({
 
       <Separator />
 
-      {/* Send Advertisement */}
+      <div className="space-y-2">
+        <Label className="text-base">Hear &amp; Be Heard</Label>
+      </div>
+
       <div className="space-y-2">
         <Label>Send Advertisement</Label>
         <p className="text-xs text-muted-foreground">
-          Send a flood advertisement to announce your presence on the mesh network.
+          Flood adverts propagate through repeaters. Zero-hop adverts are local-only and use less
+          airtime.
         </p>
-        <Button
-          onClick={handleAdvertise}
-          disabled={advertising || !health?.radio_connected}
-          className="w-full bg-warning hover:bg-warning/90 text-warning-foreground"
-        >
-          {advertising ? 'Sending...' : 'Send Advertisement'}
-        </Button>
+        <div className="grid grid-cols-1 gap-2 sm:grid-cols-2">
+          <Button
+            onClick={() => handleAdvertise('flood')}
+            disabled={advertisingMode !== null || !health?.radio_connected}
+            className="w-full bg-warning hover:bg-warning/90 text-warning-foreground"
+          >
+            {advertisingMode === 'flood' ? 'Sending...' : 'Send Flood Advertisement'}
+          </Button>
+          <Button
+            onClick={() => handleAdvertise('zero_hop')}
+            disabled={advertisingMode !== null || !health?.radio_connected}
+            className="w-full"
+          >
+            {advertisingMode === 'zero_hop' ? 'Sending...' : 'Send Zero-Hop Advertisement'}
+          </Button>
+        </div>
         {!health?.radio_connected && (
           <p className="text-sm text-destructive">Radio not connected</p>
         )}
       </div>
+
+      <div className="space-y-3">
+        <Label>Mesh Discovery</Label>
+        <p className="text-xs text-muted-foreground">
+          Discover nearby node types that currently respond to mesh discovery requests: repeaters
+          and sensors.
+        </p>
+        <div className="grid grid-cols-1 gap-2 sm:grid-cols-3">
+          {[
+            { target: 'repeaters', label: 'Discover Repeaters' },
+            { target: 'sensors', label: 'Discover Sensors' },
+            { target: 'all', label: 'Discover Both' },
+          ].map(({ target, label }) => (
+            <Button
+              key={target}
+              type="button"
+              variant="outline"
+              onClick={() => handleDiscover(target as RadioDiscoveryTarget)}
+              disabled={meshDiscoveryLoadingTarget !== null || !health?.radio_connected}
+              className="w-full"
+            >
+              {meshDiscoveryLoadingTarget === target ? 'Listening...' : label}
+            </Button>
+          ))}
+        </div>
+        {!health?.radio_connected && (
+          <p className="text-sm text-destructive">Radio not connected</p>
+        )}
+        {discoverError && (
+          <p className="text-sm text-destructive" role="alert">
+            {discoverError}
+          </p>
+        )}
+        {meshDiscovery && (
+          <div className="space-y-2 rounded-md border border-input bg-muted/20 p-3">
+            <div className="flex items-center justify-between gap-4">
+              <p className="text-sm font-medium">
+                Last sweep: {meshDiscovery.results.length} node
+                {meshDiscovery.results.length === 1 ? '' : 's'}
+              </p>
+              <p className="text-xs text-muted-foreground">
+                {meshDiscovery.duration_seconds.toFixed(0)}s listen window
+              </p>
+            </div>
+            {meshDiscovery.results.length === 0 ? (
+              <p className="text-sm text-muted-foreground">
+                No supported nodes responded during the last discovery sweep.
+              </p>
+            ) : (
+              <div className="space-y-2">
+                {meshDiscovery.results.map((result) => (
+                  <div
+                    key={result.public_key}
+                    className="rounded-md border border-input bg-background px-3 py-2"
+                  >
+                    <div className="flex items-center justify-between gap-3">
+                      <span className="text-sm font-medium capitalize">{result.node_type}</span>
+                      <span className="text-xs text-muted-foreground">
+                        heard {result.heard_count} time{result.heard_count === 1 ? '' : 's'}
+                      </span>
+                    </div>
+                    <p className="mt-1 break-all font-mono text-xs text-muted-foreground">
+                      {result.public_key}
+                    </p>
+                    <p className="mt-1 text-xs text-muted-foreground">
+                      Heard here: {result.local_snr ?? 'n/a'} dB SNR / {result.local_rssi ?? 'n/a'}{' '}
+                      dBm RSSI. Remote heard us: {result.remote_snr ?? 'n/a'} dB SNR.
+                    </p>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        )}
+      </div>
     </div>
   );
 }

frontend/src/components/visualizer/AGENTS_packet_visualizer.md

@@ -12,24 +12,41 @@ The visualizer displays:
 
 ## Architecture
 
-### Data Layer (`components/visualizer/useVisualizerData3D.ts`)
+### Semantic Data Layer (`networkGraph/packetNetworkGraph.ts`)
 
-The custom hook manages all graph state and simulation logic:
+The packet-network module owns the canonical mesh representation and the visibility-aware projection logic:
 
 ```
-Packets → Parse → Aggregate by key → Observation window → Publish → Animate
+Packets → Parse → Canonical observations/adjacency → Projection by settings
 ```
 
 **Key responsibilities:**
 
-- Maintains node and link maps (`nodesRef`, `linksRef`)
+- Resolves packet source / repeater / destination nodes into a canonical path
+- Maintains canonical node, link, observation, and neighbor state independent of UI toggles
+- Applies ambiguous repeater heuristics and advert-path hints while building canonical data
+- Projects canonical paths into rendered links, including dashed bridges over hidden ambiguous runs
+- Exposes a reusable semantic surface for other consumers besides the 3D visualizer
+
+### Visualizer Data Hook (`components/visualizer/useVisualizerData3D.ts`)
+
+The hook manages render-specific state and animation timing on top of the shared packet-network data layer:
+
+```
+Canonical projection → Aggregate by key → Observation window → Publish → Animate
+```
+
+**Key responsibilities:**
+
+- Adapts semantic packet-network nodes/links into `GraphNode` / `GraphLink` render objects
 - Runs `d3-force-3d` simulation for 3D layout (`.numDimensions(3)`)
-- Processes incoming packets with deduplication
-- Aggregates packet repeats across multiple paths
+- Processes incoming packets with deduplication and feeds them into the semantic layer
+- Aggregates packet repeats across multiple projected paths
 - Manages particle queue and animation timing
 
 **State:**
 
+- `networkStateRef`: Canonical packet-network state (nodes, links, observations, neighbors)
 - `nodesRef`: Map of node ID → GraphNode
 - `linksRef`: Map of link key → GraphLink
 - `particlesRef`: Array of active Particle objects
@@ -50,6 +67,8 @@ Scene creation, render-loop updates, raycasting hover, and click-to-pin interact
 
 ### Shared Utilities
 
+- `networkGraph/packetNetworkGraph.ts`
+  - Canonical packet-network types and replay/projection logic
 - `components/visualizer/shared.ts`
   - Graph-specific types: `GraphNode`, `GraphLink`, `NodeMeshData`
   - Shared rendering helpers: node colors, relative-time formatting, typed-array growth helpers
@@ -75,8 +94,9 @@ When a new packet arrives from the WebSocket:
 
 ```typescript
 packets.forEach((packet) => {
-  if (processedRef.current.has(packet.id)) return; // Skip duplicates
-  processedRef.current.add(packet.id);
+  const observationKey = getRawPacketObservationKey(packet);
+  if (processedRef.current.has(observationKey)) return; // Skip duplicates
+  processedRef.current.add(observationKey);
 
   const parsed = parsePacket(packet.data);
   const key = generatePacketKey(parsed, packet);
@@ -196,6 +216,8 @@ When a winner is found, the ambiguous node gets a `probableIdentity` label (the
 
 **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.
 
+**Sibling collapse projection:** When an ambiguous repeater has a high-confidence likely identity and that likely repeater also appears as a definitely-known sibling connecting to the same next hop, the projection layer can collapse the ambiguous node into the known repeater. This is projection-only: canonical observations and canonical neighbor truth remain unchanged.
+
 **Toggle:** "Use repeater advert-path identity hints" checkbox (enabled by default, disabled when ambiguous repeaters are hidden).
 
 ### Traffic Pattern Splitting (Experimental)
@@ -308,40 +330,44 @@ function buildPath(parsed, packet, myPrefix): string[] {
 | Pan (right-drag)           | Pan the camera                              |
 | Scroll wheel               | Zoom in/out                                 |
 
-**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.
+**Click-to-pin:** When a node is pinned, hovering other nodes does not change the highlight. The tooltip shows "Traffic exchanged with:" using canonical packet-network adjacency, not rendered-link adjacency, so hidden repeaters still appear truthfully as hidden neighbors.
 
 ## Configuration Options
 
-| Option                     | Default | Description                                               |
-| -------------------------- | ------- | --------------------------------------------------------- |
-| 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) |
-| 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)                 |
+| Option                     | Default | Description                                                 |
+| -------------------------- | ------- | ----------------------------------------------------------- |
+| 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        |
+| Collapse sibling repeaters | On      | Merge likely ambiguous repeater with known sibling repeater |
+| Split by traffic pattern   | Off     | Split ambiguous repeaters by next-hop routing (see above)   |
+| 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
 
 ```
 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)
+├── SEMANTIC DATA LAYER (networkGraph/packetNetworkGraph.ts)
+│   ├── Contact/advert indexes
+│   ├── Canonical node/link/neighbor/observation state
+│   ├── Path building (resolveNode, buildCanonicalPathForPacket)
 │   ├── Traffic pattern analysis (for repeater disambiguation)
-│   └── Packet processing & publishing
+│   └── Projection (projectCanonicalPath, projectPacketNetwork)
+├── DATA HOOK (useVisualizerData3D)
+│   ├── Refs (network state, render nodes, links, particles, simulation, pending, timers, stretchRaf)
+│   ├── d3-force-3d simulation initialization (.numDimensions(3))
+│   ├── Semantic→render adaptation
+│   ├── Observation-window packet aggregation
+│   └── Particle publishing
 └── MAIN COMPONENT (PacketVisualizer3D)
     ├── Three.js scene setup (WebGLRenderer, CSS2DRenderer, OrbitControls)
     ├── Node mesh management (SphereGeometry + CSS2DObject labels)
@@ -356,6 +382,13 @@ utils/visualizerUtils.ts
 ├── Constants (COLORS, PARTICLE_COLOR_MAP, PARTICLE_SPEED, PACKET_LEGEND_ITEMS)
 └── Functions (parsePacket, generatePacketKey, analyzeRepeaterTraffic, etc.)
 
+networkGraph/packetNetworkGraph.ts
+├── Types (PacketNetworkNode, PacketNetworkLink, PacketNetworkObservation, projection types)
+├── Context builders (contact and advert-path indexes)
+├── Canonical replay (ingestPacketIntoPacketNetwork)
+├── Projection helpers (projectCanonicalPath, projectPacketNetwork)
+└── State maintenance (clear, prune, neighbor snapshots)
+
 types/d3-force-3d.d.ts
 └── Type declarations for d3-force-3d (SimulationNodeDatum3D, Simulation3D, forces)
 ```

frontend/src/components/visualizer/VisualizerControls.tsx

@@ -13,6 +13,8 @@ interface VisualizerControlsProps {
   setShowAmbiguousNodes: (value: boolean) => void;
   useAdvertPathHints: boolean;
   setUseAdvertPathHints: (value: boolean) => void;
+  collapseLikelyKnownSiblingRepeaters: boolean;
+  setCollapseLikelyKnownSiblingRepeaters: (value: boolean) => void;
   splitAmbiguousByTraffic: boolean;
   setSplitAmbiguousByTraffic: (value: boolean) => void;
   observationWindowSec: number;
@@ -46,6 +48,8 @@ export function VisualizerControls({
   setShowAmbiguousNodes,
   useAdvertPathHints,
   setUseAdvertPathHints,
+  collapseLikelyKnownSiblingRepeaters,
+  setCollapseLikelyKnownSiblingRepeaters,
   splitAmbiguousByTraffic,
   setSplitAmbiguousByTraffic,
   observationWindowSec,
@@ -149,55 +153,77 @@ export function VisualizerControls({
                     Show ambiguous sender/recipient
                   </span>
                 </label>
-                <label className="flex items-center gap-2 cursor-pointer">
-                  <Checkbox
-                    checked={useAdvertPathHints}
-                    onCheckedChange={(c) => setUseAdvertPathHints(c === true)}
-                    disabled={!showAmbiguousPaths}
-                  />
-                  <span
-                    title="Use stored repeater advert paths to assign likely identity labels for ambiguous repeater nodes"
-                    className={!showAmbiguousPaths ? 'text-muted-foreground' : ''}
-                  >
-                    Use repeater advert-path identity hints
-                  </span>
-                </label>
-                <label className="flex items-center gap-2 cursor-pointer">
-                  <Checkbox
-                    checked={splitAmbiguousByTraffic}
-                    onCheckedChange={(c) => setSplitAmbiguousByTraffic(c === true)}
-                    disabled={!showAmbiguousPaths}
-                  />
-                  <span
-                    title="Split ambiguous repeaters into separate nodes based on traffic patterns (prev→next). Helps identify colliding prefixes representing different physical nodes, but requires enough traffic to disambiguate."
-                    className={!showAmbiguousPaths ? 'text-muted-foreground' : ''}
-                  >
-                    Heuristically group repeaters by traffic pattern
-                  </span>
-                </label>
-                <div className="flex items-center gap-2">
-                  <label
-                    htmlFor="observation-window-3d"
-                    className="text-muted-foreground"
-                    title="How long to wait for duplicate packets via different paths before animating"
-                  >
-                    Ack/echo listen window:
-                  </label>
-                  <input
-                    id="observation-window-3d"
-                    type="number"
-                    min="1"
-                    max="60"
-                    value={observationWindowSec}
-                    onChange={(e) =>
-                      setObservationWindowSec(
-                        Math.max(1, Math.min(60, parseInt(e.target.value, 10) || 1))
-                      )
-                    }
-                    className="w-12 px-1 py-0.5 bg-background border border-border rounded text-xs text-center"
-                  />
-                  <span className="text-muted-foreground">sec</span>
-                </div>
+                <details className="rounded border border-border/60 px-2 py-1">
+                  <summary className="cursor-pointer select-none text-muted-foreground">
+                    Advanced
+                  </summary>
+                  <div className="mt-2 flex flex-col gap-2">
+                    <label className="flex items-center gap-2 cursor-pointer">
+                      <Checkbox
+                        checked={useAdvertPathHints}
+                        onCheckedChange={(c) => setUseAdvertPathHints(c === true)}
+                        disabled={!showAmbiguousPaths}
+                      />
+                      <span
+                        title="Use stored repeater advert paths to assign likely identity labels for ambiguous repeater nodes."
+                        className={!showAmbiguousPaths ? 'text-muted-foreground' : ''}
+                      >
+                        Use repeater advert-path identity hints
+                      </span>
+                    </label>
+                    <label className="flex items-center gap-2 cursor-pointer">
+                      <Checkbox
+                        checked={collapseLikelyKnownSiblingRepeaters}
+                        onCheckedChange={(c) => setCollapseLikelyKnownSiblingRepeaters(c === true)}
+                        disabled={!showAmbiguousPaths || !useAdvertPathHints}
+                      />
+                      <span
+                        title="When an ambiguous repeater has a high-confidence likely-identity that matches a sibling definitely-known repeater, and they both connect to the same next hop, collapse them into the known repeater. This should resolve more ambiguity as the mesh navigates the 1.14 upgrade."
+                        className={
+                          !showAmbiguousPaths || !useAdvertPathHints ? 'text-muted-foreground' : ''
+                        }
+                      >
+                        Collapse likely sibling repeaters
+                      </span>
+                    </label>
+                    <label className="flex items-center gap-2 cursor-pointer">
+                      <Checkbox
+                        checked={splitAmbiguousByTraffic}
+                        onCheckedChange={(c) => setSplitAmbiguousByTraffic(c === true)}
+                        disabled={!showAmbiguousPaths}
+                      />
+                      <span
+                        title="Split ambiguous repeaters into separate nodes based on traffic patterns (prev→next). Helps identify colliding prefixes representing different physical nodes, but requires enough traffic to disambiguate."
+                        className={!showAmbiguousPaths ? 'text-muted-foreground' : ''}
+                      >
+                        Heuristically group repeaters by traffic pattern
+                      </span>
+                    </label>
+                    <div className="flex items-center gap-2">
+                      <label
+                        htmlFor="observation-window-3d"
+                        className="text-muted-foreground"
+                        title="How long to wait for duplicate packets via different paths before animating"
+                      >
+                        Ack/echo listen window:
+                      </label>
+                      <input
+                        id="observation-window-3d"
+                        type="number"
+                        min="1"
+                        max="60"
+                        value={observationWindowSec}
+                        onChange={(e) =>
+                          setObservationWindowSec(
+                            Math.max(1, Math.min(60, parseInt(e.target.value, 10) || 1))
+                          )
+                        }
+                        className="w-12 px-1 py-0.5 bg-background border border-border rounded text-xs text-center"
+                      />
+                      <span className="text-muted-foreground">sec</span>
+                    </div>
+                  </div>
+                </details>
                 <div className="border-t border-border pt-2 mt-1 flex flex-col gap-2">
                   <label className="flex items-center gap-2 cursor-pointer">
                     <Checkbox

frontend/src/components/visualizer/VisualizerTooltip.tsx

@@ -1,25 +1,37 @@
-import type { GraphNode } from './shared';
+import type { PacketNetworkNode } from '../../networkGraph/packetNetworkGraph';
 import { formatRelativeTime } from './shared';
 
 interface VisualizerTooltipProps {
   activeNodeId: string | null;
-  nodes: Map<string, GraphNode>;
-  neighborIds: string[];
+  canonicalNodes: Map<string, PacketNetworkNode>;
+  canonicalNeighborIds: Map<string, string[]>;
+  renderedNodeIds: Set<string>;
 }
 
-export function VisualizerTooltip({ activeNodeId, nodes, neighborIds }: VisualizerTooltipProps) {
+export function VisualizerTooltip({
+  activeNodeId,
+  canonicalNodes,
+  canonicalNeighborIds,
+  renderedNodeIds,
+}: VisualizerTooltipProps) {
   if (!activeNodeId) return null;
 
-  const node = nodes.get(activeNodeId);
+  const node = canonicalNodes.get(activeNodeId);
   if (!node) return null;
 
+  const neighborIds = canonicalNeighborIds.get(activeNodeId) ?? [];
   const neighbors = neighborIds
     .map((nid) => {
-      const neighbor = nodes.get(nid);
+      const neighbor = canonicalNodes.get(nid);
       if (!neighbor) return null;
       const displayName =
         neighbor.name || (neighbor.type === 'self' ? 'Me' : neighbor.id.slice(0, 8));
-      return { id: nid, name: displayName, ambiguousNames: neighbor.ambiguousNames };
+      return {
+        id: nid,
+        name: displayName,
+        ambiguousNames: neighbor.ambiguousNames,
+        hidden: !renderedNodeIds.has(nid),
+      };
     })
     .filter((neighbor): neighbor is NonNullable<typeof neighbor> => neighbor !== null);
 
@@ -56,6 +68,7 @@ export function VisualizerTooltip({ activeNodeId, nodes, neighborIds }: Visualiz
               {neighbors.map((neighbor) => (
                 <li key={neighbor.id}>
                   {neighbor.name}
+                  {neighbor.hidden && <span className="text-muted-foreground/60"> (hidden)</span>}
                   {neighbor.ambiguousNames && neighbor.ambiguousNames.length > 0 && (
                     <span className="text-muted-foreground/60">
                       {' '}

frontend/src/components/visualizer/shared.ts

@@ -21,6 +21,9 @@ export interface GraphLink extends SimulationLinkDatum<GraphNode> {
   source: string | GraphNode;
   target: string | GraphNode;
   lastActivity: number;
+  hasDirectObservation: boolean;
+  hasHiddenIntermediate: boolean;
+  hiddenHopLabels: string[];
 }
 
 export interface NodeMeshData {
@@ -74,6 +77,11 @@ export function formatRelativeTime(timestamp: number): string {
   return secs > 0 ? `${minutes}m ${secs}s ago` : `${minutes}m ago`;
 }
 
+export function getSceneNodeLabel(node: Pick<GraphNode, 'id' | 'name' | 'type' | 'isAmbiguous'>) {
+  const baseLabel = node.name || (node.type === 'self' ? 'Me' : node.id.slice(0, 8));
+  return node.isAmbiguous ? `${baseLabel} (?)` : baseLabel;
+}
+
 export function normalizePacketTimestampMs(timestamp: number | null | undefined): number {
   if (!Number.isFinite(timestamp) || !timestamp || timestamp <= 0) {
     return Date.now();