updated mymesh and platformio firmware version and date; fixed settings page so corrected radio preset list options available and custom frequency edits refined.

2026-03-28 17:42:44 +01:00 · 2026-02-14 14:10:30 +11:00
38 changed files with 474 additions and 16275 deletions
--- a/Guide.md
+++ b/Guide.md
@@ -1,78 +0,0 @@
-## Audiobook Player (Audio variant only)
-
-Press **P** from the home screen to open the audiobook player.
-Place `.mp3`, `.m4b`, `.m4a`, or `.wav` files in `/audiobooks/` on the SD card.
-Files can be organised into subfolders (e.g. by author) — use **Enter** to
-browse into folders and **.. (up)** to go back.
-
-| Key | Action |
-|-----|--------|
-| W / S | Scroll file list / Volume up-down |
-| Enter | Select book or folder / Play-Pause |
-| A | Seek back 30 seconds |
-| D | Seek forward 30 seconds |
-| [ | Previous chapter (M4B only) |
-| ] | Next chapter (M4B only) |
-| Q | Leave player (audio continues) / Close book (when paused) / Exit (from file list) |
-
-### Recommended Format
-
-**MP3 is the recommended format.** M4B/M4A files are supported but currently
-have playback issues with the ESP32-audioI2S library — some files may fail to
-decode or produce silence. MP3 files play reliably and are the safest choice.
-
-MP3 files should be encoded at a **44100 Hz sample rate**. Lower sample rates
-(e.g. 22050 Hz) can cause distortion or playback failure due to ESP32-S3 I2S
-hardware limitations.
-
-**Bookmarks** are saved automatically every 30 seconds during playback and when
-you stop or exit. Reopening a book resumes from your last position.
-
-**Cover art** from M4B files is displayed as dithered monochrome on the e-ink
-screen, along with title, author, and chapter information.
-
-**Metadata caching** — the first time you open the audiobook player, it reads
-title and author tags from each file (which can take a few seconds with many
-files). This metadata is cached to the SD card so subsequent visits load
-near-instantly. If you add or remove files the cache updates automatically.
-
-### Background Playback
-
-Audio continues playing when you leave the audiobook player screen. Press **Q**
-while audio is playing to return to the home screen — a **>>** indicator will
-appear in the status bar next to the battery icon to show that audio is active
-in the background. Press **P** at any time to return to the player screen and
-resume control.
-
-If you pause or stop playback first and then press **Q**, the book is closed
-and you're returned to the file list instead.
-
-### Audio Hardware
-
-The audiobook player uses the PCM5102A I2S DAC on the audio variant of the
-T-Deck Pro (I2S pins: BCLK=7, DOUT=8, LRC=9). Audio is output via the 3.5mm
-headphone jack.
-
-> **Note:** The audiobook player is not available on the 4G modem variant
-> due to I2S pin conflicts.
-
-### SD Card Folder Structure
-
-```
-SD Card
-├── audiobooks/
-│   ├── .bookmarks/          (auto-created, stores resume positions)
-│   │   ├── mybook.bmk
-│   │   └── another.bmk
-│   ├── .metacache            (auto-created, speeds up file list loading)
-│   ├── Ann Leckie/
-│   │   ├── Ancillary Justice.mp3
-│   │   └── Ancillary Sword.mp3
-│   ├── Iain M. Banks/
-│   │   └── The Algebraist.mp3
-│   ├── mybook.mp3
-│   └── podcast.mp3
-├── books/                   (existing — text reader)
-│   └── ...
-└── ...
-```
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
 ## Meshcore + Fork = Meck 
 This fork was created specifically to focus on enabling BLE companion firmware for the LilyGo T-Deck Pro. Created with the assistance of Claude AI using Meshcore v1.11 code. 

+⭐ ***Please note as of 1 Feb 2026, the T-Deck Pro repeater & usb firmware has not been finalised nor confirmed as functioning.*** ⭐
+
 ### Contents
 - [T-Deck Pro Keyboard Controls](#t-deck-pro-keyboard-controls)
  - [Navigation (Home Screen)](#navigation-home-screen)
@@ -14,8 +16,6 @@ This fork was created specifically to focus on enabling BLE companion firmware f
  - [Compose Mode](#compose-mode)
  - [Symbol Entry (Sym Key)](#symbol-entry-sym-key)
  - [Emoji Picker](#emoji-picker)
-  - [SMS & Phone App (4G only)](#sms--phone-app-4g-only)
-  - [Web Browser & IRC](#web-browser--irc)
 - [About MeshCore](#about-meshcore)
 - [What is MeshCore?](#what-is-meshcore)
 - [Key Features](#key-features)
@@ -24,11 +24,10 @@ This fork was created specifically to focus on enabling BLE companion firmware f
 - [MeshCore Flasher](#meshcore-flasher)
 - [MeshCore Clients](#meshcore-clients)
 - [Hardware Compatibility](#-hardware-compatibility)
+- [License](#-license)
 - [Contributing](#contributing)
 - [Road-Map / To-Do](#road-map--to-do)
 - [Get Support](#-get-support)
- [License](#-license)
-  - [Third-Party Libraries](#third-party-libraries)

 ## T-Deck Pro Keyboard Controls

@@ -44,11 +43,7 @@ The T-Deck Pro BLE companion firmware includes full keyboard support for standal
 | M | Open channel messages |
 | C | Open contacts list |
 | E | Open e-book reader |
-| N | Open notes |
 | S | Open settings |
-| B | Open web browser (BLE and 4G variants only) |
-| T | Open SMS & Phone app (4G variant only) |
-| P | Open audiobook player (audio variant only) |
 | Q | Back to home screen |

 ### Bluetooth (BLE)
@@ -86,8 +81,6 @@ The GPS page also shows the current time, satellite count, position, altitude, a
 | W / S | Scroll messages up/down |
 | A / D | Switch between channels |
 | Enter | Compose new message |
-| R | Reply to a message — enter reply select mode, scroll to a message with W/S, then press Enter to compose a reply with an @mention |
-| V | View relay path of the last received message (scrollable, up to 20 hops) |
 | Q | Back to home screen |

 ### Contacts Screen
@@ -97,14 +90,10 @@ Press **C** from the home screen to open the contacts list. All known mesh conta
 | Key | Action |
 |-----|--------|
 | W / S | Scroll up / down through contacts |
-| A / D | Cycle filter: All → Chat → Repeater → Room → Sensor → Favourites |
+| A / D | Cycle filter: All → Chat → Repeater → Room → Sensor |
 | Enter | Open DM compose (Chat contact) or repeater admin (Repeater contact) |
-| X | Export contacts to SD card (wait 5–10 seconds for confirmation popup) |
-| R | Import contacts from SD card (wait 5–10 seconds for confirmation popup) |
 | Q | Back to home screen |

-**Contact limits:** Standalone variants support up to 1,500 contacts (stored in PSRAM). BLE variants (both Audio-BLE and 4G-BLE) are limited to 500 contacts due to BLE protocol constraints.
-
 ### Sending a Direct Message

 Select a **Chat** contact in the contacts list and press **Enter** to start composing a direct message. The compose screen will show `DM: ContactName` in the header. Type your message and press **Enter** to send. The DM is sent encrypted directly to that contact (or flooded if no direct path is known). After sending or cancelling, you're returned to the contacts list.
@@ -157,8 +146,6 @@ Press **S** from the home screen to open settings. On first boot (when the devic
 | Channels | View existing channels, add hashtag channels, or delete non-primary channels (X) |
 | Device Info | Public key and firmware version (read-only) |

-The bottom of the settings screen also displays your node ID and firmware version. On the 4G variant, IMEI, carrier name, and APN details are shown here as well.
-
 When adding a hashtag channel, type the channel name and press Enter. The channel secret is automatically derived from the name via SHA-256, matching the standard MeshCore hashtag convention.

 If you've changed radio parameters, pressing Q will prompt you to apply changes before exiting.
@@ -208,22 +195,6 @@ While in compose mode, press the **$** key to open the emoji picker. A scrollabl
 | Enter | Insert selected emoji |
 | $ / Q / Backspace | Cancel and return to compose |

-### SMS & Phone App (4G only)
-
-Press **T** from the home screen to open the SMS & Phone app. The app opens to a menu screen where you can choose between the **Phone** dialer (for calling any number) or the **SMS Inbox** (for messaging and calling saved contacts).
-
-For full documentation including key mappings, dialpad usage, contacts management, and troubleshooting, see the [SMS & Phone App Guide](SMS%20%26%20Phone%20App%20Guide.md).
-
-### Web Browser & IRC
-
-Press **B** from the home screen to open the web reader. This is available on the BLE and 4G variants (not the standalone audio variant, which excludes WiFi to preserve lowest-battery-usage design).
-
-The web reader home screen provides access to the **IRC client**, the **URL bar**, and your **bookmarks** and **history**. Select IRC Chat and press Enter to configure and connect to an IRC server. Select the URL bar to enter a web address, or scroll down to open a bookmark or history entry.
-
-The browser is a text-centric reader best suited to text-heavy websites. It also includes basic web search via DuckDuckGo Lite, and can download EPUB files — follow a link to an `.epub` and it will be saved to the books folder on your SD card for reading later in the e-book reader.
-
-For full documentation including key mappings, WiFi setup, bookmarks, IRC configuration, and SD card structure, see the [Web App Guide](Web%20App%20Guide.md).
-
 ## About MeshCore

 MeshCore is a lightweight, portable C++ library that enables multi-hop packet routing for embedded projects using LoRa and other packet radios. It is designed for developers who want to create resilient, decentralized communication networks that work without the internet.
@@ -280,7 +251,7 @@ Download a copy of the Meck firmware bin from https://github.com/pelgraine/Meck/

 **Companion Firmware**

-The companion firmware can be connected to via BLE.
+The companion firmware can be connected to via BLE. USB is planned for a future update.

 > **Note:** On the T-Deck Pro, BLE is disabled by default at boot. Navigate to the Bluetooth home page and press Enter to enable BLE before connecting with a companion app.

@@ -294,6 +265,10 @@ The companion firmware can be connected to via BLE.

 MeshCore is designed for devices listed in the [MeshCore Flasher](https://flasher.meshcore.co.uk)

+## 📜 License
+
+MeshCore is open-source software released under the MIT License. You are free to use, modify, and distribute it for personal and commercial projects.
+
 ## Contributing

 Please submit PR's using 'dev' as the base branch!
@@ -315,36 +290,11 @@ There are a number of fairly major features in the pipeline, with no particular
 - [X] Standalone repeater admin access for Companion BLE firmware
 - [X] GPS time sync with on-device timezone setting
 - [X] Settings screen with radio presets, channel management, and first-boot onboarding
- [X] Expand SMS app to enable phone calls
- [X] Basic web reader app for text-centric websites
- [ ] Fix M4B rendering to enable chaptered audiobook playback
- [ ] Better JPEG and PNG decoding
- [ ] Improve EPUB rendering and EPUB format handling
- [ ] Map support with GPS
- [ ] WiFi companion environment
+- [ ] Companion radio: USB
+- [ ] Simple Repeater firmware for the T-Deck Pro
+- [ ] Get pin 45 with the screen backlight functioning for the T-Deck Pro v1.1
+- [ ] Canned messages function for Companion BLE firmware

 ## 📞 Get Support

- Join [MeshCore Discord](https://discord.gg/BMwCtwHj5V) to chat with the developers and get help from the community.
-
-## 📜 License
-
-The upstream [MeshCore](https://github.com/meshcore-dev/MeshCore) library is released under the **MIT License** (Copyright © 2025 Scott Powell / rippleradios.com). Meck-specific code (UI screens, display helpers, device integration) is also provided under the MIT License.
-
-However, this firmware links against libraries with different license terms. Because two dependencies use the **GPL-3.0** copyleft license, the combined firmware binary is effectively subject to GPL-3.0 obligations when distributed. Please review the individual licenses below if you intend to redistribute or modify this firmware.
-
-### Third-Party Libraries
-
-| Library | License | Author / Source |
-|---------|---------|-----------------|
-| [MeshCore](https://github.com/meshcore-dev/MeshCore) | MIT | Scott Powell / rippleradios.com |
-| [GxEPD2](https://github.com/ZinggJM/GxEPD2) | GPL-3.0 | Jean-Marc Zingg |
-| [ESP32-audioI2S](https://github.com/schreibfaul1/ESP32-audioI2S) | GPL-3.0 | schreibfaul1 (Wolle) |
-| [Adafruit GFX Library](https://github.com/adafruit/Adafruit-GFX-Library) | BSD | Adafruit |
-| [RadioLib](https://github.com/jgromes/RadioLib) | MIT | Jan Gromeš |
-| [JPEGDEC](https://github.com/bitbank2/JPEGDEC) | Apache-2.0 | Larry Bank (bitbank2) |
-| [CRC32](https://github.com/bakercp/CRC32) | MIT | Christopher Baker |
-| [base64](https://github.com/Densaugeo/base64_arduino) | MIT | densaugeo |
-| [Arduino Crypto](https://github.com/rweather/arduinolibs) | MIT | Rhys Weatherley |
-
-Full license texts for each dependency are available in their respective repositories linked above.
+- Join [MeshCore Discord](https://discord.gg/BMwCtwHj5V) to chat with the developers and get help from the community.
--- a/Guide.md
+++ b/Guide.md
@@ -1,206 +0,0 @@
-## SMS & Phone App (4G variant only) - Meck v0.9.5
-
-Press **T** from the home screen to open the SMS & Phone app.
-Requires a nano SIM card inserted in the T-Deck Pro V1.1 4G modem slot and an
-SD card formatted as FAT32. The modem registers on the cellular network
-automatically at boot — the red LED on the board indicates the modem is
-powered. The modem (and its red LED) can be switched off and on from the
-settings screen. After each modem startup, the system clock syncs from the
-cellular network, which takes roughly 15 seconds.
-
-### App Menu
-
-The SMS & Phone app opens to a landing screen with two options:
-
-| Option | Description |
-|--------|-------------|
-| **Phone** | Open the phone dialer to call any number |
-| **SMS Inbox** | Open the SMS inbox for messaging and calling saved contacts |
-
-Use **W / S** to select an option and **Enter** to confirm. Press **Q** to
-return to the home screen.
-
-### Key Mapping
-
-| Context | Key | Action |
-|---------|-----|--------|
-| Home screen | T | Open SMS & Phone app |
-| App menu | W / S | Select Phone or SMS Inbox |
-| App menu | Enter | Open selected option |
-| App menu | Q | Back to home screen |
-| Inbox | W / S | Scroll conversations |
-| Inbox | Enter | Open conversation |
-| Inbox | C | Compose new SMS (enter phone number) |
-| Inbox | D | Open contacts directory |
-| Inbox | Q | Back to app menu |
-| Conversation | W / S | Scroll messages |
-| Conversation | C | Reply to this conversation |
-| Conversation | F | Call this number |
-| Conversation | A | Add or edit contact name for this number |
-| Conversation | Q | Back to inbox |
-| Compose | Enter | Send SMS (from body) / Confirm phone number (from phone input) |
-| Compose | Shift+Del | Cancel and return |
-| Contacts | W / S | Scroll contact list |
-| Contacts | Enter | Compose SMS to selected contact |
-| Contacts | F | Call selected contact |
-| Contacts | Q | Back to inbox |
-| Edit Contact | Enter | Save contact name |
-| Edit Contact | Shift+Del | Cancel without saving |
-| Phone Dialer | 0–9, *, +, # | Enter phone number (see input methods below) |
-| Phone Dialer | Enter | Place call |
-| Phone Dialer | Backspace | Delete last digit |
-| Phone Dialer | Q | Back to app menu |
-| Dialing | Enter or Q | Cancel / hang up |
-| Incoming Call | Enter | Answer call |
-| Incoming Call | Q | Reject call |
-| In Call | Enter or Q | Hang up |
-| In Call | W / S | Volume up / down (0–5) |
-| In Call | 0–9, *, # | Send DTMF tone |
-
-### Sending an SMS
-
-There are three ways to start a new message:
-
-1. **From inbox** — press **C**, type the destination phone number, press
-   **Enter**, then type your message and press **Enter** to send.
-2. **From a conversation** — press **C** to reply. The recipient is
-   pre-filled so you go straight to typing the message body.
-3. **From the contacts directory** — press **D** from the inbox, scroll to a
-   contact, and press **Enter**. The compose screen opens with the number
-   pre-filled.
-
-Messages are limited to 160 characters (standard SMS). A character counter is
-shown in the footer while composing.
-
-### Making a Phone Call
-
-There are three ways to start a call:
-
-1. **From the phone dialer** — select **Phone** from the app menu to open the
-   dialer. Enter a phone number and press **Enter** to call. This is the
-   easiest way to call a number you haven't messaged before.
-2. **From a conversation** — open a conversation and press **F**. You can call
-   any number you have previously exchanged messages with, whether or not it is
-   saved as a named contact.
-3. **From the contacts directory** — press **D** from the inbox, scroll to a
-   contact, and press **F**.
-
-The display switches to a dialing screen showing the contact name (or phone
-number) and an animated progress indicator. Once the remote party answers, the
-screen transitions to the in-call view with a live call timer.
-
-During an active call, **W** and **S** adjust the speaker volume (0–5). The
-number keys **0–9**, **\***, and **#** send DTMF tones for navigating phone
-menus and voicemail systems. Press **Enter** or **Q** to hang up.
-
-Audio is routed through the A7682E modem's internal codec to the board speaker
-and microphone — no headphones or external audio hardware are required.
-
-### Phone Dialer Input Methods
-
-The phone dialer supports three ways to enter digits:
-
-1. **Direct key press** — press the keyboard letter that corresponds to each
-   number using the silk-screened labels on the T-Deck Pro keys:
-
-   | Key | Digit | | Key | Digit | | Key | Digit |
-   |-----|-------|-|-----|-------|-|-----|-------|
-   | W | 1 | | S | 4 | | Z | 7 |
-   | E | 2 | | D | 5 | | X | 8 |
-   | R | 3 | | F | 6 | | C | 9 |
-   | A | * | | O | + | | Mic | 0 |
-
-2. **Touchscreen tap** — tap the on-screen number buttons directly. Note: this
-   currently requires fairly precise taps on the numbers themselves.
-
-3. **Sym+key** — the standard symbol entry method (e.g. Sym+W for 1, Sym+S for
-   4, etc.)
-
-### Receiving a Phone Call
-
-When an incoming call arrives, the app automatically switches to the incoming
-call screen regardless of which view is active. A short alert and buzzer
-notification are triggered. The caller's name is shown if saved in contacts,
-otherwise the raw phone number is displayed.
-
-Press **Enter** to answer or **Q** to reject the call. If the call is not
-answered it is logged as a missed call and a "Missed: ..." alert is shown
-briefly.
-
-### Contacts
-
-The contacts directory lets you assign display names to phone numbers.
-Names appear in the inbox list, conversation headers, call screens, and
-compose screen instead of raw numbers.
-
-To add or edit a contact, open a conversation with that number and press **A**.
-Type the display name and press **Enter** to save. Names can be up to 23
-characters long.
-
-Contacts are stored as a plain text file at `/sms/contacts.txt` on the SD card
-in `phone=Display Name` format — one per line, human-editable. Up to 30
-contacts are supported.
-
-### Conversation History
-
-Messages are saved to the SD card automatically and persist across reboots.
-Each phone number gets its own file under `/sms/` on the SD card. The inbox
-shows the most recent 20 conversations sorted by last activity. Within a
-conversation, the most recent 30 messages are loaded with the newest at the
-bottom (chat-style). Sent messages are shown with `>>>` and received messages
-with `<<<`.
-
-Message timestamps use the cellular network clock (synced via NITZ roughly 15
-seconds after each modem startup) and display as relative times (e.g. 5m, 2h,
-1d). If the modem is toggled off and back on, the clock re-syncs automatically.
-
-### Modem Power Control
-
-The 4G modem can be toggled on or off from the settings screen. Scroll to
-**4G Modem: ON/OFF** and press **Enter** to toggle. Switching the modem off
-kills its red status LED and stops all cellular activity. The setting persists
-to SD card and is respected on subsequent boots — if disabled, the modem and
-LED stay off until re-enabled. The SMS & Phone app remains accessible when the
-modem is off but will not be able to send or receive messages or calls.
-
-### Signal Indicator
-
-A signal strength indicator is shown in the top-right corner of all SMS and
-call screens. Bars are derived from the modem's CSQ (signal quality) reading,
-updated every 30 seconds. The modem state (REG, READY, OFF, etc.) is shown
-when not yet connected. During a call, the signal indicator remains visible.
-
-### IMEI, Carrier & APN
-
-The 4G modem's IMEI, current carrier name, and APN are displayed at the bottom
-of the settings screen (press **S** from the home screen), alongside your node
-ID and firmware version.
-
-### SD Card Structure
-
-```
-SD Card
-├── sms/
-│   ├── contacts.txt           (plain text, phone=Name format)
-│   ├── modem.cfg              (0 or 1, modem enable state)
-│   ├── 0412345678.sms         (binary message log per phone number)
-│   └── 0498765432.sms
-├── books/                     (text reader)
-├── audiobooks/                (audio variant only)
-└── ...
-```
-
-### Troubleshooting
-
-| Symptom | Likely Cause |
-|---------|-------------|
-| Modem icon stays at REG / never reaches READY | SIM not inserted, no signal, or SIM requires PIN unlock (not currently supported) |
-| Timestamps show `---` | Modem clock hasn't synced yet (wait ~15 seconds after modem startup), or messages were saved before clock sync was available |
-| Red LED stays on after disabling modem | Toggle the setting off, then reboot — the boot sequence ensures power is cut when disabled |
-| SMS sends but no delivery | Check signal strength; below 5 bars is marginal. Move to better coverage |
-| Call drops immediately after dialing | Check signal strength and ensure the SIM plan supports voice calls |
-| No audio during call | The A7682E routes audio through its own codec; ensure the board speaker is not obstructed. Try adjusting volume with W/S |
-
-> **Note:** The SMS & Phone app is only available on the 4G modem variant of
-> the T-Deck Pro. It is not present on the audio or standalone BLE builds due
-> to shared GPIO pin conflicts between the A7682E modem and PCM5102A DAC.
--- a/Guide.md
+++ b/Guide.md
@@ -1,181 +0,0 @@
-# Web Reader & IRC - Meck v0.9.5
-
-Press **B** from the home screen to open the web reader. The web reader is
-available on the BLE and 4G variants. It is excluded from the standalone audio
-variant to preserve zero-radio-power design.
-
-The web reader home screen provides access to the **IRC client**, the **URL
-bar**, your **bookmarks**, and browsing **history**. Use **W / S** to navigate
-the list and **Enter** to select an item.
-
-## Web Browser
-
-A text-centric web browser ("reader mode") that fetches pages over WiFi,
-strips HTML to readable text, extracts links as numbered references, and
-paginates content for the e-ink display. Still very much in development, but
-already useful for text-heavy websites.
-
-Includes basic web search via **DuckDuckGo Lite** — type a search query into
-the URL bar and it will be sent to DuckDuckGo.
-
-### EPUB Downloads
-
-If you follow a link to an `.epub` file, it will be saved directly to the
-`/books/` folder on your SD card. You can then read it in the e-book reader
-(press **E** from the home screen).
-
-### Bookmarks
-
-Press **K** while on a page to save a bookmark. Bookmarks appear on the web
-reader home screen below the URL bar. To delete a bookmark, open the browser
-home screen, scroll down to the bookmark, and press **Delete**.
-
-### Cookies & History
-
-Press **X** to clear cookies and browsing history.
-
---
-
-## IRC Client
-
-The IRC client lets you connect to IRC networks directly from the device. It
-is accessed from the web reader home screen — select **IRC Chat** (the first
-item) and press **Enter**.
-
-If you are not currently connected, the IRC setup screen opens where you can
-configure the server, port, nickname, and channel. If you are already
-connected, you go straight to the chat view.
-
-### IRC Setup
-
-The setup screen has five fields. Use **W / S** to navigate between them and
-press **Enter** to edit a field (type the value, then **Enter** to confirm).
-
-| Field | Description | Default |
-|-------|-------------|---------|
-| Host | IRC server hostname (e.g. `irc.libera.chat`) | — |
-| Port | Server port. Use `6697` for TLS or `6667` for plain | 6697 |
-| Nick | Your IRC nickname (max 16 characters) | — |
-| Channel | Channel to join, including the `#` (e.g. `#meshcore`) | — |
-| Connect | Select and press Enter to connect | — |
-
-TLS is used automatically when the port is 6697. Other ports connect without
-encryption.
-
-Configuration is saved to the SD card at `/web/irc.cfg` and restored on next
-launch, so you only need to enter server details once.
-
-If WiFi is not connected when you press Connect, you'll be taken to the WiFi
-setup screen first.
-
-### IRC Chat View
-
-Once connected and joined to the channel, you'll see messages in a scrollable
-chat view. The channel name and connection status are shown at the top.
-
-| Key | Action |
-|-----|--------|
-| Enter | Start composing a message (type, then Enter to send) |
-| Backspace | Delete last character while composing; exit compose if empty |
-| W / S | Scroll up (older) / down (newer) through messages |
-| X | Disconnect from IRC and return to web reader home |
-| Q | Return to web reader home (connection stays alive in background) |
-
-The IRC connection remains active when you press **Q** to go back to the web
-reader home screen. You'll see the connection status and channel name displayed
-on the IRC Chat line. Select it and press Enter to return to the chat. Press
-**X** from the chat view to disconnect.
-
-The client automatically reconnects if the connection drops (10-second delay
-between attempts) and detects dead connections after 5 minutes of inactivity
-via ping timeout.
-
-Messages are stored in a circular buffer of 64 messages. Older messages are
-discarded as new ones arrive.
-
---
-
-## Key Bindings
-
-### From Home Screen
-| Key | Action |
-|-----|--------|
-| `b` | Open web reader |
-
-### Web Reader - Home View
-| Key | Action |
-|-----|--------|
-| `w` / `s` | Navigate up/down in IRC / URL bar / bookmarks / history |
-| `Enter` | Select IRC Chat, activate URL bar, or open bookmark/history item |
-| Type | Enter URL (when URL bar is active) |
-| `q` | Exit to firmware home |
-
-### Web Reader - Reading View
-| Key | Action |
-|-----|--------|
-| `w` / `a` | Previous page |
-| `s` / `d` / `Space` | Next page |
-| `l` or `Enter` | Enter link selection (type link number) |
-| `g` | Go to new URL (return to web reader home) |
-| `k` | Bookmark current page |
-| `x` | Clear cookies and history |
-| `q` | Back to web reader home |
-
-### Web Reader - WiFi Setup
-| Key | Action |
-|-----|--------|
-| `w` / `s` | Navigate SSID list |
-| `Enter` | Select SSID / submit password / retry |
-| Type | Enter WiFi password |
-| `q` | Back |
-
-### IRC - Setup View
-| Key | Action |
-|-----|--------|
-| `w` / `s` | Navigate fields (Host / Port / Nick / Channel / Connect) |
-| `Enter` | Edit selected field, or connect (when on Connect button) |
-| Type | Enter field value (when editing) |
-| `Backspace` | Delete last character (when editing) |
-| `q` | Back to web reader home |
-
-### IRC - Chat View
-| Key | Action |
-|-----|--------|
-| `Enter` | Start composing / send message |
-| `Backspace` | Delete character / exit compose if empty |
-| `w` / `s` | Scroll older / newer messages |
-| `x` | Disconnect and return to web reader home |
-| `q` | Back to web reader home (stays connected) |
-
---
-
-## WiFi
-
-The web reader and IRC client both use WiFi for network access. On first use,
-you'll be taken to the WiFi setup screen to scan for networks and enter a
-password. Credentials are saved to `/web/wifi.cfg` on the SD card and used for
-auto-reconnect on subsequent launches.
-
-On the 4G variant, the web reader currently uses WiFi. A future update will add
-PPP support via the A7682E cellular modem, allowing the browser and IRC to work
-over cellular data without WiFi.
-
---
-
-## SD Card Structure
-```
-/web/
-  wifi.cfg         - Saved WiFi credentials (auto-reconnect)
-  bookmarks.txt    - One URL per line
-  history.txt      - Recent URLs, newest first
-  irc.cfg          - IRC server/port/nick/channel config
-```
-
---
-
-## Conditional Compilation
-All web reader code is wrapped in `#ifdef MECK_WEB_READER` guards. The flag is set:
- **meck_audio_ble**: Yes (`-D MECK_WEB_READER=1`) — WiFi available via BLE radio stack
- **meck_4g_ble**: Yes (`-D MECK_WEB_READER=1`) — WiFi now, PPP via A7682E in future
- **meck_4g_standalone**: Yes (`-D MECK_WEB_READER=1`) — WiFi works better without BLE (no teardown needed, more free heap)
- **meck_audio_standalone**: No — excluded to preserve zero-radio-power design
--- a/examples/companion_radio/AbstractUITask.h
+++ b/examples/companion_radio/AbstractUITask.h
@@ -40,19 +40,14 @@ public:
  void enableSerial() { _serial->enable(); }
  void disableSerial() { _serial->disable(); }
  virtual void msgRead(int msgcount) = 0;
-  virtual void newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount,
-                      const uint8_t* path = nullptr) = 0;
+  virtual void newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount) = 0;
  virtual void notify(UIEventType t = UIEventType::none) = 0;
  virtual void loop() = 0;
  virtual void showAlert(const char* text, int duration_millis) {}
  virtual void forceRefresh() {}
  virtual void addSentChannelMessage(uint8_t channel_idx, const char* sender, const char* text) {}

-  // Mark a channel as read when BLE companion app syncs a message
-  virtual void markChannelReadFromBLE(uint8_t channel_idx) {}
-
  // Repeater admin callbacks (from MyMesh)
  virtual void onAdminLoginResult(bool success, uint8_t permissions, uint32_t server_time) {}
  virtual void onAdminCliResponse(const char* from_name, const char* text) {}
-  virtual void onAdminTelemetryResult(const uint8_t* data, uint8_t len) {}
 };
--- a/examples/companion_radio/MyMesh.cpp
+++ b/examples/companion_radio/MyMesh.cpp
@@ -439,8 +439,7 @@ void MyMesh::queueMessage(const ContactInfo &from, uint8_t txt_type, mesh::Packe
  // we only want to show text messages on display, not cli data
  bool should_display = txt_type == TXT_TYPE_PLAIN || txt_type == TXT_TYPE_SIGNED_PLAIN;
  if (should_display && _ui) {
-    const uint8_t* msg_path = (pkt->isRouteFlood() && pkt->path_len > 0) ? pkt->path : nullptr;
-    _ui->newMsg(path_len, from.name, text, offline_queue_len, msg_path);
+    _ui->newMsg(path_len, from.name, text, offline_queue_len);
    if (!_prefs.buzzer_quiet) _ui->notify(UIEventType::contactMessage); //buzz if enabled
  }
 #endif
@@ -524,13 +523,6 @@ void MyMesh::onCommandDataRecv(const ContactInfo &from, mesh::Packet *pkt, uint3
                               const char *text) {
  markConnectionActive(from); // in case this is from a server, and we have a connection
  queueMessage(from, TXT_TYPE_CLI_DATA, pkt, sender_timestamp, NULL, 0, text);
-
-  // Forward CLI response to UI admin screen if admin session is active
-#ifdef DISPLAY_CLASS
-  if (_admin_contact_idx >= 0 && _ui) {
-    _ui->onAdminCliResponse(from.name, text);
-  }
-#endif
 }

 void MyMesh::onSignedMessageRecv(const ContactInfo &from, mesh::Packet *pkt, uint32_t sender_timestamp,
@@ -582,8 +574,7 @@ void MyMesh::onChannelMessageRecv(const mesh::GroupChannel &channel, mesh::Packe
    channel_name = channel_details.name;
  }
  if (_ui) {
-    const uint8_t* msg_path = (pkt->isRouteFlood() && pkt->path_len > 0) ? pkt->path : nullptr;
-    _ui->newMsg(path_len, channel_name, text, offline_queue_len, msg_path);
+    _ui->newMsg(path_len, channel_name, text, offline_queue_len);
    if (!_prefs.buzzer_quiet) _ui->notify(UIEventType::channelMessage); //buzz if enabled
  }
 #endif
@@ -659,76 +650,6 @@ bool MyMesh::uiSendDirectMessage(uint32_t contact_idx, const char* text) {
  return true;
 }

-bool MyMesh::uiLoginToRepeater(uint32_t contact_idx, const char* password) {
-  ContactInfo contact;
-  if (!getContactByIdx(contact_idx, contact)) return false;
-
-  ContactInfo* recipient = lookupContactByPubKey(contact.id.pub_key, PUB_KEY_SIZE);
-  if (!recipient) return false;
-
-  uint32_t est_timeout;
-  int result = sendLogin(*recipient, password, est_timeout);
-  if (result == MSG_SEND_FAILED) {
-    MESH_DEBUG_PRINTLN("UI: Admin login send failed to %s", recipient->name);
-    return false;
-  }
-
-  clearPendingReqs();
-  memcpy(&pending_login, recipient->id.pub_key, 4);
-  _admin_contact_idx = contact_idx;
-
-  MESH_DEBUG_PRINTLN("UI: Admin login sent to %s (%s), timeout=%dms",
-                     recipient->name, result == MSG_SEND_SENT_FLOOD ? "flood" : "direct",
-                     est_timeout);
-  return true;
-}
-
-bool MyMesh::uiSendCliCommand(uint32_t contact_idx, const char* command) {
-  ContactInfo contact;
-  if (!getContactByIdx(contact_idx, contact)) return false;
-
-  ContactInfo* recipient = lookupContactByPubKey(contact.id.pub_key, PUB_KEY_SIZE);
-  if (!recipient) return false;
-
-  uint32_t timestamp = getRTCClock()->getCurrentTimeUnique();
-  uint32_t est_timeout;
-  int result = sendCommandData(*recipient, timestamp, 0, command, est_timeout);
-  if (result == MSG_SEND_FAILED) {
-    MESH_DEBUG_PRINTLN("UI: CLI command send failed to %s: %s", recipient->name, command);
-    return false;
-  }
-
-  _admin_contact_idx = contact_idx;
-
-  MESH_DEBUG_PRINTLN("UI: CLI command sent to %s (%s): %s, timeout=%dms",
-                     recipient->name, result == MSG_SEND_SENT_FLOOD ? "flood" : "direct",
-                     command, est_timeout);
-  return true;
-}
-
-bool MyMesh::uiSendTelemetryRequest(uint32_t contact_idx) {
-  ContactInfo contact;
-  if (!getContactByIdx(contact_idx, contact)) return false;
-
-  ContactInfo* recipient = lookupContactByPubKey(contact.id.pub_key, PUB_KEY_SIZE);
-  if (!recipient) return false;
-
-  uint32_t tag, est_timeout;
-  int result = sendRequest(*recipient, REQ_TYPE_GET_TELEMETRY_DATA, tag, est_timeout);
-  if (result == MSG_SEND_FAILED) {
-    MESH_DEBUG_PRINTLN("UI: Telemetry request send failed to %s", recipient->name);
-    return false;
-  }
-
-  clearPendingReqs();
-  pending_telemetry = tag;
-
-  MESH_DEBUG_PRINTLN("UI: Telemetry request sent to %s (%s), timeout=%dms",
-                     recipient->name, result == MSG_SEND_SENT_FLOOD ? "flood" : "direct",
-                     est_timeout);
-  return true;
-}
-
 uint8_t MyMesh::onContactRequest(const ContactInfo &contact, uint32_t sender_timestamp, const uint8_t *data,
                                 uint8_t len, uint8_t *reply) {
  if (data[0] == REQ_TYPE_GET_TELEMETRY_DATA) {
@@ -787,11 +708,6 @@ void MyMesh::onContactResponse(const ContactInfo &contact, const uint8_t *data,
      out_frame[i++] = 0; // legacy: is_admin = false
      memcpy(&out_frame[i], contact.id.pub_key, 6);
      i += 6;                                     // pub_key_prefix
-
-      #ifdef DISPLAY_CLASS
-      // Notify UI of successful legacy login
-      if (_ui) _ui->onAdminLoginResult(true, 0, tag);
-      #endif
    } else if (data[4] == RESP_SERVER_LOGIN_OK) { // new login response
      uint16_t keep_alive_secs = ((uint16_t)data[5]) * 16;
      if (keep_alive_secs > 0) {
@@ -805,21 +721,11 @@ void MyMesh::onContactResponse(const ContactInfo &contact, const uint8_t *data,
      i += 4; // NEW: include server timestamp
      out_frame[i++] = data[7]; // NEW (v7): ACL permissions
      out_frame[i++] = data[12]; // FIRMWARE_VER_LEVEL
-
-      #ifdef DISPLAY_CLASS
-      // Notify UI of successful login
-      if (_ui) _ui->onAdminLoginResult(true, data[6], tag);
-      #endif
    } else {
      out_frame[i++] = PUSH_CODE_LOGIN_FAIL;
      out_frame[i++] = 0; // reserved
      memcpy(&out_frame[i], contact.id.pub_key, 6);
      i += 6; // pub_key_prefix
-
-      #ifdef DISPLAY_CLASS
-      // Notify UI of login failure
-      if (_ui) _ui->onAdminLoginResult(false, 0, 0);
-      #endif
    }
    _serial->writeFrame(out_frame, i);
  } else if (len > 4 && // check for status response
@@ -839,7 +745,6 @@ void MyMesh::onContactResponse(const ContactInfo &contact, const uint8_t *data,
    _serial->writeFrame(out_frame, i);
  } else if (len > 4 && tag == pending_telemetry) {  // check for matching response tag
    pending_telemetry = 0;
-    MESH_DEBUG_PRINTLN("Telemetry response received from %s, len=%d", contact.name, len);

    int i = 0;
    out_frame[i++] = PUSH_CODE_TELEMETRY_RESPONSE;
@@ -849,11 +754,6 @@ void MyMesh::onContactResponse(const ContactInfo &contact, const uint8_t *data,
    memcpy(&out_frame[i], &data[4], len - 4);
    i += (len - 4);
    _serial->writeFrame(out_frame, i);
-
-    #ifdef DISPLAY_CLASS
-    // Route telemetry data to UI (LPP buffer after the 4-byte tag)
-    if (_ui) _ui->onAdminTelemetryResult(&data[4], len - 4);
-    #endif
  } else if (len > 4 && tag == pending_req) {  // check for matching response tag
    pending_req = 0;

@@ -997,7 +897,6 @@ MyMesh::MyMesh(mesh::Radio &radio, mesh::RNG &rng, mesh::RTCClock &rtc, SimpleMe
  memset(send_scope.key, 0, sizeof(send_scope.key));
  memset(_sent_track, 0, sizeof(_sent_track));
  _sent_track_idx = 0;
-  _admin_contact_idx = -1;

  // defaults
  memset(&_prefs, 0, sizeof(_prefs));
@@ -1072,7 +971,6 @@ void MyMesh::begin(bool has_display) {
  _active_ble_pin = 0;
 #endif

-  initContacts();    // allocate contacts array from PSRAM (deferred from constructor)
  resetContacts();
  _store->loadContacts(this);
  bootstrapRTCfromContacts();
@@ -1213,8 +1111,6 @@ void MyMesh::handleCmdFrame(size_t len) {
    memcpy(&msg_timestamp, &cmd_frame[i], 4);
    i += 4;
    const char *text = (char *)&cmd_frame[i];
-    int text_len = len - i;
-    cmd_frame[len] = '\0';  // Null-terminate for C string use

    if (txt_type != TXT_TYPE_PLAIN) {
      writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
@@ -1223,11 +1119,6 @@ void MyMesh::handleCmdFrame(size_t len) {
      bool success = getChannel(channel_idx, channel);
      if (success && sendGroupMessage(msg_timestamp, channel.channel, _prefs.node_name, text, len - i)) {
        writeOKFrame();
-        #ifdef DISPLAY_CLASS
-        if (_ui) {
-          _ui->addSentChannelMessage(channel_idx, _prefs.node_name, text);
-        }
-#endif
      } else {
        writeErrFrame(ERR_CODE_NOT_FOUND); // bad channel_idx
      }
@@ -1410,19 +1301,7 @@ void MyMesh::handleCmdFrame(size_t len) {
    if ((out_len = getFromOfflineQueue(out_frame)) > 0) {
      _serial->writeFrame(out_frame, out_len);
 #ifdef DISPLAY_CLASS
-      if (_ui) {
-        _ui->msgRead(offline_queue_len);
-
-        // Mark channel as read when BLE companion app syncs the message.
-        // Frame layout V3: [resp_code][snr][res1][res2][channel_idx][path_len]...
-        // Frame layout V1: [resp_code][channel_idx][path_len]...
-        bool is_v3_ch = (out_frame[0] == RESP_CODE_CHANNEL_MSG_RECV_V3);
-        bool is_old_ch = (out_frame[0] == RESP_CODE_CHANNEL_MSG_RECV);
-        if (is_v3_ch || is_old_ch) {
-          uint8_t ch_idx = is_v3_ch ? out_frame[4] : out_frame[1];
-          _ui->markChannelReadFromBLE(ch_idx);
-        }
-      }
+      if (_ui) _ui->msgRead(offline_queue_len);
 #endif
    } else {
      out_frame[0] = RESP_CODE_NO_MORE_MESSAGES;
--- a/examples/companion_radio/MyMesh.h
+++ b/examples/companion_radio/MyMesh.h
@@ -8,11 +8,11 @@
 #define FIRMWARE_VER_CODE 8

 #ifndef FIRMWARE_BUILD_DATE
-#define FIRMWARE_BUILD_DATE "27 Feb 2026"
+#define FIRMWARE_BUILD_DATE "14 Feb 2026"
 #endif

 #ifndef FIRMWARE_VERSION
-#define FIRMWARE_VERSION "Meck v0.9.5"
+#define FIRMWARE_VERSION "Meck v0.8.7"
 #endif

 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
@@ -111,7 +111,6 @@ public:
  // Repeater admin - UI-initiated operations
  bool uiLoginToRepeater(uint32_t contact_idx, const char* password);
  bool uiSendCliCommand(uint32_t contact_idx, const char* command);
-  bool uiSendTelemetryRequest(uint32_t contact_idx);
  int  getAdminContactIdx() const { return _admin_contact_idx; }


--- a/examples/companion_radio/NodePrefs.h
+++ b/examples/companion_radio/NodePrefs.h
@@ -29,5 +29,4 @@ struct NodePrefs {  // persisted to file
  uint32_t gps_interval;     // GPS read interval in seconds
  uint8_t autoadd_config;    // bitmask for auto-add contacts config
  int8_t  utc_offset_hours;  // UTC offset in hours (-12 to +14), default 0
-  uint8_t kb_flash_notify;   // Keyboard backlight flash on new message (0=off, 1=on)
 };
--- a/examples/companion_radio/main.cpp
+++ b/examples/companion_radio/main.cpp
--- a/examples/companion_radio/ui-new/ApnDatabase.h
+++ b/examples/companion_radio/ui-new/ApnDatabase.h
@@ -1,372 +0,0 @@
-#pragma once
-
-// =============================================================================
-// ApnDatabase.h - Embedded APN Lookup Table
-//
-// Maps MCC/MNC (Mobile Country Code / Mobile Network Code) to default APN
-// settings for common carriers worldwide. Compiled directly into flash (~3KB)
-// so users never need to manually install a lookup file.
-//
-// The modem queries IMSI via AT+CIMI to extract MCC (3 digits) + MNC (2-3
-// digits), then looks up the APN here. If not found, falls back to the
-// modem's existing PDP context (AT+CGDCONT?) or user-configured APN.
-//
-// To add a carrier: append to APN_DATABASE[] with the MCC+MNC as a single
-// integer.  MNC can be 2 or 3 digits:
-//   MCC=310, MNC=260  → mccmnc = 310260
-//   MCC=505, MNC=01   → mccmnc = 50501
-//
-// Guard: HAS_4G_MODEM
-// =============================================================================
-
-#ifdef HAS_4G_MODEM
-
-#ifndef APN_DATABASE_H
-#define APN_DATABASE_H
-
-struct ApnEntry {
-  uint32_t mccmnc;        // MCC+MNC as integer (e.g. 310260 for T-Mobile US)
-  const char* apn;        // APN string
-  const char* carrier;    // Human-readable carrier name (for debug/display)
-};
-
-// ---------------------------------------------------------------------------
-// APN Database — sorted by MCC for binary search potential (not required)
-//
-// Sources: carrier documentation, GSMA databases, community wikis.
-// This covers ~120 major carriers across key regions. Users with less
-// common carriers can set APN manually in Settings.
-// ---------------------------------------------------------------------------
-
-static const ApnEntry APN_DATABASE[] = {
-  // =========================================================================
-  // Australia (MCC 505)
-  // =========================================================================
-  { 50501,  "telstra.internet",    "Telstra" },
-  { 50502,  "yesinternet",         "Optus" },
-  { 50503,  "vfinternet.au",       "Vodafone AU" },
-  { 50506,  "3netaccess",          "Three AU" },
-  { 50507,  "telstra.internet",    "Vodafone AU (MVNO)" },  // Many MVNOs on Telstra
-  { 50510,  "telstra.internet",    "Norfolk Tel" },
-  { 50512,  "3netaccess",          "Amaysim" },              // Optus MVNO
-  { 50514,  "yesinternet",         "Aussie Broadband" },     // Optus MVNO
-  { 50590,  "yesinternet",         "Optus MVNO" },
-
-  // =========================================================================
-  // New Zealand (MCC 530)
-  // =========================================================================
-  { 53001,  "internet",            "Vodafone NZ" },
-  { 53005,  "internet",            "Spark NZ" },
-  { 53024,  "internet",            "2degrees" },
-
-  // =========================================================================
-  // United States (MCC 310, 311, 312, 313, 316)
-  // =========================================================================
-  { 310012, "fast.t-mobile.com",   "Verizon (old)" },
-  { 310026, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310030, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310032, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310060, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310160, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310200, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310210, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310220, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310230, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310240, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310250, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310260, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310270, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310310, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310490, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310530, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310580, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310660, "fast.t-mobile.com",   "T-Mobile US" },
-  { 310800, "fast.t-mobile.com",   "T-Mobile US" },
-  { 311480, "vzwinternet",         "Verizon" },
-  { 311481, "vzwinternet",         "Verizon" },
-  { 311482, "vzwinternet",         "Verizon" },
-  { 311483, "vzwinternet",         "Verizon" },
-  { 311484, "vzwinternet",         "Verizon" },
-  { 311489, "vzwinternet",         "Verizon" },
-  { 310410, "fast.t-mobile.com",   "AT&T (migrated)" },
-  { 310120, "att.mvno",            "AT&T (Sprint)" },
-  { 312530, "iot.1nce.net",        "1NCE IoT" },
-  { 310120, "tfdata",              "Tracfone" },
-
-  // =========================================================================
-  // Canada (MCC 302)
-  // =========================================================================
-  { 30220,  "internet.com",        "Rogers" },
-  { 30221,  "internet.com",        "Rogers" },
-  { 30237,  "internet.com",        "Rogers" },
-  { 30272,  "internet.com",        "Rogers" },
-  { 30234,  "sp.telus.com",        "Telus" },
-  { 30286,  "sp.telus.com",        "Telus" },
-  { 30236,  "sp.telus.com",        "Telus" },
-  { 30261,  "sp.bell.ca",          "Bell" },
-  { 30263,  "sp.bell.ca",          "Bell" },
-  { 30267,  "sp.bell.ca",          "Bell" },
-  { 30268,  "fido-core-appl1.apn", "Fido" },
-  { 30278,  "internet.com",        "SaskTel" },
-  { 30266,  "sp.mb.com",           "MTS" },
-
-  // =========================================================================
-  // United Kingdom (MCC 234, 235)
-  // =========================================================================
-  { 23410,  "o2-internet",         "O2 UK" },
-  { 23415,  "three.co.uk",         "Vodafone UK" },
-  { 23420,  "three.co.uk",         "Three UK" },
-  { 23430,  "everywhere",          "EE" },
-  { 23431,  "everywhere",          "EE" },
-  { 23432,  "everywhere",          "EE" },
-  { 23433,  "everywhere",          "EE" },
-  { 23450,  "data.lycamobile.co.uk","Lycamobile UK" },
-  { 23486,  "three.co.uk",         "Three UK" },
-
-  // =========================================================================
-  // Germany (MCC 262)
-  // =========================================================================
-  { 26201,  "internet.t-mobile",   "Telekom DE" },
-  { 26202,  "web.vodafone.de",     "Vodafone DE" },
-  { 26203,  "internet",            "O2 DE" },
-  { 26207,  "internet",            "O2 DE" },
-
-  // =========================================================================
-  // France (MCC 208)
-  // =========================================================================
-  { 20801,  "orange",              "Orange FR" },
-  { 20810,  "sl2sfr",              "SFR" },
-  { 20815,  "free",                "Free Mobile" },
-  { 20820,  "ofnew.fr",            "Bouygues" },
-
-  // =========================================================================
-  // Italy (MCC 222)
-  // =========================================================================
-  { 22201,  "mobile.vodafone.it",  "TIM" },
-  { 22210,  "mobile.vodafone.it",  "Vodafone IT" },
-  { 22250,  "internet.it",         "Iliad IT" },
-  { 22288,  "internet.wind",       "WindTre" },
-  { 22299,  "internet.wind",       "WindTre" },
-
-  // =========================================================================
-  // Spain (MCC 214)
-  // =========================================================================
-  { 21401,  "internet",            "Vodafone ES" },
-  { 21403,  "internet",            "Orange ES" },
-  { 21404,  "internet",            "Yoigo" },
-  { 21407,  "internet",            "Movistar" },
-
-  // =========================================================================
-  // Netherlands (MCC 204)
-  // =========================================================================
-  { 20404,  "internet",            "Vodafone NL" },
-  { 20408,  "internet",            "KPN" },
-  { 20412,  "internet",            "Telfort" },
-  { 20416,  "internet",            "T-Mobile NL" },
-  { 20420,  "internet",            "T-Mobile NL" },
-
-  // =========================================================================
-  // Sweden (MCC 240)
-  // =========================================================================
-  { 24001,  "internet.telia.se",   "Telia SE" },
-  { 24002,  "tre.se",              "Three SE" },
-  { 24007,  "internet.telenor.se", "Telenor SE" },
-
-  // =========================================================================
-  // Norway (MCC 242)
-  // =========================================================================
-  { 24201,  "internet.telenor.no", "Telenor NO" },
-  { 24202,  "internet.netcom.no",  "Telia NO" },
-
-  // =========================================================================
-  // Denmark (MCC 238)
-  // =========================================================================
-  { 23801,  "internet",            "TDC" },
-  { 23802,  "internet",            "Telenor DK" },
-  { 23806,  "internet",            "Three DK" },
-  { 23820,  "internet",            "Telia DK" },
-
-  // =========================================================================
-  // Switzerland (MCC 228)
-  // =========================================================================
-  { 22801,  "gprs.swisscom.ch",    "Swisscom" },
-  { 22802,  "internet",            "Sunrise" },
-  { 22803,  "internet",            "Salt" },
-
-  // =========================================================================
-  // Austria (MCC 232)
-  // =========================================================================
-  { 23201,  "a1.net",              "A1" },
-  { 23203,  "web.one.at",          "Three AT" },
-  { 23205,  "web",                 "T-Mobile AT" },
-
-  // =========================================================================
-  // Japan (MCC 440, 441)
-  // =========================================================================
-  { 44010,  "spmode.ne.jp",        "NTT Docomo" },
-  { 44020,  "plus.4g",             "SoftBank" },
-  { 44051,  "au.au-net.ne.jp",     "KDDI au" },
-
-  // =========================================================================
-  // South Korea (MCC 450)
-  // =========================================================================
-  { 45005,  "lte.sktelecom.com",   "SK Telecom" },
-  { 45006,  "lte.ktfwing.com",     "KT" },
-  { 45008,  "lte.lguplus.co.kr",   "LG U+" },
-
-  // =========================================================================
-  // India (MCC 404, 405)
-  // =========================================================================
-  { 40445,  "airtelgprs.com",      "Airtel" },
-  { 40410,  "airtelgprs.com",      "Airtel" },
-  { 40411,  "www",                 "Vodafone IN (Vi)" },
-  { 40413,  "www",                 "Vodafone IN (Vi)" },
-  { 40486,  "www",                 "Vodafone IN (Vi)" },
-  { 40553,  "jionet",              "Jio" },
-  { 40554,  "jionet",              "Jio" },
-  { 40512,  "bsnlnet",             "BSNL" },
-
-  // =========================================================================
-  // Singapore (MCC 525)
-  // =========================================================================
-  { 52501,  "internet",            "Singtel" },
-  { 52503,  "internet",            "M1" },
-  { 52505,  "internet",            "StarHub" },
-
-  // =========================================================================
-  // Hong Kong (MCC 454)
-  // =========================================================================
-  { 45400,  "internet",            "CSL" },
-  { 45406,  "internet",            "SmarTone" },
-  { 45412,  "internet",            "CMHK" },
-
-  // =========================================================================
-  // Brazil (MCC 724)
-  // =========================================================================
-  { 72405,  "claro.com.br",        "Claro BR" },
-  { 72406,  "wap.oi.com.br",       "Vivo" },
-  { 72410,  "wap.oi.com.br",       "Vivo" },
-  { 72411,  "wap.oi.com.br",       "Vivo" },
-  { 72415,  "internet.tim.br",     "TIM BR" },
-  { 72431,  "gprs.oi.com.br",      "Oi" },
-
-  // =========================================================================
-  // Mexico (MCC 334)
-  // =========================================================================
-  { 33402,  "internet.itelcel.com","Telcel" },
-  { 33403,  "internet.movistar.mx","Movistar MX" },
-  { 33404,  "internet.att.net.mx", "AT&T MX" },
-
-  // =========================================================================
-  // South Africa (MCC 655)
-  // =========================================================================
-  { 65501,  "internet",            "Vodacom" },
-  { 65502,  "internet",            "Telkom ZA" },
-  { 65507,  "internet",            "Cell C" },
-  { 65510,  "internet",            "MTN ZA" },
-
-  // =========================================================================
-  // Philippines (MCC 515)
-  // =========================================================================
-  { 51502,  "internet.globe.com.ph","Globe" },
-  { 51503,  "internet",            "Smart" },
-  { 51505,  "internet",            "Sun Cellular" },
-
-  // =========================================================================
-  // Thailand (MCC 520)
-  // =========================================================================
-  { 52001,  "internet",            "AIS" },
-  { 52004,  "internet",            "TrueMove" },
-  { 52005,  "internet",            "dtac" },
-
-  // =========================================================================
-  // Indonesia (MCC 510)
-  // =========================================================================
-  { 51001,  "internet",            "Telkomsel" },
-  { 51010,  "internet",            "Telkomsel" },
-  { 51011,  "3gprs",               "XL Axiata" },
-  { 51028,  "3gprs",               "XL Axiata (Axis)" },
-
-  // =========================================================================
-  // Malaysia (MCC 502)
-  // =========================================================================
-  { 50212,  "celcom3g",            "Celcom" },
-  { 50213,  "celcom3g",            "Celcom" },
-  { 50216,  "internet",            "Digi" },
-  { 50219,  "celcom3g",            "Celcom" },
-
-  // =========================================================================
-  // Czech Republic (MCC 230)
-  // =========================================================================
-  { 23001,  "internet.t-mobile.cz","T-Mobile CZ" },
-  { 23002,  "internet",            "O2 CZ" },
-  { 23003,  "internet.vodafone.cz","Vodafone CZ" },
-
-  // =========================================================================
-  // Poland (MCC 260)
-  // =========================================================================
-  { 26001,  "internet",            "Plus PL" },
-  { 26002,  "internet",            "T-Mobile PL" },
-  { 26003,  "internet",            "Orange PL" },
-  { 26006,  "internet",            "Play" },
-
-  // =========================================================================
-  // Portugal (MCC 268)
-  // =========================================================================
-  { 26801,  "internet",            "Vodafone PT" },
-  { 26803,  "internet",            "NOS" },
-  { 26806,  "internet",            "MEO" },
-
-  // =========================================================================
-  // Ireland (MCC 272)
-  // =========================================================================
-  { 27201,  "internet",            "Vodafone IE" },
-  { 27202,  "open.internet",       "Three IE" },
-  { 27205,  "three.ie",            "Three IE" },
-
-  // =========================================================================
-  // IoT / Global SIMs
-  // =========================================================================
-  { 901028, "iot.1nce.net",        "1NCE (IoT)" },
-  { 90143,  "hologram",            "Hologram" },
-};
-
-#define APN_DATABASE_SIZE (sizeof(APN_DATABASE) / sizeof(APN_DATABASE[0]))
-
-// ---------------------------------------------------------------------------
-// Lookup function — returns nullptr if not found
-// ---------------------------------------------------------------------------
-
-inline const ApnEntry* apnLookup(uint32_t mccmnc) {
-  for (int i = 0; i < (int)APN_DATABASE_SIZE; i++) {
-    if (APN_DATABASE[i].mccmnc == mccmnc) {
-      return &APN_DATABASE[i];
-    }
-  }
-  return nullptr;
-}
-
-// Parse IMSI string into MCC+MNC.  Tries 3-digit MNC first (6-digit mccmnc),
-// falls back to 2-digit MNC (5-digit mccmnc) if not found.
-inline const ApnEntry* apnLookupFromIMSI(const char* imsi) {
-  if (!imsi || strlen(imsi) < 5) return nullptr;
-
-  // Extract MCC (always 3 digits)
-  uint32_t mcc = (imsi[0] - '0') * 100 + (imsi[1] - '0') * 10 + (imsi[2] - '0');
-
-  // Try 3-digit MNC first (more specific)
-  if (strlen(imsi) >= 6) {
-    uint32_t mnc3 = (imsi[3] - '0') * 100 + (imsi[4] - '0') * 10 + (imsi[5] - '0');
-    uint32_t mccmnc6 = mcc * 1000 + mnc3;
-    const ApnEntry* entry = apnLookup(mccmnc6);
-    if (entry) return entry;
-  }
-
-  // Fall back to 2-digit MNC
-  uint32_t mnc2 = (imsi[3] - '0') * 10 + (imsi[4] - '0');
-  uint32_t mccmnc5 = mcc * 100 + mnc2;
-  return apnLookup(mccmnc5);
-}
-
-#endif // APN_DATABASE_H
-#endif // HAS_4G_MODEM
--- a/examples/companion_radio/ui-new/Audiobookplayerscreen.h
+++ b/examples/companion_radio/ui-new/Audiobookplayerscreen.h
--- a/examples/companion_radio/ui-new/ChannelScreen.h
+++ b/examples/companion_radio/ui-new/ChannelScreen.h
@@ -14,7 +14,6 @@
 // Maximum messages to store in history
 #define CHANNEL_MSG_HISTORY_SIZE 300
 #define CHANNEL_MSG_TEXT_LEN 160
-#define MSG_PATH_MAX 20  // Max repeater hops stored per message

 #ifndef MAX_GROUP_CHANNELS
  #define MAX_GROUP_CHANNELS 20
@@ -24,7 +23,7 @@
 // On-disk format for message persistence (SD card)
 // ---------------------------------------------------------------------------
 #define MSG_FILE_MAGIC   0x4D434853  // "MCHS" - MeshCore History Store
-#define MSG_FILE_VERSION 3           // v3: MSG_PATH_MAX increased to 20
+#define MSG_FILE_VERSION 1
 #define MSG_FILE_PATH    "/meshcore/messages.bin"

 struct __attribute__((packed)) MsgFileHeader {
@@ -42,9 +41,8 @@ struct __attribute__((packed)) MsgFileRecord {
  uint8_t  channel_idx;
  uint8_t  valid;
  uint8_t  reserved;
-  uint8_t  path[MSG_PATH_MAX];  // Repeater hop hashes (first byte of pub key)
  char     text[CHANNEL_MSG_TEXT_LEN];
-  // 188 bytes total
+  // 168 bytes total
 };

 class UITask;  // Forward declaration
@@ -57,7 +55,6 @@ public:
    uint32_t timestamp;
    uint8_t path_len;
    uint8_t channel_idx;  // Which channel this message belongs to
-    uint8_t path[MSG_PATH_MAX];  // Repeater hop hashes
    char text[CHANNEL_MSG_TEXT_LEN];
    bool valid;
  };
@@ -73,39 +70,21 @@ private:
  int _msgsPerPage;   // Messages that fit on screen
  uint8_t _viewChannelIdx;  // Which channel we're currently viewing
  bool _sdReady;      // SD card is available for persistence
-  bool _showPathOverlay;  // Show path detail overlay for last received msg
-  int _pathScrollPos;     // Scroll offset within path overlay hop list
-  int _pathHopsVisible;   // Hops that fit on screen (set during render)
-
-  // Reply select mode — press R to pick a message and reply with @mention
-  bool _replySelectMode;       // True when user is picking a message to reply to
-  int  _replySelectPos;        // Index into chronological channelMsgs[] (0=oldest)
-  int  _replyChannelMsgCount;  // Cached count from last render (for input bounds)
-
-  // Per-channel unread message counts (standalone mode)
-  // Index 0..MAX_GROUP_CHANNELS-1 for channel messages
-  // Index MAX_GROUP_CHANNELS for DMs (channel_idx == 0xFF)
-  int _unread[MAX_GROUP_CHANNELS + 1];
  
 public:
  ChannelScreen(UITask* task, mesh::RTCClock* rtc) 
    : _task(task), _rtc(rtc), _msgCount(0), _newestIdx(-1), _scrollPos(0), 
-      _msgsPerPage(6), _viewChannelIdx(0), _sdReady(false), _showPathOverlay(false), _pathScrollPos(0), _pathHopsVisible(20),
-      _replySelectMode(false), _replySelectPos(-1), _replyChannelMsgCount(0) {
+      _msgsPerPage(CHANNEL_MSG_HISTORY_SIZE), _viewChannelIdx(0), _sdReady(false) {
    // Initialize all messages as invalid
    for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
      _messages[i].valid = false;
-      memset(_messages[i].path, 0, MSG_PATH_MAX);
    }
-    // Initialize unread counts
-    memset(_unread, 0, sizeof(_unread));
  }

  void setSDReady(bool ready) { _sdReady = ready; }

  // Add a new message to the history
-  void addMessage(uint8_t channel_idx, uint8_t path_len, const char* sender, const char* text,
-                  const uint8_t* path_bytes = nullptr) {
+  void addMessage(uint8_t channel_idx, uint8_t path_len, const char* sender, const char* text) {
    // Move to next slot in circular buffer
    _newestIdx = (_newestIdx + 1) % CHANNEL_MSG_HISTORY_SIZE;
    
@@ -115,13 +94,6 @@ public:
    msg->channel_idx = channel_idx;
    msg->valid = true;
    
-    // Store path hop hashes
-    memset(msg->path, 0, MSG_PATH_MAX);
-    if (path_bytes && path_len > 0 && path_len != 0xFF) {
-      int n = path_len < MSG_PATH_MAX ? path_len : MSG_PATH_MAX;
-      memcpy(msg->path, path_bytes, n);
-    }
-    
    // Sanitize emoji: replace UTF-8 emoji sequences with single-byte escape codes
    // The text already contains "Sender: message" format
    emojiSanitize(text, msg->text, CHANNEL_MSG_TEXT_LEN);
@@ -132,19 +104,6 @@ public:
    
    // Reset scroll to show newest message
    _scrollPos = 0;
-    _showPathOverlay = false;  // Dismiss overlay on new message
-    _pathScrollPos = 0;
-    _replySelectMode = false;  // Dismiss reply select on new message
-    _replySelectPos = -1;
-
-    // Track unread count for this channel (only for received messages, not sent)
-    // path_len == 0 means locally sent
-    if (path_len != 0) {
-      int unreadSlot = (channel_idx == 0xFF) ? MAX_GROUP_CHANNELS : channel_idx;
-      if (unreadSlot >= 0 && unreadSlot <= MAX_GROUP_CHANNELS) {
-        _unread[unreadSlot]++;
-      }
-    }

    // Persist to SD card
    saveToSD();
@@ -164,140 +123,7 @@ public:
  int getMessageCount() const { return _msgCount; }
  
  uint8_t getViewChannelIdx() const { return _viewChannelIdx; }
-  void setViewChannelIdx(uint8_t idx) {
-    _viewChannelIdx = idx;
-    _scrollPos = 0;
-    _showPathOverlay = false;
-    _pathScrollPos = 0;
-    markChannelRead(idx);
-  }
-  bool isShowingPathOverlay() const { return _showPathOverlay; }
-  void dismissPathOverlay() { _showPathOverlay = false; _pathScrollPos = 0; }
-
-  // --- Reply select mode (R key → pick a message → Enter to @mention reply) ---
-  bool isReplySelectMode() const { return _replySelectMode; }
-  void exitReplySelect() { _replySelectMode = false; _replySelectPos = -1; }
-
-  // Extract sender name from a "Sender: message" formatted text.
-  // Returns true if a sender was found, fills senderBuf (null-terminated).
-  static bool extractSenderName(const char* msgText, char* senderBuf, int bufLen) {
-    const char* colon = strstr(msgText, ": ");
-    if (!colon || colon == msgText) return false;
-    int nameLen = colon - msgText;
-    if (nameLen >= bufLen) nameLen = bufLen - 1;
-    memcpy(senderBuf, msgText, nameLen);
-    senderBuf[nameLen] = '\0';
-    return true;
-  }
-
-  // Get the sender name of the currently selected message in reply select mode.
-  // Returns true and fills senderBuf if valid selection exists.
-  bool getReplySelectSender(char* senderBuf, int bufLen) {
-    if (!_replySelectMode || _replySelectPos < 0) return false;
-
-    // Rebuild the channel message list (same logic as render)
-    static int rsMsgs[CHANNEL_MSG_HISTORY_SIZE];
-    int count = 0;
-    for (int i = 0; i < _msgCount && count < CHANNEL_MSG_HISTORY_SIZE; i++) {
-      int idx = _newestIdx - i;
-      while (idx < 0) idx += CHANNEL_MSG_HISTORY_SIZE;
-      idx = idx % CHANNEL_MSG_HISTORY_SIZE;
-      if (_messages[idx].valid && _messages[idx].channel_idx == _viewChannelIdx) {
-        rsMsgs[count++] = idx;
-      }
-    }
-    // Reverse to chronological (oldest first)
-    for (int l = 0, r = count - 1; l < r; l++, r--) {
-      int t = rsMsgs[l]; rsMsgs[l] = rsMsgs[r]; rsMsgs[r] = t;
-    }
-
-    if (_replySelectPos >= count) return false;
-    int idx = rsMsgs[_replySelectPos];
-    return extractSenderName(_messages[idx].text, senderBuf, bufLen);
-  }
-
-  // Get the ChannelMessage pointer for the currently selected reply message.
-  ChannelMessage* getReplySelectMsg() {
-    if (!_replySelectMode || _replySelectPos < 0) return nullptr;
-
-    static int rsMsgs[CHANNEL_MSG_HISTORY_SIZE];
-    int count = 0;
-    for (int i = 0; i < _msgCount && count < CHANNEL_MSG_HISTORY_SIZE; i++) {
-      int idx = _newestIdx - i;
-      while (idx < 0) idx += CHANNEL_MSG_HISTORY_SIZE;
-      idx = idx % CHANNEL_MSG_HISTORY_SIZE;
-      if (_messages[idx].valid && _messages[idx].channel_idx == _viewChannelIdx) {
-        rsMsgs[count++] = idx;
-      }
-    }
-    for (int l = 0, r = count - 1; l < r; l++, r--) {
-      int t = rsMsgs[l]; rsMsgs[l] = rsMsgs[r]; rsMsgs[r] = t;
-    }
-
-    if (_replySelectPos >= count) return nullptr;
-    return &_messages[rsMsgs[_replySelectPos]];
-  }
-
-  // --- Unread message tracking (standalone mode) ---
-
-  // Mark all messages for a channel as read
-  void markChannelRead(uint8_t channel_idx) {
-    int slot = (channel_idx == 0xFF) ? MAX_GROUP_CHANNELS : channel_idx;
-    if (slot >= 0 && slot <= MAX_GROUP_CHANNELS) {
-      _unread[slot] = 0;
-    }
-  }
-
-  // Get unread count for a specific channel
-  int getUnreadForChannel(uint8_t channel_idx) const {
-    int slot = (channel_idx == 0xFF) ? MAX_GROUP_CHANNELS : channel_idx;
-    if (slot >= 0 && slot <= MAX_GROUP_CHANNELS) {
-      return _unread[slot];
-    }
-    return 0;
-  }
-
-  // Get total unread across all channels
-  int getTotalUnread() const {
-    int total = 0;
-    for (int i = 0; i <= MAX_GROUP_CHANNELS; i++) {
-      total += _unread[i];
-    }
-    return total;
-  }
-
-  // Find the newest RECEIVED message for the current channel
-  // (path_len != 0 means received, path_len 0 = locally sent)
-  ChannelMessage* getNewestReceivedMsg() {
-    for (int i = 0; i < _msgCount; i++) {
-      int idx = _newestIdx - i;
-      while (idx < 0) idx += CHANNEL_MSG_HISTORY_SIZE;
-      idx = idx % CHANNEL_MSG_HISTORY_SIZE;
-      if (_messages[idx].valid && _messages[idx].channel_idx == _viewChannelIdx
-          && _messages[idx].path_len != 0) {
-        return &_messages[idx];
-      }
-    }
-    return nullptr;
-  }
-
-  // Format the path of the newest received message as paste-ready text
-  // Output: comma-separated hex prefixes e.g. "30, 3b, 9b, 05, e8, 36"
-  // Returns length written (0 if no path available)
-  int formatPathAsText(char* buf, int bufLen) {
-    ChannelMessage* msg = getNewestReceivedMsg();
-    if (!msg || msg->path_len == 0 || msg->path_len == 0xFF) return 0;
-    
-    int pos = 0;
-    int plen = msg->path_len < MSG_PATH_MAX ? msg->path_len : MSG_PATH_MAX;
-    
-    for (int h = 0; h < plen && pos < bufLen - 1; h++) {
-      if (h > 0) pos += snprintf(buf + pos, bufLen - pos, ", ");
-      pos += snprintf(buf + pos, bufLen - pos, "%02x", msg->path[h]);
-    }
-    
-    return pos;
-  }
+  void setViewChannelIdx(uint8_t idx) { _viewChannelIdx = idx; _scrollPos = 0; }

  // -----------------------------------------------------------------------
  // SD card persistence
@@ -337,7 +163,6 @@ public:
      rec.channel_idx = _messages[i].channel_idx;
      rec.valid       = _messages[i].valid ? 1 : 0;
      rec.reserved    = 0;
-      memcpy(rec.path, _messages[i].path, MSG_PATH_MAX);
      memcpy(rec.text, _messages[i].text, CHANNEL_MSG_TEXT_LEN);
      f.write((uint8_t*)&rec, sizeof(rec));
    }
@@ -403,7 +228,6 @@ public:
      _messages[i].path_len    = rec.path_len;
      _messages[i].channel_idx = rec.channel_idx;
      _messages[i].valid       = (rec.valid != 0);
-      memcpy(_messages[i].path, rec.path, MSG_PATH_MAX);
      memcpy(_messages[i].text, rec.text, CHANNEL_MSG_TEXT_LEN);
      if (_messages[i].valid) loaded++;
    }
@@ -456,175 +280,6 @@ public:
    // Divider line
    display.drawRect(0, 11, display.width(), 1);
    
-    // --- Path detail overlay ---
-    if (_showPathOverlay) {
-      display.setTextSize(0);
-      int lineH = 9;
-      int y = 14;
-      
-      ChannelMessage* msg = getNewestReceivedMsg();
-      if (!msg) {
-        display.setCursor(0, y);
-        display.setColor(DisplayDriver::LIGHT);
-        display.print("No received messages");
-      } else {
-        // Message preview (first ~30 chars)
-        display.setCursor(0, y);
-        display.setColor(DisplayDriver::LIGHT);
-        char preview[32];
-        strncpy(preview, msg->text, 31);
-        preview[31] = '\0';
-        display.print(preview);
-        y += lineH;
-        
-        // Age
-        uint32_t age = _rtc->getCurrentTime() - msg->timestamp;
-        display.setCursor(0, y);
-        display.setColor(DisplayDriver::YELLOW);
-        if (age < 60) sprintf(tmp, "Age: %ds", age);
-        else if (age < 3600) sprintf(tmp, "Age: %dm", age / 60);
-        else if (age < 86400) sprintf(tmp, "Age: %dh", age / 3600);
-        else sprintf(tmp, "Age: %dd", age / 86400);
-        display.print(tmp);
-        y += lineH;
-        
-        // Route type
-        display.setCursor(0, y);
-        uint8_t plen = msg->path_len;
-        if (plen == 0xFF) {
-          display.setColor(DisplayDriver::LIGHT);
-          display.print("Route: Direct");
-        } else if (plen == 0) {
-          display.setColor(DisplayDriver::LIGHT);
-          display.print("Route: Local/Sent");
-        } else {
-          display.setColor(DisplayDriver::GREEN);
-          sprintf(tmp, "Route: %d hop%s", plen, plen == 1 ? "" : "s");
-          display.print(tmp);
-        }
-        y += lineH + 2;
-        
-        // Show each hop resolved against contacts (scrollable)
-        if (plen > 0 && plen != 0xFF) {
-          int displayHops = plen < MSG_PATH_MAX ? plen : MSG_PATH_MAX;
-          int footerReserve = 26;  // footer + divider
-          int scrollBarW = 4;
-          int maxY = display.height() - footerReserve;
-          int hopAreaTop = y;
-          
-          // Calculate how many hops fit in the visible area
-          int hopsVisible = (maxY - hopAreaTop) / lineH;
-          if (hopsVisible < 1) hopsVisible = 1;
-          _pathHopsVisible = hopsVisible;  // Cache for input handler
-          bool needsScroll = displayHops > hopsVisible;
-          
-          // Clamp scroll position
-          int maxScroll = displayHops - hopsVisible;
-          if (maxScroll < 0) maxScroll = 0;
-          if (_pathScrollPos > maxScroll) _pathScrollPos = maxScroll;
-          
-          // Available text width (narrower if scroll bar present)
-          int textRight = needsScroll ? display.width() - scrollBarW - 2 : display.width();
-          (void)textRight;  // reserved for future truncation
-          
-          int startHop = _pathScrollPos;
-          int endHop = startHop + hopsVisible;
-          if (endHop > displayHops) endHop = displayHops;
-          
-          for (int h = startHop; h < endHop && y + lineH <= maxY; h++) {
-            uint8_t hopHash = msg->path[h];
-            display.setCursor(0, y);
-            display.setColor(DisplayDriver::LIGHT);
-            sprintf(tmp, " %d: ", h + 1);
-            display.print(tmp);
-            
-            // Always show hex prefix first
-            display.setColor(DisplayDriver::LIGHT);
-            sprintf(tmp, "%02X ", hopHash);
-            display.print(tmp);
-            
-            // Try to resolve name: prefer repeaters, then any contact
-            bool resolved = false;
-            int numContacts = the_mesh.getNumContacts();
-            ContactInfo contact;
-            
-            // First pass: repeaters only
-            for (uint32_t ci = 0; ci < numContacts && !resolved; ci++) {
-              if (the_mesh.getContactByIdx(ci, contact)) {
-                if (contact.id.pub_key[0] == hopHash && contact.type == ADV_TYPE_REPEATER) {
-                  display.setColor(DisplayDriver::GREEN);
-                  display.print(contact.name);
-                  resolved = true;
-                }
-              }
-            }
-            // Second pass: any contact type
-            if (!resolved) {
-              for (uint32_t ci = 0; ci < numContacts; ci++) {
-                if (the_mesh.getContactByIdx(ci, contact)) {
-                  if (contact.id.pub_key[0] == hopHash) {
-                    display.setColor(DisplayDriver::YELLOW);
-                    display.print(contact.name);
-                    resolved = true;
-                    break;
-                  }
-                }
-              }
-            }
-            // No name resolved - hex prefix already shown, add "?" marker
-            if (!resolved) {
-              display.setColor(DisplayDriver::LIGHT);
-              display.print("?");
-            }
-            y += lineH;
-          }
-          
-          // Scroll bar (right edge) when hops exceed visible area
-          if (needsScroll) {
-            int sbX = display.width() - scrollBarW;
-            int sbTop = hopAreaTop;
-            int sbHeight = maxY - hopAreaTop;
-            
-            // Outline
-            display.setColor(DisplayDriver::LIGHT);
-            display.drawRect(sbX, sbTop, scrollBarW, sbHeight);
-            
-            // Proportional thumb
-            int thumbH = (hopsVisible * sbHeight) / displayHops;
-            if (thumbH < 4) thumbH = 4;
-            int thumbY = sbTop + (_pathScrollPos * (sbHeight - thumbH)) / maxScroll;
-            display.setColor(DisplayDriver::GREEN);
-            for (int ty = thumbY + 1; ty < thumbY + thumbH - 1; ty++)
-              display.drawRect(sbX + 1, ty, scrollBarW - 2, 1);
-          }
-        }
-      }
-      
-      // Overlay footer
-      display.setTextSize(1);
-      int footerY = display.height() - 12;
-      display.drawRect(0, footerY - 2, display.width(), 1);
-      display.setCursor(0, footerY);
-      display.setColor(DisplayDriver::YELLOW);
-      display.print("Q:Back");
-      // Show scroll hint if path is scrollable
-      if (msg && msg->path_len > _pathHopsVisible && msg->path_len != 0xFF) {
-        const char* scrollHint = "W/S:Scrl";
-        int scrollW = display.getTextWidth(scrollHint);
-        display.setCursor((display.width() - scrollW) / 2, footerY);
-        display.print(scrollHint);
-      }
-      const char* copyHint = "Ent:Copy";
-      display.setCursor(display.width() - display.getTextWidth(copyHint) - 2, footerY);
-      display.print(copyHint);
-
-#if AUTO_OFF_MILLIS == 0
-      return 5000;
-#else
-      return 1000;
-#endif
-    }
-    
    if (channelMsgCount == 0) {
      display.setTextSize(0);  // Tiny font for body text
      display.setCursor(0, 20);
@@ -640,7 +295,6 @@ public:
      int lineHeight = 9;   // 8px font + 1px spacing
      int headerHeight = 14;
      int footerHeight = 14;
-      int scrollBarW = 4;   // Width of scroll indicator on right edge
      // Hard cutoff: no text may START at or beyond this y value
      // This ensures rendered glyphs (which extend lineHeight below y) stay above the footer
      int maxY = display.height() - footerHeight;
@@ -648,8 +302,7 @@ public:
      int y = headerHeight;
      
      // Build list of messages for this channel (newest first)
-      // Static to avoid 1200-byte stack allocation every render cycle
-      static int channelMsgs[CHANNEL_MSG_HISTORY_SIZE];
+      int channelMsgs[CHANNEL_MSG_HISTORY_SIZE];
      int numChannelMsgs = 0;
      
      for (int i = 0; i < _msgCount && numChannelMsgs < CHANNEL_MSG_HISTORY_SIZE; i++) {
@@ -667,13 +320,6 @@ public:
        int tmp = channelMsgs[l]; channelMsgs[l] = channelMsgs[r]; channelMsgs[r] = tmp;
      }
      
-      // Cache for reply select input bounds
-      _replyChannelMsgCount = numChannelMsgs;
-      
-      // Clamp scroll position to valid range
-      int maxScroll = numChannelMsgs > _msgsPerPage ? numChannelMsgs - _msgsPerPage : 0;
-      if (_scrollPos > maxScroll) _scrollPos = maxScroll;
-      
      // Calculate start index so newest messages appear at the bottom
      // scrollPos=0 shows the most recent messages, scrollPos++ scrolls up to older
      int startIdx = numChannelMsgs - _msgsPerPage - _scrollPos;
@@ -682,71 +328,40 @@ public:
      // Display messages oldest-to-newest (top to bottom)
      int msgsDrawn = 0;
      bool screenFull = false;
-      bool lastMsgTruncated = false;  // Did the last message get clipped by footer?
      for (int i = startIdx; i < numChannelMsgs && y + lineHeight <= maxY; i++) {
        int idx = channelMsgs[i];
        ChannelMessage* msg = &_messages[idx];
        
-        // Reply select: is this the currently selected message?
-        bool isSelected = (_replySelectMode && i == _replySelectPos);
-        
-        // Highlight: single fillRect for the entire message area, then
-        // draw DARK text on top (same pattern as web reader bookmarks).
-        // Because message height depends on word-wrap, we fill a generous
-        // area up-front and erase the excess after rendering.
-        int yStart = y;
-        int contentW = display.width();
-        int maxLinesPerMsg = 8;
-        if (isSelected) {
-          int maxFillH = (maxLinesPerMsg + 1) * lineHeight + 2;
-          int availH = maxY - y;
-          if (maxFillH > availH) maxFillH = availH;
-          display.setColor(DisplayDriver::LIGHT);
-          display.fillRect(0, y + 5, contentW, maxFillH);
-        }
-        
        // Time indicator with hop count - inline on same line as message start
        display.setCursor(0, y);
-        display.setColor(isSelected ? DisplayDriver::DARK : DisplayDriver::YELLOW);
+        display.setColor(DisplayDriver::YELLOW);
        
        uint32_t age = _rtc->getCurrentTime() - msg->timestamp;
-        if (isSelected) {
-          // Show > marker for selected message, replacing the hop count
-          if (age < 60) {
-            sprintf(tmp, ">%ds ", age);
-          } else if (age < 3600) {
-            sprintf(tmp, ">%dm ", age / 60);
-          } else if (age < 86400) {
-            sprintf(tmp, ">%dh ", age / 3600);
-          } else {
-            sprintf(tmp, ">%dd ", age / 86400);
-          }
+        if (age < 60) {
+          sprintf(tmp, "(%d) %ds ", msg->path_len == 0xFF ? 0 : msg->path_len, age);
+        } else if (age < 3600) {
+          sprintf(tmp, "(%d) %dm ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 60);
+        } else if (age < 86400) {
+          sprintf(tmp, "(%d) %dh ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 3600);
        } else {
-          if (age < 60) {
-            sprintf(tmp, "(%d) %ds ", msg->path_len == 0xFF ? 0 : msg->path_len, age);
-          } else if (age < 3600) {
-            sprintf(tmp, "(%d) %dm ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 60);
-          } else if (age < 86400) {
-            sprintf(tmp, "(%d) %dh ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 3600);
-          } else {
-            sprintf(tmp, "(%d) %dd ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 86400);
-          }
+          sprintf(tmp, "(%d) %dd ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 86400);
        }
        display.print(tmp);
        // DO NOT advance y - message text continues on the same line
        
        // Message text with character wrapping and inline emoji support
        // (continues after timestamp on first line)
-        display.setColor(isSelected ? DisplayDriver::DARK : DisplayDriver::LIGHT);
+        display.setColor(DisplayDriver::LIGHT);
        
        int textLen = strlen(msg->text);
        int pos = 0;
        int linesForThisMsg = 0;
+        int maxLinesPerMsg = 8;
        char charStr[2] = {0, 0};
        
        // Track position in pixels for emoji placement
        // Uses advance width (cursor movement) not bounding box for px tracking
-        int lineW = display.width() - scrollBarW - 1;  // Reserve space for scroll bar
+        int lineW = display.width();
        int px = display.getTextWidth(tmp);  // Pixel X after timestamp
        char dblStr[3] = {0, 0, 0};
        
@@ -835,70 +450,21 @@ public:
          }
        }
        
-        // Check if this message was clipped (not all text rendered)
-        lastMsgTruncated = (pos < textLen);
-        
        // If we didn't end on a full line, still count it
        if (px > 0) {
          y += lineHeight;
        }
        
        y += 2;  // Small gap between messages
-        
-        // Erase excess highlight below the actual message.
-        // The upfront fillRect covered a max area; restore the unused
-        // portion back to background so subsequent messages render cleanly.
-        if (isSelected) {
-          int usedH = y - yStart;
-          int maxFillH = (maxLinesPerMsg + 1) * lineHeight + 2;
-          int availH = maxY - yStart;
-          if (maxFillH > availH) maxFillH = availH;
-          if (usedH < maxFillH) {
-            display.setColor(DisplayDriver::DARK);
-            display.fillRect(0, y + 5, contentW, maxFillH - usedH);
-          }
-        }
-        
        msgsDrawn++;
        if (y + lineHeight > maxY) screenFull = true;
      }
      
-      // Only update _msgsPerPage when at the bottom (scrollPos==0) and the
-      // screen actually filled up.  While scrolled, freezing _msgsPerPage
-      // prevents a feedback loop where variable-height messages cause
-      // msgsPerPage to oscillate, shifting startIdx every render (flicker).
-      if (screenFull && msgsDrawn > 0 && _scrollPos == 0) {
-        // If the last message was truncated (text clipped by footer), exclude it
-        // from the page count so next render starts one message later and the
-        // bottom message fits completely.
-        int effectiveDrawn = lastMsgTruncated ? msgsDrawn - 1 : msgsDrawn;
-        if (effectiveDrawn < 1) effectiveDrawn = 1;
-        _msgsPerPage = effectiveDrawn;
-      }
-      
-      // --- Scroll bar (emoji picker style) ---
-      int sbX = display.width() - scrollBarW;
-      int sbTop = headerHeight;
-      int sbHeight = maxY - headerHeight;
-      
-      // Draw track outline
-      display.setColor(DisplayDriver::LIGHT);
-      display.drawRect(sbX, sbTop, scrollBarW, sbHeight);
-      
-      if (channelMsgCount > _msgsPerPage) {
-        // Scrollable: draw proportional thumb
-        int maxScroll = channelMsgCount - _msgsPerPage;
-        if (maxScroll < 1) maxScroll = 1;
-        int thumbH = (_msgsPerPage * sbHeight) / channelMsgCount;
-        if (thumbH < 4) thumbH = 4;
-        // _scrollPos=0 is newest (bottom), so invert for thumb position
-        int thumbY = sbTop + ((maxScroll - _scrollPos) * (sbHeight - thumbH)) / maxScroll;
-        for (int ty = thumbY + 1; ty < thumbY + thumbH - 1; ty++)
-          display.drawRect(sbX + 1, ty, scrollBarW - 2, 1);
-      } else {
-        // All messages fit: fill entire track
-        for (int ty = sbTop + 1; ty < sbTop + sbHeight - 1; ty++)
-          display.drawRect(sbX + 1, ty, scrollBarW - 2, 1);
+      // Only update _msgsPerPage when the screen actually filled up.
+      // If we ran out of messages before filling the screen, keep the
+      // previous (higher) value so startIdx doesn't under-count.
+      if (screenFull && msgsDrawn > 0) {
+        _msgsPerPage = msgsDrawn;
      }
      
      display.setTextSize(1);  // Restore for footer
@@ -910,18 +476,13 @@ public:
    display.setCursor(0, footerY);
    display.setColor(DisplayDriver::YELLOW);
    
-    // Left side: abbreviated controls
-    if (_replySelectMode) {
-      display.print("W/S:Sel V:Pth Q:X");
-      const char* rightText = "Ent:Reply";
-      display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
-      display.print(rightText);
-    } else {
-      display.print("Q:Bck A/D:Ch R:Rply");
-      const char* rightText = "Ent:New";
-      display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
-      display.print(rightText);
-    }
+    // Left side: Q:Back A/D:Ch
+    display.print("Q:Back A/D:Ch");
+    
+    // Right side: Entr:New
+    const char* rightText = "Entr:New";
+    display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
+    display.print(rightText);

 #if AUTO_OFF_MILLIS == 0  // e-ink
    return 5000;
@@ -931,111 +492,7 @@ public:
  }

  bool handleInput(char c) override {
-    // If overlay is showing, handle scroll and dismiss
-    if (_showPathOverlay) {
-      if (c == 'q' || c == 'Q' || c == '\b' || c == 'v' || c == 'V') {
-        _showPathOverlay = false;
-        _pathScrollPos = 0;
-        return true;
-      }
-      if (c == '\r' || c == 13) {
-        return false;  // Let main.cpp handle Enter for copy-to-compose
-      }
-      // W - scroll up in hop list
-      if (c == 'w' || c == 'W' || c == 0xF2) {
-        if (_pathScrollPos > 0) {
-          _pathScrollPos--;
-        }
-        return true;
-      }
-      // S - scroll down in hop list
-      if (c == 's' || c == 'S' || c == 0xF1) {
-        ChannelMessage* msg = getNewestReceivedMsg();
-        if (msg && msg->path_len > 0 && msg->path_len != 0xFF) {
-          int totalHops = msg->path_len < MSG_PATH_MAX ? msg->path_len : MSG_PATH_MAX;
-          if (_pathScrollPos < totalHops - _pathHopsVisible) {
-            _pathScrollPos++;
-          }
-        }
-        return true;
-      }
-      return true;  // Consume all other keys while overlay is up
-    }
-
-    // --- Reply select mode ---
-    if (_replySelectMode) {
-      // Q - exit reply select
-      if (c == 'q' || c == 'Q' || c == '\b') {
-        _replySelectMode = false;
-        _replySelectPos = -1;
-        return true;
-      }
-      // W - select older message (lower index in chronological order)
-      if (c == 'w' || c == 'W' || c == 0xF2) {
-        if (_replySelectPos > 0) {
-          _replySelectPos--;
-          // Auto-scroll to keep selection visible
-          int startIdx = _replyChannelMsgCount - _msgsPerPage - _scrollPos;
-          if (startIdx < 0) startIdx = 0;
-          if (_replySelectPos < startIdx) {
-            _scrollPos++;
-          }
-        }
-        return true;
-      }
-      // S - select newer message (higher index in chronological order)
-      if (c == 's' || c == 'S' || c == 0xF1) {
-        if (_replySelectPos < _replyChannelMsgCount - 1) {
-          _replySelectPos++;
-          // Auto-scroll to keep selection visible
-          int endIdx = _replyChannelMsgCount - _scrollPos;
-          if (_replySelectPos >= endIdx) {
-            if (_scrollPos > 0) _scrollPos--;
-          }
-        }
-        return true;
-      }
-      // V - view path for the SELECTED message (not just newest received)
-      if (c == 'v' || c == 'V') {
-        // Path overlay will use getNewestReceivedMsg() — for v1 this is fine.
-        // The user can see the selected message's hop count in the > marker.
-        ChannelMessage* selMsg = getReplySelectMsg();
-        if (selMsg && selMsg->path_len != 0) {
-          _showPathOverlay = true;
-          _pathScrollPos = 0;
-        }
-        return true;
-      }
-      // Enter - let main.cpp handle (enters compose with @mention)
-      if (c == '\r' || c == 13) {
-        return false;
-      }
-      return true;  // Consume all other keys in reply select
-    }
-
    int channelMsgCount = getMessageCountForChannel();
-
-    // R - enter reply select mode
-    if (c == 'r' || c == 'R') {
-      if (channelMsgCount > 0) {
-        _replySelectMode = true;
-        // Start with newest message selected
-        _replySelectPos = _replyChannelMsgCount > 0
-                            ? _replyChannelMsgCount - 1 : channelMsgCount - 1;
-        return true;
-      }
-      return false;
-    }
-    
-    // V - show path detail for last received message
-    if (c == 'v' || c == 'V') {
-      if (getNewestReceivedMsg() != nullptr) {
-        _showPathOverlay = true;
-        _pathScrollPos = 0;
-        return true;
-      }
-      return false;  // No received messages to show
-    }
    
    // W or KEY_PREV - scroll up (older messages)
    if (c == 0xF2 || c == 'w' || c == 'W') {
@@ -1055,8 +512,6 @@ public:
    
    // A - previous channel
    if (c == 'a' || c == 'A') {
-      _replySelectMode = false;
-      _replySelectPos = -1;
      if (_viewChannelIdx > 0) {
        _viewChannelIdx--;
      } else {
@@ -1070,14 +525,11 @@ public:
        }
      }
      _scrollPos = 0;
-      markChannelRead(_viewChannelIdx);
      return true;
    }
    
    // D - next channel
    if (c == 'd' || c == 'D') {
-      _replySelectMode = false;
-      _replySelectPos = -1;
      ChannelDetails ch;
      uint8_t nextIdx = _viewChannelIdx + 1;
      if (the_mesh.getChannel(nextIdx, ch) && ch.name[0] != '\0') {
@@ -1086,7 +538,6 @@ public:
        _viewChannelIdx = 0;
      }
      _scrollPos = 0;
-      markChannelRead(_viewChannelIdx);
      return true;
    }
    
--- a/examples/companion_radio/ui-new/Contactsscreen.h
+++ b/examples/companion_radio/ui-new/Contactsscreen.h
@@ -18,7 +18,6 @@ public:
    FILTER_REPEATER,
    FILTER_ROOM,       // Room servers
    FILTER_SENSOR,
-    FILTER_FAVOURITE,  // Contacts marked as favourite (any type)
    FILTER_COUNT       // keep last
  };

@@ -31,9 +30,9 @@ private:

  // Cached filtered contact indices for efficient scrolling
  // We rebuild this on filter change or when entering the screen
-  // Arrays allocated in PSRAM when available (supports 1000+ contacts)
-  uint16_t* _filteredIdx;    // indices into contact table
-  uint32_t* _filteredTs;     // cached last_advert_timestamp for sorting
+  static const int MAX_VISIBLE = 400;  // matches MAX_CONTACTS build flag
+  uint16_t _filteredIdx[MAX_VISIBLE];  // indices into contact table
+  uint32_t _filteredTs[MAX_VISIBLE];   // cached last_advert_timestamp for sorting
  int _filteredCount;                  // how many contacts match current filter
  bool _cacheValid;

@@ -49,7 +48,6 @@ private:
      case FILTER_REPEATER:  return "Rptr";
      case FILTER_ROOM:      return "Room";
      case FILTER_SENSOR:    return "Sens";
-      case FILTER_FAVOURITE: return "Fav";
      default:               return "?";
    }
  }
@@ -63,7 +61,7 @@ private:
    }
  }

-  bool matchesFilter(uint8_t adv_type, uint8_t flags = 0) const {
+  bool matchesFilter(uint8_t adv_type) const {
    switch (_filter) {
      case FILTER_ALL:       return true;
      case FILTER_CHAT:      return adv_type == ADV_TYPE_CHAT;
@@ -72,7 +70,6 @@ private:
      case FILTER_SENSOR:    return (adv_type != ADV_TYPE_CHAT &&
                                     adv_type != ADV_TYPE_REPEATER &&
                                     adv_type != ADV_TYPE_ROOM);
-      case FILTER_FAVOURITE: return (flags & 0x01) != 0;
      default:               return true;
    }
  }
@@ -81,9 +78,9 @@ private:
    _filteredCount = 0;
    uint32_t numContacts = the_mesh.getNumContacts();
    ContactInfo contact;
-    for (uint32_t i = 0; i < numContacts && _filteredCount < MAX_CONTACTS; i++) {
+    for (uint32_t i = 0; i < numContacts && _filteredCount < MAX_VISIBLE; i++) {
      if (the_mesh.getContactByIdx(i, contact)) {
-        if (matchesFilter(contact.type, contact.flags)) {
+        if (matchesFilter(contact.type)) {
          _filteredIdx[_filteredCount] = (uint16_t)i;
          _filteredTs[_filteredCount] = contact.last_advert_timestamp;
          _filteredCount++;
@@ -91,7 +88,7 @@ private:
      }
    }
    // Sort by last_advert_timestamp descending (most recently seen first)
-    // Insertion sort — fine for up to ~1000 entries on ESP32
+    // Simple insertion sort â€” fine for up to 400 entries on ESP32
    for (int i = 1; i < _filteredCount; i++) {
      uint16_t tmpIdx = _filteredIdx[i];
      uint32_t tmpTs  = _filteredTs[i];
@@ -133,15 +130,7 @@ private:
 public:
  ContactsScreen(UITask* task, mesh::RTCClock* rtc)
    : _task(task), _rtc(rtc), _scrollPos(0), _filter(FILTER_ALL),
-      _filteredCount(0), _cacheValid(false), _rowsPerPage(5) {
-  #if defined(ESP32) && defined(BOARD_HAS_PSRAM)
-    _filteredIdx = (uint16_t*)ps_calloc(MAX_CONTACTS, sizeof(uint16_t));
-    _filteredTs = (uint32_t*)ps_calloc(MAX_CONTACTS, sizeof(uint32_t));
-  #else
-    _filteredIdx = new uint16_t[MAX_CONTACTS]();
-    _filteredTs = new uint32_t[MAX_CONTACTS]();
-  #endif
-  }
+      _filteredCount(0), _cacheValid(false), _rowsPerPage(5) {}

  void invalidateCache() { _cacheValid = false; }

--- a/examples/companion_radio/ui-new/Emojisprites.h
+++ b/examples/companion_radio/ui-new/Emojisprites.h
@@ -3,7 +3,7 @@
 // Emoji sprites for e-ink display - dual size
 // Large (12x12) for compose/picker, Small (10x10) for channel view
 // MSB-first, 2 bytes per row
-// 65 total emoji: joy/thumbsup/frown first, then 43 original, then 19 new
+// 46 total emoji: joy/thumbsup/frown first, then 43 original (telephone removed)

 #include <stdint.h>
 #ifdef ESP32
@@ -15,11 +15,11 @@
 #define EMOJI_SM_W 10
 #define EMOJI_SM_H 10

-#define EMOJI_COUNT 65
+#define EMOJI_COUNT 46

 // Escape codes in 0x80+ range - safe from keyboard ASCII (32-126)
 #define EMOJI_ESCAPE_START 0x80
-#define EMOJI_ESCAPE_END   0xC0   // 0x80 + 64
+#define EMOJI_ESCAPE_END   0xAD   // 0x80 + 45
 #define EMOJI_PAD_BYTE     0x7F   // DEL, not typeable (key < 127 guard)

 // ======== LARGE 12x12 SPRITES ========
@@ -208,82 +208,6 @@ static const uint8_t emoji_lg_peach[] PROGMEM = {
 static const uint8_t emoji_lg_racing_car[] PROGMEM = {
  0x00,0x00, 0x00,0x00, 0x00,0x00, 0x07,0x80, 0x0F,0xC0, 0x7F,0xE0, 0xFF,0xF0, 0xFF,0xF0, 0x6F,0x60, 0x49,0x20, 0x00,0x00, 0x00,0x00,
 };
-// [46] mouse 🐭
-static const uint8_t emoji_lg_mouse[] PROGMEM = {
-  0x30,0xC0, 0x79,0xE0, 0x79,0xE0, 0x3F,0xC0, 0x49,0x20, 0x80,0x10, 0x86,0x10, 0x89,0x10, 0x40,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
-};
-// [47] mushroom 🍄
-static const uint8_t emoji_lg_mushroom[] PROGMEM = {
-  0x1F,0x80, 0x3F,0xC0, 0x7F,0xE0, 0xE6,0x70, 0xE6,0x70, 0x7F,0xE0, 0x3F,0xC0, 0x0F,0x00, 0x0F,0x00, 0x0F,0x00, 0x1F,0x80, 0x00,0x00,
-};
-// [48] biohazard ☣️
-static const uint8_t emoji_lg_biohazard[] PROGMEM = {
-  0x0F,0x00, 0x1F,0x80, 0x3F,0xC0, 0x1F,0x80, 0x0F,0x00, 0x66,0x60, 0x76,0xE0, 0x70,0xE0, 0x79,0xE0, 0x39,0xC0, 0x19,0x80, 0x00,0x00,
-};
-// [49] panda 🐼
-static const uint8_t emoji_lg_panda[] PROGMEM = {
-  0x00,0x00, 0x60,0x60, 0xF0,0xF0, 0xF0,0xF0, 0x7F,0xE0, 0x59,0xA0, 0x59,0xA0, 0x40,0x20, 0x46,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
-};
-// [50] anger 💢
-static const uint8_t emoji_lg_anger[] PROGMEM = {
-  0x00,0x00, 0x3C,0xC0, 0x3C,0xC0, 0x30,0xC0, 0x30,0x00, 0x00,0x00, 0x00,0x00, 0x00,0xC0, 0x30,0xC0, 0x33,0xC0, 0x33,0xC0, 0x00,0x00,
-};
-// [51] dragon_face 🐲
-static const uint8_t emoji_lg_dragon_face[] PROGMEM = {
-  0xC0,0x30, 0xE0,0x70, 0x76,0xE0, 0x3F,0xC0, 0x69,0x60, 0x40,0x20, 0x4F,0x20, 0x29,0x40, 0x30,0xC0, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
-};
-// [52] pager 📟
-static const uint8_t emoji_lg_pager[] PROGMEM = {
-  0x00,0x00, 0x7F,0xE0, 0x40,0x20, 0x5F,0xA0, 0x5F,0xA0, 0x40,0x20, 0x5B,0x20, 0x5B,0x20, 0x40,0x20, 0x7F,0xE0, 0x00,0x00, 0x00,0x00,
-};
-// [53] bee 🐝
-static const uint8_t emoji_lg_bee[] PROGMEM = {
-  0x00,0x00, 0x19,0x80, 0x19,0x80, 0x3F,0x80, 0x7F,0xC0, 0x7F,0xE0, 0x7F,0xE0, 0x7F,0xC0, 0x3F,0x80, 0x1F,0x40, 0x0A,0x00, 0x00,0x00,
-};
-// [54] bulb 💡
-static const uint8_t emoji_lg_bulb[] PROGMEM = {
-  0x1F,0x80, 0x20,0x40, 0x40,0x20, 0x40,0x20, 0x40,0x20, 0x20,0x40, 0x30,0xC0, 0x1F,0x80, 0x16,0x80, 0x1F,0x80, 0x0F,0x00, 0x00,0x00,
-};
-// [55] cat 🐱
-static const uint8_t emoji_lg_cat[] PROGMEM = {
-  0x40,0x20, 0x60,0x60, 0x70,0xE0, 0x3F,0xC0, 0x59,0xA0, 0x40,0x20, 0x40,0x20, 0x46,0x20, 0x29,0x40, 0x30,0xC0, 0x1F,0x80, 0x00,0x00,
-};
-// [56] fleur ⚜️
-static const uint8_t emoji_lg_fleur[] PROGMEM = {
-  0x06,0x00, 0x06,0x00, 0x0F,0x00, 0x6F,0x60, 0xF6,0xF0, 0xF6,0xF0, 0x76,0xE0, 0x3F,0xC0, 0x1F,0x80, 0x0F,0x00, 0x19,0x80, 0x00,0x00,
-};
-// [57] moon 🌔
-static const uint8_t emoji_lg_moon[] PROGMEM = {
-  0x1F,0x80, 0x3F,0xC0, 0x7F,0xE0, 0x7F,0x80, 0xFF,0x80, 0xFF,0x00, 0xFF,0x00, 0xFF,0x80, 0x7F,0x80, 0x7F,0xE0, 0x3F,0xC0, 0x1F,0x80,
-};
-// [58] coffee ☕
-static const uint8_t emoji_lg_coffee[] PROGMEM = {
-  0x24,0x80, 0x12,0x40, 0x00,0x00, 0x7F,0xC0, 0x40,0x70, 0x40,0x50, 0x40,0x50, 0x40,0x70, 0x7F,0xC0, 0x00,0x00, 0xFF,0xC0, 0x00,0x00,
-};
-// [59] tooth 🦷
-static const uint8_t emoji_lg_tooth[] PROGMEM = {
-  0x3F,0xC0, 0x7F,0xE0, 0xFF,0xF0, 0xFF,0xF0, 0xFF,0xF0, 0x7F,0xE0, 0x3F,0xC0, 0x3F,0xC0, 0x39,0xC0, 0x39,0xC0, 0x30,0xC0, 0x20,0x40,
-};
-// [60] pretzel 🥨
-static const uint8_t emoji_lg_pretzel[] PROGMEM = {
-  0x39,0xC0, 0x46,0x20, 0x80,0x20, 0x86,0x10, 0x49,0x20, 0x30,0xC0, 0x30,0xC0, 0x49,0x20, 0x86,0x10, 0x80,0x10, 0x46,0x20, 0x39,0xC0,
-};
-// [61] abacus 🧮
-static const uint8_t emoji_lg_abacus[] PROGMEM = {
-  0xFF,0xF0, 0x80,0x10, 0xB6,0x50, 0x80,0x10, 0xA6,0x90, 0x80,0x10, 0x94,0xD0, 0x80,0x10, 0xB2,0x50, 0x80,0x10, 0xFF,0xF0, 0x00,0x00,
-};
-// [62] moai 🗿
-static const uint8_t emoji_lg_moai[] PROGMEM = {
-  0x3F,0xC0, 0x7F,0xC0, 0x7F,0xC0, 0x39,0xC0, 0x39,0xC0, 0x3F,0xC0, 0x27,0x40, 0x3F,0x80, 0x2F,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00,
-};
-// [63] tipping 💁
-static const uint8_t emoji_lg_tipping[] PROGMEM = {
-  0x1E,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00, 0x0C,0x00, 0x1E,0x00, 0x3F,0x00, 0x7F,0x80, 0x0C,0xE0, 0x0D,0xE0, 0x12,0xE0, 0x33,0x00,
-};
-// [64] hedgehog 🦔
-static const uint8_t emoji_lg_hedgehog[] PROGMEM = {
-  0x00,0x00, 0x0A,0x80, 0x15,0x40, 0x2A,0xA0, 0x55,0x60, 0x7E,0xF0, 0xDB,0x90, 0xFF,0xD0, 0x7F,0xE0, 0x3F,0xC0, 0x24,0x80, 0x00,0x00,
-};

 static const uint8_t* const EMOJI_SPRITES_LG[] PROGMEM = {
  emoji_lg_joy, emoji_lg_thumbsup, emoji_lg_frown,
@@ -296,11 +220,6 @@ static const uint8_t* const EMOJI_SPRITES_LG[] PROGMEM = {
  emoji_lg_kangaroo, emoji_lg_feather, emoji_lg_bright, emoji_lg_part_alt, emoji_lg_motorboat,
  emoji_lg_domino, emoji_lg_satellite, emoji_lg_customs, emoji_lg_cowboy, emoji_lg_wheel,
  emoji_lg_koala, emoji_lg_control_knobs, emoji_lg_peach, emoji_lg_racing_car,
-  emoji_lg_mouse, emoji_lg_mushroom, emoji_lg_biohazard, emoji_lg_panda,
-  emoji_lg_anger, emoji_lg_dragon_face, emoji_lg_pager, emoji_lg_bee,
-  emoji_lg_bulb, emoji_lg_cat, emoji_lg_fleur, emoji_lg_moon,
-  emoji_lg_coffee, emoji_lg_tooth, emoji_lg_pretzel, emoji_lg_abacus,
-  emoji_lg_moai, emoji_lg_tipping, emoji_lg_hedgehog,
 };

 // ======== SMALL 10x10 SPRITES ========
@@ -443,82 +362,6 @@ static const uint8_t emoji_sm_peach[] PROGMEM = {
 static const uint8_t emoji_sm_racing_car[] PROGMEM = {
  0x00,0x00, 0x00,0x00, 0x0E,0x00, 0x1F,0x00, 0x7F,0x80, 0xFF,0xC0, 0xFF,0xC0, 0x5E,0x80, 0x00,0x00, 0x00,0x00,
 };
-// [46] mouse 🐭
-static const uint8_t emoji_sm_mouse[] PROGMEM = {
-  0x61,0x80, 0xF3,0xC0, 0x7F,0x80, 0x92,0x40, 0x80,0x40, 0x8C,0x40, 0x52,0x80, 0x40,0x80, 0x3F,0x00, 0x00,0x00,
-};
-// [47] mushroom 🍄
-static const uint8_t emoji_sm_mushroom[] PROGMEM = {
-  0x3F,0x00, 0x7F,0x80, 0xED,0xC0, 0xED,0xC0, 0x7F,0x80, 0x3F,0x00, 0x1E,0x00, 0x1E,0x00, 0x3F,0x00, 0x00,0x00,
-};
-// [48] biohazard ☣️
-static const uint8_t emoji_sm_biohazard[] PROGMEM = {
-  0x1E,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00, 0x6D,0x80, 0x73,0x80, 0x73,0x80, 0x7B,0x80, 0x33,0x00, 0x00,0x00,
-};
-// [49] panda 🐼
-static const uint8_t emoji_sm_panda[] PROGMEM = {
-  0xC0,0xC0, 0xF3,0xC0, 0x7F,0x80, 0xB3,0x40, 0xB3,0x40, 0x80,0x40, 0x4C,0x80, 0x21,0x00, 0x3F,0x00, 0x00,0x00,
-};
-// [50] anger 💢
-static const uint8_t emoji_sm_anger[] PROGMEM = {
-  0x00,0x00, 0x73,0x00, 0x73,0x00, 0x63,0x00, 0x60,0x00, 0x01,0x80, 0x63,0x00, 0x67,0x00, 0x67,0x00, 0x00,0x00,
-};
-// [51] dragon_face 🐲
-static const uint8_t emoji_sm_dragon_face[] PROGMEM = {
-  0xC0,0xC0, 0xED,0xC0, 0x7F,0x80, 0x52,0x80, 0x40,0x80, 0x4C,0x80, 0x33,0x00, 0x2D,0x00, 0x1E,0x00, 0x00,0x00,
-};
-// [52] pager 📟
-static const uint8_t emoji_sm_pager[] PROGMEM = {
-  0x00,0x00, 0x7F,0x80, 0x40,0x80, 0x5E,0x80, 0x40,0x80, 0x5A,0x80, 0x5A,0x80, 0x40,0x80, 0x7F,0x80, 0x00,0x00,
-};
-// [53] bee 🐝
-static const uint8_t emoji_sm_bee[] PROGMEM = {
-  0x33,0x00, 0x33,0x00, 0x7F,0x00, 0xFF,0x80, 0xFF,0xC0, 0xFF,0x80, 0x7F,0x00, 0x3E,0x80, 0x14,0x00, 0x00,0x00,
-};
-// [54] bulb 💡
-static const uint8_t emoji_sm_bulb[] PROGMEM = {
-  0x3F,0x00, 0x40,0x80, 0x80,0x40, 0x80,0x40, 0x40,0x80, 0x33,0x00, 0x3F,0x00, 0x1E,0x00, 0x1E,0x00, 0x00,0x00,
-};
-// [55] cat 🐱
-static const uint8_t emoji_sm_cat[] PROGMEM = {
-  0x80,0x40, 0xC0,0xC0, 0x7F,0x80, 0xB3,0x40, 0x80,0x40, 0x8C,0x40, 0x52,0x80, 0x61,0x80, 0x3F,0x00, 0x00,0x00,
-};
-// [56] fleur ⚜️
-static const uint8_t emoji_sm_fleur[] PROGMEM = {
-  0x0C,0x00, 0x0C,0x00, 0x6D,0x80, 0xED,0xC0, 0xED,0xC0, 0x6D,0x80, 0x3F,0x00, 0x1E,0x00, 0x33,0x00, 0x00,0x00,
-};
-// [57] moon 🌔
-static const uint8_t emoji_sm_moon[] PROGMEM = {
-  0x3F,0x00, 0x7F,0x80, 0xFF,0x80, 0xFE,0x00, 0xFE,0x00, 0xFE,0x00, 0xFE,0x00, 0xFF,0x80, 0x7F,0x80, 0x3F,0x00,
-};
-// [58] coffee ☕
-static const uint8_t emoji_sm_coffee[] PROGMEM = {
-  0x49,0x00, 0x24,0x80, 0x00,0x00, 0xFF,0x00, 0x81,0xC0, 0x81,0x40, 0x81,0xC0, 0xFF,0x00, 0x00,0x00, 0xFE,0x00,
-};
-// [59] tooth 🦷
-static const uint8_t emoji_sm_tooth[] PROGMEM = {
-  0x7F,0x80, 0xFF,0xC0, 0xFF,0xC0, 0xFF,0xC0, 0x7F,0x80, 0x3F,0x00, 0x3B,0x80, 0x31,0x80, 0x20,0x80, 0x00,0x00,
-};
-// [60] pretzel 🥨
-static const uint8_t emoji_sm_pretzel[] PROGMEM = {
-  0x73,0x80, 0x9E,0x40, 0x8C,0x40, 0x52,0x80, 0x33,0x00, 0x33,0x00, 0x52,0x80, 0x8C,0x40, 0x9E,0x40, 0x73,0x80,
-};
-// [61] abacus 🧮
-static const uint8_t emoji_sm_abacus[] PROGMEM = {
-  0xFF,0xC0, 0x80,0x40, 0xB5,0x40, 0x80,0x40, 0xAD,0x40, 0x80,0x40, 0xAB,0x40, 0x80,0x40, 0xFF,0xC0, 0x00,0x00,
-};
-// [62] moai 🗿
-static const uint8_t emoji_sm_moai[] PROGMEM = {
-  0x7F,0x00, 0x7F,0x00, 0x33,0x00, 0x33,0x00, 0x3F,0x00, 0x2E,0x00, 0x3E,0x00, 0x3E,0x00, 0x3E,0x00, 0x1C,0x00,
-};
-// [63] tipping 💁
-static const uint8_t emoji_sm_tipping[] PROGMEM = {
-  0x3C,0x00, 0x7E,0x00, 0x7E,0x00, 0x3C,0x00, 0x18,0x00, 0x3C,0x00, 0x7E,0x00, 0x1B,0x80, 0x1B,0x80, 0x36,0x00,
-};
-// [64] hedgehog 🦔
-static const uint8_t emoji_sm_hedgehog[] PROGMEM = {
-  0x15,0x00, 0x2A,0x80, 0x55,0x40, 0xFF,0xC0, 0xDB,0x40, 0xFF,0x80, 0x7F,0x80, 0x3F,0x00, 0x24,0x00, 0x00,0x00,
-};

 static const uint8_t* const EMOJI_SPRITES_SM[] PROGMEM = {
  emoji_sm_joy, emoji_sm_thumbsup, emoji_sm_frown,
@@ -531,11 +374,6 @@ static const uint8_t* const EMOJI_SPRITES_SM[] PROGMEM = {
  emoji_sm_kangaroo, emoji_sm_feather, emoji_sm_bright, emoji_sm_part_alt, emoji_sm_motorboat,
  emoji_sm_domino, emoji_sm_satellite, emoji_sm_customs, emoji_sm_cowboy, emoji_sm_wheel,
  emoji_sm_koala, emoji_sm_control_knobs, emoji_sm_peach, emoji_sm_racing_car,
-  emoji_sm_mouse, emoji_sm_mushroom, emoji_sm_biohazard, emoji_sm_panda,
-  emoji_sm_anger, emoji_sm_dragon_face, emoji_sm_pager, emoji_sm_bee,
-  emoji_sm_bulb, emoji_sm_cat, emoji_sm_fleur, emoji_sm_moon,
-  emoji_sm_coffee, emoji_sm_tooth, emoji_sm_pretzel, emoji_sm_abacus,
-  emoji_sm_moai, emoji_sm_tipping, emoji_sm_hedgehog,
 };

 // ---- Codepoint lookup for UTF-8 conversion ----
@@ -588,37 +426,10 @@ static const EmojiCodepoint EMOJI_CODEPOINTS[EMOJI_COUNT] = {
  { 0x1F39B, 0x0000, 0xAB }, // control_knobs
  { 0x1F351, 0x0000, 0xAC }, // peach
  { 0x1F3CE, 0x0000, 0xAD }, // racing_car
-  { 0x1F42D, 0x0000, 0xAE }, // mouse
-  { 0x1F344, 0x0000, 0xAF }, // mushroom
-  { 0x2623,  0x0000, 0xB0 }, // biohazard
-  { 0x1F43C, 0x0000, 0xB1 }, // panda
-  { 0x1F4A2, 0x0000, 0xB2 }, // anger
-  { 0x1F432, 0x0000, 0xB3 }, // dragon_face
-  { 0x1F4DF, 0x0000, 0xB4 }, // pager
-  { 0x1F41D, 0x0000, 0xB5 }, // bee
-  { 0x1F4A1, 0x0000, 0xB6 }, // bulb
-  { 0x1F431, 0x0000, 0xB7 }, // cat
-  { 0x269C,  0x0000, 0xB8 }, // fleur
-  { 0x1F314, 0x0000, 0xB9 }, // moon
-  { 0x2615,  0x0000, 0xBA }, // coffee
-  { 0x1F9B7, 0x0000, 0xBB }, // tooth
-  { 0x1F968, 0x0000, 0xBC }, // pretzel
-  { 0x1F9EE, 0x0000, 0xBD }, // abacus
-  { 0x1F5FF, 0x0000, 0xBE }, // moai
-  { 0x1F481, 0x0000, 0xBF }, // tipping
-  { 0x1F994, 0x0000, 0xC0 }, // hedgehog
 };

 // ---- Helper functions ----

-// Alias table: extra codepoints that map to existing emoji escape bytes.
-// Used for variant codepoints (e.g. MWD node identifier 🂎 U+1F08E -> domino sprite)
-struct EmojiAlias { uint32_t cp; uint8_t escape; };
-#define EMOJI_ALIAS_COUNT 1
-static const EmojiAlias EMOJI_ALIASES[EMOJI_ALIAS_COUNT] = {
-  { 0x1F08E, 0xA5 }, // domino tile (MWD node signifier) -> domino sprite
-};
-
 static uint32_t emojiDecodeUtf8(const uint8_t* s, int remaining, int* bytes_consumed) {
  uint8_t b0 = s[0];
  if (b0 < 0x80) { *bytes_consumed = 1; return b0; }
@@ -672,18 +483,6 @@ static void emojiSanitize(const char* src, char* dst, int dstLen) {
          found = true; break;
        }
      }
-      if (!found) {
-        // Check alias table for variant codepoints
-        for (int a = 0; a < EMOJI_ALIAS_COUNT; a++) {
-          if (EMOJI_ALIASES[a].cp == cp) {
-            dst[di++] = EMOJI_ALIASES[a].escape;
-            si += consumed;
-            // Skip trailing variation selector U+FE0F
-            if (si + 2 < srcLen && s[si] == 0xEF && s[si+1] == 0xB8 && s[si+2] == 0x8F) si += 3;
-            found = true; break;
-          }
-        }
-      }
      if (!found) si += consumed;  // Skip unknown multi-byte chars
    } else {
      dst[di++] = (char)b;
--- a/examples/companion_radio/ui-new/M4BMetadata.h
+++ b/examples/companion_radio/ui-new/M4BMetadata.h
@@ -1,651 +0,0 @@
-#pragma once
-
-// =============================================================================
-// M4BMetadata.h - Lightweight MP4/M4B atom parser for metadata extraction
-//
-// Walks the MP4 atom (box) tree to extract:
-//   - Title     (moov/udta/meta/ilst/©nam)
-//   - Author    (moov/udta/meta/ilst/©ART)
-//   - Cover art (moov/udta/meta/ilst/covr) - JPEG offset+size within file
-//   - Duration  (moov/mvhd timescale + duration)
-//   - Chapter markers (moov/udta/chpl) - Nero-style chapter list
-//
-// Designed for embedded use: no dynamic allocation, reads directly from SD
-// via Arduino File API, uses a small stack buffer for atom headers.
-//
-// Usage:
-//   M4BMetadata meta;
-//   File f = SD.open("/audiobooks/mybook.m4b");
-//   if (meta.parse(f)) {
-//     Serial.printf("Title: %s\n", meta.title);
-//     Serial.printf("Author: %s\n", meta.author);
-//     if (meta.hasCoverArt) {
-//       // JPEG data is at meta.coverOffset, meta.coverSize bytes
-//     }
-//   }
-//   f.close();
-// =============================================================================
-
-#include <SD.h>
-
-// Maximum metadata string lengths (including null terminator)
-#define M4B_MAX_TITLE    128
-#define M4B_MAX_AUTHOR   64
-#define M4B_MAX_CHAPTERS 100
-
-struct M4BChapter {
-  uint32_t startMs;    // Chapter start time in milliseconds
-  char     name[48];   // Chapter title (truncated to fit)
-};
-
-class M4BMetadata {
-public:
-  // Extracted metadata
-  char     title[M4B_MAX_TITLE];
-  char     author[M4B_MAX_AUTHOR];
-  bool     hasCoverArt;
-  uint32_t coverOffset;   // Byte offset of JPEG/PNG data within file
-  uint32_t coverSize;     // Size of cover image data in bytes
-  uint8_t  coverFormat;   // 13=JPEG, 14=PNG (from MP4 well-known type)
-  uint32_t durationMs;    // Total duration in milliseconds
-  uint32_t sampleRate;    // Audio sample rate (from audio stsd)
-  uint32_t bitrate;       // Approximate bitrate in bps
-
-  // Chapter data
-  M4BChapter chapters[M4B_MAX_CHAPTERS];
-  int        chapterCount;
-
-  M4BMetadata() { clear(); }
-
-  void clear() {
-    title[0] = '\0';
-    author[0] = '\0';
-    hasCoverArt = false;
-    coverOffset = 0;
-    coverSize = 0;
-    coverFormat = 0;
-    durationMs = 0;
-    sampleRate = 44100;
-    bitrate = 0;
-    chapterCount = 0;
-  }
-
-  // Parse an open file. Returns true if at least title or duration was found.
-  // File position is NOT preserved — caller should seek as needed afterward.
-  bool parse(File& file) {
-    clear();
-    if (!file || file.size() < 8) return false;
-
-    _fileSize = file.size();
-
-    // Walk top-level atoms looking for 'moov'
-    uint32_t pos = 0;
-    while (pos < _fileSize) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      if (hdr.type == ATOM_MOOV) {
-        parseMoov(file, hdr.dataOffset, hdr.dataOffset + hdr.dataSize);
-        break;  // moov found and parsed, we're done
-      }
-
-      // Skip to next top-level atom
-      pos += hdr.size;
-      if (hdr.size == 0) break;  // size=0 means "extends to EOF"
-    }
-
-    return (title[0] != '\0' || durationMs > 0);
-  }
-
-  // Get chapter index for a given playback position (milliseconds).
-  // Returns -1 if no chapters or position is before first chapter.
-  int getChapterForPosition(uint32_t positionMs) const {
-    if (chapterCount == 0) return -1;
-    int ch = 0;
-    for (int i = 1; i < chapterCount; i++) {
-      if (chapters[i].startMs > positionMs) break;
-      ch = i;
-    }
-    return ch;
-  }
-
-  // Get the start position of the next chapter after the given position.
-  // Returns 0 if no next chapter.
-  uint32_t getNextChapterMs(uint32_t positionMs) const {
-    for (int i = 0; i < chapterCount; i++) {
-      if (chapters[i].startMs > positionMs) return chapters[i].startMs;
-    }
-    return 0;
-  }
-
-  // Get the start position of the current or previous chapter.
-  uint32_t getPrevChapterMs(uint32_t positionMs) const {
-    uint32_t prev = 0;
-    for (int i = 0; i < chapterCount; i++) {
-      if (chapters[i].startMs >= positionMs) break;
-      prev = chapters[i].startMs;
-    }
-    return prev;
-  }
-
-private:
-  uint32_t _fileSize;
-
-  // MP4 atom type codes (big-endian FourCC)
-  static constexpr uint32_t ATOM_MOOV = 0x6D6F6F76;  // 'moov'
-  static constexpr uint32_t ATOM_MVHD = 0x6D766864;  // 'mvhd'
-  static constexpr uint32_t ATOM_UDTA = 0x75647461;  // 'udta'
-  static constexpr uint32_t ATOM_META = 0x6D657461;  // 'meta'
-  static constexpr uint32_t ATOM_ILST = 0x696C7374;  // 'ilst'
-  static constexpr uint32_t ATOM_NAM  = 0xA96E616D;  // '©nam'
-  static constexpr uint32_t ATOM_ART  = 0xA9415254;  // '©ART'
-  static constexpr uint32_t ATOM_COVR = 0x636F7672;  // 'covr'
-  static constexpr uint32_t ATOM_DATA = 0x64617461;  // 'data'
-  static constexpr uint32_t ATOM_CHPL = 0x6368706C;  // 'chpl' (Nero chapters)
-  static constexpr uint32_t ATOM_TRAK = 0x7472616B;  // 'trak'
-  static constexpr uint32_t ATOM_MDIA = 0x6D646961;  // 'mdia'
-  static constexpr uint32_t ATOM_MDHD = 0x6D646864;  // 'mdhd'
-  static constexpr uint32_t ATOM_HDLR = 0x68646C72;  // 'hdlr'
-
-  struct AtomHeader {
-    uint32_t type;
-    uint64_t size;        // Total atom size including header
-    uint32_t dataOffset;  // File offset where data begins (after header)
-    uint64_t dataSize;    // size - header_length
-  };
-
-  // Read a 32-bit big-endian value from file at current position
-  static uint32_t readU32BE(File& file) {
-    uint8_t buf[4];
-    file.read(buf, 4);
-    return ((uint32_t)buf[0] << 24) | ((uint32_t)buf[1] << 16) |
-           ((uint32_t)buf[2] << 8)  | buf[3];
-  }
-
-  // Read a 64-bit big-endian value
-  static uint64_t readU64BE(File& file) {
-    uint32_t hi = readU32BE(file);
-    uint32_t lo = readU32BE(file);
-    return ((uint64_t)hi << 32) | lo;
-  }
-
-  // Read a 16-bit big-endian value
-  static uint16_t readU16BE(File& file) {
-    uint8_t buf[2];
-    file.read(buf, 2);
-    return ((uint16_t)buf[0] << 8) | buf[1];
-  }
-
-  // Read atom header at given file offset
-  bool readAtomHeader(File& file, uint32_t offset, AtomHeader& hdr) {
-    if (offset + 8 > _fileSize) return false;
-
-    file.seek(offset);
-    uint32_t size32 = readU32BE(file);
-    hdr.type = readU32BE(file);
-
-    if (size32 == 1) {
-      // 64-bit extended size
-      if (offset + 16 > _fileSize) return false;
-      hdr.size = readU64BE(file);
-      hdr.dataOffset = offset + 16;
-      hdr.dataSize = (hdr.size > 16) ? hdr.size - 16 : 0;
-    } else if (size32 == 0) {
-      // Atom extends to end of file
-      hdr.size = _fileSize - offset;
-      hdr.dataOffset = offset + 8;
-      hdr.dataSize = hdr.size - 8;
-    } else {
-      hdr.size = size32;
-      hdr.dataOffset = offset + 8;
-      hdr.dataSize = (size32 > 8) ? size32 - 8 : 0;
-    }
-
-    return true;
-  }
-
-  // Parse the moov container atom
-  void parseMoov(File& file, uint32_t start, uint32_t end) {
-    uint32_t pos = start;
-    while (pos < end) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      switch (hdr.type) {
-        case ATOM_MVHD:
-          parseMvhd(file, hdr.dataOffset, (uint32_t)hdr.dataSize);
-          break;
-        case ATOM_UDTA:
-          parseUdta(file, hdr.dataOffset, hdr.dataOffset + (uint32_t)hdr.dataSize);
-          break;
-        case ATOM_TRAK:
-          break;
-      }
-
-      pos += (uint32_t)hdr.size;
-    }
-  }
-
-  // Parse mvhd (movie header) for duration
-  void parseMvhd(File& file, uint32_t offset, uint32_t size) {
-    file.seek(offset);
-    uint8_t version = file.read();
-
-    if (version == 0) {
-      file.seek(offset + 4);   // skip version(1) + flags(3)
-      /* create_time */ readU32BE(file);
-      /* modify_time */ readU32BE(file);
-      uint32_t timescale = readU32BE(file);
-      uint32_t duration = readU32BE(file);
-      if (timescale > 0) {
-        durationMs = (uint32_t)((uint64_t)duration * 1000 / timescale);
-      }
-    } else if (version == 1) {
-      file.seek(offset + 4);
-      /* create_time */ readU64BE(file);
-      /* modify_time */ readU64BE(file);
-      uint32_t timescale = readU32BE(file);
-      uint64_t duration = readU64BE(file);
-      if (timescale > 0) {
-        durationMs = (uint32_t)(duration * 1000 / timescale);
-      }
-    }
-  }
-
-  // Parse udta container — contains meta and/or chpl
-  void parseUdta(File& file, uint32_t start, uint32_t end) {
-    uint32_t pos = start;
-    while (pos < end) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      if (hdr.type == ATOM_META) {
-        parseMeta(file, hdr.dataOffset + 4,
-                  hdr.dataOffset + (uint32_t)hdr.dataSize);
-      } else if (hdr.type == ATOM_CHPL) {
-        parseChpl(file, hdr.dataOffset, (uint32_t)hdr.dataSize);
-      }
-
-      pos += (uint32_t)hdr.size;
-    }
-  }
-
-  // Parse meta container — contains hdlr + ilst
-  void parseMeta(File& file, uint32_t start, uint32_t end) {
-    uint32_t pos = start;
-    while (pos < end) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      if (hdr.type == ATOM_ILST) {
-        parseIlst(file, hdr.dataOffset, hdr.dataOffset + (uint32_t)hdr.dataSize);
-      }
-
-      pos += (uint32_t)hdr.size;
-    }
-  }
-
-  // Parse ilst (iTunes metadata list) — contains ©nam, ©ART, covr etc.
-  void parseIlst(File& file, uint32_t start, uint32_t end) {
-    uint32_t pos = start;
-    while (pos < end) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      switch (hdr.type) {
-        case ATOM_NAM:
-          extractTextData(file, hdr.dataOffset,
-                          hdr.dataOffset + (uint32_t)hdr.dataSize,
-                          title, M4B_MAX_TITLE);
-          break;
-        case ATOM_ART:
-          extractTextData(file, hdr.dataOffset,
-                          hdr.dataOffset + (uint32_t)hdr.dataSize,
-                          author, M4B_MAX_AUTHOR);
-          break;
-        case ATOM_COVR:
-          extractCoverData(file, hdr.dataOffset,
-                           hdr.dataOffset + (uint32_t)hdr.dataSize);
-          break;
-      }
-
-      pos += (uint32_t)hdr.size;
-    }
-  }
-
-  // Extract text from a 'data' sub-atom within an ilst entry.
-  void extractTextData(File& file, uint32_t start, uint32_t end,
-                       char* dest, int maxLen) {
-    uint32_t pos = start;
-    while (pos < end) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      if (hdr.type == ATOM_DATA && hdr.dataSize > 8) {
-        uint32_t textOffset = hdr.dataOffset + 8;
-        uint32_t textLen = (uint32_t)hdr.dataSize - 8;
-        if (textLen > (uint32_t)(maxLen - 1)) textLen = maxLen - 1;
-
-        file.seek(textOffset);
-        file.read((uint8_t*)dest, textLen);
-        dest[textLen] = '\0';
-        return;
-      }
-
-      pos += (uint32_t)hdr.size;
-    }
-  }
-
-  // Extract cover art location from 'data' sub-atom within covr.
-  void extractCoverData(File& file, uint32_t start, uint32_t end) {
-    uint32_t pos = start;
-    while (pos < end) {
-      AtomHeader hdr;
-      if (!readAtomHeader(file, pos, hdr)) break;
-      if (hdr.size < 8) break;
-
-      if (hdr.type == ATOM_DATA && hdr.dataSize > 8) {
-        file.seek(hdr.dataOffset);
-        uint32_t typeIndicator = readU32BE(file);
-        uint8_t wellKnownType = typeIndicator & 0xFF;
-
-        coverOffset = hdr.dataOffset + 8;
-        coverSize = (uint32_t)hdr.dataSize - 8;
-        coverFormat = wellKnownType;  // 13=JPEG, 14=PNG
-        hasCoverArt = (coverSize > 0);
-
-        Serial.printf("M4B: Cover art found - %s, %u bytes at offset %u\n",
-                      wellKnownType == 13 ? "JPEG" :
-                      wellKnownType == 14 ? "PNG" : "unknown",
-                      coverSize, coverOffset);
-        return;
-      }
-
-      pos += (uint32_t)hdr.size;
-    }
-  }
-
-  // =====================================================================
-  // ID3v2 Parser for MP3 files
-  // =====================================================================
-public:
-  // Parse ID3v2 tags from an MP3 file. Extracts title (TIT2), artist
-  // (TPE1), and cover art (APIC). Fills the same metadata fields as
-  // the M4B parser so decodeCoverArt() works unchanged.
-  bool parseID3v2(File& file) {
-    clear();
-    if (!file || file.size() < 10) return false;
-
-    file.seek(0);
-    uint8_t hdr[10];
-    if (file.read(hdr, 10) != 10) return false;
-
-    // Verify "ID3" magic
-    if (hdr[0] != 'I' || hdr[1] != 'D' || hdr[2] != '3') {
-      Serial.println("ID3: No ID3v2 header found");
-      return false;
-    }
-
-    uint8_t versionMajor = hdr[3];  // 3 = ID3v2.3, 4 = ID3v2.4
-    bool v24 = (versionMajor == 4);
-    bool hasExtHeader = (hdr[5] & 0x40) != 0;
-
-    // Tag size is syncsafe integer (4 x 7-bit bytes)
-    uint32_t tagSize = ((uint32_t)(hdr[6] & 0x7F) << 21) |
-                       ((uint32_t)(hdr[7] & 0x7F) << 14) |
-                       ((uint32_t)(hdr[8] & 0x7F) << 7)  |
-                       (hdr[9] & 0x7F);
-
-    uint32_t tagEnd = 10 + tagSize;
-    if (tagEnd > file.size()) tagEnd = file.size();
-
-    Serial.printf("ID3: v2.%d, %u bytes\n", versionMajor, tagSize);
-
-    // Skip extended header if present
-    uint32_t pos = 10;
-    if (hasExtHeader && pos + 4 < tagEnd) {
-      file.seek(pos);
-      uint32_t extSize;
-      if (v24) {
-        uint8_t eb[4];
-        file.read(eb, 4);
-        extSize = ((uint32_t)(eb[0] & 0x7F) << 21) |
-                  ((uint32_t)(eb[1] & 0x7F) << 14) |
-                  ((uint32_t)(eb[2] & 0x7F) << 7)  |
-                  (eb[3] & 0x7F);
-      } else {
-        extSize = readU32BE(file) + 4;
-      }
-      pos += extSize;
-    }
-
-    // Walk ID3v2 frames
-    bool foundTitle = false, foundArtist = false, foundCover = false;
-
-    while (pos + 10 < tagEnd) {
-      file.seek(pos);
-      uint8_t fhdr[10];
-      if (file.read(fhdr, 10) != 10) break;
-
-      if (fhdr[0] == 0) break;
-
-      char frameId[5] = { (char)fhdr[0], (char)fhdr[1],
-                          (char)fhdr[2], (char)fhdr[3], '\0' };
-
-      uint32_t frameSize;
-      if (v24) {
-        frameSize = ((uint32_t)(fhdr[4] & 0x7F) << 21) |
-                    ((uint32_t)(fhdr[5] & 0x7F) << 14) |
-                    ((uint32_t)(fhdr[6] & 0x7F) << 7)  |
-                    (fhdr[7] & 0x7F);
-      } else {
-        frameSize = ((uint32_t)fhdr[4] << 24) | ((uint32_t)fhdr[5] << 16) |
-                    ((uint32_t)fhdr[6] << 8)  | fhdr[7];
-      }
-
-      if (frameSize == 0 || pos + 10 + frameSize > tagEnd) break;
-
-      uint32_t dataStart = pos + 10;
-
-      // --- TIT2 (Title) ---
-      if (!foundTitle && strcmp(frameId, "TIT2") == 0 && frameSize > 1) {
-        id3ExtractText(file, dataStart, frameSize, title, M4B_MAX_TITLE);
-        foundTitle = (title[0] != '\0');
-      }
-      // --- TPE1 (Artist/Author) ---
-      if (!foundArtist && strcmp(frameId, "TPE1") == 0 && frameSize > 1) {
-        id3ExtractText(file, dataStart, frameSize, author, M4B_MAX_AUTHOR);
-        foundArtist = (author[0] != '\0');
-      }
-      // --- APIC (Attached Picture) ---
-      if (!foundCover && strcmp(frameId, "APIC") == 0 && frameSize > 20) {
-        id3ExtractAPIC(file, dataStart, frameSize);
-        foundCover = hasCoverArt;
-      }
-
-      pos = dataStart + frameSize;
-
-      // Early exit once we have everything
-      if (foundTitle && foundArtist && foundCover) break;
-    }
-
-    if (foundTitle) Serial.printf("ID3: Title: %s\n", title);
-    if (foundArtist) Serial.printf("ID3: Author: %s\n", author);
-    return (foundTitle || foundCover);
-  }
-
-private:
-  // Extract text from a TIT2/TPE1 frame.
-  // Format: encoding(1) + text data
-  void id3ExtractText(File& file, uint32_t offset, uint32_t size,
-                      char* dest, int maxLen) {
-    file.seek(offset);
-    uint8_t encoding = file.read();
-    uint32_t textLen = size - 1;
-    if (textLen == 0) return;
-
-    if (encoding == 0 || encoding == 3) {
-      // ISO-8859-1 or UTF-8 — read directly
-      uint32_t readLen = (textLen < (uint32_t)(maxLen - 1))
-                         ? textLen : (uint32_t)(maxLen - 1);
-      file.read((uint8_t*)dest, readLen);
-      dest[readLen] = '\0';
-      // Strip trailing nulls
-      while (readLen > 0 && dest[readLen - 1] == '\0') readLen--;
-      dest[readLen] = '\0';
-    }
-    else if (encoding == 1 || encoding == 2) {
-      // UTF-16 (with or without BOM) — crude ASCII extraction
-      // Static buffer to avoid stack overflow (loopTask has limited stack)
-      static uint8_t u16buf[128];
-      uint32_t readLen = (textLen > sizeof(u16buf)) ? sizeof(u16buf) : textLen;
-      file.read(u16buf, readLen);
-
-      uint32_t srcStart = 0;
-      // Skip BOM if present
-      if (readLen >= 2 && ((u16buf[0] == 0xFF && u16buf[1] == 0xFE) ||
-                           (u16buf[0] == 0xFE && u16buf[1] == 0xFF))) {
-        srcStart = 2;
-      }
-      bool littleEndian = (srcStart >= 2 && u16buf[0] == 0xFF);
-
-      int dstIdx = 0;
-      for (uint32_t i = srcStart; i + 1 < readLen && dstIdx < maxLen - 1; i += 2) {
-        uint8_t lo = littleEndian ? u16buf[i] : u16buf[i + 1];
-        uint8_t hi = littleEndian ? u16buf[i + 1] : u16buf[i];
-        if (lo == 0 && hi == 0) break;  // null terminator
-        if (hi == 0 && lo >= 0x20 && lo < 0x7F) {
-          dest[dstIdx++] = (char)lo;
-        } else {
-          dest[dstIdx++] = '?';
-        }
-      }
-      dest[dstIdx] = '\0';
-    }
-  }
-
-  // Extract APIC (cover art) frame.
-  // Format: encoding(1) + MIME(null-term) + picType(1) + desc(null-term) + imageData
-  void id3ExtractAPIC(File& file, uint32_t offset, uint32_t frameSize) {
-    file.seek(offset);
-    uint8_t encoding = file.read();
-
-    // Read MIME type (null-terminated ASCII)
-    char mime[32] = {0};
-    int mimeLen = 0;
-    while (mimeLen < 31) {
-      int b = file.read();
-      if (b < 0) return;   // Read error
-      if (b == 0) break;   // Null terminator = end of MIME string
-      mime[mimeLen++] = (char)b;
-    }
-    mime[mimeLen] = '\0';
-
-    // Picture type (1 byte)
-    uint8_t picType = file.read();
-    (void)picType;
-
-    // Skip description (null-terminated, encoding-dependent)
-    if (encoding == 0 || encoding == 3) {
-      // Single-byte null terminator
-      while (true) {
-        int b = file.read();
-        if (b < 0) return;   // Read error
-        if (b == 0) break;   // Null terminator
-      }
-    } else {
-      // UTF-16: double-null terminator
-      while (true) {
-        int b1 = file.read();
-        int b2 = file.read();
-        if (b1 < 0 || b2 < 0) return;  // Read error
-        if (b1 == 0 && b2 == 0) break;  // Double-null terminator
-      }
-    }
-
-    // Everything from here to end of frame is image data
-    uint32_t imgOffset = file.position();
-    uint32_t imgEnd = offset + frameSize;
-    if (imgOffset >= imgEnd) return;
-
-    uint32_t imgSize = imgEnd - imgOffset;
-
-    // Determine format from MIME type
-    bool isJpeg = (strstr(mime, "jpeg") || strstr(mime, "jpg"));
-    bool isPng  = (strstr(mime, "png") != nullptr);
-
-    // Also detect by magic bytes if MIME is generic
-    if (!isJpeg && !isPng && imgSize > 4) {
-      file.seek(imgOffset);
-      uint8_t magic[4];
-      file.read(magic, 4);
-      if (magic[0] == 0xFF && magic[1] == 0xD8) isJpeg = true;
-      else if (magic[0] == 0x89 && magic[1] == 'P' &&
-               magic[2] == 'N'  && magic[3] == 'G') isPng = true;
-    }
-
-    coverOffset = imgOffset;
-    coverSize = imgSize;
-    coverFormat = isJpeg ? 13 : (isPng ? 14 : 0);
-    hasCoverArt = (imgSize > 100 && (isJpeg || isPng));
-
-    if (hasCoverArt) {
-      Serial.printf("ID3: Cover %s, %u bytes\n",
-                    isJpeg ? "JPEG" : "PNG", imgSize);
-    }
-  }
-
-  // Parse Nero-style chapter list (chpl atom).
-  void parseChpl(File& file, uint32_t offset, uint32_t size) {
-    if (size < 9) return;
-
-    file.seek(offset);
-    uint8_t version = file.read();
-    file.read();  // flags byte 1
-    file.read();  // flags byte 2
-    file.read();  // flags byte 3
-
-    file.read();  // reserved
-
-    uint32_t count;
-    if (version == 1) {
-      count = readU32BE(file);
-    } else {
-      count = file.read();
-    }
-
-    if (count > M4B_MAX_CHAPTERS) count = M4B_MAX_CHAPTERS;
-
-    chapterCount = 0;
-    for (uint32_t i = 0; i < count; i++) {
-      if (!file.available()) break;
-
-      uint64_t timestamp = readU64BE(file);
-      uint32_t startMs = (uint32_t)(timestamp / 10000);  // 100ns -> ms
-
-      uint8_t nameLen = file.read();
-      if (nameLen == 0 || !file.available()) break;
-
-      M4BChapter& ch = chapters[chapterCount];
-      ch.startMs = startMs;
-
-      uint8_t readLen = (nameLen < sizeof(ch.name) - 1) ? nameLen : sizeof(ch.name) - 1;
-      file.read((uint8_t*)ch.name, readLen);
-      ch.name[readLen] = '\0';
-
-      if (nameLen > readLen) {
-        file.seek(file.position() + (nameLen - readLen));
-      }
-
-      chapterCount++;
-    }
-
-    Serial.printf("M4B: Found %d chapters\n", chapterCount);
-  }
-};
--- a/examples/companion_radio/ui-new/ModemManager.cpp
+++ b/examples/companion_radio/ui-new/ModemManager.cpp
--- a/examples/companion_radio/ui-new/ModemManager.h
+++ b/examples/companion_radio/ui-new/ModemManager.h
@@ -1,255 +0,0 @@
-#pragma once
-
-// =============================================================================
-// ModemManager - A7682E 4G Modem Driver for T-Deck Pro (V1.1 4G variant)
-//
-// Runs AT commands on a dedicated FreeRTOS task (Core 0, priority 1) to never
-// block the mesh radio loop.  Communicates with main loop via lock-free queues.
-//
-// Supports: SMS send/receive, voice call dial/answer/hangup/DTMF
-//
-// Guard: HAS_4G_MODEM (defined only for the 4G build environment)
-// =============================================================================
-
-#ifdef HAS_4G_MODEM
-
-#ifndef MODEM_MANAGER_H
-#define MODEM_MANAGER_H
-
-#include <Arduino.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-#include <freertos/queue.h>
-#include <freertos/semphr.h>
-#include "variant.h"
-#include "ApnDatabase.h"
-
-// ---------------------------------------------------------------------------
-// Modem pins (from variant.h, always defined for reference)
-//   MODEM_POWER_EN  41   Board 6609 enable
-//   MODEM_PWRKEY    40   Power key toggle
-//   MODEM_RST        9   Reset (shared with I2S BCLK on audio board)
-//   MODEM_RI         7   Ring indicator (shared with I2S DOUT on audio)
-//   MODEM_DTR        8   Data terminal ready (shared with I2S LRC on audio)
-//   MODEM_RX        10   UART RX (shared with PIN_PERF_POWERON)
-//   MODEM_TX        11   UART TX
-// ---------------------------------------------------------------------------
-
-// SMS field limits
-#define SMS_PHONE_LEN    20
-#define SMS_BODY_LEN    161   // 160 chars + null
-
-// Task configuration
-#define MODEM_TASK_PRIORITY   1       // Below mesh (default loop = priority 1 on core 1)
-#define MODEM_TASK_STACK_SIZE 6144    // Increased for call handling
-#define MODEM_TASK_CORE       0       // Run on core 0 (mesh runs on core 1)
-
-// Queue sizes
-#define MODEM_SEND_QUEUE_SIZE  4
-#define MODEM_RECV_QUEUE_SIZE  8
-#define MODEM_CALL_CMD_QUEUE_SIZE  4
-#define MODEM_CALL_EVT_QUEUE_SIZE  4
-
-// ---------------------------------------------------------------------------
-// Modem state machine
-// ---------------------------------------------------------------------------
-enum class ModemState {
-  OFF,
-  POWERING_ON,
-  INITIALIZING,
-  REGISTERING,
-  READY,
-  ERROR,
-  SENDING_SMS,
-  // Voice call states
-  DIALING,        // ATD sent, waiting for connect/carrier
-  RINGING_IN,     // Incoming call detected (RING URC)
-  IN_CALL         // Voice call active
-};
-
-// ---------------------------------------------------------------------------
-// SMS structures (unchanged)
-// ---------------------------------------------------------------------------
-
-// Outgoing SMS (queued from main loop to modem task)
-struct SMSOutgoing {
-  char phone[SMS_PHONE_LEN];
-  char body[SMS_BODY_LEN];
-};
-
-// Incoming SMS (queued from modem task to main loop)
-struct SMSIncoming {
-  char phone[SMS_PHONE_LEN];
-  char body[SMS_BODY_LEN];
-  uint32_t timestamp;   // epoch seconds (from modem RTC or millis-based)
-};
-
-// ---------------------------------------------------------------------------
-// Voice call structures
-// ---------------------------------------------------------------------------
-
-// Commands from main loop → modem task
-enum class CallCmd : uint8_t {
-  DIAL,           // Initiate outgoing call
-  ANSWER,         // Answer incoming call
-  HANGUP,         // End active call or reject incoming
-  DTMF,           // Send DTMF tone during call
-  SET_VOLUME      // Set speaker volume
-};
-
-struct CallCommand {
-  CallCmd cmd;
-  char phone[SMS_PHONE_LEN];   // Used by DIAL
-  char dtmf;                    // Used by DTMF (single digit: 0-9, *, #)
-  uint8_t volume;               // Used by SET_VOLUME (0-5)
-};
-
-// Events from modem task → main loop
-enum class CallEventType : uint8_t {
-  INCOMING,       // Incoming call ringing (+CLIP parsed)
-  CONNECTED,      // Call answered / outgoing connected
-  ENDED,          // Call ended (local hangup, remote hangup, or no carrier)
-  MISSED,         // Incoming call ended before answer
-  BUSY,           // Outgoing call got busy signal
-  NO_ANSWER,      // Outgoing call not answered
-  DIAL_FAILED     // ATD command failed
-};
-
-struct CallEvent {
-  CallEventType type;
-  char phone[SMS_PHONE_LEN];   // Caller/callee number (from +CLIP or dial)
-  uint32_t duration;            // Call duration in seconds (for ENDED)
-};
-
-// ---------------------------------------------------------------------------
-// ModemManager class
-// ---------------------------------------------------------------------------
-
-class ModemManager {
-public:
-  void begin();
-  void shutdown();
-
-  // --- SMS API (unchanged) ---
-  bool sendSMS(const char* phone, const char* body);
-  bool recvSMS(SMSIncoming& out);
-
-  // --- Voice Call API ---
-  bool dialCall(const char* phone);          // Queue outgoing call
-  bool answerCall();                          // Answer incoming call
-  bool hangupCall();                          // End active / reject incoming
-  bool sendDTMF(char digit);                  // Send DTMF during call
-  bool setCallVolume(uint8_t level);          // Set volume 0-5
-  bool pollCallEvent(CallEvent& out);         // Poll from main loop
-
-  // --- State queries (lock-free reads) ---
-  ModemState getState() const { return _state; }
-  int  getSignalBars() const;       // 0-5
-  int  getCSQ() const { return _csq; }
-  bool isReady() const { return _state == ModemState::READY; }
-  bool isInCall() const { return _state == ModemState::IN_CALL; }
-  bool isRinging() const { return _state == ModemState::RINGING_IN; }
-  bool isDialing() const { return _state == ModemState::DIALING; }
-  bool isCallActive() const {
-    return _state == ModemState::IN_CALL ||
-           _state == ModemState::DIALING ||
-           _state == ModemState::RINGING_IN;
-  }
-  const char* getOperator() const { return _operator; }
-  const char* getCallPhone() const { return _callPhone; }
-  uint32_t getCallStartTime() const { return _callStartTime; }
-
-  // --- Device info (populated during init) ---
-  const char* getIMEI() const { return _imei; }
-  const char* getIMSI() const { return _imsi; }
-  const char* getAPN() const { return _apn; }
-  const char* getAPNSource() const { return _apnSource; }  // "auto", "network", "user", "none"
-
-  // --- APN configuration ---
-  // Set APN manually (overrides auto-detection). Persists to SD.
-  void setAPN(const char* apn);
-  // Load user-configured APN from SD card. Returns true if found.
-  static bool loadAPNConfig(char* apnOut, int maxLen);
-  // Save user-configured APN to SD card.
-  static void saveAPNConfig(const char* apn);
-
-  // Pause/resume polling — used by web reader to avoid Core 0 contention
-  // during WiFi TLS handshakes.  While paused, the task skips AT commands
-  // (SMS poll, CSQ poll) but still drains URCs and handles call commands
-  // so incoming calls aren't missed.
-  void pausePolling()  { _paused = true; }
-  void resumePolling() { _paused = false; }
-  bool isPaused() const { return _paused; }
-
-  static const char* stateToString(ModemState s);
-
-  // Persistent enable/disable config (SD file /sms/modem.cfg)
-  static bool loadEnabledConfig();
-  static void saveEnabledConfig(bool enabled);
-
-private:
-  volatile ModemState _state = ModemState::OFF;
-  volatile int _csq = 99;    // 99 = unknown
-  volatile bool _paused = false;  // Suppresses AT polling when true
-  char _operator[24] = {0};
-
-  // Device identity (populated during Phase 2 init)
-  char _imei[20] = {0};      // IMEI from AT+GSN
-  char _imsi[20] = {0};      // IMSI from AT+CIMI (for APN lookup)
-  char _apn[64] = {0};       // Active APN
-  char _apnSource[8] = {0};  // "auto", "network", "user", "none"
-
-  // Call state (written by modem task, read by main loop)
-  char _callPhone[SMS_PHONE_LEN] = {0};  // Current call number
-  volatile uint32_t _callStartTime = 0;    // millis() when call connected
-
-  TaskHandle_t _taskHandle = nullptr;
-
-  // SMS queues
-  QueueHandle_t _sendQueue = nullptr;
-  QueueHandle_t _recvQueue = nullptr;
-
-  // Call queues
-  QueueHandle_t _callCmdQueue = nullptr;   // main loop → modem task
-  QueueHandle_t _callEvtQueue = nullptr;   // modem task → main loop
-
-  SemaphoreHandle_t _uartMutex = nullptr;
-
-  // URC line buffer (accumulated between AT commands)
-  static const int URC_BUF_SIZE = 256;
-  char _urcBuf[URC_BUF_SIZE];
-  int  _urcPos = 0;
-
-  // UART AT command helpers (called only from modem task)
-  bool modemPowerOn();
-  bool sendAT(const char* cmd, const char* expect, uint32_t timeout_ms = 2000);
-  bool waitResponse(const char* expect, uint32_t timeout_ms, char* buf = nullptr, size_t bufLen = 0);
-  void pollCSQ();
-  void pollIncomingSMS();
-  bool doSendSMS(const char* phone, const char* body);
-
-  // URC (unsolicited result code) handling
-  void drainURCs();                // Read available UART data, process complete lines
-  void processURCLine(const char* line);  // Handle a single URC line
-
-  // APN resolution (called from modem task during init)
-  void resolveAPN();              // Auto-detect APN from network/IMSI/user config
-
-  // Call control (called from modem task)
-  bool doDialCall(const char* phone);
-  bool doAnswerCall();
-  bool doHangup();
-  bool doSendDTMF(char digit);
-  bool doSetVolume(uint8_t level);
-  void queueCallEvent(CallEventType type, const char* phone = nullptr, uint32_t duration = 0);
-
-  // FreeRTOS task
-  static void taskEntry(void* param);
-  void taskLoop();
-};
-
-// Global singleton
-extern ModemManager modemManager;
-
-#endif // MODEM_MANAGER_H
-#endif // HAS_4G_MODEM
--- a/examples/companion_radio/ui-new/Repeateradminscreen.h
+++ b/examples/companion_radio/ui-new/Repeateradminscreen.h
--- a/examples/companion_radio/ui-new/SMSContacts.cpp
+++ b/examples/companion_radio/ui-new/SMSContacts.cpp
@@ -1,8 +0,0 @@
-#ifdef HAS_4G_MODEM
-
-#include "SMSContacts.h"
-
-// Global singleton
-SMSContactStore smsContacts;
-
-#endif // HAS_4G_MODEM
--- a/examples/companion_radio/ui-new/SMSContacts.h
+++ b/examples/companion_radio/ui-new/SMSContacts.h
@@ -1,176 +0,0 @@
-#pragma once
-
-// =============================================================================
-// SMSContacts - Phone-to-name lookup for SMS contacts (4G variant)
-//
-// Stores contacts in /sms/contacts.txt on SD card.
-// Format: one contact per line as "phone=Display Name"
-//
-// Completely separate from mesh ContactInfo / IdentityStore.
-//
-// Guard: HAS_4G_MODEM
-// =============================================================================
-
-#ifdef HAS_4G_MODEM
-
-#ifndef SMS_CONTACTS_H
-#define SMS_CONTACTS_H
-
-#include <Arduino.h>
-#include <SD.h>
-
-#define SMS_CONTACT_NAME_LEN   24
-#define SMS_CONTACT_MAX        30
-#define SMS_CONTACTS_FILE      "/sms/contacts.txt"
-
-struct SMSContact {
-  char phone[20];   // matches SMS_PHONE_LEN
-  char name[SMS_CONTACT_NAME_LEN];
-  bool valid;
-};
-
-class SMSContactStore {
-public:
-  void begin() {
-    _count = 0;
-    memset(_contacts, 0, sizeof(_contacts));
-    load();
-  }
-
-  // Look up a name by phone number. Returns nullptr if not found.
-  const char* lookup(const char* phone) const {
-    for (int i = 0; i < _count; i++) {
-      if (_contacts[i].valid && strcmp(_contacts[i].phone, phone) == 0) {
-        return _contacts[i].name;
-      }
-    }
-    return nullptr;
-  }
-
-  // Fill buf with display name if found, otherwise copy phone number.
-  // Returns true if a name was found.
-  bool displayName(const char* phone, char* buf, size_t bufLen) const {
-    const char* name = lookup(phone);
-    if (name && name[0]) {
-      strncpy(buf, name, bufLen - 1);
-      buf[bufLen - 1] = '\0';
-      return true;
-    }
-    strncpy(buf, phone, bufLen - 1);
-    buf[bufLen - 1] = '\0';
-    return false;
-  }
-
-  // Add or update a contact. Returns true on success.
-  bool set(const char* phone, const char* name) {
-    // Update existing
-    for (int i = 0; i < _count; i++) {
-      if (_contacts[i].valid && strcmp(_contacts[i].phone, phone) == 0) {
-        strncpy(_contacts[i].name, name, SMS_CONTACT_NAME_LEN - 1);
-        _contacts[i].name[SMS_CONTACT_NAME_LEN - 1] = '\0';
-        save();
-        return true;
-      }
-    }
-    // Add new
-    if (_count >= SMS_CONTACT_MAX) return false;
-    strncpy(_contacts[_count].phone, phone, sizeof(_contacts[_count].phone) - 1);
-    _contacts[_count].phone[sizeof(_contacts[_count].phone) - 1] = '\0';
-    strncpy(_contacts[_count].name, name, SMS_CONTACT_NAME_LEN - 1);
-    _contacts[_count].name[SMS_CONTACT_NAME_LEN - 1] = '\0';
-    _contacts[_count].valid = true;
-    _count++;
-    save();
-    return true;
-  }
-
-  // Remove a contact by phone number
-  bool remove(const char* phone) {
-    for (int i = 0; i < _count; i++) {
-      if (_contacts[i].valid && strcmp(_contacts[i].phone, phone) == 0) {
-        for (int j = i; j < _count - 1; j++) {
-          _contacts[j] = _contacts[j + 1];
-        }
-        _count--;
-        memset(&_contacts[_count], 0, sizeof(SMSContact));
-        save();
-        return true;
-      }
-    }
-    return false;
-  }
-
-  // Accessors for list browsing
-  int count() const { return _count; }
-  const SMSContact& get(int index) const { return _contacts[index]; }
-
-  // Check if a contact exists
-  bool exists(const char* phone) const { return lookup(phone) != nullptr; }
-
-private:
-  SMSContact _contacts[SMS_CONTACT_MAX];
-  int _count = 0;
-
-  void load() {
-    File f = SD.open(SMS_CONTACTS_FILE, FILE_READ);
-    if (!f) {
-      Serial.println("[SMSContacts] No contacts file, starting fresh");
-      return;
-    }
-
-    char line[64];
-    while (f.available() && _count < SMS_CONTACT_MAX) {
-      int pos = 0;
-      while (f.available() && pos < (int)sizeof(line) - 1) {
-        char c = f.read();
-        if (c == '\n' || c == '\r') break;
-        line[pos++] = c;
-      }
-      line[pos] = '\0';
-      if (pos == 0) continue;
-      // Consume trailing CR/LF
-      while (f.available()) {
-        int pk = f.peek();
-        if (pk == '\n' || pk == '\r') { f.read(); continue; }
-        break;
-      }
-
-      // Parse "phone=name"
-      char* eq = strchr(line, '=');
-      if (!eq) continue;
-      *eq = '\0';
-      const char* phone = line;
-      const char* name = eq + 1;
-      if (strlen(phone) == 0 || strlen(name) == 0) continue;
-
-      strncpy(_contacts[_count].phone, phone, sizeof(_contacts[_count].phone) - 1);
-      strncpy(_contacts[_count].name, name, SMS_CONTACT_NAME_LEN - 1);
-      _contacts[_count].valid = true;
-      _count++;
-    }
-    f.close();
-    Serial.printf("[SMSContacts] Loaded %d contacts\n", _count);
-  }
-
-  void save() {
-    if (!SD.exists("/sms")) SD.mkdir("/sms");
-    File f = SD.open(SMS_CONTACTS_FILE, FILE_WRITE);
-    if (!f) {
-      Serial.println("[SMSContacts] Failed to write contacts file");
-      return;
-    }
-    for (int i = 0; i < _count; i++) {
-      if (!_contacts[i].valid) continue;
-      f.print(_contacts[i].phone);
-      f.print('=');
-      f.println(_contacts[i].name);
-    }
-    f.close();
-  }
-};
-
-// Global singleton
-extern SMSContactStore smsContacts;
-
-#endif // SMS_CONTACTS_H
-#endif // HAS_4G_MODEM
--- a/examples/companion_radio/ui-new/SMSScreen.h
+++ b/examples/companion_radio/ui-new/SMSScreen.h
--- a/examples/companion_radio/ui-new/SMSStore.cpp
+++ b/examples/companion_radio/ui-new/SMSStore.cpp
@@ -1,196 +0,0 @@
-#ifdef HAS_4G_MODEM
-
-#include "SMSStore.h"
-#include <Mesh.h>   // For MESH_DEBUG_PRINTLN
-#include "target.h" // For SDCARD_CS macro
-
-// Global singleton
-SMSStore smsStore;
-
-void SMSStore::begin() {
-  // Ensure SMS directory exists
-  if (!SD.exists(SMS_DIR)) {
-    SD.mkdir(SMS_DIR);
-    MESH_DEBUG_PRINTLN("[SMSStore] created %s", SMS_DIR);
-  }
-  _ready = true;
-  MESH_DEBUG_PRINTLN("[SMSStore] ready");
-}
-
-void SMSStore::phoneToFilename(const char* phone, char* out, size_t outLen) {
-  // Convert phone number to safe filename: strip non-alphanumeric, prefix with dir
-  // e.g. "+1234567890" -> "/sms/p1234567890.sms"
-  char safe[SMS_PHONE_LEN];
-  int j = 0;
-  for (int i = 0; phone[i] && j < SMS_PHONE_LEN - 1; i++) {
-    char c = phone[i];
-    if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
-      safe[j++] = c;
-    }
-  }
-  safe[j] = '\0';
-  snprintf(out, outLen, "%s/p%s.sms", SMS_DIR, safe);
-}
-
-bool SMSStore::saveMessage(const char* phone, const char* body, bool isSent, uint32_t timestamp) {
-  if (!_ready) return false;
-
-  char filepath[64];
-  phoneToFilename(phone, filepath, sizeof(filepath));
-
-  // Build record
-  SMSRecord rec;
-  memset(&rec, 0, sizeof(rec));
-  rec.timestamp = timestamp;
-  rec.isSent = isSent ? 1 : 0;
-  rec.bodyLen = strlen(body);
-  if (rec.bodyLen >= SMS_BODY_LEN) rec.bodyLen = SMS_BODY_LEN - 1;
-  strncpy(rec.phone, phone, SMS_PHONE_LEN - 1);
-  strncpy(rec.body, body, SMS_BODY_LEN - 1);
-
-  // Append to file
-  File f = SD.open(filepath, FILE_APPEND);
-  if (!f) {
-    // Try creating
-    f = SD.open(filepath, FILE_WRITE);
-    if (!f) {
-      MESH_DEBUG_PRINTLN("[SMSStore] can't open %s", filepath);
-      return false;
-    }
-  }
-
-  size_t written = f.write((uint8_t*)&rec, sizeof(rec));
-  f.close();
-
-  // Release SD CS
-  digitalWrite(SDCARD_CS, HIGH);
-
-  return written == sizeof(rec);
-}
-
-int SMSStore::loadConversations(SMSConversation* out, int maxCount) {
-  if (!_ready) return 0;
-
-  File dir = SD.open(SMS_DIR);
-  if (!dir || !dir.isDirectory()) return 0;
-
-  int count = 0;
-  File entry;
-  while ((entry = dir.openNextFile()) && count < maxCount) {
-    const char* name = entry.name();
-    // Only process .sms files
-    if (!strstr(name, ".sms")) { entry.close(); continue; }
-
-    size_t fileSize = entry.size();
-    if (fileSize < sizeof(SMSRecord)) { entry.close(); continue; }
-
-    int numRecords = fileSize / sizeof(SMSRecord);
-
-    // Read the last record for preview
-    SMSRecord lastRec;
-    entry.seek(fileSize - sizeof(SMSRecord));
-    if (entry.read((uint8_t*)&lastRec, sizeof(SMSRecord)) != sizeof(SMSRecord)) {
-      entry.close();
-      continue;
-    }
-
-    SMSConversation& conv = out[count];
-    memset(&conv, 0, sizeof(SMSConversation));
-    strncpy(conv.phone, lastRec.phone, SMS_PHONE_LEN - 1);
-    strncpy(conv.preview, lastRec.body, 39);
-    conv.preview[39] = '\0';
-    conv.lastTimestamp = lastRec.timestamp;
-    conv.messageCount = numRecords;
-    conv.unreadCount = 0;  // TODO: track read state
-    conv.valid = true;
-
-    count++;
-    entry.close();
-  }
-  dir.close();
-
-  // Release SD CS
-  digitalWrite(SDCARD_CS, HIGH);
-
-  // Sort by most recent (simple bubble sort, small N)
-  for (int i = 0; i < count - 1; i++) {
-    for (int j = 0; j < count - 1 - i; j++) {
-      if (out[j].lastTimestamp < out[j + 1].lastTimestamp) {
-        SMSConversation tmp = out[j];
-        out[j] = out[j + 1];
-        out[j + 1] = tmp;
-      }
-    }
-  }
-
-  return count;
-}
-
-int SMSStore::loadMessages(const char* phone, SMSMessage* out, int maxCount) {
-  if (!_ready) return 0;
-
-  char filepath[64];
-  phoneToFilename(phone, filepath, sizeof(filepath));
-
-  File f = SD.open(filepath, FILE_READ);
-  if (!f) return 0;
-
-  size_t fileSize = f.size();
-  int numRecords = fileSize / sizeof(SMSRecord);
-
-  // Load from end of file (most recent N messages), in chronological order
-  int startIdx = numRecords > maxCount ? numRecords - maxCount : 0;
-
-  // Read chronologically (oldest first) for chat-style display
-  SMSRecord rec;
-  int outIdx = 0;
-  for (int i = startIdx; i < numRecords && outIdx < maxCount; i++) {
-    f.seek(i * sizeof(SMSRecord));
-    if (f.read((uint8_t*)&rec, sizeof(SMSRecord)) != sizeof(SMSRecord)) continue;
-
-    out[outIdx].timestamp = rec.timestamp;
-    out[outIdx].isSent = rec.isSent != 0;
-    out[outIdx].valid = true;
-    strncpy(out[outIdx].phone, rec.phone, SMS_PHONE_LEN - 1);
-    strncpy(out[outIdx].body, rec.body, SMS_BODY_LEN - 1);
-    outIdx++;
-  }
-
-  f.close();
-
-  digitalWrite(SDCARD_CS, HIGH);
-
-  return outIdx;
-}
-
-bool SMSStore::deleteConversation(const char* phone) {
-  if (!_ready) return false;
-
-  char filepath[64];
-  phoneToFilename(phone, filepath, sizeof(filepath));
-
-  bool ok = SD.remove(filepath);
-
-  digitalWrite(SDCARD_CS, HIGH);
-
-  return ok;
-}
-
-int SMSStore::getMessageCount(const char* phone) {
-  if (!_ready) return 0;
-
-  char filepath[64];
-  phoneToFilename(phone, filepath, sizeof(filepath));
-
-  File f = SD.open(filepath, FILE_READ);
-  if (!f) return 0;
-
-  int count = f.size() / sizeof(SMSRecord);
-  f.close();
-
-  digitalWrite(SDCARD_CS, HIGH);
-
-  return count;
-}
-
-#endif // HAS_4G_MODEM
--- a/examples/companion_radio/ui-new/SMSStore.h
+++ b/examples/companion_radio/ui-new/SMSStore.h
@@ -1,87 +0,0 @@
-#pragma once
-
-// =============================================================================
-// SMSStore - SD card backed SMS message storage
-//
-// Stores sent and received messages in /sms/ on the SD card.
-// Each conversation is a separate file named by phone number (sanitised).
-// Messages are appended as fixed-size records for simple random access.
-//
-// Guard: HAS_4G_MODEM
-// =============================================================================
-
-#ifdef HAS_4G_MODEM
-
-#ifndef SMS_STORE_H
-#define SMS_STORE_H
-
-#include <Arduino.h>
-#include <SD.h>
-
-#define SMS_PHONE_LEN    20
-#define SMS_BODY_LEN    161
-#define SMS_MAX_CONVERSATIONS 20
-#define SMS_DIR          "/sms"
-
-// Fixed-size on-disk record (256 bytes, easy alignment)
-struct SMSRecord {
-  uint32_t timestamp;           // epoch seconds
-  uint8_t  isSent;              // 1=sent, 0=received
-  uint8_t  reserved[2];
-  uint8_t  bodyLen;             // actual length of body
-  char     phone[SMS_PHONE_LEN]; // 20
-  char     body[SMS_BODY_LEN];   // 161
-  uint8_t  padding[256 - 4 - 3 - 1 - SMS_PHONE_LEN - SMS_BODY_LEN];
-};
-
-// In-memory message for UI
-struct SMSMessage {
-  uint32_t timestamp;
-  bool     isSent;
-  bool     valid;
-  char     phone[SMS_PHONE_LEN];
-  char     body[SMS_BODY_LEN];
-};
-
-// Conversation summary for inbox view
-struct SMSConversation {
-  char     phone[SMS_PHONE_LEN];
-  char     preview[40];         // last message preview
-  uint32_t lastTimestamp;
-  int      messageCount;
-  int      unreadCount;
-  bool     valid;
-};
-
-class SMSStore {
-public:
-  void begin();
-  bool isReady() const { return _ready; }
-
-  // Save a message (sent or received)
-  bool saveMessage(const char* phone, const char* body, bool isSent, uint32_t timestamp);
-
-  // Load conversation list (sorted by most recent)
-  int loadConversations(SMSConversation* out, int maxCount);
-
-  // Load messages for a specific phone number (chronological, oldest first)
-  int loadMessages(const char* phone, SMSMessage* out, int maxCount);
-
-  // Delete all messages for a phone number
-  bool deleteConversation(const char* phone);
-
-  // Get total message count for a phone number
-  int getMessageCount(const char* phone);
-
-private:
-  bool _ready = false;
-
-  // Convert phone number to safe filename
-  void phoneToFilename(const char* phone, char* out, size_t outLen);
-};
-
-// Global singleton
-extern SMSStore smsStore;
-
-#endif // SMS_STORE_H
-#endif // HAS_4G_MODEM
--- a/examples/companion_radio/ui-new/Settingsscreen.h
+++ b/examples/companion_radio/ui-new/Settingsscreen.h
@@ -6,10 +6,6 @@
 #include <MeshCore.h>
 #include "../NodePrefs.h"

-#ifdef HAS_4G_MODEM
-  #include "ModemManager.h"
-#endif
-
 // Forward declarations
 class UITask;
 class MyMesh;
@@ -59,21 +55,12 @@ enum SettingsRowType : uint8_t {
  ROW_CR,             // Coding rate (5-8)
  ROW_TX_POWER,       // TX power (1-20 dBm)
  ROW_UTC_OFFSET,     // UTC offset (-12 to +14)
-  ROW_MSG_NOTIFY,     // Keyboard flash on new msg toggle
-  #ifdef HAS_4G_MODEM
-  ROW_MODEM_TOGGLE,   // 4G modem enable/disable toggle (4G builds only)
-  #endif
  ROW_CH_HEADER,      // "--- Channels ---" separator
  ROW_CHANNEL,        // A channel entry (dynamic, index stored separately)
  ROW_ADD_CHANNEL,    // "+ Add Hashtag Channel"
  ROW_INFO_HEADER,    // "--- Info ---" separator
  ROW_PUB_KEY,        // Public key display
  ROW_FIRMWARE,       // Firmware version
-  #ifdef HAS_4G_MODEM
-  ROW_IMEI,           // IMEI display (read-only)
-  ROW_OPERATOR_INFO,  // Carrier/operator display (read-only)
-  ROW_APN,            // APN setting (editable)
-  #endif
 };

 // ---------------------------------------------------------------------------
@@ -88,11 +75,7 @@ enum EditMode : uint8_t {
 };

 // Max rows in the settings list
-#ifdef HAS_4G_MODEM
-#define SETTINGS_MAX_ROWS 46  // Extra rows for IMEI, Carrier, APN
-#else
 #define SETTINGS_MAX_ROWS 40
-#endif
 #define SETTINGS_TEXT_BUF  33  // 32 chars + null

 class SettingsScreen : public UIScreen {
@@ -101,7 +84,7 @@ private:
  mesh::RTCClock* _rtc;
  NodePrefs* _prefs;

-  // Row table Ã¢â‚¬â€ rebuilt whenever channels change
+  // Row table â€” rebuilt whenever channels change
  struct Row {
    SettingsRowType type;
    uint8_t param;       // channel index for ROW_CHANNEL, preset index for ROW_RADIO_PRESET
@@ -125,14 +108,9 @@ private:
  // Onboarding mode
  bool _onboarding;

-  // Dirty flag for radio params Ã¢â‚¬â€ prompt to apply
+  // Dirty flag for radio params â€” prompt to apply
  bool _radioChanged;

-  // 4G modem state (runtime cache of config)
-  #ifdef HAS_4G_MODEM
-  bool _modemEnabled;
-  #endif
-
  // ---------------------------------------------------------------------------
  // Row table management
  // ---------------------------------------------------------------------------
@@ -148,10 +126,6 @@ private:
    addRow(ROW_CR);
    addRow(ROW_TX_POWER);
    addRow(ROW_UTC_OFFSET);
-    addRow(ROW_MSG_NOTIFY);
-    #ifdef HAS_4G_MODEM
-    addRow(ROW_MODEM_TOGGLE);
-    #endif
    addRow(ROW_CH_HEADER);

    // Enumerate current channels
@@ -169,12 +143,6 @@ private:
    addRow(ROW_PUB_KEY);
    addRow(ROW_FIRMWARE);

-    #ifdef HAS_4G_MODEM
-    addRow(ROW_IMEI);
-    addRow(ROW_OPERATOR_INFO);
-    addRow(ROW_APN);
-    #endif
-
    // Clamp cursor
    if (_cursor >= _numRows) _cursor = _numRows - 1;
    if (_cursor < 0) _cursor = 0;
@@ -192,11 +160,7 @@ private:
  bool isSelectable(int idx) const {
    if (idx < 0 || idx >= _numRows) return false;
    SettingsRowType t = _rows[idx].type;
-    return t != ROW_CH_HEADER && t != ROW_INFO_HEADER
-    #ifdef HAS_4G_MODEM
-      && t != ROW_IMEI && t != ROW_OPERATOR_INFO
-    #endif
-    ;
+    return t != ROW_CH_HEADER && t != ROW_INFO_HEADER;
  }

  void skipNonSelectable(int dir) {
@@ -246,11 +210,11 @@ private:
    strncpy(newCh.name, chanName, sizeof(newCh.name));
    newCh.name[31] = '\0';

-    // SHA-256 the channel name Ã¢â€ â€™ first 16 bytes become the secret
+    // SHA-256 the channel name â†’ first 16 bytes become the secret
    uint8_t hash[32];
    mesh::Utils::sha256(hash, 32, (const uint8_t*)chanName, strlen(chanName));
    memcpy(newCh.channel.secret, hash, 16);
-    // Upper 16 bytes left as zero Ã¢â€ â€™ setChannel uses 128-bit mode
+    // Upper 16 bytes left as zero â†’ setChannel uses 128-bit mode

    // Find next empty slot
    for (uint8_t i = 0; i < MAX_GROUP_CHANNELS; i++) {
@@ -323,9 +287,6 @@ public:
    _cursor = 0;
    _scrollTop = 0;
    _radioChanged = false;
-    #ifdef HAS_4G_MODEM
-    _modemEnabled = ModemManager::loadEnabledConfig();
-    #endif
    rebuildRows();
  }

@@ -504,20 +465,6 @@ public:
          display.print(tmp);
          break;

-        case ROW_MSG_NOTIFY:
-          snprintf(tmp, sizeof(tmp), "Msg Rcvd LED Light Pulse: %s",
-                   _prefs->kb_flash_notify ? "ON" : "OFF");
-          display.print(tmp);
-          break;
-
-        #ifdef HAS_4G_MODEM
-        case ROW_MODEM_TOGGLE:
-          snprintf(tmp, sizeof(tmp), "4G Modem: %s",
-                   _modemEnabled ? "ON" : "OFF");
-          display.print(tmp);
-          break;
-        #endif
-
        case ROW_CH_HEADER:
          display.setColor(DisplayDriver::YELLOW);
          display.print("--- Channels ---");
@@ -567,7 +514,7 @@ public:
          // Show first 8 bytes of pub key as hex (16 chars)
          char hexBuf[17];
          mesh::Utils::toHex(hexBuf, the_mesh.self_id.pub_key, 8);
-          snprintf(tmp, sizeof(tmp), "Node ID: %s", hexBuf);
+          snprintf(tmp, sizeof(tmp), "ID: %s", hexBuf);
          display.print(tmp);
          break;
        }
@@ -576,53 +523,6 @@ public:
          snprintf(tmp, sizeof(tmp), "FW: %s", FIRMWARE_VERSION);
          display.print(tmp);
          break;
-
-        #ifdef HAS_4G_MODEM
-        case ROW_IMEI: {
-          const char* imei = modemManager.getIMEI();
-          snprintf(tmp, sizeof(tmp), "IMEI: %s", imei[0] ? imei : "(unavailable)");
-          display.print(tmp);
-          break;
-        }
-
-        case ROW_OPERATOR_INFO: {
-          const char* op = modemManager.getOperator();
-          int bars = modemManager.getSignalBars();
-          if (op[0]) {
-            // Show carrier name with signal bar count
-            snprintf(tmp, sizeof(tmp), "Carrier: %s (%d/5)", op, bars);
-          } else {
-            snprintf(tmp, sizeof(tmp), "Carrier: (searching)");
-          }
-          display.print(tmp);
-          break;
-        }
-
-        case ROW_APN: {
-          if (editing && _editMode == EDIT_TEXT) {
-            snprintf(tmp, sizeof(tmp), "APN: %s_", _editBuf);
-          } else {
-            const char* apn = modemManager.getAPN();
-            const char* src = modemManager.getAPNSource();
-            if (apn[0]) {
-              // Truncate APN to fit: "APN: " (5) + apn (max 28) + " [x]" (4) = ~37 chars
-              char apnShort[29];
-              strncpy(apnShort, apn, 28);
-              apnShort[28] = '\0';
-              // Abbreviate source: auto→A, network→N, user→U, none→?
-              char srcChar = '?';
-              if (strcmp(src, "auto") == 0) srcChar = 'A';
-              else if (strcmp(src, "network") == 0) srcChar = 'N';
-              else if (strcmp(src, "user") == 0) srcChar = 'U';
-              snprintf(tmp, sizeof(tmp), "APN: %s [%c]", apnShort, srcChar);
-            } else {
-              snprintf(tmp, sizeof(tmp), "APN: (none)");
-            }
-          }
-          display.print(tmp);
-          break;
-        }
-        #endif
      }

      y += lineHeight;
@@ -739,20 +639,6 @@ public:
          }
          _editMode = EDIT_NONE;
        }
-        #ifdef HAS_4G_MODEM
-        else if (type == ROW_APN) {
-          // Save the edited APN (even if empty — clears user override)
-          if (_editPos > 0) {
-            modemManager.setAPN(_editBuf);
-            Serial.printf("Settings: APN set to '%s'\n", _editBuf);
-          } else {
-            // Empty APN: remove user override, revert to auto-detection
-            ModemManager::saveAPNConfig("");
-            Serial.println("Settings: APN cleared (will auto-detect on next boot)");
-          }
-          _editMode = EDIT_NONE;
-        }
-        #endif
        return true;
      }
      if (c == 'q' || c == 'Q' || c == 27) {
@@ -938,31 +824,6 @@ public:
        case ROW_UTC_OFFSET:
          startEditInt(_prefs->utc_offset_hours);
          break;
-        case ROW_MSG_NOTIFY:
-          _prefs->kb_flash_notify = _prefs->kb_flash_notify ? 0 : 1;
-          the_mesh.savePrefs();
-          Serial.printf("Settings: Msg flash notify = %s\n",
-                        _prefs->kb_flash_notify ? "ON" : "OFF");
-          break;
-        #ifdef HAS_4G_MODEM
-        case ROW_MODEM_TOGGLE:
-          _modemEnabled = !_modemEnabled;
-          ModemManager::saveEnabledConfig(_modemEnabled);
-          if (_modemEnabled) {
-            modemManager.begin();
-            Serial.println("Settings: 4G modem ENABLED (started)");
-          } else {
-            modemManager.shutdown();
-            Serial.println("Settings: 4G modem DISABLED (shutdown)");
-          }
-          break;
-        case ROW_APN: {
-          // Start text editing with current APN as initial value
-          const char* currentApn = modemManager.getAPN();
-          startEditText(currentApn);
-          break;
-        }
-        #endif
        case ROW_ADD_CHANNEL:
          startEditText("");
          break;
@@ -986,7 +847,7 @@ public:
      }
    }

-    // Q: back Ã¢â‚¬â€ if radio changed, prompt to apply first
+    // Q: back â€” if radio changed, prompt to apply first
    if (c == 'q' || c == 'Q') {
      if (_radioChanged) {
        _editMode = EDIT_CONFIRM;
--- a/examples/companion_radio/ui-new/Textreaderscreen.h
+++ b/examples/companion_radio/ui-new/Textreaderscreen.h
@@ -182,10 +182,8 @@ private:

  // File list state
  std::vector<String> _fileList;
-  std::vector<String> _dirList;    // Subdirectories at current path
  std::vector<FileCache> _fileCache;
  int _selectedFile;
-  String _currentPath;             // Current browsed directory

  // Reading state
  File _file;
@@ -393,8 +391,8 @@ private:
    idxFile.read(&fullyFlag, 1);
    idxFile.read((uint8_t*)&lastRead, 4);

-    // Verify file hasn't changed - try current path first, then epub cache
-    String fullPath = _currentPath + "/" + filename;
+    // Verify file hasn't changed - try BOOKS_FOLDER first, then epub cache
+    String fullPath = String(BOOKS_FOLDER) + "/" + filename;
    File txtFile = SD.open(fullPath.c_str(), FILE_READ);
    if (!txtFile) {
      // Fallback: check epub cache directory
@@ -484,94 +482,33 @@ private:

  // ---- File Scanning ----

-  // ---- Folder Navigation Helpers ----
-
-  bool isAtBooksRoot() const {
-    return _currentPath == String(BOOKS_FOLDER);
-  }
-
-  // Number of non-file entries at the start of the visual list
-  int dirEntryCount() const {
-    int count = _dirList.size();
-    if (!isAtBooksRoot()) count++;  // ".." entry
-    return count;
-  }
-
-  // Total items in the visual list (parent + dirs + files)
-  int totalListItems() const {
-    return dirEntryCount() + (int)_fileList.size();
-  }
-
-  // What type of entry is at visual list index idx?
-  // Returns: 0 = ".." parent, 1 = directory, 2 = file
-  int itemTypeAt(int idx) const {
-    bool hasParent = !isAtBooksRoot();
-    if (hasParent && idx == 0) return 0;  // ".."
-    int dirStart = hasParent ? 1 : 0;
-    if (idx < dirStart + (int)_dirList.size()) return 1;  // directory
-    return 2;  // file
-  }
-
-  // Get directory name for visual index (only valid when itemTypeAt == 1)
-  const String& dirNameAt(int idx) const {
-    int dirStart = isAtBooksRoot() ? 0 : 1;
-    return _dirList[idx - dirStart];
-  }
-
-  // Get file list index for visual index (only valid when itemTypeAt == 2)
-  int fileIndexAt(int idx) const {
-    return idx - dirEntryCount();
-  }
-
-  void navigateToParent() {
-    int lastSlash = _currentPath.lastIndexOf('/');
-    if (lastSlash > 0) {
-      _currentPath = _currentPath.substring(0, lastSlash);
-    } else {
-      _currentPath = BOOKS_FOLDER;
-    }
-  }
-
-  void navigateToChild(const String& dirName) {
-    _currentPath = _currentPath + "/" + dirName;
-  }
-
-  // ---- File Scanning ----
-
  void scanFiles() {
    _fileList.clear();
-    _dirList.clear();
    if (!SD.exists(BOOKS_FOLDER)) {
      SD.mkdir(BOOKS_FOLDER);
      Serial.printf("TextReader: Created %s\n", BOOKS_FOLDER);
    }

-    File root = SD.open(_currentPath.c_str());
+    File root = SD.open(BOOKS_FOLDER);
    if (!root || !root.isDirectory()) return;

    File f = root.openNextFile();
-    while (f && (_fileList.size() + _dirList.size()) < READER_MAX_FILES) {
-      String name = String(f.name());
-      int slash = name.lastIndexOf('/');
-      if (slash >= 0) name = name.substring(slash + 1);
+    while (f && _fileList.size() < READER_MAX_FILES) {
+      if (!f.isDirectory()) {
+        String name = String(f.name());
+        int slash = name.lastIndexOf('/');
+        if (slash >= 0) name = name.substring(slash + 1);

-      // Skip hidden files/dirs
-      if (name.startsWith(".")) {
-        f = root.openNextFile();
-        continue;
-      }
-
-      if (f.isDirectory()) {
-        _dirList.push_back(name);
-      } else if (name.endsWith(".txt") || name.endsWith(".TXT") ||
-                 name.endsWith(".epub") || name.endsWith(".EPUB")) {
-        _fileList.push_back(name);
+        if (!name.startsWith(".") &&
+            (name.endsWith(".txt") || name.endsWith(".TXT") ||
+             name.endsWith(".epub") || name.endsWith(".EPUB"))) {
+          _fileList.push_back(name);
+        }
      }
      f = root.openNextFile();
    }
    root.close();
-    Serial.printf("TextReader: %s — %d dirs, %d files\n",
-                  _currentPath.c_str(), (int)_dirList.size(), (int)_fileList.size());
+    Serial.printf("TextReader: Found %d files\n", _fileList.size());
  }

  // ---- Book Open/Close ----
@@ -581,7 +518,7 @@ private:

    // ---- EPUB auto-conversion ----
    String actualFilename = filename;
-    String actualFullPath = _currentPath + "/" + filename;
+    String actualFullPath = String(BOOKS_FOLDER) + "/" + filename;
    bool isEpub = filename.endsWith(".epub") || filename.endsWith(".EPUB");

    if (isEpub) {
@@ -818,26 +755,15 @@ private:
    display.setCursor(0, 0);
    display.setTextSize(1);
    display.setColor(DisplayDriver::GREEN);
-    if (isAtBooksRoot()) {
-      display.print("Text Reader");
-    } else {
-      // Show current subfolder name
-      int lastSlash = _currentPath.lastIndexOf('/');
-      String folderName = (lastSlash >= 0) ? _currentPath.substring(lastSlash + 1) : _currentPath;
-      char hdrBuf[20];
-      strncpy(hdrBuf, folderName.c_str(), 17);
-      hdrBuf[17] = '\0';
-      display.print(hdrBuf);
-    }
+    display.print("Text Reader");

-    int totalItems = totalListItems();
-    sprintf(tmp, "[%d]", totalItems);
+    sprintf(tmp, "[%d]", (int)_fileList.size());
    display.setCursor(display.width() - display.getTextWidth(tmp) - 2, 0);
    display.print(tmp);

    display.drawRect(0, 11, display.width(), 1);

-    if (totalItems == 0) {
+    if (_fileList.size() == 0) {
      display.setCursor(0, 18);
      display.setColor(DisplayDriver::LIGHT);
      display.print("No files found");
@@ -854,8 +780,8 @@ private:
      if (maxVisible > 15) maxVisible = 15;

      int startIdx = max(0, min(_selectedFile - maxVisible / 2,
-                                totalItems - maxVisible));
-      int endIdx = min(totalItems, startIdx + maxVisible);
+                                (int)_fileList.size() - maxVisible));
+      int endIdx = min((int)_fileList.size(), startIdx + maxVisible);

      int y = startY;
      for (int i = startIdx; i < endIdx; i++) {
@@ -874,41 +800,27 @@ private:
        // Set cursor AFTER fillRect so text draws on top of highlight
        display.setCursor(0, y);

-        int type = itemTypeAt(i);
+        // Build display string: "> filename.txt *" (asterisk if has bookmark)
        String line = selected ? "> " : "  ";
+        String name = _fileList[i];

-        if (type == 0) {
-          // ".." parent directory
-          line += ".. (up)";
-        } else if (type == 1) {
-          // Subdirectory
-          line += "/" + dirNameAt(i);
-          // Truncate if needed
-          if ((int)line.length() > _charsPerLine) {
-            line = line.substring(0, _charsPerLine - 3) + "...";
+        // Check for resume indicator
+        String suffix = "";
+        for (int j = 0; j < (int)_fileCache.size(); j++) {
+          if (_fileCache[j].filename == name && _fileCache[j].lastReadPage > 0) {
+            suffix = " *";
+            break;
          }
-        } else {
-          // File
-          int fi = fileIndexAt(i);
-          String name = _fileList[fi];
-
-          // Check for resume indicator
-          String suffix = "";
-          if (fi < (int)_fileCache.size()) {
-            if (_fileCache[fi].filename == name && _fileCache[fi].lastReadPage > 0) {
-              suffix = " *";
-            }
-          }
-
-          // Truncate if needed
-          int maxLen = _charsPerLine - 4 - suffix.length();
-          if ((int)name.length() > maxLen) {
-            name = name.substring(0, maxLen - 3) + "...";
-          }
-          line += name + suffix;
        }

+        // Truncate if needed
+        int maxLen = _charsPerLine - 4 - suffix.length();
+        if ((int)name.length() > maxLen) {
+          name = name.substring(0, maxLen - 3) + "...";
+        }
+        line += name + suffix;
        display.print(line.c_str());
+
        y += listLineH;
      }
      display.setTextSize(1);  // Restore
@@ -1016,8 +928,7 @@ public:
      _bootIndexed(false), _display(nullptr),
      _charsPerLine(38), _linesPerPage(22), _lineHeight(5),
      _headerHeight(14), _footerHeight(14),
-      _selectedFile(0), _currentPath(BOOKS_FOLDER),
-      _fileOpen(false), _currentPage(0), _totalPages(0),
+      _selectedFile(0), _fileOpen(false), _currentPage(0), _totalPages(0),
      _pageBufLen(0), _contentDirty(true) {
  }

@@ -1157,8 +1068,8 @@ public:
        indexProgress++;
        drawBootSplash(indexProgress, needsIndexCount, _fileList[i]);

-        // Try current path first, then epub cache fallback
-        String fullPath = _currentPath + "/" + _fileList[i];
+        // Try BOOKS_FOLDER first, then epub cache fallback
+        String fullPath = String(BOOKS_FOLDER) + "/" + _fileList[i];
        File file = SD.open(fullPath.c_str(), FILE_READ);
        if (!file) {
          String cacheFallback = String("/books/.epub_cache/") + _fileList[i];
@@ -1255,8 +1166,6 @@ public:
  }

  bool handleFileListInput(char c) {
-    int total = totalListItems();
-
    // W - scroll up
    if (c == 'w' || c == 'W' || c == 0xF2) {
      if (_selectedFile > 0) {
@@ -1268,36 +1177,18 @@ public:

    // S - scroll down
    if (c == 's' || c == 'S' || c == 0xF1) {
-      if (_selectedFile < total - 1) {
+      if (_selectedFile < (int)_fileList.size() - 1) {
        _selectedFile++;
        return true;
      }
      return false;
    }

-    // Enter - open selected item (directory or file)
+    // Enter - open selected file
    if (c == '\r' || c == 13) {
-      if (total == 0 || _selectedFile >= total) return false;
-
-      int type = itemTypeAt(_selectedFile);
-
-      if (type == 0) {
-        // ".." — navigate to parent
-        navigateToParent();
-        rescanAndIndex();
+      if (_fileList.size() > 0 && _selectedFile < (int)_fileList.size()) {
+        openBook(_fileList[_selectedFile]);
        return true;
-      } else if (type == 1) {
-        // Subdirectory — navigate into it
-        navigateToChild(dirNameAt(_selectedFile));
-        rescanAndIndex();
-        return true;
-      } else {
-        // File — open it
-        int fi = fileIndexAt(_selectedFile);
-        if (fi >= 0 && fi < (int)_fileList.size()) {
-          openBook(_fileList[fi]);
-          return true;
-        }
      }
      return false;
    }
@@ -1305,53 +1196,6 @@ public:
    return false;
  }

-  // Rescan current directory and re-index its files.
-  // Called when navigating into or out of a subfolder.
-  void rescanAndIndex() {
-    scanFiles();
-    _selectedFile = 0;
-
-    // Rebuild file cache for the new directory's files
-    _fileCache.clear();
-    _fileCache.resize(_fileList.size());
-
-    for (int i = 0; i < (int)_fileList.size(); i++) {
-      if (!loadIndex(_fileList[i], _fileCache[i])) {
-        // Not cached — skip EPUB auto-indexing here (it happens on open)
-        // For .txt files, index now
-        if (!(_fileList[i].endsWith(".epub") || _fileList[i].endsWith(".EPUB"))) {
-          String fullPath = _currentPath + "/" + _fileList[i];
-          File file = SD.open(fullPath.c_str(), FILE_READ);
-          if (!file) {
-            // Try epub cache fallback
-            String cacheFallback = String("/books/.epub_cache/") + _fileList[i];
-            file = SD.open(cacheFallback.c_str(), FILE_READ);
-          }
-          if (file) {
-            FileCache& cache = _fileCache[i];
-            cache.filename = _fileList[i];
-            cache.fileSize = file.size();
-            cache.fullyIndexed = false;
-            cache.lastReadPage = 0;
-            cache.pagePositions.clear();
-            cache.pagePositions.push_back(0);
-            indexPagesWordWrap(file, 0, cache.pagePositions,
-                               _linesPerPage, _charsPerLine,
-                               PREINDEX_PAGES - 1);
-            cache.fullyIndexed = !file.available();
-            file.close();
-            saveIndex(cache.filename, cache.pagePositions, cache.fileSize,
-                      cache.fullyIndexed, 0);
-          }
-        } else {
-          _fileCache[i].filename = "";
-        }
-      }
-      yield();  // Feed WDT between files
-    }
-    digitalWrite(SDCARD_CS, HIGH);
-  }
-
  bool handleReadingInput(char c) {
    // W/A - previous page
    if (c == 'w' || c == 'W' || c == 'a' || c == 'A' || c == 0xF2) {
--- a/examples/companion_radio/ui-new/Touchinput.h
+++ b/examples/companion_radio/ui-new/Touchinput.h
@@ -1,128 +0,0 @@
-#pragma once
-
-// =============================================================================
-// TouchInput - Minimal CST328/CST3530 touch driver for T-Deck Pro
-//
-// Uses raw I2C reads on the shared Wire bus. No external library needed.
-// Protocol confirmed via raw serial capture from actual hardware:
-//
-//   Register 0xD000, 7 bytes:
-//   buf[0]: event flags (0xAB = idle/no touch, other = active touch)
-//   buf[1]: X coordinate high data
-//   buf[2]: Y coordinate high data
-//   buf[3]: X low nibble (bits 7:4) | Y low nibble (bits 3:0)
-//   buf[4]: pressure
-//   buf[5]: touch count (& 0x7F), typically 0x01 for single touch
-//   buf[6]: 0xAB always (check byte, ignore)
-//
-//   Coordinate formula:
-//     x = (buf[1] << 4) | ((buf[3] >> 4) & 0x0F)   → 0..239
-//     y = (buf[2] << 4) | (buf[3] & 0x0F)           → 0..319
-//
-// Hardware: CST328 at 0x1A, INT=GPIO12, RST=GPIO38 (V1.1)
-//
-// Guard: HAS_TOUCHSCREEN
-// =============================================================================
-
-#ifdef HAS_TOUCHSCREEN
-
-#ifndef TOUCH_INPUT_H
-#define TOUCH_INPUT_H
-
-#include <Arduino.h>
-#include <Wire.h>
-
-class TouchInput {
-public:
-  static const uint8_t TOUCH_ADDR = 0x1A;
-
-  TouchInput(TwoWire* wire = &Wire)
-    : _wire(wire), _intPin(-1), _initialized(false), _debugCount(0), _lastPoll(0) {}
-
-  bool begin(int intPin) {
-    _intPin = intPin;
-    pinMode(_intPin, INPUT);
-
-    // Verify the touch controller is present on the bus
-    _wire->beginTransmission(TOUCH_ADDR);
-    uint8_t err = _wire->endTransmission();
-    if (err != 0) {
-      Serial.printf("[Touch] CST328 not found at 0x%02X (err=%d)\n", TOUCH_ADDR, err);
-      return false;
-    }
-
-    Serial.printf("[Touch] CST328 found at 0x%02X, INT=GPIO%d\n", TOUCH_ADDR, _intPin);
-    _initialized = true;
-    return true;
-  }
-
-  bool isReady() const { return _initialized; }
-
-  // Poll for touch. Returns true if a finger is down, fills x and y.
-  // Coordinates are in physical display space (0-239 X, 0-319 Y).
-  // NOTE: CST328 INT pin is pulse-based, not level. We cannot rely on
-  // digitalRead(INT) for touch state. Instead, always read and check buf[0].
-  bool getPoint(int16_t &x, int16_t &y) {
-    if (!_initialized) return false;
-
-    // Rate limit: poll at most every 20ms (50 Hz) to avoid I2C bus congestion
-    unsigned long now = millis();
-    if (now - _lastPoll < 20) return false;
-    _lastPoll = now;
-
-    uint8_t buf[7];
-    memset(buf, 0, sizeof(buf));
-
-    // Write register address 0xD000
-    _wire->beginTransmission(TOUCH_ADDR);
-    _wire->write(0xD0);
-    _wire->write(0x00);
-    if (_wire->endTransmission(false) != 0) return false;
-
-    // Read 7 bytes of touch data
-    uint8_t received = _wire->requestFrom(TOUCH_ADDR, (uint8_t)7);
-    if (received < 7) return false;
-    for (int i = 0; i < 7; i++) buf[i] = _wire->read();
-
-    // buf[0] == 0xAB means idle (no touch active)
-    if (buf[0] == 0xAB) return false;
-
-    // buf[0] == 0x00 can appear on finger-up transition — ignore
-    if (buf[0] == 0x00) return false;
-
-    // Touch count from buf[5]
-    uint8_t count = buf[5] & 0x7F;
-    if (count == 0 || count > 5) return false;
-
-    // Parse coordinates (CST226/CST328 format confirmed by hardware capture)
-    //   x = (buf[1] << 4) | high nibble of buf[3]
-    //   y = (buf[2] << 4) | low nibble of buf[3]
-    int16_t tx = ((int16_t)buf[1] << 4) | ((buf[3] >> 4) & 0x0F);
-    int16_t ty = ((int16_t)buf[2] << 4) | (buf[3] & 0x0F);
-
-    // Sanity check (panel is 240x320)
-    if (tx < 0 || tx > 260 || ty < 0 || ty > 340) return false;
-
-    // Debug: log first 20 touch events with parsed coordinates
-    if (_debugCount < 50) {
-      Serial.printf("[Touch] Raw: %02X %02X %02X %02X %02X %02X %02X → x=%d y=%d\n",
-                    buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6],
-                    tx, ty);
-      _debugCount++;
-    }
-
-    x = tx;
-    y = ty;
-    return true;
-  }
-
-private:
-  TwoWire* _wire;
-  int _intPin;
-  bool _initialized;
-  int _debugCount;
-  unsigned long _lastPoll;
-};
-
-#endif // TOUCH_INPUT_H
-#endif // HAS_TOUCHSCREEN
--- a/examples/companion_radio/ui-new/UITask.cpp
+++ b/examples/companion_radio/ui-new/UITask.cpp
@@ -2,7 +2,6 @@
 #include <helpers/TxtDataHelpers.h>
 #include "../MyMesh.h"
 #include "NotesScreen.h"
-#include "RepeaterAdminScreen.h"
 #include "target.h"
 #include "GPSDutyCycle.h"
 #ifdef WIFI_SSID
@@ -37,18 +36,11 @@
 #include "ContactsScreen.h"
 #include "TextReaderScreen.h"
 #include "SettingsScreen.h"
-#ifdef MECK_AUDIO_VARIANT
-#include "AudiobookPlayerScreen.h"
-#endif
-#ifdef HAS_4G_MODEM
-  #include "SMSScreen.h"
-  #include "ModemManager.h"
-#endif

 class SplashScreen : public UIScreen {
  UITask* _task;
  unsigned long dismiss_after;
-  char _version_info[24];
+  char _version_info[12];

 public:
  SplashScreen(UITask* task) : _task(task) {
@@ -95,18 +87,13 @@ class HomeScreen : public UIScreen {
    FIRST,
    RECENT,
    RADIO,
-#ifdef BLE_PIN_CODE
    BLUETOOTH,
-#endif
    ADVERT,
 #if ENV_INCLUDE_GPS == 1
    GPS,
 #endif
 #if UI_SENSORS_PAGE == 1
    SENSORS,
-#endif
-#if HAS_BQ27220
-    BATTERY,
 #endif
    SHUTDOWN,
    Count    // keep as last
@@ -118,22 +105,27 @@ class HomeScreen : public UIScreen {
  NodePrefs* _node_prefs;
  uint8_t _page;
  bool _shutdown_init;
-  unsigned long _shutdown_at;   // earliest time to proceed with shutdown (after e-ink refresh)
  bool _editing_utc;
  int8_t _saved_utc_offset;  // for cancel/undo
  AdvertPath recent[UI_RECENT_LIST_SIZE];


 void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts, int* outIconX = nullptr) {
-    // Use voltage-based estimation to match BLE app readings
-    uint8_t batteryPercentage = 0;
+    // Use the BQ27220 fuel gauge SOC register for accurate percentage.
+    // Falls back to voltage estimation if the fuel gauge is uncalibrated.
+    uint8_t batteryPercentage = board.getBatteryPercent();
+
+    // Sanity check: if voltage says full but gauge disagrees significantly,
+    // the gauge hasn't calibrated yet — fall back to voltage estimate
+    int voltagePct = 0;
    if (batteryMilliVolts > 0) {
-      const int minMilliVolts = 3000;
-      const int maxMilliVolts = 4200;
-      int pct = ((batteryMilliVolts - minMilliVolts) * 100) / (maxMilliVolts - minMilliVolts);
-      if (pct < 0) pct = 0;
-      if (pct > 100) pct = 100;
-      batteryPercentage = (uint8_t)pct;
+        voltagePct = ((batteryMilliVolts - 3000) * 100) / (4200 - 3000);
+        if (voltagePct < 0) voltagePct = 0;
+        if (voltagePct > 100) voltagePct = 100;
+    }
+
+    if (batteryPercentage == 0 || abs((int)batteryPercentage - voltagePct) > 30) {
+        batteryPercentage = (uint8_t)voltagePct;
    }

    display.setColor(DisplayDriver::GREEN);
@@ -153,8 +145,6 @@ void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts,
    int iconX = display.width() - totalWidth;
    int iconY = 0;  // vertically align with node name text

-    if (outIconX) *outIconX = iconX;
-
    // battery outline
    display.drawRect(iconX, iconY, iconWidth, iconHeight);

@@ -174,24 +164,6 @@ void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts,
    display.setTextSize(1);  // restore default text size
  }

-#ifdef MECK_AUDIO_VARIANT
-  // ---- Audio background playback indicator ----
-  // Shows a small play symbol to the left of the battery icon when an
-  // audiobook is actively playing in the background.
-  // Uses the font renderer (not manual pixel drawing) since it handles
-  // the e-ink coordinate scaling correctly.
-  void renderAudioIndicator(DisplayDriver& display, int batteryLeftX) {
-    if (!_task->isAudioPlayingInBackground()) return;
-
-    display.setColor(DisplayDriver::GREEN);
-    display.setTextSize(0); // tiny font (same as clock & battery %)
-    int x = batteryLeftX - display.getTextWidth(">>") - 2;
-    display.setCursor(x, -3); // align vertically with battery text
-    display.print(">>");
-    display.setTextSize(1); // restore
-  }
-#endif
-
  CayenneLPP sensors_lpp;
  int sensors_nb = 0;
  bool sensors_scroll = false;
@@ -222,7 +194,7 @@ void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts,
 public:
  HomeScreen(UITask* task, mesh::RTCClock* rtc, SensorManager* sensors, NodePrefs* node_prefs)
     : _task(task), _rtc(rtc), _sensors(sensors), _node_prefs(node_prefs), _page(0), 
-       _shutdown_init(false), _shutdown_at(0), _editing_utc(false), _saved_utc_offset(0), sensors_lpp(200) {  }
+       _shutdown_init(false), _editing_utc(false), _saved_utc_offset(0), sensors_lpp(200) {  }

  bool isEditingUTC() const { return _editing_utc; }
  void cancelEditUTC() { 
@@ -233,31 +205,23 @@ public:
  }

  void poll() override {
-    if (_shutdown_init && millis() >= _shutdown_at && !_task->isButtonPressed()) {
+    if (_shutdown_init && !_task->isButtonPressed()) {  // must wait for USR button to be released
      _task->shutdown();
    }
  }

  int render(DisplayDriver& display) override {
    char tmp[80];
-    // node name (tinyfont to avoid overlapping clock)
-    display.setTextSize(0);
+    // node name
+    display.setTextSize(1);
    display.setColor(DisplayDriver::GREEN);
    char filtered_name[sizeof(_node_prefs->node_name)];
    display.translateUTF8ToBlocks(filtered_name, _node_prefs->node_name, sizeof(filtered_name));
-    display.setCursor(0, -3);
+    display.setCursor(0, 0);
    display.print(filtered_name);

    // battery voltage
-#ifdef MECK_AUDIO_VARIANT
-    int battLeftX = display.width(); // default if battery doesn't render
-    renderBatteryIndicator(display, _task->getBattMilliVolts(), &battLeftX);
-
-    // audio background playback indicator (>> icon next to battery)
-    renderAudioIndicator(display, battLeftX);
-#else
    renderBatteryIndicator(display, _task->getBattMilliVolts());
-#endif

    // centered clock (tinyfont) - only show when time is valid
    {
@@ -294,64 +258,28 @@ public:
    }

    if (_page == HomePage::FIRST) {
-      int y = 20;
      display.setColor(DisplayDriver::YELLOW);
      display.setTextSize(2);
-      sprintf(tmp, "MSG: %d", _task->getUnreadMsgCount());
-      display.drawTextCentered(display.width() / 2, y, tmp);
-      y += 18;
+      sprintf(tmp, "MSG: %d", _task->getMsgCount());
+      display.drawTextCentered(display.width() / 2, 20, tmp);

      #ifdef WIFI_SSID
        IPAddress ip = WiFi.localIP();
        snprintf(tmp, sizeof(tmp), "IP: %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
        display.setTextSize(1);
-        display.drawTextCentered(display.width() / 2, y, tmp);
-        y += 12;
+        display.drawTextCentered(display.width() / 2, 54, tmp); 
      #endif
-      #if defined(BLE_PIN_CODE) || defined(WIFI_SSID)
      if (_task->hasConnection()) {
        display.setColor(DisplayDriver::GREEN);
        display.setTextSize(1);
-        display.drawTextCentered(display.width() / 2, y, "< Connected >");
-        y += 12;
-#ifdef BLE_PIN_CODE
-      } else if (_task->isSerialEnabled() && the_mesh.getBLEPin() != 0) {
+        display.drawTextCentered(display.width() / 2, 43, "< Connected >");
+
+      } else if (the_mesh.getBLEPin() != 0) { // BT pin
        display.setColor(DisplayDriver::RED);
        display.setTextSize(2);
        sprintf(tmp, "Pin:%d", the_mesh.getBLEPin());
-        display.drawTextCentered(display.width() / 2, y, tmp);
-        y += 18;
-#endif
+        display.drawTextCentered(display.width() / 2, 43, tmp);
      }
-      #endif
-
-      // Menu shortcuts - tinyfont monospaced grid
-      y += 6;
-      display.setColor(DisplayDriver::LIGHT);
-      display.setTextSize(0);  // tinyfont 6x8 monospaced
-      display.drawTextCentered(display.width() / 2, y, "Press:");
-      y += 12;
-      display.drawTextCentered(display.width() / 2, y, "[M] Messages    [C] Contacts  ");
-      y += 10;
-      display.drawTextCentered(display.width() / 2, y, "[N] Notes       [S] Settings  ");
-      y += 10;
-#ifdef HAS_4G_MODEM
-      display.drawTextCentered(display.width() / 2, y, "[E] Reader      [T] Phone     ");
-#elif defined(MECK_AUDIO_VARIANT)
-      display.drawTextCentered(display.width() / 2, y, "[E] Reader      [P] Audiobooks");
-#else
-      display.drawTextCentered(display.width() / 2, y, "[E] Reader                    ");
-#endif
-#ifdef MECK_WEB_READER
-      y += 10;
-      display.drawTextCentered(display.width() / 2, y, "[B] Browser                   ");
-#endif
-      y += 14;
-
-      // Nav hint
-      display.setColor(DisplayDriver::GREEN);
-      display.drawTextCentered(display.width() / 2, y, "Press A/D to cycle home views");
-      display.setTextSize(1);  // restore
    } else if (_page == HomePage::RECENT) {
      the_mesh.getRecentlyHeard(recent, UI_RECENT_LIST_SIZE);
      display.setColor(DisplayDriver::GREEN);
@@ -396,26 +324,13 @@ public:
      display.setCursor(0, 53);
      sprintf(tmp, "Noise floor: %d", radio_driver.getNoiseFloor());
      display.print(tmp);
-#ifdef BLE_PIN_CODE
    } else if (_page == HomePage::BLUETOOTH) {
      display.setColor(DisplayDriver::GREEN);
      display.drawXbm((display.width() - 32) / 2, 18,
          _task->isSerialEnabled() ? bluetooth_on : bluetooth_off,
          32, 32);
-      if (_task->hasConnection()) {
-        display.setColor(DisplayDriver::GREEN);
-        display.setTextSize(1);
-        display.drawTextCentered(display.width() / 2, 53, "< Connected >");
-      } else if (_task->isSerialEnabled() && the_mesh.getBLEPin() != 0) {
-        display.setColor(DisplayDriver::RED);
-        display.setTextSize(2);
-        sprintf(tmp, "Pin:%d", the_mesh.getBLEPin());
-        display.drawTextCentered(display.width() / 2, 53, tmp);
-      }
-      display.setColor(DisplayDriver::GREEN);
      display.setTextSize(1);
-      display.drawTextCentered(display.width() / 2, 72, "toggle: " PRESS_LABEL);
-#endif
+      display.drawTextCentered(display.width() / 2, 64 - 11, "toggle: " PRESS_LABEL);
    } else if (_page == HomePage::ADVERT) {
      display.setColor(DisplayDriver::GREEN);
      display.drawXbm((display.width() - 32) / 2, 18, advert_icon, 32, 32);
@@ -465,7 +380,7 @@ public:
        display.drawTextRightAlign(display.width()-1, y, buf);
        y = y + 12;

-        // NMEA sentence counter ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â‚¬Å¡Ã‚Â¬Ãƒâ€šÃ‚Â confirms baud rate and data flow
+        // NMEA sentence counter Ã¢â‚¬â€ confirms baud rate and data flow
        display.drawTextLeftAlign(0, y, "sentences");
        if (gpsDuty.isHardwareOn()) {
          uint16_t sps = gpsStream.getSentencesPerSec();
@@ -595,68 +510,6 @@ public:
      }
      if (sensors_scroll) sensors_scroll_offset = (sensors_scroll_offset+1)%sensors_nb;
      else sensors_scroll_offset = 0;
-#endif
-#if HAS_BQ27220
-    } else if (_page == HomePage::BATTERY) {
-      char buf[30];
-      int y = 18;
-
-      // Title
-      display.setColor(DisplayDriver::GREEN);
-      display.drawTextCentered(display.width() / 2, y, "Battery Gauge");
-      y += 12;
-
-      display.setColor(DisplayDriver::LIGHT);
-
-      // Time to empty
-      uint16_t tte = board.getTimeToEmpty();
-      display.drawTextLeftAlign(0, y, "remaining");
-      if (tte == 0xFFFF || tte == 0) {
-        strcpy(buf, tte == 0 ? "depleted" : "charging");
-      } else if (tte >= 60) {
-        sprintf(buf, "%dh %dm", tte / 60, tte % 60);
-      } else {
-        sprintf(buf, "%d min", tte);
-      }
-      display.drawTextRightAlign(display.width()-1, y, buf);
-      y += 10;
-
-      // Average current
-      int16_t avgCur = board.getAvgCurrent();
-      display.drawTextLeftAlign(0, y, "avg current");
-      sprintf(buf, "%d mA", avgCur);
-      display.drawTextRightAlign(display.width()-1, y, buf);
-      y += 10;
-
-      // Average power
-      int16_t avgPow = board.getAvgPower();
-      display.drawTextLeftAlign(0, y, "avg power");
-      sprintf(buf, "%d mW", avgPow);
-      display.drawTextRightAlign(display.width()-1, y, buf);
-      y += 10;
-
-      // Voltage (already available)
-      uint16_t mv = board.getBattMilliVolts();
-      display.drawTextLeftAlign(0, y, "voltage");
-      sprintf(buf, "%d.%03d V", mv / 1000, mv % 1000);
-      display.drawTextRightAlign(display.width()-1, y, buf);
-      y += 10;
-
-      // Remaining capacity (clamped to design capacity — gauge FCC may be
-      // stale from factory defaults until a full charge cycle re-learns it)
-      uint16_t remCap = board.getRemainingCapacity();
-      uint16_t desCap = board.getDesignCapacity();
-      if (desCap > 0 && remCap > desCap) remCap = desCap;
-      display.drawTextLeftAlign(0, y, "remaining cap");
-      sprintf(buf, "%d mAh", remCap);
-      display.drawTextRightAlign(display.width()-1, y, buf);
-      y += 10;
-
-      // Battery temperature
-      int16_t battTemp = board.getBattTemperature();
-      display.drawTextLeftAlign(0, y, "temperature");
-      sprintf(buf, "%d.%d C", battTemp / 10, abs(battTemp % 10));
-      display.drawTextRightAlign(display.width()-1, y, buf);
 #endif
    } else if (_page == HomePage::SHUTDOWN) {
      display.setColor(DisplayDriver::GREEN);
@@ -717,7 +570,6 @@ public:
      }
      return true;
    }
-#ifdef BLE_PIN_CODE
    if (c == KEY_ENTER && _page == HomePage::BLUETOOTH) {
      if (_task->isSerialEnabled()) {  // toggle Bluetooth on/off
        _task->disableSerial();
@@ -726,7 +578,6 @@ public:
      }
      return true;
    }
-#endif
    if (c == KEY_ENTER && _page == HomePage::ADVERT) {
      _task->notify(UIEventType::ack);
      if (the_mesh.advert()) {
@@ -755,8 +606,7 @@ public:
    }
 #endif
    if (c == KEY_ENTER && _page == HomePage::SHUTDOWN) {
-      _shutdown_init = true;
-      _shutdown_at = millis() + 900;  // allow e-ink refresh (644ms) before shutdown
+      _shutdown_init = true;  // need to wait for button to be released
      return true;
    }
    return false;
@@ -895,12 +745,6 @@ void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* no
  vibration.begin();
 #endif

-  // Keyboard backlight for message flash notifications
-#ifdef KB_BL_PIN
-  pinMode(KB_BL_PIN, OUTPUT);
-  digitalWrite(KB_BL_PIN, LOW);
-#endif
-
  ui_started_at = millis();
  _alert_expiry = 0;

@@ -912,11 +756,6 @@ void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* no
  text_reader = new TextReaderScreen(this);
  notes_screen = new NotesScreen(this);
  settings_screen = new SettingsScreen(this, &rtc_clock, node_prefs);
-  repeater_admin = nullptr;  // Lazy-initialized on first use to preserve heap for audio
-  audiobook_screen = nullptr;  // Created and assigned from main.cpp if audio hardware present
-#ifdef HAS_4G_MODEM
-  sms_screen = new SMSScreen(this);
-#endif
  setCurrScreen(splash);
 }

@@ -958,13 +797,12 @@ switch(t){

 void UITask::msgRead(int msgcount) {
  _msgcount = msgcount;
-  if (msgcount == 0 && curr == msg_preview) {
+  if (msgcount == 0) {
    gotoHomeScreen();
  }
 }

-void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount,
-                    const uint8_t* path) {
+void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount) {
  _msgcount = msgcount;

  // Add to preview screen (for notifications on non-keyboard devices)
@@ -982,25 +820,15 @@ void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, i
    }
  }
  
-  // Add to channel history screen with channel index and path data
-  ((ChannelScreen *) channel_screen)->addMessage(channel_idx, path_len, from_name, text, path);
-  
-  // If user is currently viewing this channel, mark it as read immediately
-  // (they can see the message arrive in real-time)
-  if (isOnChannelScreen() && 
-      ((ChannelScreen *) channel_screen)->getViewChannelIdx() == channel_idx) {
-    ((ChannelScreen *) channel_screen)->markChannelRead(channel_idx);
-  }
+  // Add to channel history screen with channel index
+  ((ChannelScreen *) channel_screen)->addMessage(channel_idx, path_len, from_name, text);
  
 #if defined(LilyGo_TDeck_Pro)
  // T-Deck Pro: Don't interrupt user with popup - just show brief notification
  // Messages are stored in channel history, accessible via 'M' key
-  // Suppress alert entirely on admin screen - it needs focused interaction
-  if (!isOnRepeaterAdmin()) {
-    char alertBuf[40];
-    snprintf(alertBuf, sizeof(alertBuf), "New: %s", from_name);
-    showAlert(alertBuf, 2000);
-  }
+  char alertBuf[40];
+  snprintf(alertBuf, sizeof(alertBuf), "New: %s", from_name);
+  showAlert(alertBuf, 2000);
 #else
  // Other devices: Show full preview screen (legacy behavior)
  setCurrScreen(msg_preview);
@@ -1015,14 +843,6 @@ void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, i
    _next_refresh = 100;  // trigger refresh
    }
  }
-
-  // Keyboard flash notification
-#ifdef KB_BL_PIN
-  if (_node_prefs->kb_flash_notify) {
-    digitalWrite(KB_BL_PIN, HIGH);
-    _kb_flash_off_at = millis() + 200;  // 200ms flash
-  }
-#endif
 }

 void UITask::userLedHandler() {
@@ -1072,31 +892,8 @@ void UITask::shutdown(bool restart){
  if (restart) {
    _board->reboot();
  } else {
-    // Disable BLE if active
-    if (_serial != NULL && _serial->isEnabled()) {
-      _serial->disable();
-    }
-
-    // Disable WiFi if active
-    #ifdef WIFI_SSID
-      WiFi.disconnect(true);
-      WiFi.mode(WIFI_OFF);
-    #endif
-
-    // Disable GPS if active
-    #if ENV_INCLUDE_GPS == 1
-    {
-      extern GPSDutyCycle gpsDuty;
-      if (_sensors != NULL && _node_prefs != NULL && _node_prefs->gps_enabled) {
-        _sensors->setSettingValue("gps", "0");
-        gpsDuty.disable();
-      }
-    }
-    #endif
-
-    // Power off LoRa radio, display, and board
-    radio_driver.powerOff();
    _display->turnOff();
+    radio_driver.powerOff();
    _board->powerOff();
  }
 }
@@ -1181,14 +978,6 @@ void UITask::loop() {

  userLedHandler();

-  // Turn off keyboard flash after timeout
-#ifdef KB_BL_PIN
-  if (_kb_flash_off_at && millis() >= _kb_flash_off_at) {
-    digitalWrite(KB_BL_PIN, LOW);
-    _kb_flash_off_at = 0;
-  }
-#endif
-
 #ifdef PIN_BUZZER
  if (buzzer.isPlaying())  buzzer.loop();
 #endif
@@ -1299,13 +1088,13 @@ void UITask::toggleGPS() {

    if (_sensors != NULL) {
      if (_node_prefs->gps_enabled) {
-        // Disable GPS ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â‚¬Å¡Ã‚Â¬Ãƒâ€šÃ‚Â cut hardware power
+        // Disable GPS Ã¢â‚¬â€ cut hardware power
        _sensors->setSettingValue("gps", "0");
        _node_prefs->gps_enabled = 0;
        gpsDuty.disable();
        notify(UIEventType::ack);
      } else {
-        // Enable GPS ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â‚¬Å¡Ã‚Â¬Ãƒâ€šÃ‚Â start duty cycle
+        // Enable GPS Ã¢â‚¬â€ start duty cycle
        _sensors->setSettingValue("gps", "1");
        _node_prefs->gps_enabled = 1;
        gpsDuty.enable();
@@ -1372,10 +1161,6 @@ bool UITask::isEditingHomeScreen() const {

 void UITask::gotoChannelScreen() {
  ((ChannelScreen *) channel_screen)->resetScroll();
-  // Mark the currently viewed channel as read
-  ((ChannelScreen *) channel_screen)->markChannelRead(
-    ((ChannelScreen *) channel_screen)->getViewChannelIdx()
-  );
  setCurrScreen(channel_screen);
  if (_display != NULL && !_display->isOn()) {
    _display->turnOn();
@@ -1440,43 +1225,10 @@ void UITask::gotoOnboarding() {
  _next_refresh = 100;
 }

-void UITask::gotoAudiobookPlayer() {
-#ifdef MECK_AUDIO_VARIANT
-  if (audiobook_screen == nullptr) return;  // No audio hardware
-  AudiobookPlayerScreen* abPlayer = (AudiobookPlayerScreen*)audiobook_screen;
-  if (_display != NULL) {
-    abPlayer->enter(*_display);
-  }
-  setCurrScreen(audiobook_screen);
-  if (_display != NULL && !_display->isOn()) {
-    _display->turnOn();
-  }
-  _auto_off = millis() + AUTO_OFF_MILLIS;
-  _next_refresh = 100;
-#endif
-}
-
-#ifdef HAS_4G_MODEM
-void UITask::gotoSMSScreen() {
-  SMSScreen* smsScr = (SMSScreen*)sms_screen;
-  smsScr->activate();
-  setCurrScreen(sms_screen);
-  if (_display != NULL && !_display->isOn()) {
-    _display->turnOn();
-  }
-  _auto_off = millis() + AUTO_OFF_MILLIS;
-  _next_refresh = 100;
-}
-#endif
-
 uint8_t UITask::getChannelScreenViewIdx() const {
  return ((ChannelScreen *) channel_screen)->getViewChannelIdx();
 }

-int UITask::getUnreadMsgCount() const {
-  return ((ChannelScreen *) channel_screen)->getTotalUnread();
-}
-
 void UITask::addSentChannelMessage(uint8_t channel_idx, const char* sender, const char* text) {
  // Format the message as "Sender: message"
  char formattedMsg[CHANNEL_MSG_TEXT_LEN];
@@ -1484,96 +1236,4 @@ void UITask::addSentChannelMessage(uint8_t channel_idx, const char* sender, cons
  
  // Add to channel history with path_len=0 (local message)
  ((ChannelScreen *) channel_screen)->addMessage(channel_idx, 0, sender, formattedMsg);
-}
-
-void UITask::markChannelReadFromBLE(uint8_t channel_idx) {
-  ((ChannelScreen *) channel_screen)->markChannelRead(channel_idx);
-  // Trigger a refresh so the home screen unread count updates in real-time
-  _next_refresh = millis() + 200;
-}
-
-void UITask::gotoRepeaterAdmin(int contactIdx) {
-  // Lazy-initialize on first use (same pattern as audiobook player)
-  if (repeater_admin == nullptr) {
-    repeater_admin = new RepeaterAdminScreen(this, &rtc_clock);
-  }
-
-  // Get contact name for the screen header
-  ContactInfo contact;
-  char name[32] = "Unknown";
-  if (the_mesh.getContactByIdx(contactIdx, contact)) {
-    strncpy(name, contact.name, sizeof(name) - 1);
-    name[sizeof(name) - 1] = '\0';
-  }
-
-  RepeaterAdminScreen* admin = (RepeaterAdminScreen*)repeater_admin;
-  admin->openForContact(contactIdx, name);
-  setCurrScreen(repeater_admin);
-
-  if (_display != NULL && !_display->isOn()) {
-    _display->turnOn();
-  }
-  _auto_off = millis() + AUTO_OFF_MILLIS;
-  _next_refresh = 100;
-}
-
-#ifdef MECK_WEB_READER
-void UITask::gotoWebReader() {
-  // Lazy-initialize on first use (same pattern as audiobook player)
-  if (web_reader == nullptr) {
-    Serial.printf("WebReader: lazy init - free heap: %d, largest block: %d\n",
-                   ESP.getFreeHeap(), ESP.getMaxAllocHeap());
-    web_reader = new WebReaderScreen(this);
-    Serial.printf("WebReader: init complete - free heap: %d\n", ESP.getFreeHeap());
-  }
-  WebReaderScreen* wr = (WebReaderScreen*)web_reader;
-  if (_display != NULL) {
-    wr->enter(*_display);
-  }
-  // Heap diagnostic — check state after web reader entry (WiFi connects later)
-  Serial.printf("[HEAP] WebReader enter - free: %u, largest: %u, PSRAM: %u\n",
-      ESP.getFreeHeap(), ESP.getMaxAllocHeap(), ESP.getFreePsram());
-  setCurrScreen(web_reader);
-  if (_display != NULL && !_display->isOn()) {
-    _display->turnOn();
-  }
-  _auto_off = millis() + AUTO_OFF_MILLIS;
-  _next_refresh = 100;
-}
-#endif
-
-void UITask::onAdminLoginResult(bool success, uint8_t permissions, uint32_t server_time) {
-  if (repeater_admin && isOnRepeaterAdmin()) {
-    ((RepeaterAdminScreen*)repeater_admin)->onLoginResult(success, permissions, server_time);
-    _next_refresh = 100;  // trigger re-render
-  }
-}
-
-void UITask::onAdminCliResponse(const char* from_name, const char* text) {
-  if (repeater_admin && isOnRepeaterAdmin()) {
-    ((RepeaterAdminScreen*)repeater_admin)->onCliResponse(text);
-    _next_refresh = 100;  // trigger re-render
-  }
-}
-
-void UITask::onAdminTelemetryResult(const uint8_t* data, uint8_t len) {
-  Serial.printf("[UITask] onAdminTelemetryResult: %d bytes, onAdmin=%d\n", len, isOnRepeaterAdmin());
-  if (repeater_admin && isOnRepeaterAdmin()) {
-    ((RepeaterAdminScreen*)repeater_admin)->onTelemetryResult(data, len);
-    _next_refresh = 100;  // trigger re-render
-  }
-}
-
-#ifdef MECK_AUDIO_VARIANT
-bool UITask::isAudioPlayingInBackground() const {
-  if (!audiobook_screen) return false;
-  AudiobookPlayerScreen* player = (AudiobookPlayerScreen*)audiobook_screen;
-  return player->isAudioActive();
-}
-
-bool UITask::isAudioPausedInBackground() const {
-  if (!audiobook_screen) return false;
-  AudiobookPlayerScreen* player = (AudiobookPlayerScreen*)audiobook_screen;
-  return player->isBookOpen() && !player->isAudioActive();
-}
-#endif
+}
--- a/examples/companion_radio/ui-new/UITask.h
+++ b/examples/companion_radio/ui-new/UITask.h
@@ -22,14 +22,6 @@
 #include "../AbstractUITask.h"
 #include "../NodePrefs.h"

-#ifdef HAS_4G_MODEM
-  #include "SMSScreen.h"
-#endif
-
-#ifdef MECK_WEB_READER
-  #include "WebReaderScreen.h"
-#endif
-
 class UITask : public AbstractUITask {
  DisplayDriver* _display;
  SensorManager* _sensors;
@@ -40,7 +32,6 @@ class UITask : public AbstractUITask {
  GenericVibration vibration;
 #endif
  unsigned long _next_refresh, _auto_off;
-  unsigned long _kb_flash_off_at;          // Keyboard flash turn-off timer
  NodePrefs* _node_prefs;
  char _alert[80];
  unsigned long _alert_expiry;
@@ -65,14 +56,6 @@ class UITask : public AbstractUITask {
  UIScreen* text_reader;     // *** NEW: Text reader screen ***
  UIScreen* notes_screen;    // Notes editor screen
  UIScreen* settings_screen; // Settings/onboarding screen
-  UIScreen* audiobook_screen; // Audiobook player screen (null if not available)
-#ifdef HAS_4G_MODEM
-  UIScreen* sms_screen;      // SMS messaging screen (4G variant only)
-#endif
-  UIScreen* repeater_admin;   // Repeater admin screen
-#ifdef MECK_WEB_READER
-  UIScreen* web_reader;       // Web reader screen (lazy-init, WiFi required)
-#endif
  UIScreen* curr;

  void userLedHandler();
@@ -89,7 +72,6 @@ public:

  UITask(mesh::MainBoard* board, BaseSerialInterface* serial) : AbstractUITask(board, serial), _display(NULL), _sensors(NULL) {
    next_batt_chck = _next_refresh = 0;
-    _kb_flash_off_at = 0;
    ui_started_at = 0;
    curr = NULL;
  }
@@ -102,26 +84,9 @@ public:
  void gotoNotesScreen();    // Navigate to notes editor
  void gotoSettingsScreen(); // Navigate to settings
  void gotoOnboarding();     // Navigate to settings in onboarding mode
-  void gotoAudiobookPlayer(); // Navigate to audiobook player
-  void gotoRepeaterAdmin(int contactIdx);  // Navigate to repeater admin
-#ifdef MECK_WEB_READER
-  void gotoWebReader();         // Navigate to web reader (browser)
-#endif
-#ifdef HAS_4G_MODEM
-  void gotoSMSScreen();
-  bool isOnSMSScreen() const { return curr == sms_screen; }
-  SMSScreen* getSMSScreen() const { return (SMSScreen*)sms_screen; }
-#endif
  void showAlert(const char* text, int duration_millis) override;
  void forceRefresh() override { _next_refresh = 100; }
-  // Wake display and extend auto-off timer. Call this when handling keys
-  // outside of injectKey() to prevent display auto-off during direct input.
-  void keepAlive() {
-    if (_display != NULL && !_display->isOn()) _display->turnOn();
-    _auto_off = millis() + 15000;  // matches AUTO_OFF_MILLIS default
-  }
  int  getMsgCount() const { return _msgcount; }
-  int  getUnreadMsgCount() const;  // Per-channel unread tracking (standalone)
  bool hasDisplay() const { return _display != NULL; }
  bool isButtonPressed() const;
  bool isOnChannelScreen() const { return curr == channel_screen; }
@@ -129,17 +94,6 @@ public:
  bool isOnTextReader() const { return curr == text_reader; }  // *** NEW ***
  bool isOnNotesScreen() const { return curr == notes_screen; }
  bool isOnSettingsScreen() const { return curr == settings_screen; }
-  bool isOnAudiobookPlayer() const { return curr == audiobook_screen; }
-  bool isOnRepeaterAdmin() const { return curr == repeater_admin; }
-#ifdef MECK_WEB_READER
-  bool isOnWebReader() const { return curr == web_reader; }
-#endif
-
-#ifdef MECK_AUDIO_VARIANT
-  // Check if audio is playing/paused in the background (for status indicators)
-  bool isAudioPlayingInBackground() const;
-  bool isAudioPausedInBackground() const;
-#endif
  uint8_t getChannelScreenViewIdx() const;

  void toggleBuzzer();
@@ -154,14 +108,6 @@ public:
  
  // Add a sent message to the channel screen history
  void addSentChannelMessage(uint8_t channel_idx, const char* sender, const char* text) override;
-
-  // Mark channel as read when BLE companion app syncs messages
-  void markChannelReadFromBLE(uint8_t channel_idx) override;
-
-  // Repeater admin callbacks
-  void onAdminLoginResult(bool success, uint8_t permissions, uint32_t server_time) override;
-  void onAdminCliResponse(const char* from_name, const char* text) override;
-  void onAdminTelemetryResult(const uint8_t* data, uint8_t len) override;
  
  // Get current screen for checking state
  UIScreen* getCurrentScreen() const { return curr; }
@@ -171,17 +117,10 @@ public:
  UIScreen* getContactsScreen() const { return contacts_screen; }
  UIScreen* getChannelScreen() const { return channel_screen; }
  UIScreen* getSettingsScreen() const { return settings_screen; }
-  UIScreen* getAudiobookScreen() const { return audiobook_screen; }
-  void setAudiobookScreen(UIScreen* s) { audiobook_screen = s; }
-  UIScreen* getRepeaterAdminScreen() const { return repeater_admin; }
-#ifdef MECK_WEB_READER
-  UIScreen* getWebReaderScreen() const { return web_reader; }
-#endif

  // from AbstractUITask
  void msgRead(int msgcount) override;
-  void newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount,
-             const uint8_t* path = nullptr) override;
+  void newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount) override;
  void notify(UIEventType t = UIEventType::none) override;
  void loop() override;

--- a/examples/companion_radio/ui-new/Webreaderscreen.h
+++ b/examples/companion_radio/ui-new/Webreaderscreen.h
--- a/examples/companion_radio/ui-new/emojipicker.h
+++ b/examples/companion_radio/ui-new/emojipicker.h
@@ -1,7 +1,7 @@
 #pragma once

 // Emoji Picker with scrolling grid and scroll bar
-// 5 columns, 4 visible rows, scrollable through all 65 emoji
+// 5 columns, 4 visible rows, scrollable through all 46 emoji
 // WASD navigation, Enter to select, $/Q/Backspace to cancel

 #include <helpers/ui/DisplayDriver.h>
@@ -58,25 +58,6 @@ static const char* EMOJI_LABELS[EMOJI_COUNT] = {
  "Knob",   // 43 control_knobs
  "Pch",    // 44 peach
  "Race",   // 45 racing_car
-  "Mous",   // 46 mouse
-  "Shrm",   // 47 mushroom
-  "Bio",    // 48 biohazard
-  "Pnda",   // 49 panda
-  "Bang",   // 50 anger
-  "DrgF",   // 51 dragon_face
-  "Pagr",   // 52 pager
-  "Bee",    // 53 bee
-  "Bulb",   // 54 bulb
-  "Cat",    // 55 cat
-  "Flur",   // 56 fleur
-  "Moon",   // 57 moon
-  "Cafe",   // 58 coffee
-  "Toth",   // 59 tooth
-  "Prtz",   // 60 pretzel
-  "Abac",   // 61 abacus
-  "Moai",   // 62 moai
-  "Hiii",   // 63 tipping
-  "Hedg",   // 64 hedgehog
 };

 struct EmojiPicker {
--- a/examples/companion_radio/ui-new/webreaderdeps.cpp
+++ b/examples/companion_radio/ui-new/webreaderdeps.cpp
@@ -1,16 +0,0 @@
-// WebReaderDeps.cpp
-// -----------------------------------------------------------------------
-// PlatformIO library dependency finder (LDF) hint file.
-//
-// The web reader's WiFi/HTTP includes live in WebReaderScreen.h (header-only),
-// but PlatformIO's LDF can't always trace framework library dependencies
-// through conditional #include chains in headers. This .cpp file exposes
-// the includes at the top level where the scanner reliably finds them.
-//
-// No actual code here — just #include directives for the dependency finder.
-// -----------------------------------------------------------------------
-#ifdef MECK_WEB_READER
-  #include <WiFi.h>
-  #include <HTTPClient.h>
-  #include <WiFiClientSecure.h>
-#endif
--- a/platformio.ini
+++ b/platformio.ini
@@ -27,7 +27,6 @@ build_flags = -w -DNDEBUG -DRADIOLIB_STATIC_ONLY=1 -DRADIOLIB_GODMODE=1
  -D LORA_FREQ=869.525
  -D LORA_BW=250
  -D LORA_SF=11
-  -D ENABLE_ADVERT_ON_BOOT=1
  -D ENABLE_PRIVATE_KEY_IMPORT=1   ; NOTE: comment these out for more secure firmware
  -D ENABLE_PRIVATE_KEY_EXPORT=1
  -D RADIOLIB_EXCLUDE_CC1101=1
@@ -59,7 +58,6 @@ platform = platformio/espressif32@6.11.0
 monitor_filters = esp32_exception_decoder
 extra_scripts = merge-bin.py
 build_flags = ${arduino_base.build_flags}
-  -D ESP32_PLATFORM
 ;  -D ESP32_CPU_FREQ=80          ; change it to your need
 build_src_filter = ${arduino_base.build_src_filter}

@@ -69,10 +67,10 @@ lib_deps =
  file://arch/esp32/AsyncElegantOTA

 ; esp32c6 uses arduino framework 3.x
-; WARNING: experimental. May not work as stable as other platforms.
+; WARNING: experimental. pioarduino on esp32c6 needs work - it's not considered stable and has issues.
 [esp32c6_base]
 extends = esp32_base
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/53.03.13-1/platform-espressif32.zip
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/53.03.12/platform-espressif32.zip

 ; ----------------- NRF52 ---------------------

@@ -81,7 +79,7 @@ extends = arduino_base
 platform = nordicnrf52
 platform_packages =
  framework-arduinoadafruitnrf52 @ 1.10700.0
-extra_scripts =
+extra_scripts = 
  create-uf2.py
  arch/nrf52/extra_scripts/patch_bluefruit.py
 build_flags = ${arduino_base.build_flags}
@@ -149,4 +147,4 @@ lib_deps =
  adafruit/Adafruit_VL53L0X @ ^1.2.4
  stevemarple/MicroNMEA @ ^2.0.6
  adafruit/Adafruit BME680 Library @ ^2.0.4
-  adafruit/Adafruit BMP085 Library @ ^1.2.4
+  adafruit/Adafruit BMP085 Library @ ^1.2.4
--- a/src/helpers/BaseChatMesh.h
+++ b/src/helpers/BaseChatMesh.h
@@ -58,9 +58,9 @@ class BaseChatMesh : public mesh::Mesh {

  friend class ContactsIterator;

-  ContactInfo* contacts;
+  ContactInfo contacts[MAX_CONTACTS];
  int num_contacts;
-  int* sort_array;
+  int sort_array[MAX_CONTACTS];
  int matching_peer_indexes[MAX_SEARCH_RESULTS];
  unsigned long txt_send_timeout;
 #ifdef MAX_GROUP_CHANNELS
@@ -78,8 +78,6 @@ protected:
  BaseChatMesh(mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::PacketManager& mgr, mesh::MeshTables& tables)
      : mesh::Mesh(radio, ms, rng, rtc, mgr, tables)
  { 
-    contacts = NULL;
-    sort_array = NULL;
    num_contacts = 0;
  #ifdef MAX_GROUP_CHANNELS
    memset(channels, 0, sizeof(channels));
@@ -92,19 +90,6 @@ protected:

  void bootstrapRTCfromContacts();
  void resetContacts() { num_contacts = 0; }
-
-  // Must be called from begin() before loadContacts/bootstrapRTCfromContacts.
-  // Deferred from constructor because PSRAM is not available during global init.
-  void initContacts() {
-    if (contacts != NULL) return;  // already initialized
-  #if defined(ESP32) && defined(BOARD_HAS_PSRAM)
-    contacts = (ContactInfo*)ps_calloc(MAX_CONTACTS, sizeof(ContactInfo));
-    sort_array = (int*)ps_calloc(MAX_CONTACTS, sizeof(int));
-  #else
-    contacts = new ContactInfo[MAX_CONTACTS]();
-    sort_array = new int[MAX_CONTACTS]();
-  #endif
-  }
  void populateContactFromAdvert(ContactInfo& ci, const mesh::Identity& id, const AdvertDataParser& parser, uint32_t timestamp);
  ContactInfo* allocateContactSlot(); // helper to find slot for new contact

@@ -184,4 +169,4 @@ public:
  int findChannelIdx(const mesh::GroupChannel& ch);

  void loop();
-};
+};
--- a/src/helpers/esp32/SerialBLEInterface.cpp
+++ b/src/helpers/esp32/SerialBLEInterface.cpp
@@ -147,21 +147,15 @@ void SerialBLEInterface::enable() {
 }

 void SerialBLEInterface::disable() {
-  bool wasEnabled = _isEnabled;
  _isEnabled = false;

  BLE_DEBUG_PRINTLN("SerialBLEInterface::disable");

-  // Only try BLE operations if we were previously enabled
-  // (avoids accessing dead BLE objects after btStop/mem_release)
-  if (wasEnabled && pServer) {
-    pServer->getAdvertising()->stop();
-    pServer->disconnect(last_conn_id);
-    pService->stop();
-  }
+  pServer->getAdvertising()->stop();
+  pServer->disconnect(last_conn_id);
+  pService->stop();
  oldDeviceConnected = deviceConnected = false;
  adv_restart_time = 0;
-  clearBuffers();
 }

 size_t SerialBLEInterface::writeFrame(const uint8_t src[], size_t len) {
@@ -192,8 +186,6 @@ bool SerialBLEInterface::isWriteBusy() const {
 }

 size_t SerialBLEInterface::checkRecvFrame(uint8_t dest[]) {
-  if (!_isEnabled) return 0;  // BLE disabled — skip all BLE operations
-
  if (send_queue_len > 0   // first, check send queue
    && millis() >= _last_write + BLE_WRITE_MIN_INTERVAL    // space the writes apart
  ) {
--- a/variants/lilygo_tdeck_pro/TDeckBoard.cpp
+++ b/variants/lilygo_tdeck_pro/TDeckBoard.cpp
@@ -72,11 +72,10 @@ void TDeckBoard::begin() {
    rtc_gpio_deinit((gpio_num_t)P_LORA_DIO_1);
  }
  
-  // Test BQ27220 communication and configure design capacity
+  // Test BQ27220 communication
  #if HAS_BQ27220
    uint16_t voltage = getBattMilliVolts();
    MESH_DEBUG_PRINTLN("TDeckBoard::begin() - Battery voltage: %d mV", voltage);
-    configureFuelGauge();
  #endif
  
  MESH_DEBUG_PRINTLN("TDeckBoard::begin() - complete");
@@ -124,357 +123,4 @@ uint8_t TDeckBoard::getBatteryPercent() {
  #else
    return 0;
  #endif
-}
-
-// ---- BQ27220 extended register helpers ----
-
-#if HAS_BQ27220
-// Read a 16-bit register from BQ27220. Returns 0 on I2C error.
-static uint16_t bq27220_read16(uint8_t reg) {
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(reg);
-  if (Wire.endTransmission(false) != 0) return 0;
-  if (Wire.requestFrom((uint8_t)BQ27220_I2C_ADDR, (uint8_t)2) != 2) return 0;
-  uint16_t val = Wire.read();
-  val |= (Wire.read() << 8);
-  return val;
-}
-
-// Read a single byte from BQ27220 register.
-static uint8_t bq27220_read8(uint8_t reg) {
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(reg);
-  if (Wire.endTransmission(false) != 0) return 0;
-  if (Wire.requestFrom((uint8_t)BQ27220_I2C_ADDR, (uint8_t)1) != 1) return 0;
-  return Wire.read();
-}
-
-// Write a 16-bit subcommand to BQ27220 Control register (0x00).
-// Subcommands control unsealing, config mode, sealing, etc.
-static bool bq27220_writeControl(uint16_t subcmd) {
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(0x00);                    // Control register
-  Wire.write(subcmd & 0xFF);           // LSB first
-  Wire.write((subcmd >> 8) & 0xFF);    // MSB
-  return Wire.endTransmission() == 0;
-}
-#endif
-
-// ---- BQ27220 Design Capacity configuration ----
-// The BQ27220 ships with a 3000 mAh default. The T-Deck Pro uses a 1400 mAh
-// cell. This function checks on boot and writes the correct value via the
-// MAC Data Memory interface if needed. The value persists in battery-backed
-// RAM, so this typically only writes once (or after a full battery disconnect).
-//
-// Procedure follows TI TRM SLUUBD4A Section 6.1:
-//   1. Unseal  â†’  2. Full Access  â†’  3. Enter CFG_UPDATE
-//   4. Write Design Capacity via MAC  â†’  5. Exit CFG_UPDATE  â†’  6. Seal
-
-bool TDeckBoard::configureFuelGauge(uint16_t designCapacity_mAh) {
-#if HAS_BQ27220
-  // Read current design capacity from standard command register
-  uint16_t currentDC = bq27220_read16(BQ27220_REG_DESIGN_CAP);
-  Serial.printf("BQ27220: Design Capacity = %d mAh (target %d)\n", currentDC, designCapacity_mAh);
-
-  if (currentDC == designCapacity_mAh) {
-    // Design Capacity correct, but check if Full Charge Capacity is sane.
-    // After a Design Capacity change, FCC may still hold the old factory
-    // value (e.g. 3000 mAh) until a RESET forces reinitialization.
-    uint16_t fcc = bq27220_read16(BQ27220_REG_FULL_CAP);
-    Serial.printf("BQ27220: Design Capacity already correct, FCC=%d mAh\n", fcc);
-    if (fcc >= designCapacity_mAh * 3 / 2) {
-      // FCC is >=150% of design — stale from factory defaults.
-      // The gauge derives FCC from Design Energy (not just Design Capacity).
-      // Design Energy = capacity × nominal voltage (3.7V for LiPo).
-      // If Design Energy still reflects 3000 mAh, FCC stays at 3000.
-      // Fix: enter CFG_UPDATE and write correct Design Energy.
-      Serial.printf("BQ27220: FCC %d >> DC %d, updating Design Energy\n",
-                    fcc, designCapacity_mAh);
-
-      uint16_t designEnergy = (uint16_t)((uint32_t)designCapacity_mAh * 37 / 10);
-      Serial.printf("BQ27220: Target Design Energy = %d mWh\n", designEnergy);
-
-      // Unseal
-      bq27220_writeControl(0x0414); delay(2);
-      bq27220_writeControl(0x3672); delay(2);
-      // Full Access
-      bq27220_writeControl(0xFFFF); delay(2);
-      bq27220_writeControl(0xFFFF); delay(2);
-      // Enter CFG_UPDATE
-      bq27220_writeControl(0x0090);
-      bool ready = false;
-      for (int i = 0; i < 50; i++) {
-        delay(20);
-        uint16_t opSt = bq27220_read16(BQ27220_REG_OP_STATUS);
-        if (opSt & 0x0400) { ready = true; break; }
-      }
-      if (ready) {
-        // Design Energy is at data memory address 0x92A1 (2 bytes after DC at 0x929F)
-        // Read old values for checksum calculation
-        Wire.beginTransmission(BQ27220_I2C_ADDR);
-        Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
-        Wire.endTransmission();
-        delay(10);
-        uint8_t oldMSB = bq27220_read8(0x40);
-        uint8_t oldLSB = bq27220_read8(0x41);
-        uint8_t oldChk = bq27220_read8(0x60);
-        uint8_t dLen   = bq27220_read8(0x61);
-
-        uint8_t newMSB = (designEnergy >> 8) & 0xFF;
-        uint8_t newLSB = designEnergy & 0xFF;
-        uint8_t temp = (255 - oldChk - oldMSB - oldLSB);
-        uint8_t newChk = 255 - ((temp + newMSB + newLSB) & 0xFF);
-
-        Serial.printf("BQ27220: DE old=0x%02X%02X new=0x%02X%02X chk=0x%02X\n",
-                      oldMSB, oldLSB, newMSB, newLSB, newChk);
-
-        // Write new Design Energy
-        Wire.beginTransmission(BQ27220_I2C_ADDR);
-        Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
-        Wire.write(newMSB); Wire.write(newLSB);
-        Wire.endTransmission();
-        delay(5);
-        // Write checksum
-        Wire.beginTransmission(BQ27220_I2C_ADDR);
-        Wire.write(0x60); Wire.write(newChk); Wire.write(dLen);
-        Wire.endTransmission();
-        delay(10);
-
-        // Exit CFG_UPDATE with reinit
-        bq27220_writeControl(0x0091);
-        delay(200);
-        Serial.println("BQ27220: Design Energy updated, exited CFG_UPDATE");
-      } else {
-        Serial.println("BQ27220: Failed to enter CFG_UPDATE for DE fix");
-        bq27220_writeControl(0x0092);  // Exit cleanly
-      }
-
-      // Seal
-      bq27220_writeControl(0x0030);
-      delay(5);
-
-      fcc = bq27220_read16(BQ27220_REG_FULL_CAP);
-      Serial.printf("BQ27220: FCC after Design Energy update: %d mAh\n", fcc);
-    }
-    return true;
-  }
-
-  Serial.printf("BQ27220: Updating Design Capacity from %d to %d mAh\n", currentDC, designCapacity_mAh);
-
-  // Step 1: Unseal (default unseal keys)
-  bq27220_writeControl(0x0414);
-  delay(2);
-  bq27220_writeControl(0x3672);
-  delay(2);
-
-  // Step 2: Enter Full Access mode
-  bq27220_writeControl(0xFFFF);
-  delay(2);
-  bq27220_writeControl(0xFFFF);
-  delay(2);
-
-  // Step 3: Enter CFG_UPDATE mode
-  bq27220_writeControl(0x0090);
-
-  // Wait for CFGUPMODE bit (bit 10) in OperationStatus register
-  bool cfgReady = false;
-  for (int i = 0; i < 50; i++) {
-    delay(20);
-    uint16_t opStatus = bq27220_read16(BQ27220_REG_OP_STATUS);
-    Serial.printf("BQ27220: OperationStatus = 0x%04X (attempt %d)\n", opStatus, i);
-    if (opStatus & 0x0400) {  // CFGUPMODE is bit 10
-      cfgReady = true;
-      break;
-    }
-  }
-  if (!cfgReady) {
-    Serial.println("BQ27220: ERROR - Timeout waiting for CFGUPDATE mode");
-    bq27220_writeControl(0x0092);  // Try to exit cleanly
-    bq27220_writeControl(0x0030);  // Re-seal
-    return false;
-  }
-  Serial.println("BQ27220: Entered CFGUPDATE mode");
-
-  // Step 4: Write Design Capacity via MAC Data Memory interface
-  // Design Capacity mAh lives at data memory address 0x929F
-
-  // 4a. Select the data memory block by writing address to 0x3E-0x3F
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(0x3E);   // MACDataControl register
-  Wire.write(0x9F);   // Address low byte
-  Wire.write(0x92);   // Address high byte
-  Wire.endTransmission();
-  delay(10);
-
-  // 4b. Read old data (MSB, LSB) and checksum for differential update
-  uint8_t oldMSB     = bq27220_read8(0x40);
-  uint8_t oldLSB     = bq27220_read8(0x41);
-  uint8_t oldChksum  = bq27220_read8(0x60);
-  uint8_t dataLen    = bq27220_read8(0x61);
-
-  Serial.printf("BQ27220: Old DC bytes=0x%02X 0x%02X chk=0x%02X len=%d\n",
-                     oldMSB, oldLSB, oldChksum, dataLen);
-
-  // 4c. Compute new values (BQ27220 stores big-endian in data memory)
-  uint8_t newMSB = (designCapacity_mAh >> 8) & 0xFF;
-  uint8_t newLSB = designCapacity_mAh & 0xFF;
-
-  // Differential checksum: remove old bytes, add new bytes
-  uint8_t temp = (255 - oldChksum - oldMSB - oldLSB);
-  uint8_t newChksum = 255 - ((temp + newMSB + newLSB) & 0xFF);
-
-  Serial.printf("BQ27220: New DC bytes=0x%02X 0x%02X chk=0x%02X\n",
-                     newMSB, newLSB, newChksum);
-
-  // 4d. Write address + new data as a single block transaction
-  //     BQ27220 MAC requires: [0x3E] [addr_lo] [addr_hi] [data...]
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(0x3E);    // Start at MACDataControl
-  Wire.write(0x9F);    // Address low byte
-  Wire.write(0x92);    // Address high byte
-  Wire.write(newMSB);  // Data byte 0 (at 0x40)
-  Wire.write(newLSB);  // Data byte 1 (at 0x41)
-  uint8_t writeResult = Wire.endTransmission();
-  Serial.printf("BQ27220: Write block result = %d\n", writeResult);
-
-  // 4e. Write updated checksum and length
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(0x60);
-  Wire.write(newChksum);
-  Wire.write(dataLen);
-  writeResult = Wire.endTransmission();
-  Serial.printf("BQ27220: Write checksum result = %d\n", writeResult);
-  delay(10);
-
-  // 4f. Verify the write took effect before exiting config mode
-  //     Re-read the block to confirm
-  Wire.beginTransmission(BQ27220_I2C_ADDR);
-  Wire.write(0x3E);
-  Wire.write(0x9F);
-  Wire.write(0x92);
-  Wire.endTransmission();
-  delay(10);
-  uint8_t verMSB = bq27220_read8(0x40);
-  uint8_t verLSB = bq27220_read8(0x41);
-  Serial.printf("BQ27220: Verify in CFGUPDATE: DC bytes=0x%02X 0x%02X (%d mAh)\n",
-                     verMSB, verLSB, (verMSB << 8) | verLSB);
-
-  // Step 4g: Also update Design Energy (address 0x92A1) while in CFG_UPDATE.
-  // Design Energy = capacity × 3.7V (nominal LiPo voltage).
-  // The gauge uses both DC and DE to compute Full Charge Capacity.
-  {
-    uint16_t designEnergy = (uint16_t)((uint32_t)designCapacity_mAh * 37 / 10);
-    Wire.beginTransmission(BQ27220_I2C_ADDR);
-    Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
-    Wire.endTransmission();
-    delay(10);
-    uint8_t deOldMSB = bq27220_read8(0x40);
-    uint8_t deOldLSB = bq27220_read8(0x41);
-    uint8_t deOldChk = bq27220_read8(0x60);
-    uint8_t deLen    = bq27220_read8(0x61);
-
-    uint8_t deNewMSB = (designEnergy >> 8) & 0xFF;
-    uint8_t deNewLSB = designEnergy & 0xFF;
-    uint8_t deTemp = (255 - deOldChk - deOldMSB - deOldLSB);
-    uint8_t deNewChk = 255 - ((deTemp + deNewMSB + deNewLSB) & 0xFF);
-
-    Serial.printf("BQ27220: Design Energy: old=%d new=%d mWh\n",
-                  (deOldMSB << 8) | deOldLSB, designEnergy);
-
-    Wire.beginTransmission(BQ27220_I2C_ADDR);
-    Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
-    Wire.write(deNewMSB); Wire.write(deNewLSB);
-    Wire.endTransmission();
-    delay(5);
-    Wire.beginTransmission(BQ27220_I2C_ADDR);
-    Wire.write(0x60); Wire.write(deNewChk); Wire.write(deLen);
-    Wire.endTransmission();
-    delay(10);
-  }
-
-  // Step 5: Exit CFG_UPDATE (with reinit to apply changes immediately)
-  bq27220_writeControl(0x0091);  // EXIT_CFG_UPDATE_REINIT
-  Serial.println("BQ27220: Sent EXIT_CFG_UPDATE_REINIT, waiting...");
-  delay(200);  // Allow gauge to reinitialize
-
-  // Verify
-  uint16_t verifyDC = bq27220_read16(BQ27220_REG_DESIGN_CAP);
-  Serial.printf("BQ27220: Design Capacity now reads %d mAh (expected %d)\n",
-                     verifyDC, designCapacity_mAh);
-
-  uint16_t newFCC = bq27220_read16(BQ27220_REG_FULL_CAP);
-  Serial.printf("BQ27220: Full Charge Capacity: %d mAh\n", newFCC);
-
-  if (verifyDC == designCapacity_mAh) {
-    Serial.println("BQ27220: Configuration SUCCESS");
-  } else {
-    Serial.println("BQ27220: Configuration FAILED");
-  }
-
-  // Step 6: Seal the device
-  bq27220_writeControl(0x0030);
-  delay(5);
-
-  return verifyDC == designCapacity_mAh;
-#else
-  return false;
-#endif
-}
-
-int16_t TDeckBoard::getAvgCurrent() {
-  #if HAS_BQ27220
-    return (int16_t)bq27220_read16(BQ27220_REG_AVG_CURRENT);
-  #else
-    return 0;
-  #endif
-}
-
-int16_t TDeckBoard::getAvgPower() {
-  #if HAS_BQ27220
-    return (int16_t)bq27220_read16(BQ27220_REG_AVG_POWER);
-  #else
-    return 0;
-  #endif
-}
-
-uint16_t TDeckBoard::getTimeToEmpty() {
-  #if HAS_BQ27220
-    return bq27220_read16(BQ27220_REG_TIME_TO_EMPTY);
-  #else
-    return 0xFFFF;
-  #endif
-}
-
-uint16_t TDeckBoard::getRemainingCapacity() {
-  #if HAS_BQ27220
-    return bq27220_read16(BQ27220_REG_REMAIN_CAP);
-  #else
-    return 0;
-  #endif
-}
-
-uint16_t TDeckBoard::getFullChargeCapacity() {
-  #if HAS_BQ27220
-    return bq27220_read16(BQ27220_REG_FULL_CAP);
-  #else
-    return 0;
-  #endif
-}
-
-uint16_t TDeckBoard::getDesignCapacity() {
-  #if HAS_BQ27220
-    return bq27220_read16(BQ27220_REG_DESIGN_CAP);
-  #else
-    return 0;
-  #endif
-}
-
-int16_t TDeckBoard::getBattTemperature() {
-  #if HAS_BQ27220
-    uint16_t raw = bq27220_read16(BQ27220_REG_TEMPERATURE);
-    // BQ27220 returns 0.1°K, convert to 0.1°C (273.1K = 0°C)
-    return (int16_t)(raw - 2731);
-  #else
-    return 0;
-  #endif
 }
--- a/variants/lilygo_tdeck_pro/TDeckBoard.h
+++ b/variants/lilygo_tdeck_pro/TDeckBoard.h
@@ -7,24 +7,11 @@
 #include <driver/rtc_io.h>

 // BQ27220 Fuel Gauge Registers
-#define BQ27220_REG_TEMPERATURE    0x06  // Temperature (0.1°K)
-#define BQ27220_REG_VOLTAGE        0x08
-#define BQ27220_REG_CURRENT        0x0C  // Instantaneous current (mA, signed)
-#define BQ27220_REG_SOC            0x2C
-#define BQ27220_REG_REMAIN_CAP     0x10  // Remaining capacity (mAh)
-#define BQ27220_REG_FULL_CAP       0x12  // Full charge capacity (mAh)
-#define BQ27220_REG_AVG_CURRENT    0x14  // Average current (mA, signed)
-#define BQ27220_REG_TIME_TO_EMPTY  0x16  // Minutes until empty
-#define BQ27220_REG_AVG_POWER      0x24  // Average power (mW, signed)
-#define BQ27220_REG_DESIGN_CAP     0x3C  // Design capacity (mAh, read-only standard cmd)
-#define BQ27220_REG_OP_STATUS      0x3A  // Operation status
+#define BQ27220_REG_VOLTAGE 0x08
+#define BQ27220_REG_CURRENT 0x0C
+#define BQ27220_REG_SOC 0x2C
 #define BQ27220_I2C_ADDR 0x55

-// T-Deck Pro battery capacity (all variants use 1400 mAh cell)
-#ifndef BQ27220_DESIGN_CAPACITY_MAH
-#define BQ27220_DESIGN_CAPACITY_MAH  1400
-#endif
-
 class TDeckBoard : public ESP32Board {
 public:
  void begin();
@@ -65,30 +52,6 @@ public:
  // Read state of charge percentage from BQ27220
  uint8_t getBatteryPercent();

-  // Read average current in mA (negative = discharging, positive = charging)
-  int16_t getAvgCurrent();
-
-  // Read average power in mW (negative = discharging, positive = charging)
-  int16_t getAvgPower();
-
-  // Read time-to-empty in minutes (0xFFFF if charging/unavailable)
-  uint16_t getTimeToEmpty();
-
-  // Read remaining capacity in mAh
-  uint16_t getRemainingCapacity();
-
-  // Read full charge capacity in mAh (learned value, may need cycling to update)
-  uint16_t getFullChargeCapacity();
-
-  // Read design capacity in mAh (the configured battery size)
-  uint16_t getDesignCapacity();
-
-  // Read battery temperature in 0.1°C units (e.g., 256 = 25.6°C)
-  int16_t getBattTemperature();
-
-  // Configure BQ27220 design capacity (checks on boot, writes only if wrong)
-  bool configureFuelGauge(uint16_t designCapacity_mAh = BQ27220_DESIGN_CAPACITY_MAH);
-
  const char* getManufacturerName() const {
    return "LilyGo T-Deck Pro";
  }
--- a/variants/lilygo_tdeck_pro/Tca8418keyboard.h
+++ b/variants/lilygo_tdeck_pro/Tca8418keyboard.h
@@ -256,12 +256,14 @@ public:
      return KB_KEY_EMOJI;
    }
    
-    // Handle Mic key - always produces '0' (silk-screened on key)
-    // Sym+Mic also produces '0' (consumes sym so it doesn't leak)
+    // Handle Mic key - produces 0 with Sym, otherwise ignore
    if (keyCode == 34) {
-      _symActive = false;
-      Serial.println("KB: Mic -> '0'");
-      return '0';
+      if (_symActive) {
+        _symActive = false;
+        Serial.println("KB: Sym+Mic -> '0'");
+        return '0';
+      }
+      return 0;  // Ignore mic without Sym
    }

    // Get the character
--- a/variants/lilygo_tdeck_pro/platformio.ini
+++ b/variants/lilygo_tdeck_pro/platformio.ini
@@ -80,7 +80,7 @@ build_flags =
  -D PIN_DISPLAY_BL=45
  -D PIN_USER_BTN=0
  -D CST328_PIN_RST=38
-  -D ARDUINO_LOOP_STACK_SIZE=32768
+  -D FIRMWARE_VERSION='"Meck v0.8.7"'
 build_src_filter = ${esp32_base.build_src_filter}
  +<../variants/LilyGo_TDeck_Pro>
  +<helpers/sensors/*.cpp>
@@ -91,73 +91,33 @@ lib_deps =
  adafruit/Adafruit GFX Library@^1.11.0
  bakercp/CRC32@^2.0.0

-; ---------------------------------------------------------------------------
-; Meck unified builds — one codebase, three variants via build flags
-; ---------------------------------------------------------------------------
-
-; Audio + BLE companion (audio-player hardware with BLE phone bridging)
-; MAX_CONTACTS=500 is near BLE protocol ceiling (MAX_CONTACTS/2 sent as uint8_t, max 510)
-[env:meck_audio_ble]
+[env:LilyGo_TDeck_Pro_companion_radio_usb]
 extends = LilyGo_TDeck_Pro
 build_flags =
  ${LilyGo_TDeck_Pro.build_flags}
  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=500
+  -D MAX_CONTACTS=350
+  -D MAX_GROUP_CHANNELS=40
+  -D OFFLINE_QUEUE_SIZE=256
+build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/MomentaryButton.cpp>
+  +<../examples/companion_radio/*.cpp>
+  +<../examples/companion_radio/ui-new/*.cpp>
+  +<helpers/ui/GxEPDDisplay.cpp>
+lib_deps =
+  ${LilyGo_TDeck_Pro.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:LilyGo_TDeck_Pro_companion_radio_ble]
+extends = LilyGo_TDeck_Pro
+build_flags =
+  ${LilyGo_TDeck_Pro.build_flags}
+  -I examples/companion_radio/ui-new
+  -D MAX_CONTACTS=400
  -D MAX_GROUP_CHANNELS=20
  -D BLE_PIN_CODE=123456
  -D OFFLINE_QUEUE_SIZE=256
-  -D MECK_AUDIO_VARIANT
-  -D MECK_WEB_READER=1
-build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<helpers/ui/MomentaryButton.cpp>
-  +<../examples/companion_radio/*.cpp>
-  +<../examples/companion_radio/ui-new/*.cpp>
-  +<helpers/ui/GxEPDDisplay.cpp>
-lib_deps =
-  ${LilyGo_TDeck_Pro.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-  https://github.com/schreibfaul1/ESP32-audioI2S.git#2.0.6
-  bitbank2/JPEGDEC
-
-; Audio standalone (audio-player hardware, no BLE/WiFi — maximum battery life)
-; No MECK_WEB_READER: WiFi power draw conflicts with zero-radio-power design.
-; Contacts and sort arrays allocated in PSRAM — 1500 contacts uses ~290KB of 8MB.
-[env:meck_audio_standalone]
-extends = LilyGo_TDeck_Pro
-build_flags =
-  ${LilyGo_TDeck_Pro.build_flags}
-  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=1500
-  -D MAX_GROUP_CHANNELS=20
-  -D OFFLINE_QUEUE_SIZE=256
-  -D MECK_AUDIO_VARIANT
-build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<helpers/ui/MomentaryButton.cpp>
-  +<../examples/companion_radio/*.cpp>
-  +<../examples/companion_radio/ui-new/*.cpp>
-  +<helpers/ui/GxEPDDisplay.cpp>
-lib_deps =
-  ${LilyGo_TDeck_Pro.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-  https://github.com/schreibfaul1/ESP32-audioI2S.git#2.0.6
-  bitbank2/JPEGDEC
-
-; 4G + BLE companion (4G modem hardware, no audio — GPIO conflict with PCM5102A)
-; MAX_CONTACTS=500 is near BLE protocol ceiling (MAX_CONTACTS/2 sent as uint8_t, max 510)
-[env:meck_4g_ble]
-extends = LilyGo_TDeck_Pro
-build_flags =
-  ${LilyGo_TDeck_Pro.build_flags}
-  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=500
-  -D MAX_GROUP_CHANNELS=20
-  -D BLE_PIN_CODE=123456
-  -D OFFLINE_QUEUE_SIZE=256
-  -D HAS_4G_MODEM=1
-  -D MECK_WEB_READER=1
-  -D FIRMWARE_VERSION='"Meck v0.9.5.4G"'
 build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
  +<helpers/esp32/*.cpp>
  +<helpers/ui/MomentaryButton.cpp>
@@ -168,28 +128,20 @@ lib_deps =
  ${LilyGo_TDeck_Pro.lib_deps}
  densaugeo/base64 @ ~1.4.0

-; 4G standalone (4G modem hardware, no BLE — maximum battery + cellular features)
-; No BLE_PIN_CODE: BLE never initializes, saving ~30KB heap + radio power.
-; MECK_WEB_READER enabled: works better without BLE (no teardown dance needed,
-; more free heap from boot). WiFi-first with cellular PPP fallback (future).
-; Contacts and sort arrays allocated in PSRAM — 1500 contacts uses ~290KB of 8MB.
-[env:meck_4g_standalone]
+[env:LilyGo_TDeck_Pro_repeater]
 extends = LilyGo_TDeck_Pro
 build_flags =
  ${LilyGo_TDeck_Pro.build_flags}
-  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=1500
-  -D MAX_GROUP_CHANNELS=20
-  -D OFFLINE_QUEUE_SIZE=256
-  -D HAS_4G_MODEM=1
-  -D MECK_WEB_READER=1
-  -D FIRMWARE_VERSION='"Meck v0.9.5.4G.SA"'
+  -D ADVERT_NAME='"TDeck Pro Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D MAX_NEIGHBOURS=50
+  -D NO_OTA=1
 build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<helpers/ui/MomentaryButton.cpp>
-  +<../examples/companion_radio/*.cpp>
-  +<../examples/companion_radio/ui-new/*.cpp>
+  +<../examples/simple_repeater>
  +<helpers/ui/GxEPDDisplay.cpp>
 lib_deps =
  ${LilyGo_TDeck_Pro.lib_deps}
-  densaugeo/base64 @ ~1.4.0
+  me-no-dev/AsyncTCP @ ^1.1.1
+  me-no-dev/ESPAsyncWebServer @ ^1.2.3