Thin out the docker image

Updating changelog + build for 3.13.0
Fix up e2e tests
2026-05-11 20:06:13 +02:00 · 2026-04-30 20:57:25 -07:00 · 2026-04-30 20:31:32 -07:00 · 2026-04-30 20:22:59 -07:00 · 2026-04-30 19:54:43 -07:00 · 2026-04-30 19:07:50 -07:00
186 changed files with 14092 additions and 3915 deletions
@@ -0,0 +1,10 @@
+name: "RemoteTerm CodeQL config"
+
+# Exclude rules that flag intentional design decisions:
+# - AES-ECB is required by the MeshCore radio protocol wire format
+# - Repeater/room passwords are not meaningfully sensitive secrets
+query-filters:
+  - exclude:
+      id: py/weak-cryptographic-algorithm
+  - exclude:
+      id: js/clear-text-storage-of-sensitive-data
@@ -4,6 +4,9 @@ on:
  push:
  pull_request:

+permissions:
+  contents: read
+
 jobs:
  backend-checks:
    runs-on: ubuntu-latest
@@ -0,0 +1,35 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: "0 6 * * 1"
+
+permissions:
+  contents: read
+  security-events: write
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [javascript-typescript, python]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          config-file: .github/codeql/codeql-config.yml
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v3
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
@@ -25,6 +25,9 @@ concurrency:
  group: publish-aur
  cancel-in-progress: false

+permissions:
+  contents: read
+
 jobs:
  publish-aur:
    runs-on: ubuntu-latest
@@ -25,6 +25,7 @@ references/

 # ancillary LLM files
 .claude/
+.codex

 # local Docker compose files
 docker-compose.yml
@@ -179,7 +179,9 @@ Outgoing DMs send once immediately, then may retry up to 2 more times in the bac

 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.
+**Channel messages**: Flood messages echo back through repeaters. Repeats are identified by the database UNIQUE constraint `idx_messages_dedup_null_safe` on `(type, conversation_key, text, COALESCE(sender_timestamp, 0))` where `type = 'CHAN'` — 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.
+
+**Incoming direct messages**: A separate unique index `idx_messages_incoming_priv_dedup` on `(type, conversation_key, text, COALESCE(sender_timestamp, 0), COALESCE(sender_key, ''))` where `type = 'PRIV' AND outgoing = 0` deduplicates incoming DMs. The additional `sender_key` term (added in migration 056) distinguishes room-server posts from different senders that arrive in the same second with identical text.

 This message-layer echo/path handling is independent of raw-packet storage deduplication.

@@ -197,6 +199,7 @@ This message-layer echo/path handling is independent of raw-packet storage dedup
 │   ├── event_handlers.py   # Radio events
 │   ├── decoder.py          # Packet decryption
 │   ├── websocket.py        # Real-time broadcasts
+│   ├── push/               # Web Push notification subsystem (VAPID keys, dispatch, send)
 │   └── fanout/             # Fanout bus: MQTT, bots, webhooks, Apprise, SQS (see fanout/AGENTS_fanout.md)
 ├── frontend/               # React frontend
 │   ├── AGENTS.md           # Frontend documentation
@@ -318,6 +321,7 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | 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 |
+| GET | `/api/radio/private-key` | Export in-memory private key as hex (requires `MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT=true`) |
 | PUT | `/api/radio/private-key` | Import private key to radio |
 | 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 |
@@ -345,6 +349,7 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | 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/contacts/{public_key}/repeater/telemetry-history` | Stored telemetry history for a repeater (read-only, no radio access) |
 | POST | `/api/contacts/{public_key}/room/login` | Log in to a room server |
 | POST | `/api/contacts/{public_key}/room/status` | Fetch room-server status telemetry |
 | POST | `/api/contacts/{public_key}/room/lpp-telemetry` | Fetch room-server CayenneLPP sensor data |
@@ -374,12 +379,22 @@ All endpoints are prefixed with `/api` (e.g., `/api/health`).
 | POST | `/api/settings/blocked-keys/toggle` | Toggle blocked key |
 | POST | `/api/settings/blocked-names/toggle` | Toggle blocked name |
 | POST | `/api/settings/tracked-telemetry/toggle` | Toggle tracked telemetry repeater |
+| GET | `/api/settings/tracked-telemetry/schedule` | Current telemetry scheduling derivation and next-run-at timestamp |
+| POST | `/api/settings/muted-channels/toggle` | Toggle muted status for a channel |
 | GET | `/api/fanout` | List all fanout configs |
 | POST | `/api/fanout` | Create new fanout config |
 | PATCH | `/api/fanout/{id}` | Update fanout config (triggers module reload) |
 | DELETE | `/api/fanout/{id}` | Delete fanout config (stops module) |
 | POST | `/api/fanout/bots/disable-until-restart` | Stop bot fanout modules and keep bots disabled until the process restarts |
 | GET | `/api/statistics` | Aggregated mesh network statistics |
+| GET | `/api/push/vapid-public-key` | VAPID public key for browser push subscription |
+| POST | `/api/push/subscribe` | Register/upsert a push subscription |
+| GET | `/api/push/subscriptions` | List all push subscriptions |
+| PATCH | `/api/push/subscriptions/{id}` | Update subscription label or filter preferences |
+| DELETE | `/api/push/subscriptions/{id}` | Delete a push subscription |
+| POST | `/api/push/subscriptions/{id}/test` | Send a test push notification |
+| GET | `/api/push/conversations` | Global list of push-enabled conversation state keys |
+| POST | `/api/push/conversations/toggle` | Add or remove a conversation from the global push list |
 | WS | `/api/ws` | Real-time updates |

 ## Key Concepts
@@ -434,6 +449,17 @@ All external integrations are managed through the fanout bus (`app/fanout/`). Ea

 Community MQTT forwards raw packets only. Its derived `path` field, when present on direct packets, is a comma-separated list of hop identifiers as reported by the packet format. Token width therefore varies with the packet's path hash mode; it is intentionally not a flat per-byte rendering.

+### Web Push Notifications
+
+Web Push is a standalone subsystem (`app/push/`) that sends browser push notifications for incoming messages even when the browser tab is closed. It is **not** a fanout module — it manages its own per-browser subscriptions, while the set of push-enabled conversations is stored once per server instance.
+
+- **Requires HTTPS** (self-signed certificates work) and outbound internet from the server to reach browser push services (Google FCM, Mozilla autopush).
+- VAPID key pair is auto-generated on first startup and stored in `app_settings`.
+- Each browser subscription is stored in `push_subscriptions` with device identity and delivery state. The set of push-enabled conversations is stored globally in `app_settings.push_conversations`, so all subscribed browsers receive the same configured rooms/DMs.
+- `broadcast_event()` in `websocket.py` dispatches to `push_manager.dispatch_message()` alongside fanout for `message` events.
+- Expired subscriptions (HTTP 404/410 from push service) are auto-deleted.
+- Frontend: service worker (`sw.js`) handles push display and notification click navigation. The `BellRing` icon in `ChatHeader` toggles per-conversation push. Device management lives in Settings > Local.
+
 ### Server-Side Decryption

 The server can decrypt packets using stored keys, both in real-time and for historical packets.
@@ -479,8 +505,10 @@ mc.subscribe(EventType.ACK, handler)
 | `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 |
+| `MESHCORE_LOAD_WITH_AUTOEVICT` | `false` | Enable autoevict contact loading: sets `AUTO_ADD_OVERWRITE_OLDEST` on the radio so adds never fail with TABLE_FULL, skips the removal phase during reconcile, and allows blind loading when `get_contacts` fails. Loaded contacts are not radio-favorited and may be evicted by new adverts when the table is full. |
+| `MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT` | `false` | Enable `GET /api/radio/private-key` to return the in-memory private key as hex. Disabled by default; only enable on a trusted network where you need to retrieve the key (e.g. for backup or migration). |

-**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`, `advert_interval`, `last_advert_time`, `last_message_times`, `flood_scope`, `blocked_keys`, `blocked_names`, `discovery_blocked_types`, `tracked_telemetry_repeaters`, and `auto_resend_channel`. `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`. 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`.
+**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`, `advert_interval`, `last_advert_time`, `last_message_times`, `flood_scope`, `blocked_keys`, `blocked_names`, `discovery_blocked_types`, `tracked_telemetry_repeaters`, `auto_resend_channel`, and `telemetry_interval_hours`. `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`. 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.

@@ -1,3 +1,83 @@
+## [3.13.0] - 2026-04-30
+
+* Feature: Error counts included in repeater telemetry
+* Feature: RX error rate + percentage surfaced and tracked for repeaters
+* Feature: Dynamic as-you-type text replacement for Cyrillic byte optimization
+* Feature: Permit hourly checks for direct/routed repeaters
+* Feature: Allow newlines in input
+* Feature: Packet-send radio time added to packet analyzer
+* Feature: Enable forced plaintext for Apprise
+* Bugfix: Less annoying MQTT failure notifications with backoff
+* Bugfis: Don't obscure input; use dvh everywhere
+* Bugfix: Clearer save button for advert interval
+* Misc: Library updates
+* Misc: Rewrite 5xx to 4xx to avoid issues with proxies that don't react well to 503/504
+
+## [3.12.3] - 2026-04-24
+
+* Feature: Customizable Apprise strings
+* Feature: Choose contact addition type
+* Featuer: Make bulk-delete sortable by last-heard
+* Misc: Bypass error on fail-to-unload-contact when it's not there
+* Misc: Docs & test updates
+
+## [3.12.2] - 2026-04-21
+
+* Feature: Auto-disambiguate colliding LPP sensor names
+* Feature: Radio config import/export
+* Bugfix: Don't push stale firmware version/model on community MQTT
+* Misc: Expose env vars in debug blob
+* Misc: Longer linger for web push error
+* Misc: Docs, test, & CI/CD improvements
+
+## [3.12.1] - 2026-04-19
+
+* Feature: Auto-evict/circular-buffer contact load mode (solves potential T-Beam issues)
+* Feature: Channel mute
+* Misc: HA Documentation improvements
+* Misc: Bump deps & update tests
+* Misc: Improve warnings around web push in untrusted contexts
+
+## [3.12.0] - 2026-04-17
+
+* Feature: Web Push -- get your mesh notifications on a locked phone or when your browser is closed!
+* Feature: Add link to node from map display
+* Feature: Map layers
+* Feature: Better contact/channel selection for fanout
+* Feature: Add glittering status dot option
+* Feature: Add airtime math and average packets/min for repeater info displays
+* Feature: Offer multiple timing intervals for repeater telemetry aurofetch
+* Feature: Add ability to follow OS light/dark mode
+* Bugfix: Clear 100% of messages from radio in fallback mode; don't stop at 100
+* Bugfix: Don't stop DM retry just because the radio did not provide a radio ack on the wire
+* Bugfix: Don't strip outgoing colons on DMs or room servers
+* Bugfix: Patch statusbar overlap on PWA
+* Bugfix: Patch default map upload URL
+* Bugfix: Show learned path in routing override
+* Bugfix: Centralize on "only means RF heard" for first_seen/last_seen
+* Misc: Reduce frequency of time set failure chirping
+* Misc: QoL improvements for Home Assistant integration
+* Misc: Overhaul settings styling
+* Misc: Documentation + tests updates
+
+## [3.11.3] - 2026-04-12
+
+* Bugfix: Add icons and screenshots for webmanifest
+* Bugfix: Use incoming DMs, not just outgoing, for recency ranking for preferential radio contact load
+
+## [3.11.2] - 2026-04-12
+
+* Feature: Unread DMs are always at the top of the DM list no matter what
+* Bugfix: Webmanifest needs withCredentials
+
+## [3.11.1] - 2026-04-12
+
+* Feature: Home Assistant MQTT fanout
+* Feature: Add dummy service worker to enable PWA
+* Bugfix: DB connection plurality issues
+* Misc: Migration improvements
+* Misc: Search keys from beginning
+
 ## [3.11.0] - 2026-04-10

 * Feature: Radio health and contact data accessible on fanout bus
@@ -9,26 +9,35 @@ COPY frontend/package.json frontend/package-lock.json frontend/.npmrc ./
 RUN npm ci

 COPY frontend/ ./
-RUN VITE_COMMIT_HASH=${COMMIT_HASH} npm run build
+RUN VITE_COMMIT_HASH=${COMMIT_HASH} npm run build \
+    && find dist -name '*.map' -delete


-# Stage 2: Python runtime
-FROM python:3.12-slim
+# Stage 2: Install Python dependencies (uv stays in this stage only)
+FROM python:3.13-slim AS python-deps
+
+WORKDIR /app
+
+COPY --from=ghcr.io/astral-sh/uv:0.6 /uv /usr/local/bin/uv
+COPY pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-dev
+
+
+# Stage 3: Final runtime (no uv, no source maps)
+FROM python:3.13-slim

 ARG COMMIT_HASH=unknown

 WORKDIR /app

-ENV COMMIT_HASH=${COMMIT_HASH}
+ENV COMMIT_HASH=${COMMIT_HASH} \
+    PATH="/app/.venv/bin:$PATH"

-# Install uv
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+# Copy installed venv from deps stage
+COPY --from=python-deps /app/.venv ./.venv

-# Copy dependency files first for layer caching
-COPY pyproject.toml uv.lock ./
-
-# Install dependencies (no dev/test deps)
-RUN uv sync --frozen --no-dev
+# Copy dependency metadata (pyproject.toml needed by app for version info)
+COPY pyproject.toml ./

 # Copy application code
 COPY app/ ./app/
@@ -36,7 +45,7 @@ COPY app/ ./app/
 # Copy license attributions
 COPY LICENSES.md ./

-# Copy built frontend from first stage
+# Copy built frontend from first stage (source maps already stripped)
 COPY --from=frontend-builder /build/dist ./frontend/dist

 # Create data directory for SQLite database
@@ -44,5 +53,5 @@ RUN mkdir -p /app/data

 EXPOSE 8000

-# Run the application (we retain root for max compatibility)
-CMD ["uv", "run", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+# Run uvicorn directly from the venv (no uv needed at runtime)
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
@@ -330,7 +330,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

 </details>

-### meshcore (2.3.2) — MIT
+### meshcore (2.3.7) — MIT

 <details>
 <summary>Full license text</summary>
@@ -647,6 +647,389 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

 </details>

+### pywebpush (2.3.0) — MPL-2.0
+
+<details>
+<summary>Full license text</summary>
+
+```
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
+```
+
+</details>
+
 ### uvicorn (0.40.0) — BSD-3-Clause

 <details>
@@ -1,6 +1,8 @@
 # RemoteTerm for MeshCore

-Backend server + browser interface for MeshCore mesh radio networks. Connect your radio over Serial, TCP, or BLE, and then you can:
+Backend server + browser interface for MeshCore mesh radio networks, providing a rich, web-based power-user management and messaging system through a companion radio.
+
+Connect your radio over Serial, TCP, or BLE, and then you can:

 * Send and receive DMs and channel messages
 * Cache all received packets, decrypting as you gain keys
@@ -8,8 +10,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 channel names for channels you don't have keys for yet
-* Forward packets to MQTT, LetsMesh, MeshRank, SQS, Apprise, etc.
-* Use the more recent 1.14 firmwares which support multibyte pathing
+* Forward packets, messages, and automatic repeater telemetry to MQTT, Home Assistant, 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!

 For advanced setup and troubleshooting see [README_ADVANCED.md](README_ADVANCED.md). If you plan to contribute, read [CONTRIBUTING.md](CONTRIBUTING.md).
@@ -83,7 +85,7 @@ Access the app at http://localhost:8000.
 Source checkouts expect a normal frontend build in `frontend/dist`.

 > [!TIP]
-> Running on lightweight hardware, or just do not want to build the frontend locally? From a cloned checkout, run `python3 scripts/setup/fetch_prebuilt_frontend.py` to fetch and unpack a prebuilt frontend into `frontend/prebuilt`, then start the app normally with `uv run uvicorn app.main:app --host 0.0.0.0 --port 8000`.
+> Running on lightweight hardware, or just don't want to build the frontend locally? From a cloned checkout, run `python3 scripts/setup/fetch_prebuilt_frontend.py` to fetch and unpack a prebuilt frontend into `frontend/prebuilt`, then start the app normally with `uv run uvicorn app.main:app --host 0.0.0.0 --port 8000`.

 > [!NOTE]
 > On Linux, you can also install RemoteTerm as a persistent `systemd` service that starts on boot and restarts automatically on failure:
@@ -118,7 +120,7 @@ bash scripts/setup/install_docker.sh

 > The interactive generator enables a self-signed (snakeoil) TLS certificate by default. If you accept the default, the app will be served over HTTPS and the generated compose file will include certificate mounts and an SSL command override. Decline if you prefer plain HTTP or plan to terminate TLS externally.

-Your local `docker-compose.yml` is gitignored so future pulls do not overwrite your Docker settings.
+Your local `docker-compose.yml` is gitignored so future pulls don't overwrite your Docker settings.

 The guided Docker flow can collect BLE settings, but BLE access from Docker still needs manual compose customization such as Bluetooth passthrough and possibly privileged mode or host networking. If you want the simpler path for BLE, use the regular Python launch flow instead.

@@ -240,6 +242,7 @@ If you enable Basic Auth, protect the app with HTTPS. HTTP Basic credentials are
 ## Where To Go Next

 - Advanced setup, troubleshooting, HTTPS, systemd, remediation variables, and debug logging: [README_ADVANCED.md](README_ADVANCED.md)
+- Home Assistant-specific guidance and entity/sensor naming schemes: [README_HA.md](README_HA.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

@@ -1,24 +1,67 @@
 # Advanced Setup And Troubleshooting

-## Remediation Environment Variables
+## Remediation & Advanced Environment Variables

-These are intended for diagnosing or working around radios that behave oddly.
+These are intended for diagnosing or working around radios that behave oddly, or enabling advanced functionality.

 | 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 |
+| `MESHCORE_ENABLE_MESSAGE_POLL_FALLBACK` | false | Run aggressive 10-second `get_msg()` fallback polling to check for messages ([docs](#message-poll-fallback)) |
+| `MESHCORE_FORCE_CHANNEL_SLOT_RECONFIGURE` | false | Disable channel-slot reuse and force `set_channel(...)` before every channel send ([docs](#force-channel-slot-reconfigure)) |
+| `MESHCORE_LOAD_WITH_AUTOEVICT` | false | Enable autoevict mode for contact loading ([docs](#autoevict-mode)) |
+| `__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 ([docs](#clock-wraparound)) |
+| `MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT` | false | Enable `GET /api/radio/private-key` to return the in-memory private key as hex for backup or migration. Only enable on a trusted network. Import via `PUT /api/radio/private-key` is always available. ([docs](#private-key-export)) |

 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).
+If the audit finds a mismatch, you'll see an error in the application UI and your logs.
+
+### Message Poll Fallback
+
+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.
+
+### Force Channel Slot Reconfigure
+
+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).
+
+### Clock Wraparound

 `__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.

+### Private Key Export
+
+`MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT=true` enables `GET /api/radio/private-key`, which returns the in-memory private key as hex for backup or migration. The key is held in memory only (exported from the radio on connect) and is never persisted to disk. Only enable this on a trusted network when you need to retrieve the key.
+
+Import via `PUT /api/radio/private-key` is always available regardless of this setting — it is write-only and does not expose key material.
+
+The Radio Settings config export/import feature uses these endpoints. When export is disabled, config exports will omit the private key and show a notice.
+
+## Contact Loading Issues
+
+RemoteTerm loads favorite and recently active contacts onto the radio so that the radio can automatically acknowledge incoming DMs on your behalf. To do this, it first enumerates the radio's existing contact table, then reconciles it with the desired working set.
+
+On BLE connections with many contacts (or radios with large contact tables from organic advertisements), the initial contact enumeration may time out. If this happens, the app will still attempt to load your favorites and recent contacts onto the radio on a best-effort basis, but without a full snapshot of what's already on the radio, some adds may be redundant or fail.
+
+If the radio's contact table is already full (from contacts added by advertisements or another client), the app may not be able to load all desired contacts. In this case you'll see a warning that auto-DM acking may not work for all contacts. To resolve this:
+
+- **Clear the radio's contact table** using another MeshCore client (e.g., the official companion app), then restart RemoteTerm
+- **Lower the contact fill target** in Radio Settings to reduce how many contacts the app tries to load
+- **Enable autoevict mode** (see below) to let the radio automatically make room
+- If you don't need auto-DM acking, you can safely ignore these warnings — **sending and receiving messages is never affected**
+
+### Autoevict Mode
+
+Setting `MESHCORE_LOAD_WITH_AUTOEVICT=true` enables an alternative contact loading strategy that avoids TABLE_FULL errors entirely. On connect, the app enables the radio's `AUTO_ADD_OVERWRITE_OLDEST` preference, which makes the radio automatically evict the oldest non-favorite contact when the contact table is full. This means:
+
+- Contact adds never fail — the radio always makes room by evicting stale contacts
+- The app can load contacts even when it can't enumerate the radio's existing contact table (e.g., on slow BLE connections)
+- No contact removal step is needed during reconciliation
+
+**Trade-off:** Contacts loaded by the app are not marked as radio-side favorites, so they are eviction candidates if the radio receives a new advertisement while full. In practice, freshly-loaded contacts have a recent `lastmod` timestamp and will be among the last to be evicted. If you disconnect the radio from RemoteTerm and use it standalone, your contacts will not be protected from eviction by newer advertisements.
+
 ## Sub-Path Reverse Proxy

 RemoteTerm works behind a reverse proxy that serves it under a sub-path (e.g. `/meshcore/` or Home Assistant ingress). All frontend asset and API paths are relative, so they resolve correctly under any prefix.
@@ -19,6 +19,26 @@ RemoteTerm can publish mesh network data to Home Assistant via MQTT Discovery. D

 Devices will appear in HA under **Settings > Devices & Services > MQTT** within a few seconds.

+## How MeshCore IDs Map Into Home Assistant
+
+RemoteTerm uses each node's public key to derive a stable short identifier for MQTT topics:
+
+- Full public key: `ae92577bae6c4f1d...`
+- Node ID: `ae92577bae6c` (the first 12 hex characters, lowercased)
+- Example MQTT topic: `meshcore/ae92577bae6c/gps`
+
+When this README shows `<node_id>`, it always means that 12-character value. Node IDs appear in:
+
+- MQTT discovery topics under `homeassistant/...`
+- Runtime MQTT state topics under your configured prefix, usually `meshcore/...`
+
+**Entity IDs** are different — HA auto-generates them from the device name and entity name, not from the node ID. For example, a radio named "MyRadio" produces entities like `binary_sensor.myradio_connected` and `event.myradio_messages`. A contact named "Alice" produces `device_tracker.alice`. You can find your actual entity IDs in **Settings > Devices & Services > MQTT** in HA, and you can rename them in HA's UI without affecting the integration.
+
+You can also see the MQTT topic IDs in RemoteTerm's Home Assistant integration UI:
+
+- `What gets created in Home Assistant`
+- `Published topic summary`
+
 ## What Gets Created

 ### Local Radio Device
@@ -27,24 +47,26 @@ Always created. Updates every 60 seconds.

 | Entity | Type | Description |
 |--------|------|-------------|
-| `binary_sensor.meshcore_*_connected` | Connectivity | Radio online/offline |
-| `sensor.meshcore_*_noise_floor` | Signal strength | Radio noise floor (dBm) |
+| `binary_sensor.<radio_name>_connected` | Connectivity | Radio online/offline |
+| `sensor.<radio_name>_noise_floor` | Signal strength | Radio noise floor (dBm) |

 ### Repeater Devices

-One device per tracked repeater (must have repeater opted). Updates when telemetry is collected (auto-collect cycle (~8 hours), or when you manually fetch from the repeater dashboard).
+One device per tracked repeater selected in the HA integration. Updates when telemetry is collected (auto-collect cycle (~8 hours or variable in settings), or when you manually fetch from the repeater dashboard).

 Repeaters must first be added to the auto-telemetry tracking list in RemoteTerm's Radio settings section. Only auto-tracked repeaters appear in the HA integration's repeater picker.

 | Entity | Type | Unit | Description |
 |--------|------|------|-------------|
-| `sensor.meshcore_*_battery_voltage` | Voltage | V | Battery level |
-| `sensor.meshcore_*_noise_floor` | Signal strength | dBm | Local noise floor |
-| `sensor.meshcore_*_last_rssi` | Signal strength | dBm | Last received signal strength |
-| `sensor.meshcore_*_last_snr` | -- | dB | Last signal-to-noise ratio |
-| `sensor.meshcore_*_packets_received` | -- | count | Total packets received |
-| `sensor.meshcore_*_packets_sent` | -- | count | Total packets sent |
-| `sensor.meshcore_*_uptime` | Duration | s | Uptime since last reboot |
+| `sensor.<repeater_name>_battery_voltage` | Voltage | V | Battery level |
+| `sensor.<repeater_name>_noise_floor` | Signal strength | dBm | Local noise floor |
+| `sensor.<repeater_name>_last_rssi` | Signal strength | dBm | Last received signal strength |
+| `sensor.<repeater_name>_last_snr` | -- | dB | Last signal-to-noise ratio |
+| `sensor.<repeater_name>_packets_received` | -- | count | Total packets received |
+| `sensor.<repeater_name>_packets_sent` | -- | count | Total packets sent |
+| `sensor.<repeater_name>_uptime` | Duration | s | Uptime since last reboot |
+
+If RemoteTerm already has a cached telemetry snapshot for that repeater, it republishes it on startup so HA can populate the sensors immediately instead of waiting for the next collection cycle.

 ### Contact Device Trackers

@@ -52,11 +74,11 @@ One `device_tracker` per tracked contact. Updates passively whenever RemoteTerm

 | Entity | Description |
 |--------|-------------|
-| `device_tracker.meshcore_*` | GPS position (latitude/longitude) |
+| `device_tracker.<contact_name>` | GPS position (latitude/longitude) |

 ### Message Event Entity

-A single `event.meshcore_messages` entity that fires for each message matching your configured scope. Each event carries these attributes:
+A single radio-scoped event entity, `event.<radio_name>_messages`, fires for each message matching your configured scope. Each event carries these attributes:

 | Attribute | Example | Description |
 |-----------|---------|-------------|
@@ -71,7 +93,21 @@ A single `event.meshcore_messages` entity that fires for each message matching y

 ## Entity Naming

-Entity IDs use the first 12 characters of the node's public key as an identifier. For example, a contact with public key `ae92577bae6c...` gets entity ID `device_tracker.meshcore_ae92577bae6c`. You can rename entities in HA's UI without affecting the integration.
+HA auto-generates entity IDs by slugifying the device name and entity name. For a radio named "My Radio", entities look like `binary_sensor.my_radio_connected` and `event.my_radio_messages`. For a repeater named "Hilltop", `sensor.hilltop_battery_voltage`. For a contact named "Alice", `device_tracker.alice`. You can rename entities in HA's UI without affecting the integration.
+
+MQTT topic paths use the 12-character node ID (first 12 hex characters of the public key). For example:
+
+- Local radio health: `meshcore/<radio_node_id>/health`
+- Repeater telemetry: `meshcore/<repeater_node_id>/telemetry`
+- Contact GPS: `meshcore/<contact_node_id>/gps`
+- Message events: `meshcore/<radio_node_id>/events/message`
+
+## What Appears When
+
+- Always created: the local radio device and its entities
+- Created when selected in the HA integration: tracked repeater devices and tracked contact device trackers
+- Populated only after data exists: contact GPS trackers need an advert with GPS; repeater sensors need telemetry, although cached repeater telemetry is replayed on startup when available
+- Message event entity: always created once the HA integration is enabled for a connected radio

 ## Common Automations

@@ -79,7 +115,7 @@ Entity IDs use the first 12 characters of the node's public key as an identifier

 Notify when a tracked repeater's battery drops below a threshold.

-**GUI:** Settings > Automations > Create > Numeric state trigger on `sensor.meshcore_*_battery_voltage`, below `3.8`, action: notification.
+**GUI:** Settings > Automations > Create > Numeric state trigger on `sensor.<repeater_name>_battery_voltage`, below `3.8`, action: notification.

 **YAML:**
 ```yaml
@@ -87,22 +123,22 @@ automation:
  - alias: "Repeater battery low"
    trigger:
      - platform: numeric_state
-        entity_id: sensor.meshcore_aabbccddeeff_battery_voltage
+        entity_id: sensor.hilltop_battery_voltage
        below: 3.8
    action:
      - service: notify.mobile_app_your_phone
        data:
          title: "Repeater Battery Low"
          message: >-
-            {{ state_attr('sensor.meshcore_aabbccddeeff_battery_voltage', 'friendly_name') }}
-            is at {{ states('sensor.meshcore_aabbccddeeff_battery_voltage') }}V
+            {{ state_attr('sensor.hilltop_battery_voltage', 'friendly_name') }}
+            is at {{ states('sensor.hilltop_battery_voltage') }}V
 ```

 ### Radio offline alert

 Notify if the radio has been disconnected for more than 5 minutes.

-**GUI:** Settings > Automations > Create > State trigger on `binary_sensor.meshcore_*_connected`, to `off`, for `00:05:00`, action: notification.
+**GUI:** Settings > Automations > Create > State trigger on `binary_sensor.<radio_name>_connected`, to `off`, for `00:05:00`, action: notification.

 **YAML:**
 ```yaml
@@ -110,7 +146,7 @@ automation:
  - alias: "Radio offline"
    trigger:
      - platform: state
-        entity_id: binary_sensor.meshcore_aabbccddeeff_connected
+        entity_id: binary_sensor.myradio_connected
        to: "off"
        for: "00:05:00"
    action:
@@ -128,7 +164,7 @@ Trigger when a message arrives in a specific channel. Two approaches:

 If you only care about one room, configure the HA integration's message scope to "Only listed channels" and select that room. Then every event fire is from that room.

-**GUI:** Settings > Automations > Create > State trigger on `event.meshcore_messages`, action: notification.
+**GUI:** Settings > Automations > Create > State trigger on `event.<radio_name>_messages`, action: notification.

 **YAML:**
 ```yaml
@@ -136,7 +172,7 @@ automation:
  - alias: "Emergency channel alert"
    trigger:
      - platform: state
-        entity_id: event.meshcore_messages
+        entity_id: event.myradio_messages
    action:
      - service: notify.mobile_app_your_phone
        data:
@@ -150,7 +186,7 @@ automation:

 Keep scope as "All messages" and filter in the automation. The trigger is GUI, but the condition uses a one-line template.

-**GUI:** Settings > Automations > Create > State trigger on `event.meshcore_messages` > Add condition > Template > enter the template below.
+**GUI:** Settings > Automations > Create > State trigger on `event.<radio_name>_messages` > Add condition > Template > enter the template below.

 **YAML:**
 ```yaml
@@ -158,7 +194,7 @@ automation:
  - alias: "Emergency channel alert"
    trigger:
      - platform: state
-        entity_id: event.meshcore_messages
+        entity_id: event.myradio_messages
    condition:
      - condition: template
        value_template: >-
@@ -180,7 +216,7 @@ automation:
  - alias: "DM from Alice"
    trigger:
      - platform: state
-        entity_id: event.meshcore_messages
+        entity_id: event.myradio_messages
    condition:
      - condition: template
        value_template: >-
@@ -201,7 +237,7 @@ automation:
  - alias: "Keyword alert"
    trigger:
      - platform: state
-        entity_id: event.meshcore_messages
+        entity_id: event.myradio_messages
    condition:
      - condition: template
        value_template: >-
@@ -226,7 +262,7 @@ Add a sensor card to any dashboard:

 ```yaml
 type: sensor
-entity: sensor.meshcore_aabbccddeeff_battery_voltage
+entity: sensor.hilltop_battery_voltage
 name: "Hilltop Repeater Battery"
 ```

@@ -236,14 +272,171 @@ Or an entities card for multiple repeaters:
 type: entities
 title: "Repeater Status"
 entities:
-  - entity: sensor.meshcore_aabbccddeeff_battery_voltage
+  - entity: sensor.hilltop_battery_voltage
    name: "Hilltop"
-  - entity: sensor.meshcore_ccdd11223344_battery_voltage
+  - entity: sensor.valley_battery_voltage
    name: "Valley"
-  - entity: sensor.meshcore_eeff55667788_battery_voltage
+  - entity: sensor.ridge_battery_voltage
    name: "Ridge"
 ```

+### Full monitoring dashboard with message feed
+
+This example creates a dashboard with repeater vitals, a live message feed, and a network activity graph. Replace the three slug values below to match your setup — find your entity IDs in **Settings > Devices & Services > MQTT**.
+
+```yaml
+# ┌─────────────────────────────────────────────────────┐
+# │  Replace these three values to match your entities  │
+# │                                                     │
+# │  radio_slug:    the prefix on your radio sensors    │
+# │                 e.g. sensor.MYRADIO_noise_floor     │
+# │  repeater_slug: the prefix on your repeater sensors │
+# │                 e.g. sensor.HILLTOP_battery_voltage  │
+# │  message_event: your message event entity ID        │
+# │                 e.g. event.MYRADIO_messages          │
+# └─────────────────────────────────────────────────────┘
+#
+#   radio_slug:    myradio
+#   repeater_slug: hilltop
+#   message_event: event.myradio_messages
+```
+
+**Step 1 — Dashboard YAML** (Settings > Dashboards > Add > edit in YAML):
+
+```yaml
+views:
+  - title: MeshCore
+    icon: mdi:radio-tower
+    cards:
+      - type: entities
+        title: Hilltop — Current                     # ← repeater name
+        state_color: true
+        entities:
+          - entity: sensor.hilltop_battery_voltage    # ← repeater_slug
+            name: Battery
+          - entity: sensor.hilltop_noise_floor        # ← repeater_slug
+            name: Noise Floor
+          - entity: sensor.hilltop_last_rssi          # ← repeater_slug
+            name: Last RSSI
+          - entity: sensor.hilltop_last_snr           # ← repeater_slug
+            name: Last SNR
+          - entity: sensor.hilltop_uptime             # ← repeater_slug
+            name: Uptime
+          - entity: sensor.hilltop_packets_received   # ← repeater_slug
+            name: Packets Rx
+          - entity: sensor.hilltop_packets_sent       # ← repeater_slug
+            name: Packets Tx
+
+      - type: statistics-graph
+        title: Battery Voltage
+        entities:
+          - sensor.hilltop_battery_voltage            # ← repeater_slug
+        stat_types: [mean, min, max]
+        days_to_show: 7
+        period: hour
+
+      - type: statistics-graph
+        title: Noise Floor
+        entities:
+          - sensor.hilltop_noise_floor                # ← repeater_slug
+        stat_types: [mean, min, max]
+        days_to_show: 7
+        period: hour
+
+      - type: markdown
+        title: Message Feed (Last 10)
+        content: |
+          {% for i in range(1, 11) %}
+          {% set msg = states('input_text.meshcore_msg_' ~ i) %}
+          {% if msg and msg not in ['unknown', '', 'unavailable'] %}
+          {{ msg }}
+
+          {% endif %}
+          {% endfor %}
+          {% if states('input_text.meshcore_msg_1') in ['unknown', '', 'unavailable'] %}
+          *No messages yet.*
+          {% endif %}
+
+      - type: statistics-graph
+        title: Overall Packets Received
+        entities:
+          - sensor.myradio_packets_received           # ← radio_slug
+        stat_types: [change]
+        days_to_show: 7
+        period: hour
+```
+
+**Step 2 — Message feed helpers**: create 10 text helpers named `MeshCore Msg 1` through `MeshCore Msg 10` (Settings > Helpers > Add > Text). These act as a rolling buffer for the Markdown card above.
+
+**Step 3 — Message feed automation** (Settings > Automations > Create > edit in YAML):
+
+```yaml
+alias: MeshCore Message Feed Buffer
+description: Rolling buffer of recent mesh messages for dashboard display
+mode: queued
+max: 10
+triggers:
+  - trigger: state
+    entity_id: event.myradio_messages               # ← message_event
+actions:
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_10
+    data:
+      value: "{{ states('input_text.meshcore_msg_9') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_9
+    data:
+      value: "{{ states('input_text.meshcore_msg_8') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_8
+    data:
+      value: "{{ states('input_text.meshcore_msg_7') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_7
+    data:
+      value: "{{ states('input_text.meshcore_msg_6') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_6
+    data:
+      value: "{{ states('input_text.meshcore_msg_5') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_5
+    data:
+      value: "{{ states('input_text.meshcore_msg_4') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_4
+    data:
+      value: "{{ states('input_text.meshcore_msg_3') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_3
+    data:
+      value: "{{ states('input_text.meshcore_msg_2') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_2
+    data:
+      value: "{{ states('input_text.meshcore_msg_1') }}"
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.meshcore_msg_1
+    data:
+      value: >-
+        {{ as_timestamp(trigger.to_state.last_changed) |
+        timestamp_custom('%-I:%M %p') }} |
+        **{% if trigger.to_state.attributes.channel_name %}{{
+        trigger.to_state.attributes.channel_name }}{% else %}DM{% endif %}** |
+        {{ trigger.to_state.attributes.sender_name or 'Unknown' }}:
+        {{ (trigger.to_state.attributes.text or '')[:180] }}
+```
+
 ## Troubleshooting

 ### Devices don't appear in HA
@@ -266,7 +459,9 @@ mosquitto_pub -h <broker> -t 'homeassistant/sensor/meshcore_unknown/noise_floor/

 ### Repeater sensors show "Unknown" or "Unavailable"

-Repeater telemetry only updates when collected. Trigger a manual fetch by opening the repeater's dashboard in RemoteTerm and clicking "Status", or wait for the next auto-collect cycle (~8 hours). Sensors show "Unknown" until the first telemetry reading arrives.
+Repeater telemetry only updates when collected. Trigger a manual fetch by opening the repeater's dashboard in RemoteTerm and clicking "Status", or wait for the next auto-collect cycle (~8 hours).
+
+If RemoteTerm already has cached telemetry for that repeater, it republishes the last known values on startup. If the sensors are still unknown or unavailable, it usually means no telemetry has ever been collected for that repeater yet.

 ### Contact device tracker shows "Unknown"

@@ -280,26 +475,52 @@ Radio health entities have a 120-second expiry. If RemoteTerm stops sending heal

 Disabling or deleting the HA integration in RemoteTerm's settings publishes empty retained messages to all discovery topics, which removes the devices and entities from HA automatically.

+## Local Test Environment
+
+For local development, RemoteTerm includes a helper that starts Mosquitto and Home Assistant with MQTT preconfigured:
+
+```bash
+./scripts/setup/start_ha_test_env.sh
+```
+
+That gives you:
+
+- Home Assistant at `http://localhost:8123`
+- Mosquitto at `localhost:1883`
+- A pre-created HA MQTT integration using that broker
+
+To watch all MQTT traffic during testing:
+
+```bash
+docker exec ha-test-mosquitto mosquitto_sub -h 127.0.0.1 -t '#' -v
+```
+
+To stop and clean up:
+
+```bash
+./scripts/setup/stop_ha_test_env.sh --clean
+```
+
 ## MQTT Topics Reference

-State topics (where data is published):
+Runtime/state topics (where data is published):

 | Topic | Content | Update frequency |
 |-------|---------|-----------------|
 | `meshcore/{node_id}/health` | `{"connected": bool, "noise_floor_dbm": int}` | Every 60s |
 | `meshcore/{node_id}/telemetry` | `{"battery_volts": float, ...}` | ~8h or manual |
 | `meshcore/{node_id}/gps` | `{"latitude": float, "longitude": float, ...}` | On advert |
-| `meshcore/events/message` | `{"event_type": "message_received", ...}` | On message |
+| `meshcore/{node_id}/events/message` | `{"event_type": "message_received", ...}` | On message |

 Discovery topics (entity registration, under `homeassistant/`):

 | Pattern | Entity type |
 |---------|------------|
-| `homeassistant/binary_sensor/meshcore_*/connected/config` | Radio connectivity |
-| `homeassistant/sensor/meshcore_*/noise_floor/config` | Noise floor sensor |
-| `homeassistant/sensor/meshcore_*/battery_voltage/config` | Repeater battery |
-| `homeassistant/sensor/meshcore_*/*/config` | Other repeater sensors |
-| `homeassistant/device_tracker/meshcore_*/config` | Contact GPS tracker |
-| `homeassistant/event/meshcore_messages/config` | Message event entity |
+| `homeassistant/binary_sensor/meshcore_<node_id>/connected/config` | Radio connectivity |
+| `homeassistant/sensor/meshcore_<node_id>/noise_floor/config` | Noise floor sensor |
+| `homeassistant/sensor/meshcore_<node_id>/battery_voltage/config` | Repeater battery |
+| `homeassistant/sensor/meshcore_<node_id>/*/config` | Other repeater sensors |
+| `homeassistant/device_tracker/meshcore_<node_id>/config` | Contact GPS tracker |
+| `homeassistant/event/meshcore_<node_id>/messages/config` | Message event entity |

 The `{node_id}` is always the first 12 characters of the node's public key, lowercased.
@@ -27,10 +27,10 @@ app/
 ├── config.py            # Env-driven runtime settings
 ├── channel_constants.py # Public/default channel constants shared across sync/send logic
 ├── database.py          # SQLite connection + base schema + migration runner
-├── migrations.py        # Schema migrations (SQLite user_version)
+├── migrations/          # Schema migrations (SQLite user_version, per-version modules)
 ├── models.py            # Pydantic request/response models and typed write contracts (for example ContactUpsert)
 ├── version_info.py      # Unified version/build metadata resolution for debug + startup surfaces
-├── repository/          # Data access layer (contacts, channels, messages, raw_packets, settings, fanout)
+├── repository/          # Data access layer (contacts, channels, messages, raw_packets, settings, fanout, push_subscriptions, repeater_telemetry)
 ├── services/            # Shared orchestration/domain services
 │   ├── messages.py              # Shared message creation, dedup, ACK application
 │   ├── message_send.py          # Direct send, channel send, resend workflows
@@ -50,8 +50,12 @@ app/
 ├── events.py            # Typed WS event payload serialization
 ├── websocket.py         # WS manager + broadcast helpers
 ├── security.py          # Optional app-wide HTTP Basic auth middleware for HTTP + WS
+├── push/                # Web Push notification subsystem
+│   ├── vapid.py                 # VAPID key generation, storage, caching
+│   ├── send.py                  # pywebpush wrapper (async via thread executor)
+│   └── manager.py               # Push dispatch: filter, build payload, concurrent send
 ├── fanout/              # Fanout bus: MQTT, bots, webhooks, Apprise, SQS (see fanout/AGENTS_fanout.md)
-├── dependencies.py      # Shared FastAPI dependency providers
+├── telemetry_interval.py # Shared telemetry interval math for tracked-repeater scheduler
 ├── 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
@@ -66,11 +70,12 @@ app/
    ├── packets.py
    ├── read_state.py
    ├── rooms.py
-    ├── server_control.py
+    ├── server_control.py   # Shared helpers for repeater/room CLI flows (not an APIRouter)
    ├── settings.py
    ├── fanout.py
    ├── repeaters.py
    ├── statistics.py
+    ├── push.py
    └── ws.py
 ```

@@ -135,8 +140,9 @@ app/

 ### 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 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.
+- Channel message uniqueness (`idx_messages_dedup_null_safe`): `(type, conversation_key, text, COALESCE(sender_timestamp, 0))` where `type = 'CHAN'`.
+- Incoming PRIV message uniqueness (`idx_messages_incoming_priv_dedup`): `(type, conversation_key, text, COALESCE(sender_timestamp, 0), COALESCE(sender_key, ''))` where `type = 'PRIV' AND outgoing = 0` — `sender_key` was added in migration 056 to distinguish room-server posts from different senders in the same second.
+- 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 dedup identity also collapse onto one stored row, with later observations merging path data instead of creating a second DM.

 ### Raw packet dedup policy

@@ -168,6 +174,17 @@ app/
 - Community MQTT publishes raw packets only, but its derived `path` field for direct packets is emitted as comma-separated hop identifiers, not flat path bytes.
 - See `app/fanout/AGENTS_fanout.md` for full architecture details and event payload shapes.

+### Web Push notifications
+
+Web Push is a standalone subsystem in `app/push/`, separate from the fanout module system. It sends browser push notifications for incoming messages even when the tab is closed.
+
+- **Not a fanout module** — Web Push manages per-browser subscriptions (N browsers, each with its own endpoint and delivery state), unlike fanout which is one-config-to-one-destination.
+- **VAPID keys**: auto-generated P-256 key pair on first startup, stored in `app_settings.vapid_private_key` / `vapid_public_key`. Cached in-module by `app/push/vapid.py`.
+- **Dispatch**: `broadcast_event()` in `websocket.py` fires `push_manager.dispatch_message(data)` alongside fanout for `message` events. The manager checks the global `app_settings.push_conversations` list, then sends to all currently registered subscriptions via `pywebpush` (run in a thread executor).
+- **Stale cleanup**: HTTP 404/410 from the push service triggers immediate subscription deletion.
+- **Subscriptions stored** in `push_subscriptions` table with `UNIQUE(endpoint)` for upsert semantics.
+- Requires HTTPS (self-signed OK) and outbound internet to reach browser push services.
+
 ## API Surface (all under `/api`)

 ### Health
@@ -179,6 +196,7 @@ app/
 ### Radio
 - `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`
+- `GET /radio/private-key` — export in-memory private key as hex (requires `MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT=true`)
 - `PUT /radio/private-key`
 - `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
@@ -208,6 +226,7 @@ app/
 - `POST /contacts/{public_key}/repeater/radio-settings`
 - `POST /contacts/{public_key}/repeater/advert-intervals`
 - `POST /contacts/{public_key}/repeater/owner-info`
+- `GET /contacts/{public_key}/repeater/telemetry-history` — stored telemetry history for a repeater (read-only, no radio access)
 - `POST /contacts/{public_key}/room/login`
 - `POST /contacts/{public_key}/room/status`
 - `POST /contacts/{public_key}/room/lpp-telemetry`
@@ -247,6 +266,8 @@ app/
 - `POST /settings/blocked-keys/toggle`
 - `POST /settings/blocked-names/toggle`
 - `POST /settings/tracked-telemetry/toggle`
+- `GET /settings/tracked-telemetry/schedule` — current telemetry scheduling derivation, interval options, and next-run-at timestamp
+- `POST /settings/muted-channels/toggle`

 ### Fanout
 - `GET /fanout` — list all fanout configs
@@ -258,6 +279,16 @@ app/
 ### Statistics
 - `GET /statistics` — aggregated mesh network stats (entity counts, message/packet splits, activity windows, busiest channels)

+### Push
+- `GET /push/vapid-public-key` — VAPID public key for browser `PushManager.subscribe()`
+- `POST /push/subscribe` — register/upsert push subscription (keyed by endpoint URL)
+- `GET /push/subscriptions` — list all push subscriptions
+- `PATCH /push/subscriptions/{id}` — update label or filter preferences
+- `DELETE /push/subscriptions/{id}` — delete subscription
+- `POST /push/subscriptions/{id}/test` — send test notification
+- `GET /push/conversations` — global list of push-enabled conversation state keys
+- `POST /push/conversations/toggle` — add or remove a conversation from the global push list
+
 ### WebSocket
 - `WS /ws`

@@ -290,7 +321,8 @@ Main tables:
 - `contact_name_history` (tracks name changes over time)
 - `repeater_telemetry_history` (time-series telemetry snapshots for tracked repeaters)
 - `fanout_configs` (MQTT, bot, webhook, Apprise, SQS integration configs)
- `app_settings`
+- `push_subscriptions` (Web Push browser subscriptions with delivery metadata; UNIQUE on endpoint)
+- `app_settings` (includes `vapid_private_key` and `vapid_public_key` for Web Push VAPID signing)

 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_*`
@@ -313,6 +345,7 @@ Repository writes should prefer typed models such as `ContactUpsert` over ad hoc
 - `blocked_keys`, `blocked_names`, `discovery_blocked_types`
 - `tracked_telemetry_repeaters`
 - `auto_resend_channel`
+- `telemetry_interval_hours`

 Note: MQTT, community MQTT, and bot configs were migrated to the `fanout_configs` table (migrations 36-38).

@@ -365,7 +398,7 @@ tests/
 ├── test_message_prefix_claim.py # Message prefix claim logic
 ├── test_mqtt.py                # MQTT publisher topic routing and lifecycle
 ├── test_messages_search.py     # Message search, around, forward pagination
-├── test_migrations.py          # Schema migration system
+├── test_mqtt_ha.py             # MQTT HA (high-availability) behavior
 ├── test_packet_pipeline.py     # End-to-end packet processing
 ├── test_packets_router.py      # Packets router endpoints (decrypt, maintenance)
 ├── test_path_utils.py          # Path hex rendering helpers
@@ -384,7 +417,13 @@ tests/
 ├── 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_push_send.py           # Web Push send/dispatch
+├── test_radio_stats.py         # Radio stats sampling and noise-floor history
+├── test_repeater_telemetry.py  # Repeater telemetry history recording
+├── test_service_installer.py   # Service installer script behavior
+├── test_sqs_fanout.py          # SQS fanout module
 ├── test_statistics.py          # Statistics aggregation
+├── test_telemetry_interval.py  # Telemetry interval scheduling math
 ├── test_version_info.py        # Version/build metadata resolution
 ├── test_websocket.py           # WS manager broadcast/cleanup
 └── test_websocket_route.py     # WS endpoint lifecycle
@@ -26,6 +26,8 @@ class Settings(BaseSettings):
        default=False,
        validation_alias="__CLOWNTOWN_DO_CLOCK_WRAPAROUND",
    )
+    enable_local_private_key_export: bool = False
+    load_with_autoevict: bool = False
    skip_post_connect_sync: bool = False
    basic_auth_username: str = ""
    basic_auth_password: str = ""
@@ -1,4 +1,7 @@
+import asyncio
 import logging
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 from pathlib import Path

 import aiosqlite
@@ -39,7 +42,8 @@ CREATE TABLE IF NOT EXISTS channels (
    flood_scope_override TEXT,
    path_hash_mode_override INTEGER,
    last_read_at INTEGER,
-    favorite INTEGER DEFAULT 0
+    favorite INTEGER DEFAULT 0,
+    muted INTEGER DEFAULT 0
 );

 CREATE TABLE IF NOT EXISTS messages (
@@ -108,7 +112,11 @@ CREATE TABLE IF NOT EXISTS app_settings (
    blocked_names TEXT DEFAULT '[]',
    discovery_blocked_types TEXT DEFAULT '[]',
    tracked_telemetry_repeaters TEXT DEFAULT '[]',
-    auto_resend_channel INTEGER DEFAULT 0
+    auto_resend_channel INTEGER DEFAULT 0,
+    telemetry_interval_hours INTEGER DEFAULT 8,
+    vapid_private_key TEXT DEFAULT '',
+    vapid_public_key TEXT DEFAULT '',
+    push_conversations TEXT DEFAULT '[]'
 );
 INSERT OR IGNORE INTO app_settings (id) VALUES (1);

@@ -130,6 +138,18 @@ CREATE TABLE IF NOT EXISTS repeater_telemetry_history (
    data TEXT NOT NULL,
    FOREIGN KEY (public_key) REFERENCES contacts(public_key) ON DELETE CASCADE
 );
+
+CREATE TABLE IF NOT EXISTS push_subscriptions (
+    id TEXT PRIMARY KEY,
+    endpoint TEXT NOT NULL,
+    p256dh TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    label TEXT NOT NULL DEFAULT '',
+    created_at INTEGER NOT NULL,
+    last_success_at INTEGER,
+    failure_count INTEGER DEFAULT 0,
+    UNIQUE(endpoint)
+);
 """

 # Indexes are created after migrations so that legacy databases have all
@@ -164,9 +184,74 @@ CREATE INDEX IF NOT EXISTS idx_repeater_telemetry_pk_ts


 class Database:
+    """Single-connection aiosqlite wrapper with coroutine-level serialization.
+
+    Why the lock: aiosqlite runs one ``sqlite3.Connection`` on a background
+    worker thread and serializes statement execution there. But SQLite's
+    ``COMMIT`` fails with ``OperationalError: cannot commit transaction -
+    SQL statements in progress`` whenever *any* cursor on the connection has
+    a live prepared statement (a ``SELECT`` that returned ``SQLITE_ROW`` but
+    hasn't been fully consumed or closed). Under concurrent coroutines, one
+    task's in-flight ``fetchone()`` can still be in ``SQLITE_ROW`` state when
+    another task's ``commit()`` runs on the worker — triggering the error.
+
+    Fix: all DB work goes through ``tx()`` (writes) or ``readonly()`` (reads),
+    both of which acquire ``self._lock``. The lock is non-reentrant (asyncio
+    default) by design — nested ``tx()`` calls are a bug. Repository methods
+    that compose multiple operations factor the raw SQL into private helpers
+    that take a ``conn`` and don't lock; the public method acquires the lock
+    once and calls those helpers.
+
+    Why reads are also locked: reads must also hold the lock, because a read
+    in ``SQLITE_ROW`` state is precisely the live statement that breaks a
+    concurrent writer's commit. Single-connection aiosqlite cannot safely
+    overlap reads and writes. If we ever split reader/writer connections in
+    the future, ``readonly()`` becomes the seam to point at the reader pool.
+    """
+
    def __init__(self, db_path: str):
        self.db_path = db_path
        self._connection: aiosqlite.Connection | None = None
+        self._lock = asyncio.Lock()
+
+    @asynccontextmanager
+    async def tx(self) -> AsyncIterator[aiosqlite.Connection]:
+        """Acquire the connection for a write transaction.
+
+        Commits on clean exit, rolls back on exception. Callers MUST close
+        every cursor opened inside the block (use ``async with conn.execute(...)
+        as cursor:``) so no prepared statement is alive when commit runs.
+
+        The lock serializes concurrent writers AND ensures no reader's cursor
+        is alive during the commit. Nested calls will deadlock — factor shared
+        SQL into helpers that accept ``conn`` and do not re-enter ``tx()``.
+        """
+        async with self._lock:
+            if self._connection is None:
+                raise RuntimeError("Database not connected")
+            conn = self._connection
+            try:
+                yield conn
+            except BaseException:
+                await conn.rollback()
+                raise
+            else:
+                await conn.commit()
+
+    @asynccontextmanager
+    async def readonly(self) -> AsyncIterator[aiosqlite.Connection]:
+        """Acquire the connection for a read. No commit, no rollback.
+
+        Locked for the same reason writes are: on a single connection, an
+        active read statement blocks a concurrent writer's commit. Callers
+        MUST fully consume or close cursors before the block exits (use
+        ``async with conn.execute(...) as cursor:`` + ``fetchall`` /
+        ``fetchone``; avoid holding a cursor across ``await`` on other IO).
+        """
+        async with self._lock:
+            if self._connection is None:
+                raise RuntimeError("Database not connected")
+            yield self._connection

    async def connect(self) -> None:
        logger.info("Connecting to database at %s", self.db_path)
@@ -178,6 +263,22 @@ class Database:
        # Persists in the DB file but we set it explicitly on every connection.
        await self._connection.execute("PRAGMA journal_mode = WAL")

+        # synchronous = NORMAL is safe with WAL — only the most recent
+        # transaction can be lost on an OS crash (no corruption risk).
+        # Reduces fsync overhead vs. the default FULL.
+        await self._connection.execute("PRAGMA synchronous = NORMAL")
+
+        # Retry for up to 5s on lock contention instead of failing instantly.
+        # Matters when a second connection (e.g. VACUUM) touches the DB.
+        await self._connection.execute("PRAGMA busy_timeout = 5000")
+
+        # Bump page cache to ~64 MB (negative value = KB). Keeps hot pages
+        # in memory for read-heavy queries (unreads, pagination, search).
+        await self._connection.execute("PRAGMA cache_size = -64000")
+
+        # Keep temp tables and sort spills in memory instead of on disk.
+        await self._connection.execute("PRAGMA temp_store = MEMORY")
+
        # Incremental auto-vacuum: freed pages are reclaimable via
        # PRAGMA incremental_vacuum without a full VACUUM. Must be set before
        # the first table is created (for new databases); for existing databases
@@ -237,7 +237,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=False)
-    contact_upsert.last_seen = int(time.time())
+    # Intentionally do not set first_seen or last_seen here: NEW_CONTACT
+    # fires from the radio's stored contact DB, not an RF observation.
+    # Both first_seen and last_seen are RF-only timestamps — they track
+    # the first and most recent time we actually heard this pubkey over
+    # the air (adverts, messages, path updates). Contacts synced from the
+    # radio's internal DB without any RF activity stay NULL until a real
+    # RF observation fills them in.
    await ContactRepository.upsert(contact_upsert)
    promoted_keys = await promote_prefix_contacts_for_contact(
        public_key=public_key,
@@ -144,8 +144,8 @@ Amazon SQS delivery. Config blob:
 - Supports both decoded messages and raw packets via normal scope selection

 ### map_upload (map_upload.py)
-Uploads heard repeater and room-server advertisements to map.meshcore.dev. Config blob:
- `api_url` (optional, default `""`) — upload endpoint; empty falls back to the public map.meshcore.dev API
+Uploads heard repeater and room-server advertisements to map.meshcore.io. Config blob:
+- `api_url` (optional, default `""`) — upload endpoint; empty falls back to the public map.meshcore.io API
 - `dry_run` (bool, default `true`) — when true, logs the payload at INFO level without sending
 - `geofence_enabled` (bool, default `false`) — when true, only uploads nodes within `geofence_radius_km` of the radio's own configured lat/lon
 - `geofence_radius_km` (float, default `0`) — filter radius in kilometres
@@ -11,6 +11,37 @@ from app.path_utils import split_path_hex

 logger = logging.getLogger(__name__)

+_MAX_SEND_ATTEMPTS = 3
+_RETRY_DELAY_S = 2
+
+DEFAULT_BODY_FORMAT_DM = "**DM:** {sender_name}: {text} **via:** [{hops_backticked}]"
+DEFAULT_BODY_FORMAT_CHANNEL = (
+    "**{channel_name}:** {sender_name}: {text} **via:** [{hops_backticked}]"
+)
+_DEFAULT_BODY_FORMAT_DM_NO_PATH = "**DM:** {sender_name}: {text}"
+_DEFAULT_BODY_FORMAT_CHANNEL_NO_PATH = "**{channel_name}:** {sender_name}: {text}"
+
+# Plain-text variants (no markdown formatting)
+DEFAULT_BODY_FORMAT_DM_PLAIN = "DM: {sender_name}: {text} via: [{hops}]"
+DEFAULT_BODY_FORMAT_CHANNEL_PLAIN = "{channel_name}: {sender_name}: {text} via: [{hops}]"
+_DEFAULT_BODY_FORMAT_DM_NO_PATH_PLAIN = "DM: {sender_name}: {text}"
+_DEFAULT_BODY_FORMAT_CHANNEL_NO_PATH_PLAIN = "{channel_name}: {sender_name}: {text}"
+
+# Variables available for user format strings
+FORMAT_VARIABLES = (
+    "type",
+    "text",
+    "sender_name",
+    "sender_key",
+    "channel_name",
+    "conversation_key",
+    "hops",
+    "hops_backticked",
+    "hop_count",
+    "rssi",
+    "snr",
+)
+

 def _parse_urls(raw: str) -> list[str]:
    """Split multi-line URL string into individual URLs."""
@@ -36,46 +67,111 @@ def _normalize_discord_url(url: str) -> str:
    return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))


-def _format_body(data: dict, *, include_path: bool) -> str:
-    """Build a human-readable notification body from message data."""
+def _compute_hops(data: dict) -> tuple[str, str, int]:
+    """Extract hop info from message data. Returns (hops, hops_backticked, hop_count)."""
+    paths = data.get("paths")
+    if paths and isinstance(paths, list) and len(paths) > 0:
+        first_path = paths[0] if isinstance(paths[0], dict) else {}
+        path_str = first_path.get("path", "")
+        path_len = first_path.get("path_len")
+    else:
+        path_str = None
+        path_len = None
+
+    if path_str is None or path_str.strip() == "":
+        return ("direct", "`direct`", 0)
+
+    path_str = path_str.strip().lower()
+    hop_count = path_len if isinstance(path_len, int) else len(path_str) // 2
+    hops = split_path_hex(path_str, hop_count)
+    if not hops:
+        return ("direct", "`direct`", 0)
+
+    return (
+        ", ".join(hops),
+        ", ".join(f"`{h}`" for h in hops),
+        len(hops),
+    )
+
+
+def _build_template_vars(data: dict) -> dict[str, str]:
+    """Build the variable dict for format string substitution."""
+    hops_raw, hops_bt, hop_count = _compute_hops(data)
+
+    paths = data.get("paths")
+    rssi = ""
+    snr = ""
+    if paths and isinstance(paths, list) and len(paths) > 0:
+        first_path = paths[0] if isinstance(paths[0], dict) else {}
+        rssi_val = first_path.get("rssi")
+        snr_val = first_path.get("snr")
+        if rssi_val is not None:
+            rssi = str(rssi_val)
+        if snr_val is not None:
+            snr = str(snr_val)
+
+    return {
+        "type": data.get("type", ""),
+        "text": get_fanout_message_text(data),
+        "sender_name": data.get("sender_name") or "Unknown",
+        "sender_key": data.get("sender_key") or "",
+        "channel_name": data.get("channel_name") or data.get("conversation_key", "channel"),
+        "conversation_key": data.get("conversation_key", ""),
+        "hops": hops_raw,
+        "hops_backticked": hops_bt,
+        "hop_count": str(hop_count),
+        "rssi": rssi,
+        "snr": snr,
+    }
+
+
+def _apply_format(fmt: str, variables: dict[str, str]) -> str:
+    """Apply template variables in a single pass to avoid re-expanding substituted values."""
+    import re
+
+    def _replacer(m: re.Match[str]) -> str:
+        key = m.group(1)
+        return variables.get(key, m.group(0))
+
+    return re.sub(r"\{(\w+)\}", _replacer, fmt)
+
+
+def _format_body(
+    data: dict,
+    *,
+    body_format_dm: str | None = None,
+    body_format_channel: str | None = None,
+    markdown: bool = True,
+) -> str:
+    """Build a notification body from message data using format strings."""
+    if body_format_dm is None:
+        body_format_dm = DEFAULT_BODY_FORMAT_DM if markdown else DEFAULT_BODY_FORMAT_DM_PLAIN
+    if body_format_channel is None:
+        body_format_channel = (
+            DEFAULT_BODY_FORMAT_CHANNEL if markdown else DEFAULT_BODY_FORMAT_CHANNEL_PLAIN
+        )
+    variables = _build_template_vars(data)
    msg_type = data.get("type", "")
-    text = get_fanout_message_text(data)
-    sender_name = data.get("sender_name") or "Unknown"
-
-    via = ""
-    if include_path:
-        paths = data.get("paths")
-        if paths and isinstance(paths, list) and len(paths) > 0:
-            first_path = paths[0] if isinstance(paths[0], dict) else {}
-            path_str = first_path.get("path", "")
-            path_len = first_path.get("path_len")
+    fmt = body_format_dm if msg_type == "PRIV" else body_format_channel
+    try:
+        return _apply_format(fmt, variables)
+    except Exception:
+        logger.warning("Apprise format string error, falling back to default")
+        if markdown:
+            default = DEFAULT_BODY_FORMAT_DM if msg_type == "PRIV" else DEFAULT_BODY_FORMAT_CHANNEL
        else:
-            path_str = None
-            path_len = None
-
-        if msg_type == "PRIV" and path_str is None:
-            via = " **via:** [`direct`]"
-        elif path_str is not None:
-            path_str = path_str.strip().lower()
-            if path_str == "":
-                via = " **via:** [`direct`]"
-            else:
-                hop_count = path_len if isinstance(path_len, int) else len(path_str) // 2
-                hops = split_path_hex(path_str, hop_count)
-                if hops:
-                    hop_list = ", ".join(f"`{h}`" for h in hops)
-                    via = f" **via:** [{hop_list}]"
-
-    if msg_type == "PRIV":
-        return f"**DM:** {sender_name}: {text}{via}"
-
-    channel_name = data.get("channel_name") or data.get("conversation_key", "channel")
-    return f"**{channel_name}:** {sender_name}: {text}{via}"
+            default = (
+                DEFAULT_BODY_FORMAT_DM_PLAIN
+                if msg_type == "PRIV"
+                else DEFAULT_BODY_FORMAT_CHANNEL_PLAIN
+            )
+        return _apply_format(default, variables)


-def _send_sync(urls_raw: str, body: str, *, preserve_identity: bool) -> bool:
+def _send_sync(urls_raw: str, body: str, *, preserve_identity: bool, markdown: bool = True) -> bool:
    """Send notification synchronously via Apprise. Returns True on success."""
    import apprise as apprise_lib
+    from apprise import NotifyFormat

    urls = _parse_urls(urls_raw)
    if not urls:
@@ -87,7 +183,8 @@ def _send_sync(urls_raw: str, body: str, *, preserve_identity: bool) -> bool:
            url = _normalize_discord_url(url)
        notifier.add(url)

-    return bool(notifier.notify(title="", body=body))
+    body_fmt = NotifyFormat.MARKDOWN if markdown else NotifyFormat.TEXT
+    return bool(notifier.notify(title="", body=body, body_format=body_fmt))


 class AppriseModule(FanoutModule):
@@ -106,19 +203,82 @@ class AppriseModule(FanoutModule):
            return

        preserve_identity = self.config.get("preserve_identity", True)
-        include_path = self.config.get("include_path", True)
-        body = _format_body(data, include_path=include_path)
+        markdown = self.config.get("markdown_format", True)

-        try:
-            success = await asyncio.to_thread(
-                _send_sync, urls, body, preserve_identity=preserve_identity
-            )
-            self._set_last_error(None if success else "Apprise notify returned failure")
-            if not success:
-                logger.warning("Apprise notification failed for module %s", self.config_id)
-        except Exception as exc:
-            self._set_last_error(str(exc))
-            logger.exception("Apprise send error for module %s", self.config_id)
+        # Read format strings; treat empty/whitespace as unset (use default).
+        # Fall back to legacy include_path for pre-migration configs.
+        body_format_dm = (self.config.get("body_format_dm") or "").strip() or None
+        body_format_channel = (self.config.get("body_format_channel") or "").strip() or None
+        if body_format_dm is None or body_format_channel is None:
+            include_path = self.config.get("include_path", True)
+            if body_format_dm is None:
+                if markdown:
+                    body_format_dm = (
+                        DEFAULT_BODY_FORMAT_DM if include_path else _DEFAULT_BODY_FORMAT_DM_NO_PATH
+                    )
+                else:
+                    body_format_dm = (
+                        DEFAULT_BODY_FORMAT_DM_PLAIN
+                        if include_path
+                        else _DEFAULT_BODY_FORMAT_DM_NO_PATH_PLAIN
+                    )
+            if body_format_channel is None:
+                if markdown:
+                    body_format_channel = (
+                        DEFAULT_BODY_FORMAT_CHANNEL
+                        if include_path
+                        else _DEFAULT_BODY_FORMAT_CHANNEL_NO_PATH
+                    )
+                else:
+                    body_format_channel = (
+                        DEFAULT_BODY_FORMAT_CHANNEL_PLAIN
+                        if include_path
+                        else _DEFAULT_BODY_FORMAT_CHANNEL_NO_PATH_PLAIN
+                    )
+
+        body = _format_body(
+            data,
+            body_format_dm=body_format_dm,
+            body_format_channel=body_format_channel,
+            markdown=markdown,
+        )
+
+        last_exc: Exception | None = None
+        for attempt in range(_MAX_SEND_ATTEMPTS):
+            try:
+                success = await asyncio.to_thread(
+                    _send_sync,
+                    urls,
+                    body,
+                    preserve_identity=preserve_identity,
+                    markdown=markdown,
+                )
+                if success:
+                    self._set_last_error(None)
+                    return
+                logger.warning(
+                    "Apprise notification failed for module %s (attempt %d/%d)",
+                    self.config_id,
+                    attempt + 1,
+                    _MAX_SEND_ATTEMPTS,
+                )
+            except Exception as exc:
+                last_exc = exc
+                logger.warning(
+                    "Apprise send error for module %s (attempt %d/%d): %s",
+                    self.config_id,
+                    attempt + 1,
+                    _MAX_SEND_ATTEMPTS,
+                    exc,
+                )
+            if attempt < _MAX_SEND_ATTEMPTS - 1:
+                await asyncio.sleep(_RETRY_DELAY_S)
+
+        # All attempts exhausted
+        if last_exc is not None:
+            self._set_last_error(str(last_exc))
+        else:
+            self._set_last_error("Apprise notify returned failure")

    @property
    def status(self) -> str:
@@ -245,7 +245,7 @@ def _get_client_version() -> str:
 class CommunityMqttPublisher(BaseMqttPublisher):
    """Manages the community MQTT connection and publishes raw packets."""

-    _backoff_max = 60
+    _backoff_max = 3600
    _log_prefix = "Community MQTT"
    _not_configured_timeout: float | None = 30

@@ -477,7 +477,21 @@ class CommunityMqttPublisher(BaseMqttPublisher):
        if radio_manager.meshcore and radio_manager.meshcore.self_info:
            device_name = radio_manager.meshcore.self_info.get("name", "")

-        device_info = await self._fetch_device_info()
+        # Prefer the always-fresh radio_manager fields (populated on every reconnect by
+        # radio_lifecycle) over the per-module _cached_device_info, which was only
+        # cleared on module restart and therefore served stale firmware versions after
+        # a radio firmware update.  Fall back to _fetch_device_info() for older firmware
+        # where device_info_loaded is False.
+        if radio_manager.device_info_loaded:
+            raw_ver = radio_manager.firmware_version or "unknown"
+            fw_build = radio_manager.firmware_build or ""
+            fw_str = f"{raw_ver} (Build: {fw_build})" if fw_build else f"{raw_ver}"
+            device_info = {
+                "model": radio_manager.device_model or "unknown",
+                "firmware_version": fw_str,
+            }
+        else:
+            device_info = await self._fetch_device_info()
        stats = await self._fetch_stats() if refresh_stats else self._cached_stats

        status_topic = _build_status_topic(settings, pubkey_hex)
@@ -1,6 +1,7 @@
-"""Fanout module for uploading heard advert packets to map.meshcore.dev.
+"""Fanout module for uploading heard advert packets to map.meshcore.io.

-Mirrors the logic of the standalone map.meshcore.dev-uploader project:
+Mirrors the logic of the standalone map.meshcore.dev-uploader project
+(historical name; the live service is now hosted at map.meshcore.io):
 - Listens on raw RF packets via on_raw
 - Filters for ADVERT packets, only processes repeaters (role 2) and rooms (role 3)
 - Skips nodes with no valid location (lat/lon None)
@@ -16,7 +17,7 @@ the raw hex link.
 Config keys
 -----------
 api_url : str, default ""
-    Upload endpoint. Empty string falls back to the public map.meshcore.dev API.
+    Upload endpoint. Empty string falls back to the public map.meshcore.io API.
 dry_run : bool, default True
    When True, log the payload at INFO level instead of sending it.
 geofence_enabled : bool, default False
@@ -46,7 +47,7 @@ from app.services.radio_runtime import radio_runtime

 logger = logging.getLogger(__name__)

-_DEFAULT_API_URL = "https://map.meshcore.dev/api/v1/uploader/node"
+_DEFAULT_API_URL = "https://map.meshcore.io/api/v1/uploader/node"

 # Re-upload guard: skip re-uploading a pubkey seen within this window (AU parity)
 _REUPLOAD_SECONDS = 3600
@@ -27,7 +27,7 @@ class PrivateMqttSettings(Protocol):
 class MqttPublisher(BaseMqttPublisher):
    """Manages an MQTT connection and publishes mesh network events."""

-    _backoff_max = 30
+    _backoff_max = 3600
    _log_prefix = "MQTT"

    def _is_configured(self) -> bool:
@@ -65,6 +65,7 @@ class BaseMqttPublisher(ABC):
        self.connected: bool = False
        self.integration_name: str = ""
        self._last_error: str | None = None
+        self._error_notified: bool = False

    def set_integration_name(self, name: str) -> None:
        """Attach the configured fanout-module name for operator-facing logs."""
@@ -104,6 +105,7 @@ class BaseMqttPublisher(ABC):
        self._client = None
        self.connected = False
        self._last_error = None
+        self._error_notified = False

    async def restart(self, settings: object) -> None:
        """Called when settings change — stop + start."""
@@ -217,6 +219,7 @@ class BaseMqttPublisher(ABC):
                    self._client = client
                    self.connected = True
                    self._last_error = None
+                    self._error_notified = False
                    backoff = _BACKOFF_MIN

                    title, detail = self._on_connected(settings)
@@ -281,9 +284,11 @@ class BaseMqttPublisher(ABC):
                    )
                    return

-                title, detail = self._on_error()
-                broadcast_error(title, detail)
-                _broadcast_health()
+                if not self._error_notified:
+                    title, detail = self._on_error()
+                    broadcast_error(title, detail)
+                    _broadcast_health()
+                    self._error_notified = True
                logger.warning(
                    "%s connection error. This is usually transient network noise; "
                    "if it self-resolves, it is generally not a concern: %s "
@@ -26,7 +26,7 @@ logger = logging.getLogger(__name__)

 # ── Repeater telemetry sensor definitions ─────────────────────────────────

-_REPEATER_SENSORS: list[dict[str, str | None]] = [
+_REPEATER_SENSORS: list[dict[str, Any]] = [
    {
        "field": "battery_volts",
        "name": "Battery Voltage",
@@ -34,6 +34,7 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": "voltage",
        "state_class": "measurement",
        "unit": "V",
+        "precision": 2,
    },
    {
        "field": "noise_floor_dbm",
@@ -42,6 +43,7 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": "signal_strength",
        "state_class": "measurement",
        "unit": "dBm",
+        "precision": 0,
    },
    {
        "field": "last_rssi_dbm",
@@ -50,6 +52,7 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": "signal_strength",
        "state_class": "measurement",
        "unit": "dBm",
+        "precision": 0,
    },
    {
        "field": "last_snr_db",
@@ -58,6 +61,7 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": None,
        "state_class": "measurement",
        "unit": "dB",
+        "precision": 1,
    },
    {
        "field": "packets_received",
@@ -66,6 +70,7 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": None,
        "state_class": "total_increasing",
        "unit": None,
+        "precision": 0,
    },
    {
        "field": "packets_sent",
@@ -74,6 +79,16 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": None,
        "state_class": "total_increasing",
        "unit": None,
+        "precision": 0,
+    },
+    {
+        "field": "recv_errors",
+        "name": "RX Errors",
+        "object_id": "recv_errors",
+        "device_class": None,
+        "state_class": "total_increasing",
+        "unit": None,
+        "precision": 0,
    },
    {
        "field": "uptime_seconds",
@@ -82,13 +97,111 @@ _REPEATER_SENSORS: list[dict[str, str | None]] = [
        "device_class": "duration",
        "state_class": None,
        "unit": "s",
+        "precision": 0,
    },
 ]

+# ── LPP sensor metadata ─────────────────────────────────────────────────
+
+_LPP_HA_META: dict[str, dict[str, Any]] = {
+    "temperature": {"device_class": "temperature", "unit": "°C", "precision": 1},
+    "humidity": {"device_class": "humidity", "unit": "%", "precision": 1},
+    "barometer": {"device_class": "atmospheric_pressure", "unit": "hPa", "precision": 1},
+    "voltage": {"device_class": "voltage", "unit": "V", "precision": 2},
+    "current": {"device_class": "current", "unit": "mA", "precision": 1},
+    "luminosity": {"device_class": "illuminance", "unit": "lux", "precision": 0},
+    "power": {"device_class": "power", "unit": "W", "precision": 1},
+    "energy": {"device_class": "energy", "unit": "kWh", "precision": 2},
+    "distance": {"device_class": "distance", "unit": "mm", "precision": 0},
+    "concentration": {"device_class": None, "unit": "ppm", "precision": 0},
+    "direction": {"device_class": None, "unit": "°", "precision": 0},
+    "altitude": {"device_class": None, "unit": "m", "precision": 1},
+}
+
+
+def _lpp_sensor_key(type_name: str, channel: int) -> str:
+    """Build the flat telemetry-payload key for an LPP sensor."""
+    return f"lpp_{type_name}_ch{channel}"
+
+
+def _assign_lpp_keys(lpp_sensors: list[dict]) -> list[tuple[dict, str, int]]:
+    """Pair each LPP sensor dict with a disambiguated flat key and occurrence.
+
+    First occurrence keeps the base key (``lpp_temperature_ch1``), occurrence=1;
+    subsequent duplicates of the same (type_name, channel) get ``_2``, ``_3``, etc.
+    """
+    counts: dict[str, int] = {}
+    result: list[tuple[dict, str, int]] = []
+    for sensor in lpp_sensors:
+        base = _lpp_sensor_key(sensor.get("type_name", "unknown"), sensor.get("channel", 0))
+        n = counts.get(base, 0) + 1
+        counts[base] = n
+        result.append((sensor, base if n == 1 else f"{base}_{n}", n))
+    return result
+
+
+def _repeater_telemetry_payload(data: dict[str, Any]) -> dict[str, Any]:
+    """Build the flat HA state payload for a repeater telemetry snapshot."""
+    payload: dict[str, Any] = {}
+    for sensor in _REPEATER_SENSORS:
+        field = sensor["field"]
+        if field is not None:
+            payload[field] = data.get(field)
+
+    for sensor, key, _ in _assign_lpp_keys(data.get("lpp_sensors", []) or []):
+        payload[key] = sensor.get("value")
+
+    return payload
+
+
+def _lpp_discovery_configs(
+    prefix: str,
+    pub_key: str,
+    device: dict,
+    lpp_sensors: list[dict],
+    state_topic: str,
+) -> list[tuple[str, dict]]:
+    """Build HA discovery configs for a repeater's LPP sensors."""
+    configs: list[tuple[str, dict]] = []
+    for sensor, field, occurrence in _assign_lpp_keys(lpp_sensors):
+        type_name = sensor.get("type_name", "unknown")
+        channel = sensor.get("channel", 0)
+        meta = _LPP_HA_META.get(type_name, {})
+
+        nid = _node_id(pub_key)
+        object_id = field
+        display = type_name.replace("_", " ").title()
+        name = (
+            f"{display} (Ch {channel})"
+            if occurrence == 1
+            else f"{display} (Ch {channel}) #{occurrence}"
+        )
+
+        cfg: dict[str, Any] = {
+            "name": name,
+            "unique_id": f"meshcore_{nid}_{object_id}",
+            "device": device,
+            "state_topic": state_topic,
+            "value_template": "{{ value_json." + field + " }}",
+            "state_class": "measurement",
+            "expire_after": 36000,
+        }
+        if meta.get("device_class"):
+            cfg["device_class"] = meta["device_class"]
+        if meta.get("unit"):
+            cfg["unit_of_measurement"] = meta["unit"]
+        if meta.get("precision") is not None:
+            cfg["suggested_display_precision"] = meta["precision"]
+
+        topic = f"homeassistant/sensor/meshcore_{nid}/{object_id}/config"
+        configs.append((topic, cfg))
+
+    return configs
+

 # ── Local radio sensor definitions ────────────────────────────────────────

-_RADIO_SENSORS: list[dict[str, str | None]] = [
+_RADIO_SENSORS: list[dict[str, Any]] = [
    {
        "field": "noise_floor_dbm",
        "name": "Noise Floor",
@@ -96,14 +209,16 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": "signal_strength",
        "state_class": "measurement",
        "unit": "dBm",
+        "precision": 0,
    },
    {
-        "field": "battery_mv",
+        "field": "battery_volts",
        "name": "Battery",
        "object_id": "battery",
        "device_class": "voltage",
        "state_class": "measurement",
-        "unit": "mV",
+        "unit": "V",
+        "precision": 2,
    },
    {
        "field": "uptime_secs",
@@ -112,6 +227,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": "duration",
        "state_class": None,
        "unit": "s",
+        "precision": 0,
    },
    {
        "field": "last_rssi",
@@ -120,6 +236,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": "signal_strength",
        "state_class": "measurement",
        "unit": "dBm",
+        "precision": 0,
    },
    {
        "field": "last_snr",
@@ -128,6 +245,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": None,
        "state_class": "measurement",
        "unit": "dB",
+        "precision": 1,
    },
    {
        "field": "tx_air_secs",
@@ -136,6 +254,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": "duration",
        "state_class": "total_increasing",
        "unit": "s",
+        "precision": 0,
    },
    {
        "field": "rx_air_secs",
@@ -144,6 +263,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": "duration",
        "state_class": "total_increasing",
        "unit": "s",
+        "precision": 0,
    },
    {
        "field": "packets_recv",
@@ -152,6 +272,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": None,
        "state_class": "total_increasing",
        "unit": None,
+        "precision": 0,
    },
    {
        "field": "packets_sent",
@@ -160,6 +281,7 @@ _RADIO_SENSORS: list[dict[str, str | None]] = [
        "device_class": None,
        "state_class": "total_increasing",
        "unit": None,
+        "precision": 0,
    },
 ]

@@ -194,7 +316,7 @@ def _device_payload(
 class _HaMqttPublisher(BaseMqttPublisher):
    """Thin MQTT lifecycle wrapper for the HA discovery module."""

-    _backoff_max = 30
+    _backoff_max = 3600
    _log_prefix = "HA-MQTT"

    def __init__(self) -> None:
@@ -281,6 +403,8 @@ def _radio_discovery_configs(
            cfg["state_class"] = sensor["state_class"]
        if sensor["unit"]:
            cfg["unit_of_measurement"] = sensor["unit"]
+        if sensor.get("precision") is not None:
+            cfg["suggested_display_precision"] = sensor["precision"]

        topic = f"homeassistant/sensor/meshcore_{nid}/{sensor['object_id']}/config"
        configs.append((topic, cfg))
@@ -314,6 +438,8 @@ def _repeater_discovery_configs(
            cfg["state_class"] = sensor["state_class"]
        if sensor["unit"]:
            cfg["unit_of_measurement"] = sensor["unit"]
+        if sensor.get("precision") is not None:
+            cfg["suggested_display_precision"] = sensor["precision"]
        # 10 hours — margin over the 8-hour auto-collect cycle
        cfg["expire_after"] = 36000

@@ -351,7 +477,7 @@ def _message_event_discovery_config(
    device = _device_payload(radio_key, radio_name, "Radio")
    topic = f"homeassistant/event/meshcore_{nid}/messages/config"
    cfg: dict[str, Any] = {
-        "name": "MeshCore Messages",
+        "name": "Messages",
        "unique_id": f"meshcore_{nid}_messages",
        "device": device,
        "state_topic": f"{prefix}/{nid}/events/message",
@@ -413,23 +539,42 @@ class MqttHaModule(FanoutModule):
    # ── Discovery publishing ──────────────────────────────────────────

    async def _publish_discovery(self) -> None:
-        """Publish all HA discovery configs with retain=True."""
+        """Publish HA discovery configs and one-shot cached repeater state."""
        if not self._radio_key:
            # Don't publish discovery until we know the radio identity —
            # the first health heartbeat will provide it and trigger this.
            return

        configs: list[tuple[str, dict]] = []
+        cached_repeater_states: list[tuple[str, dict[str, Any]]] = []

        radio_name = self._radio_name or "MeshCore Radio"
        configs.extend(_radio_discovery_configs(self._prefix, self._radio_key, radio_name))

-        # Tracked repeaters — resolve names from DB best-effort
+        # Tracked repeaters — resolve names and LPP sensors from DB best-effort
        for pub_key in self._tracked_repeaters:
            rname = await self._resolve_contact_name(pub_key)
            configs.extend(
                _repeater_discovery_configs(self._prefix, pub_key, rname, self._radio_key)
            )
+            latest = await self._resolve_latest_telemetry(pub_key)
+            latest_data = latest.get("data", {}) if latest else {}
+            # Dynamic LPP sensor entities from last known telemetry snapshot
+            lpp_sensors = latest_data.get("lpp_sensors", [])
+            if lpp_sensors:
+                nid = _node_id(pub_key)
+                device = _device_payload(pub_key, rname, "Repeater", via_device_key=self._radio_key)
+                state_topic = f"{self._prefix}/{nid}/telemetry"
+                configs.extend(
+                    _lpp_discovery_configs(self._prefix, pub_key, device, lpp_sensors, state_topic)
+                )
+            if latest_data:
+                cached_repeater_states.append(
+                    (
+                        f"{self._prefix}/{_node_id(pub_key)}/telemetry",
+                        _repeater_telemetry_payload(latest_data),
+                    )
+                )

        # Tracked contacts — resolve names from DB best-effort
        for pub_key in self._tracked_contacts:
@@ -446,11 +591,18 @@ class MqttHaModule(FanoutModule):
        for topic, payload in configs:
            await self._publisher.publish(topic, payload, retain=True)

+        for topic, payload in cached_repeater_states:
+            # Replay cached state after discovery so newly created HA entities
+            # populate immediately, but do not retain it or HA will treat a
+            # broker reconnect as fresh telemetry and reset expire_after.
+            await self._publisher.publish(topic, payload)
+
        logger.info(
-            "HA MQTT: published %d discovery configs (%d repeaters, %d contacts)",
+            "HA MQTT: published %d discovery configs (%d repeaters, %d contacts, %d cached telemetry states)",
            len(configs),
            len(self._tracked_repeaters),
            len(self._tracked_contacts),
+            len(cached_repeater_states),
        )

    async def _clear_retained_topics(self, topics: list[str]) -> None:
@@ -481,6 +633,17 @@ class MqttHaModule(FanoutModule):
            pass
        return pub_key[:12]

+    @staticmethod
+    async def _resolve_latest_telemetry(pub_key: str) -> dict | None:
+        """Return the most recent telemetry row for a repeater, or None."""
+        try:
+            from app.repository.repeater_telemetry import RepeaterTelemetryRepository
+
+            return await RepeaterTelemetryRepository.get_latest(pub_key)
+        except Exception:
+            pass
+        return None
+
    def _seed_radio_identity_from_runtime(self) -> None:
        """Best-effort bootstrap from the currently connected radio session."""
        try:
@@ -548,6 +711,13 @@ class MqttHaModule(FanoutModule):
            field = sensor["field"]
            if field is not None:
                payload[field] = data.get(field)
+
+        # Normalize battery from millivolts to volts for consistency with
+        # repeater battery and the discovery config (unit: V, precision: 2).
+        battery_mv = data.get("battery_mv")
+        if battery_mv is not None:
+            payload["battery_volts"] = battery_mv / 1000.0
+
        await self._publisher.publish(f"{self._prefix}/{nid}/health", payload)

    async def on_contact(self, data: dict) -> None:
@@ -585,11 +755,19 @@ class MqttHaModule(FanoutModule):
        nid = _node_id(pub_key)
        # Publish the full telemetry dict — HA sensors use value_template
        # to extract individual fields
-        payload: dict[str, Any] = {}
-        for s in _REPEATER_SENSORS:
-            field = s["field"]
-            if field is not None:
-                payload[field] = data.get(field)
+        payload = _repeater_telemetry_payload(data)
+        lpp_sensors: list[dict] = data.get("lpp_sensors", [])
+        rediscover = False
+        for _, key, _ in _assign_lpp_keys(lpp_sensors):
+            expected_topic = f"homeassistant/sensor/meshcore_{nid}/{key}/config"
+            if expected_topic not in self._discovery_topics:
+                rediscover = True
+
+        # If new LPP sensor types appeared, re-publish discovery *before*
+        # the state payload so HA already knows the entity when the value arrives.
+        if rediscover:
+            await self._publish_discovery()
+
        await self._publisher.publish(f"{self._prefix}/{nid}/telemetry", payload)

    async def on_message(self, data: dict) -> None:
@@ -135,7 +135,34 @@ def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
            "display_override": ["window-controls-overlay", "standalone", "fullscreen"],
            "theme_color": "#111419",
            "background_color": "#111419",
+            # Icons are PNG-only on purpose. iOS Safari's manifest parser has
+            # historically been unreliable with SVG icons, and Android/Chrome
+            # PWA install flows prefer PNG for the install prompt.
+            #
+            # The "any" purpose entries are what iOS and desktop Chrome use
+            # for the home-screen / install icon. "maskable" entries are
+            # Android-only (adaptive icon with safe-zone crop); iOS does not
+            # apply the safe-zone mask, so a maskable-only icon set would
+            # render with excessive padding.
            "icons": [
+                {
+                    "src": f"{base}favicon-96x96.png",
+                    "sizes": "96x96",
+                    "type": "image/png",
+                    "purpose": "any",
+                },
+                {
+                    "src": f"{base}apple-touch-icon.png",
+                    "sizes": "180x180",
+                    "type": "image/png",
+                    "purpose": "any",
+                },
+                {
+                    "src": f"{base}favicon-256x256.png",
+                    "sizes": "256x256",
+                    "type": "image/png",
+                    "purpose": "any",
+                },
                {
                    "src": f"{base}web-app-manifest-192x192.png",
                    "sizes": "192x192",
@@ -149,6 +176,27 @@ def register_frontend_static_routes(app: FastAPI, frontend_dir: Path) -> bool:
                    "purpose": "maskable",
                },
            ],
+            "screenshots": [
+                {
+                    "src": f"{base}screenshot-wide.png",
+                    "sizes": "1367x909",
+                    "type": "image/png",
+                    "form_factor": "wide",
+                    "label": "RemoteTerm desktop view",
+                },
+                {
+                    "src": f"{base}screenshot-mobile.png",
+                    "sizes": "1170x2532",
+                    "type": "image/png",
+                    "label": "RemoteTerm mobile view",
+                },
+                {
+                    "src": f"{base}screenshot-mobile-2.png",
+                    "sizes": "750x1334",
+                    "type": "image/png",
+                    "label": "RemoteTerm mobile conversation",
+                },
+            ],
        }
        return JSONResponse(
            manifest,
@@ -67,6 +67,7 @@ from app.routers import (
    health,
    messages,
    packets,
+    push,
    radio,
    read_state,
    repeaters,
@@ -102,6 +103,14 @@ async def lifespan(app: FastAPI):
    await db.connect()
    logger.info("Database connected")

+    # Initialize VAPID keys for Web Push (generates on first run)
+    from app.push.vapid import ensure_vapid_keys
+
+    try:
+        await ensure_vapid_keys()
+    except Exception:
+        logger.warning("Failed to initialize VAPID keys for Web Push", exc_info=True)
+
    # Ensure default channels exist in the database even before the radio
    # connects. Without this, a fresh or disconnected instance would return
    # zero channels from GET /channels until the first successful radio sync.
@@ -167,8 +176,27 @@ app.add_middleware(

@app.exception_handler(RadioDisconnectedError)
 async def radio_disconnected_handler(request: Request, exc: RadioDisconnectedError):
-    """Return 503 when a radio disconnect race occurs during an operation."""
-    return JSONResponse(status_code=503, content={"detail": "Radio not connected"})
+    """Return 423 when a radio disconnect race occurs during an operation."""
+    return JSONResponse(status_code=423, content={"detail": "Radio not connected"})
+
+
+@app.middleware("http")
+async def log_server_errors(request: Request, call_next):
+    """Capture 5xx errors and unhandled exceptions into the log ring buffer.
+
+    Starlette writes unhandled-exception tracebacks to stderr, bypassing
+    Python logging, so they never reach the debug dump.  This middleware
+    catches them and logs via ``logger.exception()`` so the full traceback
+    is preserved in the ring buffer for the ``GET /api/debug`` snapshot.
+    """
+    try:
+        response = await call_next(request)
+    except Exception:
+        logger.exception("Unhandled exception on %s %s", request.method, request.url.path)
+        raise
+    if response.status_code >= 500:
+        logger.error("HTTP %d on %s %s", response.status_code, request.method, request.url.path)
+    return response


 # API routes - all prefixed with /api for production compatibility
@@ -185,6 +213,7 @@ app.include_router(packets.router, prefix="/api")
 app.include_router(read_state.router, prefix="/api")
 app.include_router(settings.router, prefix="/api")
 app.include_router(statistics.router, prefix="/api")
+app.include_router(push.router, prefix="/api")
 app.include_router(ws.router, prefix="/api")

 # Serve frontend static files in production
@@ -0,0 +1,22 @@
+import logging
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+
+async def migrate(conn: aiosqlite.Connection) -> None:
+    """Add telemetry_interval_hours integer column to app_settings."""
+    tables_cursor = await conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    if "app_settings" not in {row[0] for row in await tables_cursor.fetchall()}:
+        await conn.commit()
+        return
+    col_cursor = await conn.execute("PRAGMA table_info(app_settings)")
+    columns = {row[1] for row in await col_cursor.fetchall()}
+    if "telemetry_interval_hours" not in columns:
+        # Default to 8 hours, matching the previous hard-coded interval
+        # so existing users see no behavior change until they opt in.
+        await conn.execute(
+            "ALTER TABLE app_settings ADD COLUMN telemetry_interval_hours INTEGER DEFAULT 8"
+        )
+        await conn.commit()
@@ -0,0 +1,49 @@
+import logging
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+
+async def migrate(conn: aiosqlite.Connection) -> None:
+    """Add Web Push support: VAPID keys, push subscriptions table, and global conversation list."""
+
+    # VAPID key pair + global push conversation list in app_settings
+    table_check = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='app_settings'"
+    )
+    if await table_check.fetchone():
+        cursor = await conn.execute("PRAGMA table_info(app_settings)")
+        columns = {row[1] for row in await cursor.fetchall()}
+
+        if "vapid_private_key" not in columns:
+            await conn.execute(
+                "ALTER TABLE app_settings ADD COLUMN vapid_private_key TEXT DEFAULT ''"
+            )
+        if "vapid_public_key" not in columns:
+            await conn.execute(
+                "ALTER TABLE app_settings ADD COLUMN vapid_public_key TEXT DEFAULT ''"
+            )
+        if "push_conversations" not in columns:
+            await conn.execute(
+                "ALTER TABLE app_settings ADD COLUMN push_conversations TEXT DEFAULT '[]'"
+            )
+
+    # Push subscriptions — one row per browser/device
+    await conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS push_subscriptions (
+            id TEXT PRIMARY KEY,
+            endpoint TEXT NOT NULL,
+            p256dh TEXT NOT NULL,
+            auth TEXT NOT NULL,
+            label TEXT NOT NULL DEFAULT '',
+            created_at INTEGER NOT NULL,
+            last_success_at INTEGER,
+            failure_count INTEGER DEFAULT 0,
+            UNIQUE(endpoint)
+        )
+        """
+    )
+
+    await conn.commit()
@@ -0,0 +1,23 @@
+import logging
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+
+async def migrate(conn: aiosqlite.Connection) -> None:
+    """Add muted column to channels table."""
+    table_check = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='channels'"
+    )
+    if not await table_check.fetchone():
+        await conn.commit()
+        return
+
+    cursor = await conn.execute("PRAGMA table_info(channels)")
+    columns = {row[1] for row in await cursor.fetchall()}
+
+    if "muted" not in columns:
+        await conn.execute("ALTER TABLE channels ADD COLUMN muted INTEGER DEFAULT 0")
+
+    await conn.commit()
@@ -0,0 +1,57 @@
+import json
+import logging
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_BODY_FORMAT_DM = "**DM:** {sender_name}: {text} **via:** [{hops_backticked}]"
+DEFAULT_BODY_FORMAT_CHANNEL = (
+    "**{channel_name}:** {sender_name}: {text} **via:** [{hops_backticked}]"
+)
+_DEFAULT_BODY_FORMAT_DM_NO_PATH = "**DM:** {sender_name}: {text}"
+_DEFAULT_BODY_FORMAT_CHANNEL_NO_PATH = "**{channel_name}:** {sender_name}: {text}"
+
+
+async def migrate(conn: aiosqlite.Connection) -> None:
+    """Migrate apprise fanout configs from include_path boolean to format strings."""
+    table_check = await conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='fanout_configs'"
+    )
+    if not await table_check.fetchone():
+        await conn.commit()
+        return
+
+    cursor = await conn.execute("SELECT id, config FROM fanout_configs WHERE type = 'apprise'")
+    rows = await cursor.fetchall()
+
+    for row in rows:
+        config_id = row["id"] if isinstance(row, dict) else row[0]
+        config_raw = row["config"] if isinstance(row, dict) else row[1]
+        try:
+            config = json.loads(config_raw)
+        except (json.JSONDecodeError, TypeError):
+            continue
+
+        # Skip if already migrated
+        if "body_format_dm" in config:
+            continue
+
+        include_path = config.get("include_path", True)
+        config["body_format_dm"] = (
+            DEFAULT_BODY_FORMAT_DM if include_path else _DEFAULT_BODY_FORMAT_DM_NO_PATH
+        )
+        config["body_format_channel"] = (
+            DEFAULT_BODY_FORMAT_CHANNEL if include_path else _DEFAULT_BODY_FORMAT_CHANNEL_NO_PATH
+        )
+        config.pop("include_path", None)
+
+        await conn.execute(
+            "UPDATE fanout_configs SET config = ? WHERE id = ?",
+            (json.dumps(config), config_id),
+        )
+        logger.info(
+            "Migrated apprise config %s: include_path=%s -> format strings", config_id, include_path
+        )
+
+    await conn.commit()
@@ -0,0 +1,20 @@
+import logging
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+
+async def migrate(conn: aiosqlite.Connection) -> None:
+    """Add telemetry_routed_hourly boolean column to app_settings."""
+    tables_cursor = await conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    if "app_settings" not in {row[0] for row in await tables_cursor.fetchall()}:
+        await conn.commit()
+        return
+    col_cursor = await conn.execute("PRAGMA table_info(app_settings)")
+    columns = {row[1] for row in await col_cursor.fetchall()}
+    if "telemetry_routed_hourly" not in columns:
+        await conn.execute(
+            "ALTER TABLE app_settings ADD COLUMN telemetry_routed_hourly INTEGER DEFAULT 0"
+        )
+        await conn.commit()
@@ -221,6 +221,9 @@ class CreateContactRequest(BaseModel):

    public_key: str = Field(min_length=64, max_length=64, description="Public key (64-char hex)")
    name: str | None = Field(default=None, description="Display name for the contact")
+    type: int = Field(
+        default=0, ge=0, le=3, description="Contact type (0=unknown, 1=client, 2=repeater, 3=room)"
+    )
    try_historical: bool = Field(
        default=False,
        description="Attempt to decrypt historical DM packets for this contact",
@@ -346,6 +349,7 @@ class Channel(BaseModel):
    )
    last_read_at: int | None = None  # Server-side read state tracking
    favorite: bool = False
+    muted: bool = False


 class ChannelMessageCounts(BaseModel):
@@ -444,6 +448,8 @@ class RawPacketDecryptedInfo(BaseModel):
    sender: str | None = None
    channel_key: str | None = None
    contact_key: str | None = None
+    sender_timestamp: int | None = None
+    message: str | None = None


 class RawPacketBroadcast(BaseModel):
@@ -536,6 +542,7 @@ class RepeaterStatusResponse(BaseModel):
    flood_dups: int = Field(description="Duplicate flood packets")
    direct_dups: int = Field(description="Duplicate direct packets")
    full_events: int = Field(description="Full event queue count")
+    recv_errors: int | None = Field(default=None, description="Radio-level RX packet errors")
    telemetry_history: list["TelemetryHistoryEntry"] = Field(
        default_factory=list, description="Recent telemetry history snapshots"
    )
@@ -842,6 +849,21 @@ class AppSettings(BaseModel):
        default_factory=list,
        description="Public keys of repeaters opted into periodic telemetry collection (max 8)",
    )
+    telemetry_interval_hours: int = Field(
+        default=8,
+        description=(
+            "User-preferred telemetry collection interval in hours. The backend "
+            "clamps this up to the shortest legal interval given the number of "
+            "tracked repeaters so daily checks stay under a 24/day ceiling."
+        ),
+    )
+    telemetry_routed_hourly: bool = Field(
+        default=False,
+        description=(
+            "When enabled, tracked repeaters with a direct or routed (non-flood) "
+            "path are polled every hour instead of on the normal scheduled interval."
+        ),
+    )
    auto_resend_channel: bool = Field(
        default=False,
        description=(
@@ -366,6 +366,8 @@ async def process_raw_packet(
            sender=result["sender"],
            channel_key=result.get("channel_key"),
            contact_key=result.get("contact_key"),
+            sender_timestamp=result.get("sender_timestamp"),
+            message=result.get("message"),
        )
        if result["decrypted"]
        else None,
@@ -428,6 +430,8 @@ async def _process_group_text(
            "sender": decrypted.sender,
            "message_id": msg_id,  # None if duplicate, msg_id if new
            "channel_key": channel.key,
+            "sender_timestamp": decrypted.timestamp,
+            "message": decrypted.message,
        }

    # Couldn't decrypt with any known key
@@ -694,6 +698,8 @@ async def _process_direct_message(
                "sender": contact.name or contact.public_key[:12],
                "message_id": msg_id,
                "contact_key": contact.public_key,
+                "sender_timestamp": result.timestamp,
+                "message": result.message,
            }

    # Couldn't decrypt with any known contact
@@ -0,0 +1,182 @@
+"""Web Push dispatch manager.
+
+Checks the global push-enabled conversation list (stored in app_settings)
+and sends push notifications to ALL registered devices when a matching
+incoming message arrives.
+"""
+
+import asyncio
+import json
+import logging
+from dataclasses import dataclass
+
+from pywebpush import WebPushException
+
+from app.push.send import send_push
+from app.push.vapid import get_vapid_private_key
+from app.repository.channels import ChannelRepository
+from app.repository.push_subscriptions import PushSubscriptionRepository
+from app.repository.settings import AppSettingsRepository
+
+logger = logging.getLogger(__name__)
+
+_SEND_TIMEOUT = 15  # seconds per push send
+_VAPID_CLAIMS = {"sub": "mailto:noreply@meshcore.local"}
+
+
+def _state_key_for_message(data: dict) -> str:
+    """Derive the conversation state key from a message event payload."""
+    msg_type = data.get("type", "")
+    conversation_key = data.get("conversation_key", "")
+    if msg_type == "PRIV":
+        return f"contact-{conversation_key}"
+    return f"channel-{conversation_key}"
+
+
+def _build_payload(data: dict) -> str:
+    """Build the push notification JSON payload from a message event."""
+    msg_type = data.get("type", "")
+    text = data.get("text", "")
+    sender_name = data.get("sender_name") or ""
+    channel_name = data.get("channel_name") or ""
+
+    if msg_type == "PRIV":
+        title = f"Message from {sender_name}" if sender_name else "New direct message"
+        body = text
+    else:
+        title = channel_name if channel_name else "Channel message"
+        body = text
+
+    conversation_key = data.get("conversation_key", "")
+    state_key = _state_key_for_message(data)
+    if msg_type == "PRIV":
+        url_hash = f"#contact/{conversation_key}"
+    else:
+        url_hash = f"#channel/{conversation_key}"
+
+    return json.dumps(
+        {
+            "title": title,
+            "body": body,
+            # Tag per conversation so different conversations coexist in the
+            # notification tray, while repeated messages in the same
+            # conversation replace each other.
+            "tag": f"meshcore-{state_key}",
+            "url_hash": url_hash,
+        }
+    )
+
+
+def _subscription_info(sub: dict) -> dict:
+    """Build the subscription_info dict that pywebpush expects."""
+    return {
+        "endpoint": sub["endpoint"],
+        "keys": {
+            "p256dh": sub["p256dh"],
+            "auth": sub["auth"],
+        },
+    }
+
+
+@dataclass
+class _SendResult:
+    sub_id: str
+    success: bool = False
+    expired: bool = False
+
+
+class PushManager:
+    async def dispatch_message(self, data: dict) -> None:
+        """Send push notifications for a message event to all devices."""
+        # Don't notify for messages the operator just sent themselves
+        if data.get("outgoing"):
+            return
+
+        # Check the global conversation list
+        state_key = _state_key_for_message(data)
+        try:
+            push_conversations = await AppSettingsRepository.get_push_conversations()
+        except Exception:
+            logger.debug("Push dispatch: failed to load push_conversations", exc_info=True)
+            return
+
+        if state_key not in push_conversations:
+            return
+
+        # Skip muted channels
+        if data.get("type") == "CHAN" and data.get("conversation_key"):
+            try:
+                ch = await ChannelRepository.get_by_key(data["conversation_key"])
+                if ch and ch.muted:
+                    return
+            except Exception:
+                logger.debug("Push dispatch: failed to check channel mute state", exc_info=True)
+
+        try:
+            subs = await PushSubscriptionRepository.get_all()
+        except Exception:
+            logger.debug("Push dispatch: failed to load subscriptions", exc_info=True)
+            return
+
+        if not subs:
+            return
+
+        payload = _build_payload(data)
+        vapid_key = get_vapid_private_key()
+        if not vapid_key:
+            logger.debug("Push dispatch: no VAPID key configured, skipping")
+            return
+
+        results = await asyncio.gather(
+            *(self._send_one(sub, payload, vapid_key) for sub in subs),
+            return_exceptions=True,
+        )
+
+        # Batch-update all delivery outcomes in one transaction.
+        success_ids: list[str] = []
+        failure_ids: list[str] = []
+        remove_ids: list[str] = []
+        for r in results:
+            if isinstance(r, _SendResult):
+                if r.expired:
+                    remove_ids.append(r.sub_id)
+                elif r.success:
+                    success_ids.append(r.sub_id)
+                else:
+                    failure_ids.append(r.sub_id)
+        if success_ids or failure_ids or remove_ids:
+            try:
+                await PushSubscriptionRepository.batch_record_outcomes(
+                    success_ids, failure_ids, remove_ids
+                )
+            except Exception:
+                logger.debug("Push dispatch: failed to record outcomes", exc_info=True)
+
+    async def _send_one(self, sub: dict, payload: str, vapid_key: str) -> _SendResult:
+        sub_id = sub["id"]
+        result = _SendResult(sub_id=sub_id)
+        try:
+            async with asyncio.timeout(_SEND_TIMEOUT):
+                await send_push(
+                    subscription_info=_subscription_info(sub),
+                    payload=payload,
+                    vapid_private_key=vapid_key,
+                    vapid_claims=_VAPID_CLAIMS,
+                )
+            result.success = True
+        except WebPushException as e:
+            status = getattr(e, "response", None)
+            status_code = getattr(status, "status_code", 0) if status else 0
+            if status_code in (403, 404, 410):
+                logger.info("Push subscription expired (HTTP %d), removing %s", status_code, sub_id)
+                result.expired = True
+            else:
+                logger.warning("Push send failed for %s: %s", sub_id, e)
+        except TimeoutError:
+            logger.warning("Push send timed out for %s", sub_id)
+        except Exception:
+            logger.debug("Push send error for %s", sub_id, exc_info=True)
+        return result
+
+
+push_manager = PushManager()
@@ -0,0 +1,231 @@
+"""Thin wrapper around pywebpush for sending push notifications.
+
+Isolates the pywebpush dependency and runs the synchronous send in
+a thread executor to avoid blocking the event loop.
+"""
+
+import asyncio
+import logging
+import socket
+from typing import Any, cast
+
+import requests
+import urllib3.connection
+import urllib3.connectionpool
+from pywebpush import webpush
+from requests.adapters import HTTPAdapter
+from requests.exceptions import ConnectionError as RequestsConnectionError
+from requests.exceptions import ConnectTimeout as RequestsConnectTimeout
+from urllib3.exceptions import ConnectTimeoutError, NameResolutionError, NewConnectionError
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = object()
+DEFAULT_PUSH_CONNECT_TIMEOUT_SECONDS = 3
+IPV4_FALLBACK_CONNECT_TIMEOUT_SECONDS = 10
+DEFAULT_PUSH_READ_TIMEOUT_SECONDS = 10
+
+
+def _create_ipv4_connection(
+    address: tuple[str, int],
+    timeout: float | None | object = DEFAULT_TIMEOUT,
+    source_address: tuple[str, int] | None = None,
+    socket_options=None,
+) -> socket.socket:
+    """Create a socket connection using IPv4 only."""
+    host, port = address
+    if host.startswith("["):
+        host = host.strip("[]")
+
+    err: OSError | None = None
+    for res in socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM):
+        af, socktype, proto, _, sa = res
+        sock = None
+        try:
+            sock = socket.socket(af, socktype, proto)
+            if socket_options:
+                for opt in socket_options:
+                    sock.setsockopt(*opt)
+            if timeout is not DEFAULT_TIMEOUT:
+                sock.settimeout(cast(float | None, timeout))
+            if source_address:
+                sock.bind(source_address)
+            sock.connect(sa)
+            return sock
+        except OSError as exc:
+            err = exc
+            if sock is not None:
+                sock.close()
+
+    if err is not None:
+        raise err
+    raise OSError("getaddrinfo returns an empty list")
+
+
+class IPv4HTTPConnection(urllib3.connection.HTTPConnection):
+    """urllib3 HTTP connection that resolves and connects via IPv4 only."""
+
+    def _new_conn(self) -> socket.socket:
+        try:
+            return _create_ipv4_connection(
+                (self._dns_host, self.port),
+                self.timeout,
+                source_address=self.source_address,
+                socket_options=self.socket_options,
+            )
+        except socket.gaierror as exc:
+            raise NameResolutionError(self.host, self, exc) from exc
+        except TimeoutError as exc:
+            raise ConnectTimeoutError(
+                self,
+                f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
+            ) from exc
+        except OSError as exc:
+            raise NewConnectionError(self, f"Failed to establish a new connection: {exc}") from exc
+
+
+class IPv4HTTPSConnection(urllib3.connection.HTTPSConnection):
+    """urllib3 HTTPS connection that resolves and connects via IPv4 only."""
+
+    def _new_conn(self) -> socket.socket:
+        try:
+            return _create_ipv4_connection(
+                (self._dns_host, self.port),
+                self.timeout,
+                source_address=self.source_address,
+                socket_options=self.socket_options,
+            )
+        except socket.gaierror as exc:
+            raise NameResolutionError(self.host, self, exc) from exc
+        except TimeoutError as exc:
+            raise ConnectTimeoutError(
+                self,
+                f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
+            ) from exc
+        except OSError as exc:
+            raise NewConnectionError(self, f"Failed to establish a new connection: {exc}") from exc
+
+
+class IPv4HTTPConnectionPool(urllib3.connectionpool.HTTPConnectionPool):
+    ConnectionCls = cast(Any, IPv4HTTPConnection)
+
+
+class IPv4HTTPSConnectionPool(urllib3.connectionpool.HTTPSConnectionPool):
+    ConnectionCls = cast(Any, IPv4HTTPSConnection)
+
+
+def _configure_pool_manager_for_ipv4(manager: Any) -> None:
+    manager.pool_classes_by_scheme = manager.pool_classes_by_scheme.copy()
+    manager.pool_classes_by_scheme["http"] = IPv4HTTPConnectionPool
+    manager.pool_classes_by_scheme["https"] = IPv4HTTPSConnectionPool
+
+
+class IPv4HTTPAdapter(HTTPAdapter):
+    """requests adapter that uses IPv4-only urllib3 connection pools."""
+
+    def init_poolmanager(self, connections, maxsize, block=False, **pool_kwargs):
+        super().init_poolmanager(connections, maxsize, block=block, **pool_kwargs)
+        _configure_pool_manager_for_ipv4(self.poolmanager)
+
+    def proxy_manager_for(self, *args, **kwargs):
+        manager = super().proxy_manager_for(*args, **kwargs)
+        _configure_pool_manager_for_ipv4(manager)
+        return manager
+
+
+def _build_default_requests_session() -> requests.Session:
+    return requests.Session()
+
+
+def _build_ipv4_requests_session() -> requests.Session:
+    session = requests.Session()
+    adapter = IPv4HTTPAdapter()
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    return session
+
+
+def _send_push_with_session(
+    *,
+    subscription_info: dict,
+    payload: str,
+    vapid_private_key: str,
+    vapid_claims: dict,
+    session: requests.Session,
+    connect_timeout_seconds: int,
+) -> int:
+    response = webpush(
+        subscription_info=subscription_info,
+        data=payload,
+        vapid_private_key=vapid_private_key,
+        vapid_claims=vapid_claims,
+        content_encoding="aes128gcm",
+        timeout=cast(Any, (connect_timeout_seconds, DEFAULT_PUSH_READ_TIMEOUT_SECONDS)),
+        requests_session=session,
+    )
+    return response.status_code  # type: ignore[union-attr]
+
+
+def _send_push_with_fallback(
+    subscription_info: dict,
+    payload: str,
+    vapid_private_key: str,
+    vapid_claims: dict,
+) -> int:
+    """Send using normal dual-stack resolution, then retry with IPv4-only on connect failures."""
+    session = _build_default_requests_session()
+    try:
+        return _send_push_with_session(
+            subscription_info=subscription_info,
+            payload=payload,
+            vapid_private_key=vapid_private_key,
+            vapid_claims=vapid_claims,
+            session=session,
+            connect_timeout_seconds=DEFAULT_PUSH_CONNECT_TIMEOUT_SECONDS,
+        )
+    except (RequestsConnectTimeout, RequestsConnectionError) as exc:
+        logger.info("Push delivery retrying via IPv4 after initial network failure: %s", exc)
+    finally:
+        session.close()
+
+    session = _build_ipv4_requests_session()
+    try:
+        return _send_push_with_session(
+            subscription_info=subscription_info,
+            payload=payload,
+            vapid_private_key=vapid_private_key,
+            vapid_claims=vapid_claims,
+            session=session,
+            connect_timeout_seconds=IPV4_FALLBACK_CONNECT_TIMEOUT_SECONDS,
+        )
+    finally:
+        session.close()
+
+
+async def send_push(
+    subscription_info: dict,
+    payload: str,
+    vapid_private_key: str,
+    vapid_claims: dict,
+) -> int:
+    """Send an encrypted push notification.
+
+    Args:
+        subscription_info: {"endpoint": ..., "keys": {"p256dh": ..., "auth": ...}}
+        payload: JSON string to encrypt and send
+        vapid_private_key: base64url-encoded raw EC private key scalar
+        vapid_claims: {"sub": "mailto:..."} or {"sub": "https://..."}
+
+    Returns:
+        HTTP status code from the push service.
+
+    Raises:
+        WebPushException: on push service error (caller handles 404/410 cleanup).
+    """
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(
+        None,
+        lambda: _send_push_with_fallback(
+            subscription_info, payload, vapid_private_key, vapid_claims
+        ),
+    )
@@ -0,0 +1,60 @@
+"""VAPID key management for Web Push.
+
+Generates a P-256 key pair on first use and caches it in app_settings
+via ``AppSettingsRepository``.  The public key is served to browsers
+for ``PushManager.subscribe()``.
+"""
+
+import base64
+import logging
+
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+from py_vapid import Vapid
+
+from app.repository.settings import AppSettingsRepository
+
+logger = logging.getLogger(__name__)
+
+_cached_private_key: str = ""
+_cached_public_key: str = ""
+
+
+async def ensure_vapid_keys() -> tuple[str, str]:
+    """Read or generate VAPID keys. Call once at startup after DB connect."""
+    global _cached_private_key, _cached_public_key
+
+    private, public = await AppSettingsRepository.get_vapid_keys()
+    if private and public:
+        _cached_private_key = private
+        _cached_public_key = public
+        logger.info("VAPID keys loaded from database")
+        return _cached_private_key, _cached_public_key
+
+    # Generate new key pair
+    vapid = Vapid()
+    vapid.generate_keys()
+
+    # Private key as base64url-encoded raw 32-byte EC scalar — the format
+    # that pywebpush passes to ``Vapid.from_string()``.
+    raw_priv = vapid.private_key.private_numbers().private_value.to_bytes(32, "big")  # type: ignore[union-attr]
+    _cached_private_key = base64.urlsafe_b64encode(raw_priv).rstrip(b"=").decode("ascii")
+
+    # Public key as uncompressed P-256 point, base64url-encoded (no padding)
+    # for the browser Push API's applicationServerKey
+    raw_pub = vapid.public_key.public_bytes(Encoding.X962, PublicFormat.UncompressedPoint)  # type: ignore[union-attr]
+    _cached_public_key = base64.urlsafe_b64encode(raw_pub).rstrip(b"=").decode("ascii")
+
+    await AppSettingsRepository.set_vapid_keys(_cached_private_key, _cached_public_key)
+    logger.info("Generated and stored new VAPID key pair")
+
+    return _cached_private_key, _cached_public_key
+
+
+def get_vapid_public_key() -> str:
+    """Return the cached VAPID public key (base64url). Must call ensure_vapid_keys() first."""
+    return _cached_public_key
+
+
+def get_vapid_private_key() -> str:
+    """Return the cached VAPID private key (base64url). Must call ensure_vapid_keys() first."""
+    return _cached_private_key
@@ -14,6 +14,7 @@ import logging
 import math
 import time
 from contextlib import asynccontextmanager
+from datetime import UTC, datetime, timedelta
 from typing import Literal

 from meshcore import EventType, MeshCore
@@ -36,14 +37,47 @@ from app.services.contact_reconciliation import (
 )
 from app.services.messages import create_fallback_channel_message
 from app.services.radio_runtime import radio_runtime as radio_manager
+from app.telemetry_interval import clamp_telemetry_interval
 from app.websocket import broadcast_error, broadcast_event

 logger = logging.getLogger(__name__)

 DEFAULT_MAX_CHANNELS = 40
+_GET_CONTACTS_TIMEOUT = 10

 AdvertMode = Literal["flood", "zero_hop"]

+_AUTO_ADD_OVERWRITE_OLDEST = 0x01
+_RADIO_CONTACT_FAVORITE = 0x01
+
+
+async def _enable_autoevict_on_radio(mc: MeshCore) -> bool:
+    """Ensure the radio's AUTO_ADD_OVERWRITE_OLDEST preference bit is set."""
+    try:
+        current = await mc.commands.get_autoadd_config()
+        if current is None or current.type == EventType.ERROR:
+            logger.warning("Could not read autoadd config from radio: %s", current)
+            return False
+        current_flags = current.payload.get("config", 0)
+        if current_flags & _AUTO_ADD_OVERWRITE_OLDEST:
+            logger.debug("Radio autoevict already enabled (autoadd_config=0x%02x)", current_flags)
+            return True
+        new_flags = current_flags | _AUTO_ADD_OVERWRITE_OLDEST
+        result = await mc.commands.set_autoadd_config(new_flags)
+        if result is not None and result.type == EventType.OK:
+            logger.info(
+                "Enabled radio autoevict (autoadd_config 0x%02x -> 0x%02x)",
+                current_flags,
+                new_flags,
+            )
+            return True
+        else:
+            logger.warning("Failed to enable radio autoevict: %s", result)
+            return False
+    except Exception as exc:
+        logger.warning("Error enabling radio autoevict: %s", exc)
+        return False
+

 def _contact_sync_debug_fields(contact: Contact) -> dict[str, object]:
    """Return key contact fields for sync failure diagnostics."""
@@ -159,10 +193,10 @@ MIN_ADVERT_INTERVAL = 3600
 # Periodic telemetry collection task handle
 _telemetry_collect_task: asyncio.Task | None = None

-# Telemetry collection interval (8 hours)
-TELEMETRY_COLLECT_INTERVAL = 8 * 3600
-
-# Initial delay before the first telemetry collection cycle (let radio settle)
+# Initial delay before the scheduler starts (let radio settle). After this,
+# the loop wakes at each UTC top-of-hour and decides whether to run a cycle
+# based on the user's telemetry_interval_hours preference, clamped up to
+# the shortest-legal interval for the current tracked-repeater count.
 TELEMETRY_COLLECT_INITIAL_DELAY = 60

 # Counter to pause polling during repeater operations (supports nested pauses)
@@ -237,7 +271,7 @@ async def should_run_full_periodic_sync(mc: MeshCore) -> bool:
    capacity = _effective_radio_capacity(app_settings.max_radio_contacts)
    refill_target, full_sync_trigger = _compute_radio_contact_limits(capacity)

-    result = await mc.commands.get_contacts()
+    result = await mc.commands.get_contacts(timeout=_GET_CONTACTS_TIMEOUT)
    if result is None or result.type == EventType.ERROR:
        logger.warning("Periodic sync occupancy check failed: %s", result)
        return False
@@ -428,6 +462,16 @@ async def ensure_default_channels() -> None:

 async def sync_and_offload_all(mc: MeshCore) -> dict:
    """Run fast startup sync, then background contact reconcile."""
+    autoevict_requested = settings.load_with_autoevict
+    autoevict = False
+
+    if autoevict_requested:
+        autoevict = await _enable_autoevict_on_radio(mc)
+        if not autoevict:
+            logger.warning(
+                "Autoevict requested but unavailable; falling back to snapshot-based "
+                "background contact reconcile"
+            )

    # 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.
@@ -439,9 +483,25 @@ async def sync_and_offload_all(mc: MeshCore) -> dict:
    # Ensure default channels exist
    await ensure_default_channels()

+    snapshot_failed = "error" in contacts_result
+    if snapshot_failed and not autoevict:
+        logger.warning(
+            "Radio contact snapshot failed — attempting best-effort contact "
+            "loading without a full picture of what's already on the radio"
+        )
+        broadcast_error(
+            "Could not enumerate radio contacts",
+            "Loading favorites and recent contacts on a best-effort basis — "
+            "some adds may be redundant or fail if the radio's contact table "
+            "is already full. Set MESHCORE_LOAD_WITH_AUTOEVICT=true for more "
+            "reliable loading without needing to read the radio first. "
+            "See 'Contact Loading Issues' in the Advanced Setup documentation.",
+        )
+
    start_background_contact_reconciliation(
        initial_radio_contacts=contacts_result.get("radio_contacts", {}),
        expected_mc=mc,
+        autoevict=autoevict,
    )

    return {
@@ -459,9 +519,8 @@ async def drain_pending_messages(mc: MeshCore) -> int:
    Returns the count of messages retrieved.
    """
    count = 0
-    max_iterations = 100  # Safety limit

-    for _ in range(max_iterations):
+    while True:
        try:
            result = await mc.commands.get_msg(timeout=2.0)

@@ -853,7 +912,7 @@ async def _attempt_clock_wraparound(mc: MeshCore, *, now: int, observed_radio_ti
    return False


-async def sync_radio_time(mc: MeshCore) -> bool:
+async def sync_radio_time(mc: MeshCore, *, warn_on_failure: bool = True) -> bool:
    """Sync the radio's clock with the system time.

    The firmware only accepts forward time adjustments (new >= current).
@@ -868,9 +927,15 @@ async def sync_radio_time(mc: MeshCore) -> bool:
    only once; if it doesn't help (hardware RTC persists the wrong time),
    the skew is logged as a warning on subsequent syncs.

+    ``warn_on_failure`` controls log severity for rejected/failed sync attempts.
+    Startup and reconnect setup should leave this enabled so operators see the
+    initial skew problem. Periodic maintenance syncs pass ``False`` to avoid
+    repeating the same warning every few minutes after startup.
+
    Returns True if the radio accepted the new time, False otherwise.
    """
    global _clock_reboot_attempted  # noqa: PLW0603
+    log_failure = logger.warning if warn_on_failure else logger.debug
    try:
        now = int(time.time())
        preflight_radio_time: int | None = None
@@ -899,7 +964,7 @@ async def sync_radio_time(mc: MeshCore) -> bool:

        if radio_time is not None:
            delta = radio_time - now
-            logger.warning(
+            log_failure(
                "Radio rejected time sync: radio clock is %+d seconds "
                "(%+.1f hours) from system time (radio=%d, system=%d).",
                delta,
@@ -909,7 +974,7 @@ async def sync_radio_time(mc: MeshCore) -> bool:
            )
        else:
            delta = None
-            logger.warning(
+            log_failure(
                "Radio rejected time sync (set_time returned %s) "
                "and get_time query failed; cannot determine clock skew.",
                result.type,
@@ -934,14 +999,14 @@ async def sync_radio_time(mc: MeshCore) -> bool:
        # 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(
+            log_failure(
                "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)
+                log_failure("Reboot command failed", exc_info=True)
        elif _clock_reboot_attempted:
            logger.debug(
                "Clock skew persists after reboot (hardware RTC); ignoring until next session."
@@ -949,7 +1014,7 @@ async def sync_radio_time(mc: MeshCore) -> bool:

        return False
    except Exception as e:
-        logger.warning("Failed to sync radio time: %s", e, exc_info=True)
+        log_failure("Failed to sync radio time: %s", e, exc_info=True)
        return False


@@ -969,7 +1034,7 @@ async def _periodic_sync_loop():
                ) as mc:
                    if await should_run_full_periodic_sync(mc):
                        await sync_and_offload_all(mc)
-                    await sync_radio_time(mc)
+                    await sync_radio_time(mc, warn_on_failure=False)
            except RadioOperationBusyError:
                logger.debug("Skipping periodic sync: radio busy")
        except asyncio.CancelledError:
@@ -1038,7 +1103,7 @@ async def sync_contacts_from_radio(mc: MeshCore) -> dict:
    synced = 0

    try:
-        result = await mc.commands.get_contacts()
+        result = await mc.commands.get_contacts(timeout=_GET_CONTACTS_TIMEOUT)

        if result is None or result.type == EventType.ERROR:
            logger.error(
@@ -1101,12 +1166,24 @@ async def _reconcile_radio_contacts_in_background(
    *,
    initial_radio_contacts: dict[str, dict],
    expected_mc: MeshCore,
+    autoevict: bool = False,
 ) -> None:
-    """Converge radio contacts toward the desired favorites+recents working set."""
+    """Converge radio contacts toward the desired favorites+recents working set.
+
+    When *autoevict* is ``True`` the removal phase is skipped entirely and the
+    desired working set is blind-refreshed. Re-adding the full desired list
+    refreshes each contact's recency on supported firmware, so one successful
+    full pass converges the radio toward the desired working set without relying
+    on a stale contact snapshot.
+    """
    radio_contacts = dict(initial_radio_contacts)
    removed = 0
    loaded = 0
    failed = 0
+    table_full = False
+    autoevict_next_index = 0
+    autoevict_full_pass_retries = 0
+    _MAX_AUTOEVICT_RETRIES = 3

    try:
        while True:
@@ -1114,18 +1191,32 @@ async def _reconcile_radio_contacts_in_background(
                logger.info("Stopping background contact reconcile: radio transport changed")
                break

+            # Pre-lock snapshot for quick-exit checks; authoritative list is
+            # re-fetched inside the radio lock below.
            selected_contacts = await get_contacts_selected_for_radio_sync()
+            desired_fill_contacts = [
+                contact for contact in selected_contacts if len(contact.public_key) >= 64
+            ]
+
+            if autoevict:
+                if not desired_fill_contacts:
+                    logger.info(
+                        "Background contact blind fill complete: no desired contacts selected"
+                    )
+                    break
+                if autoevict_next_index >= len(desired_fill_contacts):
+                    autoevict_next_index = 0
            desired_contacts = {
-                contact.public_key.lower(): contact
-                for contact in selected_contacts
-                if len(contact.public_key) >= 64
+                contact.public_key.lower(): contact for contact in desired_fill_contacts
            }
-            removable_keys = [key for key in radio_contacts if key not in desired_contacts]
+            removable_keys = (
+                [] if autoevict else [key for key in radio_contacts if key not in desired_contacts]
+            )
            missing_contacts = [
                contact for key, contact in desired_contacts.items() if key not in radio_contacts
            ]

-            if not removable_keys and not missing_contacts:
+            if not autoevict and not removable_keys and not missing_contacts:
                logger.info(
                    "Background contact reconcile complete: %d contacts on radio working set",
                    len(radio_contacts),
@@ -1133,6 +1224,8 @@ async def _reconcile_radio_contacts_in_background(
                break

            progressed = False
+            autoevict_pass_complete = False
+            autoevict_pass_failed = False
            try:
                async with radio_manager.radio_operation(
                    "background_contact_reconcile",
@@ -1146,100 +1239,237 @@ async def _reconcile_radio_contacts_in_background(

                    budget = CONTACT_RECONCILE_BATCH_SIZE
                    selected_contacts = await get_contacts_selected_for_radio_sync()
+                    desired_fill_contacts = [
+                        contact for contact in selected_contacts if len(contact.public_key) >= 64
+                    ]
+                    if autoevict and autoevict_next_index >= len(desired_fill_contacts):
+                        autoevict_next_index = 0
                    desired_contacts = {
-                        contact.public_key.lower(): contact
-                        for contact in selected_contacts
-                        if len(contact.public_key) >= 64
+                        contact.public_key.lower(): contact for contact in desired_fill_contacts
                    }

-                    for public_key in list(radio_contacts):
-                        if budget <= 0:
-                            break
-                        if public_key in desired_contacts:
-                            continue
-
-                        remove_payload = (
-                            mc.get_contact_by_key_prefix(public_key[:12])
-                            or radio_contacts.get(public_key)
-                            or {"public_key": public_key}
-                        )
-                        try:
-                            remove_result = await mc.commands.remove_contact(remove_payload)
-                        except Exception as exc:
-                            failed += 1
-                            budget -= 1
-                            logger.warning(
-                                "Error removing contact %s during background reconcile: %s",
-                                public_key[:12],
-                                exc,
-                            )
-                            continue
-
-                        budget -= 1
-                        if remove_result.type == EventType.OK:
-                            radio_contacts.pop(public_key, None)
-                            _evict_removed_contact_from_library_cache(mc, public_key)
-                            removed += 1
-                            progressed = True
-                        else:
-                            failed += 1
-                            logger.warning(
-                                "Failed to remove contact %s during background reconcile: %s",
-                                public_key[:12],
-                                remove_result.payload,
-                            )
-
-                    if budget > 0:
-                        for public_key, contact in desired_contacts.items():
+                    if not autoevict:
+                        for public_key in list(radio_contacts):
                            if budget <= 0:
                                break
-                            if public_key in radio_contacts:
-                                continue
-
-                            if mc.get_contact_by_key_prefix(public_key[:12]):
-                                radio_contacts[public_key] = {"public_key": public_key}
+                            if public_key in desired_contacts:
                                continue

+                            remove_payload = (
+                                mc.get_contact_by_key_prefix(public_key[:12])
+                                or radio_contacts.get(public_key)
+                                or {"public_key": public_key}
+                            )
                            try:
-                                add_payload = contact.to_radio_dict()
-                                add_result = await mc.commands.add_contact(add_payload)
+                                remove_result = await mc.commands.remove_contact(remove_payload)
                            except Exception as exc:
                                failed += 1
                                budget -= 1
                                logger.warning(
-                                    "Error adding contact %s during background reconcile: %s",
+                                    "Error removing contact %s during background reconcile: %s",
                                    public_key[:12],
                                    exc,
-                                    exc_info=True,
                                )
                                continue

                            budget -= 1
-                            if add_result.type == EventType.OK:
-                                radio_contacts[public_key] = add_payload
-                                loaded += 1
+                            not_found = (
+                                remove_result.type != EventType.OK
+                                and isinstance(remove_result.payload, dict)
+                                and remove_result.payload.get("error_code") == 2
+                            )
+                            if remove_result.type == EventType.OK or not_found:
+                                radio_contacts.pop(public_key, None)
+                                _evict_removed_contact_from_library_cache(mc, public_key)
+                                removed += 1
                                progressed = True
                            else:
                                failed += 1
-                                reason = add_result.payload
-                                hint = ""
-                                if reason is None:
-                                    hint = (
-                                        " (no response from radio — if this repeats, check for "
-                                        "serial port contention from another process or try a "
-                                        "power cycle)"
-                                    )
                                logger.warning(
-                                    "Failed to add contact %s during background reconcile: %s%s",
+                                    "Failed to remove contact %s during background reconcile: %s",
                                    public_key[:12],
-                                    reason,
-                                    hint,
+                                    remove_result.payload,
                                )
+
+                    if budget > 0:
+                        if autoevict:
+                            # Budget is consumed by the slice bound rather than
+                            # per-operation decrement — autoevict skips the
+                            # removal phase so the full budget is always available.
+                            batch_contacts = desired_fill_contacts[
+                                autoevict_next_index : autoevict_next_index + budget
+                            ]
+                            processed_contacts = 0
+                            for contact in batch_contacts:
+                                public_key = contact.public_key.lower()
+                                try:
+                                    add_payload = contact.to_radio_dict()
+                                    # In autoevict mode, app-loaded contacts should
+                                    # remain evictable by the radio even if the
+                                    # stored contact record carries the favorite bit.
+                                    add_payload["flags"] = (
+                                        int(add_payload.get("flags", 0)) & ~_RADIO_CONTACT_FAVORITE
+                                    )
+                                    add_result = await mc.commands.add_contact(add_payload)
+                                except Exception as exc:
+                                    failed += 1
+                                    logger.warning(
+                                        "Error blind-filling contact %s during background reconcile: %s",
+                                        public_key[:12],
+                                        exc,
+                                        exc_info=True,
+                                    )
+                                    autoevict_pass_failed = True
+                                    processed_contacts += 1
+                                    continue
+
+                                if add_result.type == EventType.OK:
+                                    radio_contacts[public_key] = add_payload
+                                    loaded += 1
+                                    progressed = True
+                                else:
+                                    failed += 1
+                                    autoevict_pass_failed = True
+                                    reason = add_result.payload
+                                    if isinstance(reason, dict) and reason.get("error_code") == 3:
+                                        logger.warning(
+                                            "Radio contact table full — stopping "
+                                            "contact reconcile (loaded %d this cycle)",
+                                            loaded,
+                                        )
+                                        table_full = True
+                                        break
+                                    hint = ""
+                                    if reason is None:
+                                        hint = (
+                                            " (no response from radio — if this repeats, check for "
+                                            "serial port contention from another process or try a "
+                                            "power cycle)"
+                                        )
+                                    logger.warning(
+                                        "Failed to blind-fill contact %s during background reconcile: %s%s",
+                                        public_key[:12],
+                                        reason,
+                                        hint,
+                                    )
+                                processed_contacts += 1
+
+                            autoevict_next_index += processed_contacts
+                            autoevict_pass_complete = autoevict_next_index >= len(
+                                desired_fill_contacts
+                            )
+                        else:
+                            for public_key, contact in desired_contacts.items():
+                                if budget <= 0:
+                                    break
+                                if public_key in radio_contacts:
+                                    continue
+
+                                if mc.get_contact_by_key_prefix(public_key[:12]):
+                                    radio_contacts[public_key] = {"public_key": public_key}
+                                    continue
+
+                                try:
+                                    add_payload = contact.to_radio_dict()
+                                    add_result = await mc.commands.add_contact(add_payload)
+                                except Exception as exc:
+                                    failed += 1
+                                    budget -= 1
+                                    logger.warning(
+                                        "Error adding contact %s during background reconcile: %s",
+                                        public_key[:12],
+                                        exc,
+                                        exc_info=True,
+                                    )
+                                    continue
+
+                                budget -= 1
+                                if add_result.type == EventType.OK:
+                                    radio_contacts[public_key] = add_payload
+                                    loaded += 1
+                                    progressed = True
+                                else:
+                                    failed += 1
+                                    reason = add_result.payload
+                                    if isinstance(reason, dict) and reason.get("error_code") == 3:
+                                        logger.warning(
+                                            "Radio contact table full — stopping "
+                                            "contact reconcile (loaded %d this cycle)",
+                                            loaded,
+                                        )
+                                        table_full = True
+                                        break
+                                    hint = ""
+                                    if reason is None:
+                                        hint = (
+                                            " (no response from radio — if this repeats, check for "
+                                            "serial port contention from another process or try a "
+                                            "power cycle)"
+                                        )
+                                    logger.warning(
+                                        "Failed to add contact %s during background reconcile: %s%s",
+                                        public_key[:12],
+                                        reason,
+                                        hint,
+                                    )
            except RadioOperationBusyError:
                logger.debug("Background contact reconcile yielding: radio busy")
                await asyncio.sleep(CONTACT_RECONCILE_BUSY_BACKOFF_SECONDS)
                continue

+            if table_full:
+                if autoevict:
+                    logger.error(
+                        "We're expecting the radio to be in AUTO_ADD_OVERWRITE_OLDEST mode, "
+                        "so a full-table error means we have no idea what is going on with "
+                        "this radio; it is misbehaving. You should consider DM auto-acking "
+                        "to be unreliable and/or not working for this radio. Sending and "
+                        "receiving messages are not impacted by this error unless other "
+                        "things are broken on your radio."
+                    )
+                    broadcast_error(
+                        "Could not load all desired contacts onto the radio for auto-DM ack",
+                        "Despite having auto-evict enabled, we got a contact-table-full error "
+                        "from your radio. DM auto-ack is likely unavailable.",
+                    )
+                else:
+                    normal_table_full_message = (
+                        "The radio's contact table is full. Clearing your radio contacts "
+                        "using another client, lowering your contact fill target in "
+                        "settings, or setting MESHCORE_LOAD_WITH_AUTOEVICT=true may "
+                        "relieve this. See 'Contact Loading Issues' in the Advanced "
+                        "README.md"
+                    )
+                    logger.error(
+                        "Contact reconcile hit TABLE_FULL. %s",
+                        normal_table_full_message,
+                    )
+                    broadcast_error(
+                        "Could not load all desired contacts onto the radio for auto-DM ack",
+                        normal_table_full_message,
+                    )
+                break
+
+            if autoevict and autoevict_pass_complete:
+                if autoevict_pass_failed:
+                    autoevict_full_pass_retries += 1
+                    if autoevict_full_pass_retries >= _MAX_AUTOEVICT_RETRIES:
+                        logger.warning(
+                            "Background contact blind fill giving up after %d full passes "
+                            "with persistent failures (loaded %d, failed %d)",
+                            autoevict_full_pass_retries,
+                            loaded,
+                            failed,
+                        )
+                        break
+                    autoevict_next_index = 0
+                else:
+                    logger.info(
+                        "Background contact blind fill complete: refreshed %d desired contacts",
+                        len(desired_fill_contacts),
+                    )
+                    break
+
            await asyncio.sleep(CONTACT_RECONCILE_YIELD_SECONDS)
            if not progressed:
                continue
@@ -1262,6 +1492,7 @@ def start_background_contact_reconciliation(
    *,
    initial_radio_contacts: dict[str, dict],
    expected_mc: MeshCore,
+    autoevict: bool = False,
 ) -> None:
    """Start or replace the background contact reconcile task for the current radio."""
    global _contact_reconcile_task
@@ -1273,11 +1504,13 @@ def start_background_contact_reconciliation(
        _reconcile_radio_contacts_in_background(
            initial_radio_contacts=initial_radio_contacts,
            expected_mc=expected_mc,
+            autoevict=autoevict,
        )
    )
    logger.info(
-        "Started background contact reconcile for %d radio contact(s)",
+        "Started background contact reconcile for %d radio contact(s)%s",
        len(initial_radio_contacts),
+        " (autoevict mode)" if autoevict else "",
    )


@@ -1295,7 +1528,13 @@ async def stop_background_contact_reconciliation() -> None:


 async def get_contacts_selected_for_radio_sync() -> list[Contact]:
-    """Return the contacts that would be loaded onto the radio right now."""
+    """Return the contacts that would be loaded onto the radio right now.
+
+    Fill order:
+    1. Favorites (up to full capacity)
+    2. Most recently DM-active non-repeaters (sent or received, up to 80% refill target)
+    3. Most recently advertised non-repeaters (up to 80% refill target)
+    """
    app_settings = await AppSettingsRepository.get()
    max_contacts = _effective_radio_capacity(app_settings.max_radio_contacts)
    refill_target, _full_sync_trigger = _compute_radio_contact_limits(max_contacts)
@@ -1315,7 +1554,7 @@ async def get_contacts_selected_for_radio_sync() -> list[Contact]:
            break

    if len(selected_contacts) < refill_target:
-        for contact in await ContactRepository.get_recently_contacted_non_repeaters(
+        for contact in await ContactRepository.get_recently_dm_active_non_repeaters(
            limit=max_contacts
        ):
            key = contact.public_key.lower()
@@ -1354,8 +1593,8 @@ async def _sync_contacts_to_radio_inner(mc: MeshCore) -> dict:

    Fill order is:
    1. Favorite contacts
-    2. Most recently interacted-with non-repeaters
-    3. Most recently advert-heard non-repeaters without interaction history
+    2. Most recently DM-active non-repeaters (sent or received)
+    3. Most recently advert-heard non-repeaters

    Favorite contacts are always reloaded first, up to the configured capacity.
    Additional non-favorite fill stops at the refill target (80% of capacity).
@@ -1489,8 +1728,8 @@ async def sync_recent_contacts_to_radio(force: bool = False, mc: MeshCore | None
    """
    Load contacts to the radio for DM ACK support.

-    Fill order is favorites, then recently contacted non-repeaters,
-    then recently advert-heard non-repeaters. Favorites are always reloaded
+    Fill order is favorites, then recently DM-active non-repeaters (sent or
+    received), then recently advert-heard non-repeaters. Favorites are always reloaded
    up to the configured capacity; additional non-favorite fill stops at the
    80% refill target.
    Only runs at most once every CONTACT_SYNC_THROTTLE_SECONDS unless forced.
@@ -1582,8 +1821,38 @@ async def _collect_repeater_telemetry(mc: MeshCore, contact: Contact) -> bool:
        "flood_dups": status.get("flood_dups", 0),
        "direct_dups": status.get("direct_dups", 0),
        "full_events": status.get("full_evts", 0),
+        "recv_errors": status.get("recv_errors"),
    }

+    # Best-effort LPP sensor fetch — failure here does not fail the overall
+    # collection; status telemetry is still recorded without sensor data.
+    try:
+        lpp_raw = await mc.commands.req_telemetry_sync(
+            contact.public_key, timeout=10, min_timeout=5
+        )
+        if lpp_raw:
+            lpp_sensors = []
+            for entry in lpp_raw:
+                value = entry.get("value", 0)
+                # Skip multi-value sensors (GPS, accelerometer, etc.)
+                if isinstance(value, dict):
+                    continue
+                lpp_sensors.append(
+                    {
+                        "channel": entry.get("channel", 0),
+                        "type_name": str(entry.get("type", "unknown")),
+                        "value": value,
+                    }
+                )
+            if lpp_sensors:
+                data["lpp_sensors"] = lpp_sensors
+    except Exception as e:
+        logger.debug(
+            "Telemetry collect: LPP sensor fetch failed for %s (non-fatal): %s",
+            contact.public_key[:12],
+            e,
+        )
+
    try:
        timestamp = int(time.time())
        await RepeaterTelemetryRepository.record(
@@ -1621,62 +1890,149 @@ async def _collect_repeater_telemetry(mc: MeshCore, contact: Contact) -> bool:
        return False


+async def _run_telemetry_cycle(*, routed_only: bool = False) -> None:
+    """Collect one telemetry sample from tracked repeaters.
+
+    When *routed_only* is True, only repeaters whose effective route is
+    ``"direct"`` or ``"override"`` (i.e. not ``"flood"``) are collected.
+    This is used by the hourly routed-path fast-poll feature.
+    """
+    if not radio_manager.is_connected:
+        logger.debug("Telemetry collect: radio not connected, skipping cycle")
+        return
+
+    app_settings = await AppSettingsRepository.get()
+    tracked = app_settings.tracked_telemetry_repeaters
+    if not tracked:
+        return
+
+    candidates: list[tuple[str, Contact]] = []
+    for pub_key in tracked:
+        contact = await ContactRepository.get_by_key(pub_key)
+        if not contact or contact.type != 2:
+            logger.debug(
+                "Telemetry collect: skipping %s (not found or not repeater)",
+                pub_key[:12],
+            )
+            continue
+        if routed_only and (not contact.effective_route or contact.effective_route.path_len < 0):
+            continue
+        candidates.append((pub_key, contact))
+
+    if not candidates:
+        if routed_only:
+            logger.debug("Telemetry collect: no routed repeaters to poll this hour")
+        return
+
+    label = "routed" if routed_only else "full"
+    logger.info(
+        "Telemetry collect: starting %s cycle for %d repeater(s)",
+        label,
+        len(candidates),
+    )
+    collected = 0
+
+    for _pub_key, contact in candidates:
+        try:
+            async with radio_manager.radio_operation(
+                "telemetry_collect",
+                blocking=False,
+                suspend_auto_fetch=True,
+            ) as mc:
+                if await _collect_repeater_telemetry(mc, contact):
+                    collected += 1
+        except RadioOperationBusyError:
+            logger.debug(
+                "Telemetry collect: radio busy, skipping %s",
+                contact.public_key[:12],
+            )
+
+    logger.info(
+        "Telemetry collect: %s cycle complete, %d/%d successful",
+        label,
+        collected,
+        len(candidates),
+    )
+
+
+async def _sleep_until_next_utc_top_of_hour() -> None:
+    """Sleep until the next UTC top-of-hour (or a minimum of 1 second)."""
+    now = datetime.now(UTC)
+    next_top = now.replace(minute=0, second=0, microsecond=0) + timedelta(hours=1)
+    delay = (next_top - now).total_seconds()
+    if delay < 1:
+        delay = 1
+    await asyncio.sleep(delay)
+
+
+async def _maybe_run_scheduled_cycle(now: datetime) -> None:
+    """Evaluate the modulo gate for the given UTC time and run a cycle if due.
+
+    Factored out of the loop so we can also invoke it immediately after the
+    post-boot initial delay — otherwise a restart within the initial-delay
+    window before a scheduled boundary would carry the task past that boundary
+    and skip a due cycle (for 24h cadence users, that's a full day of missed
+    telemetry).
+    """
+    app_settings = await AppSettingsRepository.get()
+    tracked_count = len(app_settings.tracked_telemetry_repeaters)
+    if tracked_count == 0:
+        return
+    effective_hours = clamp_telemetry_interval(app_settings.telemetry_interval_hours, tracked_count)
+    if effective_hours <= 0:
+        return
+
+    is_normal_cycle = now.hour % effective_hours == 0
+
+    if is_normal_cycle:
+        # Normal scheduled boundary: collect ALL tracked repeaters.
+        await _run_telemetry_cycle()
+    elif app_settings.telemetry_routed_hourly:
+        # Hourly routed-path fast-poll: only repeaters with a non-flood route.
+        await _run_telemetry_cycle(routed_only=True)
+
+
 async def _telemetry_collect_loop() -> None:
-    """Background task that collects telemetry from tracked repeaters every 8 hours.
+    """Background task that runs tracked-repeater telemetry collection.

-    Runs a first cycle after a short initial delay (so newly tracked repeaters
-    get a sample promptly), then sleeps the full interval between subsequent cycles.
+    After an initial post-boot delay we evaluate the modulo gate once
+    (covers the edge case where the initial delay crossed a scheduled
+    boundary on restart). Then we wake at every UTC top-of-hour and
+    evaluate the gate again. A cycle runs only when
+    ``current_utc_hour % effective_interval_hours == 0``, where the
+    effective interval is the user preference clamped up to the shortest
+    legal interval for the current tracked-repeater count. This keeps the
+    total daily check count bounded at ``DAILY_CHECK_CEILING`` (24).

-    Acquires the radio lock per-repeater (non-blocking) so manual operations can
+    The loop never updates the stored user preference. If the user picks a
+    short interval and then adds repeaters that make it illegal, they keep
+    their pick stored and we silently use the clamped value until they drop
+    repeaters.
+
+    Radio lock is acquired per-repeater (non-blocking) so manual ops can
    interleave. Failures are logged and skipped.
    """
-    first_run = True
+    try:
+        await asyncio.sleep(TELEMETRY_COLLECT_INITIAL_DELAY)
+    except asyncio.CancelledError:
+        logger.info("Telemetry collect task cancelled before initial delay")
+        return
+
+    # Post-boot boundary check: if the delay carried us into a matching hour
+    # (or we booted exactly at a matching hour), run now rather than waiting
+    # another full cycle.
+    try:
+        await _maybe_run_scheduled_cycle(datetime.now(UTC))
+    except asyncio.CancelledError:
+        logger.info("Telemetry collect task cancelled after initial delay")
+        return
+    except Exception as e:
+        logger.error("Error in post-boot telemetry check: %s", e, exc_info=True)
+
    while True:
        try:
-            delay = TELEMETRY_COLLECT_INITIAL_DELAY if first_run else TELEMETRY_COLLECT_INTERVAL
-            await asyncio.sleep(delay)
-            first_run = False
-
-            if not radio_manager.is_connected:
-                logger.debug("Telemetry collect: radio not connected, skipping cycle")
-                continue
-
-            app_settings = await AppSettingsRepository.get()
-            tracked = app_settings.tracked_telemetry_repeaters
-            if not tracked:
-                continue
-
-            logger.info("Telemetry collect: starting cycle for %d repeater(s)", len(tracked))
-            collected = 0
-
-            for pub_key in tracked:
-                contact = await ContactRepository.get_by_key(pub_key)
-                if not contact or contact.type != 2:
-                    logger.debug(
-                        "Telemetry collect: skipping %s (not found or not repeater)",
-                        pub_key[:12],
-                    )
-                    continue
-
-                try:
-                    async with radio_manager.radio_operation(
-                        "telemetry_collect",
-                        blocking=False,
-                        suspend_auto_fetch=True,
-                    ) as mc:
-                        if await _collect_repeater_telemetry(mc, contact):
-                            collected += 1
-                except RadioOperationBusyError:
-                    logger.debug(
-                        "Telemetry collect: radio busy, skipping %s",
-                        pub_key[:12],
-                    )
-
-            logger.info(
-                "Telemetry collect: cycle complete, %d/%d successful",
-                collected,
-                len(tracked),
-            )
+            await _sleep_until_next_utc_top_of_hour()
+            await _maybe_run_scheduled_cycle(datetime.now(UTC))

        except asyncio.CancelledError:
            logger.info("Telemetry collect task cancelled")
@@ -1690,10 +2046,7 @@ def start_telemetry_collect() -> None:
    global _telemetry_collect_task
    if _telemetry_collect_task is None or _telemetry_collect_task.done():
        _telemetry_collect_task = asyncio.create_task(_telemetry_collect_loop())
-        logger.info(
-            "Started periodic telemetry collection (interval: %ds)",
-            TELEMETRY_COLLECT_INTERVAL,
-        )
+        logger.info("Started periodic telemetry collection (UTC-hourly scheduler)")


 async def stop_telemetry_collect() -> None:
@@ -8,31 +8,33 @@ class ChannelRepository:
    @staticmethod
    async def upsert(key: str, name: str, is_hashtag: bool = False, on_radio: bool = False) -> None:
        """Upsert a channel. Key is 32-char hex string."""
-        await db.conn.execute(
-            """
-            INSERT INTO channels (key, name, is_hashtag, on_radio, flood_scope_override)
-            VALUES (?, ?, ?, ?, NULL)
-            ON CONFLICT(key) DO UPDATE SET
-                name = excluded.name,
-                is_hashtag = excluded.is_hashtag,
-                on_radio = excluded.on_radio
-            """,
-            (key.upper(), name, is_hashtag, on_radio),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                INSERT INTO channels (key, name, is_hashtag, on_radio, flood_scope_override)
+                VALUES (?, ?, ?, ?, NULL)
+                ON CONFLICT(key) DO UPDATE SET
+                    name = excluded.name,
+                    is_hashtag = excluded.is_hashtag,
+                    on_radio = excluded.on_radio
+                """,
+                (key.upper(), name, is_hashtag, on_radio),
+            ):
+                pass

    @staticmethod
    async def get_by_key(key: str) -> Channel | None:
        """Get a channel by its key (32-char hex string)."""
-        cursor = await db.conn.execute(
-            """
-            SELECT key, name, is_hashtag, on_radio, flood_scope_override, path_hash_mode_override, last_read_at, favorite
-            FROM channels
-            WHERE key = ?
-            """,
-            (key.upper(),),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT key, name, is_hashtag, on_radio, flood_scope_override, path_hash_mode_override, last_read_at, favorite, muted
+                FROM channels
+                WHERE key = ?
+                """,
+                (key.upper(),),
+            ) as cursor:
+                row = await cursor.fetchone()
        if row:
            return Channel(
                key=row["key"],
@@ -43,19 +45,21 @@ class ChannelRepository:
                path_hash_mode_override=row["path_hash_mode_override"],
                last_read_at=row["last_read_at"],
                favorite=bool(row["favorite"]),
+                muted=bool(row["muted"]),
            )
        return None

    @staticmethod
    async def get_all() -> list[Channel]:
-        cursor = await db.conn.execute(
-            """
-            SELECT key, name, is_hashtag, on_radio, flood_scope_override, path_hash_mode_override, last_read_at, favorite
-            FROM channels
-            ORDER BY name
-            """
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT key, name, is_hashtag, on_radio, flood_scope_override, path_hash_mode_override, last_read_at, favorite, muted
+                FROM channels
+                ORDER BY name
+                """
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [
            Channel(
                key=row["key"],
@@ -66,6 +70,7 @@ class ChannelRepository:
                path_hash_mode_override=row["path_hash_mode_override"],
                last_read_at=row["last_read_at"],
                favorite=bool(row["favorite"]),
+                muted=bool(row["muted"]),
            )
            for row in rows
        ]
@@ -73,21 +78,34 @@ class ChannelRepository:
    @staticmethod
    async def set_favorite(key: str, value: bool) -> bool:
        """Set or clear the favorite flag for a channel. Returns True if row was found."""
-        cursor = await db.conn.execute(
-            "UPDATE channels SET favorite = ? WHERE key = ?",
-            (1 if value else 0, key.upper()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE channels SET favorite = ? WHERE key = ?",
+                (1 if value else 0, key.upper()),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount > 0
+
+    @staticmethod
+    async def set_muted(key: str, value: bool) -> bool:
+        """Set or clear the muted flag for a channel. Returns True if row was found."""
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE channels SET muted = ? WHERE key = ?",
+                (1 if value else 0, key.upper()),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount > 0

    @staticmethod
    async def delete(key: str) -> None:
        """Delete a channel by key."""
-        await db.conn.execute(
-            "DELETE FROM channels WHERE key = ?",
-            (key.upper(),),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                "DELETE FROM channels WHERE key = ?",
+                (key.upper(),),
+            ):
+                pass

    @staticmethod
    async def update_last_read_at(key: str, timestamp: int | None = None) -> bool:
@@ -96,35 +114,39 @@ class ChannelRepository:
        Returns True if a row was updated, False if channel not found.
        """
        ts = timestamp if timestamp is not None else int(time.time())
-        cursor = await db.conn.execute(
-            "UPDATE channels SET last_read_at = ? WHERE key = ?",
-            (ts, key.upper()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE channels SET last_read_at = ? WHERE key = ?",
+                (ts, key.upper()),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount > 0

    @staticmethod
    async def update_flood_scope_override(key: str, flood_scope_override: str | None) -> bool:
        """Set or clear a channel's flood-scope override."""
-        cursor = await db.conn.execute(
-            "UPDATE channels SET flood_scope_override = ? WHERE key = ?",
-            (flood_scope_override, key.upper()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE channels SET flood_scope_override = ? WHERE key = ?",
+                (flood_scope_override, key.upper()),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount > 0

    @staticmethod
    async def update_path_hash_mode_override(key: str, path_hash_mode_override: int | None) -> bool:
        """Set or clear a channel's path hash mode override."""
-        cursor = await db.conn.execute(
-            "UPDATE channels SET path_hash_mode_override = ? WHERE key = ?",
-            (path_hash_mode_override, key.upper()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE channels SET path_hash_mode_override = ? WHERE key = ?",
+                (path_hash_mode_override, key.upper()),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount > 0

    @staticmethod
    async def mark_all_read(timestamp: int) -> None:
        """Mark all channels as read at the given timestamp."""
-        await db.conn.execute("UPDATE channels SET last_read_at = ?", (timestamp,))
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute("UPDATE channels SET last_read_at = ?", (timestamp,)):
+                pass
@@ -61,66 +61,72 @@ class ContactRepository:
            )
        )

-        await db.conn.execute(
-            """
-            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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            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,
-                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
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                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,
+                    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
+                    ),
+                    route_override_len = COALESCE(
+                        excluded.route_override_len, contacts.route_override_len
+                    ),
+                    route_override_hash_mode = COALESCE(
+                        excluded.route_override_hash_mode, contacts.route_override_hash_mode
+                    ),
+                    last_advert = COALESCE(excluded.last_advert, contacts.last_advert),
+                    lat = COALESCE(excluded.lat, contacts.lat),
+                    lon = COALESCE(excluded.lon, contacts.lon),
+                    last_seen = CASE
+                        WHEN excluded.last_seen IS NULL THEN contacts.last_seen
+                        WHEN contacts.last_seen IS NULL THEN excluded.last_seen
+                        WHEN excluded.last_seen > contacts.last_seen THEN excluded.last_seen
+                        ELSE contacts.last_seen
+                    END,
+                    on_radio = COALESCE(excluded.on_radio, contacts.on_radio),
+                    last_contacted = COALESCE(excluded.last_contacted, contacts.last_contacted),
+                    first_seen = COALESCE(contacts.first_seen, excluded.first_seen)
+                """,
+                (
+                    contact_row.public_key.lower(),
+                    contact_row.name,
+                    contact_row.type,
+                    contact_row.flags,
+                    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,
+                    contact_row.last_advert,
+                    contact_row.lat,
+                    contact_row.lon,
+                    contact_row.last_seen,
+                    contact_row.on_radio,
+                    contact_row.last_contacted,
+                    contact_row.first_seen,
                ),
-                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
-                ),
-                route_override_len = COALESCE(
-                    excluded.route_override_len, contacts.route_override_len
-                ),
-                route_override_hash_mode = COALESCE(
-                    excluded.route_override_hash_mode, contacts.route_override_hash_mode
-                ),
-                last_advert = COALESCE(excluded.last_advert, contacts.last_advert),
-                lat = COALESCE(excluded.lat, contacts.lat),
-                lon = COALESCE(excluded.lon, contacts.lon),
-                last_seen = excluded.last_seen,
-                on_radio = COALESCE(excluded.on_radio, contacts.on_radio),
-                last_contacted = COALESCE(excluded.last_contacted, contacts.last_contacted),
-                first_seen = COALESCE(contacts.first_seen, excluded.first_seen)
-            """,
-            (
-                contact_row.public_key.lower(),
-                contact_row.name,
-                contact_row.type,
-                contact_row.flags,
-                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,
-                contact_row.last_advert,
-                contact_row.lat,
-                contact_row.lon,
-                contact_row.last_seen if contact_row.last_seen is not None else int(time.time()),
-                contact_row.on_radio,
-                contact_row.last_contacted,
-                contact_row.first_seen,
-            ),
-        )
-        await db.conn.commit()
+            ):
+                pass

    @staticmethod
    def _row_to_contact(row) -> Contact:
@@ -178,10 +184,11 @@ class ContactRepository:

    @staticmethod
    async def get_by_key(public_key: str) -> Contact | None:
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE public_key = ?", (public_key.lower(),)
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM contacts WHERE public_key = ?", (public_key.lower(),)
+            ) as cursor:
+                row = await cursor.fetchone()
        return ContactRepository._row_to_contact(row) if row else None

    @staticmethod
@@ -195,11 +202,12 @@ class ContactRepository:
        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}%",),
-        )
-        rows = list(await cursor.fetchall())
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT 2",
+                (f"{normalized_prefix}%",),
+            ) as cursor:
+                rows = list(await cursor.fetchall())
        if len(rows) != 1:
            return None
        return ContactRepository._row_to_contact(rows[0])
@@ -207,11 +215,12 @@ class ContactRepository:
    @staticmethod
    async def _get_prefix_matches(prefix: str, limit: int = 2) -> list[Contact]:
        """Get contacts matching a key prefix, up to limit."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT ?",
-            (f"{prefix.lower()}%", limit),
-        )
-        rows = list(await cursor.fetchall())
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM contacts WHERE public_key LIKE ? ORDER BY public_key LIMIT ?",
+                (f"{prefix.lower()}%", limit),
+            ) as cursor:
+                rows = list(await cursor.fetchall())
        return [ContactRepository._row_to_contact(row) for row in rows]

    @staticmethod
@@ -237,8 +246,9 @@ class ContactRepository:
    @staticmethod
    async def get_by_name(name: str) -> list[Contact]:
        """Get all contacts with the given exact name."""
-        cursor = await db.conn.execute("SELECT * FROM contacts WHERE name = ?", (name,))
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute("SELECT * FROM contacts WHERE name = ?", (name,)) as cursor:
+                rows = await cursor.fetchall()
        return [ContactRepository._row_to_contact(row) for row in rows]

    @staticmethod
@@ -254,8 +264,9 @@ class ContactRepository:
        normalized = [p.lower() for p in prefixes]
        conditions = " OR ".join(["public_key LIKE ?"] * len(normalized))
        params = [f"{p}%" for p in normalized]
-        cursor = await db.conn.execute(f"SELECT * FROM contacts WHERE {conditions}", params)
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(f"SELECT * FROM contacts WHERE {conditions}", params) as cursor:
+                rows = await cursor.fetchall()
        # Group by which prefix each row matches
        prefix_to_rows: dict[str, list] = {p: [] for p in normalized}
        for row in rows:
@@ -272,41 +283,67 @@ class ContactRepository:

    @staticmethod
    async def get_all(limit: int = 100, offset: int = 0) -> list[Contact]:
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts ORDER BY COALESCE(name, public_key) LIMIT ? OFFSET ?",
-            (limit, offset),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM contacts ORDER BY COALESCE(name, public_key) LIMIT ? OFFSET ?",
+                (limit, offset),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [ContactRepository._row_to_contact(row) for row in rows]

    @staticmethod
    async def get_recently_contacted_non_repeaters(limit: int = 200) -> list[Contact]:
        """Get recently interacted-with non-repeater contacts."""
-        cursor = await db.conn.execute(
-            """
-            SELECT * FROM contacts
-            WHERE type != 2 AND last_contacted IS NOT NULL AND length(public_key) = 64
-            ORDER BY last_contacted DESC
-            LIMIT ?
-            """,
-            (limit,),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT * FROM contacts
+                WHERE type != 2 AND last_contacted IS NOT NULL AND length(public_key) = 64
+                ORDER BY last_contacted DESC
+                LIMIT ?
+                """,
+                (limit,),
+            ) as cursor:
+                rows = await cursor.fetchall()
+        return [ContactRepository._row_to_contact(row) for row in rows]
+
+    @staticmethod
+    async def get_recently_dm_active_non_repeaters(limit: int = 200) -> list[Contact]:
+        """Get non-repeater contacts with the most recent DM activity (sent or received)."""
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT c.*
+                FROM contacts c
+                INNER JOIN (
+                    SELECT conversation_key, MAX(received_at) AS last_dm
+                    FROM messages
+                    WHERE type = 'PRIV'
+                    GROUP BY conversation_key
+                ) m ON c.public_key = m.conversation_key
+                WHERE c.type != 2 AND length(c.public_key) = 64
+                ORDER BY m.last_dm DESC
+                LIMIT ?
+                """,
+                (limit,),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [ContactRepository._row_to_contact(row) for row in rows]

    @staticmethod
    async def get_recently_advertised_non_repeaters(limit: int = 200) -> list[Contact]:
        """Get recently advert-heard non-repeater contacts."""
-        cursor = await db.conn.execute(
-            """
-            SELECT * FROM contacts
-            WHERE type != 2 AND last_advert IS NOT NULL AND length(public_key) = 64
-            ORDER BY last_advert DESC
-            LIMIT ?
-            """,
-            (limit,),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT * FROM contacts
+                WHERE type != 2 AND last_advert IS NOT NULL AND length(public_key) = 64
+                ORDER BY last_advert DESC
+                LIMIT ?
+                """,
+                (limit,),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [ContactRepository._row_to_contact(row) for row in rows]

    @staticmethod
@@ -317,27 +354,44 @@ class ContactRepository:
        path_hash_mode: int | None = None,
        updated_at: int | None = None,
    ) -> None:
+        """Persist a learned direct route for a contact.
+
+        Both callers (the RF PATH packet processor and the firmware PATH_UPDATE
+        event handler) are RF-backed: firmware ``onContactPathUpdated`` only
+        fires from ``onContactPathRecv`` during RF PATH packet reception. So
+        this method also advances ``last_seen`` monotonically. Never moves
+        ``last_seen`` backwards if an out-of-order arrival lands with an older
+        timestamp.
+        """
        normalized_path, normalized_path_len, normalized_hash_mode = normalize_contact_route(
            path,
            path_len,
            path_hash_mode,
        )
        ts = updated_at if updated_at is not None else int(time.time())
-        await db.conn.execute(
-            """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,
-                ts,
-                ts,
-                public_key.lower(),
-            ),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """UPDATE contacts SET direct_path = ?, direct_path_len = ?,
+                   direct_path_hash_mode = COALESCE(?, direct_path_hash_mode),
+                   direct_path_updated_at = ?,
+                   last_seen = CASE
+                       WHEN last_seen IS NULL THEN ?
+                       WHEN ? > last_seen THEN ?
+                       ELSE last_seen
+                   END
+                   WHERE public_key = ?""",
+                (
+                    normalized_path,
+                    normalized_path_len,
+                    normalized_hash_mode,
+                    ts,
+                    ts,
+                    ts,
+                    ts,
+                    public_key.lower(),
+                ),
+            ):
+                pass

    @staticmethod
    async def set_routing_override(
@@ -351,65 +405,71 @@ class ContactRepository:
            path_len,
            path_hash_mode,
        )
-        await db.conn.execute(
-            """
-            UPDATE contacts
-            SET route_override_path = ?, route_override_len = ?, route_override_hash_mode = ?
-            WHERE public_key = ?
-            """,
-            (
-                normalized_path,
-                normalized_len,
-                normalized_hash_mode,
-                public_key.lower(),
-            ),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                UPDATE contacts
+                SET route_override_path = ?, route_override_len = ?, route_override_hash_mode = ?
+                WHERE public_key = ?
+                """,
+                (
+                    normalized_path,
+                    normalized_len,
+                    normalized_hash_mode,
+                    public_key.lower(),
+                ),
+            ):
+                pass

    @staticmethod
    async def clear_routing_override(public_key: str) -> None:
-        await db.conn.execute(
-            """
-            UPDATE contacts
-            SET route_override_path = NULL,
-                route_override_len = NULL,
-                route_override_hash_mode = NULL
-            WHERE public_key = ?
-            """,
-            (public_key.lower(),),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                UPDATE contacts
+                SET route_override_path = NULL,
+                    route_override_len = NULL,
+                    route_override_hash_mode = NULL
+                WHERE public_key = ?
+                """,
+                (public_key.lower(),),
+            ):
+                pass

    @staticmethod
    async def clear_on_radio_except(keep_keys: list[str]) -> None:
        """Set on_radio=False for all contacts NOT in keep_keys."""
-        if not keep_keys:
-            await db.conn.execute("UPDATE contacts SET on_radio = 0 WHERE on_radio = 1")
-        else:
-            placeholders = ",".join("?" * len(keep_keys))
-            await db.conn.execute(
-                f"UPDATE contacts SET on_radio = 0 WHERE on_radio = 1 AND public_key NOT IN ({placeholders})",
-                keep_keys,
-            )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            if not keep_keys:
+                async with conn.execute("UPDATE contacts SET on_radio = 0 WHERE on_radio = 1"):
+                    pass
+            else:
+                placeholders = ",".join("?" * len(keep_keys))
+                async with conn.execute(
+                    f"UPDATE contacts SET on_radio = 0 WHERE on_radio = 1 AND public_key NOT IN ({placeholders})",
+                    keep_keys,
+                ):
+                    pass

    @staticmethod
    async def get_favorites() -> list[Contact]:
        """Return all contacts marked as favorite."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE favorite = 1 AND LENGTH(public_key) = 64"
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM contacts WHERE favorite = 1 AND LENGTH(public_key) = 64"
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [ContactRepository._row_to_contact(row) for row in rows]

    @staticmethod
    async def set_favorite(public_key: str, value: bool) -> None:
        """Set or clear the favorite flag for a contact."""
-        await db.conn.execute(
-            "UPDATE contacts SET favorite = ? WHERE public_key = ?",
-            (1 if value else 0, public_key.lower()),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE contacts SET favorite = ? WHERE public_key = ?",
+                (1 if value else 0, public_key.lower()),
+            ):
+                pass

    @staticmethod
    async def delete(public_key: str) -> None:
@@ -417,18 +477,53 @@ class ContactRepository:
        # contact_name_history and contact_advert_paths cascade via FK.
        # Messages are intentionally preserved so history re-surfaces
        # if the contact is re-added later.
-        await db.conn.execute("DELETE FROM contacts WHERE public_key = ?", (normalized,))
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute("DELETE FROM contacts WHERE public_key = ?", (normalized,)):
+                pass

    @staticmethod
    async def update_last_contacted(public_key: str, timestamp: int | None = None) -> None:
-        """Update the last_contacted timestamp for a contact."""
+        """Update the last_contacted timestamp for a contact.
+
+        ``last_contacted`` tracks the most recent direct-conversation activity
+        with this contact in either direction (incoming or outgoing DM). It is
+        the field that powers "recent conversations" ordering on the frontend.
+
+        It deliberately does not touch ``last_seen``: ``last_seen`` is reserved
+        for actual RF reception from the contact, and outgoing sends are not
+        evidence that we heard from them. RF observations from DM ingest update
+        ``last_seen`` via :meth:`touch_last_seen` on incoming DMs only.
+        """
        ts = timestamp if timestamp is not None else int(time.time())
-        await db.conn.execute(
-            "UPDATE contacts SET last_contacted = ?, last_seen = ? WHERE public_key = ?",
-            (ts, ts, public_key.lower()),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE contacts SET last_contacted = ? WHERE public_key = ?",
+                (ts, public_key.lower()),
+            ):
+                pass
+
+    @staticmethod
+    async def touch_last_seen(public_key: str, timestamp: int) -> None:
+        """Monotonically bump last_seen for a contact from an RF observation.
+
+        Never moves last_seen backwards; a no-op if the contact row does not
+        exist. Use this from packet-ingest paths that have attributed a packet
+        to a specific contact pubkey (advert, incoming DM, decrypted PATH, etc.).
+        """
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                UPDATE contacts
+                SET last_seen = CASE
+                    WHEN last_seen IS NULL THEN ?
+                    WHEN ? > last_seen THEN ?
+                    ELSE last_seen
+                END
+                WHERE public_key = ?
+                """,
+                (timestamp, timestamp, timestamp, public_key.lower()),
+            ):
+                pass

    @staticmethod
    async def update_last_read_at(public_key: str, timestamp: int | None = None) -> bool:
@@ -437,22 +532,25 @@ class ContactRepository:
        Returns True if a row was updated, False if contact not found.
        """
        ts = timestamp if timestamp is not None else int(time.time())
-        cursor = await db.conn.execute(
-            "UPDATE contacts SET last_read_at = ? WHERE public_key = ?",
-            (ts, public_key.lower()),
-        )
-        await db.conn.commit()
-        return cursor.rowcount > 0
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE contacts SET last_read_at = ? WHERE public_key = ?",
+                (ts, public_key.lower()),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return 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.
+        All operations for the promotion happen inside one ``db.tx()`` so
+        partial promotions never leak to readers between steps.
        """

-        async def migrate_child_rows(old_key: str, new_key: str) -> None:
-            await db.conn.execute(
+        async def migrate_child_rows(conn, old_key: str, new_key: str) -> None:
+            async with conn.execute(
                """
                INSERT INTO contact_name_history (public_key, name, first_seen, last_seen)
                SELECT ?, name, first_seen, last_seen
@@ -463,8 +561,9 @@ class ContactRepository:
                    last_seen = MAX(contact_name_history.last_seen, excluded.last_seen)
                """,
                (new_key, old_key),
-            )
-            await db.conn.execute(
+            ):
+                pass
+            async with conn.execute(
                """
                INSERT INTO contact_advert_paths
                    (public_key, path_hex, path_len, first_seen, last_seen, heard_count)
@@ -477,132 +576,138 @@ class ContactRepository:
                    heard_count = contact_advert_paths.heard_count + excluded.heard_count
                """,
                (new_key, old_key),
-            )
-            await db.conn.execute(
+            ):
+                pass
+            async with conn.execute(
                "DELETE FROM contact_name_history WHERE public_key = ?",
                (old_key,),
-            )
-            await db.conn.execute(
+            ):
+                pass
+            async with conn.execute(
                "DELETE FROM contact_advert_paths WHERE public_key = ?",
                (old_key,),
-            )
+            ):
+                pass

        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] = []
-
-        for row in rows:
-            old_key = row["public_key"]
-            if old_key == normalized_full_key:
-                continue
-
-            match_cursor = await db.conn.execute(
+        async with db.tx() as conn:
+            async with conn.execute(
                """
-                SELECT COUNT(*) AS match_count
+                SELECT public_key, last_seen, last_contacted, first_seen, last_read_at
                FROM contacts
-                WHERE length(public_key) = 64
-                  AND public_key LIKE ? || '%'
+                WHERE length(public_key) < 64
+                  AND ? LIKE public_key || '%'
+                ORDER BY length(public_key) DESC, public_key
                """,
-                (old_key,),
-            )
-            match_row = await match_cursor.fetchone()
-            match_count = match_row["match_count"] if match_row is not None else 0
-            if match_count != 1:
-                logger.warning(
-                    "Skipping prefix promotion for %s: %d full-key contacts match (expected 1)",
-                    old_key,
-                    match_count,
-                )
-                continue
+                (normalized_full_key,),
+            ) as cursor:
+                rows = list(await cursor.fetchall())
+            if not rows:
+                return []

-            await migrate_child_rows(old_key, normalized_full_key)
+            for row in rows:
+                old_key = row["public_key"]
+                if old_key == normalized_full_key:
+                    continue

-            # Merge timestamp metadata from the old prefix contact into the
-            # full-key contact (which all callers guarantee already exists),
-            # then delete the prefix placeholder.
-            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 = CASE
-                        WHEN contacts.last_read_at IS NULL THEN ?
-                        WHEN ? IS NULL THEN contacts.last_read_at
-                        WHEN ? > contacts.last_read_at THEN ?
-                        ELSE contacts.last_read_at
-                    END
-                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"],
-                    row["last_read_at"],
-                    row["last_read_at"],
-                    row["last_read_at"],
-                    normalized_full_key,
-                ),
-            )
-            await db.conn.execute("DELETE FROM contacts WHERE public_key = ?", (old_key,))
+                async with conn.execute(
+                    """
+                    SELECT COUNT(*) AS match_count
+                    FROM contacts
+                    WHERE length(public_key) = 64
+                      AND public_key LIKE ? || '%'
+                    """,
+                    (old_key,),
+                ) as match_cursor:
+                    match_row = await match_cursor.fetchone()
+                match_count = match_row["match_count"] if match_row is not None else 0
+                if match_count != 1:
+                    logger.warning(
+                        "Skipping prefix promotion for %s: %d full-key contacts match (expected 1)",
+                        old_key,
+                        match_count,
+                    )
+                    continue

-            promoted_keys.append(old_key)
+                await migrate_child_rows(conn, old_key, normalized_full_key)
+
+                # Merge timestamp metadata from the old prefix contact into the
+                # full-key contact (which all callers guarantee already exists),
+                # then delete the prefix placeholder.
+                async with 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 = CASE
+                            WHEN contacts.last_read_at IS NULL THEN ?
+                            WHEN ? IS NULL THEN contacts.last_read_at
+                            WHEN ? > contacts.last_read_at THEN ?
+                            ELSE contacts.last_read_at
+                        END
+                    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"],
+                        row["last_read_at"],
+                        row["last_read_at"],
+                        row["last_read_at"],
+                        normalized_full_key,
+                    ),
+                ):
+                    pass
+                async with conn.execute("DELETE FROM contacts WHERE public_key = ?", (old_key,)):
+                    pass
+
+                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."""
-        await db.conn.execute("UPDATE contacts SET last_read_at = ?", (timestamp,))
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute("UPDATE contacts SET last_read_at = ?", (timestamp,)):
+                pass

    @staticmethod
    async def get_by_pubkey_first_byte(hex_byte: str) -> list[Contact]:
        """Get contacts whose public key starts with the given hex byte (2 chars)."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM contacts WHERE substr(public_key, 1, 2) = ?",
-            (hex_byte.lower(),),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM contacts WHERE substr(public_key, 1, 2) = ?",
+                (hex_byte.lower(),),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [ContactRepository._row_to_contact(row) for row in rows]


@@ -641,71 +746,75 @@ class ContactAdvertPathRepository:
        normalized_path = path_hex.lower()
        path_len = hop_count if hop_count is not None else len(normalized_path) // 2

-        await db.conn.execute(
-            """
-            INSERT INTO contact_advert_paths
-                (public_key, path_hex, path_len, first_seen, last_seen, heard_count)
-            VALUES (?, ?, ?, ?, ?, 1)
-            ON CONFLICT(public_key, path_hex, path_len) DO UPDATE SET
-                last_seen = MAX(contact_advert_paths.last_seen, excluded.last_seen),
-                heard_count = contact_advert_paths.heard_count + 1
-            """,
-            (normalized_key, normalized_path, path_len, timestamp, timestamp),
-        )
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                INSERT INTO contact_advert_paths
+                    (public_key, path_hex, path_len, first_seen, last_seen, heard_count)
+                VALUES (?, ?, ?, ?, ?, 1)
+                ON CONFLICT(public_key, path_hex, path_len) DO UPDATE SET
+                    last_seen = MAX(contact_advert_paths.last_seen, excluded.last_seen),
+                    heard_count = contact_advert_paths.heard_count + 1
+                """,
+                (normalized_key, normalized_path, path_len, timestamp, timestamp),
+            ):
+                pass

-        # Keep only the N most recent unique paths per contact.
-        await db.conn.execute(
-            """
-            DELETE FROM contact_advert_paths
-            WHERE public_key = ?
-              AND id NOT IN (
-                  SELECT id
-                  FROM contact_advert_paths
-                  WHERE public_key = ?
-                  ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
-                  LIMIT ?
-              )
-            """,
-            (normalized_key, normalized_key, max_paths),
-        )
-        await db.conn.commit()
+            # Keep only the N most recent unique paths per contact.
+            async with conn.execute(
+                """
+                DELETE FROM contact_advert_paths
+                WHERE public_key = ?
+                  AND id NOT IN (
+                      SELECT id
+                      FROM contact_advert_paths
+                      WHERE public_key = ?
+                      ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+                      LIMIT ?
+                  )
+                """,
+                (normalized_key, normalized_key, max_paths),
+            ):
+                pass

    @staticmethod
    async def get_recent_for_contact(public_key: str, limit: int = 10) -> list[ContactAdvertPath]:
-        cursor = await db.conn.execute(
-            """
-            SELECT path_hex, path_len, first_seen, last_seen, heard_count
-            FROM contact_advert_paths
-            WHERE public_key = ?
-            ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
-            LIMIT ?
-            """,
-            (public_key.lower(), limit),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT path_hex, path_len, first_seen, last_seen, heard_count
+                FROM contact_advert_paths
+                WHERE public_key = ?
+                ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+                LIMIT ?
+                """,
+                (public_key.lower(), limit),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [ContactAdvertPathRepository._row_to_path(row) for row in rows]

    @staticmethod
    async def get_recent_for_all_contacts(
        limit_per_contact: int = 10,
    ) -> list[ContactAdvertPathSummary]:
-        cursor = await db.conn.execute(
-            """
-            SELECT public_key, path_hex, path_len, first_seen, last_seen, heard_count
-            FROM (
-                SELECT *,
-                       ROW_NUMBER() OVER (
-                           PARTITION BY public_key
-                           ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
-                       ) AS rn
-                FROM contact_advert_paths
-            )
-            WHERE rn <= ?
-            ORDER BY public_key ASC, last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
-            """,
-            (limit_per_contact,),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT public_key, path_hex, path_len, first_seen, last_seen, heard_count
+                FROM (
+                    SELECT *,
+                           ROW_NUMBER() OVER (
+                               PARTITION BY public_key
+                               ORDER BY last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+                           ) AS rn
+                    FROM contact_advert_paths
+                )
+                WHERE rn <= ?
+                ORDER BY public_key ASC, last_seen DESC, heard_count DESC, path_len ASC, path_hex ASC
+                """,
+                (limit_per_contact,),
+            ) as cursor:
+                rows = await cursor.fetchall()

        grouped: dict[str, list[ContactAdvertPath]] = {}
        for row in rows:
@@ -727,29 +836,31 @@ class ContactNameHistoryRepository:
    @staticmethod
    async def record_name(public_key: str, name: str, timestamp: int) -> None:
        """Record a name observation. Upserts: updates last_seen if name already known."""
-        await db.conn.execute(
-            """
-            INSERT INTO contact_name_history (public_key, name, first_seen, last_seen)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(public_key, name) DO UPDATE SET
-                last_seen = MAX(contact_name_history.last_seen, excluded.last_seen)
-            """,
-            (public_key.lower(), name, timestamp, timestamp),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                INSERT INTO contact_name_history (public_key, name, first_seen, last_seen)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(public_key, name) DO UPDATE SET
+                    last_seen = MAX(contact_name_history.last_seen, excluded.last_seen)
+                """,
+                (public_key.lower(), name, timestamp, timestamp),
+            ):
+                pass

    @staticmethod
    async def get_history(public_key: str) -> list[ContactNameHistory]:
-        cursor = await db.conn.execute(
-            """
-            SELECT name, first_seen, last_seen
-            FROM contact_name_history
-            WHERE public_key = ?
-            ORDER BY last_seen DESC
-            """,
-            (public_key.lower(),),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT name, first_seen, last_seen
+                FROM contact_name_history
+                WHERE public_key = ?
+                ORDER BY last_seen DESC
+                """,
+                (public_key.lower(),),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [
            ContactNameHistory(
                name=row["name"], first_seen=row["first_seen"], last_seen=row["last_seen"]
@@ -6,6 +6,8 @@ import time
 import uuid
 from typing import Any

+import aiosqlite
+
 from app.database import db

 logger = logging.getLogger(__name__)
@@ -31,26 +33,37 @@ def _row_to_dict(row: Any) -> dict[str, Any]:
    return result


+async def _get_in_conn(conn: aiosqlite.Connection, config_id: str) -> dict[str, Any] | None:
+    """Fetch a config using an already-acquired connection.
+
+    Used by ``create`` and ``update`` to return the freshly-written row
+    without re-entering the non-reentrant DB lock.
+    """
+    async with conn.execute("SELECT * FROM fanout_configs WHERE id = ?", (config_id,)) as cursor:
+        row = await cursor.fetchone()
+    if row is None:
+        return None
+    return _row_to_dict(row)
+
+
 class FanoutConfigRepository:
    """CRUD operations for fanout_configs table."""

    @staticmethod
    async def get_all() -> list[dict[str, Any]]:
        """Get all fanout configs ordered by sort_order."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM fanout_configs ORDER BY sort_order, created_at"
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM fanout_configs ORDER BY sort_order, created_at"
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [_row_to_dict(row) for row in rows]

    @staticmethod
    async def get(config_id: str) -> dict[str, Any] | None:
        """Get a single fanout config by ID."""
-        cursor = await db.conn.execute("SELECT * FROM fanout_configs WHERE id = ?", (config_id,))
-        row = await cursor.fetchone()
-        if row is None:
-            return None
-        return _row_to_dict(row)
+        async with db.readonly() as conn:
+            return await _get_in_conn(conn, config_id)

    @staticmethod
    async def create(
@@ -65,39 +78,41 @@ class FanoutConfigRepository:
        new_id = config_id or str(uuid.uuid4())
        now = int(time.time())

-        # Get next sort_order
-        cursor = await db.conn.execute(
-            "SELECT COALESCE(MAX(sort_order), -1) + 1 FROM fanout_configs"
-        )
-        row = await cursor.fetchone()
-        sort_order = row[0] if row else 0
+        async with db.tx() as conn:
+            # Determine next sort_order under the same lock as the insert,
+            # so two concurrent ``create()`` calls cannot collide.
+            async with conn.execute(
+                "SELECT COALESCE(MAX(sort_order), -1) + 1 FROM fanout_configs"
+            ) as cursor:
+                row = await cursor.fetchone()
+            sort_order = row[0] if row else 0

-        await db.conn.execute(
-            """
-            INSERT INTO fanout_configs (id, type, name, enabled, config, scope, sort_order, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-            (
-                new_id,
-                config_type,
-                name,
-                1 if enabled else 0,
-                json.dumps(config),
-                json.dumps(scope),
-                sort_order,
-                now,
-            ),
-        )
-        await db.conn.commit()
+            async with conn.execute(
+                """
+                INSERT INTO fanout_configs (id, type, name, enabled, config, scope, sort_order, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    new_id,
+                    config_type,
+                    name,
+                    1 if enabled else 0,
+                    json.dumps(config),
+                    json.dumps(scope),
+                    sort_order,
+                    now,
+                ),
+            ):
+                pass

-        result = await FanoutConfigRepository.get(new_id)
+            result = await _get_in_conn(conn, new_id)
        assert result is not None
        return result

    @staticmethod
    async def update(config_id: str, **fields: Any) -> dict[str, Any] | None:
        """Update a fanout config. Only provided fields are updated."""
-        updates = []
+        updates: list[str] = []
        params: list[Any] = []

        for field in ("name", "enabled", "config", "scope", "sort_order"):
@@ -115,23 +130,25 @@ class FanoutConfigRepository:

        params.append(config_id)
        query = f"UPDATE fanout_configs SET {', '.join(updates)} WHERE id = ?"
-        await db.conn.execute(query, params)
-        await db.conn.commit()
-
-        return await FanoutConfigRepository.get(config_id)
+        async with db.tx() as conn:
+            async with conn.execute(query, params):
+                pass
+            return await _get_in_conn(conn, config_id)

    @staticmethod
    async def delete(config_id: str) -> None:
        """Delete a fanout config."""
-        await db.conn.execute("DELETE FROM fanout_configs WHERE id = ?", (config_id,))
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute("DELETE FROM fanout_configs WHERE id = ?", (config_id,)):
+                pass
        _configs_cache.pop(config_id, None)

    @staticmethod
    async def get_enabled() -> list[dict[str, Any]]:
        """Get all enabled fanout configs."""
-        cursor = await db.conn.execute(
-            "SELECT * FROM fanout_configs WHERE enabled = 1 ORDER BY sort_order, created_at"
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM fanout_configs WHERE enabled = 1 ORDER BY sort_order, created_at"
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [_row_to_dict(row) for row in rows]
@@ -89,32 +89,34 @@ class MessageRepository:
        # Normalize sender_key to lowercase so queries can match without LOWER().
        normalized_sender_key = sender_key.lower() if sender_key else sender_key

-        cursor = await db.conn.execute(
-            """
-            INSERT OR IGNORE INTO messages (type, conversation_key, text, sender_timestamp,
-                                            received_at, paths, txt_type, signature, outgoing,
-                                            sender_name, sender_key)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-            (
-                msg_type,
-                conversation_key,
-                text,
-                sender_timestamp,
-                received_at,
-                paths_json,
-                txt_type,
-                signature,
-                outgoing,
-                sender_name,
-                normalized_sender_key,
-            ),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                INSERT OR IGNORE INTO messages (type, conversation_key, text, sender_timestamp,
+                                                received_at, paths, txt_type, signature, outgoing,
+                                                sender_name, sender_key)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    msg_type,
+                    conversation_key,
+                    text,
+                    sender_timestamp,
+                    received_at,
+                    paths_json,
+                    txt_type,
+                    signature,
+                    outgoing,
+                    sender_name,
+                    normalized_sender_key,
+                ),
+            ) as cursor:
+                rowcount = cursor.rowcount
+                lastrowid = cursor.lastrowid
        # rowcount is 0 if INSERT was ignored due to UNIQUE constraint violation
-        if cursor.rowcount == 0:
+        if rowcount == 0:
            return None
-        return cursor.lastrowid
+        return lastrowid

    @staticmethod
    async def add_path(
@@ -142,17 +144,20 @@ class MessageRepository:
        if snr is not None:
            entry["snr"] = snr
        new_entry = json.dumps(entry)
-        await db.conn.execute(
-            """UPDATE messages SET paths = json_insert(
-                COALESCE(paths, '[]'), '$[#]', json(?)
-            ) WHERE id = ?""",
-            (new_entry, message_id),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                """UPDATE messages SET paths = json_insert(
+                    COALESCE(paths, '[]'), '$[#]', json(?)
+                ) WHERE id = ?""",
+                (new_entry, message_id),
+            ):
+                pass

-        # Read back the full list for the return value
-        cursor = await db.conn.execute("SELECT paths FROM messages WHERE id = ?", (message_id,))
-        row = await cursor.fetchone()
+            # Read back the full list for the return value, same transaction.
+            async with conn.execute(
+                "SELECT paths FROM messages WHERE id = ?", (message_id,)
+            ) as cursor:
+                row = await cursor.fetchone()
        if not row or not row["paths"]:
            return []

@@ -171,23 +176,24 @@ class MessageRepository:
        only a prefix as conversation_key are updated to use the full key.
        """
        lower_key = full_key.lower()
-        cursor = await db.conn.execute(
-            """UPDATE messages SET conversation_key = ?,
-                   sender_key = CASE
-                       WHEN sender_key IS NOT NULL AND length(sender_key) < 64
-                            AND ? LIKE sender_key || '%'
-                       THEN ? ELSE sender_key END
-               WHERE type = 'PRIV' AND length(conversation_key) < 64
-               AND ? LIKE conversation_key || '%'
-               AND (
-                   SELECT COUNT(*) FROM contacts
-                   WHERE length(public_key) = 64
-                     AND public_key LIKE messages.conversation_key || '%'
-               ) = 1""",
-            (lower_key, lower_key, lower_key, lower_key),
-        )
-        await db.conn.commit()
-        return cursor.rowcount
+        async with db.tx() as conn:
+            async with conn.execute(
+                """UPDATE messages SET conversation_key = ?,
+                       sender_key = CASE
+                           WHEN sender_key IS NOT NULL AND length(sender_key) < 64
+                                AND ? LIKE sender_key || '%'
+                           THEN ? ELSE sender_key END
+                   WHERE type = 'PRIV' AND length(conversation_key) < 64
+                   AND ? LIKE conversation_key || '%'
+                   AND (
+                       SELECT COUNT(*) FROM contacts
+                       WHERE length(public_key) = 64
+                         AND public_key LIKE messages.conversation_key || '%'
+                   ) = 1""",
+                (lower_key, lower_key, lower_key, lower_key),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount

    @staticmethod
    async def backfill_channel_sender_key(public_key: str, name: str) -> int:
@@ -197,21 +203,22 @@ class MessageRepository:
        any channel messages with a matching sender_name but no sender_key
        are updated to associate them with this contact's public key.
        """
-        cursor = await db.conn.execute(
-            """UPDATE messages SET sender_key = ?
-               WHERE type = 'CHAN' AND sender_name = ? AND sender_key IS NULL
-               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
+        async with db.tx() as conn:
+            async with conn.execute(
+                """UPDATE messages SET sender_key = ?
+                   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),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount

    @staticmethod
    def _normalize_conversation_key(conversation_key: str) -> tuple[str, str]:
@@ -462,8 +469,9 @@ class MessageRepository:
                query += " OFFSET ?"
                params.append(offset)

-        cursor = await db.conn.execute(query, params)
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(query, params) as cursor:
+                rows = await cursor.fetchall()
        return [MessageRepository._row_to_message(row) for row in rows]

    @staticmethod
@@ -501,51 +509,54 @@ class MessageRepository:
        where_sql = " AND ".join(["1=1", *where_parts])

        # 1. Get the target message (must satisfy filters if provided)
-        target_cursor = await db.conn.execute(
-            f"SELECT {MessageRepository._message_select('messages')} "
-            f"FROM messages WHERE id = ? AND {where_sql}",
-            (message_id, *base_params),
-        )
-        target_row = await target_cursor.fetchone()
-        if not target_row:
-            return [], False, False
+        async with db.readonly() as conn:
+            async with conn.execute(
+                f"SELECT {MessageRepository._message_select('messages')} "
+                f"FROM messages WHERE id = ? AND {where_sql}",
+                (message_id, *base_params),
+            ) as target_cursor:
+                target_row = await target_cursor.fetchone()
+            if not target_row:
+                return [], False, False

-        target = MessageRepository._row_to_message(target_row)
+            target = MessageRepository._row_to_message(target_row)

-        # 2. Get context_size+1 messages before target (DESC)
-        before_query = f"""
-            SELECT {MessageRepository._message_select("messages")} FROM messages WHERE {where_sql}
-            AND (received_at < ? OR (received_at = ? AND id < ?))
-            ORDER BY received_at DESC, id DESC LIMIT ?
-        """
-        before_params = [
-            *base_params,
-            target.received_at,
-            target.received_at,
-            target.id,
-            context_size + 1,
-        ]
-        before_cursor = await db.conn.execute(before_query, before_params)
-        before_rows = list(await before_cursor.fetchall())
+            # 2. Get context_size+1 messages before target (DESC)
+            before_query = f"""
+                SELECT {MessageRepository._message_select("messages")} FROM messages WHERE {where_sql}
+                AND (received_at < ? OR (received_at = ? AND id < ?))
+                ORDER BY received_at DESC, id DESC LIMIT ?
+            """
+            before_params = [
+                *base_params,
+                target.received_at,
+                target.received_at,
+                target.id,
+                context_size + 1,
+            ]
+            async with conn.execute(before_query, before_params) as before_cursor:
+                before_rows = list(await before_cursor.fetchall())

-        has_older = len(before_rows) > context_size
-        before_messages = [MessageRepository._row_to_message(r) for r in before_rows[:context_size]]
+            has_older = len(before_rows) > context_size
+            before_messages = [
+                MessageRepository._row_to_message(r) for r in before_rows[:context_size]
+            ]

-        # 3. Get context_size+1 messages after target (ASC)
-        after_query = f"""
-            SELECT {MessageRepository._message_select("messages")} FROM messages WHERE {where_sql}
-            AND (received_at > ? OR (received_at = ? AND id > ?))
-            ORDER BY received_at ASC, id ASC LIMIT ?
-        """
-        after_params = [
-            *base_params,
-            target.received_at,
-            target.received_at,
-            target.id,
-            context_size + 1,
-        ]
-        after_cursor = await db.conn.execute(after_query, after_params)
-        after_rows = list(await after_cursor.fetchall())
+            # 3. Get context_size+1 messages after target (ASC)
+            after_query = f"""
+                SELECT {MessageRepository._message_select("messages")} FROM messages WHERE {where_sql}
+                AND (received_at > ? OR (received_at = ? AND id > ?))
+                ORDER BY received_at ASC, id ASC LIMIT ?
+            """
+            after_params = [
+                *base_params,
+                target.received_at,
+                target.received_at,
+                target.id,
+                context_size + 1,
+            ]
+            async with conn.execute(after_query, after_params) as after_cursor:
+                after_rows = list(await after_cursor.fetchall())

        has_newer = len(after_rows) > context_size
        after_messages = [MessageRepository._row_to_message(r) for r in after_rows[:context_size]]
@@ -556,21 +567,29 @@ class MessageRepository:

    @staticmethod
    async def increment_ack_count(message_id: int) -> int:
-        """Increment ack count and return the new value."""
-        cursor = await db.conn.execute(
-            "UPDATE messages SET acked = acked + 1 WHERE id = ? RETURNING acked", (message_id,)
-        )
-        row = await cursor.fetchone()
-        await db.conn.commit()
+        """Increment ack count and return the new value.
+
+        NOTE: ``RETURNING`` leaves the prepared statement active until the
+        row is fetched, so we MUST consume it inside the ``async with``
+        block. Without that, the commit at the end of ``db.tx()`` fails
+        with ``cannot commit transaction - SQL statements in progress``.
+        """
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE messages SET acked = acked + 1 WHERE id = ? RETURNING acked",
+                (message_id,),
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["acked"] if row else 1

    @staticmethod
    async def get_ack_and_paths(message_id: int) -> tuple[int, list[MessagePath] | None]:
        """Get the current ack count and paths for a message."""
-        cursor = await db.conn.execute(
-            "SELECT acked, paths FROM messages WHERE id = ?", (message_id,)
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT acked, paths FROM messages WHERE id = ?", (message_id,)
+            ) as cursor:
+                row = await cursor.fetchone()
        if not row:
            return 0, None
        return row["acked"], MessageRepository._parse_paths(row["paths"])
@@ -578,11 +597,12 @@ class MessageRepository:
    @staticmethod
    async def get_by_id(message_id: int) -> "Message | None":
        """Look up a message by its ID."""
-        cursor = await db.conn.execute(
-            f"SELECT {MessageRepository._message_select('messages')} FROM messages WHERE id = ?",
-            (message_id,),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                f"SELECT {MessageRepository._message_select('messages')} FROM messages WHERE id = ?",
+                (message_id,),
+            ) as cursor:
+                row = await cursor.fetchone()
        if not row:
            return None

@@ -591,11 +611,14 @@ class MessageRepository:
    @staticmethod
    async def delete_by_id(message_id: int) -> None:
        """Delete a message row by ID."""
-        await db.conn.execute(
-            "UPDATE raw_packets SET message_id = NULL WHERE message_id = ?", (message_id,)
-        )
-        await db.conn.execute("DELETE FROM messages WHERE id = ?", (message_id,))
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE raw_packets SET message_id = NULL WHERE message_id = ?",
+                (message_id,),
+            ):
+                pass
+            async with conn.execute("DELETE FROM messages WHERE id = ?", (message_id,)):
+                pass

    @staticmethod
    async def get_by_content(
@@ -618,8 +641,9 @@ class MessageRepository:
            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()
+        async with db.readonly() as conn:
+            async with conn.execute(query, params) as cursor:
+                row = await cursor.fetchone()
        if not row:
            return None

@@ -653,76 +677,6 @@ class MessageRepository:
        )
        blocked_sql = f" AND {blocked_clause}" if blocked_clause else ""

-        # Channel unreads
-        cursor = await db.conn.execute(
-            f"""
-            SELECT m.conversation_key,
-                   COUNT(*) as unread_count,
-                   SUM(CASE
-                           WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
-                           ELSE 0
-                       END) > 0 as has_mention
-            FROM messages m
-            JOIN channels c ON m.conversation_key = c.key
-            WHERE m.type = 'CHAN' AND m.outgoing = 0
-              AND m.received_at > COALESCE(c.last_read_at, 0)
-              {blocked_sql}
-            GROUP BY m.conversation_key
-            """,
-            (mention_token or "", mention_token or "", *blocked_params),
-        )
-        rows = await cursor.fetchall()
-        for row in rows:
-            state_key = f"channel-{row['conversation_key']}"
-            counts[state_key] = row["unread_count"]
-            if mention_token and row["has_mention"]:
-                mention_flags[state_key] = True
-
-        # Contact unreads
-        cursor = await db.conn.execute(
-            f"""
-            SELECT m.conversation_key,
-                   COUNT(*) as unread_count,
-                   SUM(CASE
-                           WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
-                           ELSE 0
-                       END) > 0 as has_mention
-            FROM messages m
-            LEFT 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)
-              {blocked_sql}
-            GROUP BY m.conversation_key
-            """,
-            (mention_token or "", mention_token or "", *blocked_params),
-        )
-        rows = await cursor.fetchall()
-        for row in rows:
-            state_key = f"contact-{row['conversation_key']}"
-            counts[state_key] = row["unread_count"]
-            if mention_token and row["has_mention"]:
-                mention_flags[state_key] = True
-
-        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(
@@ -730,20 +684,95 @@ class MessageRepository:
        )
        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:
-            prefix = "channel" if row["type"] == "CHAN" else "contact"
-            state_key = f"{prefix}-{row['conversation_key']}"
-            last_message_times[state_key] = row["last_message_time"]
+        # Single readonly acquisition for all 5 queries — they form one logical
+        # snapshot, and holding the lock for the batch is cheaper than acquiring
+        # it 5 times.
+        async with db.readonly() as conn:
+            # Channel unreads
+            async with conn.execute(
+                f"""
+                SELECT m.conversation_key,
+                       COUNT(*) as unread_count,
+                       SUM(CASE
+                               WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
+                               ELSE 0
+                           END) > 0 as has_mention
+                FROM messages m
+                JOIN channels c ON m.conversation_key = c.key
+                WHERE m.type = 'CHAN' AND m.outgoing = 0
+                  AND m.received_at > COALESCE(c.last_read_at, 0)
+                  AND COALESCE(c.muted, 0) = 0
+                  {blocked_sql}
+                GROUP BY m.conversation_key
+                """,
+                (mention_token or "", mention_token or "", *blocked_params),
+            ) as cursor:
+                rows = await cursor.fetchall()
+            for row in rows:
+                state_key = f"channel-{row['conversation_key']}"
+                counts[state_key] = row["unread_count"]
+                if mention_token and row["has_mention"]:
+                    mention_flags[state_key] = True
+
+            # Contact unreads
+            async with conn.execute(
+                f"""
+                SELECT m.conversation_key,
+                       COUNT(*) as unread_count,
+                       SUM(CASE
+                               WHEN ? <> '' AND INSTR(LOWER(m.text), LOWER(?)) > 0 THEN 1
+                               ELSE 0
+                           END) > 0 as has_mention
+                FROM messages m
+                LEFT 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)
+                  {blocked_sql}
+                GROUP BY m.conversation_key
+                """,
+                (mention_token or "", mention_token or "", *blocked_params),
+            ) as cursor:
+                rows = await cursor.fetchall()
+            for row in rows:
+                state_key = f"contact-{row['conversation_key']}"
+                counts[state_key] = row["unread_count"]
+                if mention_token and row["has_mention"]:
+                    mention_flags[state_key] = True
+
+            async with conn.execute(
+                """
+                SELECT key, last_read_at
+                FROM channels
+                """
+            ) as cursor:
+                rows = await cursor.fetchall()
+            for row in rows:
+                last_read_ats[f"channel-{row['key']}"] = row["last_read_at"]
+
+            async with conn.execute(
+                """
+                SELECT public_key, last_read_at
+                FROM contacts
+                """
+            ) as cursor:
+                rows = await cursor.fetchall()
+            for row in rows:
+                last_read_ats[f"contact-{row['public_key']}"] = row["last_read_at"]
+
+            async with 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,
+            ) as cursor:
+                rows = await cursor.fetchall()
+            for row in rows:
+                prefix = "channel" if row["type"] == "CHAN" else "contact"
+                state_key = f"{prefix}-{row['conversation_key']}"
+                last_message_times[state_key] = row["last_message_time"]

        # Only include last_read_ats for conversations that actually have messages.
        # Without this filter, every contact heard via advertisement (even without
@@ -760,41 +789,45 @@ class MessageRepository:
    @staticmethod
    async def count_dm_messages(contact_key: str) -> int:
        """Count total DM messages for a contact."""
-        cursor = await db.conn.execute(
-            "SELECT COUNT(*) as cnt FROM messages WHERE type = 'PRIV' AND conversation_key = ?",
-            (contact_key.lower(),),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT COUNT(*) as cnt FROM messages WHERE type = 'PRIV' AND conversation_key = ?",
+                (contact_key.lower(),),
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["cnt"] if row else 0

    @staticmethod
    async def count_channel_messages_by_sender(sender_key: str) -> int:
        """Count channel messages sent by a specific contact."""
-        cursor = await db.conn.execute(
-            "SELECT COUNT(*) as cnt FROM messages WHERE type = 'CHAN' AND sender_key = ?",
-            (sender_key.lower(),),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT COUNT(*) as cnt FROM messages WHERE type = 'CHAN' AND sender_key = ?",
+                (sender_key.lower(),),
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["cnt"] if row else 0

    @staticmethod
    async def count_channel_messages_by_sender_name(sender_name: str) -> int:
        """Count channel messages attributed to a display name."""
-        cursor = await db.conn.execute(
-            "SELECT COUNT(*) as cnt FROM messages WHERE type = 'CHAN' AND sender_name = ?",
-            (sender_name,),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT COUNT(*) as cnt FROM messages WHERE type = 'CHAN' AND sender_name = ?",
+                (sender_name,),
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["cnt"] if row else 0

    @staticmethod
    async def get_first_channel_message_by_sender_name(sender_name: str) -> int | None:
        """Get the earliest stored channel message timestamp for a display name."""
-        cursor = await db.conn.execute(
-            "SELECT MIN(received_at) AS first_seen FROM messages WHERE type = 'CHAN' AND sender_name = ?",
-            (sender_name,),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT MIN(received_at) AS first_seen FROM messages WHERE type = 'CHAN' AND sender_name = ?",
+                (sender_name,),
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["first_seen"] if row and row["first_seen"] is not None else None

    @staticmethod
@@ -813,68 +846,76 @@ class MessageRepository:
        t_48h = now - 172800
        t_7d = now - 604800

-        cursor = await db.conn.execute(
-            """
-            SELECT COUNT(*) AS all_time,
-                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_1h,
-                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_24h,
-                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_48h,
-                SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_7d,
-                MIN(received_at) AS first_message_at,
-                COUNT(DISTINCT sender_key) AS unique_sender_count
-            FROM messages WHERE type = 'CHAN' AND conversation_key = ?
-            """,
-            (t_1h, t_24h, t_48h, t_7d, conversation_key),
-        )
-        row = await cursor.fetchone()
-        assert row is not None  # Aggregate query always returns a row
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT COUNT(*) AS all_time,
+                    SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_1h,
+                    SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_24h,
+                    SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_48h,
+                    SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) AS last_7d,
+                    MIN(received_at) AS first_message_at,
+                    COUNT(DISTINCT sender_key) AS unique_sender_count
+                FROM messages WHERE type = 'CHAN' AND conversation_key = ?
+                """,
+                (t_1h, t_24h, t_48h, t_7d, conversation_key),
+            ) as cursor:
+                row = await cursor.fetchone()
+            assert row is not None  # Aggregate query always returns a row

-        message_counts = {
-            "last_1h": row["last_1h"] or 0,
-            "last_24h": row["last_24h"] or 0,
-            "last_48h": row["last_48h"] or 0,
-            "last_7d": row["last_7d"] or 0,
-            "all_time": row["all_time"] or 0,
-        }
-
-        cursor2 = await db.conn.execute(
-            """
-            SELECT COALESCE(sender_name, sender_key, 'Unknown') AS display_name,
-                sender_key, COUNT(*) AS cnt
-            FROM messages
-            WHERE type = 'CHAN' AND conversation_key = ?
-                AND received_at >= ? AND sender_key IS NOT NULL
-            GROUP BY sender_key ORDER BY cnt DESC LIMIT 5
-            """,
-            (conversation_key, t_24h),
-        )
-        top_rows = await cursor2.fetchall()
-        top_senders = [
-            {
-                "sender_name": r["display_name"],
-                "sender_key": r["sender_key"],
-                "message_count": r["cnt"],
+            message_counts = {
+                "last_1h": row["last_1h"] or 0,
+                "last_24h": row["last_24h"] or 0,
+                "last_48h": row["last_48h"] or 0,
+                "last_7d": row["last_7d"] or 0,
+                "all_time": row["all_time"] or 0,
            }
-            for r in top_rows
-        ]

-        # Path hash width distribution for last 24h (in-Python parse of raw packet envelopes)
-        cursor3 = await db.conn.execute(
-            """
-            SELECT rp.data FROM raw_packets rp
-            JOIN messages m ON rp.message_id = m.id
-            WHERE m.type = 'CHAN' AND m.conversation_key = ?
-              AND rp.timestamp >= ?
-            """,
-            (conversation_key, t_24h),
-        )
-        rows3 = await cursor3.fetchall()
+            async with conn.execute(
+                """
+                SELECT COALESCE(sender_name, sender_key, 'Unknown') AS display_name,
+                    sender_key, COUNT(*) AS cnt
+                FROM messages
+                WHERE type = 'CHAN' AND conversation_key = ?
+                    AND received_at >= ? AND sender_key IS NOT NULL
+                GROUP BY sender_key ORDER BY cnt DESC LIMIT 5
+                """,
+                (conversation_key, t_24h),
+            ) as cursor:
+                top_rows = await cursor.fetchall()
+            top_senders = [
+                {
+                    "sender_name": r["display_name"],
+                    "sender_key": r["sender_key"],
+                    "message_count": r["cnt"],
+                }
+                for r in top_rows
+            ]
+
+            # Path hash width distribution for last 24h: fetch raw rows under
+            # the lock, then release BEFORE the CPU-bound in-Python envelope
+            # parse. Parsing can iterate thousands of rows and previously held
+            # the DB lock for the whole traversal — blocking every other repo
+            # caller on a Pi. Keep the lock only for the fetch.
+            async with conn.execute(
+                """
+                SELECT rp.data FROM raw_packets rp
+                JOIN messages m ON rp.message_id = m.id
+                WHERE m.type = 'CHAN' AND m.conversation_key = ?
+                  AND rp.timestamp >= ?
+                """,
+                (conversation_key, t_24h),
+            ) as cursor:
+                rows3 = await cursor.fetchall()
+            first_message_at = row["first_message_at"]
+            unique_sender_count = row["unique_sender_count"] or 0
+
        path_hash_width_24h = bucket_path_hash_widths(rows3)

        return {
            "message_counts": message_counts,
-            "first_message_at": row["first_message_at"],
-            "unique_sender_count": row["unique_sender_count"] or 0,
+            "first_message_at": first_message_at,
+            "unique_sender_count": unique_sender_count,
            "top_senders_24h": top_senders,
            "path_hash_width_24h": path_hash_width_24h,
        }
@@ -882,14 +923,15 @@ class MessageRepository:
    @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()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT COUNT(DISTINCT conversation_key) AS cnt
+                FROM messages
+                WHERE type = 'CHAN' AND outgoing = 0
+                """
+            ) as cursor:
+                row = await cursor.fetchone()
        return int(row["cnt"]) if row and row["cnt"] is not None else 0

    @staticmethod
@@ -898,20 +940,21 @@ class MessageRepository:

        Returns list of (channel_key, channel_name, message_count) tuples.
        """
-        cursor = await db.conn.execute(
-            """
-            SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
-                   COUNT(*) AS cnt
-            FROM messages m
-            LEFT JOIN channels c ON m.conversation_key = c.key
-            WHERE m.type = 'CHAN' AND m.sender_key = ?
-            GROUP BY m.conversation_key
-            ORDER BY cnt DESC
-            LIMIT ?
-            """,
-            (sender_key.lower(), limit),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
+                       COUNT(*) AS cnt
+                FROM messages m
+                LEFT JOIN channels c ON m.conversation_key = c.key
+                WHERE m.type = 'CHAN' AND m.sender_key = ?
+                GROUP BY m.conversation_key
+                ORDER BY cnt DESC
+                LIMIT ?
+                """,
+                (sender_key.lower(), limit),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [(row["conversation_key"], row["channel_name"], row["cnt"]) for row in rows]

    @staticmethod
@@ -919,34 +962,36 @@ class MessageRepository:
        sender_name: str, limit: int = 5
    ) -> list[tuple[str, str, int]]:
        """Get channels where a display name has sent the most messages."""
-        cursor = await db.conn.execute(
-            """
-            SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
-                   COUNT(*) AS cnt
-            FROM messages m
-            LEFT JOIN channels c ON m.conversation_key = c.key
-            WHERE m.type = 'CHAN' AND m.sender_name = ?
-            GROUP BY m.conversation_key
-            ORDER BY cnt DESC
-            LIMIT ?
-            """,
-            (sender_name, limit),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
+                       COUNT(*) AS cnt
+                FROM messages m
+                LEFT JOIN channels c ON m.conversation_key = c.key
+                WHERE m.type = 'CHAN' AND m.sender_name = ?
+                GROUP BY m.conversation_key
+                ORDER BY cnt DESC
+                LIMIT ?
+                """,
+                (sender_name, limit),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [(row["conversation_key"], row["channel_name"], row["cnt"]) for row in rows]

    @staticmethod
    async def _get_activity_hour_buckets(where_sql: str, params: list[Any]) -> dict[int, int]:
-        cursor = await db.conn.execute(
-            f"""
-            SELECT received_at / 3600 AS hour_bucket, COUNT(*) AS cnt
-            FROM messages
-            WHERE {where_sql}
-            GROUP BY hour_bucket
-            """,
-            params,
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                f"""
+                SELECT received_at / 3600 AS hour_bucket, COUNT(*) AS cnt
+                FROM messages
+                WHERE {where_sql}
+                GROUP BY hour_bucket
+                """,
+                params,
+            ) as cursor:
+                rows = await cursor.fetchall()
        return {int(row["hour_bucket"]): row["cnt"] for row in rows}

    @staticmethod
@@ -1000,16 +1045,17 @@ class MessageRepository:
        current_day_start = (now // 86400) * 86400
        start = current_day_start - (weeks - 1) * bucket_seconds

-        cursor = await db.conn.execute(
-            f"""
-            SELECT (received_at - ?) / ? AS bucket_idx, COUNT(*) AS cnt
-            FROM messages
-            WHERE {where_sql} AND received_at >= ?
-            GROUP BY bucket_idx
-            """,
-            [start, bucket_seconds, *params, start],
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                f"""
+                SELECT (received_at - ?) / ? AS bucket_idx, COUNT(*) AS cnt
+                FROM messages
+                WHERE {where_sql} AND received_at >= ?
+                GROUP BY bucket_idx
+                """,
+                [start, bucket_seconds, *params, start],
+            ) as cursor:
+                rows = await cursor.fetchall()
        counts = {int(row["bucket_idx"]): row["cnt"] for row in rows}

        return [
@@ -0,0 +1,162 @@
+"""Repository for push_subscriptions table."""
+
+import logging
+import time
+import uuid
+from typing import Any
+
+from app.database import db
+
+logger = logging.getLogger(__name__)
+
+# Auto-delete subscriptions that have failed this many times consecutively
+# without any successful delivery in between.
+MAX_CONSECUTIVE_FAILURES = 15
+
+
+def _row_to_dict(row: Any) -> dict[str, Any]:
+    return {
+        "id": row["id"],
+        "endpoint": row["endpoint"],
+        "p256dh": row["p256dh"],
+        "auth": row["auth"],
+        "label": row["label"] or "",
+        "created_at": row["created_at"] or 0,
+        "last_success_at": row["last_success_at"],
+        "failure_count": row["failure_count"] or 0,
+    }
+
+
+class PushSubscriptionRepository:
+    @staticmethod
+    async def create(
+        endpoint: str,
+        p256dh: str,
+        auth: str,
+        label: str = "",
+    ) -> dict[str, Any]:
+        """Create or upsert a push subscription (keyed by endpoint)."""
+        sub_id = str(uuid.uuid4())
+        now = int(time.time())
+
+        async with db.tx() as conn:
+            await conn.execute(
+                """
+                INSERT INTO push_subscriptions
+                    (id, endpoint, p256dh, auth, label, created_at, failure_count)
+                VALUES (?, ?, ?, ?, ?, ?, 0)
+                ON CONFLICT(endpoint) DO UPDATE SET
+                    p256dh = excluded.p256dh,
+                    auth = excluded.auth,
+                    label = CASE WHEN excluded.label != '' THEN excluded.label
+                                 ELSE push_subscriptions.label END,
+                    failure_count = 0
+                """,
+                (sub_id, endpoint, p256dh, auth, label, now),
+            )
+            async with conn.execute(
+                "SELECT * FROM push_subscriptions WHERE endpoint = ?", (endpoint,)
+            ) as cursor:
+                row = await cursor.fetchone()
+
+        return _row_to_dict(row) if row else {"id": sub_id}  # type: ignore[arg-type]
+
+    @staticmethod
+    async def get(subscription_id: str) -> dict[str, Any] | None:
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM push_subscriptions WHERE id = ?", (subscription_id,)
+            ) as cursor:
+                row = await cursor.fetchone()
+        return _row_to_dict(row) if row else None
+
+    @staticmethod
+    async def get_by_endpoint(endpoint: str) -> dict[str, Any] | None:
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM push_subscriptions WHERE endpoint = ?", (endpoint,)
+            ) as cursor:
+                row = await cursor.fetchone()
+        return _row_to_dict(row) if row else None
+
+    @staticmethod
+    async def get_all() -> list[dict[str, Any]]:
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT * FROM push_subscriptions ORDER BY created_at DESC"
+            ) as cursor:
+                rows = await cursor.fetchall()
+        return [_row_to_dict(row) for row in rows]
+
+    @staticmethod
+    async def update(subscription_id: str, **fields: Any) -> dict[str, Any] | None:
+        updates: list[str] = []
+        params: list[Any] = []
+
+        if "label" in fields:
+            updates.append("label = ?")
+            params.append(fields["label"])
+
+        if not updates:
+            return await PushSubscriptionRepository.get(subscription_id)
+
+        params.append(subscription_id)
+        async with db.tx() as conn:
+            await conn.execute(
+                f"UPDATE push_subscriptions SET {', '.join(updates)} WHERE id = ?",
+                params,
+            )
+            async with conn.execute(
+                "SELECT * FROM push_subscriptions WHERE id = ?", (subscription_id,)
+            ) as cursor:
+                row = await cursor.fetchone()
+        return _row_to_dict(row) if row else None
+
+    @staticmethod
+    async def delete(subscription_id: str) -> bool:
+        async with db.tx() as conn:
+            async with conn.execute(
+                "DELETE FROM push_subscriptions WHERE id = ?", (subscription_id,)
+            ) as cursor:
+                return cursor.rowcount > 0
+
+    @staticmethod
+    async def delete_by_endpoint(endpoint: str) -> bool:
+        async with db.tx() as conn:
+            async with conn.execute(
+                "DELETE FROM push_subscriptions WHERE endpoint = ?", (endpoint,)
+            ) as cursor:
+                return cursor.rowcount > 0
+
+    @staticmethod
+    async def batch_record_outcomes(
+        success_ids: list[str], failure_ids: list[str], remove_ids: list[str]
+    ) -> None:
+        """Batch-update delivery outcomes in a single transaction."""
+        now = int(time.time())
+        async with db.tx() as conn:
+            if remove_ids:
+                placeholders = ",".join("?" for _ in remove_ids)
+                await conn.execute(
+                    f"DELETE FROM push_subscriptions WHERE id IN ({placeholders})",
+                    remove_ids,
+                )
+            if success_ids:
+                placeholders = ",".join("?" for _ in success_ids)
+                await conn.execute(
+                    f"UPDATE push_subscriptions SET last_success_at = ?, failure_count = 0 "
+                    f"WHERE id IN ({placeholders})",
+                    [now, *success_ids],
+                )
+            if failure_ids:
+                placeholders = ",".join("?" for _ in failure_ids)
+                await conn.execute(
+                    f"UPDATE push_subscriptions SET failure_count = failure_count + 1 "
+                    f"WHERE id IN ({placeholders})",
+                    failure_ids,
+                )
+            # Evict subscriptions that have exceeded the failure threshold
+            await conn.execute(
+                "DELETE FROM push_subscriptions WHERE failure_count >= ?",
+                (MAX_CONSECUTIVE_FAILURES,),
+            )
@@ -34,65 +34,85 @@ class RawPacketRepository:
            # For malformed packets, hash the full data
            payload_hash = sha256(data).digest()

-        cursor = await db.conn.execute(
-            "INSERT OR IGNORE INTO raw_packets (timestamp, data, payload_hash) VALUES (?, ?, ?)",
-            (ts, data, payload_hash),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                "INSERT OR IGNORE INTO raw_packets (timestamp, data, payload_hash) VALUES (?, ?, ?)",
+                (ts, data, payload_hash),
+            ) as cursor:
+                rowcount = cursor.rowcount
+                lastrowid = cursor.lastrowid

-        if cursor.rowcount > 0:
-            assert cursor.lastrowid is not None
-            return (cursor.lastrowid, True)
+            if rowcount > 0:
+                assert lastrowid is not None
+                return (lastrowid, True)

-        # Duplicate payload — look up the existing row.
-        cursor = await db.conn.execute(
-            "SELECT id FROM raw_packets WHERE payload_hash = ?", (payload_hash,)
-        )
-        existing = await cursor.fetchone()
+            # Duplicate payload — look up the existing row (same transaction).
+            async with conn.execute(
+                "SELECT id FROM raw_packets WHERE payload_hash = ?", (payload_hash,)
+            ) as cursor:
+                existing = await cursor.fetchone()
        assert existing is not None
        return (existing["id"], False)

    @staticmethod
    async def get_undecrypted_count() -> int:
        """Get count of undecrypted packets (those without a linked message)."""
-        cursor = await db.conn.execute(
-            "SELECT COUNT(*) as count FROM raw_packets WHERE message_id IS NULL"
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT COUNT(*) as count FROM raw_packets WHERE message_id IS NULL"
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["count"] if row else 0

    @staticmethod
    async def get_oldest_undecrypted() -> int | None:
        """Get timestamp of oldest undecrypted packet, or None if none exist."""
-        cursor = await db.conn.execute(
-            "SELECT MIN(timestamp) as oldest FROM raw_packets WHERE message_id IS NULL"
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT MIN(timestamp) as oldest FROM raw_packets WHERE message_id IS NULL"
+            ) as cursor:
+                row = await cursor.fetchone()
        return row["oldest"] if row and row["oldest"] is not None else None

+    @staticmethod
+    async def _stream_undecrypted_rows(
+        batch_size: int,
+    ) -> AsyncIterator[tuple[int, bytes, int]]:
+        """Internal: keyset-paginated scan of every undecrypted raw packet.
+
+        Yields ``(id, data, timestamp)`` for each row across all batches.
+        Lock is acquired per batch only — concurrent writes can interleave
+        at batch boundaries rather than being blocked for the full scan.
+        Each batch opens a fresh cursor and consumes it fully with
+        ``fetchall()`` before releasing, so no prepared statement is alive
+        at a yield boundary.
+
+        ``last_id`` advances per row, not per yield, so external filters
+        (see ``stream_undecrypted_text_messages``) that drop rows do not
+        cause a re-scan of skipped IDs.
+        """
+        last_id = -1
+        while True:
+            async with db.readonly() as conn:
+                async with conn.execute(
+                    "SELECT id, data, timestamp FROM raw_packets "
+                    "WHERE message_id IS NULL AND id > ? ORDER BY id ASC LIMIT ?",
+                    (last_id, batch_size),
+                ) as cursor:
+                    rows = await cursor.fetchall()
+            if not rows:
+                return
+            for row in rows:
+                last_id = row["id"]
+                yield (row["id"], bytes(row["data"]), row["timestamp"])
+
    @staticmethod
    async def stream_all_undecrypted(
        batch_size: int = UNDECRYPTED_PACKET_BATCH_SIZE,
    ) -> AsyncIterator[tuple[int, bytes, int]]:
-        """Yield all undecrypted packets as (id, data, timestamp) in bounded batches.
-
-        Uses keyset pagination so each batch is a fresh query with a fully
-        consumed cursor — no open statement held across yield boundaries.
-        """
-        last_id = -1
-        while True:
-            cursor = await db.conn.execute(
-                "SELECT id, data, timestamp FROM raw_packets "
-                "WHERE message_id IS NULL AND id > ? ORDER BY id ASC LIMIT ?",
-                (last_id, batch_size),
-            )
-            rows = await cursor.fetchall()
-            await cursor.close()
-            if not rows:
-                break
-            for row in rows:
-                last_id = row["id"]
-                yield (row["id"], bytes(row["data"]), row["timestamp"])
+        """Yield all undecrypted packets as (id, data, timestamp) in bounded batches."""
+        async for row in RawPacketRepository._stream_undecrypted_rows(batch_size):
+            yield row

    @staticmethod
    async def stream_undecrypted_text_messages(
@@ -100,26 +120,15 @@ class RawPacketRepository:
    ) -> AsyncIterator[tuple[int, bytes, int]]:
        """Yield undecrypted TEXT_MESSAGE packets in bounded-size batches.

-        Uses keyset pagination so each batch is a fresh query with a fully
-        consumed cursor — no open statement held across yield boundaries.
+        Filters the shared scan to rows whose payload parses as a text
+        message. Non-matching rows still advance the keyset cursor so they
+        aren't re-fetched on subsequent batches.
        """
-        last_id = -1
-        while True:
-            cursor = await db.conn.execute(
-                "SELECT id, data, timestamp FROM raw_packets "
-                "WHERE message_id IS NULL AND id > ? ORDER BY id ASC LIMIT ?",
-                (last_id, batch_size),
-            )
-            rows = await cursor.fetchall()
-            await cursor.close()
-            if not rows:
-                break
-            for row in rows:
-                last_id = row["id"]
-                data = bytes(row["data"])
-                payload_type = get_packet_payload_type(data)
-                if payload_type == PayloadType.TEXT_MESSAGE:
-                    yield (row["id"], data, row["timestamp"])
+        async for packet_id, data, timestamp in RawPacketRepository._stream_undecrypted_rows(
+            batch_size
+        ):
+            if get_packet_payload_type(data) == PayloadType.TEXT_MESSAGE:
+                yield (packet_id, data, timestamp)

    @staticmethod
    async def count_undecrypted_text_messages(
@@ -136,20 +145,22 @@ class RawPacketRepository:
    @staticmethod
    async def mark_decrypted(packet_id: int, message_id: int) -> None:
        """Link a raw packet to its decrypted message."""
-        await db.conn.execute(
-            "UPDATE raw_packets SET message_id = ? WHERE id = ?",
-            (message_id, packet_id),
-        )
-        await db.conn.commit()
+        async with db.tx() as conn:
+            async with conn.execute(
+                "UPDATE raw_packets SET message_id = ? WHERE id = ?",
+                (message_id, packet_id),
+            ):
+                pass

    @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()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT message_id FROM raw_packets WHERE id = ?",
+                (packet_id,),
+            ) as cursor:
+                row = await cursor.fetchone()
        if not row:
            return None
        return row["message_id"]
@@ -157,11 +168,12 @@ class RawPacketRepository:
    @staticmethod
    async def get_by_id(packet_id: int) -> tuple[int, bytes, int, int | None] | None:
        """Return a raw packet row as (id, data, timestamp, message_id)."""
-        cursor = await db.conn.execute(
-            "SELECT id, data, timestamp, message_id FROM raw_packets WHERE id = ?",
-            (packet_id,),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT id, data, timestamp, message_id FROM raw_packets WHERE id = ?",
+                (packet_id,),
+            ) as cursor:
+                row = await cursor.fetchone()
        if not row:
            return None
        return (row["id"], bytes(row["data"]), row["timestamp"], row["message_id"])
@@ -170,16 +182,20 @@ class RawPacketRepository:
    async def prune_old_undecrypted(max_age_days: int) -> int:
        """Delete undecrypted packets older than max_age_days. Returns count deleted."""
        cutoff = int(time.time()) - (max_age_days * 86400)
-        cursor = await db.conn.execute(
-            "DELETE FROM raw_packets WHERE message_id IS NULL AND timestamp < ?",
-            (cutoff,),
-        )
-        await db.conn.commit()
-        return cursor.rowcount
+        async with db.tx() as conn:
+            async with conn.execute(
+                "DELETE FROM raw_packets WHERE message_id IS NULL AND timestamp < ?",
+                (cutoff,),
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount

    @staticmethod
    async def purge_linked_to_messages() -> int:
        """Delete raw packets that are already linked to a stored message."""
-        cursor = await db.conn.execute("DELETE FROM raw_packets WHERE message_id IS NOT NULL")
-        await db.conn.commit()
-        return cursor.rowcount
+        async with db.tx() as conn:
+            async with conn.execute(
+                "DELETE FROM raw_packets WHERE message_id IS NOT NULL"
+            ) as cursor:
+                rowcount = cursor.rowcount
+        return rowcount
@@ -21,51 +21,54 @@ class RepeaterTelemetryRepository:
        data: dict,
    ) -> None:
        """Insert a telemetry history row and prune stale entries."""
-        await db.conn.execute(
-            """
-            INSERT INTO repeater_telemetry_history
-                (public_key, timestamp, data)
-            VALUES (?, ?, ?)
-            """,
-            (public_key, timestamp, json.dumps(data)),
-        )
-
-        # Prune entries older than 30 days
        cutoff = int(time.time()) - _MAX_AGE_SECONDS
-        await db.conn.execute(
-            "DELETE FROM repeater_telemetry_history WHERE public_key = ? AND timestamp < ?",
-            (public_key, cutoff),
-        )
+        async with db.tx() as conn:
+            async with conn.execute(
+                """
+                INSERT INTO repeater_telemetry_history
+                    (public_key, timestamp, data)
+                VALUES (?, ?, ?)
+                """,
+                (public_key, timestamp, json.dumps(data)),
+            ):
+                pass

-        # Cap at _MAX_ENTRIES_PER_REPEATER (keep newest)
-        await db.conn.execute(
-            """
-            DELETE FROM repeater_telemetry_history
-            WHERE public_key = ? AND id NOT IN (
-                SELECT id FROM repeater_telemetry_history
-                WHERE public_key = ?
-                ORDER BY timestamp DESC
-                LIMIT ?
-            )
-            """,
-            (public_key, public_key, _MAX_ENTRIES_PER_REPEATER),
-        )
+            # Prune entries older than 30 days
+            async with conn.execute(
+                "DELETE FROM repeater_telemetry_history WHERE public_key = ? AND timestamp < ?",
+                (public_key, cutoff),
+            ):
+                pass

-        await db.conn.commit()
+            # Cap at _MAX_ENTRIES_PER_REPEATER (keep newest)
+            async with conn.execute(
+                """
+                DELETE FROM repeater_telemetry_history
+                WHERE public_key = ? AND id NOT IN (
+                    SELECT id FROM repeater_telemetry_history
+                    WHERE public_key = ?
+                    ORDER BY timestamp DESC
+                    LIMIT ?
+                )
+                """,
+                (public_key, public_key, _MAX_ENTRIES_PER_REPEATER),
+            ):
+                pass

    @staticmethod
    async def get_history(public_key: str, since_timestamp: int) -> list[dict]:
        """Return telemetry rows for a repeater since a given timestamp, ordered ASC."""
-        cursor = await db.conn.execute(
-            """
-            SELECT timestamp, data
-            FROM repeater_telemetry_history
-            WHERE public_key = ? AND timestamp >= ?
-            ORDER BY timestamp ASC
-            """,
-            (public_key, since_timestamp),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT timestamp, data
+                FROM repeater_telemetry_history
+                WHERE public_key = ? AND timestamp >= ?
+                ORDER BY timestamp ASC
+                """,
+                (public_key, since_timestamp),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [
            {
                "timestamp": row["timestamp"],
@@ -73,3 +76,25 @@ class RepeaterTelemetryRepository:
            }
            for row in rows
        ]
+
+    @staticmethod
+    async def get_latest(public_key: str) -> dict | None:
+        """Return the most recent telemetry row for a repeater, or None."""
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT timestamp, data
+                FROM repeater_telemetry_history
+                WHERE public_key = ?
+                ORDER BY timestamp DESC
+                LIMIT 1
+                """,
+                (public_key,),
+            ) as cursor:
+                row = await cursor.fetchone()
+        if row is None:
+            return None
+        return {
+            "timestamp": row["timestamp"],
+            "data": json.loads(row["data"]),
+        }
@@ -3,9 +3,12 @@ import logging
 import time
 from typing import Any

+import aiosqlite
+
 from app.database import db
 from app.models import AppSettings
 from app.path_utils import bucket_path_hash_widths
+from app.telemetry_interval import DEFAULT_TELEMETRY_INTERVAL_HOURS

 logger = logging.getLogger(__name__)

@@ -16,25 +19,34 @@ SECONDS_7D = 604800


 class AppSettingsRepository:
-    """Repository for app_settings table (single-row pattern)."""
+    """Repository for app_settings table (single-row pattern).
+
+    Public methods acquire the DB lock exactly once. ``toggle_*`` helpers that
+    need a read-modify-write do so inside a single ``db.tx()`` — the internal
+    ``_get_in_conn`` / ``_apply_updates`` helpers run under the caller's
+    already-held lock and must NEVER call ``db.tx()`` or ``db.readonly()``.
+    """

    @staticmethod
-    async def get() -> AppSettings:
-        """Get the current app settings.
+    async def _get_in_conn(conn: aiosqlite.Connection) -> AppSettings:
+        """Load settings using an already-acquired connection.

-        Always returns settings - creates default row if needed (migration handles initial row).
+        Used by the public ``get()`` and by multi-step operations
+        (``toggle_blocked_key``, ``toggle_blocked_name``) to avoid re-entering
+        the non-reentrant DB lock.
        """
-        cursor = await db.conn.execute(
+        async with conn.execute(
            """
            SELECT max_radio_contacts, auto_decrypt_dm_on_advert,
                   last_message_times,
                   advert_interval, last_advert_time, flood_scope,
                   blocked_keys, blocked_names, discovery_blocked_types,
-                   tracked_telemetry_repeaters, auto_resend_channel
+                   tracked_telemetry_repeaters, auto_resend_channel,
+                   telemetry_interval_hours, telemetry_routed_hourly
            FROM app_settings WHERE id = 1
            """
-        )
-        row = await cursor.fetchone()
+        ) as cursor:
+            row = await cursor.fetchone()

        if not row:
            # Should not happen after migration, but handle gracefully
@@ -91,6 +103,22 @@ class AppSettingsRepository:
        except (KeyError, TypeError):
            auto_resend_channel = False

+        # Parse telemetry_interval_hours (migration adds the column with
+        # default=8, but guard against older rows / partial migrations).
+        try:
+            raw_interval = row["telemetry_interval_hours"]
+            telemetry_interval_hours = (
+                int(raw_interval) if raw_interval is not None else DEFAULT_TELEMETRY_INTERVAL_HOURS
+            )
+        except (KeyError, TypeError, ValueError):
+            telemetry_interval_hours = DEFAULT_TELEMETRY_INTERVAL_HOURS
+
+        # Parse telemetry_routed_hourly boolean
+        try:
+            telemetry_routed_hourly = bool(row["telemetry_routed_hourly"])
+        except (KeyError, TypeError):
+            telemetry_routed_hourly = False
+
        return AppSettings(
            max_radio_contacts=row["max_radio_contacts"],
            auto_decrypt_dm_on_advert=bool(row["auto_decrypt_dm_on_advert"]),
@@ -103,10 +131,14 @@ class AppSettingsRepository:
            discovery_blocked_types=discovery_blocked_types,
            tracked_telemetry_repeaters=tracked_telemetry_repeaters,
            auto_resend_channel=auto_resend_channel,
+            telemetry_interval_hours=telemetry_interval_hours,
+            telemetry_routed_hourly=telemetry_routed_hourly,
        )

    @staticmethod
-    async def update(
+    async def _apply_updates(
+        conn: aiosqlite.Connection,
+        *,
        max_radio_contacts: int | None = None,
        auto_decrypt_dm_on_advert: bool | None = None,
        last_message_times: dict[str, int] | None = None,
@@ -118,9 +150,15 @@ class AppSettingsRepository:
        discovery_blocked_types: list[int] | None = None,
        tracked_telemetry_repeaters: list[str] | None = None,
        auto_resend_channel: bool | None = None,
-    ) -> AppSettings:
-        """Update app settings. Only provided fields are updated."""
-        updates = []
+        telemetry_interval_hours: int | None = None,
+        telemetry_routed_hourly: bool | None = None,
+    ) -> None:
+        """Apply field updates using an already-acquired connection.
+
+        Emits a single UPDATE statement inside the caller's transaction. Does
+        NOT commit — the caller's ``db.tx()`` handles that.
+        """
+        updates: list[str] = []
        params: list[Any] = []

        if max_radio_contacts is not None:
@@ -167,49 +205,192 @@ class AppSettingsRepository:
            updates.append("auto_resend_channel = ?")
            params.append(1 if auto_resend_channel else 0)

+        if telemetry_interval_hours is not None:
+            updates.append("telemetry_interval_hours = ?")
+            params.append(telemetry_interval_hours)
+
+        if telemetry_routed_hourly is not None:
+            updates.append("telemetry_routed_hourly = ?")
+            params.append(1 if telemetry_routed_hourly else 0)
+
        if updates:
            query = f"UPDATE app_settings SET {', '.join(updates)} WHERE id = 1"
-            await db.conn.execute(query, params)
-            await db.conn.commit()
+            async with conn.execute(query, params):
+                pass

-        return await AppSettingsRepository.get()
+    @staticmethod
+    async def get() -> AppSettings:
+        """Get the current app settings.
+
+        Always returns settings - creates default row if needed (migration handles initial row).
+        """
+        async with db.readonly() as conn:
+            return await AppSettingsRepository._get_in_conn(conn)
+
+    @staticmethod
+    async def update(
+        max_radio_contacts: int | None = None,
+        auto_decrypt_dm_on_advert: bool | None = None,
+        last_message_times: dict[str, int] | None = None,
+        advert_interval: int | None = None,
+        last_advert_time: int | None = None,
+        flood_scope: str | None = None,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
+        discovery_blocked_types: list[int] | None = None,
+        tracked_telemetry_repeaters: list[str] | None = None,
+        auto_resend_channel: bool | None = None,
+        telemetry_interval_hours: int | None = None,
+        telemetry_routed_hourly: bool | None = None,
+    ) -> AppSettings:
+        """Update app settings. Only provided fields are updated."""
+        async with db.tx() as conn:
+            await AppSettingsRepository._apply_updates(
+                conn,
+                max_radio_contacts=max_radio_contacts,
+                auto_decrypt_dm_on_advert=auto_decrypt_dm_on_advert,
+                last_message_times=last_message_times,
+                advert_interval=advert_interval,
+                last_advert_time=last_advert_time,
+                flood_scope=flood_scope,
+                blocked_keys=blocked_keys,
+                blocked_names=blocked_names,
+                discovery_blocked_types=discovery_blocked_types,
+                tracked_telemetry_repeaters=tracked_telemetry_repeaters,
+                auto_resend_channel=auto_resend_channel,
+                telemetry_interval_hours=telemetry_interval_hours,
+                telemetry_routed_hourly=telemetry_routed_hourly,
+            )
+            return await AppSettingsRepository._get_in_conn(conn)

    @staticmethod
    async def toggle_blocked_key(key: str) -> AppSettings:
-        """Toggle a public key in the blocked list. Keys are normalized to lowercase."""
+        """Toggle a public key in the blocked list. Keys are normalized to lowercase.
+
+        Read-modify-write is atomic under a single ``db.tx()`` lock — two
+        concurrent toggles for the same key cannot produce an inconsistent
+        intermediate state.
+        """
        normalized = key.lower()
-        settings = await AppSettingsRepository.get()
-        if normalized in settings.blocked_keys:
-            new_keys = [k for k in settings.blocked_keys if k != normalized]
-        else:
-            new_keys = settings.blocked_keys + [normalized]
-        return await AppSettingsRepository.update(blocked_keys=new_keys)
+        async with db.tx() as conn:
+            settings = await AppSettingsRepository._get_in_conn(conn)
+            if normalized in settings.blocked_keys:
+                new_keys = [k for k in settings.blocked_keys if k != normalized]
+            else:
+                new_keys = settings.blocked_keys + [normalized]
+            await AppSettingsRepository._apply_updates(conn, blocked_keys=new_keys)
+            return await AppSettingsRepository._get_in_conn(conn)

    @staticmethod
    async def toggle_blocked_name(name: str) -> AppSettings:
-        """Toggle a display name in the blocked list."""
-        settings = await AppSettingsRepository.get()
-        if name in settings.blocked_names:
-            new_names = [n for n in settings.blocked_names if n != name]
-        else:
-            new_names = settings.blocked_names + [name]
-        return await AppSettingsRepository.update(blocked_names=new_names)
+        """Toggle a display name in the blocked list.
+
+        Same atomicity guarantee as ``toggle_blocked_key``.
+        """
+        async with db.tx() as conn:
+            settings = await AppSettingsRepository._get_in_conn(conn)
+            if name in settings.blocked_names:
+                new_names = [n for n in settings.blocked_names if n != name]
+            else:
+                new_names = settings.blocked_names + [name]
+            await AppSettingsRepository._apply_updates(conn, blocked_names=new_names)
+            return await AppSettingsRepository._get_in_conn(conn)
+
+    @staticmethod
+    async def get_vapid_keys() -> tuple[str, str]:
+        """Return (private_key_pem, public_key_b64url) from app_settings.
+
+        These are internal-only columns not exposed via the AppSettings model.
+        """
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT vapid_private_key, vapid_public_key FROM app_settings WHERE id = 1"
+            ) as cursor:
+                row = await cursor.fetchone()
+        if row and row["vapid_private_key"] and row["vapid_public_key"]:
+            return row["vapid_private_key"], row["vapid_public_key"]
+        return "", ""
+
+    @staticmethod
+    async def set_vapid_keys(private_key: str, public_key: str) -> None:
+        """Persist auto-generated VAPID key pair to app_settings."""
+        async with db.tx() as conn:
+            await conn.execute(
+                "UPDATE app_settings SET vapid_private_key = ?, vapid_public_key = ? WHERE id = 1",
+                (private_key, public_key),
+            )
+
+    @staticmethod
+    async def get_push_conversations() -> list[str]:
+        """Return the global list of push-enabled conversation state keys.
+
+        Internal-only column, not exposed via the AppSettings model.
+        """
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT push_conversations FROM app_settings WHERE id = 1"
+            ) as cursor:
+                row = await cursor.fetchone()
+        if row and row["push_conversations"]:
+            try:
+                return json.loads(row["push_conversations"])
+            except (json.JSONDecodeError, TypeError):
+                return []
+        return []
+
+    @staticmethod
+    async def set_push_conversations(conversations: list[str]) -> list[str]:
+        """Replace the global push-enabled conversation list."""
+        async with db.tx() as conn:
+            await conn.execute(
+                "UPDATE app_settings SET push_conversations = ? WHERE id = 1",
+                (json.dumps(conversations),),
+            )
+        return conversations
+
+    @staticmethod
+    async def toggle_push_conversation(key: str) -> list[str]:
+        """Add or remove a conversation state key from the global push list.
+
+        Atomic read-modify-write under a single ``db.tx()`` lock.
+        """
+        async with db.tx() as conn:
+            async with conn.execute(
+                "SELECT push_conversations FROM app_settings WHERE id = 1"
+            ) as cursor:
+                row = await cursor.fetchone()
+            current: list[str] = []
+            if row and row["push_conversations"]:
+                try:
+                    current = json.loads(row["push_conversations"])
+                except (json.JSONDecodeError, TypeError):
+                    current = []
+            if key in current:
+                current = [k for k in current if k != key]
+            else:
+                current.append(key)
+            await conn.execute(
+                "UPDATE app_settings SET push_conversations = ? WHERE id = 1",
+                (json.dumps(current),),
+            )
+        return current


 class StatisticsRepository:
    @staticmethod
    async def get_database_message_totals() -> dict[str, int]:
        """Return message totals needed by lightweight debug surfaces."""
-        cursor = await db.conn.execute(
-            """
-            SELECT
-                SUM(CASE WHEN type = 'PRIV' THEN 1 ELSE 0 END) AS total_dms,
-                SUM(CASE WHEN type = 'CHAN' THEN 1 ELSE 0 END) AS total_channel_messages,
-                SUM(CASE WHEN outgoing = 1 THEN 1 ELSE 0 END) AS total_outgoing
-            FROM messages
-            """
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT
+                    SUM(CASE WHEN type = 'PRIV' THEN 1 ELSE 0 END) AS total_dms,
+                    SUM(CASE WHEN type = 'CHAN' THEN 1 ELSE 0 END) AS total_channel_messages,
+                    SUM(CASE WHEN outgoing = 1 THEN 1 ELSE 0 END) AS total_outgoing
+                FROM messages
+                """
+            ) as cursor:
+                row = await cursor.fetchone()
        assert row is not None
        return {
            "total_dms": row["total_dms"] or 0,
@@ -222,18 +403,19 @@ class StatisticsRepository:
        """Get time-windowed counts for contacts/repeaters heard."""
        now = int(time.time())
        op = "!=" if exclude else "="
-        cursor = await db.conn.execute(
-            f"""
-            SELECT
-                SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_hour,
-                SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_24_hours,
-                SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_week
-            FROM contacts
-            WHERE type {op} ? AND last_seen IS NOT NULL
-            """,
-            (now - SECONDS_1H, now - SECONDS_24H, now - SECONDS_7D, contact_type),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                f"""
+                SELECT
+                    SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_hour,
+                    SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_24_hours,
+                    SUM(CASE WHEN last_seen >= ? THEN 1 ELSE 0 END) AS last_week
+                FROM contacts
+                WHERE type {op} ? AND last_seen IS NOT NULL
+                """,
+                (now - SECONDS_1H, now - SECONDS_24H, now - SECONDS_7D, contact_type),
+            ) as cursor:
+                row = await cursor.fetchone()
        assert row is not None  # Aggregate query always returns a row
        return {
            "last_hour": row["last_hour"] or 0,
@@ -249,24 +431,25 @@ class StatisticsRepository:
        the old UPPER(...) join and aggregate per known channel directly.
        """
        now = int(time.time())
-        cursor = await db.conn.execute(
-            """
-            WITH known AS (
-                SELECT conversation_key, MAX(received_at) AS last_received_at
-                FROM messages
-                WHERE type = 'CHAN'
-                  AND conversation_key IN (SELECT key FROM channels)
-                GROUP BY conversation_key
-            )
-            SELECT
-                SUM(CASE WHEN last_received_at >= ? THEN 1 ELSE 0 END) AS last_hour,
-                SUM(CASE WHEN last_received_at >= ? THEN 1 ELSE 0 END) AS last_24_hours,
-                SUM(CASE WHEN last_received_at >= ? THEN 1 ELSE 0 END) AS last_week
-            FROM known
-            """,
-            (now - SECONDS_1H, now - SECONDS_24H, now - SECONDS_7D),
-        )
-        row = await cursor.fetchone()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                WITH known AS (
+                    SELECT conversation_key, MAX(received_at) AS last_received_at
+                    FROM messages
+                    WHERE type = 'CHAN'
+                      AND conversation_key IN (SELECT key FROM channels)
+                    GROUP BY conversation_key
+                )
+                SELECT
+                    SUM(CASE WHEN last_received_at >= ? THEN 1 ELSE 0 END) AS last_hour,
+                    SUM(CASE WHEN last_received_at >= ? THEN 1 ELSE 0 END) AS last_24_hours,
+                    SUM(CASE WHEN last_received_at >= ? THEN 1 ELSE 0 END) AS last_week
+                FROM known
+                """,
+                (now - SECONDS_1H, now - SECONDS_24H, now - SECONDS_7D),
+            ) as cursor:
+                row = await cursor.fetchone()
        assert row is not None
        return {
            "last_hour": row["last_hour"] or 0,
@@ -280,92 +463,105 @@ class StatisticsRepository:
        now = int(time.time())
        cutoff = now - SECONDS_72H
        # Bucket timestamps to the start of each hour
-        cursor = await db.conn.execute(
-            """
-            SELECT (timestamp / 3600) * 3600 AS hour_ts, COUNT(*) AS count
-            FROM raw_packets
-            WHERE timestamp >= ?
-            GROUP BY hour_ts
-            ORDER BY hour_ts
-            """,
-            (cutoff,),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                """
+                SELECT (timestamp / 3600) * 3600 AS hour_ts, COUNT(*) AS count
+                FROM raw_packets
+                WHERE timestamp >= ?
+                GROUP BY hour_ts
+                ORDER BY hour_ts
+                """,
+                (cutoff,),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return [{"timestamp": row["hour_ts"], "count": row["count"]} for row in rows]

    @staticmethod
    async def _path_hash_width_24h() -> dict[str, int | float]:
        """Count parsed raw packets from the last 24h by hop hash width."""
        now = int(time.time())
-        cursor = await db.conn.execute(
-            "SELECT data FROM raw_packets WHERE timestamp >= ?",
-            (now - SECONDS_24H,),
-        )
-        rows = await cursor.fetchall()
+        async with db.readonly() as conn:
+            async with conn.execute(
+                "SELECT data FROM raw_packets WHERE timestamp >= ?",
+                (now - SECONDS_24H,),
+            ) as cursor:
+                rows = await cursor.fetchall()
        return bucket_path_hash_widths(rows)

    @staticmethod
    async def get_all() -> dict:
-        """Aggregate all statistics from existing tables."""
+        """Aggregate all statistics from existing tables.
+
+        Each helper acquires its own lock; there's no requirement that the
+        whole snapshot be atomic. If we ever wanted a consistent snapshot
+        we'd batch all queries into a single ``db.readonly()`` and use
+        ``_in_conn`` helpers, but statistics are intentionally approximate.
+        """
        now = int(time.time())

-        # Top 5 busiest channels in last 24h
-        cursor = await db.conn.execute(
-            """
-            SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
-                   COUNT(*) AS message_count
-            FROM messages m
-            LEFT JOIN channels c ON m.conversation_key = c.key
-            WHERE m.type = 'CHAN' AND m.received_at >= ?
-            GROUP BY m.conversation_key
-            ORDER BY COUNT(*) DESC
-            LIMIT 5
-            """,
-            (now - SECONDS_24H,),
-        )
-        rows = await cursor.fetchall()
-        busiest_channels_24h = [
-            {
-                "channel_key": row["conversation_key"],
-                "channel_name": row["channel_name"],
-                "message_count": row["message_count"],
-            }
-            for row in rows
-        ]
+        async with db.readonly() as conn:
+            # Top 5 busiest channels in last 24h
+            async with conn.execute(
+                """
+                SELECT m.conversation_key, COALESCE(c.name, m.conversation_key) AS channel_name,
+                       COUNT(*) AS message_count
+                FROM messages m
+                LEFT JOIN channels c ON m.conversation_key = c.key
+                WHERE m.type = 'CHAN' AND m.received_at >= ?
+                GROUP BY m.conversation_key
+                ORDER BY COUNT(*) DESC
+                LIMIT 5
+                """,
+                (now - SECONDS_24H,),
+            ) as cursor:
+                rows = await cursor.fetchall()
+            busiest_channels_24h = [
+                {
+                    "channel_key": row["conversation_key"],
+                    "channel_name": row["channel_name"],
+                    "message_count": row["message_count"],
+                }
+                for row in rows
+            ]

-        # Entity counts
-        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM contacts WHERE type != 2")
-        row = await cursor.fetchone()
-        assert row is not None
-        contact_count: int = row["cnt"]
+            # Entity counts
+            async with conn.execute(
+                "SELECT COUNT(*) AS cnt FROM contacts WHERE type != 2"
+            ) as cursor:
+                row = await cursor.fetchone()
+            assert row is not None
+            contact_count: int = row["cnt"]

-        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM contacts WHERE type = 2")
-        row = await cursor.fetchone()
-        assert row is not None
-        repeater_count: int = row["cnt"]
+            async with conn.execute(
+                "SELECT COUNT(*) AS cnt FROM contacts WHERE type = 2"
+            ) as cursor:
+                row = await cursor.fetchone()
+            assert row is not None
+            repeater_count: int = row["cnt"]

-        cursor = await db.conn.execute("SELECT COUNT(*) AS cnt FROM channels")
-        row = await cursor.fetchone()
-        assert row is not None
-        channel_count: int = row["cnt"]
+            async with conn.execute("SELECT COUNT(*) AS cnt FROM channels") as cursor:
+                row = await cursor.fetchone()
+            assert row is not None
+            channel_count: int = row["cnt"]

-        # Packet split
-        cursor = await db.conn.execute(
-            """
-            SELECT COUNT(*) AS total,
-                   SUM(CASE WHEN message_id IS NOT NULL THEN 1 ELSE 0 END) AS decrypted
-            FROM raw_packets
-            """
-        )
-        pkt_row = await cursor.fetchone()
-        assert pkt_row is not None
-        total_packets = pkt_row["total"] or 0
-        decrypted_packets = pkt_row["decrypted"] or 0
-        undecrypted_packets = total_packets - decrypted_packets
+            # Packet split
+            async with conn.execute(
+                """
+                SELECT COUNT(*) AS total,
+                       SUM(CASE WHEN message_id IS NOT NULL THEN 1 ELSE 0 END) AS decrypted
+                FROM raw_packets
+                """
+            ) as cursor:
+                pkt_row = await cursor.fetchone()
+            assert pkt_row is not None
+            total_packets = pkt_row["total"] or 0
+            decrypted_packets = pkt_row["decrypted"] or 0
+            undecrypted_packets = total_packets - decrypted_packets

+        # These each acquire their own lock. The snapshot isn't atomic across
+        # them — fine for stats, which are approximate by nature.
        message_totals = await StatisticsRepository.get_database_message_totals()
-
-        # Activity windows
        contacts_heard = await StatisticsRepository._activity_counts(contact_type=2, exclude=True)
        repeaters_heard = await StatisticsRepository._activity_counts(contact_type=2)
        known_channels_active = await StatisticsRepository._known_channels_active()
@@ -66,11 +66,11 @@ async def _resolve_contact_or_404(


 async def _ensure_on_radio(mc, contact: Contact) -> None:
-    """Add a contact to the radio for routing, raising 500 on failure."""
+    """Add a contact to the radio for routing, raising 422 on failure."""
    add_result = await mc.commands.add_contact(contact.to_radio_dict())
    if add_result is not None and add_result.type == EventType.ERROR:
        raise HTTPException(
-            status_code=500, detail=f"Failed to add contact to radio: {add_result.payload}"
+            status_code=422, detail=f"Failed to add contact to radio: {add_result.payload}"
        )


@@ -315,6 +315,7 @@ async def create_contact(
    contact_upsert = ContactUpsert(
        public_key=lower_key,
        name=request.name,
+        type=request.type,
        on_radio=False,
    )
    await ContactRepository.upsert(contact_upsert)
@@ -451,7 +452,7 @@ async def request_trace(public_key: str) -> TraceResponse:
        )

        if result.type == EventType.ERROR:
-            raise HTTPException(status_code=500, detail=f"Failed to send trace: {result.payload}")
+            raise HTTPException(status_code=422, detail=f"Failed to send trace: {result.payload}")

        # Wait for the matching TRACE_DATA event
        event = await mc.wait_for_event(
@@ -461,7 +462,7 @@ async def request_trace(public_key: str) -> TraceResponse:
        )

    if event is None:
-        raise HTTPException(status_code=504, detail="No trace response heard")
+        raise HTTPException(status_code=408, detail="No trace response heard")

    trace = event.payload
    path = trace.get("path", [])
@@ -505,7 +506,7 @@ async def request_path_discovery(public_key: str) -> PathDiscoveryResponse:
            result = await mc.commands.send_path_discovery(contact.public_key)
            if result.type == EventType.ERROR:
                raise HTTPException(
-                    status_code=500,
+                    status_code=422,
                    detail=f"Failed to send path discovery: {result.payload}",
                )

@@ -517,7 +518,7 @@ async def request_path_discovery(public_key: str) -> PathDiscoveryResponse:
                await response_task

        if event is None:
-            raise HTTPException(status_code=504, detail="No path discovery response heard")
+            raise HTTPException(status_code=408, detail="No path discovery response heard")

        payload = event.payload
        forward_path = str(payload.get("out_path") or "")
@@ -64,7 +64,6 @@ class DebugRuntimeInfo(BaseModel):
    path_hash_mode_supported: bool
    channel_slot_reuse_enabled: bool
    channel_send_cache_capacity: int
-    remediation_flags: dict[str, bool]


 class DebugContactAudit(BaseModel):
@@ -110,6 +109,21 @@ class DebugHealthSummary(BaseModel):
    basic_auth_enabled: bool = False


+class DebugEnvironment(BaseModel):
+    connection_type: str
+    serial_port: str
+    serial_baudrate: int
+    tcp_host: str
+    tcp_port: int
+    ble_address: str
+    log_level: str
+    database_path: str
+    disable_bots: bool
+    enable_message_poll_fallback: bool
+    force_channel_slot_reconfigure: bool
+    load_with_autoevict: bool
+
+
 class DebugAppSettings(BaseModel):
    max_radio_contacts: int
    auto_decrypt_dm_on_advert: bool
@@ -123,6 +137,7 @@ class DebugSnapshotResponse(BaseModel):
    captured_at: str
    system: DebugSystemInfo
    application: DebugApplicationInfo
+    environment: DebugEnvironment
    health: DebugHealthSummary
    settings: DebugAppSettings
    runtime: DebugRuntimeInfo
@@ -203,6 +218,23 @@ def _coerce_live_max_channels(device_info: dict[str, Any] | None) -> int | None:
        return None


+def _build_environment() -> DebugEnvironment:
+    return DebugEnvironment(
+        connection_type=settings.connection_type,
+        serial_port=settings.serial_port,
+        serial_baudrate=settings.serial_baudrate,
+        tcp_host=settings.tcp_host,
+        tcp_port=settings.tcp_port,
+        ble_address=settings.ble_address,
+        log_level=settings.log_level,
+        database_path=settings.database_path,
+        disable_bots=settings.disable_bots,
+        enable_message_poll_fallback=settings.enable_message_poll_fallback,
+        force_channel_slot_reconfigure=settings.force_channel_slot_reconfigure,
+        load_with_autoevict=settings.load_with_autoevict,
+    )
+
+
 def _build_debug_app_settings(app_settings: AppSettings) -> DebugAppSettings:
    return DebugAppSettings(
        max_radio_contacts=app_settings.max_radio_contacts,
@@ -393,6 +425,7 @@ async def debug_support_snapshot() -> DebugSnapshotResponse:
        captured_at=datetime.now(UTC).isoformat(),
        system=_build_system_info(),
        application=_build_application_info(),
+        environment=_build_environment(),
        health=_build_debug_health_summary(health_data, radio_state=radio_state),
        settings=_build_debug_app_settings(app_settings),
        runtime=DebugRuntimeInfo(
@@ -404,10 +437,6 @@ async def debug_support_snapshot() -> DebugSnapshotResponse:
            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=message_totals["total_dms"],
@@ -259,6 +259,25 @@ def _validate_apprise_config(config: dict) -> None:
    if not urls or not urls.strip():
        raise HTTPException(status_code=400, detail="At least one Apprise URL is required")

+    from app.fanout.apprise_mod import FORMAT_VARIABLES, _apply_format
+
+    dummy_vars: dict[str, str] = dict.fromkeys(FORMAT_VARIABLES, "test")
+    for field in ("body_format_dm", "body_format_channel"):
+        value = config.get(field)
+        if value is not None and not isinstance(value, str):
+            raise HTTPException(status_code=400, detail=f"{field} must be a string")
+        if isinstance(value, str) and value.strip():
+            try:
+                _apply_format(value, dummy_vars)
+            except Exception:
+                raise HTTPException(
+                    status_code=400, detail=f"Invalid format string in {field}"
+                ) from None
+
+    markdown_format = config.get("markdown_format")
+    if markdown_format is not None:
+        config["markdown_format"] = bool(markdown_format)
+

 def _validate_webhook_config(config: dict) -> None:
    """Validate webhook config blob."""
@@ -40,6 +40,8 @@ class RadioStatsSnapshot(BaseModel):
    # Core stats
    battery_mv: int | None = None
    uptime_secs: int | None = None
+    queue_len: int | None = None
+    errors: int | None = None
    # Radio stats
    noise_floor: int | None = None
    last_rssi: int | None = None
@@ -155,6 +157,8 @@ async def build_health_data(radio_connected: bool, connection_info: str | None)
            "timestamp": raw_stats.get("timestamp"),
            "battery_mv": raw_stats.get("battery_mv"),
            "uptime_secs": raw_stats.get("uptime_secs"),
+            "queue_len": raw_stats.get("queue_len"),
+            "errors": raw_stats.get("errors"),
            "noise_floor": raw_stats.get("noise_floor"),
            "last_rssi": raw_stats.get("last_rssi"),
            "last_snr": raw_stats.get("last_snr"),
@@ -128,11 +128,15 @@ async def get_raw_packet(packet_id: int) -> RawPacketDetail:
                    sender=message.sender_name,
                    channel_key=message.conversation_key,
                    contact_key=message.sender_key,
+                    sender_timestamp=message.sender_timestamp,
+                    message=message.text,
                )
            else:
                decrypted_info = RawPacketDecryptedInfo(
                    sender=message.sender_name,
                    contact_key=message.conversation_key,
+                    sender_timestamp=message.sender_timestamp,
+                    message=message.text,
                )

    return RawPacketDetail(
@@ -0,0 +1,164 @@
+"""Web Push subscription management endpoints."""
+
+import asyncio
+import json
+import logging
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from pywebpush import WebPushException
+
+from app.push.send import send_push
+from app.push.vapid import get_vapid_private_key, get_vapid_public_key
+from app.repository.push_subscriptions import PushSubscriptionRepository
+from app.repository.settings import AppSettingsRepository
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/push", tags=["push"])
+
+
+# ── Request/response models ─────────────────────────────────────────────
+
+
+class VapidPublicKeyResponse(BaseModel):
+    public_key: str
+
+
+class PushSubscribeRequest(BaseModel):
+    endpoint: str = Field(min_length=1)
+    p256dh: str = Field(min_length=1)
+    auth: str = Field(min_length=1)
+    label: str = ""
+
+
+class PushSubscriptionUpdate(BaseModel):
+    label: str | None = None
+
+
+class PushConversationToggle(BaseModel):
+    key: str = Field(min_length=1)
+
+
+# ─��� Endpoints ────────────────────────────────────────────────────────────
+
+
+@router.get("/vapid-public-key", response_model=VapidPublicKeyResponse)
+async def vapid_public_key() -> VapidPublicKeyResponse:
+    """Return the VAPID public key for browser PushManager.subscribe()."""
+    key = get_vapid_public_key()
+    if not key:
+        raise HTTPException(status_code=423, detail="VAPID keys not initialized")
+    return VapidPublicKeyResponse(public_key=key)
+
+
+@router.post("/subscribe")
+async def subscribe(body: PushSubscribeRequest) -> dict:
+    """Register or update a push subscription (device). Upserts by endpoint."""
+    sub = await PushSubscriptionRepository.create(
+        endpoint=body.endpoint,
+        p256dh=body.p256dh,
+        auth=body.auth,
+        label=body.label,
+    )
+    return sub
+
+
+@router.get("/subscriptions")
+async def list_subscriptions() -> list[dict]:
+    """List all push subscriptions (devices)."""
+    return await PushSubscriptionRepository.get_all()
+
+
+@router.patch("/subscriptions/{subscription_id}")
+async def update_subscription(subscription_id: str, body: PushSubscriptionUpdate) -> dict:
+    """Update a subscription's label."""
+    existing = await PushSubscriptionRepository.get(subscription_id)
+    if not existing:
+        raise HTTPException(status_code=404, detail="Subscription not found")
+
+    updates = {}
+    if body.label is not None:
+        updates["label"] = body.label
+
+    result = await PushSubscriptionRepository.update(subscription_id, **updates)
+    return result or existing
+
+
+@router.delete("/subscriptions/{subscription_id}")
+async def unsubscribe(subscription_id: str) -> dict:
+    """Delete a push subscription (device)."""
+    deleted = await PushSubscriptionRepository.delete(subscription_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Subscription not found")
+    return {"deleted": True}
+
+
+@router.post("/subscriptions/{subscription_id}/test")
+async def test_push(subscription_id: str) -> dict:
+    """Send a test notification to a subscription."""
+    sub = await PushSubscriptionRepository.get(subscription_id)
+    if not sub:
+        raise HTTPException(status_code=404, detail="Subscription not found")
+
+    vapid_key = get_vapid_private_key()
+    if not vapid_key:
+        raise HTTPException(status_code=423, detail="VAPID keys not initialized")
+
+    payload = json.dumps(
+        {
+            "title": "RemoteTerm Test",
+            "body": "Push notifications are working!",
+            "tag": "meshcore-test",
+            "url_hash": "",
+        }
+    )
+
+    try:
+        async with asyncio.timeout(15):
+            await send_push(
+                subscription_info={
+                    "endpoint": sub["endpoint"],
+                    "keys": {"p256dh": sub["p256dh"], "auth": sub["auth"]},
+                },
+                payload=payload,
+                vapid_private_key=vapid_key,
+                vapid_claims={"sub": "mailto:noreply@meshcore.local"},
+            )
+        return {"status": "sent"}
+    except TimeoutError:
+        raise HTTPException(status_code=408, detail="Push delivery timed out") from None
+    except WebPushException as e:
+        status_code = getattr(getattr(e, "response", None), "status_code", 0)
+        if status_code in (403, 404, 410):
+            logger.info(
+                "Test push: subscription stale (HTTP %d), removing %s",
+                status_code,
+                subscription_id,
+            )
+            await PushSubscriptionRepository.delete(subscription_id)
+            raise HTTPException(
+                status_code=410,
+                detail="Subscription is stale (VAPID key mismatch or expired). "
+                "Re-enable push from a conversation header.",
+            ) from None
+        logger.warning("Test push failed: %s", e)
+        raise HTTPException(status_code=422, detail=f"Push delivery failed: {e}") from None
+    except Exception as e:
+        logger.warning("Test push failed: %s", e)
+        raise HTTPException(status_code=422, detail=f"Push delivery failed: {e}") from None
+
+
+# ── Global push conversation management ──────────────────────────────────
+
+
+@router.get("/conversations")
+async def get_push_conversations() -> list[str]:
+    """Return the global list of push-enabled conversation state keys."""
+    return await AppSettingsRepository.get_push_conversations()
+
+
+@router.post("/conversations/toggle")
+async def toggle_push_conversation(body: PushConversationToggle) -> list[str]:
+    """Add or remove a conversation from the global push list."""
+    return await AppSettingsRepository.toggle_push_conversation(body.key)
@@ -338,7 +338,7 @@ async def get_radio_config() -> RadioConfigResponse:

    info = mc.self_info
    if not info:
-        raise HTTPException(status_code=503, detail="Radio info not available")
+        raise HTTPException(status_code=423, 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"
@@ -380,11 +380,35 @@ async def update_radio_config(update: RadioConfigUpdate) -> RadioConfigResponse:
        except PathHashModeUnsupportedError as exc:
            raise HTTPException(status_code=400, detail=str(exc)) from exc
        except RadioCommandRejectedError as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
+            raise HTTPException(status_code=422, detail=str(exc)) from exc

    return await get_radio_config()


+@router.get("/private-key")
+async def get_private_key() -> dict:
+    """Return the in-memory private key (exported from radio on startup).
+
+    Gated behind MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT=true.
+    """
+    from app.config import settings
+    from app.keystore import get_private_key as ks_get
+
+    if not settings.enable_local_private_key_export:
+        raise HTTPException(
+            status_code=403,
+            detail="Private key export is disabled (set MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT=true)",
+        )
+
+    key = ks_get()
+    if key is None:
+        raise HTTPException(
+            status_code=404,
+            detail="Private key not available (not exported from radio)",
+        )
+    return {"private_key": key.hex()}
+
+
@router.put("/private-key")
 async def set_private_key(update: PrivateKeyUpdate) -> dict:
    """Set the radio's private key. This is write-only."""
@@ -406,7 +430,7 @@ async def set_private_key(update: PrivateKeyUpdate) -> dict:
                export_and_store_private_key_fn=export_and_store_private_key,
            )
        except (RadioCommandRejectedError, KeystoreRefreshError) as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
+            raise HTTPException(status_code=422, detail=str(exc)) from exc

    return {"status": "ok"}

@@ -430,7 +454,7 @@ async def send_advertisement(request: RadioAdvertiseRequest | None = None) -> di
        success = await do_send_advertisement(mc, force=True, mode=mode)

    if not success:
-        raise HTTPException(status_code=500, detail=f"Failed to send {mode} advertisement")
+        raise HTTPException(status_code=422, detail=f"Failed to send {mode} advertisement")

    return {"status": "ok"}

@@ -462,7 +486,7 @@ async def discover_mesh(request: RadioDiscoveryRequest) -> RadioDiscoveryRespons
                tag=tag,
            )
            if send_result is None or send_result.type == EventType.ERROR:
-                raise HTTPException(status_code=500, detail="Failed to start mesh discovery")
+                raise HTTPException(status_code=422, detail="Failed to start mesh discovery")

            deadline = _monotonic() + DISCOVERY_WINDOW_SECONDS
            results_by_key: dict[str, RadioDiscoveryResult] = {}
@@ -514,7 +538,7 @@ async def trace_path(request: RadioTraceRequest) -> RadioTraceResponse:
    async with radio_manager.radio_operation("radio_trace", pause_polling=True) as mc:
        local_public_key = str((mc.self_info or {}).get("public_key") or "").lower()
        if len(local_public_key) != 64:
-            raise HTTPException(status_code=503, detail="Local radio public key is unavailable")
+            raise HTTPException(status_code=423, detail="Local radio public key is unavailable")
        local_name = (mc.self_info or {}).get("name")

        response_task = asyncio.create_task(
@@ -531,13 +555,13 @@ async def trace_path(request: RadioTraceRequest) -> RadioTraceResponse:
                flags=trace_flags,
            )
            if send_result is None or send_result.type == EventType.ERROR:
-                raise HTTPException(status_code=500, detail="Failed to send trace")
+                raise HTTPException(status_code=422, detail="Failed to send trace")

            timeout_seconds = _trace_timeout_seconds(send_result)
            try:
                event = await asyncio.wait_for(response_task, timeout=timeout_seconds)
            except TimeoutError as exc:
-                raise HTTPException(status_code=504, detail="No trace response heard") from exc
+                raise HTTPException(status_code=408, detail="No trace response heard") from exc
        finally:
            if not response_task.done():
                response_task.cancel()
@@ -545,12 +569,12 @@ async def trace_path(request: RadioTraceRequest) -> RadioTraceResponse:
                await response_task

    if event is None:
-        raise HTTPException(status_code=504, detail="No trace response heard")
+        raise HTTPException(status_code=408, detail="No trace response heard")

    payload = event.payload if isinstance(event.payload, dict) else {}
    path_len = payload.get("path_len")
    if not isinstance(path_len, int):
-        raise HTTPException(status_code=500, detail="Trace response was malformed")
+        raise HTTPException(status_code=422, detail="Trace response was malformed")

    raw_path = payload.get("path")
    path_nodes = raw_path if isinstance(raw_path, list) else []
@@ -564,7 +588,7 @@ async def trace_path(request: RadioTraceRequest) -> RadioTraceResponse:
    hashed_nodes = path_nodes[:-1] if final_local_node is not None else path_nodes

    if len(hashed_nodes) < len(trace_nodes):
-        raise HTTPException(status_code=500, detail="Trace response was incomplete")
+        raise HTTPException(status_code=422, detail="Trace response was incomplete")

    nodes: list[RadioTraceNode] = []
    for index, trace_node in enumerate(trace_nodes):
@@ -617,13 +641,13 @@ async def _attempt_reconnect() -> dict:
    except Exception as e:
        logger.exception("Post-connect setup failed after reconnect")
        raise HTTPException(
-            status_code=503,
+            status_code=423,
            detail=f"Radio connected but setup failed: {e}",
        ) from e

    if not success:
        raise HTTPException(
-            status_code=503, detail="Failed to reconnect. Check radio connection and power."
+            status_code=423, detail="Failed to reconnect. Check radio connection and power."
        )

    return {"status": "ok", "message": "Reconnected successfully", "connected": True}
@@ -678,14 +702,14 @@ async def reconnect_radio() -> dict:
        logger.info("Radio connected but setup incomplete, retrying setup")
        try:
            if not await _prepare_connected(broadcast_on_success=True):
-                raise HTTPException(status_code=503, detail="Radio connection is paused")
+                raise HTTPException(status_code=423, detail="Radio connection is paused")
            return {"status": "ok", "message": "Setup completed", "connected": True}
        except HTTPException:
            raise
        except Exception as e:
            logger.exception("Post-connect setup failed")
            raise HTTPException(
-                status_code=503,
+                status_code=423,
                detail=f"Radio connected but setup failed: {e}",
            ) from e

@@ -94,6 +94,7 @@ async def repeater_status(public_key: str) -> RepeaterStatusResponse:
    contact = await _resolve_contact_or_404(public_key)
    _require_repeater(contact)

+    lpp_raw = None
    async with radio_manager.radio_operation(
        "repeater_status", pause_polling=True, suspend_auto_fetch=True
    ) as mc:
@@ -102,8 +103,17 @@ async def repeater_status(public_key: str) -> RepeaterStatusResponse:

        status = await mc.commands.req_status_sync(contact.public_key, timeout=10, min_timeout=5)

+        # Best-effort LPP sensor fetch while we still hold the lock
+        if status is not None:
+            try:
+                lpp_raw = await mc.commands.req_telemetry_sync(
+                    contact.public_key, timeout=10, min_timeout=5
+                )
+            except Exception as e:
+                logger.debug("LPP sensor fetch failed for %s (non-fatal): %s", public_key[:12], e)
+
    if status is None:
-        raise HTTPException(status_code=504, detail="No status response from repeater")
+        raise HTTPException(status_code=408, detail="No status response from repeater")

    response = RepeaterStatusResponse(
        battery_volts=status.get("bat", 0) / 1000.0,
@@ -123,11 +133,30 @@ async def repeater_status(public_key: str) -> RepeaterStatusResponse:
        flood_dups=status.get("flood_dups", 0),
        direct_dups=status.get("direct_dups", 0),
        full_events=status.get("full_evts", 0),
+        recv_errors=status.get("recv_errors"),
    )

    # Record to telemetry history as a JSON blob (best-effort)
    now = int(time.time())
    status_dict = response.model_dump(exclude={"telemetry_history"})
+
+    # Attach scalar LPP sensors to the stored snapshot (same logic as auto-collect)
+    if lpp_raw:
+        lpp_sensors = []
+        for entry in lpp_raw:
+            value = entry.get("value", 0)
+            if isinstance(value, dict):
+                continue
+            lpp_sensors.append(
+                {
+                    "channel": entry.get("channel", 0),
+                    "type_name": str(entry.get("type", "unknown")),
+                    "value": value,
+                }
+            )
+        if lpp_sensors:
+            status_dict["lpp_sensors"] = lpp_sensors
+
    try:
        await RepeaterTelemetryRepository.record(
            public_key=contact.public_key,
@@ -193,7 +222,7 @@ async def repeater_lpp_telemetry(public_key: str) -> RepeaterLppTelemetryRespons
        )

    if telemetry is None:
-        raise HTTPException(status_code=504, detail="No telemetry response from repeater")
+        raise HTTPException(status_code=408, detail="No telemetry response from repeater")

    sensors: list[LppSensor] = []
    for entry in telemetry:
@@ -58,7 +58,7 @@ async def room_status(public_key: str) -> RepeaterStatusResponse:
        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")
+        raise HTTPException(status_code=408, detail="No status response from room server")

    return RepeaterStatusResponse(
        battery_volts=status.get("bat", 0) / 1000.0,
@@ -78,6 +78,7 @@ async def room_status(public_key: str) -> RepeaterStatusResponse:
        flood_dups=status.get("flood_dups", 0),
        direct_dups=status.get("direct_dups", 0),
        full_events=status.get("full_evts", 0),
+        recv_errors=status.get("recv_errors"),
    )


@@ -97,7 +98,7 @@ async def room_lpp_telemetry(public_key: str) -> RepeaterLppTelemetryResponse:
        )

    if telemetry is None:
-        raise HTTPException(status_code=504, detail="No telemetry response from room server")
+        raise HTTPException(status_code=408, detail="No telemetry response from room server")

    sensors = [
        LppSensor(
@@ -291,7 +291,7 @@ async def send_contact_cli_command(

        if send_result.type == EventType.ERROR:
            raise HTTPException(
-                status_code=500, detail=f"Failed to send command: {send_result.payload}"
+                status_code=422, detail=f"Failed to send command: {send_result.payload}"
            )

        response_event = await fetch_contact_cli_response(mc, contact.public_key[:12])
@@ -8,6 +8,13 @@ from pydantic import BaseModel, Field
 from app.models import CONTACT_TYPE_REPEATER, AppSettings
 from app.region_scope import normalize_region_scope
 from app.repository import AppSettingsRepository, ChannelRepository, ContactRepository
+from app.telemetry_interval import (
+    DEFAULT_TELEMETRY_INTERVAL_HOURS,
+    TELEMETRY_INTERVAL_OPTIONS_HOURS,
+    clamp_telemetry_interval,
+    legal_interval_options,
+    next_run_timestamp_utc,
+)

 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/settings", tags=["settings"])
@@ -57,6 +64,22 @@ class AppSettingsUpdate(BaseModel):
        default=None,
        description="Auto-resend channel messages once if no echo heard within 2 seconds",
    )
+    telemetry_interval_hours: int | None = Field(
+        default=None,
+        description=(
+            "Preferred tracked-repeater telemetry interval in hours. "
+            f"Must be one of {list(TELEMETRY_INTERVAL_OPTIONS_HOURS)}. "
+            "Effective interval is clamped up to the shortest legal value "
+            "based on the current tracked-repeater count."
+        ),
+    )
+    telemetry_routed_hourly: bool | None = Field(
+        default=None,
+        description=(
+            "When enabled, tracked repeaters with a direct or routed (non-flood) "
+            "path are polled every hour instead of on the normal scheduled interval."
+        ),
+    )


 class BlockKeyRequest(BaseModel):
@@ -78,10 +101,53 @@ class FavoriteToggleResponse(BaseModel):
    favorite: bool


+class MuteChannelRequest(BaseModel):
+    key: str = Field(description="Channel key to toggle mute status")
+
+
+class MuteChannelToggleResponse(BaseModel):
+    key: str
+    muted: bool
+
+
 class TrackedTelemetryRequest(BaseModel):
    public_key: str = Field(description="Public key of the repeater to toggle tracking")


+class TelemetrySchedule(BaseModel):
+    """Surface of telemetry scheduling derivations for the UI.
+
+    ``preferred_hours`` is the stored user choice. ``effective_hours`` is the
+    value the scheduler actually uses (preferred, clamped up to the shortest
+    legal interval given the current tracked-repeater count). ``options``
+    lists the subset of the menu that is legal at the current count; the UI
+    should hide anything not in this list. ``next_run_at`` is the Unix
+    timestamp (seconds, UTC) of the next scheduled cycle, or ``None`` when
+    no repeaters are tracked (nothing to schedule).
+    """
+
+    preferred_hours: int = Field(description="User's saved telemetry interval preference")
+    effective_hours: int = Field(description="Scheduler's clamped interval")
+    options: list[int] = Field(description="Legal interval choices at the current count")
+    tracked_count: int = Field(description="Number of repeaters currently tracked")
+    max_tracked: int = Field(description="Maximum number of repeaters that can be tracked")
+    next_run_at: int | None = Field(
+        default=None,
+        description="Unix timestamp (UTC seconds) of the next scheduled flood cycle",
+    )
+    routed_hourly: bool = Field(
+        default=False,
+        description="Whether hourly routed/direct-path telemetry is enabled",
+    )
+    next_routed_run_at: int | None = Field(
+        default=None,
+        description=(
+            "Unix timestamp (UTC seconds) of the next hourly routed/direct check, "
+            "or None when routed_hourly is off or no repeaters are tracked"
+        ),
+    )
+
+
 class TrackedTelemetryResponse(BaseModel):
    tracked_telemetry_repeaters: list[str] = Field(
        description="Current list of tracked repeater public keys"
@@ -89,6 +155,31 @@ class TrackedTelemetryResponse(BaseModel):
    names: dict[str, str] = Field(
        description="Map of public key to display name for tracked repeaters"
    )
+    schedule: TelemetrySchedule = Field(description="Current scheduling state")
+
+
+def _build_schedule(
+    tracked_count: int,
+    preferred_hours: int | None,
+    routed_hourly: bool = False,
+) -> TelemetrySchedule:
+    pref = (
+        preferred_hours
+        if preferred_hours in TELEMETRY_INTERVAL_OPTIONS_HOURS
+        else DEFAULT_TELEMETRY_INTERVAL_HOURS
+    )
+    effective = clamp_telemetry_interval(pref, tracked_count)
+    has_tracked = tracked_count > 0
+    return TelemetrySchedule(
+        preferred_hours=pref,
+        effective_hours=effective,
+        options=legal_interval_options(tracked_count),
+        tracked_count=tracked_count,
+        max_tracked=MAX_TRACKED_TELEMETRY_REPEATERS,
+        next_run_at=next_run_timestamp_utc(effective) if has_tracked else None,
+        routed_hourly=routed_hourly,
+        next_routed_run_at=(next_run_timestamp_utc(1) if has_tracked and routed_hourly else None),
+    )


@router.get("", response_model=AppSettings)
@@ -136,6 +227,25 @@ async def update_settings(update: AppSettingsUpdate) -> AppSettings:
    if update.auto_resend_channel is not None:
        kwargs["auto_resend_channel"] = update.auto_resend_channel

+    # Telemetry interval preference. Invalid values fall back to default
+    # rather than 400-ing so a stale client can't brick settings saves.
+    if update.telemetry_interval_hours is not None:
+        raw_interval = update.telemetry_interval_hours
+        if raw_interval not in TELEMETRY_INTERVAL_OPTIONS_HOURS:
+            logger.warning(
+                "telemetry_interval_hours=%r is not in the menu; defaulting to %d",
+                raw_interval,
+                DEFAULT_TELEMETRY_INTERVAL_HOURS,
+            )
+            raw_interval = DEFAULT_TELEMETRY_INTERVAL_HOURS
+        logger.info("Updating telemetry_interval_hours to %d", raw_interval)
+        kwargs["telemetry_interval_hours"] = raw_interval
+
+    # Telemetry routed hourly
+    if update.telemetry_routed_hourly is not None:
+        logger.info("Updating telemetry_routed_hourly to %s", update.telemetry_routed_hourly)
+        kwargs["telemetry_routed_hourly"] = update.telemetry_routed_hourly
+
    # Flood scope
    flood_scope_changed = False
    if update.flood_scope is not None:
@@ -189,6 +299,25 @@ async def toggle_favorite(request: FavoriteRequest) -> FavoriteToggleResponse:
    return FavoriteToggleResponse(type=request.type, id=request.id, favorite=new_value)


+@router.post("/muted-channels/toggle", response_model=MuteChannelToggleResponse)
+async def toggle_muted_channel(request: MuteChannelRequest) -> MuteChannelToggleResponse:
+    """Toggle a channel's muted status."""
+    channel = await ChannelRepository.get_by_key(request.key)
+    if not channel:
+        raise HTTPException(status_code=404, detail="Channel not found")
+    new_value = not channel.muted
+    await ChannelRepository.set_muted(request.key, new_value)
+    logger.info("%s channel mute: %s", "Muted" if new_value else "Unmuted", request.key[:12])
+
+    refreshed = await ChannelRepository.get_by_key(request.key)
+    if refreshed:
+        from app.websocket import broadcast_event
+
+        broadcast_event("channel", refreshed.model_dump())
+
+    return MuteChannelToggleResponse(key=request.key, muted=new_value)
+
+
@router.post("/blocked-keys/toggle", response_model=AppSettings)
 async def toggle_blocked_key(request: BlockKeyRequest) -> AppSettings:
    """Toggle a public key's blocked status."""
@@ -229,6 +358,11 @@ async def toggle_tracked_telemetry(request: TrackedTelemetryRequest) -> TrackedT
        return TrackedTelemetryResponse(
            tracked_telemetry_repeaters=new_list,
            names=await _resolve_names(new_list),
+            schedule=_build_schedule(
+                len(new_list),
+                settings.telemetry_interval_hours,
+                settings.telemetry_routed_hourly,
+            ),
        )

    # Validate it's a repeater
@@ -255,4 +389,25 @@ async def toggle_tracked_telemetry(request: TrackedTelemetryRequest) -> TrackedT
    return TrackedTelemetryResponse(
        tracked_telemetry_repeaters=new_list,
        names=await _resolve_names(new_list),
+        schedule=_build_schedule(
+            len(new_list),
+            settings.telemetry_interval_hours,
+            settings.telemetry_routed_hourly,
+        ),
+    )
+
+
+@router.get("/tracked-telemetry/schedule", response_model=TelemetrySchedule)
+async def get_telemetry_schedule() -> TelemetrySchedule:
+    """Return the current telemetry scheduling derivation.
+
+    The UI uses this to render the interval dropdown (legal options),
+    surface saved-vs-effective when they differ, and show the next-run-at
+    timestamp so users know when the next cycle will fire.
+    """
+    app_settings = await AppSettingsRepository.get()
+    return _build_schedule(
+        len(app_settings.tracked_telemetry_repeaters),
+        app_settings.telemetry_interval_hours,
+        app_settings.telemetry_routed_hourly,
    )
@@ -252,6 +252,11 @@ async def _store_direct_message(

        if update_last_contacted_key:
            await contact_repository.update_last_contacted(update_last_contacted_key, received_at)
+            # Incoming DMs are direct RF evidence that this contact transmitted;
+            # outgoing DMs are our own send and must not bump the contact's
+            # last_seen.
+            if not outgoing:
+                await contact_repository.touch_last_seen(update_last_contacted_key, received_at)

        return message

@@ -159,7 +159,7 @@ async def send_channel_message_with_effective_scope(
                override_result.payload,
            )
            raise HTTPException(
-                status_code=500,
+                status_code=422,
                detail=(
                    f"Failed to apply regional override {override_scope!r} before {action_label}: "
                    f"{override_result.payload}"
@@ -189,7 +189,7 @@ async def send_channel_message_with_effective_scope(
                phm_result.payload,
            )
            raise HTTPException(
-                status_code=500,
+                status_code=422,
                detail=(
                    f"Failed to apply path hash mode override before {action_label}: "
                    f"{phm_result.payload}"
@@ -233,7 +233,7 @@ async def send_channel_message_with_effective_scope(
                    set_result.payload,
                )
                raise HTTPException(
-                    status_code=500,
+                    status_code=422,
                    detail=f"Failed to configure channel on radio before {action_label}",
                )
            radio_manager.note_channel_slot_loaded(channel_key, channel_slot)
@@ -256,8 +256,14 @@ async def send_channel_message_with_effective_scope(
                action_label,
                channel.name,
            )
-            raise HTTPException(status_code=504, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
+            raise HTTPException(status_code=408, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
        if send_result.type == EventType.ERROR:
+            logger.error(
+                "Radio returned error during %s for channel %s: %s",
+                action_label,
+                channel.name,
+                send_result.payload,
+            )
            radio_manager.invalidate_cached_channel_slot(channel_key)
        else:
            radio_manager.note_channel_slot_used(channel_key)
@@ -513,14 +519,15 @@ async def _retry_direct_message_until_acked(

        ack_code = _extract_expected_ack_code(result)
        if not ack_code:
-            logger.warning(
+            logger.debug(
                "Background DM retry attempt %d/%d for %s returned no expected_ack; "
-                "stopping retries to avoid duplicate sends",
+                "continuing with previous timeout",
                attempt + 1,
                DM_SEND_MAX_ATTEMPTS,
                contact.public_key[:12],
            )
-            return
+            attempt += 1
+            continue

        next_wait_timeout_ms = _get_direct_message_retry_timeout_ms(result)

@@ -591,10 +598,10 @@ async def send_direct_message_to_contact(
                "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)
+            raise HTTPException(status_code=408, 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}")
+            raise HTTPException(status_code=422, detail=f"Failed to send message: {result.payload}")

        message = await create_outgoing_direct_message(
            conversation_key=contact.public_key.lower(),
@@ -606,7 +613,7 @@ async def send_direct_message_to_contact(
        )
        if message is None:
            raise HTTPException(
-                status_code=500,
+                status_code=422,
                detail="Failed to store outgoing message - unexpected duplicate",
            )
    finally:
@@ -619,7 +626,7 @@ async def send_direct_message_to_contact(
            )

    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")
+        raise HTTPException(status_code=422, detail="Failed to store outgoing message")

    await contact_repository.update_last_contacted(contact.public_key.lower(), sent_at)

@@ -784,7 +791,7 @@ async def send_channel_message_to_channel(
            )
            if outgoing_message is None:
                raise HTTPException(
-                    status_code=500,
+                    status_code=422,
                    detail="Failed to store outgoing message - unexpected duplicate",
                )

@@ -806,11 +813,11 @@ async def send_channel_message_to_channel(
                    "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)
+                raise HTTPException(status_code=408, 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}"
+                    status_code=422, detail=f"Failed to send message: {result.payload}"
                )
    except Exception:
        if outgoing_message is not None:
@@ -827,7 +834,7 @@ async def send_channel_message_to_channel(
            )

    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")
+        raise HTTPException(status_code=422, detail="Failed to store outgoing message")

    outgoing_message = await build_stored_outgoing_channel_message(
        message_id=outgoing_message.id,
@@ -855,7 +862,7 @@ async def send_channel_message_to_channel(
                )
            )
    except Exception:
-        pass  # Never let watchdog setup failure break the send
+        logger.error("Echo watchdog setup failed", exc_info=True)

    return outgoing_message

@@ -921,7 +928,7 @@ async def resend_channel_message_record(
                )
                if new_message is None:
                    raise HTTPException(
-                        status_code=500,
+                        status_code=422,
                        detail="Failed to store resent message - unexpected duplicate",
                    )

@@ -942,10 +949,10 @@ async def resend_channel_message_record(
                    "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)
+                raise HTTPException(status_code=408, detail=NO_RADIO_RESPONSE_AFTER_SEND_DETAIL)
            if result.type == EventType.ERROR:
                raise HTTPException(
-                    status_code=500,
+                    status_code=422,
                    detail=f"Failed to resend message: {result.payload}",
                )
    except Exception:
@@ -964,7 +971,7 @@ async def resend_channel_message_record(

    if new_timestamp:
        if sent_at is None or new_message is None:
-            raise HTTPException(status_code=500, detail="Failed to assign resend timestamp")
+            raise HTTPException(status_code=422, detail="Failed to assign resend timestamp")

        new_message = await build_stored_outgoing_channel_message(
            message_id=new_message.id,
@@ -52,12 +52,12 @@ class RadioRuntime:
    def require_connected(self):
        """Return MeshCore when available, mirroring existing HTTP semantics."""
        if self.is_setup_in_progress:
-            raise HTTPException(status_code=503, detail="Radio is initializing")
+            raise HTTPException(status_code=423, detail="Radio is initializing")
        if not self.is_connected:
-            raise HTTPException(status_code=503, detail="Radio not connected")
+            raise HTTPException(status_code=423, detail="Radio not connected")
        mc = self.meshcore
        if mc is None:
-            raise HTTPException(status_code=503, detail="Radio not connected")
+            raise HTTPException(status_code=423, detail="Radio not connected")
        return mc

    @asynccontextmanager
@@ -0,0 +1,88 @@
+"""Shared math for the tracked-repeater telemetry scheduler.
+
+The app enforces a ceiling of 24 repeater status checks per 24 hours across
+all tracked repeaters. With N repeaters tracked, the shortest legal interval
+is ``24 // floor(24 / N)`` hours. Longer intervals (``12`` or ``24``) are
+always legal at any N and are offered as user choices on top of the derived
+shortest-legal value.
+
+The user picks an interval via settings. The scheduler uses
+``clamp_telemetry_interval`` to push that pick up to the shortest legal
+interval if the user has added repeaters that invalidated their choice.
+The stored preference is *not* mutated on clamp — users get their pick back
+if they later drop repeaters.
+"""
+
+from datetime import UTC, datetime
+
+# Daily check budget: total number of repeater status checks we allow
+# across all tracked repeaters per 24-hour window.
+DAILY_CHECK_CEILING = 24
+
+# Menu of interval values shown to users. The derivation-based options
+# (1..8) are filtered per current repeater count via
+# ``legal_interval_options``; 12 and 24 are always legal.
+TELEMETRY_INTERVAL_OPTIONS_HOURS: tuple[int, ...] = (1, 2, 3, 4, 6, 8, 12, 24)
+
+DEFAULT_TELEMETRY_INTERVAL_HOURS = 8
+
+
+def shortest_legal_interval_hours(n_tracked: int) -> int:
+    """Return the shortest interval (hours) that keeps under the daily ceiling.
+
+    With ``N`` repeaters, each full cycle costs ``N`` checks. We're capped at
+    ``DAILY_CHECK_CEILING`` checks/day, so the maximum cycles/day is
+    ``floor(24 / N)`` and the resulting interval is ``24 // cycles_per_day``.
+    For ``N == 0`` we return the default so the math still terminates, though
+    the scheduler skips empty-tracked cycles regardless.
+    """
+    if n_tracked <= 0:
+        return DEFAULT_TELEMETRY_INTERVAL_HOURS
+    cycles_per_day = DAILY_CHECK_CEILING // n_tracked
+    if cycles_per_day <= 0:
+        # Would exceed ceiling even at 24h cadence; fall back to 24h.
+        return 24
+    return 24 // cycles_per_day
+
+
+def clamp_telemetry_interval(preferred_hours: int, n_tracked: int) -> int:
+    """Return the effective interval: max of user preference and shortest legal.
+
+    Unrecognized values fall back to the default.
+    """
+    if preferred_hours not in TELEMETRY_INTERVAL_OPTIONS_HOURS:
+        preferred_hours = DEFAULT_TELEMETRY_INTERVAL_HOURS
+    shortest = shortest_legal_interval_hours(n_tracked)
+    return max(preferred_hours, shortest)
+
+
+def legal_interval_options(n_tracked: int) -> list[int]:
+    """Return the subset of the interval menu that is legal for a given N."""
+    shortest = shortest_legal_interval_hours(n_tracked)
+    return [h for h in TELEMETRY_INTERVAL_OPTIONS_HOURS if h >= shortest]
+
+
+def next_run_timestamp_utc(effective_hours: int, now: datetime | None = None) -> int:
+    """Return Unix timestamp for the next UTC top-of-hour where
+    ``hour % effective_hours == 0``.
+
+    Returns the next matching hour strictly in the future (never ``now``
+    itself, even if ``now`` lies exactly on a matching boundary).
+    """
+    if effective_hours <= 0:
+        effective_hours = DEFAULT_TELEMETRY_INTERVAL_HOURS
+    if now is None:
+        now = datetime.now(UTC)
+    else:
+        now = now.astimezone(UTC)
+
+    # Round up to the next top-of-hour, then skip forward until the modulo matches.
+    candidate = now.replace(minute=0, second=0, microsecond=0)
+    # Always move at least one hour forward so "now" never matches.
+    candidate = candidate.replace(hour=candidate.hour)
+    from datetime import timedelta
+
+    candidate = candidate + timedelta(hours=1)
+    while candidate.hour % effective_hours != 0:
+        candidate = candidate + timedelta(hours=1)
+    return int(candidate.timestamp())
@@ -108,6 +108,10 @@ def broadcast_event(event_type: str, data: dict, *, realtime: bool = True) -> No

        if event_type == "message":
            asyncio.create_task(fanout_manager.broadcast_message(data))
+
+            from app.push.manager import push_manager
+
+            asyncio.create_task(push_manager.dispatch_message(data))
        elif event_type == "raw_packet":
            asyncio.create_task(fanout_manager.broadcast_raw(data))
        elif event_type == "contact":
@@ -44,6 +44,7 @@ services:
      # MESHCORE_DISABLE_BOTS: "true"
      # MESHCORE_BASIC_AUTH_USERNAME: changeme
      # MESHCORE_BASIC_AUTH_PASSWORD: changeme
+      # MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT: "false"

      # Logging
      # MESHCORE_LOG_LEVEL: INFO
@@ -40,7 +40,8 @@ frontend/src/
 ├── styles.css              # Additional global app styles
 ├── themes.css              # Color theme definitions
 ├── contexts/
-│   └── DistanceUnitContext.tsx # Browser-local distance-unit context/provider
+│   ├── DistanceUnitContext.tsx # Browser-local distance-unit context/provider
+│   └── PushSubscriptionContext.tsx # Push subscription state context/provider
 ├── lib/
 │   └── utils.ts            # cn() — clsx + tailwind-merge helper
 ├── hooks/
@@ -57,6 +58,7 @@ frontend/src/
 │   ├── useConversationRouter.ts    # URL hash → active conversation routing
 │   ├── useContactsAndChannels.ts   # Contact/channel loading, creation, deletion
 │   ├── useBrowserNotifications.ts  # Per-conversation browser notification preferences + dispatch
+│   ├── usePushSubscription.ts      # Web Push subscription lifecycle, per-conversation filters
 │   ├── useFaviconBadge.ts          # Browser tab unread badge state
 │   ├── useRawPacketStatsSession.ts # Session-scoped packet-feed stats history
 │   └── useRememberedServerPassword.ts # Browser-local repeater/room password persistence
@@ -73,7 +75,6 @@ frontend/src/
 ├── utils/
 │   ├── urlHash.ts              # Hash parsing and encoding
 │   ├── conversationState.ts    # State keys, in-memory + localStorage helpers
-│   ├── favorites.ts            # LocalStorage migration for favorites
 │   ├── messageParser.ts        # Message text → rendered segments
 │   ├── pathUtils.ts            # Distance/validation helpers for paths + map
 │   ├── pubkey.ts               # getContactDisplayName (12-char prefix fallback)
@@ -91,7 +92,13 @@ frontend/src/
 │   ├── radioPresets.ts            # LoRa radio preset configurations
 │   ├── publicChannel.ts           # Public-channel resolution helpers for routing/hash defaults
 │   ├── fontScale.ts               # Browser-local relative font scale persistence/application
-│   └── theme.ts                   # Theme switching helpers
+│   ├── theme.ts                   # Theme switching helpers
+│   ├── autoFocusInput.ts          # Auto-focus input helper
+│   ├── batteryDisplay.ts          # Battery level display helpers
+│   ├── messageIdentity.ts         # Message identity/dedup helpers
+│   ├── rawPacketInspector.ts      # Raw packet inspection helpers
+│   ├── serverLoginState.ts        # Server login state helpers
+│   └── statusDotPulse.ts          # Status dot pulse animation helpers
 ├── components/
 │   ├── StatusBar.tsx
 │   ├── Sidebar.tsx
@@ -124,6 +131,9 @@ frontend/src/
 │   ├── ServerLoginStatusBanner.tsx # Shared repeater/room login state banner
 │   ├── ChannelInfoPane.tsx     # Channel detail sheet (stats, top senders)
 │   ├── ChannelFloodScopeOverrideModal.tsx # Per-channel flood-scope override editor
+│   ├── ChannelPathHashModeOverrideModal.tsx # Per-channel path hash mode override editor
+│   ├── BulkAddChannelResultModal.tsx # Results dialog for bulk channel creation
+│   ├── CommandPalette.tsx      # Command palette overlay
 │   ├── DirectTraceIcon.tsx     # Shared direct-trace glyph used in header/dashboard
 │   ├── NeighborsMiniMap.tsx    # Leaflet mini-map for repeater neighbor locations
 │   ├── settings/
@@ -134,7 +144,8 @@ frontend/src/
 │   │   ├── SettingsDatabaseSection.tsx   # DB size, cleanup, auto-decrypt, local label
 │   │   ├── SettingsStatisticsSection.tsx # Read-only mesh network stats
 │   │   ├── SettingsAboutSection.tsx     # Version, author, license, links
-│   │   └── ThemeSelector.tsx           # Color theme picker
+│   │   ├── ThemeSelector.tsx           # Color theme picker
+│   │   └── BulkDeleteContactsModal.tsx # Bulk contact deletion dialog
 │   ├── repeater/
 │   │   ├── repeaterPaneShared.tsx        # Shared: RepeaterPane, KvRow, format helpers
 │   │   ├── RepeaterTelemetryPane.tsx    # Battery, airtime, packet counts
@@ -144,6 +155,7 @@ frontend/src/
 │   │   ├── RepeaterRadioSettingsPane.tsx # Radio config + advert intervals
 │   │   ├── RepeaterLppTelemetryPane.tsx # CayenneLPP sensor data
 │   │   ├── RepeaterOwnerInfoPane.tsx    # Owner info + guest password
+│   │   ├── RepeaterTelemetryHistoryPane.tsx # Historical telemetry chart/table
 │   │   ├── RepeaterActionsPane.tsx      # Send Advert, Sync Clock, Reboot
 │   │   └── RepeaterConsolePane.tsx      # CLI console with history
 │   └── ui/                     # shadcn/ui primitives
@@ -168,7 +180,6 @@ frontend/src/
    ├── prefetch.test.ts
    ├── rawPacketDetailModal.test.tsx
    ├── rawPacketFeedView.test.tsx
-    ├── radioPresets.test.ts
    ├── rawPacketIdentity.test.ts
    ├── repeaterDashboard.test.tsx
    ├── repeaterFormatters.test.ts
@@ -340,10 +351,6 @@ It falls back to a 12-char prefix when `name` is missing.

 Distance/validation helpers used by path + map UI.

-### `utils/favorites.ts`
-
-LocalStorage migration helpers for favorites; canonical favorites are server-side.
-
 ## Types and Contracts (`types.ts`)

 `AppSettings` currently includes:
@@ -356,7 +363,7 @@ LocalStorage migration helpers for favorites; canonical favorites are server-sid
 - `blocked_keys`, `blocked_names`, `discovery_blocked_types`
 - `tracked_telemetry_repeaters`
 - `auto_resend_channel`
-
+- `telemetry_interval_hours`

 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`.

@@ -429,6 +436,17 @@ The `SearchView` component (`components/SearchView.tsx`) provides full-text sear
 - **Bidirectional pagination**: After jumping mid-history, `hasNewerMessages` enables forward pagination via `fetchNewerMessages`. The scroll-to-bottom button calls `jumpToBottom` (re-fetches latest page) instead of just scrolling.
 - **WS message suppression**: When `hasNewerMessages` is true, incoming WS messages for the active conversation are not added to the message list (the user is viewing historical context, not the latest page).

+## Web Push Notifications
+
+Web Push allows notifications even when the browser tab is closed. Requires HTTPS (self-signed OK).
+
+- **Service worker**: `frontend/public/sw.js` handles `push` events (show notification) and `notificationclick` (focus/open tab, navigate via `url_hash`). Registered in `main.tsx` on secure contexts only.
+- **`usePushSubscription` hook**: manages the full subscription lifecycle — subscribe (register SW → `PushManager.subscribe()` → POST to backend), unsubscribe, global push-conversation toggles, device listing, and deletion.
+- **ChatHeader integration**: `BellRing` icon (amber when active) appears next to the existing desktop notification `Bell` on secure contexts. First click subscribes the browser and enables push for that conversation; subsequent clicks toggle the conversation on/off.
+- **Settings > Local**: `PushDeviceManagement` component shows subscription status, lists all registered devices with test/delete buttons. Uses `usePushSubscription` hook directly.
+- Auto-generates device labels from User-Agent (e.g., "Chrome on macOS").
+- `PushSubscriptionInfo` type in `types.ts`; API methods in `api.ts`.
+
 ## Styling

 UI styling is mostly utility-class driven (Tailwind-style classes in JSX) plus shared globals in `index.css` and `styles.css`.
@@ -441,7 +459,9 @@ Do not rely on old class-only layout assumptions.
 Key conventions documented in the reference:

 - **Text sizes** use `rem`-based Tailwind values so they scale with the user's font-size slider. Do not use hard-locked `px` values (e.g., `text-[10px]`). The canonical sizes are `text-[0.625rem]` (10px), `text-[0.6875rem]` (11px), `text-[0.8125rem]` (13px), plus standard Tailwind `text-xs`/`text-sm`/`text-base`/`text-lg`/`text-xl`.
- **Section labels** use `text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium`.
+- **Group titles** (sub-section headings within settings tabs) use `<h3 className="text-base font-semibold tracking-tight">`. These separate major groups like "Connection", "Identity", "MQTT Broker". When a group contains named sub-items (e.g. "Contact Management" → "Blocked Contacts", "Bulk Delete"), use `<h4 className="text-sm font-semibold">` for the children and nest them inside the parent group's `div` instead of separating with `<Separator />`.
+- **Helper / description text** uses `text-[0.8125rem] text-muted-foreground` (13px). This is for explanatory paragraphs under inputs or sections — not for metadata, timestamps, or alert text which stay at `text-xs`.
+- **Metadata labels** use `text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium` for compact category tags like "Push-enabled conversations" or "Registered Devices".
 - **Buttons** use the shadcn `<Button>` component. Semantic color overrides (danger, warning, success) use `variant="outline"` with `className="border-{color}/50 text-{color} hover:bg-{color}/10"`.
 - **Badges/tags** use `text-[0.625rem] uppercase tracking-wider px-1.5 py-0.5 rounded` with `bg-muted` (neutral) or `bg-primary/10` (active).
 - **Clickable text** (copy-to-clipboard, navigational links) uses `role="button" tabIndex={0}` with `cursor-pointer hover:text-primary transition-colors`.
@@ -13,8 +13,11 @@
    <link rel="icon" type="image/png" href="./favicon-96x96.png" sizes="96x96" />
    <link rel="shortcut icon" href="./favicon.ico" />
    <link rel="apple-touch-icon" sizes="180x180" href="./apple-touch-icon.png" />
-    <link rel="manifest" href="./site.webmanifest" />
+    <link rel="manifest" href="./site.webmanifest" crossorigin="use-credentials" />
    <script>
+      // Service worker registration moved to main.tsx (requires isSecureContext
+      // for Web Push). Do not duplicate here.
+
      // Start critical data fetches before React/Vite JS loads.
      // Must be in <head> BEFORE the module script so the browser queues these
      // fetches before it discovers and starts downloading the JS bundle.
@@ -1,7 +1,7 @@
 {
  "name": "remoteterm-meshcore-frontend",
  "private": true,
-  "version": "3.11.0",
+  "version": "3.13.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
@@ -61,12 +61,12 @@
    "eslint": "^9.17.0",
    "eslint-plugin-react-hooks": "^5.1.0",
    "jsdom": "^25.0.0",
-    "postcss": "^8.5.6",
+    "postcss": "^8.5.10",
    "prettier": "^3.4.2",
    "tailwindcss": "^3.4.19",
    "typescript": "^5.6.3",
    "typescript-eslint": "^8.19.0",
-    "vite": "^6.0.3",
-    "vitest": "^2.1.0"
+    "vite": "^6.4.2",
+    "vitest": "^4.1.4"
  }
 }
@@ -0,0 +1,60 @@
+/* Service worker for PWA installability and Web Push notifications. */
+
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+// No-op fetch handler — required for PWA installability criteria.
+// We don't cache anything; the app always fetches from the network.
+self.addEventListener("fetch", () => {});
+
+self.addEventListener("push", (event) => {
+  let data = {};
+  try {
+    data = event.data ? event.data.json() : {};
+  } catch {
+    data = { title: "New message", body: event.data?.text() || "" };
+  }
+
+  const title = data.title || "New message";
+  const options = {
+    body: data.body || "",
+    icon: "./favicon-256x256.png",
+    badge: "./favicon-96x96.png",
+    tag: data.tag || "meshcore-push",
+    data: { url_hash: data.url_hash || "" },
+  };
+
+  event.waitUntil(self.registration.showNotification(title, options));
+});
+
+self.addEventListener("notificationclick", (event) => {
+  event.notification.close();
+  const urlHash = event.notification.data?.url_hash || "";
+  // Use the SW registration scope as the base URL so subpath deployments
+  // (e.g. archworks.co/meshcore/) navigate correctly.
+  const base = self.registration.scope;
+
+  event.waitUntil(
+    clients
+      .matchAll({ type: "window", includeUncontrolled: true })
+      .then((windowClients) => {
+        // Focus an existing tab if one is open
+        for (const client of windowClients) {
+          if (client.url.startsWith(base)) {
+            client.focus();
+            if (urlHash) {
+              client.navigate(base + urlHash);
+            }
+            return;
+          }
+        }
+        // Otherwise open a new tab
+        return clients.openWindow(base + (urlHash || ""));
+      })
+  );
+});
@@ -22,9 +22,16 @@ import { toast } from './components/ui/sonner';
 import { AppShell } from './components/AppShell';
 import type { MessageInputHandle } from './components/MessageInput';
 import { DistanceUnitProvider } from './contexts/DistanceUnitContext';
+import { usePush } from './contexts/PushSubscriptionContext';
 import { messageContainsMention } from './utils/messageParser';
 import { getStateKey } from './utils/conversationState';
-import type { BulkCreateHashtagChannelsResult, Conversation, Message, RawPacket } from './types';
+import type {
+  BulkCreateHashtagChannelsResult,
+  Channel,
+  Conversation,
+  Message,
+  RawPacket,
+} from './types';
 import { CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM } from './types';
 import { shouldAutoFocusInput } from './utils/autoFocusInput';

@@ -99,6 +106,7 @@ export function App() {
    toggleConversationNotifications,
    notifyIncomingMessage,
  } = useBrowserNotifications();
+  const pushSubscription = usePush();
  const { rawPacketStatsSession, recordRawPacketObservation } = useRawPacketStatsSession();
  const {
    showNewMessage,
@@ -205,6 +213,12 @@ export function App() {
      removeConversationMessagesRef.current(conversationId),
  });

+  // Keep channels in a ref for WS callback mute filtering
+  const channelsRef = useRef<Channel[]>([]);
+  useEffect(() => {
+    channelsRef.current = channels;
+  }, [channels]);
+
  const handleToggleFavorite = useCallback(
    async (type: 'channel' | 'contact', id: string) => {
      // Optimistically toggle the favorite flag
@@ -341,6 +355,20 @@ export function App() {
  useFaviconBadge(unreadCounts, mentions, channels);
  useUnreadTitle(unreadCounts, contacts, channels);

+  const handleToggleMute = useCallback(
+    async (key: string) => {
+      setChannels((prev) => prev.map((c) => (c.key === key ? { ...c, muted: !c.muted } : c)));
+      try {
+        await api.toggleChannelMute(key);
+        await refreshUnreads();
+      } catch {
+        setChannels((prev) => prev.map((c) => (c.key === key ? { ...c, muted: !c.muted } : c)));
+        toast.error('Failed to update mute');
+      }
+    },
+    [setChannels, refreshUnreads]
+  );
+
  useEffect(() => {
    if (activeConversation?.type !== 'channel') {
      setChannelUnreadMarker(null);
@@ -406,6 +434,7 @@ export function App() {
    setContacts,
    blockedKeysRef,
    blockedNamesRef,
+    channelsRef,
    activeConversationRef,
    observeMessage,
    recordMessageEvent,
@@ -584,10 +613,12 @@ export function App() {
    onRunTracePath: api.requestRadioTrace,
    onPathDiscovery: handlePathDiscovery,
    onToggleFavorite: handleToggleFavorite,
+    onToggleMute: handleToggleMute,
    onDeleteContact: handleDeleteContact,
    onDeleteChannel: handleDeleteChannel,
    onSetChannelFloodScopeOverride: handleSetChannelFloodScopeOverride,
    onSetChannelPathHashModeOverride: handleSetChannelPathHashModeOverride,
+    onSelectConversation: handleSelectConversationWithTargetReset,
    onOpenContactInfo: handleOpenContactInfo,
    onOpenChannelInfo: handleOpenChannelInfo,
    onSenderClick: handleSenderClick,
@@ -614,6 +645,36 @@ export function App() {
        );
      }
    },
+    pushSupported: pushSubscription.isSupported,
+    pushSubscribed: pushSubscription.isSubscribed,
+    pushEnabledForConversation:
+      activeConversation?.type === 'contact' || activeConversation?.type === 'channel'
+        ? pushSubscription.isConversationPushEnabled(
+            getStateKey(activeConversation.type, activeConversation.id)
+          )
+        : false,
+    onTogglePush: async () => {
+      if (
+        !activeConversation ||
+        (activeConversation.type !== 'contact' && activeConversation.type !== 'channel')
+      )
+        return;
+      const key = getStateKey(activeConversation.type, activeConversation.id);
+      const pushEnabled = pushSubscription.isConversationPushEnabled(key);
+
+      if (!pushEnabled && !pushSubscription.isSubscribed) {
+        const subscriptionId = await pushSubscription.subscribe();
+        if (!subscriptionId) {
+          return;
+        }
+      }
+
+      await pushSubscription.toggleConversation(key);
+    },
+    onOpenPushSettings: () => {
+      setSettingsSection('local');
+      if (!showSettings) handleToggleSettingsView();
+    },
    trackedTelemetryRepeaters: appSettings?.tracked_telemetry_repeaters ?? [],
    onToggleTrackedTelemetry: handleToggleTrackedTelemetry,
    repeaterAutoLoginKey,
@@ -647,6 +708,7 @@ export function App() {
    onToggleBlockedKey: handleBlockKey,
    onToggleBlockedName: handleBlockName,
    contacts,
+    channels,
    onBulkDeleteContacts: (deletedKeys: string[]) => {
      const keySet = new Set(deletedKeys.map((k) => k.toLowerCase()));
      setContacts((prev) => prev.filter((c) => !keySet.has(c.public_key.toLowerCase())));
@@ -22,6 +22,7 @@ import type {
  RadioTraceResponse,
  RadioDiscoveryTarget,
  PathDiscoveryResponse,
+  PushSubscriptionInfo,
  ResendChannelMessageResponse,
  RepeaterAclResponse,
  RepeaterAdvertIntervalsResponse,
@@ -33,6 +34,7 @@ import type {
  RepeaterRadioSettingsResponse,
  RepeaterStatusResponse,
  TelemetryHistoryEntry,
+  TelemetrySchedule,
  TrackedTelemetryResponse,
  StatisticsResponse,
  TraceResponse,
@@ -94,6 +96,7 @@ export const api = {
      method: 'PATCH',
      body: JSON.stringify(config),
    }),
+  getPrivateKey: () => fetchJson<{ private_key: string }>('/radio/private-key'),
  setPrivateKey: (privateKey: string) =>
    fetchJson<{ status: string }>('/radio/private-key', {
      method: 'PUT',
@@ -155,10 +158,10 @@ export const api = {
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ public_keys: publicKeys }),
    }),
-  createContact: (publicKey: string, name?: string, tryHistorical?: boolean) =>
+  createContact: (publicKey: string, name?: string, tryHistorical?: boolean, type?: number) =>
    fetchJson<Contact>('/contacts', {
      method: 'POST',
-      body: JSON.stringify({ public_key: publicKey, name, try_historical: tryHistorical }),
+      body: JSON.stringify({ public_key: publicKey, name, type, try_historical: tryHistorical }),
    }),
  markContactRead: (publicKey: string) =>
    fetchJson<{ status: string; public_key: string }>(`/contacts/${publicKey}/mark-read`, {
@@ -332,6 +335,8 @@ export const api = {
      body: JSON.stringify({ public_key: publicKey }),
    }),

+  getTelemetrySchedule: () => fetchJson<TelemetrySchedule>('/settings/tracked-telemetry/schedule'),
+
  // Favorites
  toggleFavorite: (type: 'channel' | 'contact', id: string) =>
    fetchJson<{ type: string; id: string; favorite: boolean }>('/settings/favorites/toggle', {
@@ -339,6 +344,12 @@ export const api = {
      body: JSON.stringify({ type, id }),
    }),

+  toggleChannelMute: (key: string) =>
+    fetchJson<{ key: string; muted: boolean }>('/settings/muted-channels/toggle', {
+      method: 'POST',
+      body: JSON.stringify({ key }),
+    }),
+
  // Fanout
  getFanoutConfigs: () => fetchJson<FanoutConfig[]>('/fanout'),
  createFanoutConfig: (config: {
@@ -438,4 +449,28 @@ export const api = {
    fetchJson<RepeaterLppTelemetryResponse>(`/contacts/${publicKey}/room/lpp-telemetry`, {
      method: 'POST',
    }),
+
+  // Push Notifications
+  getVapidPublicKey: () => fetchJson<{ public_key: string }>('/push/vapid-public-key'),
+  pushSubscribe: (subscription: {
+    endpoint: string;
+    p256dh: string;
+    auth: string;
+    label?: string;
+  }) =>
+    fetchJson<PushSubscriptionInfo>('/push/subscribe', {
+      method: 'POST',
+      body: JSON.stringify(subscription),
+    }),
+  getPushSubscriptions: () => fetchJson<PushSubscriptionInfo[]>('/push/subscriptions'),
+  deletePushSubscription: (id: string) =>
+    fetchJson<{ deleted: boolean }>(`/push/subscriptions/${id}`, { method: 'DELETE' }),
+  testPushSubscription: (id: string) =>
+    fetchJson<{ status: string }>(`/push/subscriptions/${id}/test`, { method: 'POST' }),
+  getPushConversations: () => fetchJson<string[]>('/push/conversations'),
+  togglePushConversation: (key: string) =>
+    fetchJson<string[]>('/push/conversations/toggle', {
+      method: 'POST',
+      body: JSON.stringify({ key }),
+    }),
 };
@@ -1,4 +1,12 @@
-import { lazy, Suspense, useCallback, useRef, type ComponentProps } from 'react';
+import {
+  lazy,
+  Suspense,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  type ComponentProps,
+} from 'react';
 import { useSwipeable } from 'react-swipeable';

 import { StatusBar } from './StatusBar';
@@ -140,6 +148,26 @@ export function AppShell({
    crackerMounted.current = true;
  }

+  // Position toasts below the conversation header when in chat, otherwise below the status bar
+  const TOAST_TOP_PADDING = 10;
+  const [toastTopOffset, setToastTopOffset] = useState<number | undefined>(undefined);
+  const hasLocalLabel = !!localLabel.text;
+  const activeType = conversationPaneProps.activeConversation?.type;
+  const activeId = conversationPaneProps.activeConversation?.id;
+  useEffect(() => {
+    const measure = () => {
+      const anchor =
+        document.querySelector('[data-toast-anchor="conversation"]') ??
+        document.querySelector('[data-toast-anchor="statusbar"]');
+      setToastTopOffset(
+        anchor ? anchor.getBoundingClientRect().top + TOAST_TOP_PADDING : undefined
+      );
+    };
+    measure();
+    window.addEventListener('resize', measure);
+    return () => window.removeEventListener('resize', measure);
+  }, [hasLocalLabel, activeType, activeId, showSettings]);
+
  const settingsSidebarContent = (
    <nav
      className="sidebar w-60 h-full min-h-0 overflow-hidden bg-card border-r border-border flex flex-col"
@@ -220,6 +248,7 @@ export function AppShell({
        onSettingsClick={onToggleSettingsView}
        onMenuClick={showSettings ? undefined : () => onSidebarOpenChange(true)}
      />
+      <div data-toast-anchor="statusbar" aria-hidden="true" />

      <div className="flex flex-1 overflow-hidden">
        <div className="hidden md:block min-h-0 overflow-hidden">{activeSidebarContent}</div>
@@ -344,7 +373,11 @@ export function AppShell({
      <SecurityWarningModal health={statusProps.health} />
      <ContactInfoPane {...contactInfoPaneProps} />
      <ChannelInfoPane {...channelInfoPaneProps} />
-      <Toaster position="top-right" />
+      <Toaster
+        position="top-right"
+        offset={toastTopOffset !== undefined ? { top: toastTopOffset } : undefined}
+        mobileOffset={toastTopOffset !== undefined ? { top: toastTopOffset } : undefined}
+      />
    </div>
  );
 }
@@ -84,12 +84,12 @@ export function BulkAddChannelResultModal({
              </div>
            </div>
          ) : (
-            <p className="text-sm text-muted-foreground">No new rooms were added.</p>
+            <p className="text-sm text-muted-foreground">No new channels were added.</p>
          )}

          {result && result.invalid_names.length > 0 && (
            <div className="rounded-md border border-warning/30 bg-warning/10 px-3 py-2 text-sm text-warning">
-              Ignored invalid room names: {result.invalid_names.join(', ')}
+              Ignored invalid channel names: {result.invalid_names.join(', ')}
            </div>
          )}
        </div>
@@ -1,5 +1,5 @@
-import { useEffect, useState } from 'react';
-import { Bell, ChevronsLeftRight, Globe2, Info, Route, Star, Trash2 } from 'lucide-react';
+import { useEffect, useRef, useState } from 'react';
+import { Bell, BellOff, ChevronsLeftRight, Globe2, Info, Route, Star, Trash2 } from 'lucide-react';
 import { toast } from './ui/sonner';
 import { DirectTraceIcon } from './DirectTraceIcon';
 import { ContactPathDiscoveryModal } from './ContactPathDiscoveryModal';
@@ -26,7 +26,13 @@ interface ChatHeaderProps {
  onTrace: () => void;
  onPathDiscovery: (publicKey: string) => Promise<PathDiscoveryResponse>;
  onToggleNotifications: () => void;
+  pushSupported?: boolean;
+  pushSubscribed?: boolean;
+  pushEnabledForConversation?: boolean;
+  onTogglePush?: () => void;
+  onOpenPushSettings?: () => void;
  onToggleFavorite: (type: 'channel' | 'contact', id: string) => void;
+  onToggleMute?: (key: string) => void;
  onSetChannelFloodScopeOverride?: (key: string, floodScopeOverride: string) => void;
  onSetChannelPathHashModeOverride?: (key: string, pathHashModeOverride: number | null) => void;
  onDeleteChannel: (key: string) => void;
@@ -46,7 +52,13 @@ export function ChatHeader({
  onTrace,
  onPathDiscovery,
  onToggleNotifications,
+  pushSupported,
+  pushSubscribed,
+  pushEnabledForConversation,
+  onTogglePush,
+  onOpenPushSettings,
  onToggleFavorite,
+  onToggleMute,
  onSetChannelFloodScopeOverride,
  onSetChannelPathHashModeOverride,
  onDeleteChannel,
@@ -58,14 +70,29 @@ export function ChatHeader({
  const [pathDiscoveryOpen, setPathDiscoveryOpen] = useState(false);
  const [channelOverrideOpen, setChannelOverrideOpen] = useState(false);
  const [pathHashModeOverrideOpen, setPathHashModeOverrideOpen] = useState(false);
+  const [notifDropdownOpen, setNotifDropdownOpen] = useState(false);
+  const notifDropdownRef = useRef<HTMLDivElement>(null);

  useEffect(() => {
    setShowKey(false);
    setPathDiscoveryOpen(false);
    setChannelOverrideOpen(false);
    setPathHashModeOverrideOpen(false);
+    setNotifDropdownOpen(false);
  }, [conversation.id]);

+  // Close notification dropdown on outside click
+  useEffect(() => {
+    if (!notifDropdownOpen) return;
+    const handler = (e: MouseEvent) => {
+      if (notifDropdownRef.current && !notifDropdownRef.current.contains(e.target as Node)) {
+        setNotifDropdownOpen(false);
+      }
+    };
+    document.addEventListener('mousedown', handler);
+    return () => document.removeEventListener('mousedown', handler);
+  }, [notifDropdownOpen]);
+
  const activeChannel =
    conversation.type === 'channel'
      ? channels.find((channel) => channel.key === conversation.id)
@@ -288,35 +315,125 @@ export function ChatHeader({
            <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}
-            title={
-              notificationsEnabled
-                ? 'Disable desktop notifications for this conversation'
-                : notificationsPermission === 'denied'
-                  ? 'Notifications blocked by the browser'
-                  : 'Enable desktop notifications for this conversation'
-            }
-            aria-label={
-              notificationsEnabled
-                ? 'Disable notifications for this conversation'
-                : 'Enable notifications for this conversation'
-            }
-          >
-            <Bell
-              className={`h-4 w-4 ${notificationsEnabled ? 'text-status-connected' : 'text-muted-foreground'}`}
-              fill={notificationsEnabled ? 'currentColor' : 'none'}
-              aria-hidden="true"
-            />
-            {notificationsEnabled && (
-              <span className="hidden md:inline text-[0.6875rem] font-medium text-status-connected">
-                Notifications On
-              </span>
-            )}
-          </button>
-        )}
+        {(notificationsSupported ||
+          pushSupported ||
+          (conversation.type === 'channel' && onToggleMute)) &&
+          !activeContactIsRoomServer && (
+            <div className="relative" ref={notifDropdownRef}>
+              <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={() => setNotifDropdownOpen((v) => !v)}
+                title="Notification settings"
+                aria-label="Notification settings"
+                aria-expanded={notifDropdownOpen}
+              >
+                {activeChannel?.muted ? (
+                  <BellOff className="h-4 w-4 text-muted-foreground" aria-hidden="true" />
+                ) : (
+                  <Bell
+                    className={cn(
+                      'h-4 w-4',
+                      notificationsEnabled || pushEnabledForConversation
+                        ? 'text-primary'
+                        : 'text-muted-foreground'
+                    )}
+                    fill={
+                      notificationsEnabled || pushEnabledForConversation ? 'currentColor' : 'none'
+                    }
+                    aria-hidden="true"
+                  />
+                )}
+              </button>
+              {notifDropdownOpen && (
+                <div className="absolute right-[-4.5rem] sm:right-0 top-full z-50 mt-1 w-[calc(100vw-2rem)] sm:w-72 max-w-72 rounded-md border border-border bg-popover p-3 shadow-lg space-y-3">
+                  {notificationsSupported && (
+                    <label className="flex items-start gap-2.5 cursor-pointer group">
+                      <input
+                        type="checkbox"
+                        className="mt-0.5 accent-primary h-4 w-4 shrink-0"
+                        checked={notificationsEnabled}
+                        disabled={notificationsPermission === 'denied'}
+                        onChange={onToggleNotifications}
+                      />
+                      <div className="min-w-0">
+                        <span className="text-sm font-medium text-foreground block leading-tight">
+                          Desktop notifications (legacy)
+                        </span>
+                        <span className="text-xs text-muted-foreground leading-snug block mt-0.5">
+                          {notificationsPermission === 'denied'
+                            ? 'Blocked by browser — check site permissions'
+                            : 'Alerts while this tab is open'}
+                        </span>
+                      </div>
+                    </label>
+                  )}
+                  {pushSupported && onTogglePush && (
+                    <>
+                      <label className="flex items-start gap-2.5 cursor-pointer group">
+                        <input
+                          type="checkbox"
+                          className="mt-0.5 accent-primary h-4 w-4 shrink-0"
+                          checked={!!pushEnabledForConversation}
+                          onChange={onTogglePush}
+                        />
+                        <div className="min-w-0">
+                          <span className="text-sm font-medium text-foreground block leading-tight">
+                            Web Push (beta testing)
+                          </span>
+                          <span className="text-xs text-muted-foreground leading-snug block mt-0.5">
+                            {pushSubscribed
+                              ? 'Alerts even when the browser is closed'
+                              : 'Alerts even when the browser is closed. Requires HTTPS.'}
+                          </span>
+                        </div>
+                      </label>
+                      <span className="text-xs text-muted-foreground leading-snug block mt-0.5">
+                        All notification types require a trusted HTTPS context. Depending on your
+                        browser, a snakeoil certificate may not be sufficient.
+                      </span>
+                      {onOpenPushSettings && (
+                        <p className="text-xs text-muted-foreground leading-snug mt-1.5">
+                          Manage Web Push enabled devices in{' '}
+                          <button
+                            type="button"
+                            onClick={() => {
+                              setNotifDropdownOpen(false);
+                              onOpenPushSettings();
+                            }}
+                            className="text-primary hover:underline transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                          >
+                            Settings &rarr; Local
+                          </button>
+                          .
+                        </p>
+                      )}
+                    </>
+                  )}
+                  {conversation.type === 'channel' && onToggleMute && (
+                    <>
+                      <hr className="border-border" />
+                      <label className="flex items-start gap-2.5 cursor-pointer group">
+                        <input
+                          type="checkbox"
+                          className="mt-0.5 accent-primary h-4 w-4 shrink-0"
+                          checked={!!activeChannel?.muted}
+                          onChange={() => onToggleMute(conversation.id)}
+                        />
+                        <div className="min-w-0">
+                          <span className="text-sm font-medium text-foreground block leading-tight">
+                            Mute channel
+                          </span>
+                          <span className="text-xs text-muted-foreground leading-snug block mt-0.5">
+                            Hide unread counts and suppress all notifications
+                          </span>
+                        </div>
+                      </label>
+                    </>
+                  )}
+                </div>
+              )}
+            </div>
+          )}
        {conversation.type === 'channel' && onSetChannelFloodScopeOverride && (
          <button
            className="flex shrink-0 items-center gap-1 rounded px-1 py-1 text-lg leading-none transition-colors hover:bg-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
@@ -298,17 +298,16 @@ export function ContactInfoPane({

            {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.
+                We&apos;ve received a message from this sender but don&apos;t have their full
+                identity yet. This contact stays read-only until their identity is confirmed &mdash;
+                this usually happens automatically when they next advertise.
              </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.
+                This sender&apos;s profile details (name, location) haven&apos;t arrived yet. They
+                will fill in automatically when the sender&apos;s next advertisement is heard.
              </div>
            )}

@@ -3,10 +3,9 @@ import { useMemo, useState } from 'react';
 import type { Contact, PathDiscoveryResponse, PathDiscoveryRoute } from '../types';
 import {
  findContactsByPrefix,
+  formatForcedRouteSummary,
+  formatLearnedRouteSummary,
  formatRouteLabel,
-  getDirectContactRoute,
-  getEffectiveContactRoute,
-  hasRoutingOverride,
  parsePathHops,
 } from '../utils/pathUtils';
 import { Button } from './ui/button';
@@ -99,30 +98,9 @@ export function ContactPathDiscoveryModal({
  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 learnedRouteSummary = useMemo(() => formatLearnedRouteSummary(contact), [contact]);
+  const forcedRouteSummary = useMemo(() => formatForcedRouteSummary(contact), [contact]);
+  const hasForcedRoute = forcedRouteSummary !== null;

  const forwardChain = result
    ? renderRouteNodes(
@@ -3,10 +3,9 @@ import { useEffect, useMemo, useState } from 'react';
 import { api } from '../api';
 import type { Contact } from '../types';
 import {
-  formatRouteLabel,
+  formatForcedRouteSummary,
+  formatLearnedRouteSummary,
  formatRoutingOverrideInput,
-  getDirectContactRoute,
-  hasRoutingOverride,
 } from '../utils/pathUtils';
 import { Button } from './ui/button';
 import {
@@ -28,18 +27,6 @@ interface ContactRoutingOverrideModalProps {
  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,
@@ -59,7 +46,8 @@ export function ContactRoutingOverrideModal({
    setError(null);
  }, [contact, open]);

-  const forcedRouteSummary = useMemo(() => summarizeForcedRoute(contact), [contact]);
+  const learnedRouteSummary = useMemo(() => formatLearnedRouteSummary(contact), [contact]);
+  const forcedRouteSummary = useMemo(() => formatForcedRouteSummary(contact), [contact]);

  const saveRoute = async (value: string) => {
    setSaving(true);
@@ -98,7 +86,7 @@ export function ContactRoutingOverrideModal({
          <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)}
+              Current learned route: {learnedRouteSummary}
            </div>
            {forcedRouteSummary && (
              <div className="mt-1 text-destructive">
@@ -20,7 +20,11 @@ import type {
 } from '../types';
 import type { RawPacketStatsSessionState } from '../utils/rawPacketStats';
 import { CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM } from '../types';
-import { isPrefixOnlyContact, isUnknownFullKeyContact } from '../utils/pubkey';
+import {
+  getContactDisplayName,
+  isPrefixOnlyContact,
+  isUnknownFullKeyContact,
+} from '../utils/pubkey';

 const RepeaterDashboard = lazy(() =>
  import('./RepeaterDashboard').then((m) => ({ default: m.RepeaterDashboard }))
@@ -58,6 +62,7 @@ interface ConversationPaneProps {
  ) => Promise<RadioTraceResponse>;
  onPathDiscovery: (publicKey: string) => Promise<PathDiscoveryResponse>;
  onToggleFavorite: (type: 'channel' | 'contact', id: string) => Promise<void>;
+  onToggleMute: (key: string) => Promise<void>;
  onDeleteContact: (publicKey: string) => Promise<void>;
  onDeleteChannel: (key: string) => Promise<void>;
  onSetChannelFloodScopeOverride: (channelKey: string, floodScopeOverride: string) => Promise<void>;
@@ -65,6 +70,7 @@ interface ConversationPaneProps {
    channelKey: string,
    pathHashModeOverride: number | null
  ) => Promise<void>;
+  onSelectConversation: (conversation: Conversation) => void;
  onOpenContactInfo: (publicKey: string, fromChannel?: boolean) => void;
  onOpenChannelInfo: (channelKey: string) => void;
  onSenderClick: (sender: string) => void;
@@ -77,6 +83,11 @@ interface ConversationPaneProps {
  onDismissUnreadMarker: () => void;
  onSendMessage: (text: string) => Promise<void>;
  onToggleNotifications: () => void;
+  pushSupported?: boolean;
+  pushSubscribed?: boolean;
+  pushEnabledForConversation?: boolean;
+  onTogglePush?: () => void;
+  onOpenPushSettings?: () => void;
  trackedTelemetryRepeaters: string[];
  onToggleTrackedTelemetry: (publicKey: string) => Promise<void>;
  repeaterAutoLoginKey: string | null;
@@ -93,17 +104,17 @@ function ContactResolutionBanner({ variant }: { variant: 'unknown-full-key' | 'p
  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.
+        We&apos;ve received a message from this sender but don&apos;t have their full identity yet.
+        Sending is disabled until their identity is confirmed &mdash; this usually happens
+        automatically when they next advertise.
      </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.
+      This sender&apos;s profile details (name, location) haven&apos;t arrived yet. They will fill
+      in automatically when the sender&apos;s next advert is heard.
    </div>
  );
 }
@@ -133,10 +144,12 @@ export function ConversationPane({
  onRunTracePath,
  onPathDiscovery,
  onToggleFavorite,
+  onToggleMute,
  onDeleteContact,
  onDeleteChannel,
  onSetChannelFloodScopeOverride,
  onSetChannelPathHashModeOverride,
+  onSelectConversation,
  onOpenContactInfo,
  onOpenChannelInfo,
  onSenderClick,
@@ -149,6 +162,11 @@ export function ConversationPane({
  onDismissUnreadMarker,
  onSendMessage,
  onToggleNotifications,
+  pushSupported,
+  pushSubscribed,
+  pushEnabledForConversation,
+  onTogglePush,
+  onOpenPushSettings,
  trackedTelemetryRepeaters,
  onToggleTrackedTelemetry,
  repeaterAutoLoginKey,
@@ -197,6 +215,17 @@ export function ConversationPane({
              focusedKey={activeConversation.mapFocusKey}
              rawPackets={rawPackets}
              config={config}
+              onSelectContact={(contact) =>
+                onSelectConversation({
+                  type: 'contact',
+                  id: contact.public_key,
+                  name: getContactDisplayName(
+                    contact.name,
+                    contact.public_key,
+                    contact.last_advert
+                  ),
+                })
+              }
            />
          </Suspense>
        </div>
@@ -271,10 +300,16 @@ export function ConversationPane({
        notificationsSupported={notificationsSupported}
        notificationsEnabled={notificationsEnabled}
        notificationsPermission={notificationsPermission}
+        pushSupported={pushSupported}
+        pushSubscribed={pushSubscribed}
+        pushEnabledForConversation={pushEnabledForConversation}
+        onTogglePush={onTogglePush}
+        onOpenPushSettings={onOpenPushSettings}
        onTrace={onTrace}
        onPathDiscovery={onPathDiscovery}
        onToggleNotifications={onToggleNotifications}
        onToggleFavorite={onToggleFavorite}
+        onToggleMute={onToggleMute}
        onSetChannelFloodScopeOverride={onSetChannelFloodScopeOverride}
        onSetChannelPathHashModeOverride={onSetChannelPathHashModeOverride}
        onDeleteChannel={onDeleteChannel}
@@ -291,6 +326,7 @@ export function ConversationPane({
      {activeContactIsRoom && activeContact && (
        <RoomServerPanel contact={activeContact} onAuthenticatedChange={setRoomAuthenticated} />
      )}
+      {showRoomChat && <div data-toast-anchor="conversation" aria-hidden="true" />}
      {showRoomChat && (
        <MessageList
          key={activeConversation.id}
@@ -1,5 +1,14 @@
 import { Fragment, useEffect, useState, useMemo, useRef, useCallback } from 'react';
-import { MapContainer, TileLayer, CircleMarker, Popup, useMap, Polyline } from 'react-leaflet';
+import {
+  MapContainer,
+  TileLayer,
+  CircleMarker,
+  Popup,
+  useMap,
+  useMapEvents,
+  Polyline,
+  LayersControl,
+} from 'react-leaflet';
 import type { LatLngBoundsExpression, CircleMarker as LeafletCircleMarker } from 'leaflet';
 import L from 'leaflet';
 import 'leaflet/dist/leaflet.css';
@@ -21,29 +30,132 @@ interface MapViewProps {
  focusedKey?: string | null;
  rawPackets?: RawPacket[];
  config?: RadioConfig | null;
+  /** When provided, the contact name in each popup becomes a clickable link
+   *  that opens the conversation for that contact (DM, repeater, or room). */
+  onSelectContact?: (contact: Contact) => void;
 }

 // --- Tile layer presets ---
-const TILE_LIGHT = {
-  url: 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
-  attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>',
-  background: '#1a1a2e',
-};
-const TILE_DARK = {
-  url: 'https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png',
-  attribution:
-    '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> &copy; <a href="https://carto.com/">CARTO</a>',
-  background: '#0d0d0d',
-};
+// Every provider here is free and works without an API key. Attribution strings
+// follow each provider's requirements; do not remove them. If you add a new
+// provider, verify its terms of service (especially for Esri / Google-style
+// satellite tiles) before committing.
+interface TileLayerPreset {
+  id: string;
+  label: string;
+  url: string;
+  attribution: string;
+  background: string;
+  /** Highest zoom the provider publishes tiles at. When the layer is active,
+   *  the map's zoom ceiling is tightened to this value via
+   *  `MaxZoomByActiveLayer` so the user cannot zoom into a grey void. */
+  maxZoom?: number;
+}

-function getSavedDarkMap(): boolean {
+// Global zoom bounds for the MapContainer itself. These are pinned to the
+// container so Leaflet's internal tile-range math never has to guess when
+// layers swap in/out via LayersControl. Without this, an initial-mount race
+// between MapContainer layout and LayersControl.BaseLayer addition has been
+// observed to throw "Attempted to load an infinite number of tiles".
+const MAP_MIN_ZOOM = 2;
+const MAP_MAX_ZOOM = 19;
+
+const TILE_LAYERS: readonly TileLayerPreset[] = [
+  {
+    id: 'light',
+    label: 'Light (OpenStreetMap)',
+    url: 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+    attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>',
+    background: '#1a1a2e',
+    maxZoom: 19,
+  },
+  {
+    id: 'dark',
+    label: 'Dark (CARTO)',
+    url: 'https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png',
+    attribution:
+      '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> &copy; <a href="https://carto.com/">CARTO</a>',
+    background: '#0d0d0d',
+    maxZoom: 19,
+  },
+  {
+    id: 'topographic',
+    label: 'Topographic (OpenTopoMap)',
+    url: 'https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png',
+    attribution:
+      'Map data: &copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, <a href="http://viewfinderpanoramas.org">SRTM</a> | Map style: &copy; <a href="https://opentopomap.org">OpenTopoMap</a> (<a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-BY-SA</a>)',
+    background: '#a3b3bc',
+    maxZoom: 17,
+  },
+  {
+    id: 'satellite',
+    label: 'Satellite (Esri)',
+    url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+    attribution:
+      'Tiles &copy; <a href="https://www.esri.com/">Esri</a> &mdash; Source: Esri, Maxar, Earthstar Geographics, and the GIS User Community',
+    background: '#1a1f2e',
+    // Esri's tile service advertises LODs up to 23 and returns HTTP 200 for
+    // every tile request, but the underlying imagery is only high-resolution
+    // up to ~18 in most developed areas and shallower in rural regions. We
+    // cap at 18 rather than 19 so users don't zoom into visibly-empty or
+    // severely-upscaled tiles. Remote regions may still be sparse at 18.
+    maxZoom: 18,
+  },
+] as const;
+
+const MAP_LAYER_STORAGE_KEY = 'remoteterm-map-layer';
+const LEGACY_DARK_MAP_STORAGE_KEY = 'remoteterm-dark-map';
+
+function getSavedLayerId(): string {
  try {
-    return localStorage.getItem('remoteterm-dark-map') === 'true';
+    const stored = localStorage.getItem(MAP_LAYER_STORAGE_KEY);
+    if (stored && TILE_LAYERS.some((l) => l.id === stored)) return stored;
+    // Legacy migration: boolean dark-map flag predates multi-layer support.
+    const legacyDark = localStorage.getItem(LEGACY_DARK_MAP_STORAGE_KEY) === 'true';
+    return legacyDark ? 'dark' : 'light';
  } catch {
-    return false;
+    return 'light';
  }
 }

+/**
+ * Leaflet-internal companion component: listens for base-layer changes driven
+ * by Leaflet's own LayersControl UI and pipes the selection back to React.
+ * Kept separate so the persistence/state logic stays out of the render tree.
+ */
+function LayerChangeWatcher({ onChange }: { onChange: (name: string) => void }) {
+  useMapEvents({
+    baselayerchange: (event) => {
+      if (event.name) onChange(event.name);
+    },
+  });
+  return null;
+}
+
+/**
+ * Enforces the active layer's zoom ceiling on the underlying Leaflet map.
+ *
+ * Leaflet's `map.getMaxZoom()` prefers `options.maxZoom` (set on MapContainer)
+ * over per-layer `maxZoom`, so a per-TileLayer cap is silently ignored unless
+ * we push it down to the map itself. We do that here whenever the active
+ * layer changes, and clamp the current zoom if the user happened to be zoomed
+ * past the new cap at the moment of the switch.
+ *
+ * The MapContainer's fixed `minZoom`/`maxZoom` remain the absolute hull that
+ * prevents the "Attempted to load an infinite number of tiles" race during
+ * initial mount (see `MAP_MIN_ZOOM`/`MAP_MAX_ZOOM` below).
+ */
+function MaxZoomByActiveLayer({ maxZoom }: { maxZoom: number }) {
+  const map = useMap();
+  useEffect(() => {
+    map.setMaxZoom(maxZoom);
+    if (map.getZoom() > maxZoom) {
+      map.setZoom(maxZoom);
+    }
+  }, [map, maxZoom]);
+  return null;
+}
+
 const MAP_RECENCY_COLORS = {
  recent: '#06b6d4',
  today: '#2563eb',
@@ -379,20 +491,43 @@ function ParticleOverlay({ particles }: { particles: MapParticle[] }) {

 // --- Main component ---

-export function MapView({ contacts, focusedKey, rawPackets, config }: MapViewProps) {
+export function MapView({
+  contacts,
+  focusedKey,
+  rawPackets,
+  config,
+  onSelectContact,
+}: MapViewProps) {
  const [sevenDaysAgo] = useState(() => Date.now() / 1000 - 7 * 24 * 60 * 60);
-  const [darkMap, setDarkMap] = useState(getSavedDarkMap);
-  const tile = darkMap ? TILE_DARK : TILE_LIGHT;
+  const [selectedLayerId, setSelectedLayerId] = useState<string>(getSavedLayerId);
+  const activeLayer = TILE_LAYERS.find((l) => l.id === selectedLayerId) ?? TILE_LAYERS[0];

-  // Sync with settings changes from other components
+  // Sync layer selection across tabs and windows.
  useEffect(() => {
    const onStorage = (e: StorageEvent) => {
-      if (e.key === 'remoteterm-dark-map') setDarkMap(e.newValue === 'true');
+      if (e.key !== MAP_LAYER_STORAGE_KEY) return;
+      const next = e.newValue ?? '';
+      if (TILE_LAYERS.some((l) => l.id === next)) {
+        setSelectedLayerId(next);
+      }
    };
    window.addEventListener('storage', onStorage);
    return () => window.removeEventListener('storage', onStorage);
  }, []);

+  const handleLayerChange = useCallback((layerName: string) => {
+    const match = TILE_LAYERS.find((l) => l.label === layerName);
+    if (!match) return;
+    setSelectedLayerId(match.id);
+    try {
+      localStorage.setItem(MAP_LAYER_STORAGE_KEY, match.id);
+      // Clear the legacy key so a future downgrade-rollback doesn't revert us.
+      localStorage.removeItem(LEGACY_DARK_MAP_STORAGE_KEY);
+    } catch {
+      // localStorage may be disabled; selection stays in memory only.
+    }
+  }, []);
+
  const [showPackets, setShowPackets] = useState(false);
  const [discoveryMode, setDiscoveryMode] = useState(false);
  const [discoveredKeys, setDiscoveredKeys] = useState<Set<string>>(new Set());
@@ -674,10 +809,12 @@ export function MapView({ contacts, focusedKey, rawPackets, config }: MapViewPro

  return (
    <div className="flex flex-col h-full">
-      {/* Info bar */}
-      <div className="px-4 py-2 bg-muted/50 text-xs text-muted-foreground flex items-center justify-between">
+      {/* Info bar: stacks vertically on narrow viewports (info label, legend
+          row, controls row) so nothing truncates; flattens to a single row
+          with right-aligned cluster at md and up. */}
+      <div className="px-4 py-2 bg-muted/50 text-xs text-muted-foreground flex flex-col gap-1 md:flex-row md:items-center md:justify-between md:gap-3">
        <span>{infoLabel}</span>
-        <div className="flex items-center gap-3">
+        <div className="flex flex-wrap items-center gap-x-3 gap-y-1 md:justify-end">
          {!showPackets && (
            <>
              <span className="flex items-center gap-1">
@@ -758,7 +895,7 @@ export function MapView({ contacts, focusedKey, rawPackets, config }: MapViewPro
            />{' '}
            repeater
          </span>
-          <label className="flex items-center gap-1.5 cursor-pointer ml-2">
+          <label className="flex items-center gap-1.5 cursor-pointer">
            <input
              type="checkbox"
              checked={showPackets}
@@ -791,10 +928,28 @@ export function MapView({ contacts, focusedKey, rawPackets, config }: MapViewPro
        <MapContainer
          center={[20, 0]}
          zoom={2}
+          minZoom={MAP_MIN_ZOOM}
+          maxZoom={MAP_MAX_ZOOM}
          className="h-full w-full"
-          style={{ background: tile.background }}
+          style={{ background: activeLayer.background }}
        >
-          <TileLayer key={tile.url} attribution={tile.attribution} url={tile.url} />
+          <LayersControl position="topright" collapsed={false}>
+            {TILE_LAYERS.map((layer) => (
+              <LayersControl.BaseLayer
+                key={layer.id}
+                name={layer.label}
+                checked={layer.id === selectedLayerId}
+              >
+                <TileLayer
+                  url={layer.url}
+                  attribution={layer.attribution}
+                  maxZoom={layer.maxZoom}
+                />
+              </LayersControl.BaseLayer>
+            ))}
+          </LayersControl>
+          <LayerChangeWatcher onChange={handleLayerChange} />
+          <MaxZoomByActiveLayer maxZoom={activeLayer.maxZoom ?? MAP_MAX_ZOOM} />
          <MapBoundsHandler contacts={mappableContacts} focusedContact={focusedContact} />

          {/* Faint route lines for active packet paths */}
@@ -839,7 +994,21 @@ export function MapView({ contacts, focusedKey, rawPackets, config }: MapViewPro
                            🛜
                          </span>
                        )}
-                        {displayName}
+                        {onSelectContact ? (
+                          <button
+                            type="button"
+                            className="p-0 bg-transparent border-0 font-inherit text-primary underline hover:text-primary/80 cursor-pointer"
+                            onClick={(event) => {
+                              event.stopPropagation();
+                              onSelectContact(contact);
+                            }}
+                            title={`Open conversation with ${displayName}`}
+                          >
+                            {displayName}
+                          </button>
+                        ) : (
+                          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">
@@ -4,14 +4,20 @@ import {
  useImperativeHandle,
  forwardRef,
  useRef,
+  useEffect,
  useMemo,
+  type ChangeEvent,
  type FormEvent,
  type KeyboardEvent,
 } from 'react';
-import { Input } from './ui/input';
 import { Button } from './ui/button';
 import { toast } from './ui/sonner';
 import { cn } from '@/lib/utils';
+import {
+  getTextReplaceEnabled,
+  getTextReplaceMapJson,
+  applyTextReplacements,
+} from '../utils/textReplace';

 // MeshCore message size limits (empirically determined from LoRa packet constraints)
 // Direct delivery allows ~156 bytes; multi-hop requires buffer for path growth.
@@ -53,19 +59,32 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
 ) {
  const [text, setText] = useState('');
  const [sending, setSending] = useState(false);
-  const inputRef = useRef<HTMLInputElement>(null);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+
+  /** Resize textarea to fit content, clamped between 1 row and ~6 rows. */
+  const autoResize = useCallback(() => {
+    const el = textareaRef.current;
+    if (!el) return;
+    el.style.height = 'auto';
+    // Clamp: min 40px (≈1 row), max 160px (≈6 rows)
+    el.style.height = `${Math.min(el.scrollHeight, 160)}px`;
+  }, []);

  useImperativeHandle(ref, () => ({
    appendText: (appendedText: string) => {
      setText((prev) => prev + appendedText);
-      // Focus the input after appending
-      inputRef.current?.focus();
+      textareaRef.current?.focus();
    },
    focus: () => {
-      inputRef.current?.focus();
+      textareaRef.current?.focus();
    },
  }));

+  // Re-measure height whenever text changes (covers programmatic updates like appendText)
+  useEffect(() => {
+    autoResize();
+  }, [text, autoResize]);
+
  // Calculate character limits based on conversation type
  const limits = useMemo(() => {
    if (conversationType === 'contact') {
@@ -133,18 +152,44 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
      } finally {
        setSending(false);
      }
-      // Refocus after React re-enables the input
-      setTimeout(() => inputRef.current?.focus(), 0);
+      // Refocus after React re-enables the textarea
+      setTimeout(() => textareaRef.current?.focus(), 0);
    },
    [text, sending, disabled, onSend]
  );

+  const handleChange = useCallback((e: ChangeEvent<HTMLTextAreaElement>) => {
+    const input = e.target;
+    const raw = input.value;
+    // Skip replacement during IME / dead-key composition to avoid garbling interim input
+    if (!e.nativeEvent || (e.nativeEvent as InputEvent).isComposing) {
+      setText(raw);
+      return;
+    }
+    if (getTextReplaceEnabled()) {
+      const result = applyTextReplacements(
+        raw,
+        input.selectionStart ?? raw.length,
+        getTextReplaceMapJson()
+      );
+      if (result) {
+        setText(result.text);
+        // Schedule cursor restore after React flushes the new value
+        const pos = result.cursor;
+        requestAnimationFrame(() => input.setSelectionRange(pos, pos));
+        return;
+      }
+    }
+    setText(raw);
+  }, []);
+
  const handleKeyDown = useCallback(
-    (e: KeyboardEvent<HTMLInputElement>) => {
+    (e: KeyboardEvent<HTMLTextAreaElement>) => {
      if (e.key === 'Enter' && !e.shiftKey) {
        e.preventDefault();
        handleSubmit(e as unknown as FormEvent);
      }
+      // Shift+Enter falls through naturally and inserts a newline
    },
    [handleSubmit]
  );
@@ -162,22 +207,28 @@ export const MessageInput = forwardRef<MessageInputHandle, MessageInputProps>(fu
      onSubmit={handleSubmit}
      autoComplete="off"
    >
-      <div className="flex gap-2">
-        <Input
-          ref={inputRef}
-          type="text"
+      <div className="flex gap-2 items-end">
+        <textarea
+          ref={textareaRef}
          autoComplete="off"
          name="chat-message-input"
          aria-label={placeholder || 'Type a message'}
          data-lpignore="true"
          data-1p-ignore="true"
          data-bwignore="true"
+          rows={1}
          value={text}
-          onChange={(e) => setText(e.target.value)}
+          onChange={handleChange}
          onKeyDown={handleKeyDown}
          placeholder={placeholder || 'Type a message...'}
          disabled={disabled || sending}
-          className="flex-1 min-w-0"
+          className={cn(
+            'flex-1 min-w-0 resize-none overflow-y-auto',
+            'rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background',
+            'placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+            'disabled:cursor-not-allowed disabled:opacity-50 md:text-sm'
+          )}
+          style={{ minHeight: '40px', maxHeight: '160px' }}
        />
        <Button
          type="submit"
@@ -9,7 +9,7 @@ import {
  type ReactNode,
 } from 'react';
 import type { Channel, Contact, Message, MessagePath, RadioConfig, RawPacket } from '../types';
-import { CONTACT_TYPE_REPEATER, CONTACT_TYPE_ROOM } from '../types';
+import { CONTACT_TYPE_ROOM } from '../types';
 import { api } from '../api';
 import {
  findLinkedChannelReferences,
@@ -808,12 +808,13 @@ export function MessageList({
        {sortedMessages.map((msg, index) => {
          // For DMs, look up contact; for channel messages, use parsed sender
          const contact = msg.type === 'PRIV' ? getContact(msg.conversation_key) : null;
-          const isRepeater = contact?.type === CONTACT_TYPE_REPEATER;
          const isRoomServer = contact?.type === CONTACT_TYPE_ROOM;

-          // Skip sender parsing for repeater messages (CLI responses often have colons)
+          // Only parse "sender: text" prefix for channel messages — DMs never carry
+          // an in-text sender prefix, so parsing them would incorrectly strip
+          // user text that happens to contain a colon (e.g. "TEST1: TEST2").
          const { sender, content } =
-            isRepeater || (isRoomServer && msg.type === 'PRIV')
+            msg.type === 'PRIV'
              ? { sender: null, content: msg.text }
              : parseSenderFromText(msg.text);
          const directSenderName =
@@ -845,7 +846,8 @@ export function MessageList({
            isCorruptChannelMessage
          );
          const prevMsg = sortedMessages[index - 1];
-          const prevParsedSender = prevMsg ? parseSenderFromText(prevMsg.text).sender : null;
+          const prevParsedSender =
+            prevMsg && prevMsg.type === 'CHAN' ? parseSenderFromText(prevMsg.text).sender : null;
          const prevSenderKey = prevMsg
            ? getSenderKey(
                prevMsg,
@@ -32,7 +32,12 @@ interface NewMessageModalProps {
    nonce: number;
  } | null;
  onClose: () => void;
-  onCreateContact: (name: string, publicKey: string, tryHistorical: boolean) => Promise<void>;
+  onCreateContact: (
+    name: string,
+    publicKey: string,
+    tryHistorical: boolean,
+    type?: number
+  ) => Promise<void>;
  onCreateChannel: (name: string, key: string, tryHistorical: boolean) => Promise<void>;
  onCreateHashtagChannel: (name: string, tryHistorical: boolean) => Promise<void>;
  onBulkAddHashtagChannels: (channelNames: string[], tryHistorical: boolean) => Promise<void>;
@@ -91,6 +96,7 @@ export function NewMessageModal({
 }: NewMessageModalProps) {
  const [tab, setTab] = useState<Tab>('new-contact');
  const [name, setName] = useState('');
+  const [contactType, setContactType] = useState(1);
  const [contactKey, setContactKey] = useState('');
  const [channelKey, setChannelKey] = useState('');
  const [bulkChannelText, setBulkChannelText] = useState('');
@@ -103,6 +109,7 @@ export function NewMessageModal({

  const resetForm = () => {
    setName('');
+    setContactType(1);
    setContactKey('');
    setChannelKey('');
    setBulkChannelText('');
@@ -161,7 +168,7 @@ export function NewMessageModal({
          setError('Name and public key are required');
          return;
        }
-        await onCreateContact(name.trim(), contactKey.trim(), tryHistorical);
+        await onCreateContact(name.trim(), contactKey.trim(), tryHistorical, contactType);
      } else if (tab === 'new-channel') {
        if (!name.trim() || !channelKey.trim()) {
          setError('Channel name and key are required');
@@ -183,11 +190,11 @@ export function NewMessageModal({
          permitCapitals
        );
        if (channelNames.length === 0) {
-          setError('Enter at least one valid room name');
+          setError('Enter at least one valid channel name');
          return;
        }
        if (invalidNames.length > 0) {
-          setError(`Invalid room names: ${invalidNames.join(', ')}`);
+          setError(`Invalid channel names: ${invalidNames.join(', ')}`);
          return;
        }
        await onBulkAddHashtagChannels(channelNames, tryHistorical);
@@ -249,7 +256,7 @@ export function NewMessageModal({
            {tab === 'new-contact' && 'Add a new contact by entering their name and public key'}
            {tab === 'new-channel' && 'Create a private channel with a shared encryption key'}
            {tab === 'hashtag' && 'Join a public hashtag channel'}
-            {tab === 'bulk-hashtag' && 'Paste multiple hashtag rooms to add them in one batch'}
+            {tab === 'bulk-hashtag' && 'Paste multiple hashtag channels to add them in one batch'}
          </DialogDescription>
        </DialogHeader>

@@ -293,6 +300,19 @@ export function NewMessageModal({
                placeholder="64-character hex public key"
              />
            </div>
+            <div className="space-y-2">
+              <Label htmlFor="contact-type">Type</Label>
+              <select
+                id="contact-type"
+                value={contactType}
+                onChange={(e) => setContactType(Number(e.target.value))}
+                className="block h-9 w-full rounded-md border border-input bg-background px-3 text-sm shadow-sm"
+              >
+                <option value={1}>Client</option>
+                <option value={2}>Repeater</option>
+                <option value={3}>Room Server</option>
+              </select>
+            </div>
          </TabsContent>

          <TabsContent value="new-channel" className="mt-4 space-y-4">
@@ -377,11 +397,11 @@ export function NewMessageModal({
                  aria-label="Bulk channel names"
                  value={bulkChannelText}
                  onChange={(e) => setBulkChannelText(e.target.value)}
-                  placeholder={'#ops\nmesh-room\nanother-room'}
+                  placeholder={'#ops\nmesh-chat\nanother-channel'}
                  className="min-h-48 w-full rounded-md border border-input bg-background px-3 py-2 text-sm shadow-sm outline-none transition-colors placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-ring"
                />
                <p className="text-xs text-muted-foreground">
-                  Paste room names separated by lines, spaces, or commas. Leading # marks are
+                  Paste channel names separated by lines, spaces, or commas. Leading # marks are
                  stripped automatically.
                </p>
              </div>
@@ -300,6 +300,7 @@ export function RepeaterDashboard({
          />
        )}
      </header>
+      <div data-toast-anchor="conversation" aria-hidden="true" />

      {/* Body */}
      <div className="flex-1 overflow-y-auto p-4">
@@ -2,6 +2,7 @@ import { useState, useEffect, type ReactNode } from 'react';
 import type {
  AppSettings,
  AppSettingsUpdate,
+  Channel,
  Contact,
  HealthStatus,
  RadioAdvertMode,
@@ -49,6 +50,7 @@ interface SettingsModalBaseProps {
  onToggleBlockedKey?: (key: string) => void;
  onToggleBlockedName?: (name: string) => void;
  contacts?: Contact[];
+  channels?: Channel[];
  onBulkDeleteContacts?: (deletedKeys: string[]) => void;
  trackedTelemetryRepeaters?: string[];
  onToggleTrackedTelemetry?: (publicKey: string) => Promise<void>;
@@ -86,6 +88,7 @@ export function SettingsModal(props: SettingsModalProps) {
    onToggleBlockedKey,
    onToggleBlockedName,
    contacts,
+    channels,
    onBulkDeleteContacts,
    trackedTelemetryRepeaters,
    onToggleTrackedTelemetry,
@@ -228,6 +231,8 @@ export function SettingsModal(props: SettingsModalProps) {
          {isSectionVisible('local') && (
            <SettingsLocalSection
              onLocalLabelChange={onLocalLabelChange}
+              contacts={contacts}
+              channels={channels}
              className={sectionContentClass}
            />
          )}
@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
  Bell,
+  BellOff,
  Cable,
  ChartNetwork,
  CheckCheck,
@@ -49,6 +50,7 @@ type ConversationRow = {
  unreadCount: number;
  isMention: boolean;
  notificationsEnabled: boolean;
+  muted?: boolean;
  contact?: Contact;
 };

@@ -250,6 +252,10 @@ export function Sidebar({
        if (isPublicChannelKey(a.key)) return -1;
        if (isPublicChannelKey(b.key)) return 1;

+        // Muted channels always sort to the bottom
+        if (a.muted && !b.muted) return 1;
+        if (!a.muted && b.muted) return -1;
+
        if (sectionSortOrders.channels === 'recent') {
          const timeA = getLastMessageTime('channel', a.key);
          const timeB = getLastMessageTime('channel', b.key);
@@ -265,6 +271,12 @@ export function Sidebar({
  const sortContactsByOrder = useCallback(
    (items: Contact[], order: SortOrder) =>
      [...items].sort((a, b) => {
+        // Unread DM contacts always float to the top
+        const unreadA = unreadCounts[getStateKey('contact', a.public_key)] || 0;
+        const unreadB = unreadCounts[getStateKey('contact', b.public_key)] || 0;
+        if (unreadA > 0 && unreadB === 0) return -1;
+        if (unreadA === 0 && unreadB > 0) return 1;
+
        if (order === 'recent') {
          const timeA = getContactRecentTime(a);
          const timeB = getContactRecentTime(b);
@@ -274,7 +286,7 @@ export function Sidebar({
        }
        return (a.name || a.public_key).localeCompare(b.name || b.public_key);
      }),
-    [getContactRecentTime]
+    [getContactRecentTime, unreadCounts]
  );

  const sortRepeatersByOrder = useCallback(
@@ -524,9 +536,10 @@ export function Sidebar({
    type: 'channel',
    id: channel.key,
    name: channel.name,
-    unreadCount: getUnreadCount('channel', channel.key),
-    isMention: hasMention('channel', channel.key),
+    unreadCount: channel.muted ? 0 : getUnreadCount('channel', channel.key),
+    isMention: channel.muted ? false : hasMention('channel', channel.key),
    notificationsEnabled: isConversationNotificationsEnabled?.('channel', channel.key) ?? false,
+    muted: channel.muted,
  });

  const buildContactRow = (contact: Contact, keyPrefix: string): ConversationRow => ({
@@ -578,23 +591,31 @@ export function Sidebar({
        )}
        <span className="name flex-1 truncate text-[0.8125rem]">{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" />
+          {row.muted ? (
+            <span aria-label="Channel muted" title="Channel muted">
+              <BellOff className="h-3.5 w-3.5 text-muted-foreground" />
            </span>
-          )}
-          {row.unreadCount > 0 && (
-            <span
-              className={cn(
-                'text-[0.625rem] 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'
+          ) : (
+            <>
+              {row.notificationsEnabled && (
+                <span aria-label="Notifications enabled" title="Notifications enabled">
+                  <Bell className="h-3.5 w-3.5 text-muted-foreground" />
+                </span>
              )}
-              aria-label={`${row.unreadCount} unread message${row.unreadCount !== 1 ? 's' : ''}`}
-            >
-              {row.unreadCount}
-            </span>
+              {row.unreadCount > 0 && (
+                <span
+                  className={cn(
+                    'text-[0.625rem] 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>
@@ -12,13 +12,21 @@ import type { HealthStatus, RadioConfig } from '../types';
 import { api } from '../api';
 import { toast } from './ui/sonner';
 import { handleKeyboardActivate } from '../utils/a11y';
-import { applyTheme, getSavedTheme, THEME_CHANGE_EVENT } from '../utils/theme';
+import { applyTheme, getEffectiveTheme, THEME_CHANGE_EVENT } from '../utils/theme';
 import {
  BATTERY_DISPLAY_CHANGE_EVENT,
  getShowBatteryPercent,
  getShowBatteryVoltage,
  mvToPercent,
 } from '../utils/batteryDisplay';
+import {
+  STATUS_DOT_PULSE_CHANGE_EVENT,
+  STATUS_DOT_PULSE_DURATION_MS,
+  STATUS_DOT_PULSE_PACKET_EVENT,
+  getStatusDotPulseEnabled,
+  pulseColorFor,
+  type StatusDotPulseKind,
+} from '../utils/statusDotPulse';
 import { cn } from '@/lib/utils';

 interface StatusBarProps {
@@ -84,17 +92,71 @@ export function StatusBar({
            ? 'Radio OK'
            : 'Radio Disconnected';
  const [reconnecting, setReconnecting] = useState(false);
-  const [currentTheme, setCurrentTheme] = useState(getSavedTheme);
+  // Track the *effective* theme (follow-os is resolved to original/light) so the
+  // toggle icon and action match what the user currently sees rendered.
+  const [currentTheme, setCurrentTheme] = useState(getEffectiveTheme);
+  const [pulseEnabled, setPulseEnabled] = useState(getStatusDotPulseEnabled);
+  const [pulseKind, setPulseKind] = useState<StatusDotPulseKind | null>(null);

  useEffect(() => {
-    const handleThemeChange = (event: Event) => {
-      const themeId = (event as CustomEvent<string>).detail;
-      setCurrentTheme(typeof themeId === 'string' && themeId ? themeId : getSavedTheme());
-    };
+    const handler = () => setPulseEnabled(getStatusDotPulseEnabled());
+    window.addEventListener(STATUS_DOT_PULSE_CHANGE_EVENT, handler);
+    return () => window.removeEventListener(STATUS_DOT_PULSE_CHANGE_EVENT, handler);
+  }, []);

-    window.addEventListener(THEME_CHANGE_EVENT, handleThemeChange as EventListener);
+  useEffect(() => {
+    if (!pulseEnabled) {
+      setPulseKind(null);
+      return;
+    }
+    let timer: number | null = null;
+    const handler = (event: Event) => {
+      const kind = (event as CustomEvent<StatusDotPulseKind>).detail;
+      setPulseKind(kind);
+      if (timer !== null) {
+        window.clearTimeout(timer);
+      }
+      timer = window.setTimeout(() => {
+        setPulseKind(null);
+        timer = null;
+      }, STATUS_DOT_PULSE_DURATION_MS);
+    };
+    window.addEventListener(STATUS_DOT_PULSE_PACKET_EVENT, handler);
    return () => {
-      window.removeEventListener(THEME_CHANGE_EVENT, handleThemeChange as EventListener);
+      window.removeEventListener(STATUS_DOT_PULSE_PACKET_EVENT, handler);
+      if (timer !== null) {
+        window.clearTimeout(timer);
+      }
+    };
+  }, [pulseEnabled]);
+
+  useEffect(() => {
+    const syncEffective = () => setCurrentTheme(getEffectiveTheme());
+    window.addEventListener(THEME_CHANGE_EVENT, syncEffective);
+
+    // When saved theme is "follow-os", OS appearance changes alter the effective
+    // theme without firing a THEME_CHANGE_EVENT, so also watch matchMedia.
+    const mql =
+      typeof window.matchMedia === 'function'
+        ? window.matchMedia('(prefers-color-scheme: light)')
+        : null;
+    if (mql) {
+      if (typeof mql.addEventListener === 'function') {
+        mql.addEventListener('change', syncEffective);
+      } else if (typeof (mql as MediaQueryList).addListener === 'function') {
+        (mql as MediaQueryList).addListener(syncEffective);
+      }
+    }
+
+    return () => {
+      window.removeEventListener(THEME_CHANGE_EVENT, syncEffective);
+      if (mql) {
+        if (typeof mql.removeEventListener === 'function') {
+          mql.removeEventListener('change', syncEffective);
+        } else if (typeof (mql as MediaQueryList).removeListener === 'function') {
+          (mql as MediaQueryList).removeListener(syncEffective);
+        }
+      }
    };
  }, []);

@@ -154,9 +216,12 @@ export function StatusBar({
            radioState === 'initializing' || radioState === 'connecting'
              ? 'bg-warning'
              : connected
-                ? 'bg-status-connected shadow-[0_0_6px_hsl(var(--status-connected)/0.5)]'
+                ? pulseKind
+                  ? ''
+                  : 'bg-status-connected shadow-[0_0_6px_hsl(var(--status-connected)/0.5)]'
                : 'bg-status-disconnected'
          )}
+          style={connected && pulseKind ? { backgroundColor: pulseColorFor(pulseKind) } : undefined}
          aria-hidden="true"
        />
        <span className="hidden lg:inline text-muted-foreground">{statusLabel}</span>
@@ -1,4 +1,6 @@
-import { RepeaterPane, NotFetched, LppSensorRow } from './repeaterPaneShared';
+import { useMemo } from 'react';
+import { RepeaterPane, NotFetched, LppSensorRow, formatLppLabel } from './repeaterPaneShared';
+import { useDistanceUnit } from '../../contexts/DistanceUnitContext';
 import type { RepeaterLppTelemetryResponse, PaneState } from '../../types';

 export function LppTelemetryPane({
@@ -12,6 +14,20 @@ export function LppTelemetryPane({
  onRefresh: () => void;
  disabled?: boolean;
 }) {
+  const { distanceUnit } = useDistanceUnit();
+
+  // Build disambiguated labels matching the telemetry history chart names
+  const labels = useMemo(() => {
+    if (!data) return [];
+    const counts = new Map<string, number>();
+    return data.sensors.map((s) => {
+      const base = `${s.type_name}_${s.channel}`;
+      const n = (counts.get(base) ?? 0) + 1;
+      counts.set(base, n);
+      return formatLppLabel(s.type_name) + ` Ch${s.channel}` + (n > 1 ? ` (${n})` : '');
+    });
+  }, [data]);
+
  return (
    <RepeaterPane title="LPP Sensors" state={state} onRefresh={onRefresh} disabled={disabled}>
      {!data ? (
@@ -21,7 +37,7 @@ export function LppTelemetryPane({
      ) : (
        <div className="space-y-0.5">
          {data.sensors.map((sensor, i) => (
-            <LppSensorRow key={i} sensor={sensor} />
+            <LppSensorRow key={i} sensor={sensor} unitPref={distanceUnit} label={labels[i]} />
          ))}
        </div>
      )}
@@ -1,6 +1,15 @@
 import { RepeaterPane, NotFetched, KvRow } from './repeaterPaneShared';
 import type { RepeaterOwnerInfoResponse, PaneState } from '../../types';

+function LabeledBlock({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="py-0.5">
+      <span className="text-sm text-muted-foreground whitespace-nowrap">{label}</span>
+      <p className="text-sm font-medium mt-0.5 break-words">{value}</p>
+    </div>
+  );
+}
+
 export function OwnerInfoPane({
  data,
  state,
@@ -17,8 +26,8 @@ export function OwnerInfoPane({
      {!data ? (
        <NotFetched />
      ) : (
-        <div className="break-all">
-          <KvRow label="Owner Info" value={data.owner_info ?? '—'} />
+        <div className="space-y-1">
+          <LabeledBlock label="Owner Info" value={data.owner_info ?? '—'} />
          <KvRow label="Guest Password" value={data.guest_password ?? '—'} />
        </div>
      )}
@@ -11,19 +11,52 @@ import {
 import { cn } from '@/lib/utils';
 import { Button } from '../ui/button';
 import { Separator } from '../ui/separator';
-import type { TelemetryHistoryEntry, Contact } from '../../types';
+import { lppDisplayUnit } from './repeaterPaneShared';
+import { useDistanceUnit } from '../../contexts/DistanceUnitContext';
+import type { TelemetryHistoryEntry, TelemetryLppSensor, Contact } from '../../types';

 const MAX_TRACKED = 8;

-type Metric = 'battery_volts' | 'noise_floor_dbm' | 'packets' | 'uptime_seconds';
+type BuiltinMetric =
+  | 'battery_volts'
+  | 'noise_floor_dbm'
+  | 'packets'
+  | 'recv_errors'
+  | 'uptime_seconds';

-const METRIC_CONFIG: Record<Metric, { label: string; unit: string; color: string }> = {
+interface MetricConfig {
+  label: string;
+  unit: string;
+  color: string;
+}
+
+const BUILTIN_METRIC_CONFIG: Record<BuiltinMetric, MetricConfig> = {
  battery_volts: { label: 'Voltage', unit: 'V', color: '#22c55e' },
  noise_floor_dbm: { label: 'Noise Floor', unit: 'dBm', color: '#8b5cf6' },
  packets: { label: 'Packets', unit: '', color: '#0ea5e9' },
+  recv_errors: { label: 'RX Errors', unit: '', color: '#ef4444' },
  uptime_seconds: { label: 'Uptime', unit: 's', color: '#f59e0b' },
 };

+const BUILTIN_METRICS: BuiltinMetric[] = Object.keys(BUILTIN_METRIC_CONFIG) as BuiltinMetric[];
+
+// Stable color rotation for dynamic LPP sensors
+const LPP_COLORS = ['#ec4899', '#14b8a6', '#f97316', '#6366f1', '#84cc16', '#e11d48'];
+
+/** Assign disambiguated flat keys to an array of LPP sensors.
+ *  First occurrence keeps the base key; duplicates of the same (type, channel) get _2, _3, etc. */
+function assignLppKeys(
+  sensors: TelemetryLppSensor[]
+): { sensor: TelemetryLppSensor; key: string; occurrence: number }[] {
+  const counts = new Map<string, number>();
+  return sensors.map((s) => {
+    const base = `lpp_${s.type_name}_ch${s.channel}`;
+    const n = (counts.get(base) ?? 0) + 1;
+    counts.set(base, n);
+    return { sensor: s, key: n === 1 ? base : `${base}_${n}`, occurrence: n };
+  });
+}
+
 const TOOLTIP_STYLE = {
  contentStyle: {
    backgroundColor: 'hsl(var(--popover))',
@@ -66,38 +99,115 @@ export function TelemetryHistoryPane({
  trackedTelemetryRepeaters,
  onToggleTrackedTelemetry,
 }: TelemetryHistoryPaneProps) {
-  const [metric, setMetric] = useState<Metric>('battery_volts');
+  const { distanceUnit } = useDistanceUnit();
+  const [metric, setMetric] = useState<string>('battery_volts');
  const [toggling, setToggling] = useState(false);

  const isTracked = trackedTelemetryRepeaters.includes(publicKey);
  const slotsFull = trackedTelemetryRepeaters.length >= MAX_TRACKED && !isTracked;

-  const config = METRIC_CONFIG[metric];
+  // Discover unique LPP sensors across all history entries
+  const lppMetrics = useMemo(() => {
+    const seen = new Map<string, { type_name: string; channel: number; occurrence: number }>();
+    for (const e of entries) {
+      for (const { sensor: s, key: k, occurrence } of assignLppKeys(e.data.lpp_sensors ?? [])) {
+        if (!seen.has(k)) seen.set(k, { type_name: s.type_name, channel: s.channel, occurrence });
+      }
+    }
+    const result: { key: string; config: MetricConfig; type_name: string; channel: number }[] = [];
+    let colorIdx = 0;
+    for (const [k, info] of seen) {
+      const label =
+        info.type_name.charAt(0).toUpperCase() +
+        info.type_name.slice(1).replace(/_/g, ' ') +
+        ` Ch${info.channel}` +
+        (info.occurrence > 1 ? ` (${info.occurrence})` : '');
+      const { unit } = lppDisplayUnit(info.type_name, 0, distanceUnit);
+      result.push({
+        key: k,
+        config: { label, unit, color: LPP_COLORS[colorIdx % LPP_COLORS.length] },
+        type_name: info.type_name,
+        channel: info.channel,
+      });
+      colorIdx++;
+    }
+    return result;
+  }, [entries, distanceUnit]);
+
+  const allMetricKeys = useMemo(
+    () => [...BUILTIN_METRICS, ...lppMetrics.map((m) => m.key)],
+    [lppMetrics]
+  );
+
+  // If the selected metric disappears (e.g. different repeater), reset to default
+  const activeMetric = allMetricKeys.includes(metric) ? metric : 'battery_volts';
+
+  const isBuiltin = BUILTIN_METRICS.includes(activeMetric as BuiltinMetric);
+  const activeConfig: MetricConfig = isBuiltin
+    ? BUILTIN_METRIC_CONFIG[activeMetric as BuiltinMetric]
+    : (lppMetrics.find((m) => m.key === activeMetric)?.config ?? {
+        label: activeMetric,
+        unit: '',
+        color: '#888',
+      });

  const chartData = useMemo(() => {
    return entries.map((e) => {
      const d = e.data;
-      return {
+      const recvErrors = d.recv_errors ?? undefined;
+      const packetsReceived = d.packets_received;
+      const point: Record<string, number | undefined> = {
        timestamp: e.timestamp,
        battery_volts: d.battery_volts,
        noise_floor_dbm: d.noise_floor_dbm,
-        packets_received: d.packets_received,
+        packets_received: packetsReceived,
        packets_sent: d.packets_sent,
+        recv_errors: recvErrors,
+        recv_error_pct:
+          recvErrors != null && packetsReceived != null && packetsReceived + recvErrors > 0
+            ? +((recvErrors / (packetsReceived + recvErrors)) * 100).toFixed(2)
+            : undefined,
        uptime_seconds: d.uptime_seconds,
      };
+      // Flatten LPP sensors into the point, converting units as needed
+      for (const { sensor: s, key } of assignLppKeys(d.lpp_sensors ?? [])) {
+        if (typeof s.value === 'number') {
+          point[key] = lppDisplayUnit(s.type_name, s.value, distanceUnit).value;
+        }
+      }
+      return point;
    });
-  }, [entries]);
+  }, [entries, distanceUnit]);

-  const dataKeys = metric === 'packets' ? ['packets_received', 'packets_sent'] : [metric];
+  const dataKeys =
+    activeMetric === 'packets'
+      ? ['packets_received', 'packets_sent']
+      : activeMetric === 'recv_errors'
+        ? ['recv_errors', 'recv_error_pct']
+        : [activeMetric];

  const yDomain = useMemo<[number, number] | undefined>(() => {
-    if (metric !== 'battery_volts' || chartData.length === 0) return undefined;
+    if (activeMetric !== 'battery_volts' || chartData.length === 0) return undefined;
    const values = chartData.map((d) => d.battery_volts).filter((v) => v != null) as number[];
    if (values.length === 0) return [3, 5];
    const lo = Math.min(...values);
    const hi = Math.max(...values);
    return [Math.min(3, Math.floor(lo) - 1), Math.max(5, Math.ceil(hi) + 1)];
-  }, [metric, chartData]);
+  }, [activeMetric, chartData]);
+
+  const yDomainPct = useMemo<[number, number]>(() => {
+    const MIN_SPAN = 5;
+    const values = chartData.map((d) => d.recv_error_pct).filter((v) => v != null) as number[];
+    if (values.length === 0) return [0, MIN_SPAN];
+    const lo = Math.min(...values);
+    const hi = Math.max(...values);
+    const span = hi - lo;
+    if (span >= MIN_SPAN)
+      return [Math.max(0, Math.floor(lo - span * 0.1)), Math.ceil(hi + span * 0.1)];
+    const pad = (MIN_SPAN - span) / 2;
+    const bottom = Math.max(0, Math.floor(lo - pad));
+    return [bottom, Math.ceil(bottom + MIN_SPAN)];
+  }, [chartData]);

  const handleToggle = async () => {
    setToggling(true);
@@ -135,16 +245,16 @@ export function TelemetryHistoryPane({
            via the repeater pane, API calls to the endpoint (
            <code className="text-[0.6875rem]">POST /api/contacts/&lt;key&gt;/repeater/status</code>
            ), or when the repeater is opted into interval telemetry polling, in which case the
-            repeater will be polled for metrics every 8 hours. You can see which repeaters are opted
-            into this flow in the{' '}
+            repeater will be polled for metrics automatically. Fetch frequency can be configured in{' '}
            <a
              href="#settings/database"
              className="underline text-primary hover:text-primary/80 transition-colors"
            >
-              Database &amp; Messaging
-            </a>{' '}
-            settings pane. A maximum of {MAX_TRACKED} repeaters may be opted into this for the sake
-            of keeping mesh congestion reasonable.
+              Settings &rarr; Database &amp; Messaging
+            </a>
+            , where you can also see which repeaters are currently opted in. A maximum of{' '}
+            {MAX_TRACKED} repeaters may be opted into this for the sake of keeping mesh congestion
+            reasonable.
          </p>

          {isTracked ? (
@@ -173,7 +283,7 @@ export function TelemetryHistoryPane({
              disabled={toggling}
              className="border-green-600/50 text-green-600 hover:bg-green-600/10"
            >
-              {toggling ? 'Updating...' : 'Opt Repeater into 8hr Interval Metrics Tracking'}
+              {toggling ? 'Updating...' : 'Opt Repeater into Interval Metrics Tracking'}
            </Button>
          )}
        </div>
@@ -181,20 +291,35 @@ export function TelemetryHistoryPane({
        <Separator className="mb-3" />

        {/* Metric selector */}
-        <div className="flex gap-1 mb-2">
-          {(Object.keys(METRIC_CONFIG) as Metric[]).map((m) => (
+        <div className="flex flex-wrap gap-1 mb-2">
+          {BUILTIN_METRICS.map((m) => (
            <button
              key={m}
              type="button"
              onClick={() => setMetric(m)}
              className={cn(
                'text-[0.6875rem] px-2 py-0.5 rounded transition-colors',
-                metric === m
+                activeMetric === m
                  ? 'bg-primary text-primary-foreground'
                  : 'text-muted-foreground hover:text-foreground hover:bg-accent'
              )}
            >
-              {METRIC_CONFIG[m].label}
+              {BUILTIN_METRIC_CONFIG[m].label}
+            </button>
+          ))}
+          {lppMetrics.map((m) => (
+            <button
+              key={m.key}
+              type="button"
+              onClick={() => setMetric(m.key)}
+              className={cn(
+                'text-[0.6875rem] px-2 py-0.5 rounded transition-colors',
+                activeMetric === m.key
+                  ? 'bg-primary text-primary-foreground'
+                  : 'text-muted-foreground hover:text-foreground hover:bg-accent'
+              )}
+            >
+              {m.config.label}
            </button>
          ))}
        </div>
@@ -205,7 +330,15 @@ export function TelemetryHistoryPane({
          </p>
        ) : (
          <ResponsiveContainer width="100%" height={180}>
-            <AreaChart data={chartData} margin={{ top: 4, right: 4, bottom: 0, left: -8 }}>
+            <AreaChart
+              data={chartData}
+              margin={{
+                top: 4,
+                right: activeMetric === 'recv_errors' ? 8 : 4,
+                bottom: 0,
+                left: -8,
+              }}
+            >
              <CartesianGrid strokeDasharray="3 3" stroke="hsl(var(--border))" vertical={false} />
              <XAxis
                dataKey="timestamp"
@@ -217,12 +350,26 @@ export function TelemetryHistoryPane({
                tickFormatter={formatTime}
              />
              <YAxis
+                yAxisId="left"
                domain={yDomain}
                tick={{ fontSize: 10, fill: 'hsl(var(--muted-foreground))' }}
                tickLine={false}
                axisLine={false}
-                tickFormatter={(v) => (metric === 'uptime_seconds' ? formatUptime(v) : `${v}`)}
+                tickFormatter={(v) =>
+                  activeMetric === 'uptime_seconds' ? formatUptime(v) : `${v}`
+                }
              />
+              {activeMetric === 'recv_errors' && (
+                <YAxis
+                  yAxisId="right"
+                  orientation="right"
+                  domain={yDomainPct}
+                  tick={{ fontSize: 10, fill: 'hsl(var(--muted-foreground))' }}
+                  tickLine={false}
+                  axisLine={false}
+                  tickFormatter={(v) => `${v}%`}
+                />
+              )}
              <RechartsTooltip
                {...TOOLTIP_STYLE}
                cursor={{
@@ -234,41 +381,65 @@ export function TelemetryHistoryPane({
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                formatter={(value: any, name: any) => {
                  const numVal = typeof value === 'number' ? value : Number(value);
-                  const display = metric === 'uptime_seconds' ? formatUptime(numVal) : `${value}`;
+                  if (activeMetric === 'recv_errors') {
+                    if (name === 'recv_error_pct') return [`${numVal}%`, 'Error Rate'];
+                    return [`${value}`, 'RX Errors'];
+                  }
+                  const display =
+                    activeMetric === 'uptime_seconds' ? formatUptime(numVal) : `${value}`;
                  const suffix =
-                    metric === 'uptime_seconds' ? '' : config.unit ? ` ${config.unit}` : '';
+                    activeMetric === 'uptime_seconds'
+                      ? ''
+                      : activeConfig.unit
+                        ? ` ${activeConfig.unit}`
+                        : '';
                  const label =
-                    metric === 'packets'
+                    activeMetric === 'packets'
                      ? name === 'packets_received'
                        ? 'Received'
                        : 'Sent'
-                      : config.label;
+                      : activeConfig.label;
                  return [`${display}${suffix}`, label];
                }}
              />
-              {dataKeys.map((key, i) => (
-                <Area
-                  key={key}
-                  type="linear"
-                  dataKey={key}
-                  stroke={metric === 'packets' ? (i === 0 ? '#0ea5e9' : '#f43f5e') : config.color}
-                  fill={metric === 'packets' ? (i === 0 ? '#0ea5e9' : '#f43f5e') : config.color}
-                  fillOpacity={0.15}
-                  strokeWidth={1.5}
-                  dot={{
-                    r: 4,
-                    fill: metric === 'packets' ? (i === 0 ? '#0ea5e9' : '#f43f5e') : config.color,
-                    strokeWidth: 1.5,
-                    stroke: 'hsl(var(--popover))',
-                  }}
-                  activeDot={{
-                    r: 6,
-                    fill: metric === 'packets' ? (i === 0 ? '#0ea5e9' : '#f43f5e') : config.color,
-                    strokeWidth: 2,
-                    stroke: 'hsl(var(--popover))',
-                  }}
-                />
-              ))}
+              {dataKeys.map((key, i) => {
+                const color =
+                  activeMetric === 'packets'
+                    ? i === 0
+                      ? '#0ea5e9'
+                      : '#f43f5e'
+                    : activeMetric === 'recv_errors'
+                      ? i === 0
+                        ? '#ef4444'
+                        : '#f59e0b'
+                      : activeConfig.color;
+                return (
+                  <Area
+                    key={key}
+                    type="linear"
+                    dataKey={key}
+                    yAxisId={
+                      activeMetric === 'recv_errors' && key === 'recv_error_pct' ? 'right' : 'left'
+                    }
+                    stroke={color}
+                    fill={color}
+                    fillOpacity={0.15}
+                    strokeWidth={1.5}
+                    dot={{
+                      r: 4,
+                      fill: color,
+                      strokeWidth: 1.5,
+                      stroke: 'hsl(var(--popover))',
+                    }}
+                    activeDot={{
+                      r: 6,
+                      fill: color,
+                      strokeWidth: 2,
+                      stroke: 'hsl(var(--popover))',
+                    }}
+                  />
+                );
+              })}
            </AreaChart>
          </ResponsiveContainer>
        )}
@@ -1,7 +1,23 @@
+import type { ReactNode } from 'react';
 import { Separator } from '../ui/separator';
 import { RepeaterPane, NotFetched, KvRow, formatDuration } from './repeaterPaneShared';
 import type { RepeaterStatusResponse, PaneState } from '../../types';

+function Secondary({ children }: { children: ReactNode }) {
+  return <span className="ml-1.5 font-normal text-muted-foreground">{children}</span>;
+}
+
+function formatAirtimePercent(airtimeSec: number, uptimeSec: number): string | null {
+  if (uptimeSec <= 0) return null;
+  return `${((airtimeSec / uptimeSec) * 100).toFixed(2)}%`;
+}
+
+function formatPerMinute(count: number, uptimeSec: number): string | null {
+  if (uptimeSec <= 0) return null;
+  const rate = (count * 60) / uptimeSec;
+  return rate >= 10 ? rate.toFixed(0) : rate.toFixed(1);
+}
+
 export function TelemetryPane({
  data,
  state,
@@ -13,6 +29,11 @@ export function TelemetryPane({
  onRefresh: () => void;
  disabled?: boolean;
 }) {
+  const txPct = data ? formatAirtimePercent(data.airtime_seconds, data.uptime_seconds) : null;
+  const rxPct = data ? formatAirtimePercent(data.rx_airtime_seconds, data.uptime_seconds) : null;
+  const rxPerMin = data ? formatPerMinute(data.packets_received, data.uptime_seconds) : null;
+  const txPerMin = data ? formatPerMinute(data.packets_sent, data.uptime_seconds) : null;
+
  return (
    <RepeaterPane title="Telemetry" state={state} onRefresh={onRefresh} disabled={disabled}>
      {!data ? (
@@ -21,8 +42,24 @@ export function TelemetryPane({
        <div className="space-y-2">
          <KvRow label="Battery" value={`${data.battery_volts.toFixed(3)}V`} />
          <KvRow label="Uptime" value={formatDuration(data.uptime_seconds)} />
-          <KvRow label="TX Airtime" value={formatDuration(data.airtime_seconds)} />
-          <KvRow label="RX Airtime" value={formatDuration(data.rx_airtime_seconds)} />
+          <KvRow
+            label="TX Airtime"
+            value={
+              <>
+                {formatDuration(data.airtime_seconds)}
+                {txPct && <Secondary>({txPct})</Secondary>}
+              </>
+            }
+          />
+          <KvRow
+            label="RX Airtime"
+            value={
+              <>
+                {formatDuration(data.rx_airtime_seconds)}
+                {rxPct && <Secondary>({rxPct})</Secondary>}
+              </>
+            }
+          />
          <Separator className="my-1" />
          <KvRow label="Noise Floor" value={`${data.noise_floor_dbm} dBm`} />
          <KvRow label="Last RSSI" value={`${data.last_rssi_dbm} dBm`} />
@@ -30,7 +67,17 @@ export function TelemetryPane({
          <Separator className="my-1" />
          <KvRow
            label="Packets"
-            value={`${data.packets_received.toLocaleString()} rx / ${data.packets_sent.toLocaleString()} tx`}
+            value={
+              <>
+                {data.packets_received.toLocaleString()} rx / {data.packets_sent.toLocaleString()}{' '}
+                tx
+                {rxPerMin && txPerMin && (
+                  <Secondary>
+                    (avg {rxPerMin} rx/min / {txPerMin} tx/min)
+                  </Secondary>
+                )}
+              </>
+            }
          />
          <KvRow
            label="Flood"
@@ -44,6 +91,26 @@ export function TelemetryPane({
            label="Duplicates"
            value={`${data.flood_dups.toLocaleString()} flood / ${data.direct_dups.toLocaleString()} direct`}
          />
+          {data.recv_errors != null && (
+            <KvRow
+              label="RX Errors"
+              value={
+                <>
+                  {data.recv_errors.toLocaleString()}
+                  {data.packets_received > 0 && (
+                    <Secondary>
+                      (
+                      {(
+                        (data.recv_errors / (data.packets_received + data.recv_errors)) *
+                        100
+                      ).toFixed(2)}
+                      %)
+                    </Secondary>
+                  )}
+                </>
+              }
+            />
+          )}
          <Separator className="my-1" />
          <KvRow label="TX Queue" value={data.tx_queue_len} />
          <KvRow label="Debug Flags" value={data.full_events} />
@@ -223,12 +223,35 @@ export const LPP_UNIT_MAP: Record<string, string> = {
  colour: '',
 };

+/**
+ * Return the display unit and converted value for an LPP sensor,
+ * respecting the user's unit preference for temperature.
+ */
+export function lppDisplayUnit(
+  typeName: string,
+  value: number,
+  unitPref: 'metric' | 'imperial' | string
+): { unit: string; value: number } {
+  if (typeName === 'temperature' && unitPref === 'imperial') {
+    return { unit: '°F', value: (value * 9) / 5 + 32 };
+  }
+  return { unit: LPP_UNIT_MAP[typeName] ?? '', value };
+}
+
 export function formatLppLabel(typeName: string): string {
  return typeName.charAt(0).toUpperCase() + typeName.slice(1).replace(/_/g, ' ');
 }

-export function LppSensorRow({ sensor }: { sensor: LppSensor }) {
-  const label = formatLppLabel(sensor.type_name);
+export function LppSensorRow({
+  sensor,
+  unitPref,
+  label: labelOverride,
+}: {
+  sensor: LppSensor;
+  unitPref?: string;
+  label?: string;
+}) {
+  const label = labelOverride ?? formatLppLabel(sensor.type_name);

  if (typeof sensor.value === 'object' && sensor.value !== null) {
    // Multi-value sensor (GPS, accelerometer, etc.)
@@ -248,10 +271,10 @@ export function LppSensorRow({ sensor }: { sensor: LppSensor }) {
    );
  }

-  const unit = LPP_UNIT_MAP[sensor.type_name] ?? '';
+  const display = lppDisplayUnit(sensor.type_name, sensor.value as number, unitPref ?? 'metric');
  const formatted =
    typeof sensor.value === 'number'
-      ? `${sensor.value % 1 === 0 ? sensor.value : sensor.value.toFixed(2)}${unit ? ` ${unit}` : ''}`
+      ? `${display.value % 1 === 0 ? display.value : display.value.toFixed(2)}${display.unit ? ` ${display.unit}` : ''}`
      : String(sensor.value);

  return <KvRow label={label} value={formatted} />;
@@ -15,6 +15,9 @@ const CONTACT_TYPE_LABELS: Record<number, string> = {
  4: 'Sensor',
 };

+type SortField = 'name' | 'type' | 'key' | 'first_seen' | 'last_seen';
+type SortDir = 'asc' | 'desc';
+
 function formatDate(ts: number): string {
  return new Date(ts * 1000).toLocaleDateString([], {
    year: 'numeric',
@@ -32,6 +35,32 @@ function datetimeToUnix(datetimeStr: string): number {
  return Math.floor(d.getTime() / 1000);
 }

+function SortableHeader({
+  label,
+  field,
+  sortField,
+  sortDir,
+  onSort,
+  className,
+}: {
+  label: string;
+  field: SortField;
+  sortField: SortField;
+  sortDir: SortDir;
+  onSort: (field: SortField) => void;
+  className?: string;
+}) {
+  const active = sortField === field;
+  return (
+    <th
+      className={`px-3 py-1.5 cursor-pointer select-none hover:text-foreground transition-colors ${className ?? ''}`}
+      onClick={() => onSort(field)}
+    >
+      {label} {active ? (sortDir === 'asc' ? '▲' : '▼') : ''}
+    </th>
+  );
+}
+
 interface BulkDeleteContactsModalProps {
  open: boolean;
  onClose: () => void;
@@ -49,22 +78,42 @@ export function BulkDeleteContactsModal({
  const [selectedKeys, setSelectedKeys] = useState<Set<string>>(new Set());
  const [startDate, setStartDate] = useState('');
  const [endDate, setEndDate] = useState('');
+  const [lastHeardAfter, setLastHeardAfter] = useState('');
+  const [lastHeardBefore, setLastHeardBefore] = useState('');
  const [typeFilter, setTypeFilter] = useState<number | 'all'>('all');
+  const [sortField, setSortField] = useState<SortField>('first_seen');
+  const [sortDir, setSortDir] = useState<SortDir>('desc');
  const [deleting, setDeleting] = useState(false);
  const lastClickedKeyRef = useRef<string | null>(null);

+  const handleSort = useCallback(
+    (field: SortField) => {
+      if (sortField === field) {
+        setSortDir((d) => (d === 'asc' ? 'desc' : 'asc'));
+      } else {
+        setSortField(field);
+        setSortDir(field === 'name' || field === 'key' ? 'asc' : 'desc');
+      }
+    },
+    [sortField]
+  );
+
  const resetAndClose = useCallback(() => {
    setStep('select');
    setSelectedKeys(new Set());
    setStartDate('');
    setEndDate('');
+    setLastHeardAfter('');
+    setLastHeardBefore('');
    setTypeFilter('all');
+    setSortField('first_seen');
+    setSortDir('desc');
    lastClickedKeyRef.current = null;
    onClose();
  }, [onClose]);

  const filteredContacts = useMemo(() => {
-    let list = [...contacts].sort((a, b) => (b.first_seen ?? 0) - (a.first_seen ?? 0));
+    let list = [...contacts];
    if (typeFilter !== 'all') {
      list = list.filter((c) => c.type === typeFilter);
    }
@@ -76,8 +125,44 @@ export function BulkDeleteContactsModal({
      const end = datetimeToUnix(endDate);
      list = list.filter((c) => (c.first_seen ?? 0) <= end);
    }
+    if (lastHeardAfter) {
+      const after = datetimeToUnix(lastHeardAfter);
+      list = list.filter((c) => (c.last_seen ?? 0) >= after);
+    }
+    if (lastHeardBefore) {
+      const before = datetimeToUnix(lastHeardBefore);
+      list = list.filter((c) => (c.last_seen ?? 0) <= before);
+    }
+
+    const dir = sortDir === 'asc' ? 1 : -1;
+    list.sort((a, b) => {
+      switch (sortField) {
+        case 'name': {
+          const an = getContactDisplayName(a.name, a.public_key, a.last_advert).toLowerCase();
+          const bn = getContactDisplayName(b.name, b.public_key, b.last_advert).toLowerCase();
+          return an < bn ? -dir : an > bn ? dir : 0;
+        }
+        case 'type':
+          return (a.type - b.type) * dir;
+        case 'key':
+          return a.public_key < b.public_key ? -dir : a.public_key > b.public_key ? dir : 0;
+        case 'first_seen':
+          return ((a.first_seen ?? 0) - (b.first_seen ?? 0)) * dir;
+        case 'last_seen':
+          return ((a.last_seen ?? 0) - (b.last_seen ?? 0)) * dir;
+      }
+    });
    return list;
-  }, [contacts, typeFilter, startDate, endDate]);
+  }, [
+    contacts,
+    typeFilter,
+    startDate,
+    endDate,
+    lastHeardAfter,
+    lastHeardBefore,
+    sortField,
+    sortDir,
+  ]);

  const handleToggle = (key: string, shiftKey: boolean) => {
    if (shiftKey && lastClickedKeyRef.current && lastClickedKeyRef.current !== key) {
@@ -148,6 +233,8 @@ export function BulkDeleteContactsModal({
    }
  };

+  const hasFilters = startDate || endDate || lastHeardAfter || lastHeardBefore;
+
  return (
    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && resetAndClose()}>
      <DialogContent className="sm:max-w-2xl max-h-[85dvh] flex flex-col">
@@ -164,40 +251,64 @@ export function BulkDeleteContactsModal({

        {step === 'select' && (
          <>
-            <div className="flex flex-wrap items-end gap-3">
-              <div className="space-y-1">
-                <label className="text-xs text-muted-foreground">Show</label>
-                <select
-                  value={typeFilter === 'all' ? 'all' : String(typeFilter)}
-                  onChange={(e) =>
-                    setTypeFilter(e.target.value === 'all' ? 'all' : Number(e.target.value))
-                  }
-                  className="block h-8 rounded-md border border-input bg-background px-2 text-sm"
-                >
-                  <option value="all">All</option>
-                  <option value="1">Clients</option>
-                  <option value="2">Repeaters</option>
-                  <option value="3">Room Servers</option>
-                  <option value="4">Sensors</option>
-                </select>
+            <div className="flex flex-col gap-3">
+              <div className="flex flex-wrap items-end gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs text-muted-foreground">Show</label>
+                  <select
+                    value={typeFilter === 'all' ? 'all' : String(typeFilter)}
+                    onChange={(e) =>
+                      setTypeFilter(e.target.value === 'all' ? 'all' : Number(e.target.value))
+                    }
+                    className="block h-8 rounded-md border border-input bg-background px-2 text-sm"
+                  >
+                    <option value="all">All</option>
+                    <option value="1">Clients</option>
+                    <option value="2">Repeaters</option>
+                    <option value="3">Room Servers</option>
+                    <option value="4">Sensors</option>
+                  </select>
+                </div>
              </div>
-              <div className="space-y-1">
-                <label className="text-xs text-muted-foreground">Created after</label>
-                <Input
-                  type="datetime-local"
-                  value={startDate}
-                  onChange={(e) => setStartDate(e.target.value)}
-                  className="w-48 h-8 text-sm"
-                />
+              <div className="flex flex-wrap items-end gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs text-muted-foreground">Created after</label>
+                  <Input
+                    type="datetime-local"
+                    value={startDate}
+                    onChange={(e) => setStartDate(e.target.value)}
+                    className="w-48 h-8 text-sm"
+                  />
+                </div>
+                <div className="space-y-1">
+                  <label className="text-xs text-muted-foreground">Created before</label>
+                  <Input
+                    type="datetime-local"
+                    value={endDate}
+                    onChange={(e) => setEndDate(e.target.value)}
+                    className="w-48 h-8 text-sm"
+                  />
+                </div>
              </div>
-              <div className="space-y-1">
-                <label className="text-xs text-muted-foreground">Created before</label>
-                <Input
-                  type="datetime-local"
-                  value={endDate}
-                  onChange={(e) => setEndDate(e.target.value)}
-                  className="w-48 h-8 text-sm"
-                />
+              <div className="flex flex-wrap items-end gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs text-muted-foreground">Last heard after</label>
+                  <Input
+                    type="datetime-local"
+                    value={lastHeardAfter}
+                    onChange={(e) => setLastHeardAfter(e.target.value)}
+                    className="w-48 h-8 text-sm"
+                  />
+                </div>
+                <div className="space-y-1">
+                  <label className="text-xs text-muted-foreground">Last heard before</label>
+                  <Input
+                    type="datetime-local"
+                    value={lastHeardBefore}
+                    onChange={(e) => setLastHeardBefore(e.target.value)}
+                    className="w-48 h-8 text-sm"
+                  />
+                </div>
              </div>
              <div className="flex gap-1.5">
                <Button type="button" variant="outline" size="sm" onClick={handleSelectAll}>
@@ -211,7 +322,7 @@ export function BulkDeleteContactsModal({

            <div className="text-xs text-muted-foreground">
              {filteredContacts.length} contact{filteredContacts.length === 1 ? '' : 's'} shown
-              {(startDate || endDate) && ' (filtered)'}
+              {hasFilters && ' (filtered)'}
              {' · '}
              {selectedKeys.size} selected
            </div>
@@ -219,17 +330,51 @@ export function BulkDeleteContactsModal({
            <div className="flex-1 overflow-y-auto min-h-0 border border-border rounded-md">
              {filteredContacts.length === 0 ? (
                <div className="p-4 text-center text-sm text-muted-foreground">
-                  No contacts match the selected date range.
+                  No contacts match the selected filters.
                </div>
              ) : (
                <table className="w-full text-sm">
                  <thead className="sticky top-0 bg-muted/90 backdrop-blur-sm">
                    <tr className="text-left text-xs text-muted-foreground">
                      <th className="px-3 py-1.5 w-8" />
-                      <th className="px-3 py-1.5">Name</th>
-                      <th className="px-3 py-1.5 hidden sm:table-cell">Type</th>
-                      <th className="px-3 py-1.5">Key</th>
-                      <th className="px-3 py-1.5 hidden sm:table-cell">Created</th>
+                      <SortableHeader
+                        label="Name"
+                        field="name"
+                        sortField={sortField}
+                        sortDir={sortDir}
+                        onSort={handleSort}
+                      />
+                      <SortableHeader
+                        label="Type"
+                        field="type"
+                        sortField={sortField}
+                        sortDir={sortDir}
+                        onSort={handleSort}
+                        className="hidden sm:table-cell"
+                      />
+                      <SortableHeader
+                        label="Key"
+                        field="key"
+                        sortField={sortField}
+                        sortDir={sortDir}
+                        onSort={handleSort}
+                      />
+                      <SortableHeader
+                        label="Created"
+                        field="first_seen"
+                        sortField={sortField}
+                        sortDir={sortDir}
+                        onSort={handleSort}
+                        className="hidden sm:table-cell"
+                      />
+                      <SortableHeader
+                        label="Last heard"
+                        field="last_seen"
+                        sortField={sortField}
+                        sortDir={sortDir}
+                        onSort={handleSort}
+                        className="hidden sm:table-cell"
+                      />
                    </tr>
                  </thead>
                  <tbody>
@@ -265,6 +410,9 @@ export function BulkDeleteContactsModal({
                        <td className="px-3 py-1.5 hidden sm:table-cell text-xs text-muted-foreground">
                          {c.first_seen ? formatDate(c.first_seen) : '—'}
                        </td>
+                        <td className="px-3 py-1.5 hidden sm:table-cell text-xs text-muted-foreground">
+                          {c.last_seen ? formatDate(c.last_seen) : '—'}
+                        </td>
                      </tr>
                    ))}
                  </tbody>
@@ -298,6 +446,7 @@ export function BulkDeleteContactsModal({
                    <th className="px-3 py-1.5">Type</th>
                    <th className="px-3 py-1.5">Key</th>
                    <th className="px-3 py-1.5 hidden sm:table-cell">Created</th>
+                    <th className="px-3 py-1.5 hidden sm:table-cell">Last heard</th>
                  </tr>
                </thead>
                <tbody>
@@ -315,6 +464,9 @@ export function BulkDeleteContactsModal({
                      <td className="px-3 py-1.5 hidden sm:table-cell text-xs text-muted-foreground">
                        {c.first_seen ? formatDate(c.first_seen) : '—'}
                      </td>
+                      <td className="px-3 py-1.5 hidden sm:table-cell text-xs text-muted-foreground">
+                        {c.last_seen ? formatDate(c.last_seen) : '—'}
+                      </td>
                    </tr>
                  ))}
                </tbody>
@@ -6,6 +6,8 @@ import { Separator } from '../ui/separator';
 import { toast } from '../ui/sonner';
 import { api } from '../../api';
 import { formatTime } from '../../utils/messageParser';
+import { lppDisplayUnit } from '../repeater/repeaterPaneShared';
+import { useDistanceUnit } from '../../contexts/DistanceUnitContext';
 import { BulkDeleteContactsModal } from './BulkDeleteContactsModal';
 import type {
  AppSettings,
@@ -13,6 +15,7 @@ import type {
  Contact,
  HealthStatus,
  TelemetryHistoryEntry,
+  TelemetrySchedule,
 } from '../../types';

 export function SettingsDatabaseSection({
@@ -44,6 +47,7 @@ export function SettingsDatabaseSection({
  onToggleTrackedTelemetry?: (publicKey: string) => Promise<void>;
  className?: string;
 }) {
+  const { distanceUnit } = useDistanceUnit();
  const [retentionDays, setRetentionDays] = useState('14');
  const [cleaning, setCleaning] = useState(false);
  const [purgingDecryptedRaw, setPurgingDecryptedRaw] = useState(false);
@@ -51,19 +55,49 @@ export function SettingsDatabaseSection({
  const [discoveryBlockedTypes, setDiscoveryBlockedTypes] = useState<number[]>([]);
  const [bulkDeleteOpen, setBulkDeleteOpen] = useState(false);

-  const [busy, setBusy] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
  const [latestTelemetry, setLatestTelemetry] = useState<
    Record<string, TelemetryHistoryEntry | null>
  >({});
  const telemetryFetchedRef = useRef(false);

+  const [schedule, setSchedule] = useState<TelemetrySchedule | null>(null);
+  const [intervalDraft, setIntervalDraft] = useState<number>(appSettings.telemetry_interval_hours);
+
+  // Serialization chain for every auto-persisted control on this page.
+  // Without this, rapid successive toggles (or mixed dropdown + checkbox
+  // interactions) can dispatch overlapping PATCHes that land out of order
+  // on HTTP/2 — a stale write then wins, reverting the user's last click.
+  // Each call awaits the previous one before sending its request, so the
+  // server sees updates in the order the user made them.
+  const saveChainRef = useRef<Promise<void>>(Promise.resolve());
+
  useEffect(() => {
    setAutoDecryptOnAdvert(appSettings.auto_decrypt_dm_on_advert);
    setDiscoveryBlockedTypes(appSettings.discovery_blocked_types ?? []);
+    setIntervalDraft(appSettings.telemetry_interval_hours);
  }, [appSettings]);

+  // Re-fetch the scheduler derivation whenever the tracked list changes or
+  // the stored preference changes. Cheap: single GET, no radio lock.
+  useEffect(() => {
+    let cancelled = false;
+    api
+      .getTelemetrySchedule()
+      .then((s) => {
+        if (!cancelled) setSchedule(s);
+      })
+      .catch(() => {
+        // Non-critical: dropdown falls back to the unfiltered menu.
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    trackedTelemetryRepeaters.length,
+    appSettings.telemetry_interval_hours,
+    appSettings.telemetry_routed_hourly,
+  ]);
+
  useEffect(() => {
    if (trackedTelemetryRepeaters.length === 0 || telemetryFetchedRef.current) return;
    telemetryFetchedRef.current = true;
@@ -129,35 +163,33 @@ export function SettingsDatabaseSection({
    }
  };

-  const handleSave = async () => {
-    setBusy(true);
-    setError(null);
-
-    try {
-      const update: AppSettingsUpdate = { auto_decrypt_dm_on_advert: autoDecryptOnAdvert };
-      const currentBlocked = appSettings.discovery_blocked_types ?? [];
-      if (
-        discoveryBlockedTypes.length !== currentBlocked.length ||
-        discoveryBlockedTypes.some((t) => !currentBlocked.includes(t))
-      ) {
-        update.discovery_blocked_types = discoveryBlockedTypes;
+  /**
+   * Apply an AppSettings PATCH after any already-queued saves finish, and
+   * revert local state if the save fails. Every auto-persist control on
+   * this page routes through here so the user-visible order of clicks is
+   * the order the backend sees, regardless of network reordering.
+   */
+  const persistAppSettings = (update: AppSettingsUpdate, revert: () => void): Promise<void> => {
+    const chained = saveChainRef.current.then(async () => {
+      try {
+        await onSaveAppSettings(update);
+      } catch (err) {
+        console.error('Failed to save database settings:', err);
+        revert();
+        toast.error('Failed to save setting', {
+          description: err instanceof Error ? err.message : 'Unknown error',
+        });
      }
-      await onSaveAppSettings(update);
-      toast.success('Database settings saved');
-    } catch (err) {
-      console.error('Failed to save database settings:', err);
-      setError(err instanceof Error ? err.message : 'Failed to save');
-      toast.error('Failed to save settings');
-    } finally {
-      setBusy(false);
-    }
+    });
+    saveChainRef.current = chained;
+    return chained;
  };

  return (
    <div className={className}>
      {/* ── Database Overview ── */}
      <div className="space-y-3">
-        <Label className="text-base">Database Overview</Label>
+        <h3 className="text-base font-semibold tracking-tight">Database Overview</h3>
        <div className="rounded-md border border-border bg-muted/30 p-3 space-y-2">
          <div className="flex justify-between items-center">
            <span className="text-sm">Database size</span>
@@ -184,11 +216,11 @@ export function SettingsDatabaseSection({

      {/* ── Storage Cleanup ── */}
      <div className="space-y-4">
-        <Label className="text-base">Storage Cleanup</Label>
+        <h3 className="text-base font-semibold tracking-tight">Storage Cleanup</h3>

        <div className="rounded-md border border-border p-3 space-y-2">
-          <Label className="text-sm">Delete Undecrypted Packets</Label>
-          <p className="text-xs text-muted-foreground">
+          <h3 className="text-sm font-semibold">Delete Undecrypted Packets</h3>
+          <p className="text-[0.8125rem] text-muted-foreground">
            Permanently deletes stored raw packets that have not yet been decrypted. These are
            retained in case you later obtain the correct key — once deleted, these messages can
            never be recovered.
@@ -220,8 +252,8 @@ export function SettingsDatabaseSection({
        </div>

        <div className="rounded-md border border-border p-3 space-y-2">
-          <Label className="text-sm">Purge Archival Raw Packets</Label>
-          <p className="text-xs text-muted-foreground">
+          <h3 className="text-sm font-semibold">Purge Archival Raw Packets</h3>
+          <p className="text-[0.8125rem] text-muted-foreground">
            Deletes the raw packet bytes behind messages that are already decrypted and visible in
            chat. This frees space but removes packet-analysis availability for those messages. It
            does not affect displayed messages or future decryption.
@@ -241,17 +273,24 @@ export function SettingsDatabaseSection({

      {/* ── DM Decryption ── */}
      <div className="space-y-3">
-        <Label className="text-base">DM Decryption</Label>
+        <h3 className="text-base font-semibold tracking-tight">DM Decryption</h3>
        <label className="flex items-center gap-3 cursor-pointer">
          <input
            type="checkbox"
            checked={autoDecryptOnAdvert}
-            onChange={(e) => setAutoDecryptOnAdvert(e.target.checked)}
+            onChange={(e) => {
+              const next = e.target.checked;
+              const prev = autoDecryptOnAdvert;
+              setAutoDecryptOnAdvert(next);
+              void persistAppSettings({ auto_decrypt_dm_on_advert: next }, () =>
+                setAutoDecryptOnAdvert(prev)
+              );
+            }}
            className="w-4 h-4 rounded border-input accent-primary"
          />
          <span className="text-sm">Auto-decrypt historical DMs when new contact advertises</span>
        </label>
-        <p className="text-xs text-muted-foreground">
+        <p className="text-[0.8125rem] text-muted-foreground">
          When enabled, the server will automatically try to decrypt stored DM packets when a new
          contact sends an advertisement. This may cause brief delays on large packet backlogs.
        </p>
@@ -261,12 +300,91 @@ export function SettingsDatabaseSection({

      {/* ── Tracked Repeater Telemetry ── */}
      <div className="space-y-3">
-        <Label className="text-base">Tracked Repeater Telemetry</Label>
-        <p className="text-xs text-muted-foreground">
-          Repeaters opted into automatic telemetry collection are polled every 8 hours. Up to 8
-          repeaters may be tracked at a time ({trackedTelemetryRepeaters.length} / 8 slots used).
+        <h3 className="text-base font-semibold tracking-tight">Tracked Repeater Telemetry</h3>
+        <p className="text-[0.8125rem] text-muted-foreground">
+          Repeaters opted into automatic telemetry collection are polled on a scheduled interval. To
+          limit mesh traffic, the app caps telemetry at 24 checks per day across all tracked
+          repeaters — so fewer tracked repeaters allows shorter intervals, and more tracked
+          repeaters forces longer ones. Up to {schedule?.max_tracked ?? 8} repeaters may be tracked
+          at once ({trackedTelemetryRepeaters.length} / {schedule?.max_tracked ?? 8} slots used).
        </p>

+        {/* Interval picker. Legal options depend on current tracked count;
+            we list only those. If the saved preference is no longer legal,
+            the effective interval is shown below so the user knows what the
+            scheduler is actually using. */}
+        <div className="space-y-1.5">
+          <Label htmlFor="telemetry-interval" className="text-sm">
+            Collection interval
+          </Label>
+          <div className="flex items-center gap-2">
+            <select
+              id="telemetry-interval"
+              value={intervalDraft}
+              onChange={(e) => {
+                const nextValue = Number(e.target.value);
+                if (!Number.isFinite(nextValue) || nextValue === intervalDraft) return;
+                const prevValue = intervalDraft;
+                setIntervalDraft(nextValue);
+                void persistAppSettings({ telemetry_interval_hours: nextValue }, () =>
+                  setIntervalDraft(prevValue)
+                );
+              }}
+              className="h-9 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"
+            >
+              {(schedule?.options ?? [1, 2, 3, 4, 6, 8, 12, 24]).map((hrs) => (
+                <option key={hrs} value={hrs}>
+                  Every {hrs} hour{hrs === 1 ? '' : 's'} ({Math.floor(24 / hrs)} check
+                  {Math.floor(24 / hrs) === 1 ? '' : 's'}/day)
+                </option>
+              ))}
+            </select>
+          </div>
+          {schedule && schedule.effective_hours !== schedule.preferred_hours && (
+            <p className="text-xs text-warning">
+              Saved preference is {schedule.preferred_hours} hour
+              {schedule.preferred_hours === 1 ? '' : 's'}, but the scheduler is using{' '}
+              {schedule.effective_hours} hours because {schedule.tracked_count} repeater
+              {schedule.tracked_count === 1 ? '' : 's'}{' '}
+              {schedule.tracked_count === 1 ? 'is' : 'are'} tracked. Your preference will be
+              restored if you drop back to a supported count.
+            </p>
+          )}
+        </div>
+
+        {/* Routed hourly toggle */}
+        <label className="flex items-start gap-2 cursor-pointer">
+          <input
+            type="checkbox"
+            checked={appSettings.telemetry_routed_hourly}
+            onChange={() => {
+              const next = !appSettings.telemetry_routed_hourly;
+              void persistAppSettings({ telemetry_routed_hourly: next }, () => {});
+            }}
+            className="w-4 h-4 rounded border-input accent-primary mt-0.5"
+          />
+          <div>
+            <span className="text-sm">Poll direct/routed-path repeaters hourly</span>
+            <p className="text-[0.8125rem] text-muted-foreground">
+              When enabled, tracked repeaters with a direct or routed path (not flood) are polled
+              every hour instead of on the scheduled interval above. Flood-only repeaters still
+              follow the normal schedule.
+            </p>
+          </div>
+        </label>
+
+        {schedule?.next_run_at != null && (
+          <p className="text-xs text-muted-foreground">
+            {schedule.routed_hourly ? 'Next flood run at' : 'Next run at'}{' '}
+            {formatTime(schedule.next_run_at)} (UTC top of hour).
+          </p>
+        )}
+        {schedule?.next_routed_run_at != null && (
+          <p className="text-xs text-muted-foreground">
+            Next direct/routed run at {formatTime(schedule.next_routed_run_at)} (UTC top of hour).
+          </p>
+        )}
+
        {trackedTelemetryRepeaters.length === 0 ? (
          <p className="text-sm text-muted-foreground italic">
            No repeaters are being tracked. Enable tracking from a repeater's dashboard.
@@ -276,6 +394,21 @@ export function SettingsDatabaseSection({
            {trackedTelemetryRepeaters.map((key) => {
              const contact = contacts.find((c) => c.public_key === key);
              const displayName = contact?.name ?? key.slice(0, 12);
+              const routeSource = contact?.effective_route_source ?? 'flood';
+              // A forced-flood override (path_len < 0) still reports source
+              // "override", but the actual route is flood. Check the real path.
+              const hasRealPath =
+                contact?.effective_route != null && contact.effective_route.path_len >= 0;
+              const routeLabel = !hasRealPath
+                ? 'flood'
+                : routeSource === 'override'
+                  ? 'routed'
+                  : routeSource === 'direct'
+                    ? 'direct'
+                    : 'flood';
+              const routeColor = hasRealPath
+                ? 'text-primary bg-primary/10'
+                : 'text-muted-foreground bg-muted';
              const snap = latestTelemetry[key];
              const d = snap?.data;
              return (
@@ -283,9 +416,16 @@ export function SettingsDatabaseSection({
                  <div className="flex items-center justify-between gap-2">
                    <div className="flex-1 min-w-0">
                      <span className="text-sm truncate block">{displayName}</span>
-                      <span className="text-[0.625rem] text-muted-foreground font-mono">
-                        {key.slice(0, 12)}
-                      </span>
+                      <div className="flex items-center gap-1.5">
+                        <span className="text-[0.625rem] text-muted-foreground font-mono">
+                          {key.slice(0, 12)}
+                        </span>
+                        <span
+                          className={`text-[0.625rem] uppercase tracking-wider px-1.5 py-0.5 rounded font-medium ${routeColor}`}
+                        >
+                          {routeLabel}
+                        </span>
+                      </div>
                    </div>
                    {onToggleTrackedTelemetry && (
                      <Button
@@ -308,6 +448,22 @@ export function SettingsDatabaseSection({
                      <span>
                        tx {d.packets_sent != null ? d.packets_sent.toLocaleString() : '?'}
                      </span>
+                      {d.lpp_sensors?.map((s) => {
+                        const display = lppDisplayUnit(s.type_name, s.value, distanceUnit);
+                        const val =
+                          typeof display.value === 'number'
+                            ? display.value % 1 === 0
+                              ? display.value
+                              : display.value.toFixed(1)
+                            : display.value;
+                        const label = s.type_name.charAt(0).toUpperCase() + s.type_name.slice(1);
+                        return (
+                          <span key={`${s.type_name}-${s.channel}`}>
+                            {label} {val}
+                            {display.unit ? ` ${display.unit}` : ''}
+                          </span>
+                        );
+                      })}
                      <span className="ml-auto">checked {formatTime(snap.timestamp)}</span>
                    </div>
                  ) : snap === null ? (
@@ -322,155 +478,146 @@ export function SettingsDatabaseSection({
        )}
      </div>

-      {error && (
-        <div className="text-sm text-destructive" role="alert">
-          {error}
-        </div>
-      )}
-
-      <Button onClick={handleSave} disabled={busy} className="w-full">
-        {busy ? 'Saving...' : 'Save Settings'}
-      </Button>
-
      <Separator />

      {/* ── Contact Management ── */}
-      <div className="space-y-2">
-        <Label className="text-base">Contact Management</Label>
-      </div>
+      <div className="space-y-5">
+        <h3 className="text-base font-semibold tracking-tight">Contact Management</h3>

-      {/* Block discovery of new node types */}
-      <div className="space-y-3">
-        <Label>Block Discovery of New Node Types</Label>
-        <p className="text-xs text-muted-foreground">
-          Checked types will be ignored when heard via advertisement. Existing contacts of these
-          types are still updated. This does not affect contacts added manually or via DM.
-        </p>
-        <div className="space-y-1.5">
-          {(
-            [
-              [1, 'Block clients'],
-              [2, 'Block repeaters'],
-              [3, 'Block room servers'],
-              [4, 'Block sensors'],
-            ] as const
-          ).map(([typeCode, label]) => {
-            const checked = discoveryBlockedTypes.includes(typeCode);
-            return (
-              <label key={typeCode} className="flex items-center gap-2 text-sm cursor-pointer">
-                <input
-                  type="checkbox"
-                  checked={checked}
-                  onChange={() =>
-                    setDiscoveryBlockedTypes((prev) =>
-                      checked ? prev.filter((t) => t !== typeCode) : [...prev, typeCode]
-                    )
-                  }
-                  className="rounded border-input"
-                />
-                {label}
-              </label>
-            );
-          })}
-        </div>
-        {discoveryBlockedTypes.length > 0 && (
-          <p className="text-xs text-warning">
-            New{' '}
-            {discoveryBlockedTypes
-              .map((t) =>
-                t === 1 ? 'clients' : t === 2 ? 'repeaters' : t === 3 ? 'room servers' : 'sensors'
-              )
-              .join(', ')}{' '}
-            heard via advertisement will not be added to your contact list.
+        {/* Block discovery of new node types */}
+        <div className="space-y-3">
+          <h4 className="text-sm font-semibold">Block Discovery of New Node Types</h4>
+          <p className="text-[0.8125rem] text-muted-foreground">
+            Checked types will be ignored when heard via advertisement. Existing contacts of these
+            types are still updated. This does not affect contacts added manually or via DM.
          </p>
-        )}
-      </div>
-
-      <Separator />
-
-      {/* Blocked contacts list */}
-      <div className="space-y-3">
-        <Label>Blocked Contacts</Label>
-        <p className="text-xs text-muted-foreground">
-          Blocked contacts are hidden from the sidebar. Blocking only hides messages from the UI —
-          MQTT forwarding and bot responses are not affected. Messages are still stored and will
-          reappear if unblocked.
-        </p>
-
-        {blockedKeys.length === 0 && blockedNames.length === 0 ? (
-          <p className="text-sm text-muted-foreground italic">
-            No blocked contacts. Block contacts from their info pane, viewed by clicking their
-            avatar in any channel, or their name within the top status bar with the conversation
-            open.
-          </p>
-        ) : (
-          <div className="space-y-2">
-            {blockedKeys.length > 0 && (
-              <div>
-                <span className="text-xs text-muted-foreground font-medium">Blocked Keys</span>
-                <div className="mt-1 space-y-1">
-                  {blockedKeys.map((key) => (
-                    <div key={key} className="flex items-center justify-between gap-2">
-                      <span className="text-xs font-mono truncate flex-1">{key}</span>
-                      {onToggleBlockedKey && (
-                        <Button
-                          variant="ghost"
-                          size="sm"
-                          onClick={() => onToggleBlockedKey(key)}
-                          className="h-7 text-xs flex-shrink-0"
-                        >
-                          Unblock
-                        </Button>
-                      )}
-                    </div>
-                  ))}
-                </div>
-              </div>
-            )}
-            {blockedNames.length > 0 && (
-              <div>
-                <span className="text-xs text-muted-foreground font-medium">Blocked Names</span>
-                <div className="mt-1 space-y-1">
-                  {blockedNames.map((name) => (
-                    <div key={name} className="flex items-center justify-between gap-2">
-                      <span className="text-sm truncate flex-1">{name}</span>
-                      {onToggleBlockedName && (
-                        <Button
-                          variant="ghost"
-                          size="sm"
-                          onClick={() => onToggleBlockedName(name)}
-                          className="h-7 text-xs flex-shrink-0"
-                        >
-                          Unblock
-                        </Button>
-                      )}
-                    </div>
-                  ))}
-                </div>
-              </div>
-            )}
+          <div className="space-y-1.5">
+            {(
+              [
+                [1, 'Block clients'],
+                [2, 'Block repeaters'],
+                [3, 'Block room servers'],
+                [4, 'Block sensors'],
+              ] as const
+            ).map(([typeCode, label]) => {
+              const checked = discoveryBlockedTypes.includes(typeCode);
+              return (
+                <label key={typeCode} className="flex items-center gap-2 text-sm cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={checked}
+                    onChange={() => {
+                      const prev = discoveryBlockedTypes;
+                      const next = checked
+                        ? prev.filter((t) => t !== typeCode)
+                        : [...prev, typeCode];
+                      setDiscoveryBlockedTypes(next);
+                      void persistAppSettings({ discovery_blocked_types: next }, () =>
+                        setDiscoveryBlockedTypes(prev)
+                      );
+                    }}
+                    className="rounded border-input"
+                  />
+                  {label}
+                </label>
+              );
+            })}
          </div>
-        )}
-      </div>
+          {discoveryBlockedTypes.length > 0 && (
+            <p className="text-xs text-warning">
+              New{' '}
+              {discoveryBlockedTypes
+                .map((t) =>
+                  t === 1 ? 'clients' : t === 2 ? 'repeaters' : t === 3 ? 'room servers' : 'sensors'
+                )
+                .join(', ')}{' '}
+              heard via advertisement will not be added to your contact list.
+            </p>
+          )}
+        </div>

-      <Separator />
+        {/* Blocked contacts list */}
+        <div className="space-y-3">
+          <h4 className="text-sm font-semibold">Blocked Contacts</h4>
+          <p className="text-[0.8125rem] text-muted-foreground">
+            Blocked contacts are hidden from the sidebar. Blocking only hides messages from the UI —
+            MQTT forwarding and bot responses are not affected. Messages are still stored and will
+            reappear if unblocked.
+          </p>

-      {/* Bulk delete */}
-      <div className="space-y-3">
-        <Label>Bulk Delete Contacts</Label>
-        <p className="text-xs text-muted-foreground">
-          Remove multiple contacts or repeaters at once. Useful for cleaning up spam or unwanted
-          nodes. Message history will be preserved.
-        </p>
-        <Button variant="outline" className="w-full" onClick={() => setBulkDeleteOpen(true)}>
-          Open Bulk Delete
-        </Button>
-        <BulkDeleteContactsModal
-          open={bulkDeleteOpen}
-          onClose={() => setBulkDeleteOpen(false)}
-          contacts={contacts}
-          onDeleted={(keys) => onBulkDeleteContacts?.(keys)}
-        />
+          {blockedKeys.length === 0 && blockedNames.length === 0 ? (
+            <p className="text-sm text-muted-foreground italic">
+              No blocked contacts. Block contacts from their info pane, viewed by clicking their
+              avatar in any channel, or their name within the top status bar with the conversation
+              open.
+            </p>
+          ) : (
+            <div className="space-y-2">
+              {blockedKeys.length > 0 && (
+                <div>
+                  <span className="text-xs text-muted-foreground font-medium">Blocked Keys</span>
+                  <div className="mt-1 space-y-1">
+                    {blockedKeys.map((key) => (
+                      <div key={key} className="flex items-center justify-between gap-2">
+                        <span className="text-xs font-mono truncate flex-1">{key}</span>
+                        {onToggleBlockedKey && (
+                          <Button
+                            variant="ghost"
+                            size="sm"
+                            onClick={() => onToggleBlockedKey(key)}
+                            className="h-7 text-xs flex-shrink-0"
+                          >
+                            Unblock
+                          </Button>
+                        )}
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+              {blockedNames.length > 0 && (
+                <div>
+                  <span className="text-xs text-muted-foreground font-medium">Blocked Names</span>
+                  <div className="mt-1 space-y-1">
+                    {blockedNames.map((name) => (
+                      <div key={name} className="flex items-center justify-between gap-2">
+                        <span className="text-sm truncate flex-1">{name}</span>
+                        {onToggleBlockedName && (
+                          <Button
+                            variant="ghost"
+                            size="sm"
+                            onClick={() => onToggleBlockedName(name)}
+                            className="h-7 text-xs flex-shrink-0"
+                          >
+                            Unblock
+                          </Button>
+                        )}
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+
+        {/* Bulk delete */}
+        <div className="space-y-3">
+          <h4 className="text-sm font-semibold">Bulk Delete Contacts</h4>
+          <p className="text-[0.8125rem] text-muted-foreground">
+            Remove multiple contacts or repeaters at once. Useful for cleaning up spam or unwanted
+            nodes. Message history will be preserved.
+          </p>
+          <Button variant="outline" className="w-full" onClick={() => setBulkDeleteOpen(true)}>
+            Open Bulk Delete
+          </Button>
+          <BulkDeleteContactsModal
+            open={bulkDeleteOpen}
+            onClose={() => setBulkDeleteOpen(false)}
+            contacts={contacts}
+            onDeleted={(keys) => onBulkDeleteContacts?.(keys)}
+          />
+        </div>
      </div>
    </div>
  );
@@ -1,6 +1,11 @@
-import { useState } from 'react';
-import { ChevronRight, Logs, MessageSquare, Send, Settings } from 'lucide-react';
+import { useState, useEffect } from 'react';
+import { ChevronRight, Logs, MessageSquare, Send, Settings, X } from 'lucide-react';
+import { toast } from '../ui/sonner';
+import { usePush } from '../../contexts/PushSubscriptionContext';
+import type { Channel, Contact } from '../../types';
+import { getContactDisplayName } from '../../utils/pubkey';
 import { Button } from '../ui/button';
+import { Checkbox } from '../ui/checkbox';
 import { Input } from '../ui/input';
 import { Label } from '../ui/label';
 import { Separator } from '../ui/separator';
@@ -28,6 +33,13 @@ import {
  setSavedFontScale,
 } from '../../utils/fontScale';
 import { getAutoFocusInputEnabled, setAutoFocusInputEnabled } from '../../utils/autoFocusInput';
+import {
+  getTextReplaceEnabled,
+  setTextReplaceEnabled as saveTextReplaceEnabled,
+  getTextReplaceMapJson,
+  setTextReplaceMapJson,
+  DEFAULT_MAP_JSON,
+} from '../../utils/textReplace';
 import {
  BATTERY_DISPLAY_CHANGE_EVENT,
  getShowBatteryPercent,
@@ -35,30 +47,201 @@ import {
  getShowBatteryVoltage,
  setShowBatteryVoltage as saveBatteryVoltage,
 } from '../../utils/batteryDisplay';
+import {
+  STATUS_DOT_PULSE_CHANGE_EVENT,
+  getStatusDotPulseEnabled,
+  setStatusDotPulseEnabled as saveStatusDotPulse,
+} from '../../utils/statusDotPulse';
+
+/** Resolve a state key like "contact-abc123" or "channel-def456" to a display name. */
+function resolveConversationName(
+  stateKey: string,
+  contacts: Contact[],
+  channels: Channel[]
+): string {
+  if (stateKey.startsWith('contact-')) {
+    const pubkey = stateKey.slice('contact-'.length);
+    const contact = contacts.find((c) => c.public_key === pubkey);
+    return contact ? getContactDisplayName(contact.name, contact.public_key) : pubkey.slice(0, 12);
+  }
+  if (stateKey.startsWith('channel-')) {
+    const key = stateKey.slice('channel-'.length);
+    const channel = channels.find((c) => c.key === key);
+    if (channel?.name) return channel.name.startsWith('#') ? channel.name : `#${channel.name}`;
+    return `#${key.slice(0, 12)}`;
+  }
+  return stateKey;
+}
+
+function PushDeviceManagement({
+  contacts = [],
+  channels = [],
+}: {
+  contacts?: Contact[];
+  channels?: Channel[];
+}) {
+  const {
+    isSupported,
+    allSubscriptions,
+    pushConversations,
+    loading,
+    subscribe,
+    currentSubscriptionId,
+    toggleConversation,
+    deleteSubscription,
+    testPush,
+    refreshSubscriptions,
+  } = usePush();
+
+  useEffect(() => {
+    refreshSubscriptions();
+  }, [refreshSubscriptions]);
+
+  if (!isSupported) {
+    return (
+      <div className="space-y-3">
+        <h3 className="text-base font-semibold tracking-tight">Web Push Notifications</h3>
+        <p className="text-[0.8125rem] text-muted-foreground">
+          {window.isSecureContext
+            ? 'Push notifications are not supported by this browser.'
+            : 'Web Push requires HTTPS. Access RemoteTerm over HTTPS (self-signed certificates work) to enable push notifications.'}
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-4">
+      <div className="space-y-1">
+        <h3 className="text-base font-semibold tracking-tight">Web Push Notifications</h3>
+        <p className="text-[0.8125rem] text-muted-foreground">
+          Receive notifications even when the browser is closed. Use the bell icon in any
+          conversation header to enable push for that contact or channel, or subscribe this browser
+          to receive notifications for all push-enabled conversations.
+        </p>
+        <p className="text-[0.8125rem] text-muted-foreground">
+          The set of channels or DMs that trigger push notifications are global per-install (i.e.
+          all devices that register for Web Push will have the same set of channels/DMs that trigger
+          notifications). Subscribing or unsubscribing a particular browser only controls whether
+          that browser receives notifications for the configured set of channels/DMs.
+        </p>
+      </div>
+
+      {!currentSubscriptionId && (
+        <Button variant="outline" size="sm" onClick={() => void subscribe()} disabled={loading}>
+          {loading ? 'Subscribing...' : 'Subscribe This Browser'}
+        </Button>
+      )}
+
+      {pushConversations.length > 0 && (
+        <div className="space-y-2">
+          <span className="text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium">
+            Push-enabled conversations
+          </span>
+          <div className="flex flex-wrap gap-1.5">
+            {pushConversations.map((key) => (
+              <span
+                key={key}
+                className="inline-flex items-center gap-1 rounded-full bg-muted px-2.5 py-1 text-sm"
+              >
+                {resolveConversationName(key, contacts, channels)}
+                <button
+                  type="button"
+                  onClick={() => void toggleConversation(key)}
+                  className="rounded-full p-0.5 hover:bg-accent transition-colors"
+                  title="Remove"
+                  aria-label={`Remove ${resolveConversationName(key, contacts, channels)} from push`}
+                >
+                  <X className="h-3.5 w-3.5" />
+                </button>
+              </span>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {allSubscriptions.length > 0 && (
+        <div className="space-y-2">
+          <span className="text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium">
+            Registered Devices
+          </span>
+          <div className="mt-2 space-y-2">
+            {allSubscriptions.map((sub) => (
+              <div
+                key={sub.id}
+                className="flex items-center justify-between gap-3 rounded-md border border-border px-3 py-2"
+              >
+                <div className="min-w-0 flex-1">
+                  <div className="flex items-center gap-2 overflow-hidden">
+                    <span className="truncate text-sm font-medium">
+                      {sub.label || 'Unknown device'}
+                    </span>
+                    {sub.id === currentSubscriptionId && (
+                      <span className="shrink-0 rounded bg-primary/10 px-1.5 py-0.5 text-[0.625rem] font-medium text-primary">
+                        Current device
+                      </span>
+                    )}
+                  </div>
+                  <span className="text-xs text-muted-foreground">
+                    {sub.last_success_at
+                      ? `Last push: ${new Date(sub.last_success_at * 1000).toLocaleDateString()}`
+                      : 'Never pushed'}
+                    {sub.failure_count > 0 && ` · ${sub.failure_count} failures`}
+                  </span>
+                </div>
+                <div className="flex gap-1">
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    className="h-8 text-sm"
+                    onClick={() => void testPush(sub.id)}
+                  >
+                    Test
+                  </Button>
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    className="h-8 text-sm text-destructive hover:text-destructive"
+                    onClick={() => {
+                      void deleteSubscription(sub.id).then(() => toast.success('Device removed'));
+                    }}
+                  >
+                    Unsubscribe this device
+                  </Button>
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

 export function SettingsLocalSection({
  onLocalLabelChange,
+  contacts,
+  channels,
  className,
 }: {
  onLocalLabelChange?: (label: LocalLabel) => void;
+  contacts?: Contact[];
+  channels?: Channel[];
  className?: string;
 }) {
  const { distanceUnit, setDistanceUnit } = useDistanceUnit();
  const [reopenLastConversation, setReopenLastConversation] = useState(
    getReopenLastConversationEnabled
  );
-  const [darkMap, setDarkMap] = useState(() => {
-    try {
-      return localStorage.getItem('remoteterm-dark-map') === 'true';
-    } catch {
-      return false;
-    }
-  });
  const [localLabelText, setLocalLabelText] = useState(() => getLocalLabel().text);
  const [localLabelColor, setLocalLabelColor] = useState(() => getLocalLabel().color);
  const [autoFocusInput, setAutoFocusInput] = useState(getAutoFocusInputEnabled);
  const [batteryPercent, setBatteryPercent] = useState(getShowBatteryPercent);
  const [batteryVoltage, setBatteryVoltage] = useState(getShowBatteryVoltage);
+  const [statusDotPulse, setStatusDotPulse] = useState(getStatusDotPulseEnabled);
+  const [textReplaceEnabled, setTextReplaceEnabled] = useState(getTextReplaceEnabled);
+  const [textReplaceJson, setTextReplaceJson] = useState(getTextReplaceMapJson);
+  const [textReplaceError, setTextReplaceError] = useState<string | null>(null);
  const [fontScale, setFontScale] = useState(getSavedFontScale);
  const [fontScaleSlider, setFontScaleSlider] = useState(getSavedFontScale);
  const [fontScaleInput, setFontScaleInput] = useState(() => String(getSavedFontScale()));
@@ -93,12 +276,12 @@ export function SettingsLocalSection({

  return (
    <div className={className}>
-      <p className="text-sm text-muted-foreground">
+      <p className="text-[0.8125rem] text-muted-foreground">
        These settings apply only to this device/browser.
      </p>

      <div className="space-y-1">
-        <Label>Color Scheme</Label>
+        <h3 className="text-base font-semibold tracking-tight">Color Scheme</h3>
        <ThemeSelector />
        <ThemePreview className="mt-6" />
      </div>
@@ -106,7 +289,7 @@ export function SettingsLocalSection({
      <Separator />

      <div className="space-y-3">
-        <Label>Local Label</Label>
+        <h3 className="text-base font-semibold tracking-tight">Local Label</h3>
        <div className="flex items-center gap-2">
          <Input
            value={localLabelText}
@@ -133,7 +316,7 @@ export function SettingsLocalSection({
            className="w-10 h-9 rounded border border-input cursor-pointer bg-transparent p-0.5"
          />
        </div>
-        <p className="text-xs text-muted-foreground">
+        <p className="text-[0.8125rem] text-muted-foreground">
          Display a colored banner at the top of the page to identify this instance.
        </p>
      </div>
@@ -158,7 +341,7 @@ export function SettingsLocalSection({
            </option>
          ))}
        </select>
-        <p className="text-xs text-muted-foreground">
+        <p className="text-[0.8125rem] text-muted-foreground">
          Controls how distances are shown throughout the app.
        </p>
      </div>
@@ -166,86 +349,164 @@ export function SettingsLocalSection({
      <Separator />

      <div className="space-y-3">
-        <Label>UI Tweaks</Label>
+        <h3 className="text-base font-semibold tracking-tight">UI Tweaks</h3>

-        <label className="flex items-center gap-3 cursor-pointer">
-          <input
-            type="checkbox"
-            checked={reopenLastConversation}
-            onChange={(e) => handleToggleReopenLastConversation(e.target.checked)}
-            className="w-4 h-4 rounded border-input accent-primary"
-          />
-          <span className="text-sm">Reopen to last viewed channel/conversation</span>
-        </label>
+        <div className="space-y-2">
+          <div className="flex items-start gap-3 rounded-md border border-border/60 p-3">
+            <Checkbox
+              id="reopen-last"
+              checked={reopenLastConversation}
+              onCheckedChange={(checked) => handleToggleReopenLastConversation(checked === true)}
+              className="mt-0.5"
+            />
+            <div className="space-y-1">
+              <Label htmlFor="reopen-last">Reopen Last Conversation</Label>
+              <p className="text-[0.8125rem] text-muted-foreground">
+                Automatically reopen to the last-open channel or contact when the app loads to the
+                bare URL.
+              </p>
+            </div>
+          </div>

-        <label className="flex items-center gap-3 cursor-pointer">
-          <input
-            type="checkbox"
-            checked={darkMap}
-            onChange={(e) => {
-              const v = e.target.checked;
-              setDarkMap(v);
-              try {
-                localStorage.setItem('remoteterm-dark-map', String(v));
-              } catch {
-                // localStorage may be disabled
-              }
-            }}
-            className="w-4 h-4 rounded border-input accent-primary"
-          />
-          <span className="text-sm">Dark mode map tiles</span>
-        </label>
+          <div className="flex items-start gap-3 rounded-md border border-border/60 p-3">
+            <Checkbox
+              id="auto-focus-input"
+              checked={autoFocusInput}
+              onCheckedChange={(checked) => {
+                const v = checked === true;
+                setAutoFocusInput(v);
+                setAutoFocusInputEnabled(v);
+              }}
+              className="mt-0.5"
+            />
+            <div className="space-y-1">
+              <Label htmlFor="auto-focus-input">Auto-Focus Message Input</Label>
+              <p className="text-[0.8125rem] text-muted-foreground">
+                Place the cursor in the message input when switching conversations. Desktop only.
+              </p>
+            </div>
+          </div>

-        <label className="flex items-center gap-3 cursor-pointer">
-          <input
-            type="checkbox"
-            checked={autoFocusInput}
-            onChange={(e) => {
-              const v = e.target.checked;
-              setAutoFocusInput(v);
-              setAutoFocusInputEnabled(v);
-            }}
-            className="w-4 h-4 rounded border-input accent-primary"
-          />
-          <span className="text-sm">Auto-focus input on conversation load (desktop only)</span>
-        </label>
+          <div className="flex items-start gap-3 rounded-md border border-border/60 p-3">
+            <Checkbox
+              id="battery-percent"
+              checked={batteryPercent}
+              onCheckedChange={(checked) => {
+                const v = checked === true;
+                setBatteryPercent(v);
+                saveBatteryPercent(v);
+                window.dispatchEvent(new Event(BATTERY_DISPLAY_CHANGE_EVENT));
+              }}
+              className="mt-0.5"
+            />
+            <div className="space-y-1">
+              <Label htmlFor="battery-percent">Show Battery Percentage</Label>
+              <p className="text-[0.8125rem] text-muted-foreground">
+                Display the radio&apos;s battery percentage in the status bar. Data updates every 60
+                seconds and may take up to a minute to appear after connecting.
+              </p>
+            </div>
+          </div>

-        <label className="flex items-center gap-3 cursor-pointer">
-          <input
-            type="checkbox"
-            checked={batteryPercent}
-            onChange={(e) => {
-              const v = e.target.checked;
-              setBatteryPercent(v);
-              saveBatteryPercent(v);
-              window.dispatchEvent(new Event(BATTERY_DISPLAY_CHANGE_EVENT));
-            }}
-            className="w-4 h-4 rounded border-input accent-primary"
-          />
-          <span className="text-sm">Show battery percentage in status bar</span>
-        </label>
+          <div className="flex items-start gap-3 rounded-md border border-border/60 p-3">
+            <Checkbox
+              id="battery-voltage"
+              checked={batteryVoltage}
+              onCheckedChange={(checked) => {
+                const v = checked === true;
+                setBatteryVoltage(v);
+                saveBatteryVoltage(v);
+                window.dispatchEvent(new Event(BATTERY_DISPLAY_CHANGE_EVENT));
+              }}
+              className="mt-0.5"
+            />
+            <div className="space-y-1">
+              <Label htmlFor="battery-voltage">Show Battery Voltage</Label>
+              <p className="text-[0.8125rem] text-muted-foreground">
+                Display the radio&apos;s battery voltage in the status bar (in mV). Data updates
+                every 60 seconds and may take up to a minute to appear after connecting.
+              </p>
+            </div>
+          </div>

-        <label className="flex items-center gap-3 cursor-pointer">
-          <input
-            type="checkbox"
-            checked={batteryVoltage}
-            onChange={(e) => {
-              const v = e.target.checked;
-              setBatteryVoltage(v);
-              saveBatteryVoltage(v);
-              window.dispatchEvent(new Event(BATTERY_DISPLAY_CHANGE_EVENT));
-            }}
-            className="w-4 h-4 rounded border-input accent-primary"
-          />
-          <span className="text-sm">Show battery voltage in status bar</span>
-        </label>
+          <div className="flex items-start gap-3 rounded-md border border-border/60 p-3">
+            <Checkbox
+              id="status-dot-pulse"
+              checked={statusDotPulse}
+              onCheckedChange={(checked) => {
+                const v = checked === true;
+                setStatusDotPulse(v);
+                saveStatusDotPulse(v);
+                window.dispatchEvent(new Event(STATUS_DOT_PULSE_CHANGE_EVENT));
+              }}
+              className="mt-0.5"
+            />
+            <div className="space-y-1">
+              <Label htmlFor="status-dot-pulse">Status Dot Glitters</Label>
+              <p className="text-[0.8125rem] text-muted-foreground">
+                Flash the connection status dot in color as packets arrive: blue for channel, purple
+                for DM, cyan for advert, dark green for other.
+              </p>
+            </div>
+          </div>

-        {(batteryPercent || batteryVoltage) && (
-          <p className="text-xs text-muted-foreground ml-7">
-            Battery data updates every 60 seconds and may take up to a minute to appear after
-            connecting.
-          </p>
-        )}
+          <div className="rounded-md border border-border/60 p-3 space-y-2">
+            <div className="flex items-start gap-3">
+              <Checkbox
+                id="text-replace"
+                checked={textReplaceEnabled}
+                onCheckedChange={(checked) => {
+                  const v = checked === true;
+                  setTextReplaceEnabled(v);
+                  saveTextReplaceEnabled(v);
+                }}
+                className="mt-0.5"
+              />
+              <div className="space-y-1">
+                <Label htmlFor="text-replace">Replace as you Type</Label>
+                <p className="text-[0.8125rem] text-muted-foreground">
+                  Automatically replace characters as you type in the message input. Define
+                  replacements as a JSON object mapping source strings to their replacements.
+                </p>
+              </div>
+            </div>
+            {textReplaceEnabled && (
+              <div className="space-y-2 pl-7">
+                <textarea
+                  value={textReplaceJson}
+                  onChange={(e) => {
+                    const val = e.target.value;
+                    setTextReplaceJson(val);
+                    setTextReplaceError(setTextReplaceMapJson(val));
+                  }}
+                  spellCheck={false}
+                  rows={10}
+                  className={cn(
+                    'w-full rounded-md border bg-background px-3 py-2 text-sm font-mono',
+                    textReplaceError ? 'border-destructive' : 'border-input'
+                  )}
+                  aria-label="Text replacement map (JSON)"
+                />
+                {textReplaceError && (
+                  <p className="text-xs text-destructive">
+                    {textReplaceError} Changes are not saved until this is resolved.
+                  </p>
+                )}
+                <button
+                  type="button"
+                  onClick={() => {
+                    setTextReplaceJson(DEFAULT_MAP_JSON);
+                    setTextReplaceMapJson(DEFAULT_MAP_JSON);
+                    setTextReplaceError(null);
+                  }}
+                  className="inline-flex h-8 items-center justify-center rounded-md border border-input px-3 text-sm font-medium transition-colors hover:bg-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                >
+                  Reset to Default
+                </button>
+              </div>
+            )}
+          </div>
+        </div>

        <div className="space-y-3">
          <Label htmlFor="font-scale-input">Relative Font Size</Label>
@@ -318,12 +579,16 @@ export function SettingsLocalSection({
              Reset
            </button>
          </div>
-          <p className="text-xs text-muted-foreground">
+          <p className="text-[0.8125rem] text-muted-foreground">
            Scales the app&apos;s typography for this browser only. The slider moves in 5% steps;
            the number field accepts any value from 25% to 400%.
          </p>
        </div>
      </div>
+
+      <Separator />
+
+      <PushDeviceManagement contacts={contacts} channels={channels} />
    </div>
  );
 }
@@ -427,15 +692,15 @@ function ThemePreview({ className }: { className?: string }) {
                desc="Sheet / dialog title"
              />
              <PreviewTextRow
-                classes="text-base font-semibold"
-                label="text-base font-semibold"
-                desc="Section title"
+                classes="text-base font-semibold tracking-tight"
+                label="text-base font-semibold tracking-tight"
+                desc="Section / group title"
              />
              <PreviewTextRow classes="text-sm" label="text-sm" desc="Body text, form labels" />
              <PreviewTextRow
-                classes="text-xs text-muted-foreground"
-                label="text-xs text-muted-foreground"
-                desc="Helper text"
+                classes="text-[0.8125rem] text-muted-foreground"
+                label="text-[0.8125rem] text-muted-foreground"
+                desc="Helper / description text"
              />
              <PreviewTextRow
                classes="text-[0.6875rem] text-muted-foreground"
@@ -444,7 +709,7 @@ function ThemePreview({ className }: { className?: string }) {
              />
              <div>
                <p className="text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium">
-                  Section Label
+                  Metadata Label
                </p>
                <p className="text-[0.625rem] text-muted-foreground/60 mt-0.5">
                  text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium
@@ -1,11 +1,20 @@
-import { useState, useEffect, useMemo } from 'react';
-import { MapPinned } from 'lucide-react';
+import { useState, useEffect, useMemo, useRef } from 'react';
+import { ChevronDown, Download, MapPinned, Upload } from 'lucide-react';
 import { Input } from '../ui/input';
 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 {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '../ui/dialog';
+import { api } from '../../api';
 import { RADIO_PRESETS } from '../../utils/radioPresets';
 import { stripRegionScopePrefix } from '../../utils/regionScope';
 import type {
@@ -17,8 +26,116 @@ import type {
  RadioConfigUpdate,
  RadioDiscoveryResponse,
  RadioDiscoveryTarget,
+  RadioStatsSnapshot,
 } from '../../types';

+function formatUptime(secs: number): string {
+  const days = Math.floor(secs / 86400);
+  const hours = Math.floor((secs % 86400) / 3600);
+  const minutes = Math.floor((secs % 3600) / 60);
+  if (days > 0) return `${days}d ${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+
+function formatAirtime(secs: number): string {
+  if (secs < 60) return `${secs}s`;
+  const hours = Math.floor(secs / 3600);
+  const minutes = Math.floor((secs % 3600) / 60);
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+
+function StatRow({ label, value, warn }: { label: string; value: string; warn?: boolean }) {
+  return (
+    <div className="flex items-center justify-between gap-2 py-0.5">
+      <span className="text-xs text-muted-foreground">{label}</span>
+      <span
+        className={`text-xs font-mono tabular-nums ${warn ? 'text-warning font-semibold' : ''}`}
+      >
+        {value}
+      </span>
+    </div>
+  );
+}
+
+function RadioDetailsCollapsible({ stats }: { stats: RadioStatsSnapshot }) {
+  const age = stats.timestamp ? Math.max(0, Math.floor(Date.now() / 1000) - stats.timestamp) : null;
+  const packets = {
+    recv: stats.packets_recv,
+    sent: stats.packets_sent,
+    flood_tx: stats.flood_tx,
+    direct_tx: stats.direct_tx,
+    flood_rx: stats.flood_rx,
+    direct_rx: stats.direct_rx,
+  };
+
+  return (
+    <details className="group">
+      <summary className="text-sm font-medium text-foreground cursor-pointer select-none flex items-center gap-1">
+        <ChevronDown className="h-3 w-3 transition-transform group-open:rotate-0 -rotate-90" />
+        Radio Details
+      </summary>
+      <div className="mt-2 space-y-2 rounded-md border border-input bg-muted/20 p-3">
+        {age !== null && (
+          <p className="text-[0.625rem] uppercase tracking-wider text-muted-foreground font-medium">
+            Updated {age < 5 ? 'just now' : `${age}s ago`}
+          </p>
+        )}
+
+        {/* Core */}
+        {stats.uptime_secs != null && (
+          <StatRow label="Uptime" value={formatUptime(stats.uptime_secs)} />
+        )}
+        {stats.battery_mv != null && stats.battery_mv > 0 && (
+          <StatRow label="Battery" value={`${(stats.battery_mv / 1000).toFixed(2)}V`} />
+        )}
+        {stats.queue_len != null && (
+          <StatRow
+            label="TX Queue"
+            value={`${stats.queue_len} / 16`}
+            warn={stats.queue_len >= 14}
+          />
+        )}
+        {stats.errors != null && (
+          <StatRow label="Errors" value={String(stats.errors)} warn={stats.errors > 0} />
+        )}
+
+        {/* RF */}
+        {stats.noise_floor != null && (
+          <StatRow label="Noise Floor" value={`${stats.noise_floor} dBm`} />
+        )}
+        {stats.last_rssi != null && <StatRow label="Last RSSI" value={`${stats.last_rssi} dBm`} />}
+        {stats.last_snr != null && <StatRow label="Last SNR" value={`${stats.last_snr} dB`} />}
+
+        {/* Airtime */}
+        {(stats.tx_air_secs != null || stats.rx_air_secs != null) && (
+          <>
+            {stats.tx_air_secs != null && (
+              <StatRow label="TX Airtime" value={formatAirtime(stats.tx_air_secs)} />
+            )}
+            {stats.rx_air_secs != null && (
+              <StatRow label="RX Airtime" value={formatAirtime(stats.rx_air_secs)} />
+            )}
+          </>
+        )}
+
+        {/* Packets */}
+        {packets.recv != null && <StatRow label="Packets Received" value={String(packets.recv)} />}
+        {packets.sent != null && <StatRow label="Packets Sent" value={String(packets.sent)} />}
+        {packets.flood_tx != null && <StatRow label="Flood TX" value={String(packets.flood_tx)} />}
+        {packets.flood_rx != null && <StatRow label="Flood RX" value={String(packets.flood_rx)} />}
+        {packets.direct_tx != null && (
+          <StatRow label="Direct TX" value={String(packets.direct_tx)} />
+        )}
+        {packets.direct_rx != null && (
+          <StatRow label="Direct RX" value={String(packets.direct_rx)} />
+        )}
+      </div>
+    </details>
+  );
+}
+
 export function SettingsRadioSection({
  config,
  health,
@@ -279,11 +396,6 @@ export function SettingsRadioSection({

    try {
      const update: AppSettingsUpdate = {};
-      const hours = parseInt(advertIntervalHours, 10);
-      const newAdvertInterval = isNaN(hours) ? 0 : hours * 3600;
-      if (newAdvertInterval !== appSettings.advert_interval) {
-        update.advert_interval = newAdvertInterval;
-      }
      if (floodScope !== stripRegionScopePrefix(appSettings.flood_scope)) {
        update.flood_scope = floodScope;
      }
@@ -302,6 +414,27 @@ export function SettingsRadioSection({
    }
  };

+  const [advertIntervalBusy, setAdvertIntervalBusy] = useState(false);
+  const [advertIntervalError, setAdvertIntervalError] = useState<string | null>(null);
+
+  const handleSaveAdvertInterval = async () => {
+    setAdvertIntervalError(null);
+    setAdvertIntervalBusy(true);
+
+    try {
+      const hours = parseInt(advertIntervalHours, 10);
+      const newAdvertInterval = isNaN(hours) ? 0 : hours * 3600;
+      if (newAdvertInterval !== appSettings.advert_interval) {
+        await onSaveAppSettings({ advert_interval: newAdvertInterval });
+      }
+      toast.success('Advertising interval saved');
+    } catch (err) {
+      setAdvertIntervalError(err instanceof Error ? err.message : 'Failed to save');
+    } finally {
+      setAdvertIntervalBusy(false);
+    }
+  };
+
  const handleAdvertise = async (mode: RadioAdvertMode) => {
    setAdvertisingMode(mode);
    try {
@@ -320,6 +453,169 @@ export function SettingsRadioSection({
    }
  };

+  const importInputRef = useRef<HTMLInputElement>(null);
+  const [keyImportDialogOpen, setKeyImportDialogOpen] = useState(false);
+  const pendingImportRef = useRef<Record<string, unknown> | null>(null);
+
+  const buildConfigProfile = () => ({
+    version: 1,
+    exported_at: new Date().toISOString(),
+    name: config.name,
+    lat: config.lat,
+    lon: config.lon,
+    tx_power: config.tx_power,
+    radio: { ...config.radio },
+    path_hash_mode: config.path_hash_mode,
+    advert_location_source: config.advert_location_source ?? 'current',
+    multi_acks_enabled: config.multi_acks_enabled ?? false,
+  });
+
+  const downloadJson = (profile: object, suffix: string) => {
+    const blob = new Blob([JSON.stringify(profile, null, 2)], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    const safeName = (config.name || 'radio').replace(/[^a-zA-Z0-9_-]/g, '_');
+    const timestamp = new Date()
+      .toLocaleString(undefined, {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+      })
+      .replace(/[/:, ]+/g, '-');
+    a.download = `${safeName}-${suffix}-${timestamp}.json`;
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+
+  const handleExportConfig = async () => {
+    const profile = buildConfigProfile();
+    try {
+      const { private_key } = await api.getPrivateKey();
+      downloadJson({ ...profile, private_key }, 'config');
+      toast.success('Export generated with private key');
+    } catch {
+      downloadJson(profile, 'config');
+      toast.info('Export generated without private key', {
+        description: 'See README_ADVANCED.md for private key export enable',
+      });
+    }
+  };
+
+  const validateImportData = (
+    data: unknown
+  ): data is {
+    name: string;
+    radio: { freq: number; bw: number; sf: number; cr: number };
+    [k: string]: unknown;
+  } =>
+    typeof data === 'object' &&
+    data !== null &&
+    'name' in data &&
+    typeof (data as Record<string, unknown>).name === 'string' &&
+    'radio' in data &&
+    typeof (data as Record<string, unknown>).radio === 'object' &&
+    (data as Record<string, unknown>).radio !== null &&
+    typeof (data as Record<string, Record<string, unknown>>).radio.freq === 'number' &&
+    typeof (data as Record<string, Record<string, unknown>>).radio.bw === 'number' &&
+    typeof (data as Record<string, Record<string, unknown>>).radio.sf === 'number' &&
+    typeof (data as Record<string, Record<string, unknown>>).radio.cr === 'number';
+
+  const populateFormFromImport = (data: Record<string, unknown>) => {
+    const radio = data.radio as { freq: number; bw: number; sf: number; cr: number };
+    setName(data.name as string);
+    if (typeof data.lat === 'number') setLat(String(data.lat));
+    if (typeof data.lon === 'number') setLon(String(data.lon));
+    if (typeof data.tx_power === 'number') setTxPower(String(data.tx_power));
+    setFreq(String(radio.freq));
+    setBw(String(radio.bw));
+    setSf(String(radio.sf));
+    setCr(String(radio.cr));
+    if (typeof data.path_hash_mode === 'number') setPathHashMode(String(data.path_hash_mode));
+    if (data.advert_location_source === 'off' || data.advert_location_source === 'current')
+      setAdvertLocationSource(data.advert_location_source);
+    if (typeof data.multi_acks_enabled === 'boolean') setMultiAcksEnabled(data.multi_acks_enabled);
+  };
+
+  const buildUpdateFromImport = (data: Record<string, unknown>): RadioConfigUpdate => {
+    const radio = data.radio as { freq: number; bw: number; sf: number; cr: number };
+    const update: RadioConfigUpdate = {
+      name: data.name as string,
+      lat: typeof data.lat === 'number' ? data.lat : config.lat,
+      lon: typeof data.lon === 'number' ? data.lon : config.lon,
+      tx_power: typeof data.tx_power === 'number' ? (data.tx_power as number) : config.tx_power,
+      radio,
+    };
+    if (data.advert_location_source === 'off' || data.advert_location_source === 'current')
+      update.advert_location_source = data.advert_location_source;
+    if (typeof data.multi_acks_enabled === 'boolean')
+      update.multi_acks_enabled = data.multi_acks_enabled;
+    if (config.path_hash_mode_supported && typeof data.path_hash_mode === 'number')
+      update.path_hash_mode = data.path_hash_mode as number;
+    return update;
+  };
+
+  const applyImport = async (data: Record<string, unknown>) => {
+    populateFormFromImport(data);
+    const update = buildUpdateFromImport(data);
+
+    setBusy(true);
+    setRebooting(true);
+    try {
+      if (typeof data.private_key === 'string' && data.private_key) {
+        await onSetPrivateKey(data.private_key);
+        toast.success('Config + private key imported, saving & rebooting...');
+      } else {
+        toast.success('Config imported, saving & rebooting...');
+      }
+      await onSave(update);
+      await onReboot();
+      if (!pageMode) onClose();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to import config');
+    } finally {
+      setRebooting(false);
+      setBusy(false);
+    }
+  };
+
+  const handleImportConfig = async (file: File) => {
+    try {
+      const text = await file.text();
+      const data = JSON.parse(text);
+
+      if (!validateImportData(data)) {
+        toast.error('Invalid config file', {
+          description: 'File must contain name and radio parameters (freq, bw, sf, cr)',
+        });
+        return;
+      }
+
+      if (typeof data.private_key === 'string' && data.private_key) {
+        // Private key present — show warning dialog before applying
+        pendingImportRef.current = data;
+        setKeyImportDialogOpen(true);
+      } else {
+        await applyImport(data);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to import config');
+    } finally {
+      if (importInputRef.current) importInputRef.current.value = '';
+    }
+  };
+
+  const handleConfirmKeyImport = async () => {
+    setKeyImportDialogOpen(false);
+    const data = pendingImportRef.current;
+    pendingImportRef.current = null;
+    if (data) await applyImport(data);
+  };
+
  const radioState =
    health?.radio_state ?? (health?.radio_initializing ? 'initializing' : 'disconnected');
  const connectionActionLabel =
@@ -392,7 +688,7 @@ export function SettingsRadioSection({
    <div className={className}>
      {/* ── Connection ── */}
      <div className="space-y-3">
-        <Label className="text-base">Connection</Label>
+        <h3 className="text-base font-semibold tracking-tight">Connection</h3>
        <div className="flex items-center gap-2">
          <div
            className={`w-2 h-2 rounded-full ${
@@ -414,6 +710,9 @@ export function SettingsRadioSection({
          </span>
        </div>
        {deviceInfoLabel && <p className="text-sm text-muted-foreground">{deviceInfoLabel}</p>}
+
+        {health?.radio_stats && <RadioDetailsCollapsible stats={health.radio_stats} />}
+
        <Button
          type="button"
          variant="outline"
@@ -423,7 +722,7 @@ export function SettingsRadioSection({
        >
          {connectionBusy ? `${connectionActionLabel}...` : connectionActionLabel}
        </Button>
-        <p className="text-xs text-muted-foreground">
+        <p className="text-[0.8125rem] text-muted-foreground">
          Disconnect pauses automatic reconnect attempts so another device can use the radio.
        </p>
      </div>
@@ -432,7 +731,7 @@ export function SettingsRadioSection({

      {/* ── Identity ── */}
      <div className="space-y-2">
-        <Label className="text-base">Identity</Label>
+        <h3 className="text-base font-semibold tracking-tight">Identity</h3>
      </div>

      <div className="space-y-2">
@@ -477,7 +776,7 @@ export function SettingsRadioSection({

      {/* ── Radio Parameters ── */}
      <div className="space-y-2">
-        <Label className="text-base">Radio Parameters</Label>
+        <h3 className="text-base font-semibold tracking-tight">Radio Parameters</h3>
      </div>

      <div className="space-y-2">
@@ -590,7 +889,7 @@ export function SettingsRadioSection({
      {/* ── Location ── */}
      <div className="space-y-2">
        <div className="flex items-center justify-between">
-          <Label className="text-base">Location</Label>
+          <h3 className="text-base font-semibold tracking-tight">Location</h3>
          <Button
            type="button"
            variant="outline"
@@ -645,7 +944,7 @@ export function SettingsRadioSection({
            <option value="off">Off</option>
            <option value="current">Include Node Location</option>
          </select>
-          <p className="text-xs text-muted-foreground">
+          <p className="text-[0.8125rem] 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
@@ -668,21 +967,52 @@ export function SettingsRadioSection({
          variant="outline"
          className="flex-1"
        >
-          {busy && !rebooting ? 'Saving...' : 'Save'}
+          {busy && !rebooting ? 'Saving...' : 'Save Radio Config'}
        </Button>
        <Button onClick={handleSaveAndReboot} disabled={busy || rebooting} className="flex-1">
-          {rebooting ? 'Rebooting...' : 'Save & Reboot'}
+          {rebooting ? 'Rebooting...' : 'Save Radio Config & Reboot'}
        </Button>
      </div>
-      <p className="text-xs text-muted-foreground">
+      <p className="text-[0.8125rem] text-muted-foreground">
        Some settings may require a reboot to take effect on some radios.
      </p>

+      <div className="flex gap-2">
+        <Button variant="outline" size="sm" onClick={handleExportConfig} className="flex-1">
+          <Download className="mr-1.5 h-4 w-4" aria-hidden="true" />
+          Export Config
+        </Button>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={() => importInputRef.current?.click()}
+          disabled={busy || rebooting}
+          className="flex-1"
+        >
+          <Upload className="mr-1.5 h-4 w-4" aria-hidden="true" />
+          Import &amp; Reboot
+        </Button>
+        <input
+          ref={importInputRef}
+          type="file"
+          accept=".json"
+          className="hidden"
+          onChange={(e) => {
+            const file = e.target.files?.[0];
+            if (file) handleImportConfig(file);
+          }}
+        />
+      </div>
+      <p className="text-[0.8125rem] text-muted-foreground">
+        Export saves the current server config to a JSON file. Import loads a config file, applies
+        it, and reboots the radio.
+      </p>
+
      <Separator />

      {/* ── Messaging ── */}
      <div className="space-y-2">
-        <Label className="text-base">Messaging</Label>
+        <h3 className="text-base font-semibold tracking-tight">Messaging</h3>
      </div>

      <div className="space-y-2">
@@ -695,7 +1025,7 @@ export function SettingsRadioSection({
          />
          <div className="space-y-1">
            <Label htmlFor="multi-acks-enabled">Extra Direct ACK Transmission</Label>
-            <p className="text-xs text-muted-foreground">
+            <p className="text-[0.8125rem] 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.
@@ -714,7 +1044,7 @@ export function SettingsRadioSection({
          />
          <div className="space-y-1">
            <Label htmlFor="auto-resend-channel">Auto-Resend Unheard Channel Messages</Label>
-            <p className="text-xs text-muted-foreground">
+            <p className="text-[0.8125rem] text-muted-foreground">
              When enabled, outgoing channel messages that receive no echo within 2 seconds are
              automatically resent once (byte-perfect, within the 30-second dedup window). Repeaters
              that already heard the original will ignore the duplicate. This functionality will NOT
@@ -732,10 +1062,10 @@ export function SettingsRadioSection({
          onChange={(e) => setFloodScope(e.target.value)}
          placeholder="MyRegion"
        />
-        <p className="text-xs text-muted-foreground">
-          Tag outgoing flood messages with a region name (e.g. MyRegion). Repeaters configured for
-          that region can forward the traffic, while repeaters configured to deny other regions may
-          drop it. Leave empty to disable.
+        <p className="text-[0.8125rem] text-muted-foreground">
+          Tag outgoing messages with a region name (e.g. MyRegion). Repeaters configured for that
+          region can forward the traffic, while repeaters configured to deny other regions may drop
+          it. Leave empty to disable.
        </p>
      </div>

@@ -749,7 +1079,7 @@ export function SettingsRadioSection({
          value={maxRadioContacts}
          onChange={(e) => setMaxRadioContacts(e.target.value)}
        />
-        <p className="text-xs text-muted-foreground">
+        <p className="text-[0.8125rem] text-muted-foreground">
          Configured radio contact capacity. Favorites reload first, then background maintenance
          refills to about 80% of this value and offloads once occupancy reaches about 95%.
        </p>
@@ -769,141 +1099,194 @@ export function SettingsRadioSection({
      )}

      <Button onClick={handleSaveFloodSettings} disabled={floodBusy} className="w-full">
-        {floodBusy ? 'Saving...' : 'Save Settings'}
+        {floodBusy ? 'Saving...' : 'Save Messaging Settings'}
      </Button>

      <Separator />

      {/* ── Advertising & Discovery ── */}
-      <div className="space-y-2">
-        <Label className="text-base">Advertising &amp; Discovery</Label>
-      </div>
+      <div className="space-y-5">
+        <h3 className="text-base font-semibold tracking-tight">Advertising &amp; Discovery</h3>

-      <div className="space-y-2">
-        <Label htmlFor="advert-interval">Periodic Advertising Interval</Label>
-        <div className="flex items-center gap-2">
-          <Input
-            id="advert-interval"
-            type="number"
-            min="0"
-            value={advertIntervalHours}
-            onChange={(e) => setAdvertIntervalHours(e.target.value)}
-            className="w-28"
-          />
-          <span className="text-sm text-muted-foreground">hours (0 = off)</span>
-        </div>
-        <p className="text-xs text-muted-foreground">
-          How often to automatically advertise presence. Set to 0 to disable. Minimum: 1 hour.
-          Recommended: 24 hours or higher.
-        </p>
-      </div>
-
-      <div className="space-y-2">
-        <Label>Send Advertisement</Label>
-        <p className="text-xs text-muted-foreground">
-          Flood adverts propagate through repeaters. Zero-hop adverts are local-only and use less
-          airtime.
-        </p>
-        <div className="grid grid-cols-1 gap-2 sm:grid-cols-2">
+        <div className="space-y-2">
+          <Label htmlFor="advert-interval">Periodic Advertising Interval</Label>
+          <div className="flex items-center gap-2">
+            <Input
+              id="advert-interval"
+              type="number"
+              min="0"
+              value={advertIntervalHours}
+              onChange={(e) => setAdvertIntervalHours(e.target.value)}
+              className="w-28"
+            />
+            <span className="text-sm text-muted-foreground">hours (0 = off)</span>
+          </div>
+          <p className="text-[0.8125rem] text-muted-foreground">
+            How often to automatically advertise presence. Set to 0 to disable. Minimum: 1 hour.
+            Recommended: 24 hours or higher.
+          </p>
+          {advertIntervalError && (
+            <div className="text-sm text-destructive" role="alert">
+              {advertIntervalError}
+            </div>
+          )}
          <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}
+            onClick={handleSaveAdvertInterval}
+            disabled={advertIntervalBusy}
            className="w-full"
          >
-            {advertisingMode === 'zero_hop' ? 'Sending...' : 'Send Zero-Hop Advertisement'}
+            {advertIntervalBusy ? 'Saving...' : 'Save Advertising Interval'}
          </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 }) => (
+        <div className="space-y-2">
+          <h4 className="text-sm font-semibold">Send Advertisement</h4>
+          <p className="text-[0.8125rem] text-muted-foreground">
+            Flood adverts propagate through repeaters. Zero-hop adverts are local-only and use less
+            airtime.
+          </p>
+          <div className="grid grid-cols-1 gap-2 sm:grid-cols-2">
            <Button
-              key={target}
-              type="button"
-              variant="outline"
-              onClick={() => handleDiscover(target as RadioDiscoveryTarget)}
-              disabled={meshDiscoveryLoadingTarget !== null || !health?.radio_connected}
+              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"
            >
-              {meshDiscoveryLoadingTarget === target ? 'Listening...' : label}
+              {advertisingMode === 'zero_hop' ? 'Sending...' : 'Send Zero-Hop Advertisement'}
            </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">
-                        {result.name ?? <span className="capitalize">{result.node_type}</span>}
-                      </span>
-                      <span className="text-xs text-muted-foreground">
-                        heard {result.heard_count} time{result.heard_count === 1 ? '' : 's'}
-                      </span>
-                    </div>
-                    {result.name && (
-                      <p className="text-xs capitalize text-muted-foreground">{result.node_type}</p>
-                    )}
-                    <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>
-        )}
+          {!health?.radio_connected && (
+            <p className="text-sm text-destructive">Radio not connected</p>
+          )}
+        </div>
+
+        <div className="space-y-3">
+          <h4 className="text-sm font-semibold">Mesh Discovery</h4>
+          <p className="text-[0.8125rem] 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">
+                          {result.name ?? <span className="capitalize">{result.node_type}</span>}
+                        </span>
+                        <span className="text-xs text-muted-foreground">
+                          heard {result.heard_count} time{result.heard_count === 1 ? '' : 's'}
+                        </span>
+                      </div>
+                      {result.name && (
+                        <p className="text-xs capitalize text-muted-foreground">
+                          {result.node_type}
+                        </p>
+                      )}
+                      <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>
+
+      {/* ── Private Key Import Warning ── */}
+      <Dialog
+        open={keyImportDialogOpen}
+        onOpenChange={(open) => {
+          setKeyImportDialogOpen(open);
+          if (!open) pendingImportRef.current = null;
+        }}
+      >
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>Import includes Private Key</DialogTitle>
+            <DialogDescription>
+              This config file contains a private key. Importing it will change your radio&apos;s
+              identity &mdash; your radio will have a new public key and other nodes will see it as
+              a different device. This cannot be undone without the original key.
+            </DialogDescription>
+          </DialogHeader>
+          <DialogFooter>
+            <Button
+              variant="outline"
+              onClick={() => {
+                setKeyImportDialogOpen(false);
+                pendingImportRef.current = null;
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              onClick={handleConfirmKeyImport}
+              className="border-destructive/50 text-destructive hover:bg-destructive/10"
+              variant="outline"
+            >
+              Import Config &amp; Key
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
    </div>
  );
 }
@@ -226,7 +226,7 @@ export function SettingsStatisticsSection({ className }: { className?: string })
        <div className="space-y-6">
          {/* Network */}
          <div>
-            <h4 className="text-sm font-medium mb-2">Network</h4>
+            <h3 className="text-base font-semibold tracking-tight mb-2">Network</h3>
            <div className="grid grid-cols-3 gap-3">
              <div className="text-center p-3 bg-muted/50 rounded-md">
                <div className="text-2xl font-bold">{stats.contact_count}</div>
@@ -247,7 +247,7 @@ export function SettingsStatisticsSection({ className }: { className?: string })

          {/* Messages */}
          <div>
-            <h4 className="text-sm font-medium mb-2">Messages</h4>
+            <h3 className="text-base font-semibold tracking-tight mb-2">Messages</h3>
            <div className="grid grid-cols-3 gap-3">
              <div className="text-center p-3 bg-muted/50 rounded-md">
                <div className="text-2xl font-bold">{stats.total_dms}</div>
@@ -268,7 +268,7 @@ export function SettingsStatisticsSection({ className }: { className?: string })

          {/* Activity */}
          <div>
-            <h4 className="text-sm font-medium mb-2">Activity</h4>
+            <h3 className="text-base font-semibold tracking-tight mb-2">Activity</h3>
            <table className="w-full text-sm">
              <thead>
                <tr className="text-muted-foreground">
@@ -305,7 +305,7 @@ export function SettingsStatisticsSection({ className }: { className?: string })

          {/* Packets */}
          <div>
-            <h4 className="text-sm font-medium mb-2">Packets</h4>
+            <h3 className="text-base font-semibold tracking-tight mb-2">Packets</h3>
            <div className="space-y-2">
              <div className="flex justify-between items-center">
                <span className="text-sm text-muted-foreground">Total stored</span>
@@ -327,7 +327,9 @@ export function SettingsStatisticsSection({ className }: { className?: string })
            <>
              <Separator />
              <div>
-                <h4 className="text-sm font-medium mb-2">Packets per Hour (72h)</h4>
+                <h3 className="text-base font-semibold tracking-tight mb-2">
+                  Packets per Hour (72h)
+                </h3>
                <PacketsPerHourChart buckets={stats.packets_per_hour_72h} />
              </div>
            </>
@@ -337,7 +339,7 @@ export function SettingsStatisticsSection({ className }: { className?: string })

          {/* Path Hash Width */}
          <div>
-            <h4 className="text-sm font-medium mb-2">Path Hash Width (24h)</h4>
+            <h3 className="text-base font-semibold tracking-tight mb-2">Path Hash Width (24h)</h3>
            <div className="mb-2 text-xs text-muted-foreground">
              Parsed stored raw packets from the last 24 hours:{' '}
              {stats.path_hash_width_24h.total_packets}
@@ -407,7 +409,9 @@ export function SettingsStatisticsSection({ className }: { className?: string })
            <>
              <Separator />
              <div>
-                <h4 className="text-sm font-medium mb-2">Busiest Channels (24h)</h4>
+                <h3 className="text-base font-semibold tracking-tight mb-2">
+                  Busiest Channels (24h)
+                </h3>
                <ResponsiveContainer
                  width="100%"
                  height={stats.busiest_channels_24h.length * 28 + 8}
@@ -451,7 +455,7 @@ export function SettingsStatisticsSection({ className }: { className?: string })
            <>
              <Separator />
              <div>
-                <h4 className="text-sm font-medium mb-2">Noise Floor (24h)</h4>
+                <h3 className="text-base font-semibold tracking-tight mb-2">Noise Floor (24h)</h3>
                {stats.noise_floor_24h.latest_noise_floor_dbm != null && (
                  <div className="mb-2 text-xs text-muted-foreground">
                    Latest reading: {stats.noise_floor_24h.latest_noise_floor_dbm} dBm
@@ -56,15 +56,68 @@ interface SheetContentProps
  hideCloseButton?: boolean;
 }

+// Safe-area insets for each sheet side. Sheets are position:fixed and escape
+// body padding, so without this they render under the iOS status bar/home
+// indicator when the app is installed as a PWA.
+//
+// NOTE: these inline styles override the matching sides of the `p-6` default
+// in sheetVariants. All current consumers pass `p-0`; future sheets that want
+// the default padding should compose explicit per-side padding in their own
+// className rather than relying on the `p-6` shorthand being preserved.
+type SheetSide = Exclude<VariantProps<typeof sheetVariants>['side'], null | undefined>;
+
+const sheetSafeAreaStyles: Record<SheetSide, React.CSSProperties> = {
+  top: {
+    paddingTop: 'var(--safe-area-top)',
+    paddingLeft: 'var(--safe-area-left)',
+    paddingRight: 'var(--safe-area-right)',
+  },
+  bottom: {
+    paddingBottom: 'var(--safe-area-bottom)',
+    paddingLeft: 'var(--safe-area-left)',
+    paddingRight: 'var(--safe-area-right)',
+  },
+  left: {
+    paddingTop: 'var(--safe-area-top)',
+    paddingLeft: 'var(--safe-area-left)',
+    paddingBottom: 'var(--safe-area-bottom)',
+  },
+  right: {
+    paddingTop: 'var(--safe-area-top)',
+    paddingRight: 'var(--safe-area-right)',
+    paddingBottom: 'var(--safe-area-bottom)',
+  },
+};
+
 const SheetContent = React.forwardRef<
  React.ElementRef<typeof SheetPrimitive.Content>,
  SheetContentProps
->(({ side = 'right', className, children, hideCloseButton = false, ...props }, ref) => (
+>(({ side = 'right', className, children, hideCloseButton = false, style, ...props }, ref) => (
  <SheetPortal>
    <SheetOverlay />
-    <SheetPrimitive.Content ref={ref} className={cn(sheetVariants({ side }), className)} {...props}>
+    <SheetPrimitive.Content
+      ref={ref}
+      className={cn(sheetVariants({ side }), className)}
+      style={{ ...sheetSafeAreaStyles[side as SheetSide], ...style }}
+      {...props}
+    >
      {!hideCloseButton && (
-        <SheetPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary">
+        <SheetPrimitive.Close
+          // Absolute positioning is measured from the containing block's
+          // padding edge, so the safe-area padding on SheetContent does not
+          // push this button down. We offset `top` by safe-area-top manually
+          // for sheets that pin to the viewport top (top/left/right). Bottom
+          // sheets start mid-viewport, so no adjustment is needed there.
+          style={
+            side === 'bottom'
+              ? undefined
+              : {
+                  top: 'calc(var(--safe-area-top) + 1rem)',
+                  right: 'calc(var(--safe-area-right) + 1rem)',
+                }
+          }
+          className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary"
+        >
          <X className="h-4 w-4" />
          <span className="sr-only">Close</span>
        </SheetPrimitive.Close>
@@ -0,0 +1,35 @@
+import { createContext, useContext, type ReactNode } from 'react';
+import { usePushSubscription, type PushSubscriptionState } from '../hooks/usePushSubscription';
+
+const noopAsync = async () => {};
+const noopAsyncNull = async () => null;
+
+const defaultState: PushSubscriptionState = {
+  isSupported: false,
+  isSubscribed: false,
+  currentSubscriptionId: null,
+  allSubscriptions: [],
+  pushConversations: [],
+  loading: false,
+  subscribe: noopAsyncNull,
+  unsubscribe: noopAsync,
+  toggleConversation: noopAsync,
+  isConversationPushEnabled: () => false,
+  deleteSubscription: noopAsync,
+  testPush: noopAsync,
+  refreshSubscriptions: async () => [],
+  refreshConversations: noopAsync,
+};
+
+const PushSubscriptionContext = createContext<PushSubscriptionState>(defaultState);
+
+export function PushSubscriptionProvider({ children }: { children: ReactNode }) {
+  const push = usePushSubscription();
+  return (
+    <PushSubscriptionContext.Provider value={push}>{children}</PushSubscriptionContext.Provider>
+  );
+}
+
+export function usePush(): PushSubscriptionState {
+  return useContext(PushSubscriptionContext);
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jack Kingsman	462ba8945f	Thin out the docker image	2026-04-30 20:57:25 -07:00
Jack Kingsman	f95745cb05	Updating changelog + build for 3.13.0	2026-04-30 20:31:32 -07:00
Jack Kingsman	39ba88bc4b	Fix up e2e tests	2026-04-30 20:22:59 -07:00
Jack Kingsman	e814653300	Add non-markdown option. Closes #232 .	2026-04-30 19:54:43 -07:00
Jack Kingsman	e76d922752	Add recieved time to packet display. Closes #238 .	2026-04-30 19:07:50 -07:00
Jack Kingsman	d0e02a42f8	Merge pull request #237 from Bjorkan/TraceFix Return HTTP 422 for missing trace responses to avoid confusing proxies in front of RemoteTerm. Closes #236.	2026-04-30 18:51:24 -07:00
Jack Kingsman	dbf14259dc	Do full rewrite of 5xx => 4xx	2026-04-30 18:47:35 -07:00
Jack Kingsman	a9ac87e668	Allow newlines in text input. Closes #234 .	2026-04-30 18:36:36 -07:00
Björkan	f710a1f2d9	Change failed trace from using 504 to instead use 422	2026-04-30 23:03:08 +02:00
Björkan	9f6c0f12c5	Don't include .codex file	2026-04-30 22:58:59 +02:00
Jack Kingsman	466f693c21	Fix page to dvh. Closes #233 .	2026-04-28 14:41:56 -07:00
Jack Kingsman	16f87e640f	Attempt up to three Apprise retries. Closes #232 .	2026-04-28 14:40:14 -07:00
Jack Kingsman	761fd82da6	Backoff MQTT failures all the way up to 1hr on connection failure, and also don't multi-toast on connection error. Closes #231 .	2026-04-28 12:00:03 -07:00
Jack Kingsman	2c1279eb9e	Add error rate percentage to metrics graph	2026-04-27 11:21:02 -07:00
Jack Kingsman	047d713003	Permit hourly checks for direct/routed repeaters. Closes #226 .	2026-04-27 09:51:57 -07:00
Jack Kingsman	25041e1367	Add dynamic text replacement. Closes #223 .	2026-04-25 15:00:36 -07:00
Jack Kingsman	b3fe717416	Correct packet sum for repeater error rate. Closes #225 .	2026-04-25 14:48:44 -07:00
Jack Kingsman	9a4e78c504	Show RX error percentage	2026-04-25 14:01:39 -07:00
Jack Kingsman	d436de67a2	Merge pull request #224 from jkingsman/repeater-error-count Repeater error count	2026-04-25 13:54:42 -07:00
Jack Kingsman	89cee49725	Actuall bump lib	2026-04-25 13:45:43 -07:00
Jack Kingsman	b37ce89c96	Add repeater telemetry error count	2026-04-25 13:45:17 -07:00
Jack Kingsman	f0b7842c60	Merge pull request #221 from jkingsman/dependabot/npm_and_yarn/frontend/npm_and_yarn-754666cf41 Bump postcss from 8.5.8 to 8.5.10 in /frontend in the npm_and_yarn group across 1 directory	2026-04-24 18:06:54 -07:00
Jack Kingsman	4eb29f376e	Make clearer save button for advert interval	2026-04-24 14:44:27 -07:00
dependabot[bot]	82a6553539	Bump postcss in /frontend in the npm_and_yarn group across 1 directory Bumps the npm_and_yarn group with 1 update in the /frontend directory: [postcss](https://github.com/postcss/postcss). Updates `postcss` from 8.5.8 to 8.5.10 - [Release notes](https://github.com/postcss/postcss/releases) - [Changelog](https://github.com/postcss/postcss/blob/main/CHANGELOG.md) - [Commits](https://github.com/postcss/postcss/compare/8.5.8...8.5.10) --- updated-dependencies: - dependency-name: postcss dependency-version: 8.5.10 dependency-type: direct:development dependency-group: npm_and_yarn ... Signed-off-by: dependabot[bot] <support@github.com>	2026-04-24 21:10:08 +00:00
Jack Kingsman	a69eb9c534	Updating changelog + build for 3.12.3	2026-04-24 14:03:11 -07:00
Jack Kingsman	70aabb78aa	Remove MESHCORE_ENABLE_LOCAL_PRIVATE_KEY_EXPORT from standard README -- new users don't need that.	2026-04-23 12:38:42 -07:00
Jack Kingsman	cafd9678ee	Fix e2e tests after apprise message updates	2026-04-22 18:12:01 -07:00
Jack Kingsman	a8e346d0c5	Docs, schema, and error handling improvements	2026-04-22 18:08:47 -07:00
Jack Kingsman	55f05bf03b	Add dropdown to choose contact addition type. Closes #216 .	2026-04-22 17:43:01 -07:00
Jack Kingsman	091ba06ccf	Make bulk delete sortable and filterable by last-heard. Closes #218 .	2026-04-22 17:01:50 -07:00
Jack Kingsman	c5c828a4ed	Bypass error on fail-to-unload-contact-because-it's-not-there	2026-04-21 20:38:05 -07:00
Jack Kingsman	7eac3a9754	Use padding in repeaters	2026-04-21 20:15:16 -07:00
Jack Kingsman	329df1a0d2	Add conversational padding to toasts. Closes #214 .	2026-04-21 20:09:30 -07:00
Jack Kingsman	ecb4c99a43	Make Apprise strings customizable. Closes #212 .	2026-04-21 19:40:14 -07:00
Jack Kingsman	2f412e1a93	Be clearer about private key export	2026-04-21 13:47:46 -07:00
Jack Kingsman	0353a98e87	Merge pull request #213 from jkingsman/dependabot/uv/uv-4ea199e985 Bump python-dotenv from 1.2.1 to 1.2.2 in the uv group across 1 directory	2026-04-21 13:15:00 -07:00
dependabot[bot]	3e2258c34b	Bump python-dotenv in the uv group across 1 directory Bumps the uv group with 1 update in the / directory: [python-dotenv](https://github.com/theskumar/python-dotenv). Updates `python-dotenv` from 1.2.1 to 1.2.2 - [Release notes](https://github.com/theskumar/python-dotenv/releases) - [Changelog](https://github.com/theskumar/python-dotenv/blob/main/CHANGELOG.md) - [Commits](https://github.com/theskumar/python-dotenv/compare/v1.2.1...v1.2.2) --- updated-dependencies: - dependency-name: python-dotenv dependency-version: 1.2.2 dependency-type: indirect dependency-group: uv ... Signed-off-by: dependabot[bot] <support@github.com>	2026-04-21 20:11:34 +00:00
Jack Kingsman	e695d629b9	Updating changelog + build for 3.12.2	2026-04-21 13:10:25 -07:00
Jack Kingsman	300677aca3	Disambiguate colliding sensors and display all. Closes #211 .	2026-04-21 10:14:09 -07:00
jkingsman	b89f7ce76b	Add missing docs around pk export	2026-04-20 20:10:21 -07:00
Jack Kingsman	82bd25a09f	Merge pull request #210 from jkingsman/radio-config-export Add config export	2026-04-20 19:58:58 -07:00
Jack Kingsman	7528e4121f	Add config export	2026-04-20 19:55:25 -07:00
Jack Kingsman	b8f0228f68	Merge pull request #209 from kizniche/fix-stale-mqtt-radio-values Fix Community MQTT publishing stale firmware_version and model	2026-04-20 19:48:11 -07:00
Kizniche	25089930f1	fIX Community MQTT publishing stale firmware_version and model	2026-04-20 21:47:38 -04:00
Jack Kingsman	291bd85c78	Better env var/config knob exposure	2026-04-20 16:43:43 -07:00
Jack Kingsman	4bc87b4a0f	Add debug radio details to radio pane	2026-04-20 16:10:24 -07:00
Jack Kingsman	6d0434d59e	Add more intense logging on errors	2026-04-20 16:10:24 -07:00
Jack Kingsman	f22184c166	Update README.md to be more clear about core purpose	2026-04-19 23:40:23 -07:00
Jack Kingsman	d10de8abf7	CI/CD improvements for codeql	2026-04-19 23:33:45 -07:00
Jack Kingsman	5f78294cd1	Longer linger for web push mobile error	2026-04-19 23:04:36 -07:00
Jack Kingsman	6b81dd3082	Updating changelog + build for 3.12.1	2026-04-19 21:18:26 -07:00
Jack Kingsman	cc2b16e53f	Test fix	2026-04-19 21:14:38 -07:00
Jack Kingsman	330007e120	Be smarter about web push not being available on snakeoil certs for mobile	2026-04-19 21:10:17 -07:00
Jack Kingsman	f5a2a21f11	Fix e2e tests	2026-04-19 20:45:11 -07:00
Jack Kingsman	a3e62885d4	Merge pull request #206 from jkingsman/dependabot/uv/uv-2c6491f7af Bump the uv group across 1 directory with 2 updates	2026-04-19 19:36:12 -07:00
Jack Kingsman	dbdd722c48	Merge pull request #207 from jkingsman/channel-mute Add channel mute	2026-04-19 19:35:52 -07:00
jkingsman	c8c8e6b549	Add channel mute	2026-04-19 19:31:26 -07:00
dependabot[bot]	b8683e57d8	Bump the uv group across 1 directory with 2 updates Bumps the uv group with 2 updates in the / directory: [pytest](https://github.com/pytest-dev/pytest) and [requests](https://github.com/psf/requests). Updates `pytest` from 9.0.2 to 9.0.3 - [Release notes](https://github.com/pytest-dev/pytest/releases) - [Changelog](https://github.com/pytest-dev/pytest/blob/main/CHANGELOG.rst) - [Commits](https://github.com/pytest-dev/pytest/compare/9.0.2...9.0.3) Updates `requests` from 2.32.5 to 2.33.0 - [Release notes](https://github.com/psf/requests/releases) - [Changelog](https://github.com/psf/requests/blob/main/HISTORY.md) - [Commits](https://github.com/psf/requests/compare/v2.32.5...v2.33.0) --- updated-dependencies: - dependency-name: pytest dependency-version: 9.0.3 dependency-type: direct:development dependency-group: uv - dependency-name: requests dependency-version: 2.33.0 dependency-type: indirect dependency-group: uv ... Signed-off-by: dependabot[bot] <support@github.com>	2026-04-20 01:44:21 +00:00
Jack Kingsman	491f159463	Merge pull request #205 from jkingsman/dependabot/npm_and_yarn/frontend/npm_and_yarn-916abd5bfa Bump the npm_and_yarn group across 1 directory with 4 updates	2026-04-19 18:43:06 -07:00
jkingsman	ead74e975b	Update tests for vitest bump	2026-04-19 18:36:13 -07:00
dependabot[bot]	4fbd245ee4	Bump the npm_and_yarn group across 1 directory with 4 updates Bumps the npm_and_yarn group with 3 updates in the /frontend directory: [vite](https://github.com/vitejs/vite/tree/HEAD/packages/vite), [flatted](https://github.com/WebReflection/flatted) and [picomatch](https://github.com/micromatch/picomatch). Updates `vite` from 6.4.1 to 6.4.2 - [Release notes](https://github.com/vitejs/vite/releases) - [Changelog](https://github.com/vitejs/vite/blob/v6.4.2/packages/vite/CHANGELOG.md) - [Commits](https://github.com/vitejs/vite/commits/v6.4.2/packages/vite) Updates `esbuild` from 0.21.5 to 0.25.12 - [Release notes](https://github.com/evanw/esbuild/releases) - [Changelog](https://github.com/evanw/esbuild/blob/main/CHANGELOG-2024.md) - [Commits](https://github.com/evanw/esbuild/compare/v0.21.5...v0.25.12) Updates `flatted` from 3.4.0 to 3.4.2 - [Commits](https://github.com/WebReflection/flatted/compare/v3.4.0...v3.4.2) Updates `picomatch` from 2.3.1 to 2.3.2 - [Release notes](https://github.com/micromatch/picomatch/releases) - [Changelog](https://github.com/micromatch/picomatch/blob/master/CHANGELOG.md) - [Commits](https://github.com/micromatch/picomatch/compare/2.3.1...2.3.2) Updates `picomatch` from 4.0.3 to 4.0.4 - [Release notes](https://github.com/micromatch/picomatch/releases) - [Changelog](https://github.com/micromatch/picomatch/blob/master/CHANGELOG.md) - [Commits](https://github.com/micromatch/picomatch/compare/2.3.1...2.3.2) --- updated-dependencies: - dependency-name: vite dependency-version: 6.4.2 dependency-type: direct:development dependency-group: npm_and_yarn - dependency-name: esbuild dependency-version: 0.25.12 dependency-type: indirect dependency-group: npm_and_yarn - dependency-name: flatted dependency-version: 3.4.2 dependency-type: indirect dependency-group: npm_and_yarn - dependency-name: picomatch dependency-version: 2.3.2 dependency-type: indirect dependency-group: npm_and_yarn - dependency-name: picomatch dependency-version: 4.0.4 dependency-type: indirect dependency-group: npm_and_yarn ... Signed-off-by: dependabot[bot] <support@github.com>	2026-04-20 01:15:37 +00:00
Jack Kingsman	dc7ec13cc5	Instructions for full monitoring feed	2026-04-19 16:25:18 -07:00
Jack Kingsman	cfa2bf575c	Correct HA documentation to use the actual node name	2026-04-19 15:11:25 -07:00
Jack Kingsman	e9ef68432a	Make caps consistent	2026-04-19 14:51:09 -07:00
Jack Kingsman	476adf393f	Merge pull request #204 from jkingsman/extended-contact-fetch-timeout Work better with radios that are flakey around providing current contact load state (BLE?)	2026-04-19 14:12:35 -07:00
Jack Kingsman	f7a311d74b	Always clear fav flag on a blind load	2026-04-19 01:25:08 -07:00
Jack Kingsman	09f807230b	Patch up some vagaries and maintain best-effort loading.	2026-04-19 00:51:45 -07:00
Jack Kingsman	c098f9eeb5	Be better about blind loading/auto-evict logging and run-through	2026-04-19 00:27:53 -07:00
Jack Kingsman	05493d06fc	Extend contact read timeouts and add circular load/autoevict load mode	2026-04-18 21:06:27 -07:00
Jack Kingsman	6c1b8bd7e9	Phrasing fixups	2026-04-17 12:49:56 -07:00
Jack Kingsman	d6e1218888	Updating changelog + build for 3.12.0	2026-04-17 12:21:35 -07:00
Jack Kingsman	ad0e398704	Docs improvements	2026-04-17 10:24:45 -07:00
Jack Kingsman	39f5bb2b51	Don't stop on missing wire ack for dm send	2026-04-17 10:04:26 -07:00
Jack Kingsman	5257cb0b1b	Go ham on radio clearing in manual mode	2026-04-17 09:38:05 -07:00
Jack Kingsman	b1547773c5	Phrasing corrections	2026-04-17 08:56:16 -07:00
Jack Kingsman	71da6841c1	Documentation improvements	2026-04-17 00:38:50 -07:00
Jack Kingsman	6f00e857c2	Suck less at settings UI (help me I'm not a designer)	2026-04-16 23:49:52 -07:00
Jack Kingsman	303becf4b8	Merge pull request #183 from jkingsman/web-push Add web push	2026-04-16 23:12:39 -07:00
Jack Kingsman	9ab4e7a9b0	Add beta testing note	2026-04-16 23:08:57 -07:00
Jack Kingsman	b1020e6e34	Add some QOL improvements to HA integration	2026-04-16 23:03:56 -07:00
Jack Kingsman	87a892fc6e	Don't chirp about the time set failures all the time	2026-04-16 21:58:53 -07:00
Jack Kingsman	af76546287	Pass 2	2026-04-16 21:44:52 -07:00
Jack Kingsman	31bd4a0744	Add web push	2026-04-16 18:41:19 -07:00
Jack Kingsman	1db724073b	Add follow-os light/dark theme. Closes #199 .	2026-04-16 18:40:22 -07:00
Jack Kingsman	4783da8f3e	Work on some more concurrency fixes re: locks and context managers. Poking at #179 .	2026-04-16 18:04:56 -07:00
Jack Kingsman	4b69ec4519	Offer multiple timing windows for repeater telemetry pickup. Closes #192 .	2026-04-16 13:55:01 -07:00
Jack Kingsman	8efbbd97bd	Add airtime math and per-minute packets-over-uptime display for repeaters. Closes #194 .	2026-04-16 13:29:24 -07:00
Jack Kingsman	1437e8e48a	Fix issue where last_seen is incremented by events that definitely shouldn't increment it. Fixes #201 .	2026-04-16 13:16:07 -07:00
Jack Kingsman	5cd8f7e80f	Add local tunable for glittering status dot. Closes #200 .	2026-04-16 12:40:30 -07:00
Jack Kingsman	e8c50d0b2a	Add neater contact + channels. Closes #197 .	2026-04-16 12:22:02 -07:00
Jack Kingsman	7f3bb89323	Always expand layer selection and fix up top status bar	2026-04-16 12:18:14 -07:00
Jack Kingsman	5bfdd0880e	Support multiple map layers. Closes #193 .	2026-04-16 12:15:36 -07:00
Jack Kingsman	0e9bd59b44	Show learned path in routing override. Closes #195 .	2026-04-16 11:59:43 -07:00
Jack Kingsman	b1cd6e1aa9	Add link to node from map display. Closes #189 .	2026-04-16 11:58:39 -07:00
Jack Kingsman	56fc589e0b	Move to all PNGs in webmanifest.	2026-04-16 11:44:22 -07:00
Jack Kingsman	64502c4ca2	Fix default URL for map upload. Closes #190 .	2026-04-16 11:39:17 -07:00
Jack Kingsman	d1f657342a	Fix statusbar over slide out panes in PWA. Closes #191 .	2026-04-16 11:33:53 -07:00
Jack Kingsman	86a0ac7beb	Don't strip outgoing colons on DMs or room servers. Closes #198 .	2026-04-15 19:13:29 -07:00
Jack Kingsman	3b7e2737ee	Updating changelog + build for 3.11.3	2026-04-12 23:54:44 -07:00
Jack Kingsman	01158ac69f	Add screenshots and icons for webmanifest	2026-04-12 23:51:13 -07:00
Jack Kingsman	485df05372	Modify radio contact fill logic to use sent OR received messages as recency queue for loadin selection after favorites	2026-04-12 23:45:43 -07:00
Jack Kingsman	e5e9eab935	Updating changelog + build for 3.11.2	2026-04-12 22:44:46 -07:00
Jack Kingsman	33b2d3c260	Unread DMs are ALWAYS at the top. Closes #185 .	2026-04-12 22:41:41 -07:00
Jack Kingsman	eccbd0bac5	use-credentials on webmanifest fetches so basic auth behaves. Closes #182 .	2026-04-12 22:36:08 -07:00
Jack Kingsman	4f54ec2c93	Updating changelog + build for 3.11.1	2026-04-12 20:50:12 -07:00
Jack Kingsman	eed38337c8	Add dummy SWer	2026-04-12 19:11:17 -07:00
Jack Kingsman	e1ee7fcd24	Add default precision	2026-04-12 18:59:44 -07:00
Jack Kingsman	2756b1ae8d	better wrapping around owner label on repeaters	2026-04-12 17:40:37 -07:00
Jack Kingsman	ef1d6a5a1a	Make all scripts +x	2026-04-12 17:35:54 -07:00
Jack Kingsman	14f42c59fe	Use localized units for repeater display	2026-04-12 17:32:07 -07:00
Jack Kingsman	b9414e84ee	Add LPP/tracked repeater telemetry and HA fanout	2026-04-12 17:23:25 -07:00
Jack Kingsman	95a17ca8ee	Merge pull request #174 from jkingsman/ha HomeAssistant MQTT Integration Module	2026-04-12 15:09:49 -07:00
Jack Kingsman	e6cedfbd0b	Improve db best practices. Contributes to fixing #179 .	2026-04-12 15:08:53 -07:00