updated readme

standalone device phase 1 complete - utc offset from gps homepage and gps timesync without ble enabled
repeater admin password persistence after successful login enabled
2026-02-10 16:04:03 +11:00 · 2026-02-10 15:59:34 +11:00 · 2026-02-10 15:12:29 +11:00 · 2026-02-10 15:10:59 +11:00 · 2026-02-10 15:06:48 +11:00 · 2026-02-10 14:59:30 +11:00
34 changed files with 8397 additions and 1708 deletions
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,4 +1,6 @@
 {
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
    "recommendations": [
        "pioarduino.pioarduino-ide",
        "platformio.platformio-ide"
--- a/README.md
+++ b/README.md
@@ -1,24 +1,167 @@
+## 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.*** ⭐
+
+## T-Deck Pro Keyboard Controls
+
+The T-Deck Pro BLE companion firmware includes full keyboard support for standalone messaging without a phone.
+
+### Navigation (Home Screen)
+
+| Key | Action |
+|-----|--------|
+| W / A | Previous page |
+| S / D | Next page |
+| Enter | Select / Confirm |
+| M | Open channel messages |
+| N | Open contacts list |
+| R | Open e-book reader |
+| Q | Back to home screen |
+
+### Bluetooth (BLE)
+
+BLE is **disabled by default** at boot to support standalone-first operation. The device is fully functional without a phone — you can send and receive messages, browse contacts, read e-books, and set your timezone directly from the keyboard.
+
+To connect to the MeshCore companion app, navigate to the **Bluetooth** home page (use D to page through) and press **Enter** to toggle BLE on. The BLE PIN will be displayed on screen. Toggle it off again the same way when you're done.
+
+### Clock & Timezone
+
+The T-Deck Pro does not include a dedicated RTC chip, so after each reboot the device clock starts unset. The clock will appear in the nav bar (between node name and battery) once the time has been synced by one of two methods:
+
+1. **GPS fix** (standalone) — Once the GPS acquires a satellite fix, the time is automatically synced from the NMEA data. No phone or BLE connection required. Typical time to first fix is 30–90 seconds outdoors with clear sky.
+2. **BLE companion app** — If BLE is enabled and connected to the MeshCore companion app, the app will push the current time to the device.
+
+**Setting your timezone:**
+
+Navigate to the **GPS** home page and press **U** to open the UTC offset editor.
+
+| Key | Action |
+|-----|--------|
+| W | Increase offset (+1 hour) |
+| S | Decrease offset (-1 hour) |
+| Enter | Save and exit |
+| Q | Cancel and exit |
+
+The UTC offset is persisted to flash and survives reboots — you only need to set it once. The valid range is UTC-12 to UTC+14. For example, AEST is UTC+10 and AEDT is UTC+11.
+
+The GPS page also shows the current time, satellite count, position, altitude, and your configured UTC offset for reference.
+
+### Channel Message Screen
+
+| Key | Action |
+|-----|--------|
+| W / S | Scroll messages up/down |
+| A / D | Switch between channels |
+| C | Compose new message |
+| Q | Back to home screen |
+
+### Contacts Screen
+
+Press **N** from the home screen to open the contacts list. All known mesh contacts are shown sorted by most recently seen, with their type (Chat, Repeater, Room, Sensor), hop count, and time since last advert.
+
+| Key | Action |
+|-----|--------|
+| W / S | Scroll up / down through contacts |
+| A / D | Cycle filter: All → Chat → Repeater → Room → Sensor |
+| Enter | Open DM compose (Chat contact) or repeater admin (Repeater contact) |
+| C | Open DM compose to selected chat contact |
+| Q | Back to home screen |
+
+### Sending a Direct Message
+
+Select a **Chat** contact in the contacts list and press **Enter** or **C** 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.
+
+### Repeater Admin Screen
+
+Select a **Repeater** contact in the contacts list and press **Enter** to open the repeater admin screen. You'll be prompted for the repeater's admin password. Characters briefly appear as you type them before being masked, making it easier to enter symbols and numbers on the T-Deck Pro keyboard.
+
+After a successful login, you'll see a menu with the following remote administration commands:
+
+| Menu Item | Description |
+|-----------|-------------|
+| Clock Sync | Push your device's clock time to the repeater |
+| Send Advert | Trigger the repeater to broadcast an advertisement |
+| Neighbors | View other repeaters heard via zero-hop adverts |
+| Get Clock | Read the repeater's current clock value |
+| Version | Query the repeater's firmware version |
+| Get Status | Retrieve repeater status information |
+
+| Key | Action |
+|-----|--------|
+| W / S | Navigate menu items |
+| Enter | Execute selected command |
+| C | Enter compose mode (send raw CLI command) |
+| Q | Back to contacts (from menu) or cancel login |
+
+Command responses are displayed in a scrollable view. Use **W / S** to scroll long responses and **Q** to return to the menu.
+
+### Compose Mode
+
+| Key | Action |
+|-----|--------|
+| A / D | Switch destination channel (when message is empty, channel compose only) |
+| Enter | Send message |
+| Backspace | Delete last character |
+| Shift + Backspace | Cancel and exit compose mode |
+
+### Symbol Entry (Sym Key)
+
+Press the **Sym** key then the letter key to enter numbers and symbols:
+
+| Key | Sym+ | | Key | Sym+ | | Key | Sym+ |
+|-----|------|-|-----|------|-|-----|------|
+| Q | # | | A | * | | Z | 7 |
+| W | 1 | | S | 4 | | X | 8 |
+| E | 2 | | D | 5 | | C | 9 |
+| R | 3 | | F | 6 | | V | ? |
+| T | ( | | G | / | | B | ! |
+| Y | ) | | H | : | | N | , |
+| U | _ | | J | ; | | M | . |
+| I | - | | K | ' | | Mic | 0 |
+| O | + | | L | " | | $ | Emoji picker (Sym+$ for literal $) |
+| P | @ | | | | | | |
+
+### Other Keys
+
+| Key | Action |
+|-----|--------|
+| Shift | Uppercase next letter |
+| Alt | Same as Sym (for numbers/symbols) |
+| Space | Space character / Next in navigation |
+
+### Emoji Picker
+
+While in compose mode, press the **$** key to open the emoji picker. A scrollable grid of 47 emoji is displayed in a 5-column layout.
+
+| Key | Action |
+|-----|--------|
+| W / S | Navigate up / down |
+| A / D | Navigate left / right |
+| Enter | Insert selected emoji |
+| $ / Q / Backspace | Cancel and return to compose |
+
 ## 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.

-## 🔍 What is MeshCore?
+## What is MeshCore?

 MeshCore now supports a range of LoRa devices, allowing for easy flashing without the need to compile firmware manually. Users can flash a pre-built binary using tools like Adafruit ESPTool and interact with the network through a serial console.
 MeshCore provides the ability to create wireless mesh networks, similar to Meshtastic and Reticulum but with a focus on lightweight multi-hop packet routing for embedded projects. Unlike Meshtastic, which is tailored for casual LoRa communication, or Reticulum, which offers advanced networking, MeshCore balances simplicity with scalability, making it ideal for custom embedded solutions., where devices (nodes) can communicate over long distances by relaying messages through intermediate nodes. This is especially useful in off-grid, emergency, or tactical situations where traditional communication infrastructure is unavailable.

-## ⚡ Key Features
+## Key Features

 * Multi-Hop Packet Routing
  * Devices can forward messages across multiple nodes, extending range beyond a single radio's reach.
  * Supports up to a configurable number of hops to balance network efficiency and prevent excessive traffic.
  * Nodes use fixed roles where "Companion" nodes are not repeating messages at all to prevent adverse routing paths from being used.
-* Supports LoRa Radios – Works with Heltec, RAK Wireless, and other LoRa-based hardware.
-* Decentralized & Resilient – No central server or internet required; the network is self-healing.
-* Low Power Consumption – Ideal for battery-powered or solar-powered devices.
-* Simple to Deploy – Pre-built example applications make it easy to get started.
+* Supports LoRa Radios — Works with Heltec, RAK Wireless, and other LoRa-based hardware.
+* Decentralized & Resilient — No central server or internet required; the network is self-healing.
+* Low Power Consumption — Ideal for battery-powered or solar-powered devices.
+* Simple to Deploy — Pre-built example applications make it easy to get started.

-## 🎯 What Can You Use MeshCore For?
+## What Can You Use MeshCore For?

 * Off-Grid Communication: Stay connected even in remote areas.
 * Emergency Response & Disaster Recovery: Set up instant networks where infrastructure is down.
@@ -26,7 +169,7 @@ MeshCore provides the ability to create wireless mesh networks, similar to Mesht
 * Tactical & Security Applications: Military, law enforcement, and private security use cases.
 * IoT & Sensor Networks: Collect data from remote sensors and relay it back to a central location.

-## 🚀 How to Get Started
+## How to Get Started

 - Watch the [MeshCore Intro Video](https://www.youtube.com/watch?v=t1qne8uJBAc) by Andy Kirby.
 - Read through our [Frequently Asked Questions](./docs/faq.md) section.
@@ -39,27 +182,24 @@ For developers;
 - Clone and open the MeshCore repository in Visual Studio Code.
 - See the example applications you can modify and run:
  - [Companion Radio](./examples/companion_radio) - For use with an external chat app, over BLE, USB or WiFi.
-  - [Simple Repeater](./examples/simple_repeater) - Extends network coverage by relaying messages.
-  - [Simple Room Server](./examples/simple_room_server) - A simple BBS server for shared Posts.
-  - [Simple Secure Chat](./examples/simple_secure_chat) - Secure terminal based text communication between devices.

-The Simple Secure Chat example can be interacted with through the Serial Monitor in Visual Studio Code, or with a Serial USB Terminal on Android.
+## MeshCore Flasher

-## ⚡️ MeshCore Flasher
-
-We have prebuilt firmware ready to flash on supported devices.
+Download a copy of the Meck firmware bin from https://github.com/pelgraine/Meck/releases, then:

 - Launch https://flasher.meshcore.co.uk
- Select a supported device
- Flash one of the firmware types:
-  - Companion, Repeater or Room Server
+- Select Custom Firmware
+- Select the .bin file you just downloaded, and click Open or press Enter.
+- Click Flash, then select your device in the popup window (eg. USB JTAG/serial debug unit cu.usbmodem101 as an example), then click Connect.
 - Once flashing is complete, you can connect with one of the MeshCore clients below.

-## 📱 MeshCore Clients
+## MeshCore Clients

 **Companion Firmware**

-The companion firmware can be connected to via BLE, USB or WiFi depending on the firmware type you flashed.
+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.

 - Web: https://app.meshcore.nz
 - Android: https://play.google.com/store/apps/details?id=com.liamcottle.meshcore.android
@@ -67,14 +207,6 @@ The companion firmware can be connected to via BLE, USB or WiFi depending on the
 - NodeJS: https://github.com/liamcottle/meshcore.js
 - Python: https://github.com/fdlamotte/meshcore-cli

-**Repeater and Room Server Firmware**
-
-The repeater and room server firmwares can be setup via USB in the web config tool.
-
- https://config.meshcore.dev
-
-They can also be managed via LoRa in the mobile app by using the Remote Management feature.
-
 ## 🛠 Hardware Compatibility

 MeshCore is designed for devices listed in the [MeshCore Flasher](https://flasher.meshcore.co.uk)
@@ -95,30 +227,19 @@ Here are some general principals you should try to adhere to:

 ## Road-Map / To-Do

-There are a number of fairly major features in the pipeline, with no particular time-frames attached yet. In very rough chronological order:
- [X] Companion radio: UI redesign
- [ ] Repeater + Room Server: add ACL's (like Sensor Node has)
- [ ] Standardise Bridge mode for repeaters
- [ ] Repeater/Bridge: Standardise the Transport Codes for zoning/filtering
- [ ] Core + Repeater: enhanced zero-hop neighbour discovery
- [ ] Core: round-trip manual path support
- [ ] Companion + Apps: support for multiple sub-meshes (and 'off-grid' client repeat mode)
- [ ] Core + Apps: support for LZW message compression
- [ ] Core: dynamic CR (Coding Rate) for weak vs strong hops
- [ ] Core: new framework for hosting multiple virtual nodes on one physical device
- [ ] V2 protocol spec: discussion and consensus around V2 packet protocol, including path hashes, new encryption specs, etc
+There are a number of fairly major features in the pipeline, with no particular time-frames attached yet. In partly chronological order:
+- [X] Companion radio: BLE
+- [X] Text entry for Public channel messages Companion BLE firmware
+- [X] View and compose all channel messages Companion BLE firmware
+- [X] Standalone DM functionality for Companion BLE firmware
+- [X] Contacts list with filtering for Companion BLE firmware
+- [X] Standalone repeater admin access for Companion BLE firmware
+- [X] GPS time sync with on-device timezone setting
+- [ ] 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

- Report bugs and request features on the [GitHub Issues](https://github.com/ripplebiz/MeshCore/issues) page.
- Find additional guides and components on [my site](https://buymeacoffee.com/ripplebiz).
- Join [MeshCore Discord](https://discord.gg/BMwCtwHj5V) to chat with the developers and get help from the community.
-
-## RAK Wireless Board Support in PlatformIO
-
-Before building/flashing the RAK4631 targets in this project, there is, unfortunately, some patching you have to do to your platformIO packages to make it work. There is a guide here on the process:
-   [RAK Wireless: How to Perform Installation of Board Support Package in PlatformIO](https://learn.rakwireless.com/hc/en-us/articles/26687276346775-How-To-Perform-Installation-of-Board-Support-Package-in-PlatformIO)
-
-After building, you will need to convert the output firmware.hex file into a .uf2 file you can copy over to your RAK4631 device (after doing a full erase) by using the command `uf2conv.py -f 0xADA52840 -c firmware.hex` with the python script available from:
-   [GitHub: Microsoft - uf2](https://github.com/Microsoft/uf2/blob/master/utils/uf2conv.py)
-
+- Join [MeshCore Discord](https://discord.gg/BMwCtwHj5V) to chat with the developers and get help from the community.
--- a/Guide.md
+++ b/Guide.md
@@ -0,0 +1,117 @@
+# Text & EPUB Reader Integration for Meck Firmware
+
+## Overview
+
+This adds a text reader accessible via the **R** key from the home screen.
+
+**Features:**
+- Browse `.txt` and `.epub` files from `/books/` folder on SD card
+- Automatic EPUB-to-text conversion on first open (cached for instant re-opens)
+- Word-wrapped text rendering using tiny font (maximum text density)  
+- Page navigation with W/S/A/D keys
+- Automatic reading position resume (persisted to SD card)
+- Index files cached to SD for instant re-opens
+- Bookmark indicator (`*`) on files with saved positions
+- Compose mode (`C`) still accessible from within reader
+
+**Key Mapping:**
+| Context | Key | Action |
+|---------|-----|--------|
+| Home screen | R | Open text reader |
+| File list | W/S | Navigate up/down |
+| File list | Enter | Open selected file |
+| File list | Q | Back to home screen |
+| Reading | W/A | Previous page |
+| Reading | S/D/Space/Enter | Next page |
+| Reading | Q | Close book → file list |
+| Reading | C | Enter compose mode |
+
+---
+
+## SD Card Setup
+
+Place `.txt` or `.epub` files in a `/books/` folder on the SD card root. The reader will:
+- Auto-create `/books/` if it doesn't exist
+- Auto-create `/.indexes/` for page index cache files
+- Auto-create `/books/.epub_cache/` for converted EPUB text
+- Skip macOS hidden files (`._*`, `.DS_Store`)
+- Support up to 50 files
+
+**Index format** is compatible with the standalone reader (version 4), so if you've used the standalone reader previously, bookmarks and indexes will carry over.
+
+---
+
+## EPUB Support
+
+### How It Works
+
+EPUB files are transparently converted to plain text on first open. The conversion pipeline is:
+
+1. **File list** — `scanFiles()` picks up both `.txt` and `.epub` files from `/books/`
+2. **First open** — `openBook()` detects the `.epub` extension and triggers conversion:
+   - Shows a "Converting EPUB..." splash screen
+   - Extracts the ZIP structure using ESP32-S3's built-in ROM `tinfl` decompressor (no external library needed)
+   - Parses `META-INF/container.xml` → finds the OPF file
+   - Parses the OPF manifest and spine to get chapters in reading order
+   - Extracts each XHTML chapter, strips tags, decodes HTML entities
+   - Writes concatenated plain text to `/books/.epub_cache/<filename>.txt`
+3. **Subsequent opens** — the cached `.txt` is found immediately and opened like any regular text file
+
+### Cache Structure
+
+```
+/books/
+  MyBook.epub              ← original EPUB (untouched)
+  SomeStory.txt            ← regular text file
+  .epub_cache/
+    MyBook.txt             ← auto-generated from MyBook.epub
+/.indexes/
+  MyBook.txt.idx           ← page index for the converted text
+```
+
+- The original `.epub` file is never modified
+- Deleting a cached `.txt` from `.epub_cache/` forces re-conversion on next open
+- Index files (`.idx`) work identically for both regular and EPUB-derived text files
+- Boot scan picks up previously cached EPUB text files so they appear in the file list even before the EPUB is re-opened
+
+### EPUB Processing Details
+
+The conversion is handled by three components:
+
+| Component | Role |
+|-----------|------|
+| `EpubZipReader.h` | ZIP central directory parsing + `tinfl` decompression (supports Store and Deflate) |
+| `EpubProcessor.h` | EPUB structure parsing (container.xml → OPF → spine) and XHTML tag stripping |
+| `TextReaderScreen.h` | Integration: detects `.epub`, triggers conversion, redirects to cached `.txt` |
+
+**XHTML stripping handles:**
+- Tag removal with block-element newlines (`<p>`, `<br>`, `<div>`, `<h1>`–`<h6>`, `<li>`, etc.)
+- `<head>`, `<style>`, `<script>` content skipped entirely
+- HTML entity decoding: named (`&amp;`, `&mdash;`, `&ldquo;`, etc.) and numeric (`&#8212;`, `&#x2014;`)
+- Smart quote / em-dash / ellipsis → ASCII equivalents (e-ink font is ASCII-only)
+- Whitespace collapsing and cleanup
+
+**Limits:**
+- Max 200 chapters in spine (`EPUB_MAX_CHAPTERS`)
+- Max 256 manifest items (`EPUB_MAX_MANIFEST`)
+- Manifest and chapter data are heap-allocated in PSRAM where available
+- Typical conversion time: 2–10 seconds depending on book size
+
+### Troubleshooting
+
+| Symptom | Likely Cause |
+|---------|-------------|
+| "Convert failed!" splash | EPUB may be DRM-protected, corrupted, or use an unusual structure |
+| EPUB appears in list but opens as blank | Check serial output for `EpubProc:` messages; chapter count may be 0 |
+| Stale content after replacing an EPUB | Delete the matching `.txt` from `/books/.epub_cache/` to force re-conversion |
+
+---
+
+## Architecture Notes
+
+- The reader renders through the standard `UIScreen::render()` framework, so no special bypass is needed in the main loop (unlike compose mode)
+- SD card uses the same HSPI bus as e-ink display and LoRa radio — CS pin management handles contention
+- Page content is pre-read from SD into a memory buffer during `handleInput()`, then rendered from buffer during `render()` — this avoids SPI bus conflicts during display refresh
+- Layout metrics (chars per line, lines per page) are calculated dynamically from the display driver's font metrics on first entry
+- EPUB conversion runs synchronously in `openBook()` — the e-ink splash screen keeps the user informed while the ESP32 processes the archive
+- ZIP extraction uses the ESP32-S3's hardware-optimised ROM `tinfl` inflate, avoiding external compression library dependencies and the linker conflicts they cause
--- a/examples/companion_radio/AbstractUITask.h
+++ b/examples/companion_radio/AbstractUITask.h
@@ -43,4 +43,11 @@ public:
  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) {}
+
+  // 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) {}
+};
--- a/examples/companion_radio/DataStore.cpp
+++ b/examples/companion_radio/DataStore.cpp
@@ -228,6 +228,7 @@ void DataStore::loadPrefsInt(const char *filename, NodePrefs& _prefs, double& no
    file.read((uint8_t *)&_prefs.gps_enabled, sizeof(_prefs.gps_enabled));                 // 85
    file.read((uint8_t *)&_prefs.gps_interval, sizeof(_prefs.gps_interval));               // 86
    file.read((uint8_t *)&_prefs.autoadd_config, sizeof(_prefs.autoadd_config));           // 87
+    file.read((uint8_t *)&_prefs.utc_offset_hours, sizeof(_prefs.utc_offset_hours));       // 88

    file.close();
  }
@@ -263,6 +264,7 @@ void DataStore::savePrefs(const NodePrefs& _prefs, double node_lat, double node_
    file.write((uint8_t *)&_prefs.gps_enabled, sizeof(_prefs.gps_enabled));                 // 85
    file.write((uint8_t *)&_prefs.gps_interval, sizeof(_prefs.gps_interval));               // 86
    file.write((uint8_t *)&_prefs.autoadd_config, sizeof(_prefs.autoadd_config));           // 87
+    file.write((uint8_t *)&_prefs.utc_offset_hours, sizeof(_prefs.utc_offset_hours));     // 88

    file.close();
  }
@@ -598,4 +600,4 @@ bool DataStore::putBlobByKey(const uint8_t key[], int key_len, const uint8_t src
  }
  return false; // error
 }
-#endif
+#endif
--- a/examples/companion_radio/MyMesh.cpp
+++ b/examples/companion_radio/MyMesh.cpp
@@ -446,9 +446,37 @@ void MyMesh::queueMessage(const ContactInfo &from, uint8_t txt_type, mesh::Packe
 }

 bool MyMesh::filterRecvFloodPacket(mesh::Packet* packet) {
-  // REVISIT: try to determine which Region (from transport_codes[1]) that Sender is indicating for replies/responses
-  //    if unknown, fallback to finding Region from transport_codes[0], the 'scope' used by Sender
-  return false;
+  // Check if this incoming flood packet is a repeat of a message we recently sent
+  if (packet->payload_len >= SENT_FINGERPRINT_SIZE) {
+    unsigned long now = millis();
+    for (int i = 0; i < SENT_TRACK_SIZE; i++) {
+      SentMsgTrack* t = &_sent_track[i];
+      if (!t->active) continue;
+
+      // Expire old entries
+      if ((now - t->sent_millis) > SENT_TRACK_EXPIRY_MS) {
+        t->active = false;
+        continue;
+      }
+
+      // Compare payload fingerprint
+      if (memcmp(packet->payload, t->fingerprint, SENT_FINGERPRINT_SIZE) == 0) {
+        t->repeat_count++;
+        MESH_DEBUG_PRINTLN("SentTrack: heard repeat #%d (SNR=%.1f)", t->repeat_count, packet->getSNR());
+        
+#ifdef DISPLAY_CLASS
+        if (_ui) {
+          char buf[40];
+          snprintf(buf, sizeof(buf), "Sent! (%d)", t->repeat_count);
+          _ui->showAlert(buf, 2000);  // show/extend alert with updated count
+        }
+#endif
+        break;  // found match, no need to check other entries
+      }
+    }
+  }
+
+  return false;  // never filter Ã¢â‚¬â€ let normal processing continue
 }

 void MyMesh::sendFloodScoped(const ContactInfo& recipient, mesh::Packet* pkt, uint32_t delay_millis) {
@@ -463,6 +491,17 @@ void MyMesh::sendFloodScoped(const ContactInfo& recipient, mesh::Packet* pkt, ui
  }
 }
 void MyMesh::sendFloodScoped(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t delay_millis) {
+  // Capture payload fingerprint for repeat tracking before sending
+  if (pkt->payload_len >= SENT_FINGERPRINT_SIZE) {
+    SentMsgTrack* t = &_sent_track[_sent_track_idx];
+    memcpy(t->fingerprint, pkt->payload, SENT_FINGERPRINT_SIZE);
+    t->repeat_count = 0;
+    t->sent_millis = millis();
+    t->active = true;
+    _sent_track_idx = (_sent_track_idx + 1) % SENT_TRACK_SIZE;
+    MESH_DEBUG_PRINTLN("SentTrack: captured fingerprint for channel msg");
+  }
+
  // TODO: have per-channel send_scope
  if (send_scope.isNull()) {
    sendFlood(pkt, delay_millis);
@@ -541,6 +580,76 @@ void MyMesh::onChannelMessageRecv(const mesh::GroupChannel &channel, mesh::Packe
 #endif
 }

+void MyMesh::queueSentChannelMessage(uint8_t channel_idx, uint32_t timestamp, const char* sender, const char* text) {
+  // Format message the same way as onChannelMessageRecv for BLE app sync
+  // This allows sent messages from device keyboard to appear in the app
+  int i = 0;
+  if (app_target_ver >= 3) {
+    out_frame[i++] = RESP_CODE_CHANNEL_MSG_RECV_V3;
+    out_frame[i++] = 0;  // SNR not applicable for sent messages
+    out_frame[i++] = 0;  // reserved1
+    out_frame[i++] = 0;  // reserved2
+  } else {
+    out_frame[i++] = RESP_CODE_CHANNEL_MSG_RECV;
+  }
+
+  out_frame[i++] = channel_idx;
+  out_frame[i++] = 0;  // path_len = 0 indicates local/sent message
+
+  out_frame[i++] = TXT_TYPE_PLAIN;
+  memcpy(&out_frame[i], &timestamp, 4);
+  i += 4;
+  
+  // Format as "sender: text" like the app expects
+  char formatted[MAX_FRAME_SIZE];
+  snprintf(formatted, sizeof(formatted), "%s: %s", sender, text);
+  int tlen = strlen(formatted);
+  if (i + tlen > MAX_FRAME_SIZE) {
+    tlen = MAX_FRAME_SIZE - i;
+  }
+  memcpy(&out_frame[i], formatted, tlen);
+  i += tlen;
+  
+  addToOfflineQueue(out_frame, i);
+
+  // If app is connected, send push notification
+  if (_serial->isConnected()) {
+    uint8_t frame[1];
+    frame[0] = PUSH_CODE_MSG_WAITING;
+    _serial->writeFrame(frame, 1);
+  }
+}
+
+bool MyMesh::uiSendDirectMessage(uint32_t contact_idx, const char* text) {
+  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 expected_ack, est_timeout;
+  int result = sendMessage(*recipient, timestamp, 0, text, expected_ack, est_timeout);
+
+  if (result == MSG_SEND_FAILED) {
+    MESH_DEBUG_PRINTLN("UI: DM send failed to %s", recipient->name);
+    return false;
+  }
+
+  // Track expected ACK for delivery confirmation
+  if (expected_ack) {
+    expected_ack_table[next_ack_idx].msg_sent = _ms->getMillis();
+    expected_ack_table[next_ack_idx].ack = expected_ack;
+    expected_ack_table[next_ack_idx].contact = recipient;
+    next_ack_idx = (next_ack_idx + 1) % EXPECTED_ACK_TABLE_SIZE;
+  }
+
+  MESH_DEBUG_PRINTLN("UI: DM sent to %s (%s), ack=0x%08X timeout=%dms",
+                     recipient->name, result == MSG_SEND_SENT_FLOOD ? "flood" : "direct",
+                     expected_ack, 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) {
@@ -786,6 +895,8 @@ MyMesh::MyMesh(mesh::Radio &radio, mesh::RNG &rng, mesh::RTCClock &rtc, SimpleMe
  dirty_contacts_expiry = 0;
  memset(advert_paths, 0, sizeof(advert_paths));
  memset(send_scope.key, 0, sizeof(send_scope.key));
+  memset(_sent_track, 0, sizeof(_sent_track));
+  _sent_track_idx = 0;

  // defaults
  memset(&_prefs, 0, sizeof(_prefs));
@@ -839,6 +950,7 @@ void MyMesh::begin(bool has_display) {
  _prefs.buzzer_quiet = constrain(_prefs.buzzer_quiet, 0, 1);  // Ensure boolean 0 or 1
  _prefs.gps_enabled = constrain(_prefs.gps_enabled, 0, 1);  // Ensure boolean 0 or 1
  _prefs.gps_interval = constrain(_prefs.gps_interval, 0, 86400);  // Max 24 hours
+  _prefs.utc_offset_hours = constrain(_prefs.utc_offset_hours, -12, 14);  // Valid timezone range

 #ifdef BLE_PIN_CODE // 123456 by default
  if (_prefs.ble_pin == 0) {
@@ -1622,6 +1734,12 @@ void MyMesh::handleCmdFrame(size_t len) {
          savePrefs();
        }
        #endif
+        // UTC offset for local clock display (works regardless of GPS)
+        if (strcmp(sp, "utc_offset") == 0) {
+          int offset = atoi(np);
+          _prefs.utc_offset_hours = constrain(offset, -12, 14);
+          savePrefs();
+        }
        writeOKFrame();
      } else {
        writeErrFrame(ERR_CODE_ILLEGAL_ARG);
@@ -1979,4 +2097,4 @@ bool MyMesh::advert() {
  } else {
    return false;
  }
-}
+}
--- 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 "28 Jan 2026"
+#define FIRMWARE_BUILD_DATE "10 Feb 2026"
 #endif

 #ifndef FIRMWARE_VERSION
-#define FIRMWARE_VERSION "Meck v0.3"
+#define FIRMWARE_VERSION "Meck v0.8.2"
 #endif

 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
@@ -101,6 +101,18 @@ public:
  void enterCLIRescue();

  int  getRecentlyHeard(AdvertPath dest[], int max_num);
+  
+  // Queue a sent channel message for BLE app sync
+  void queueSentChannelMessage(uint8_t channel_idx, uint32_t timestamp, const char* sender, const char* text);
+
+  // Send a direct message from the UI (no BLE dependency)
+  bool uiSendDirectMessage(uint32_t contact_idx, const char* text);
+
+  // Repeater admin - UI-initiated operations
+  bool uiLoginToRepeater(uint32_t contact_idx, const char* password);
+  bool uiSendCliCommand(uint32_t contact_idx, const char* command);
+  int  getAdminContactIdx() const { return _admin_contact_idx; }
+

 protected:
  float getAirtimeBudgetFactor() const override;
@@ -228,6 +240,20 @@ private:

  #define ADVERT_PATH_TABLE_SIZE   16
  AdvertPath advert_paths[ADVERT_PATH_TABLE_SIZE]; // circular table
+
+    // Sent message repeat tracking
+  #define SENT_TRACK_SIZE          4
+  #define SENT_FINGERPRINT_SIZE    12
+  #define SENT_TRACK_EXPIRY_MS     30000  // stop tracking after 30 seconds
+  struct SentMsgTrack {
+    uint8_t fingerprint[SENT_FINGERPRINT_SIZE];
+    uint8_t repeat_count;
+    unsigned long sent_millis;
+    bool active;
+  };
+  SentMsgTrack _sent_track[SENT_TRACK_SIZE];
+  int _sent_track_idx;  // next slot in circular buffer
+  int _admin_contact_idx;  // contact index for active admin session (-1 if none)
 };

-extern MyMesh the_mesh;
+extern MyMesh the_mesh;
--- a/examples/companion_radio/NodePrefs.h
+++ b/examples/companion_radio/NodePrefs.h
@@ -28,4 +28,5 @@ struct NodePrefs {  // persisted to file
  uint8_t  gps_enabled;      // GPS enabled flag (0=disabled, 1=enabled)
  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
 };
--- a/examples/companion_radio/main.cpp
+++ b/examples/companion_radio/main.cpp
@@ -4,6 +4,48 @@
 #include "variant.h"   // Board-specific defines (HAS_GPS, etc.)
 #include "target.h"    // For sensors, board, etc.

+// T-Deck Pro Keyboard support
+#if defined(LilyGo_TDeck_Pro)
+  #include "TCA8418Keyboard.h"
+  #include <SD.h>
+  #include "TextReaderScreen.h"
+  #include "ContactsScreen.h"
+  extern SPIClass displaySpi;  // From GxEPDDisplay.cpp, shared SPI bus
+
+  TCA8418Keyboard keyboard(I2C_ADDR_KEYBOARD, &Wire);
+  
+  // Compose mode state
+  static bool composeMode = false;
+  static char composeBuffer[138];  // 137 bytes max + null terminator (matches BLE wire cost)
+  static int composePos = 0;       // Current wire-cost byte count
+  static uint8_t composeChannelIdx = 0;
+  static unsigned long lastComposeRefresh = 0;
+  static bool composeNeedsRefresh = false;
+  #define COMPOSE_REFRESH_INTERVAL 600  // ms between e-ink refreshes while typing (refresh takes ~650ms)
+
+  // DM compose mode (direct message to a specific contact)
+  static bool composeDM = false;
+  static int composeDMContactIdx = -1;
+  static char composeDMName[32];
+   // AGC reset - periodically re-assert RX boosted gain to prevent sensitivity drift
+  #define AGC_RESET_INTERVAL_MS 500
+  static unsigned long lastAGCReset = 0;
+
+  // Emoji picker state
+  #include "EmojiPicker.h"
+  static bool emojiPickerMode = false;
+  static EmojiPicker emojiPicker;
+  
+  // Text reader mode state
+  static bool readerMode = false;
+  
+  void initKeyboard();
+  void handleKeyboardInput();
+  void drawComposeScreen();
+  void drawEmojiPicker();
+  void sendComposedMessage();
+#endif
+
 // Believe it or not, this std C function is busted on some platforms!
 static uint32_t _atoi(const char* sp) {
  uint32_t n = 0;
@@ -110,14 +152,14 @@ void halt() {
 void setup() {
  Serial.begin(115200);
  delay(100);  // Give serial time to initialize
-  Serial.println("=== setup() - STARTING ===");
+  MESH_DEBUG_PRINTLN("=== setup() - STARTING ===");

  board.begin();
-  Serial.println("setup() - board.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - board.begin() done");

 #ifdef DISPLAY_CLASS
  DisplayDriver* disp = NULL;
-  Serial.println("setup() - about to call display.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call display.begin()");
  
  // =========================================================================
  // T-Deck Pro V1.1: Initialize E-Ink reset pin BEFORE display.begin()
@@ -127,7 +169,7 @@ void setup() {
    // Initialize E-Ink reset pin (GPIO 16)
    pinMode(PIN_DISPLAY_RST, OUTPUT);
    digitalWrite(PIN_DISPLAY_RST, HIGH);
-    Serial.println("setup() - E-Ink reset pin initialized");
+    MESH_DEBUG_PRINTLN("setup() - E-Ink reset pin initialized");
    
    // Initialize Touch reset pin (GPIO 38) 
    #ifdef CST328_PIN_RST
@@ -138,13 +180,13 @@ void setup() {
      delay(80);
      digitalWrite(CST328_PIN_RST, HIGH);
      delay(20);
-      Serial.println("setup() - Touch reset pin initialized");
+      MESH_DEBUG_PRINTLN("setup() - Touch reset pin initialized");
    #endif
  #endif
  // =========================================================================
  
  if (display.begin()) {
-    Serial.println("setup() - display.begin() returned true");
+    MESH_DEBUG_PRINTLN("setup() - display.begin() returned true");
    disp = &display;
    disp->startFrame();
  #ifdef ST7789
@@ -152,25 +194,25 @@ void setup() {
  #endif
    disp->drawTextCentered(disp->width() / 2, 28, "Loading...");
    disp->endFrame();
-    Serial.println("setup() - Loading screen drawn");
+    MESH_DEBUG_PRINTLN("setup() - Loading screen drawn");
  } else {
-    Serial.println("setup() - display.begin() returned false!");
+    MESH_DEBUG_PRINTLN("setup() - display.begin() returned false!");
  }
 #endif

-  Serial.println("setup() - about to call radio_init()");
+  MESH_DEBUG_PRINTLN("setup() - about to call radio_init()");
  if (!radio_init()) { 
-    Serial.println("setup() - radio_init() FAILED! Halting.");
+    MESH_DEBUG_PRINTLN("setup() - radio_init() FAILED! Halting.");
    halt(); 
  }
-  Serial.println("setup() - radio_init() done");
+  MESH_DEBUG_PRINTLN("setup() - radio_init() done");

-  Serial.println("setup() - about to call fast_rng.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call fast_rng.begin()");
  fast_rng.begin(radio_get_rng_seed());
-  Serial.println("setup() - fast_rng.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - fast_rng.begin() done");

 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
-  Serial.println("setup() - NRF52/STM32 filesystem init");
+  MESH_DEBUG_PRINTLN("setup() - NRF52/STM32 filesystem init");
  InternalFS.begin();
  #if defined(QSPIFLASH)
    if (!QSPIFlash.begin()) {
@@ -183,11 +225,11 @@ void setup() {
      ExtraFS.begin();
  #endif
  #endif
-  Serial.println("setup() - about to call store.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call store.begin()");
  store.begin();
-  Serial.println("setup() - store.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - store.begin() done");
  
-  Serial.println("setup() - about to call the_mesh.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call the_mesh.begin()");
  the_mesh.begin(
    #ifdef DISPLAY_CLASS
        disp != NULL
@@ -195,27 +237,27 @@ void setup() {
        false
    #endif
  );
-  Serial.println("setup() - the_mesh.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - the_mesh.begin() done");

 #ifdef BLE_PIN_CODE
-  Serial.println("setup() - about to call serial_interface.begin() with BLE");
+  MESH_DEBUG_PRINTLN("setup() - about to call serial_interface.begin() with BLE");
  serial_interface.begin(BLE_NAME_PREFIX, the_mesh.getNodePrefs()->node_name, the_mesh.getBLEPin());
-  Serial.println("setup() - serial_interface.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - serial_interface.begin() done");
 #else
  serial_interface.begin(Serial);
 #endif
-  Serial.println("setup() - about to call the_mesh.startInterface()");
+  MESH_DEBUG_PRINTLN("setup() - about to call the_mesh.startInterface()");
  the_mesh.startInterface(serial_interface);
-  Serial.println("setup() - the_mesh.startInterface() done");
+  MESH_DEBUG_PRINTLN("setup() - the_mesh.startInterface() done");

 #elif defined(RP2040_PLATFORM)
-  Serial.println("setup() - RP2040 filesystem init");
+  MESH_DEBUG_PRINTLN("setup() - RP2040 filesystem init");
  LittleFS.begin();
-  Serial.println("setup() - about to call store.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call store.begin()");
  store.begin();
-  Serial.println("setup() - store.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - store.begin() done");
  
-  Serial.println("setup() - about to call the_mesh.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call the_mesh.begin()");
  the_mesh.begin(
    #ifdef DISPLAY_CLASS
        disp != NULL
@@ -223,7 +265,7 @@ void setup() {
        false
    #endif
  );
-  Serial.println("setup() - the_mesh.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - the_mesh.begin() done");

  //#ifdef WIFI_SSID
  //  WiFi.begin(WIFI_SSID, WIFI_PWD);
@@ -239,20 +281,20 @@ void setup() {
  #else
    serial_interface.begin(Serial);
  #endif
-  Serial.println("setup() - about to call the_mesh.startInterface()");
+  MESH_DEBUG_PRINTLN("setup() - about to call the_mesh.startInterface()");
  the_mesh.startInterface(serial_interface);
-  Serial.println("setup() - the_mesh.startInterface() done");
+  MESH_DEBUG_PRINTLN("setup() - the_mesh.startInterface() done");

 #elif defined(ESP32)
-  Serial.println("setup() - ESP32 filesystem init - calling SPIFFS.begin()");
+  MESH_DEBUG_PRINTLN("setup() - ESP32 filesystem init - calling SPIFFS.begin()");
  SPIFFS.begin(true);
-  Serial.println("setup() - SPIFFS.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - SPIFFS.begin() done");
  
-  Serial.println("setup() - about to call store.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call store.begin()");
  store.begin();
-  Serial.println("setup() - store.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - store.begin() done");
  
-  Serial.println("setup() - about to call the_mesh.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call the_mesh.begin()");
  the_mesh.begin(
    #ifdef DISPLAY_CLASS
        disp != NULL
@@ -260,16 +302,16 @@ void setup() {
        false
    #endif
  );
-  Serial.println("setup() - the_mesh.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - the_mesh.begin() done");

 #ifdef WIFI_SSID
-  Serial.println("setup() - WiFi mode");
+  MESH_DEBUG_PRINTLN("setup() - WiFi mode");
  WiFi.begin(WIFI_SSID, WIFI_PWD);
  serial_interface.begin(TCP_PORT);
 #elif defined(BLE_PIN_CODE)
-  Serial.println("setup() - about to call serial_interface.begin() with BLE");
+  MESH_DEBUG_PRINTLN("setup() - about to call serial_interface.begin() with BLE");
  serial_interface.begin(BLE_NAME_PREFIX, the_mesh.getNodePrefs()->node_name, the_mesh.getBLEPin());
-  Serial.println("setup() - serial_interface.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - serial_interface.begin() done");
 #elif defined(SERIAL_RX)
  companion_serial.setPins(SERIAL_RX, SERIAL_TX);
  companion_serial.begin(115200);
@@ -277,69 +319,667 @@ void setup() {
 #else
  serial_interface.begin(Serial);
 #endif
-  Serial.println("setup() - about to call the_mesh.startInterface()");
+  MESH_DEBUG_PRINTLN("setup() - about to call the_mesh.startInterface()");
  the_mesh.startInterface(serial_interface);
-  Serial.println("setup() - the_mesh.startInterface() done");
+  MESH_DEBUG_PRINTLN("setup() - the_mesh.startInterface() done");

 #else
  #error "need to define filesystem"
 #endif

-  Serial.println("setup() - about to call sensors.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call sensors.begin()");
  sensors.begin();
-  Serial.println("setup() - sensors.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - sensors.begin() done");

  // IMPORTANT: sensors.begin() calls initBasicGPS() which steals the GPS pins for Serial1
  // We need to reinitialize Serial2 to reclaim them
  #if HAS_GPS
    Serial2.end();  // Close any existing Serial2
    Serial2.begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
-    Serial.println("setup() - Reinitialized Serial2 for GPS after sensors.begin()");
+    MESH_DEBUG_PRINTLN("setup() - Reinitialized Serial2 for GPS after sensors.begin()");
  #endif

 #ifdef DISPLAY_CLASS
-  Serial.println("setup() - about to call ui_task.begin()");
+  MESH_DEBUG_PRINTLN("setup() - about to call ui_task.begin()");
  ui_task.begin(disp, &sensors, the_mesh.getNodePrefs());
-  Serial.println("setup() - ui_task.begin() done");
+  MESH_DEBUG_PRINTLN("setup() - ui_task.begin() done");
 #endif

+  // Initialize T-Deck Pro keyboard
+  #if defined(LilyGo_TDeck_Pro)
+    initKeyboard();
+  #endif
+
+  // Initialize SD card for text reader
+  #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
+  {
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);  // Deselect SD initially
+    
+    if (SD.begin(SDCARD_CS, displaySpi, 4000000)) {
+      MESH_DEBUG_PRINTLN("setup() - SD card initialized");
+      // Tell the text reader that SD is ready, then pre-index books at boot
+      TextReaderScreen* reader = (TextReaderScreen*)ui_task.getTextReaderScreen();
+      if (reader) {
+        reader->setSDReady(true);
+        if (disp) {
+          reader->bootIndex(*disp);
+        }
+      }
+  }
+  }
+  #endif
+
  // Enable GPS by default on T-Deck Pro
  #if HAS_GPS
    // Set GPS enabled in both sensor manager and node prefs
    sensors.setSettingValue("gps", "1");
    the_mesh.getNodePrefs()->gps_enabled = 1;
    the_mesh.savePrefs();
-    Serial.println("setup() - GPS enabled by default");
+    MESH_DEBUG_PRINTLN("setup() - GPS enabled by default");
  #endif

-  Serial.println("=== setup() - COMPLETE ===");
+  // T-Deck Pro: BLE starts disabled for standalone-first operation
+  // User can toggle it on from the Bluetooth home page (Enter or long-press)
+  #if defined(LilyGo_TDeck_Pro) && defined(BLE_PIN_CODE)
+    serial_interface.disable();
+    MESH_DEBUG_PRINTLN("setup() - BLE disabled at boot (standalone mode)");
+  #endif
+
+  MESH_DEBUG_PRINTLN("=== setup() - COMPLETE ===");
 }

 void loop() {
  the_mesh.loop();
  sensors.loop();
 #ifdef DISPLAY_CLASS
-  ui_task.loop();
-#endif
-  rtc_clock.tick();
-
-  // Debug: Check for GPS data on Serial2
-  #if HAS_GPS
-  static unsigned long lastGpsDebug = 0;
-  if (millis() - lastGpsDebug > 5000) {  // Every 5 seconds
-    lastGpsDebug = millis();
-    Serial.print("GPS Debug - Serial2 available: ");
-    Serial.print(Serial2.available());
-    Serial.print(" bytes");
-    LocationProvider* loc = sensors.getLocationProvider();
-    if (loc) {
-      Serial.print(", valid: ");
-      Serial.print(loc->isValid() ? "YES" : "NO");
-      Serial.print(", sats: ");
-      Serial.println(loc->satellitesCount());
-    } else {
-      Serial.println(", LocationProvider: NULL");
+  // Skip UITask rendering when in compose mode to prevent flickering
+  #if defined(LilyGo_TDeck_Pro)
+  if (!composeMode) {
+    ui_task.loop();
+  } else {
+    // Handle debounced compose/emoji picker screen refresh
+    if (composeNeedsRefresh && (millis() - lastComposeRefresh) >= COMPOSE_REFRESH_INTERVAL) {
+      if (emojiPickerMode) {
+        drawEmojiPicker();
+      } else {
+        drawComposeScreen();
+      }
+      lastComposeRefresh = millis();
+      composeNeedsRefresh = false;
    }
  }
+  // Track reader mode state for key routing
+  readerMode = ui_task.isOnTextReader();
+  #else
+  ui_task.loop();
  #endif
-}
+#endif
+  rtc_clock.tick();
+  // Periodic AGC reset - re-assert boosted RX gain to prevent sensitivity drift
+  if ((millis() - lastAGCReset) >= AGC_RESET_INTERVAL_MS) {
+    radio_reset_agc();
+    lastAGCReset = millis();
+  }
+  // Handle T-Deck Pro keyboard input
+  #if defined(LilyGo_TDeck_Pro)
+    handleKeyboardInput();
+  #endif
+}
+
+// ============================================================================
+// T-DECK PRO KEYBOARD FUNCTIONS
+// ============================================================================
+
+#if defined(LilyGo_TDeck_Pro)
+
+void initKeyboard() {
+  // Keyboard uses the same I2C bus as other peripherals (already initialized)
+  if (keyboard.begin()) {
+    MESH_DEBUG_PRINTLN("setup() - Keyboard initialized");
+    composeBuffer[0] = '\0';
+    composePos = 0;
+    composeMode = false;
+    composeNeedsRefresh = false;
+    lastComposeRefresh = 0;
+  } else {
+    MESH_DEBUG_PRINTLN("setup() - Keyboard initialization failed!");
+  }
+}
+
+void handleKeyboardInput() {
+  if (!keyboard.isReady()) return;
+  
+  char key = keyboard.readKey();
+  if (key == 0) return;
+  
+  Serial.printf("handleKeyboardInput: key='%c' (0x%02X) composeMode=%d\n", 
+                key >= 32 ? key : '?', key, composeMode);
+  
+  if (composeMode) {
+    // Emoji picker sub-mode
+    if (emojiPickerMode) {
+      uint8_t result = emojiPicker.handleInput(key);
+      if (result == 0xFF) {
+        // Cancelled - immediate draw to return to compose
+        emojiPickerMode = false;
+        drawComposeScreen();
+        lastComposeRefresh = millis();
+        composeNeedsRefresh = false;
+      } else if (result >= EMOJI_ESCAPE_START && result <= EMOJI_ESCAPE_END) {
+        // Emoji selected - insert escape byte + padding to match UTF-8 wire cost
+        int cost = emojiUtf8Cost(result);
+        if (composePos + cost <= 137) {
+          composeBuffer[composePos++] = (char)result;
+          for (int p = 1; p < cost; p++) {
+            composeBuffer[composePos++] = (char)EMOJI_PAD_BYTE;
+          }
+          composeBuffer[composePos] = '\0';
+          Serial.printf("Compose: Inserted emoji 0x%02X cost=%d, pos=%d\n", result, cost, composePos);
+        }
+        emojiPickerMode = false;
+        drawComposeScreen();
+        lastComposeRefresh = millis();
+        composeNeedsRefresh = false;
+      } else {
+        // Navigation - debounce (don't draw immediately, let loop handle it)
+        composeNeedsRefresh = true;
+      }
+      return;
+    }
+    
+    // In compose mode - handle text input
+    if (key == '\r') {
+      // Enter - send the message
+      Serial.println("Compose: Enter pressed, sending...");
+      if (composePos > 0) {
+        sendComposedMessage();
+      }
+      bool wasDM = composeDM;
+      composeMode = false;
+      emojiPickerMode = false;
+      composeDM = false;
+      composeDMContactIdx = -1;
+      composeBuffer[0] = '\0';
+      composePos = 0;
+      if (wasDM) {
+        ui_task.gotoContactsScreen();
+      } else {
+        ui_task.gotoHomeScreen();
+      }
+      return;
+    }
+    
+    if (key == '\b') {
+      // Backspace - check if shift was recently pressed for cancel combo
+      if (keyboard.wasShiftRecentlyPressed(500)) {
+        // Shift+Backspace = Cancel (works anytime)
+        Serial.println("Compose: Shift+Backspace, cancelling...");
+        bool wasDM = composeDM;
+        composeMode = false;
+        emojiPickerMode = false;
+        composeDM = false;
+        composeDMContactIdx = -1;
+        composeBuffer[0] = '\0';
+        composePos = 0;
+        if (wasDM) {
+          ui_task.gotoContactsScreen();
+        } else {
+          ui_task.gotoHomeScreen();
+        }
+        return;
+      }
+      // Regular backspace - delete last character (or entire emoji including pads)
+      if (composePos > 0) {
+        // Delete trailing pad bytes first, then the escape byte
+        while (composePos > 0 && (uint8_t)composeBuffer[composePos - 1] == EMOJI_PAD_BYTE) {
+          composePos--;
+        }
+        // Now delete the actual character (escape byte or regular char)
+        if (composePos > 0) {
+          composePos--;
+        }
+        composeBuffer[composePos] = '\0';
+        Serial.printf("Compose: Backspace, pos=%d\n", composePos);
+        composeNeedsRefresh = true;  // Use debounced refresh
+      }
+      return;
+    }
+    
+    // A/D keys switch channels (only when buffer is empty, not in DM mode)
+    if ((key == 'a' || key == 'A') && composePos == 0 && !composeDM) {
+      // Previous channel
+      if (composeChannelIdx > 0) {
+        composeChannelIdx--;
+      } else {
+        // Wrap to last valid channel
+        for (uint8_t i = MAX_GROUP_CHANNELS - 1; i > 0; i--) {
+          ChannelDetails ch;
+          if (the_mesh.getChannel(i, ch) && ch.name[0] != '\0') {
+            composeChannelIdx = i;
+            break;
+          }
+        }
+      }
+      Serial.printf("Compose: Channel switched to %d\n", composeChannelIdx);
+      composeNeedsRefresh = true;  // Debounced refresh
+      return;
+    }
+    
+    if ((key == 'd' || key == 'D') && composePos == 0 && !composeDM) {
+      // Next channel
+      ChannelDetails ch;
+      uint8_t nextIdx = composeChannelIdx + 1;
+      if (the_mesh.getChannel(nextIdx, ch) && ch.name[0] != '\0') {
+        composeChannelIdx = nextIdx;
+      } else {
+        composeChannelIdx = 0;  // Wrap to first channel
+      }
+      Serial.printf("Compose: Channel switched to %d\n", composeChannelIdx);
+      composeNeedsRefresh = true;  // Debounced refresh
+      return;
+    }
+    
+    // '$' key (without Sym) opens emoji picker
+    if (key == KB_KEY_EMOJI) {
+      emojiPicker.reset();
+      emojiPickerMode = true;
+      drawEmojiPicker();
+      lastComposeRefresh = millis();
+      composeNeedsRefresh = false;
+      return;
+    }
+    
+    // Regular character input
+    if (key >= 32 && key < 127 && composePos < 137) {
+      composeBuffer[composePos++] = key;
+      composeBuffer[composePos] = '\0';
+      Serial.printf("Compose: Added '%c', pos=%d\n", key, composePos);
+      composeNeedsRefresh = true;  // Use debounced refresh
+    }
+    return;
+  }
+  
+  // *** TEXT READER MODE ***
+  if (readerMode) {
+    TextReaderScreen* reader = (TextReaderScreen*)ui_task.getTextReaderScreen();
+    
+    // Q key: if reading, reader handles it (close book -> file list)
+    //         if on file list, exit reader entirely
+    if (key == 'q' || key == 'Q') {
+      if (reader->isReading()) {
+        // Let the reader handle Q (close book, go to file list)
+        ui_task.injectKey('q');
+      } else {
+        // On file list - exit reader, go home
+        reader->exitReader();
+        Serial.println("Exiting text reader");
+        ui_task.gotoHomeScreen();
+      }
+      return;
+    }
+    
+    // C key: allow entering compose mode from reader
+    if (key == 'c' || key == 'C') {
+      composeDM = false;
+      composeDMContactIdx = -1;
+      composeMode = true;
+      composeBuffer[0] = '\0';
+      composePos = 0;
+      Serial.printf("Entering compose mode from reader, channel %d\n", composeChannelIdx);
+      drawComposeScreen();
+      lastComposeRefresh = millis();
+      return;
+    }
+    
+    // All other keys pass through to the reader screen
+    ui_task.injectKey(key);
+    return;
+  }
+
+  // Normal mode - not composing
+  switch (key) {
+    case 'c':
+    case 'C':
+      // Enter compose mode - DM if on contacts screen, channel otherwise
+      if (ui_task.isOnContactsScreen()) {
+        ContactsScreen* cs = (ContactsScreen*)ui_task.getContactsScreen();
+        int idx = cs->getSelectedContactIdx();
+        uint8_t ctype = cs->getSelectedContactType();
+        if (idx >= 0 && ctype == ADV_TYPE_CHAT) {
+          composeDM = true;
+          composeDMContactIdx = idx;
+          cs->getSelectedContactName(composeDMName, sizeof(composeDMName));
+          composeMode = true;
+          composeBuffer[0] = '\0';
+          composePos = 0;
+          Serial.printf("Entering DM compose to %s (idx %d)\n", composeDMName, idx);
+          drawComposeScreen();
+          lastComposeRefresh = millis();
+        }
+      } else {
+        composeDM = false;
+        composeDMContactIdx = -1;
+        composeMode = true;
+        composeBuffer[0] = '\0';
+        composePos = 0;
+        // If on channel screen, sync compose channel with viewed channel
+        if (ui_task.isOnChannelScreen()) {
+          composeChannelIdx = ui_task.getChannelScreenViewIdx();
+        }
+        Serial.printf("Entering compose mode, channel %d\n", composeChannelIdx);
+        drawComposeScreen();
+        lastComposeRefresh = millis();
+      }
+      break;
+    
+    case 'm':
+    case 'M':
+      // Go to channel message screen
+      Serial.println("Opening channel messages");
+      ui_task.gotoChannelScreen();
+      break;
+    
+    case 'r':
+    case 'R':
+      // Open text reader
+      Serial.println("Opening text reader");
+      ui_task.gotoTextReader();
+      break;
+    
+    case 'n':
+    case 'N':
+      // Open contacts list
+      Serial.println("Opening contacts");
+      ui_task.gotoContactsScreen();
+      break;
+    
+    case 'w':
+    case 'W':
+      // Navigate up/previous (scroll on channel screen)
+      if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
+        ui_task.injectKey('w');  // Pass directly for channel/contacts switching
+      } else {
+        Serial.println("Nav: Previous");
+        ui_task.injectKey(0xF2);  // KEY_PREV
+      }
+      break;
+    
+    case 's':
+    case 'S':
+      // Navigate down/next (scroll on channel screen)
+      if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
+        ui_task.injectKey('s');  // Pass directly for channel/contacts switching
+      } else {
+        Serial.println("Nav: Next");
+        ui_task.injectKey(0xF1);  // KEY_NEXT
+      }
+      break;
+      
+    case 'a':
+    case 'A':
+      // Navigate left or switch channel (on channel screen)
+      if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
+        ui_task.injectKey('a');  // Pass directly for channel/contacts switching
+      } else {
+        Serial.println("Nav: Previous");
+        ui_task.injectKey(0xF2);  // KEY_PREV
+      }
+      break;
+      
+    case 'd':
+    case 'D':
+      // Navigate right or switch channel (on channel screen)
+      if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
+        ui_task.injectKey('d');  // Pass directly for channel/contacts switching
+      } else {
+        Serial.println("Nav: Next");
+        ui_task.injectKey(0xF1);  // KEY_NEXT
+      }
+      break;
+      
+    case '\r':
+      // Select/Enter - if on contacts screen, enter DM compose for chat contacts
+      if (ui_task.isOnContactsScreen()) {
+        ContactsScreen* cs = (ContactsScreen*)ui_task.getContactsScreen();
+        int idx = cs->getSelectedContactIdx();
+        uint8_t ctype = cs->getSelectedContactType();
+        if (idx >= 0 && ctype == ADV_TYPE_CHAT) {
+          composeDM = true;
+          composeDMContactIdx = idx;
+          cs->getSelectedContactName(composeDMName, sizeof(composeDMName));
+          composeMode = true;
+          composeBuffer[0] = '\0';
+          composePos = 0;
+          Serial.printf("Entering DM compose to %s (idx %d)\n", composeDMName, idx);
+          drawComposeScreen();
+          lastComposeRefresh = millis();
+        } else if (idx >= 0) {
+          // Non-chat contact selected (repeater, room, etc.) - future use
+          Serial.printf("Selected non-chat contact type=%d idx=%d\n", ctype, idx);
+        }
+      } else {
+        Serial.println("Nav: Enter/Select");
+        ui_task.injectKey(13);  // KEY_ENTER
+      }
+      break;
+      
+    case 'q':
+    case 'Q':
+    case '\b':
+      // If editing UTC offset on GPS page, pass through to cancel
+      if (ui_task.isEditingHomeScreen()) {
+        ui_task.injectKey('q');
+      } else {
+        // Go back to home screen
+        Serial.println("Nav: Back to home");
+        ui_task.gotoHomeScreen();
+      }
+      break;
+      
+    case 'u':
+    case 'U':
+      // UTC offset editing (on GPS home page)
+      Serial.println("Nav: UTC offset");
+      ui_task.injectKey('u');
+      break;
+      
+    case ' ':
+      // Space - also acts as next/select
+      Serial.println("Nav: Space (Next)");
+      ui_task.injectKey(0xF1);  // KEY_NEXT
+      break;
+      
+    default:
+      Serial.printf("Unhandled key in normal mode: '%c' (0x%02X)\n", key, key);
+      break;
+  }
+}
+
+void drawComposeScreen() {
+  #ifdef DISPLAY_CLASS
+  display.startFrame();
+  display.setTextSize(1);
+  display.setColor(DisplayDriver::GREEN);
+  display.setCursor(0, 0);
+  
+  // Get the channel name for display
+  char headerBuf[40];
+  if (composeDM) {
+    snprintf(headerBuf, sizeof(headerBuf), "DM: %s", composeDMName);
+  } else {
+    ChannelDetails channel;
+    if (the_mesh.getChannel(composeChannelIdx, channel)) {
+      snprintf(headerBuf, sizeof(headerBuf), "To: %s", channel.name);
+    } else {
+      snprintf(headerBuf, sizeof(headerBuf), "To: Channel %d", composeChannelIdx);
+    }
+  }
+  display.print(headerBuf);
+  
+  display.setColor(DisplayDriver::LIGHT);
+  display.drawRect(0, 11, display.width(), 1);
+  
+  display.setCursor(0, 14);
+  display.setColor(DisplayDriver::LIGHT);
+  
+  // Word wrap the compose buffer with word-boundary awareness
+  // Uses advance width (cursor movement) not bounding box width for px tracking.
+  // Advance = getTextWidth("cc") - getTextWidth("c") to get true cursor step.
+  int y = 14;
+  char charStr[2] = {0, 0};
+  char dblStr[3] = {0, 0, 0};
+  
+  int px = 0;
+  int lineW = display.width();
+  bool atWordBoundary = true;
+  
+  for (int i = 0; i < composePos; i++) {
+    uint8_t b = (uint8_t)composeBuffer[i];
+    
+    if (b == EMOJI_PAD_BYTE) continue;
+    
+    // Word wrap: when starting a new text word, check if it fits on this line
+    if (atWordBoundary && b != ' ' && !isEmojiEscape(b) && px > 0) {
+      int wordW = 0;
+      for (int j = i; j < composePos; j++) {
+        uint8_t wb = (uint8_t)composeBuffer[j];
+        if (wb == EMOJI_PAD_BYTE) continue;
+        if (wb == ' ' || isEmojiEscape(wb)) break;
+        dblStr[0] = dblStr[1] = (char)wb;
+        charStr[0] = (char)wb;
+        wordW += display.getTextWidth(dblStr) - display.getTextWidth(charStr);
+      }
+      if (px + wordW > lineW) {
+        px = 0;
+        y += 12;
+      }
+    }
+    
+    if (isEmojiEscape(b)) {
+      if (px + EMOJI_LG_W > lineW) {
+        px = 0;
+        y += 12;
+      }
+      const uint8_t* sprite = getEmojiSpriteLg(b);
+      if (sprite) {
+        display.drawXbm(px, y, sprite, EMOJI_LG_W, EMOJI_LG_H);
+      }
+      px += EMOJI_LG_W + 1;
+      display.setCursor(px, y);
+      atWordBoundary = true;
+    } else if (b == ' ') {
+      charStr[0] = ' ';
+      dblStr[0] = dblStr[1] = ' ';
+      int adv = display.getTextWidth(dblStr) - display.getTextWidth(charStr);
+      if (px + adv > lineW) {
+        px = 0;
+        y += 12;
+      } else {
+        display.setCursor(px, y);
+        display.print(charStr);
+        px += adv;
+      }
+      atWordBoundary = true;
+    } else {
+      charStr[0] = (char)b;
+      dblStr[0] = dblStr[1] = (char)b;
+      int adv = display.getTextWidth(dblStr) - display.getTextWidth(charStr);
+      if (px + adv > lineW) {
+        px = 0;
+        y += 12;
+      }
+      display.setCursor(px, y);
+      display.print(charStr);
+      px += adv;
+      atWordBoundary = false;
+    }
+  }
+  
+  // Show cursor
+  display.setCursor(px, y);
+  display.print("_");
+  
+  // Status bar
+  int statusY = display.height() - 12;
+  display.setColor(DisplayDriver::LIGHT);
+  display.drawRect(0, statusY - 2, display.width(), 1);
+  display.setCursor(0, statusY);
+  display.setColor(DisplayDriver::YELLOW);
+  
+  char status[40];
+  if (composePos == 0) {
+    // Empty buffer - show channel switching hint
+    display.print("A/D:Ch $:Emoji");
+    sprintf(status, "Sh+Del:X");
+    display.setCursor(display.width() - display.getTextWidth(status) - 2, statusY);
+    display.print(status);
+  } else {
+    // Has text - show send/cancel hint
+    sprintf(status, "%d/137 $:Emj", composePos);
+    display.print(status);
+    sprintf(status, "Sh+Del:X");
+    display.setCursor(display.width() - display.getTextWidth(status) - 2, statusY);
+    display.print(status);
+  }
+  
+  display.endFrame();
+  #endif
+}
+
+void drawEmojiPicker() {
+  #ifdef DISPLAY_CLASS
+  display.startFrame();
+  emojiPicker.draw(display);
+  display.endFrame();
+  #endif
+}
+
+void sendComposedMessage() {
+  if (composePos == 0) return;
+  
+  // Convert escape bytes back to UTF-8 for mesh transmission and BLE app
+  char utf8Buf[512];
+  emojiUnescape(composeBuffer, utf8Buf, sizeof(utf8Buf));
+
+  if (composeDM) {
+    // Direct message to a specific contact
+    if (composeDMContactIdx >= 0) {
+      if (the_mesh.uiSendDirectMessage((uint32_t)composeDMContactIdx, utf8Buf)) {
+        ui_task.showAlert("DM sent!", 1500);
+      } else {
+        ui_task.showAlert("DM failed!", 1500);
+      }
+    } else {
+      ui_task.showAlert("No contact!", 1500);
+    }
+    return;
+  }
+
+  // Channel (group) message
+  ChannelDetails channel;
+  if (the_mesh.getChannel(composeChannelIdx, channel)) {
+    uint32_t timestamp = rtc_clock.getCurrentTime();
+    int utf8Len = strlen(utf8Buf);
+    
+    if (the_mesh.sendGroupMessage(timestamp, channel.channel, 
+                                   the_mesh.getNodePrefs()->node_name, 
+                                   utf8Buf, utf8Len)) {
+      ui_task.addSentChannelMessage(composeChannelIdx, 
+                                     the_mesh.getNodePrefs()->node_name, 
+                                     utf8Buf);
+      
+      the_mesh.queueSentChannelMessage(composeChannelIdx, timestamp,
+                                        the_mesh.getNodePrefs()->node_name,
+                                        utf8Buf);
+      
+      ui_task.showAlert("Sent!", 1500);
+    } else {
+      ui_task.showAlert("Send failed!", 1500);
+    }
+  } else {
+    ui_task.showAlert("No channel!", 1500);
+  }
+}
+
+#endif // LilyGo_TDeck_Pro
--- a/examples/companion_radio/ui-new/ChannelScreen.h
+++ b/examples/companion_radio/ui-new/ChannelScreen.h
@@ -0,0 +1,377 @@
+#pragma once
+
+#include <helpers/ui/UIScreen.h>
+#include <helpers/ui/DisplayDriver.h>
+#include <helpers/ChannelDetails.h>
+#include <MeshCore.h>
+#include "EmojiSprites.h"
+
+// Maximum messages to store in history
+#define CHANNEL_MSG_HISTORY_SIZE 20
+#define CHANNEL_MSG_TEXT_LEN 160
+
+#ifndef MAX_GROUP_CHANNELS
+  #define MAX_GROUP_CHANNELS 20
+#endif
+
+class UITask;  // Forward declaration
+class MyMesh;  // Forward declaration
+extern MyMesh the_mesh;
+
+class ChannelScreen : public UIScreen {
+public:
+  struct ChannelMessage {
+    uint32_t timestamp;
+    uint8_t path_len;
+    uint8_t channel_idx;  // Which channel this message belongs to
+    char text[CHANNEL_MSG_TEXT_LEN];
+    bool valid;
+  };
+
+private:
+  UITask* _task;
+  mesh::RTCClock* _rtc;
+  
+  ChannelMessage _messages[CHANNEL_MSG_HISTORY_SIZE];
+  int _msgCount;      // Total messages stored
+  int _newestIdx;     // Index of newest message (circular buffer)
+  int _scrollPos;     // Current scroll position (0 = newest)
+  int _msgsPerPage;   // Messages that fit on screen
+  uint8_t _viewChannelIdx;  // Which channel we're currently viewing
+  
+public:
+  ChannelScreen(UITask* task, mesh::RTCClock* rtc) 
+    : _task(task), _rtc(rtc), _msgCount(0), _newestIdx(-1), _scrollPos(0), 
+      _msgsPerPage(3), _viewChannelIdx(0) {
+    // Initialize all messages as invalid
+    for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
+      _messages[i].valid = false;
+    }
+  }
+
+  // Add a new message to the history
+  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;
+    
+    ChannelMessage* msg = &_messages[_newestIdx];
+    msg->timestamp = _rtc->getCurrentTime();
+    msg->path_len = path_len;
+    msg->channel_idx = channel_idx;
+    msg->valid = true;
+    
+    // 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);
+    
+    if (_msgCount < CHANNEL_MSG_HISTORY_SIZE) {
+      _msgCount++;
+    }
+    
+    // Reset scroll to show newest message
+    _scrollPos = 0;
+  }
+
+  // Get count of messages for the currently viewed channel
+  int getMessageCountForChannel() const {
+    int count = 0;
+    for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
+      if (_messages[i].valid && _messages[i].channel_idx == _viewChannelIdx) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  int getMessageCount() const { return _msgCount; }
+  
+  uint8_t getViewChannelIdx() const { return _viewChannelIdx; }
+  void setViewChannelIdx(uint8_t idx) { _viewChannelIdx = idx; _scrollPos = 0; }
+
+  int render(DisplayDriver& display) override {
+    char tmp[40];
+    
+    // Header - show current channel name
+    display.setCursor(0, 0);
+    display.setTextSize(1);
+    display.setColor(DisplayDriver::GREEN);
+    
+    // Get channel name
+    ChannelDetails channel;
+    if (the_mesh.getChannel(_viewChannelIdx, channel)) {
+      display.print(channel.name);
+    } else {
+      sprintf(tmp, "Channel %d", _viewChannelIdx);
+      display.print(tmp);
+    }
+    
+    // Message count for this channel on right
+    int channelMsgCount = getMessageCountForChannel();
+    sprintf(tmp, "[%d]", channelMsgCount);
+    display.setCursor(display.width() - display.getTextWidth(tmp) - 2, 0);
+    display.print(tmp);
+    
+    // Divider line
+    display.drawRect(0, 11, display.width(), 1);
+    
+    if (channelMsgCount == 0) {
+      display.setTextSize(0);  // Tiny font for body text
+      display.setCursor(0, 20);
+      display.setColor(DisplayDriver::LIGHT);
+      display.print("No messages yet");
+      display.setCursor(0, 30);
+      display.print("A/D: Switch channel");
+      display.setCursor(0, 40);
+      display.print("C: Compose message");
+      display.setTextSize(1);  // Restore for footer
+    } else {
+      display.setTextSize(0);  // Tiny font for message body
+      int lineHeight = 9;   // 8px font + 1px spacing
+      int headerHeight = 14;
+      int footerHeight = 14;
+      // 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;
+      
+      int y = headerHeight;
+      
+      // Build list of messages for this channel (newest first)
+      int channelMsgs[CHANNEL_MSG_HISTORY_SIZE];
+      int numChannelMsgs = 0;
+      
+      for (int i = 0; i < _msgCount && numChannelMsgs < 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) {
+          channelMsgs[numChannelMsgs++] = idx;
+        }
+      }
+      
+      // Reverse to chronological order (oldest first, newest last at bottom)
+      for (int l = 0, r = numChannelMsgs - 1; l < r; l++, r--) {
+        int tmp = channelMsgs[l]; channelMsgs[l] = channelMsgs[r]; channelMsgs[r] = tmp;
+      }
+      
+      // 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;
+      if (startIdx < 0) startIdx = 0;
+      
+      // Display messages oldest-to-newest (top to bottom)
+      int msgsDrawn = 0;
+      for (int i = startIdx; i < numChannelMsgs && y + lineHeight <= maxY; i++) {
+        int idx = channelMsgs[i];
+        ChannelMessage* msg = &_messages[idx];
+        
+        // Time indicator with hop count - inline on same line as message start
+        display.setCursor(0, y);
+        display.setColor(DisplayDriver::YELLOW);
+        
+        uint32_t age = _rtc->getCurrentTime() - msg->timestamp;
+        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);
+        }
+        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(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();
+        int px = display.getTextWidth(tmp);  // Pixel X after timestamp
+        char dblStr[3] = {0, 0, 0};
+        
+        while (pos < textLen && linesForThisMsg < maxLinesPerMsg && y + lineHeight <= maxY) {
+          uint8_t b = (uint8_t)msg->text[pos];
+          
+          if (b == EMOJI_PAD_BYTE) { pos++; continue; }
+          
+          // Word wrap: when starting a new text word, check if it fits
+          if (b != ' ' && !isEmojiEscape(b) && px > 0) {
+            bool boundary = (pos == 0);
+            if (!boundary) {
+              for (int bp = pos - 1; bp >= 0; bp--) {
+                uint8_t pb = (uint8_t)msg->text[bp];
+                if (pb == EMOJI_PAD_BYTE) continue;
+                boundary = (pb == ' ' || isEmojiEscape(pb));
+                break;
+              }
+            }
+            if (boundary) {
+              int wordW = 0;
+              for (int j = pos; j < textLen; j++) {
+                uint8_t wb = (uint8_t)msg->text[j];
+                if (wb == EMOJI_PAD_BYTE) continue;
+                if (wb == ' ' || isEmojiEscape(wb)) break;
+                charStr[0] = (char)wb;
+                dblStr[0] = dblStr[1] = (char)wb;
+                wordW += display.getTextWidth(dblStr) - display.getTextWidth(charStr);
+              }
+              if (px + wordW > lineW) {
+                px = 0;
+                linesForThisMsg++;
+                y += lineHeight;
+                if (linesForThisMsg >= maxLinesPerMsg || y + lineHeight > maxY) break;
+              }
+            }
+          }
+          
+          if (isEmojiEscape(b)) {
+            if (px + EMOJI_SM_W > lineW) {
+              px = 0;
+              linesForThisMsg++;
+              y += lineHeight;
+              if (linesForThisMsg >= maxLinesPerMsg || y + lineHeight > maxY) break;
+            }
+            const uint8_t* sprite = getEmojiSpriteSm(b);
+            if (sprite) {
+              display.drawXbm(px, y, sprite, EMOJI_SM_W, EMOJI_SM_H);
+            }
+            pos++;
+            px += EMOJI_SM_W + 1;
+            display.setCursor(px, y);
+          } else if (b == ' ') {
+            charStr[0] = ' ';
+            dblStr[0] = dblStr[1] = ' ';
+            int adv = display.getTextWidth(dblStr) - display.getTextWidth(charStr);
+            if (px + adv > lineW) {
+              px = 0;
+              linesForThisMsg++;
+              y += lineHeight;
+              if (linesForThisMsg < maxLinesPerMsg && y + lineHeight <= maxY) {
+                // skip trailing space at wrap
+              } else break;
+            } else {
+              display.setCursor(px, y);
+              display.print(charStr);
+              px += adv;
+            }
+            pos++;
+          } else {
+            charStr[0] = (char)b;
+            dblStr[0] = dblStr[1] = (char)b;
+            int adv = display.getTextWidth(dblStr) - display.getTextWidth(charStr);
+            if (px + adv > lineW) {
+              px = 0;
+              linesForThisMsg++;
+              y += lineHeight;
+              if (linesForThisMsg < maxLinesPerMsg && y + lineHeight <= maxY) {
+                // continue to print below
+              } else break;
+            }
+            display.setCursor(px, y);
+            display.print(charStr);
+            px += adv;
+            pos++;
+          }
+        }
+        
+        // If we didn't end on a full line, still count it
+        if (px > 0) {
+          y += lineHeight;
+        }
+        
+        y += 2;  // Small gap between messages
+        msgsDrawn++;
+        _msgsPerPage = msgsDrawn;
+      }
+      
+      display.setTextSize(1);  // Restore for footer
+    }
+    
+    // Footer with controls
+    int footerY = display.height() - 12;
+    display.drawRect(0, footerY - 2, display.width(), 1);
+    display.setCursor(0, footerY);
+    display.setColor(DisplayDriver::YELLOW);
+    
+    // Left side: Q:Back A/D:Ch
+    display.print("Q:Back A/D:Ch");
+    
+    // Right side: C:New
+    const char* rightText = "C:New";
+    display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
+    display.print(rightText);
+
+#if AUTO_OFF_MILLIS == 0  // e-ink
+    return 5000;
+#else
+    return 1000;
+#endif
+  }
+
+  bool handleInput(char c) override {
+    int channelMsgCount = getMessageCountForChannel();
+    
+    // W or KEY_PREV - scroll up (older messages)
+    if (c == 0xF2 || c == 'w' || c == 'W') {
+      if (_scrollPos + _msgsPerPage < channelMsgCount) {
+        _scrollPos++;
+        return true;
+      }
+    }
+    
+    // S or KEY_NEXT - scroll down (newer messages)
+    if (c == 0xF1 || c == 's' || c == 'S') {
+      if (_scrollPos > 0) {
+        _scrollPos--;
+        return true;
+      }
+    }
+    
+    // A - previous channel
+    if (c == 'a' || c == 'A') {
+      if (_viewChannelIdx > 0) {
+        _viewChannelIdx--;
+      } else {
+        // Wrap to last valid channel
+        for (uint8_t i = MAX_GROUP_CHANNELS - 1; i > 0; i--) {
+          ChannelDetails ch;
+          if (the_mesh.getChannel(i, ch) && ch.name[0] != '\0') {
+            _viewChannelIdx = i;
+            break;
+          }
+        }
+      }
+      _scrollPos = 0;
+      return true;
+    }
+    
+    // D - next channel
+    if (c == 'd' || c == 'D') {
+      ChannelDetails ch;
+      uint8_t nextIdx = _viewChannelIdx + 1;
+      if (the_mesh.getChannel(nextIdx, ch) && ch.name[0] != '\0') {
+        _viewChannelIdx = nextIdx;
+      } else {
+        _viewChannelIdx = 0;
+      }
+      _scrollPos = 0;
+      return true;
+    }
+    
+    return false;
+  }
+  
+  // Reset scroll position to newest
+  void resetScroll() {
+    _scrollPos = 0;
+  }
+};
--- a/examples/companion_radio/ui-new/Contactsscreen.h
+++ b/examples/companion_radio/ui-new/Contactsscreen.h
@@ -0,0 +1,344 @@
+#pragma once
+
+#include <helpers/ui/UIScreen.h>
+#include <helpers/ui/DisplayDriver.h>
+#include <MeshCore.h>
+
+// Forward declarations
+class UITask;
+class MyMesh;
+extern MyMesh the_mesh;
+
+class ContactsScreen : public UIScreen {
+public:
+  // Filter modes for contact type
+  enum FilterMode {
+    FILTER_ALL = 0,
+    FILTER_CHAT,       // Companions / Chat nodes
+    FILTER_REPEATER,
+    FILTER_ROOM,       // Room servers
+    FILTER_SENSOR,
+    FILTER_COUNT       // keep last
+  };
+
+private:
+  UITask* _task;
+  mesh::RTCClock* _rtc;
+
+  int _scrollPos;        // Index into filtered list (top visible row)
+  FilterMode _filter;    // Current filter mode
+
+  // Cached filtered contact indices for efficient scrolling
+  // We rebuild this on filter change or when entering the screen
+  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;
+
+  // How many rows fit on screen (computed during render)
+  int _rowsPerPage;
+
+  // --- helpers ---
+
+  static const char* filterLabel(FilterMode f) {
+    switch (f) {
+      case FILTER_ALL:       return "All";
+      case FILTER_CHAT:      return "Chat";
+      case FILTER_REPEATER:  return "Rptr";
+      case FILTER_ROOM:      return "Room";
+      case FILTER_SENSOR:    return "Sens";
+      default:               return "?";
+    }
+  }
+
+  static char typeChar(uint8_t adv_type) {
+    switch (adv_type) {
+      case ADV_TYPE_CHAT:     return 'C';
+      case ADV_TYPE_REPEATER: return 'R';
+      case ADV_TYPE_ROOM:     return 'S';  // Server
+      default:                return '?';
+    }
+  }
+
+  bool matchesFilter(uint8_t adv_type) const {
+    switch (_filter) {
+      case FILTER_ALL:       return true;
+      case FILTER_CHAT:      return adv_type == ADV_TYPE_CHAT;
+      case FILTER_REPEATER:  return adv_type == ADV_TYPE_REPEATER;
+      case FILTER_ROOM:      return adv_type == ADV_TYPE_ROOM;
+      case FILTER_SENSOR:    return (adv_type != ADV_TYPE_CHAT &&
+                                     adv_type != ADV_TYPE_REPEATER &&
+                                     adv_type != ADV_TYPE_ROOM);
+      default:               return true;
+    }
+  }
+
+  void rebuildCache() {
+    _filteredCount = 0;
+    uint32_t numContacts = the_mesh.getNumContacts();
+    ContactInfo contact;
+    for (uint32_t i = 0; i < numContacts && _filteredCount < MAX_VISIBLE; i++) {
+      if (the_mesh.getContactByIdx(i, contact)) {
+        if (matchesFilter(contact.type)) {
+          _filteredIdx[_filteredCount] = (uint16_t)i;
+          _filteredTs[_filteredCount] = contact.last_advert_timestamp;
+          _filteredCount++;
+        }
+      }
+    }
+    // Sort by last_advert_timestamp descending (most recently seen first)
+    // 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];
+      int j = i - 1;
+      while (j >= 0 && _filteredTs[j] < tmpTs) {
+        _filteredIdx[j + 1] = _filteredIdx[j];
+        _filteredTs[j + 1]  = _filteredTs[j];
+        j--;
+      }
+      _filteredIdx[j + 1] = tmpIdx;
+      _filteredTs[j + 1]  = tmpTs;
+    }
+    _cacheValid = true;
+    // Clamp scroll position
+    if (_scrollPos >= _filteredCount) {
+      _scrollPos = (_filteredCount > 0) ? _filteredCount - 1 : 0;
+    }
+  }
+
+  // Format seconds-ago as compact string: "3s" "5m" "2h" "4d" "??"
+  static void formatAge(char* buf, size_t bufLen, uint32_t now, uint32_t timestamp) {
+    if (timestamp == 0) {
+      strncpy(buf, "--", bufLen);
+      return;
+    }
+    int secs = (int)(now - timestamp);
+    if (secs < 0) secs = 0;
+    if (secs < 60) {
+      snprintf(buf, bufLen, "%ds", secs);
+    } else if (secs < 3600) {
+      snprintf(buf, bufLen, "%dm", secs / 60);
+    } else if (secs < 86400) {
+      snprintf(buf, bufLen, "%dh", secs / 3600);
+    } else {
+      snprintf(buf, bufLen, "%dd", secs / 86400);
+    }
+  }
+
+public:
+  ContactsScreen(UITask* task, mesh::RTCClock* rtc)
+    : _task(task), _rtc(rtc), _scrollPos(0), _filter(FILTER_ALL),
+      _filteredCount(0), _cacheValid(false), _rowsPerPage(5) {}
+
+  void invalidateCache() { _cacheValid = false; }
+
+  void resetScroll() {
+    _scrollPos = 0;
+    _cacheValid = false;
+  }
+
+  FilterMode getFilter() const { return _filter; }
+
+  // Get the raw contact table index for the currently highlighted item
+  // Returns -1 if no valid selection
+  int getSelectedContactIdx() const {
+    if (_filteredCount == 0) return -1;
+    return _filteredIdx[_scrollPos];
+  }
+
+  // Get the adv_type of the currently highlighted contact
+  // Returns 0xFF if no valid selection
+  uint8_t getSelectedContactType() const {
+    if (_filteredCount == 0) return 0xFF;
+    ContactInfo contact;
+    if (!the_mesh.getContactByIdx(_filteredIdx[_scrollPos], contact)) return 0xFF;
+    return contact.type;
+  }
+
+  // Copy the name of the currently highlighted contact into buf
+  // Returns false if no valid selection
+  bool getSelectedContactName(char* buf, size_t bufLen) const {
+    if (_filteredCount == 0) return false;
+    ContactInfo contact;
+    if (!the_mesh.getContactByIdx(_filteredIdx[_scrollPos], contact)) return false;
+    strncpy(buf, contact.name, bufLen);
+    buf[bufLen - 1] = '\0';
+    return true;
+  }
+
+  int render(DisplayDriver& display) override {
+    if (!_cacheValid) rebuildCache();
+
+    char tmp[48];
+
+    // === Header ===
+    display.setTextSize(1);
+    display.setColor(DisplayDriver::GREEN);
+    display.setCursor(0, 0);
+    snprintf(tmp, sizeof(tmp), "Contacts [%s]", filterLabel(_filter));
+    display.print(tmp);
+
+    // Count on right
+    snprintf(tmp, sizeof(tmp), "%d/%d", _filteredCount, (int)the_mesh.getNumContacts());
+    display.setCursor(display.width() - display.getTextWidth(tmp) - 2, 0);
+    display.print(tmp);
+
+    // Divider
+    display.drawRect(0, 11, display.width(), 1);
+
+    // === Body - contact rows ===
+    display.setTextSize(0);  // tiny font for compact rows
+    int lineHeight = 9;      // 8px font + 1px gap
+    int headerHeight = 14;
+    int footerHeight = 14;
+    int maxY = display.height() - footerHeight;
+    int y = headerHeight;
+
+    uint32_t now = _rtc->getCurrentTime();
+    int rowsDrawn = 0;
+
+    if (_filteredCount == 0) {
+      display.setColor(DisplayDriver::LIGHT);
+      display.setCursor(0, y);
+      display.print("No contacts");
+      display.setCursor(0, y + lineHeight);
+      display.print("A/D: Change filter");
+    } else {
+      // Center visible window around selected item (TextReaderScreen pattern)
+      int maxVisible = (maxY - headerHeight) / lineHeight;
+      if (maxVisible < 3) maxVisible = 3;
+      int startIdx = max(0, min(_scrollPos - maxVisible / 2,
+                                _filteredCount - maxVisible));
+      int endIdx = min(_filteredCount, startIdx + maxVisible);
+
+      for (int i = startIdx; i < endIdx && y + lineHeight <= maxY; i++) {
+        ContactInfo contact;
+        if (!the_mesh.getContactByIdx(_filteredIdx[i], contact)) continue;
+
+        bool selected = (i == _scrollPos);
+
+        // Highlight: fill LIGHT rect first, then draw DARK text on top
+        if (selected) {
+          display.setColor(DisplayDriver::LIGHT);
+          display.fillRect(0, y + 5, display.width(), lineHeight);
+          display.setColor(DisplayDriver::DARK);
+        } else {
+          display.setColor(DisplayDriver::LIGHT);
+        }
+
+        // Set cursor AFTER fillRect so text draws on top of highlight
+        display.setCursor(0, y);
+
+        // Prefix: "> " for selected, type char + space for others
+        char prefix[4];
+        if (selected) {
+          snprintf(prefix, sizeof(prefix), ">%c", typeChar(contact.type));
+        } else {
+          snprintf(prefix, sizeof(prefix), " %c", typeChar(contact.type));
+        }
+        display.print(prefix);
+
+        // Contact name (truncated to fit)
+        char filteredName[32];
+        display.translateUTF8ToBlocks(filteredName, contact.name, sizeof(filteredName));
+
+        // Reserve space for hops + age on right side
+        char hopStr[6];
+        if (contact.out_path_len == 0xFF || contact.out_path_len == 0) {
+          strcpy(hopStr, "D");  // direct
+        } else {
+          snprintf(hopStr, sizeof(hopStr), "%d", contact.out_path_len);
+        }
+
+        char ageStr[6];
+        formatAge(ageStr, sizeof(ageStr), now, contact.last_advert_timestamp);
+
+        // Build right-side string: "hops age"
+        char rightStr[14];
+        snprintf(rightStr, sizeof(rightStr), "%sh %s", hopStr, ageStr);
+        int rightWidth = display.getTextWidth(rightStr) + 2;
+
+        // Name region: after prefix + small gap, before right info
+        int nameX = display.getTextWidth(prefix) + 2;
+        int nameMaxW = display.width() - nameX - rightWidth - 2;
+        display.drawTextEllipsized(nameX, y, nameMaxW, filteredName);
+
+        // Right-aligned: hops + age
+        display.setCursor(display.width() - rightWidth, y);
+        display.print(rightStr);
+
+        y += lineHeight;
+        rowsDrawn++;
+      }
+      _rowsPerPage = (rowsDrawn > 0) ? rowsDrawn : 1;
+    }
+
+    display.setTextSize(1);  // restore for footer
+
+    // === Footer ===
+    int footerY = display.height() - 12;
+    display.drawRect(0, footerY - 2, display.width(), 1);
+    display.setColor(DisplayDriver::YELLOW);
+
+    // Left: Q:Back
+    display.setCursor(0, footerY);
+    display.print("Q:Back");
+
+    // Center: A/D:Filter
+    const char* mid = "A/D:Filtr";
+    display.setCursor((display.width() - display.getTextWidth(mid)) / 2, footerY);
+    display.print(mid);
+
+    // Right: W/S:Scroll
+    const char* right = "W/S:Scrll";
+    display.setCursor(display.width() - display.getTextWidth(right) - 2, footerY);
+    display.print(right);
+
+    return 5000;  // e-ink: next render after 5s
+  }
+
+  bool handleInput(char c) override {
+    // W - scroll up (previous contact)
+    if (c == 'w' || c == 'W' || c == 0xF2) {
+      if (_scrollPos > 0) {
+        _scrollPos--;
+        return true;
+      }
+    }
+
+    // S - scroll down (next contact)
+    if (c == 's' || c == 'S' || c == 0xF1) {
+      if (_scrollPos < _filteredCount - 1) {
+        _scrollPos++;
+        return true;
+      }
+    }
+
+    // A - previous filter
+    if (c == 'a' || c == 'A') {
+      _filter = (FilterMode)(((int)_filter + FILTER_COUNT - 1) % FILTER_COUNT);
+      _scrollPos = 0;
+      _cacheValid = false;
+      return true;
+    }
+
+    // D - next filter
+    if (c == 'd' || c == 'D') {
+      _filter = (FilterMode)(((int)_filter + 1) % FILTER_COUNT);
+      _scrollPos = 0;
+      _cacheValid = false;
+      return true;
+    }
+
+    // Enter - select contact (future: open RepeaterAdmin for repeaters)
+    if (c == 13 || c == KEY_ENTER) {
+      // TODO Phase 3: if selected contact is a repeater, open RepeaterAdminScreen
+      // For now, just acknowledge the selection
+      return true;
+    }
+
+    return false;
+  }
+};
--- a/examples/companion_radio/ui-new/Emojisprites.h
+++ b/examples/companion_radio/ui-new/Emojisprites.h
@@ -0,0 +1,547 @@
+#pragma once
+
+// Emoji sprites for e-ink display - dual size
+// Large (12x12) for compose/picker, Small (10x10) for channel view
+// MSB-first, 2 bytes per row
+// 46 total emoji: joy/thumbsup/frown first, then 43 original (telephone removed)
+
+#include <stdint.h>
+#ifdef ESP32
+#include <pgmspace.h>
+#endif
+
+#define EMOJI_LG_W 12
+#define EMOJI_LG_H 12
+#define EMOJI_SM_W 10
+#define EMOJI_SM_H 10
+
+#define EMOJI_COUNT 46
+
+// Escape codes in 0x80+ range - safe from keyboard ASCII (32-126)
+#define EMOJI_ESCAPE_START 0x80
+#define EMOJI_ESCAPE_END   0xAD   // 0x80 + 45
+#define EMOJI_PAD_BYTE     0x7F   // DEL, not typeable (key < 127 guard)
+
+// ======== LARGE 12x12 SPRITES ========
+
+// [0] joy  (most common mesh emoji)
+static const uint8_t emoji_lg_joy[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x59,0xA0, 0x59,0xA0, 0x80,0x10, 0xA0,0x50, 0x9F,0x90, 0x40,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [1] thumbsup
+static const uint8_t emoji_lg_thumbsup[] PROGMEM = {
+  0x00,0x00, 0x70,0x00, 0x70,0x00, 0x70,0x00, 0x7F,0x80, 0xFF,0x80, 0xFF,0x80, 0x7F,0x80, 0x3F,0x80, 0x1F,0x00, 0x00,0x00, 0x00,0x00,
+};
+// [2] frown
+static const uint8_t emoji_lg_frown[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x59,0xA0, 0x59,0xA0, 0x80,0x10, 0x9F,0x90, 0xA0,0x50, 0x40,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [3] wireless
+static const uint8_t emoji_lg_wireless[] PROGMEM = {
+  0x00,0x00, 0x3F,0xC0, 0x60,0x60, 0xC0,0x30, 0x0F,0x00, 0x19,0x80, 0x30,0xC0, 0x00,0x00, 0x06,0x00, 0x0F,0x00, 0x06,0x00, 0x00,0x00,
+};
+// [4] infinity
+static const uint8_t emoji_lg_infinity[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x61,0x80, 0x92,0x40, 0x8C,0x40, 0x8C,0x40, 0x92,0x40, 0x61,0x80, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00,
+};
+// [5] trex
+static const uint8_t emoji_lg_trex[] PROGMEM = {
+  0x03,0xE0, 0x06,0xA0, 0x07,0xE0, 0x0C,0x00, 0x5C,0x00, 0x7C,0x00, 0x3C,0x00, 0x38,0x00, 0x3C,0x00, 0x36,0x00, 0x22,0x00, 0x33,0x00,
+};
+// [6] skull
+static const uint8_t emoji_lg_skull[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x59,0xA0, 0x59,0xA0, 0x40,0x20, 0x49,0x20, 0x2F,0x40, 0x1F,0x80, 0x96,0x90, 0x66,0x60, 0x36,0xC0, 0x96,0x90,
+};
+// [7] cross
+static const uint8_t emoji_lg_cross[] PROGMEM = {
+  0x0F,0x00, 0x0F,0x00, 0x0F,0x00, 0x3F,0xC0, 0x3F,0xC0, 0x3F,0xC0, 0x0F,0x00, 0x0F,0x00, 0x0F,0x00, 0x0F,0x00, 0x0F,0x00, 0x0F,0x00,
+};
+// [8] lightning
+static const uint8_t emoji_lg_lightning[] PROGMEM = {
+  0x03,0x00, 0x07,0x00, 0x0E,0x00, 0x1C,0x00, 0x3F,0x80, 0x01,0x80, 0x03,0x00, 0x06,0x00, 0x0C,0x00, 0x18,0x00, 0x30,0x00, 0x00,0x00,
+};
+// [9] tophat
+static const uint8_t emoji_lg_tophat[] PROGMEM = {
+  0x00,0x00, 0x1F,0x80, 0x3F,0xC0, 0x3F,0xC0, 0x3F,0xC0, 0x3F,0xC0, 0x3F,0xC0, 0x20,0x40, 0x7F,0xE0, 0xFF,0xF0, 0xFF,0xF0, 0x00,0x00,
+};
+// [10] motorcycle
+static const uint8_t emoji_lg_motorcycle[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x0F,0x00, 0x1F,0x80, 0x7F,0xE0, 0xDF,0xB0, 0xDF,0xB0, 0xDF,0xB0, 0xDF,0xB0, 0x60,0x60, 0x00,0x00, 0x00,0x00,
+};
+// [11] seedling
+static const uint8_t emoji_lg_seedling[] PROGMEM = {
+  0x00,0x00, 0x30,0x00, 0x79,0x80, 0x7B,0xC0, 0x33,0xC0, 0x1F,0x80, 0x06,0x00, 0x06,0x00, 0x06,0x00, 0x06,0x00, 0x00,0x00, 0x00,0x00,
+};
+// [12] flag_au
+static const uint8_t emoji_lg_flag_au[] PROGMEM = {
+  0x00,0x00, 0x32,0x40, 0x4A,0x40, 0x4A,0x40, 0x7A,0x40, 0x4A,0x40, 0x49,0x80, 0x00,0x00, 0xFF,0xF0, 0x00,0x00, 0xFF,0xF0, 0x00,0x00,
+};
+// [13] umbrella
+static const uint8_t emoji_lg_umbrella[] PROGMEM = {
+  0x06,0x00, 0x1F,0x80, 0x3F,0xC0, 0x7F,0xE0, 0xFF,0xF0, 0xDB,0x70, 0x06,0x00, 0x06,0x00, 0x06,0x00, 0x06,0x00, 0x46,0x00, 0x3C,0x00,
+};
+// [14] nazar
+static const uint8_t emoji_lg_nazar[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x4F,0x20, 0x99,0x90, 0xB6,0xD0, 0xB6,0xD0, 0xB6,0xD0, 0x99,0x90, 0x4F,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [15] globe
+static const uint8_t emoji_lg_globe[] PROGMEM = {
+  0x1F,0x80, 0x34,0xC0, 0x66,0x60, 0x4F,0x20, 0x8E,0x10, 0x86,0x10, 0x80,0x30, 0x46,0x60, 0x43,0xE0, 0x30,0xC0, 0x1F,0x80, 0x00,0x00,
+};
+// [16] radioactive
+static const uint8_t emoji_lg_radioactive[] PROGMEM = {
+  0x00,0x00, 0x22,0x40, 0x32,0xC0, 0x32,0xC0, 0x1B,0x40, 0x00,0x00, 0x0F,0x00, 0x0F,0x00, 0x00,0x00, 0x60,0x20, 0x39,0xC0, 0x0F,0x00,
+};
+// [17] cow
+static const uint8_t emoji_lg_cow[] PROGMEM = {
+  0x00,0x00, 0xC0,0x60, 0x6E,0xC0, 0x3F,0x80, 0x2A,0x80, 0x3F,0x80, 0x3F,0x80, 0x7F,0xC0, 0x5F,0x40, 0x5F,0x40, 0x11,0x00, 0x31,0x80,
+};
+// [18] alien
+static const uint8_t emoji_lg_alien[] PROGMEM = {
+  0x1F,0x80, 0x3F,0xC0, 0x7F,0xE0, 0x76,0xE0, 0xF6,0xF0, 0x96,0x90, 0x7F,0xE0, 0x36,0xC0, 0x3F,0xC0, 0x16,0x80, 0x0F,0x00, 0x06,0x00,
+};
+// [19] invader
+static const uint8_t emoji_lg_invader[] PROGMEM = {
+  0x10,0x80, 0x09,0x00, 0x1F,0x80, 0x36,0xC0, 0x7F,0xE0, 0x5F,0xA0, 0x50,0xA0, 0x50,0xA0, 0x19,0x80, 0x19,0x80, 0x30,0xC0, 0x00,0x00,
+};
+// [20] dagger
+static const uint8_t emoji_lg_dagger[] PROGMEM = {
+  0x01,0x80, 0x01,0x40, 0x01,0xA0, 0x01,0xC0, 0x01,0x80, 0x03,0x00, 0x06,0x00, 0x0C,0x00, 0x18,0x00, 0x30,0x00, 0x60,0x00, 0x40,0x00,
+};
+// [21] grimace
+static const uint8_t emoji_lg_grimace[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x59,0xA0, 0x59,0xA0, 0x40,0x20, 0x40,0x20, 0x5F,0xA0, 0x55,0x40, 0x5F,0xA0, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [22] mountain
+static const uint8_t emoji_lg_mountain[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x06,0x00, 0x0F,0x00, 0x19,0x80, 0x30,0xC0, 0x66,0x60, 0xCF,0x30, 0x9F,0x90, 0xFF,0xF0, 0xFF,0xF0, 0x00,0x00,
+};
+// [23] end_arrow
+static const uint8_t emoji_lg_end_arrow[] PROGMEM = {
+  0x00,0x00, 0x7B,0x60, 0x43,0x60, 0x42,0xA0, 0x72,0xA0, 0x43,0x60, 0x43,0x60, 0x7B,0x60, 0x00,0x00, 0x06,0x00, 0x0F,0x00, 0x06,0x00,
+};
+// [24] hollow_circle
+static const uint8_t emoji_lg_hollow_circle[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x40,0x20, 0x80,0x10, 0x80,0x10, 0x80,0x10, 0x80,0x10, 0x80,0x10, 0x40,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [25] dragon
+static const uint8_t emoji_lg_dragon[] PROGMEM = {
+  0x60,0x00, 0xF0,0x00, 0x76,0x00, 0x3F,0x00, 0x1F,0x00, 0x0F,0x00, 0x1F,0x80, 0x3F,0xC0, 0x79,0xE0, 0x30,0xC0, 0x20,0x40, 0x30,0xC0,
+};
+// [26] globe_meridians
+static const uint8_t emoji_lg_globe_meridians[] PROGMEM = {
+  0x1F,0x80, 0x26,0x40, 0x46,0x20, 0x86,0x10, 0xFF,0xF0, 0x86,0x10, 0x86,0x10, 0x46,0x20, 0x26,0x40, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [27] eggplant
+static const uint8_t emoji_lg_eggplant[] PROGMEM = {
+  0x01,0x80, 0x03,0x00, 0x07,0x00, 0x0F,0x00, 0x1F,0x00, 0x3F,0x00, 0x3F,0x00, 0x7E,0x00, 0x7C,0x00, 0x78,0x00, 0x30,0x00, 0x00,0x00,
+};
+// [28] shield
+static const uint8_t emoji_lg_shield[] PROGMEM = {
+  0x00,0x00, 0x7F,0xE0, 0x7F,0xE0, 0x6F,0x60, 0x6F,0x60, 0x6F,0x60, 0x36,0xC0, 0x3F,0xC0, 0x1F,0x80, 0x0F,0x00, 0x06,0x00, 0x00,0x00,
+};
+// [29] goggles
+static const uint8_t emoji_lg_goggles[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x00,0x00, 0x79,0xE0, 0xCF,0x30, 0x86,0x10, 0x86,0x10, 0xCF,0x30, 0x79,0xE0, 0x00,0x00, 0x00,0x00, 0x00,0x00,
+};
+// [30] lizard
+static const uint8_t emoji_lg_lizard[] PROGMEM = {
+  0x00,0x00, 0x03,0x80, 0x07,0xC0, 0x8F,0x00, 0x7F,0x00, 0x3E,0x00, 0x3F,0x80, 0x23,0xC0, 0x41,0xC0, 0x00,0xC0, 0x00,0x60, 0x00,0x20,
+};
+// [31] zany_face
+static const uint8_t emoji_lg_zany_face[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x59,0x20, 0x58,0xA0, 0x40,0x20, 0x40,0x20, 0x4F,0x20, 0x50,0xA0, 0x20,0x40, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [32] kangaroo
+static const uint8_t emoji_lg_kangaroo[] PROGMEM = {
+  0x0E,0x00, 0x1F,0x00, 0x1F,0x00, 0x0E,0x00, 0x0F,0x00, 0x07,0x80, 0x47,0x80, 0x65,0x80, 0x3C,0x80, 0x18,0x80, 0x10,0xC0, 0x18,0xF0,
+};
+// [33] feather
+static const uint8_t emoji_lg_feather[] PROGMEM = {
+  0x00,0x20, 0x00,0x60, 0x00,0xC0, 0x01,0x80, 0x03,0x00, 0x06,0x00, 0x0C,0x00, 0x18,0x00, 0x30,0x00, 0x60,0x00, 0x70,0x00, 0x00,0x00,
+};
+// [34] bright
+static const uint8_t emoji_lg_bright[] PROGMEM = {
+  0x06,0x00, 0x26,0x40, 0x16,0x80, 0x0F,0x00, 0x6F,0x60, 0x6F,0x60, 0x0F,0x00, 0x16,0x80, 0x26,0x40, 0x06,0x00, 0x00,0x00, 0x00,0x00,
+};
+// [35] part_alt
+static const uint8_t emoji_lg_part_alt[] PROGMEM = {
+  0xC0,0xC0, 0xE1,0xC0, 0xF3,0xC0, 0xDE,0xC0, 0xCC,0xC0, 0xCC,0xC0, 0xC0,0xC0, 0xC0,0xC0, 0xC0,0xC0, 0xC0,0xC0, 0x00,0x00, 0x00,0x00,
+};
+// [36] motorboat
+static const uint8_t emoji_lg_motorboat[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x02,0x00, 0x07,0x00, 0x0F,0x80, 0x1F,0xC0, 0xFF,0xF0, 0x7F,0xE0, 0x3F,0xC0, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [37] domino
+static const uint8_t emoji_lg_domino[] PROGMEM = {
+  0xFF,0xF0, 0x99,0x90, 0x80,0x10, 0x99,0x90, 0x80,0x10, 0x99,0x90, 0xFF,0xF0, 0x80,0x10, 0x80,0x10, 0x86,0x10, 0x80,0x10, 0xFF,0xF0,
+};
+// [38] satellite
+static const uint8_t emoji_lg_satellite[] PROGMEM = {
+  0x78,0x00, 0xCC,0x00, 0x84,0x00, 0xCD,0x00, 0x7B,0x00, 0x03,0x80, 0x01,0xC0, 0x00,0xE0, 0x00,0x60, 0x00,0x20, 0x00,0x00, 0x00,0x00,
+};
+// [39] customs
+static const uint8_t emoji_lg_customs[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x40,0x20, 0x4F,0x20, 0x50,0xA0, 0x50,0xA0, 0x4F,0x20, 0x42,0x20, 0x22,0x40, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [40] cowboy
+static const uint8_t emoji_lg_cowboy[] PROGMEM = {
+  0x0F,0x00, 0x0F,0x00, 0x7F,0xE0, 0xFF,0xF0, 0x00,0x00, 0x3F,0xC0, 0x59,0xA0, 0x40,0x20, 0x4F,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [41] wheel
+static const uint8_t emoji_lg_wheel[] PROGMEM = {
+  0x1F,0x80, 0x26,0x40, 0x46,0x20, 0x9F,0x90, 0xB6,0xD0, 0xFF,0xF0, 0xB6,0xD0, 0x9F,0x90, 0x46,0x20, 0x26,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [42] koala
+static const uint8_t emoji_lg_koala[] PROGMEM = {
+  0x60,0x60, 0xF0,0xF0, 0xF0,0xF0, 0x76,0xE0, 0x26,0x40, 0x2F,0x40, 0x26,0x40, 0x30,0xC0, 0x1F,0x80, 0x00,0x00, 0x00,0x00, 0x00,0x00,
+};
+// [43] control_knobs
+static const uint8_t emoji_lg_control_knobs[] PROGMEM = {
+  0x00,0x00, 0x33,0x30, 0x33,0x30, 0x33,0x30, 0x33,0x30, 0x33,0x30, 0x33,0x30, 0x7B,0x30, 0x37,0xB0, 0x33,0x70, 0x33,0x30, 0x00,0x00,
+};
+// [44] peach
+static const uint8_t emoji_lg_peach[] PROGMEM = {
+  0x06,0x00, 0x0C,0x00, 0x1E,0x00, 0x3F,0x00, 0x7F,0x80, 0x7B,0xC0, 0x7B,0xC0, 0x7B,0xC0, 0x3F,0xC0, 0x1F,0x80, 0x0F,0x00, 0x00,0x00,
+};
+// [45] racing_car
+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,
+};
+
+static const uint8_t* const EMOJI_SPRITES_LG[] PROGMEM = {
+  emoji_lg_joy, emoji_lg_thumbsup, emoji_lg_frown,
+  emoji_lg_wireless, emoji_lg_infinity, emoji_lg_trex, emoji_lg_skull, emoji_lg_cross,
+  emoji_lg_lightning, emoji_lg_tophat, emoji_lg_motorcycle, emoji_lg_seedling, emoji_lg_flag_au,
+  emoji_lg_umbrella, emoji_lg_nazar, emoji_lg_globe, emoji_lg_radioactive, emoji_lg_cow,
+  emoji_lg_alien, emoji_lg_invader, emoji_lg_dagger, emoji_lg_grimace,
+  emoji_lg_mountain, emoji_lg_end_arrow, emoji_lg_hollow_circle, emoji_lg_dragon, emoji_lg_globe_meridians,
+  emoji_lg_eggplant, emoji_lg_shield, emoji_lg_goggles, emoji_lg_lizard, emoji_lg_zany_face,
+  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,
+};
+
+// ======== SMALL 10x10 SPRITES ========
+
+static const uint8_t emoji_sm_joy[] PROGMEM = {
+  0x3F,0x00, 0x61,0x80, 0xF3,0xC0, 0x80,0x40, 0xA1,0x40, 0x9E,0x40, 0x40,0x80, 0x3F,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_thumbsup[] PROGMEM = {
+  0x70,0x00, 0x70,0x00, 0x70,0x00, 0x7F,0x00, 0xFF,0x00, 0xFF,0x00, 0x7F,0x00, 0x3E,0x00, 0x1C,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_frown[] PROGMEM = {
+  0x3F,0x00, 0x61,0x80, 0xF3,0xC0, 0x80,0x40, 0x9E,0x40, 0xA1,0x40, 0x40,0x80, 0x3F,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_wireless[] PROGMEM = {
+  0x00,0x00, 0x7F,0x80, 0xC0,0xC0, 0x1E,0x00, 0x33,0x00, 0x21,0x00, 0x00,0x00, 0x0C,0x00, 0x0C,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_infinity[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0xE7,0x00, 0x99,0x00, 0x99,0x00, 0xA5,0x00, 0x42,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_trex[] PROGMEM = {
+  0x07,0x80, 0x0F,0x80, 0x0F,0x80, 0x58,0x00, 0x78,0x00, 0x38,0x00, 0x38,0x00, 0x3C,0x00, 0x24,0x00, 0x26,0x00,
+};
+static const uint8_t emoji_sm_skull[] PROGMEM = {
+  0x3F,0x00, 0x61,0x80, 0x73,0x80, 0x40,0x80, 0x52,0x80, 0x3F,0x00, 0x3F,0x00, 0xED,0xC0, 0x6D,0x80, 0xAD,0x40,
+};
+static const uint8_t emoji_sm_cross[] PROGMEM = {
+  0x1E,0x00, 0x1E,0x00, 0x3F,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00, 0x1E,0x00, 0x1E,0x00, 0x1E,0x00, 0x1E,0x00,
+};
+static const uint8_t emoji_sm_lightning[] PROGMEM = {
+  0x06,0x00, 0x0E,0x00, 0x1C,0x00, 0x3E,0x00, 0x03,0x00, 0x06,0x00, 0x0C,0x00, 0x18,0x00, 0x30,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_tophat[] PROGMEM = {
+  0x00,0x00, 0x3F,0x00, 0x3F,0x00, 0x3F,0x00, 0x3F,0x00, 0x21,0x00, 0x7F,0x80, 0xFF,0xC0, 0xFF,0xC0, 0x00,0x00,
+};
+static const uint8_t emoji_sm_motorcycle[] PROGMEM = {
+  0x00,0x00, 0x1E,0x00, 0x7F,0x80, 0xDE,0xC0, 0xDE,0xC0, 0xDE,0xC0, 0xDE,0xC0, 0x61,0x80, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_seedling[] PROGMEM = {
+  0x00,0x00, 0x70,0x00, 0x77,0x00, 0x77,0x00, 0x3F,0x00, 0x0C,0x00, 0x0C,0x00, 0x0C,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_flag_au[] PROGMEM = {
+  0x00,0x00, 0x75,0x00, 0x55,0x00, 0x75,0x00, 0x55,0x00, 0x53,0x00, 0x00,0x00, 0xFF,0xC0, 0xFF,0xC0, 0x00,0x00,
+};
+static const uint8_t emoji_sm_umbrella[] PROGMEM = {
+  0x0C,0x00, 0x3F,0x00, 0x7F,0x80, 0xFF,0xC0, 0xF7,0xC0, 0x0C,0x00, 0x0C,0x00, 0x0C,0x00, 0x4C,0x00, 0x78,0x00,
+};
+static const uint8_t emoji_sm_nazar[] PROGMEM = {
+  0x3F,0x00, 0x40,0x80, 0x9E,0x40, 0xBF,0x40, 0xAD,0x40, 0xBF,0x40, 0x9E,0x40, 0x4C,0x80, 0x3F,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_globe[] PROGMEM = {
+  0x3F,0x00, 0x69,0x80, 0x4C,0x80, 0x9C,0x40, 0x8C,0x40, 0x80,0xC0, 0x4D,0x80, 0x67,0x80, 0x3F,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_radioactive[] PROGMEM = {
+  0x00,0x00, 0x25,0x00, 0x25,0x00, 0x37,0x00, 0x00,0x00, 0x1E,0x00, 0x1E,0x00, 0x40,0x00, 0x73,0x80, 0x1E,0x00,
+};
+static const uint8_t emoji_sm_cow[] PROGMEM = {
+  0x00,0x00, 0xC1,0x80, 0x7F,0x00, 0x3F,0x00, 0x3F,0x00, 0x7F,0x00, 0x7F,0x00, 0x7F,0x00, 0x36,0x00, 0x23,0x00,
+};
+static const uint8_t emoji_sm_alien[] PROGMEM = {
+  0x3F,0x00, 0x7F,0x80, 0x7F,0x80, 0xED,0xC0, 0xAD,0x40, 0x7F,0x80, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00, 0x0C,0x00,
+};
+static const uint8_t emoji_sm_invader[] PROGMEM = {
+  0x33,0x00, 0x1E,0x00, 0x3F,0x00, 0x7F,0x80, 0x7F,0x80, 0x61,0x80, 0x73,0x80, 0x33,0x00, 0x33,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_dagger[] PROGMEM = {
+  0x03,0x00, 0x03,0x80, 0x03,0x80, 0x03,0x00, 0x06,0x00, 0x0C,0x00, 0x18,0x00, 0x30,0x00, 0x60,0x00, 0x40,0x00,
+};
+static const uint8_t emoji_sm_grimace[] PROGMEM = {
+  0x3F,0x00, 0x61,0x80, 0x73,0x80, 0x40,0x80, 0x40,0x80, 0x7F,0x80, 0x55,0x00, 0x7F,0x80, 0x3F,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_mountain[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x0C,0x00, 0x1E,0x00, 0x33,0x00, 0x6D,0x80, 0xDE,0xC0, 0xFF,0xC0, 0xFF,0xC0, 0x00,0x00,
+};
+static const uint8_t emoji_sm_end_arrow[] PROGMEM = {
+  0x00,0x00, 0x77,0x80, 0x47,0x80, 0x65,0x80, 0x47,0x80, 0x47,0x80, 0x76,0x80, 0x0C,0x00, 0x1E,0x00, 0x0C,0x00,
+};
+static const uint8_t emoji_sm_hollow_circle[] PROGMEM = {
+  0x3F,0x00, 0x40,0x80, 0x80,0x40, 0x80,0x40, 0x80,0x40, 0x80,0x40, 0x80,0x40, 0x40,0x80, 0x3F,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_dragon[] PROGMEM = {
+  0x60,0x00, 0xE0,0x00, 0x7C,0x00, 0x3E,0x00, 0x1E,0x00, 0x3F,0x00, 0x7F,0x80, 0x73,0x80, 0x21,0x00, 0x21,0x00,
+};
+static const uint8_t emoji_sm_globe_meridians[] PROGMEM = {
+  0x3F,0x00, 0x4C,0x80, 0x8C,0x40, 0xFF,0xC0, 0x8C,0x40, 0x8C,0x40, 0x4C,0x80, 0x3F,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_eggplant[] PROGMEM = {
+  0x03,0x00, 0x06,0x00, 0x0E,0x00, 0x1E,0x00, 0x3E,0x00, 0x7E,0x00, 0x7C,0x00, 0x78,0x00, 0x70,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_shield[] PROGMEM = {
+  0x00,0x00, 0xFF,0xC0, 0xFF,0xC0, 0xDE,0xC0, 0xDE,0xC0, 0x6D,0x80, 0x7F,0x80, 0x3F,0x00, 0x1E,0x00, 0x0C,0x00,
+};
+static const uint8_t emoji_sm_goggles[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x73,0x80, 0xDE,0xC0, 0x8C,0x40, 0x8C,0x40, 0xDE,0xC0, 0x73,0x80, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_lizard[] PROGMEM = {
+  0x00,0x00, 0x07,0x00, 0x9E,0x00, 0x7E,0x00, 0x3E,0x00, 0x27,0x80, 0x43,0x00, 0x01,0x80, 0x00,0x80, 0x00,0x00,
+};
+static const uint8_t emoji_sm_zany_face[] PROGMEM = {
+  0x3F,0x00, 0x60,0x80, 0x72,0x80, 0x40,0x80, 0x40,0x80, 0x5E,0x80, 0x61,0x80, 0x3F,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_kangaroo[] PROGMEM = {
+  0x1C,0x00, 0x3E,0x00, 0x1C,0x00, 0x1E,0x00, 0x0F,0x00, 0x4F,0x00, 0x6B,0x00, 0x39,0x00, 0x31,0x00, 0x31,0xC0,
+};
+static const uint8_t emoji_sm_feather[] PROGMEM = {
+  0x00,0x80, 0x01,0x80, 0x03,0x00, 0x06,0x00, 0x0C,0x00, 0x18,0x00, 0x30,0x00, 0x60,0x00, 0x60,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_bright[] PROGMEM = {
+  0x0C,0x00, 0x2D,0x00, 0x1E,0x00, 0x5E,0x80, 0x7F,0x80, 0x1E,0x00, 0x2D,0x00, 0x0C,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_part_alt[] PROGMEM = {
+  0xC3,0x00, 0xE7,0x00, 0xDB,0x00, 0xDB,0x00, 0xC3,0x00, 0xC3,0x00, 0xC3,0x00, 0xC3,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_motorboat[] PROGMEM = {
+  0x00,0x00, 0x00,0x00, 0x0C,0x00, 0x1E,0x00, 0x3F,0x00, 0xFF,0xC0, 0x7F,0x80, 0x3F,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_domino[] PROGMEM = {
+  0xFF,0xC0, 0xB6,0x40, 0xB6,0x40, 0xB6,0x40, 0xFF,0xC0, 0x80,0x40, 0x8C,0x40, 0x80,0x40, 0xFF,0xC0, 0x00,0x00,
+};
+static const uint8_t emoji_sm_satellite[] PROGMEM = {
+  0x70,0x00, 0xD8,0x00, 0x88,0x00, 0xFE,0x00, 0x07,0x00, 0x03,0x80, 0x01,0x80, 0x00,0x80, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_customs[] PROGMEM = {
+  0x3F,0x00, 0x40,0x80, 0x4C,0x80, 0x52,0x80, 0x61,0x80, 0x5E,0x80, 0x44,0x80, 0x3F,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_cowboy[] PROGMEM = {
+  0x1E,0x00, 0x1E,0x00, 0xFF,0xC0, 0x00,0x00, 0x3F,0x00, 0x73,0x80, 0x40,0x80, 0x4C,0x80, 0x3F,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_wheel[] PROGMEM = {
+  0x3F,0x00, 0x4C,0x80, 0x9E,0x40, 0xBF,0x40, 0xFF,0xC0, 0xBF,0x40, 0x9E,0x40, 0x4C,0x80, 0x3F,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_koala[] PROGMEM = {
+  0x61,0x80, 0xE1,0xC0, 0xED,0xC0, 0x6D,0x80, 0x3F,0x00, 0x2D,0x00, 0x33,0x00, 0x1E,0x00, 0x00,0x00, 0x00,0x00,
+};
+static const uint8_t emoji_sm_control_knobs[] PROGMEM = {
+  0x00,0x00, 0x26,0xC0, 0x26,0xC0, 0x26,0xC0, 0x26,0xC0, 0x76,0xC0, 0x7E,0xC0, 0x2F,0xC0, 0x26,0xC0, 0x00,0x00,
+};
+static const uint8_t emoji_sm_peach[] PROGMEM = {
+  0x0C,0x00, 0x18,0x00, 0x3C,0x00, 0x7E,0x00, 0x77,0x00, 0x77,0x00, 0x7F,0x00, 0x3F,0x00, 0x1E,0x00, 0x00,0x00,
+};
+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,
+};
+
+static const uint8_t* const EMOJI_SPRITES_SM[] PROGMEM = {
+  emoji_sm_joy, emoji_sm_thumbsup, emoji_sm_frown,
+  emoji_sm_wireless, emoji_sm_infinity, emoji_sm_trex, emoji_sm_skull, emoji_sm_cross,
+  emoji_sm_lightning, emoji_sm_tophat, emoji_sm_motorcycle, emoji_sm_seedling, emoji_sm_flag_au,
+  emoji_sm_umbrella, emoji_sm_nazar, emoji_sm_globe, emoji_sm_radioactive, emoji_sm_cow,
+  emoji_sm_alien, emoji_sm_invader, emoji_sm_dagger, emoji_sm_grimace,
+  emoji_sm_mountain, emoji_sm_end_arrow, emoji_sm_hollow_circle, emoji_sm_dragon, emoji_sm_globe_meridians,
+  emoji_sm_eggplant, emoji_sm_shield, emoji_sm_goggles, emoji_sm_lizard, emoji_sm_zany_face,
+  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,
+};
+
+// ---- Codepoint lookup for UTF-8 conversion ----
+struct EmojiCodepoint { uint32_t cp; uint32_t cp2; uint8_t escape; };
+
+static const EmojiCodepoint EMOJI_CODEPOINTS[EMOJI_COUNT] = {
+  { 0x1F602, 0x0000, 0x80 }, // joy
+  { 0x1F44D, 0x0000, 0x81 }, // thumbsup
+  { 0x2639,  0x0000, 0x82 }, // frown
+  { 0x1F6DC, 0x0000, 0x83 }, // wireless
+  { 0x267E,  0x0000, 0x84 }, // infinity
+  { 0x1F996, 0x0000, 0x85 }, // trex
+  { 0x2620,  0x0000, 0x86 }, // skull
+  { 0x271D,  0x0000, 0x87 }, // cross
+  { 0x26A1,  0x0000, 0x88 }, // lightning
+  { 0x1F3A9, 0x0000, 0x89 }, // tophat
+  { 0x1F3CD, 0x0000, 0x8A }, // motorcycle
+  { 0x1F331, 0x0000, 0x8B }, // seedling
+  { 0x1F1E6, 0x1F1FA, 0x8C }, // flag_au
+  { 0x2602,  0x0000, 0x8D }, // umbrella
+  { 0x1F9FF, 0x0000, 0x8E }, // nazar
+  { 0x1F30F, 0x0000, 0x8F }, // globe
+  { 0x2622,  0x0000, 0x90 }, // radioactive
+  { 0x1F404, 0x0000, 0x91 }, // cow
+  { 0x1F47D, 0x0000, 0x92 }, // alien
+  { 0x1F47E, 0x0000, 0x93 }, // invader
+  { 0x1F5E1, 0x0000, 0x94 }, // dagger
+  { 0x1F62C, 0x0000, 0x95 }, // grimace
+  { 0x26F0,  0x0000, 0x96 }, // mountain
+  { 0x1F51A, 0x0000, 0x97 }, // end_arrow
+  { 0x2B55,  0x0000, 0x98 }, // hollow_circle
+  { 0x1F409, 0x0000, 0x99 }, // dragon
+  { 0x1F310, 0x0000, 0x9A }, // globe_meridians
+  { 0x1F346, 0x0000, 0x9B }, // eggplant
+  { 0x1F6E1, 0x0000, 0x9C }, // shield
+  { 0x1F97D, 0x0000, 0x9D }, // goggles
+  { 0x1F98E, 0x0000, 0x9E }, // lizard
+  { 0x1F92A, 0x0000, 0x9F }, // zany_face
+  { 0x1F998, 0x0000, 0xA0 }, // kangaroo
+  { 0x1FAB6, 0x0000, 0xA1 }, // feather
+  { 0x1F506, 0x0000, 0xA2 }, // bright
+  { 0x303D,  0x0000, 0xA3 }, // part_alt
+  { 0x1F6E5, 0x0000, 0xA4 }, // motorboat
+  { 0x1F0CE, 0x0000, 0xA5 }, // domino
+  { 0x1F4E1, 0x0000, 0xA6 }, // satellite
+  { 0x1F6C3, 0x0000, 0xA7 }, // customs
+  { 0x1F920, 0x0000, 0xA8 }, // cowboy
+  { 0x1F6DE, 0x0000, 0xA9 }, // wheel
+  { 0x1F428, 0x0000, 0xAA }, // koala
+  { 0x1F39B, 0x0000, 0xAB }, // control_knobs
+  { 0x1F351, 0x0000, 0xAC }, // peach
+  { 0x1F3CE, 0x0000, 0xAD }, // racing_car
+};
+
+// ---- Helper functions ----
+
+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; }
+  if ((b0 & 0xE0) == 0xC0 && remaining >= 2) {
+    *bytes_consumed = 2;
+    return ((uint32_t)(b0 & 0x1F) << 6) | (s[1] & 0x3F);
+  }
+  if ((b0 & 0xF0) == 0xE0 && remaining >= 3) {
+    *bytes_consumed = 3;
+    return ((uint32_t)(b0 & 0x0F) << 12) | ((uint32_t)(s[1] & 0x3F) << 6) | (s[2] & 0x3F);
+  }
+  if ((b0 & 0xF8) == 0xF0 && remaining >= 4) {
+    *bytes_consumed = 4;
+    return ((uint32_t)(b0 & 0x07) << 18) | ((uint32_t)(s[1] & 0x3F) << 12) | ((uint32_t)(s[2] & 0x3F) << 6) | (s[3] & 0x3F);
+  }
+  *bytes_consumed = 1;
+  return 0xFFFD;
+}
+
+// Convert UTF-8 text to internal format (emoji codepoints -> escape bytes)
+// Now handles ALL multi-byte UTF-8 (>= 0x80) to prevent raw high bytes in buffer
+static void emojiSanitize(const char* src, char* dst, int dstLen) {
+  const uint8_t* s = (const uint8_t*)src;
+  int si = 0, di = 0;
+  int srcLen = strlen(src);
+  while (si < srcLen && di < dstLen - 1) {
+    uint8_t b = s[si];
+    if (b >= 0x80) {
+      int consumed;
+      uint32_t cp = emojiDecodeUtf8(s + si, srcLen - si, &consumed);
+      if (cp == 0xFE0F) { si += consumed; continue; }
+      bool found = false;
+      for (int e = 0; e < EMOJI_COUNT; e++) {
+        if (EMOJI_CODEPOINTS[e].cp == cp) {
+          if (EMOJI_CODEPOINTS[e].cp2 != 0) {
+            int consumed2;
+            if (si + consumed < srcLen) {
+              uint32_t cp2 = emojiDecodeUtf8(s + si + consumed, srcLen - si - consumed, &consumed2);
+              if (cp2 == EMOJI_CODEPOINTS[e].cp2) {
+                dst[di++] = EMOJI_CODEPOINTS[e].escape;
+                si += consumed + consumed2;
+                found = true; break;
+              }
+            }
+            continue;
+          }
+          dst[di++] = EMOJI_CODEPOINTS[e].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;
+      si++;
+    }
+  }
+  dst[di] = '\0';
+}
+
+static inline bool isEmojiEscape(uint8_t b) {
+  return b >= EMOJI_ESCAPE_START && b <= EMOJI_ESCAPE_END;
+}
+
+static int emojiEncodeUtf8(uint32_t cp, uint8_t* dst) {
+  if (cp < 0x80) { dst[0] = (uint8_t)cp; return 1; }
+  if (cp < 0x800) { dst[0] = 0xC0|(cp>>6); dst[1] = 0x80|(cp&0x3F); return 2; }
+  if (cp < 0x10000) { dst[0] = 0xE0|(cp>>12); dst[1] = 0x80|((cp>>6)&0x3F); dst[2] = 0x80|(cp&0x3F); return 3; }
+  dst[0] = 0xF0|(cp>>18); dst[1] = 0x80|((cp>>12)&0x3F); dst[2] = 0x80|((cp>>6)&0x3F); dst[3] = 0x80|(cp&0x3F); return 4;
+}
+
+static void emojiUnescape(const char* src, char* dst, int dstLen) {
+  int si = 0, di = 0;
+  int srcLen = strlen(src);
+  while (si < srcLen && di < dstLen - 1) {
+    uint8_t b = (uint8_t)src[si];
+    if (b == EMOJI_PAD_BYTE) { si++; continue; }
+    if (isEmojiEscape(b)) {
+      int idx = b - EMOJI_ESCAPE_START;
+      if (idx < EMOJI_COUNT) {
+        uint8_t utf8[8];
+        int len = emojiEncodeUtf8(EMOJI_CODEPOINTS[idx].cp, utf8);
+        if (EMOJI_CODEPOINTS[idx].cp2 != 0)
+          len += emojiEncodeUtf8(EMOJI_CODEPOINTS[idx].cp2, utf8 + len);
+        if (di + len < dstLen) { memcpy(dst + di, utf8, len); di += len; } else break;
+      }
+      si++;
+    } else { dst[di++] = src[si++]; }
+  }
+  dst[di] = '\0';
+}
+
+static inline const uint8_t* getEmojiSpriteLg(uint8_t escape_byte) {
+  if (!isEmojiEscape(escape_byte)) return nullptr;
+  return (const uint8_t*)pgm_read_ptr(&EMOJI_SPRITES_LG[escape_byte - EMOJI_ESCAPE_START]);
+}
+
+static inline const uint8_t* getEmojiSpriteSm(uint8_t escape_byte) {
+  if (!isEmojiEscape(escape_byte)) return nullptr;
+  return (const uint8_t*)pgm_read_ptr(&EMOJI_SPRITES_SM[escape_byte - EMOJI_ESCAPE_START]);
+}
+
+static inline int emojiUtf8Cost(uint8_t escape_byte) {
+  if (!isEmojiEscape(escape_byte)) return 1;
+  int idx = escape_byte - EMOJI_ESCAPE_START;
+  uint32_t cp = EMOJI_CODEPOINTS[idx].cp;
+  int cost = (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
+  if (EMOJI_CODEPOINTS[idx].cp2 != 0) {
+    uint32_t cp2 = EMOJI_CODEPOINTS[idx].cp2;
+    cost += (cp2 < 0x80) ? 1 : (cp2 < 0x800) ? 2 : (cp2 < 0x10000) ? 3 : 4;
+  }
+  return cost;
+}
--- a/examples/companion_radio/ui-new/Repeateradminscreen.h
+++ b/examples/companion_radio/ui-new/Repeateradminscreen.h
@@ -0,0 +1,615 @@
+#pragma once
+
+#include <helpers/ui/UIScreen.h>
+#include <helpers/ui/DisplayDriver.h>
+#include <MeshCore.h>
+
+// Forward declarations
+class UITask;
+class MyMesh;
+extern MyMesh the_mesh;
+
+#define ADMIN_PASSWORD_MAX    32
+#define ADMIN_RESPONSE_MAX    512   // CLI responses can be multi-line
+#define ADMIN_TIMEOUT_MS      15000 // 15s timeout for login/commands
+
+class RepeaterAdminScreen : public UIScreen {
+public:
+  enum AdminState {
+    STATE_PASSWORD_ENTRY,   // Typing admin password
+    STATE_LOGGING_IN,       // Waiting for login response
+    STATE_MENU,             // Main admin menu
+    STATE_COMMAND_PENDING,  // Waiting for CLI response
+    STATE_RESPONSE_VIEW,    // Displaying CLI response
+    STATE_ERROR             // Error state (timeout, send fail)
+  };
+
+  // Menu items
+  enum MenuItem {
+    MENU_CLOCK_SYNC = 0,
+    MENU_ADVERT,
+    MENU_NEIGHBORS,
+    MENU_GET_CLOCK,
+    MENU_GET_VER,
+    MENU_GET_STATUS,
+    MENU_COUNT
+  };
+
+private:
+  UITask* _task;
+  mesh::RTCClock* _rtc;
+
+  AdminState _state;
+  int _contactIdx;              // Contact table index of the repeater
+  char _repeaterName[32];       // Cached repeater name
+  uint8_t _permissions;         // Login permissions (0=guest, 3=admin)
+  uint32_t _serverTime;         // Server timestamp from login response
+
+  // Password entry
+  char _password[ADMIN_PASSWORD_MAX];
+  int _pwdLen;
+  unsigned long _lastCharAt;      // millis() when last char typed (for brief reveal)
+
+  // Menu
+  int _menuSel;                 // Currently selected menu item
+
+  // Response buffer
+  char _response[ADMIN_RESPONSE_MAX];
+  int _responseLen;
+  int _responseScroll;          // Scroll offset for long responses
+
+  // Timing
+  unsigned long _cmdSentAt;     // millis() when command was sent
+  bool _waitingForLogin;
+
+  // Password cache - remembers passwords per repeater within session
+  static const int PWD_CACHE_SIZE = 8;
+  struct PwdCacheEntry {
+    int contactIdx;
+    char password[ADMIN_PASSWORD_MAX];
+  };
+  PwdCacheEntry _pwdCache[PWD_CACHE_SIZE];
+  int _pwdCacheCount;
+
+  // Look up cached password for a contact, returns nullptr if not found
+  const char* getCachedPassword(int contactIdx) {
+    for (int i = 0; i < _pwdCacheCount; i++) {
+      if (_pwdCache[i].contactIdx == contactIdx) return _pwdCache[i].password;
+    }
+    return nullptr;
+  }
+
+  // Save password to cache (update existing or add new, evict oldest if full)
+  void cachePassword(int contactIdx, const char* pwd) {
+    // Update existing entry
+    for (int i = 0; i < _pwdCacheCount; i++) {
+      if (_pwdCache[i].contactIdx == contactIdx) {
+        strncpy(_pwdCache[i].password, pwd, ADMIN_PASSWORD_MAX - 1);
+        _pwdCache[i].password[ADMIN_PASSWORD_MAX - 1] = '\0';
+        return;
+      }
+    }
+    // Add new entry, evict oldest if full
+    if (_pwdCacheCount < PWD_CACHE_SIZE) {
+      int slot = _pwdCacheCount++;
+      _pwdCache[slot].contactIdx = contactIdx;
+      strncpy(_pwdCache[slot].password, pwd, ADMIN_PASSWORD_MAX - 1);
+      _pwdCache[slot].password[ADMIN_PASSWORD_MAX - 1] = '\0';
+    } else {
+      // Shift entries down to evict oldest
+      for (int i = 0; i < PWD_CACHE_SIZE - 1; i++) {
+        _pwdCache[i] = _pwdCache[i + 1];
+      }
+      _pwdCache[PWD_CACHE_SIZE - 1].contactIdx = contactIdx;
+      strncpy(_pwdCache[PWD_CACHE_SIZE - 1].password, pwd, ADMIN_PASSWORD_MAX - 1);
+      _pwdCache[PWD_CACHE_SIZE - 1].password[ADMIN_PASSWORD_MAX - 1] = '\0';
+    }
+  }
+
+  static const char* menuLabel(MenuItem m) {
+    switch (m) {
+      case MENU_CLOCK_SYNC:  return "Clock Sync";
+      case MENU_ADVERT:      return "Send Advert";
+      case MENU_NEIGHBORS:   return "Neighbors";
+      case MENU_GET_CLOCK:   return "Get Clock";
+      case MENU_GET_VER:     return "Version";
+      case MENU_GET_STATUS:  return "Get Status";
+      default:               return "?";
+    }
+  }
+
+  static const char* menuCommand(MenuItem m) {
+    switch (m) {
+      case MENU_CLOCK_SYNC:  return "clock sync";
+      case MENU_ADVERT:      return "advert";
+      case MENU_NEIGHBORS:   return "neighbors";
+      case MENU_GET_CLOCK:   return "clock";
+      case MENU_GET_VER:     return "ver";
+      case MENU_GET_STATUS:  return "get status";
+      default:               return "";
+    }
+  }
+
+  // Format epoch as HH:MM:SS
+  static void formatTime(char* buf, size_t bufLen, uint32_t epoch) {
+    if (epoch == 0) {
+      strncpy(buf, "--:--:--", bufLen);
+      return;
+    }
+    uint32_t secs = epoch % 60;
+    uint32_t mins = (epoch / 60) % 60;
+    uint32_t hrs  = (epoch / 3600) % 24;
+    snprintf(buf, bufLen, "%02d:%02d:%02d", (int)hrs, (int)mins, (int)secs);
+  }
+
+public:
+  RepeaterAdminScreen(UITask* task, mesh::RTCClock* rtc)
+    : _task(task), _rtc(rtc), _state(STATE_PASSWORD_ENTRY),
+      _contactIdx(-1), _permissions(0), _serverTime(0),
+      _pwdLen(0), _lastCharAt(0), _menuSel(0),
+      _responseLen(0), _responseScroll(0),
+      _cmdSentAt(0), _waitingForLogin(false), _pwdCacheCount(0) {
+    _password[0] = '\0';
+    _repeaterName[0] = '\0';
+    _response[0] = '\0';
+  }
+
+  // Called when entering the screen for a specific repeater contact
+  void openForContact(int contactIdx, const char* name) {
+    _contactIdx = contactIdx;
+    strncpy(_repeaterName, name, sizeof(_repeaterName) - 1);
+    _repeaterName[sizeof(_repeaterName) - 1] = '\0';
+
+    // Reset state
+    _state = STATE_PASSWORD_ENTRY;
+    _lastCharAt = 0;
+    _menuSel = 0;
+    _permissions = 0;
+    _serverTime = 0;
+    _responseLen = 0;
+    _responseScroll = 0;
+    _response[0] = '\0';
+    _waitingForLogin = false;
+
+    // Pre-fill from password cache if available
+    const char* cached = getCachedPassword(contactIdx);
+    if (cached) {
+      strncpy(_password, cached, ADMIN_PASSWORD_MAX - 1);
+      _password[ADMIN_PASSWORD_MAX - 1] = '\0';
+      _pwdLen = strlen(_password);
+    } else {
+      _pwdLen = 0;
+      _password[0] = '\0';
+    }
+  }
+
+  int getContactIdx() const { return _contactIdx; }
+  AdminState getState() const { return _state; }
+
+  // Called by UITask when a login response is received
+  void onLoginResult(bool success, uint8_t permissions, uint32_t server_time) {
+    _waitingForLogin = false;
+    if (success) {
+      _permissions = permissions;
+      _serverTime = server_time;
+      _state = STATE_MENU;
+      cachePassword(_contactIdx, _password);  // remember for next time
+    } else {
+      snprintf(_response, sizeof(_response), "Login failed.\nCheck password.");
+      _responseLen = strlen(_response);
+      _state = STATE_ERROR;
+    }
+  }
+
+  // Called by UITask when a CLI response is received
+  void onCliResponse(const char* text) {
+    if (_state != STATE_COMMAND_PENDING) return;
+
+    int tlen = strlen(text);
+    if (tlen >= ADMIN_RESPONSE_MAX) tlen = ADMIN_RESPONSE_MAX - 1;
+    memcpy(_response, text, tlen);
+    _response[tlen] = '\0';
+    _responseLen = tlen;
+    _responseScroll = 0;
+    _state = STATE_RESPONSE_VIEW;
+  }
+
+  // Poll for timeouts
+  void poll() override {
+    if ((_state == STATE_LOGGING_IN || _state == STATE_COMMAND_PENDING) &&
+        _cmdSentAt > 0 && (millis() - _cmdSentAt) > ADMIN_TIMEOUT_MS) {
+      snprintf(_response, sizeof(_response), "Timeout - no response.");
+      _responseLen = strlen(_response);
+      _state = STATE_ERROR;
+    }
+  }
+
+  int render(DisplayDriver& display) override {
+    char tmp[64];
+
+    // === Header ===
+    display.setTextSize(1);
+    display.setColor(DisplayDriver::GREEN);
+    display.setCursor(0, 0);
+
+    // Truncate name if needed to fit header
+    snprintf(tmp, sizeof(tmp), "Admin: %.16s", _repeaterName);
+    display.print(tmp);
+
+    // Show permissions if logged in
+    if (_state >= STATE_MENU && _state <= STATE_RESPONSE_VIEW) {
+      const char* perm = (_permissions & 0x03) >= 3 ? "ADM" : 
+                         (_permissions & 0x03) >= 2 ? "R/W" : "R/O";
+      display.setCursor(display.width() - display.getTextWidth(perm) - 2, 0);
+      display.print(perm);
+    }
+
+    display.drawRect(0, 11, display.width(), 1);  // divider
+
+    // === Body - depends on state ===
+    int bodyY = 14;
+    int footerY = display.height() - 12;
+    int bodyHeight = footerY - bodyY - 4;
+
+    switch (_state) {
+      case STATE_PASSWORD_ENTRY:
+        renderPasswordEntry(display, bodyY);
+        break;
+      case STATE_LOGGING_IN:
+        renderWaiting(display, bodyY, "Logging in...");
+        break;
+      case STATE_MENU:
+        renderMenu(display, bodyY, bodyHeight);
+        break;
+      case STATE_COMMAND_PENDING:
+        renderWaiting(display, bodyY, "Waiting...");
+        break;
+      case STATE_RESPONSE_VIEW:
+        renderResponse(display, bodyY, bodyHeight);
+        break;
+      case STATE_ERROR:
+        renderResponse(display, bodyY, bodyHeight);  // reuse response renderer for errors
+        break;
+    }
+
+    // === Footer ===
+    display.drawRect(0, footerY - 2, display.width(), 1);
+    display.setColor(DisplayDriver::YELLOW);
+    display.setTextSize(1);
+    display.setCursor(0, footerY);
+
+    switch (_state) {
+      case STATE_PASSWORD_ENTRY:
+        display.print("Q:Back");
+        {
+          const char* right = "Enter:Login";
+          display.setCursor(display.width() - display.getTextWidth(right) - 2, footerY);
+          display.print(right);
+        }
+        break;
+      case STATE_LOGGING_IN:
+      case STATE_COMMAND_PENDING:
+        display.print("Q:Cancel");
+        break;
+      case STATE_MENU:
+        display.print("Q:Back");
+        {
+          const char* mid = "W/S:Sel";
+          display.setCursor((display.width() - display.getTextWidth(mid)) / 2, footerY);
+          display.print(mid);
+          const char* right = "Ent:Run";
+          display.setCursor(display.width() - display.getTextWidth(right) - 2, footerY);
+          display.print(right);
+        }
+        break;
+      case STATE_RESPONSE_VIEW:
+      case STATE_ERROR:
+        display.print("Q:Menu");
+        if (_responseLen > bodyHeight / 9) {  // if scrollable
+          const char* right = "W/S:Scrll";
+          display.setCursor(display.width() - display.getTextWidth(right) - 2, footerY);
+          display.print(right);
+        }
+        break;
+    }
+
+    if (_state == STATE_LOGGING_IN || _state == STATE_COMMAND_PENDING) return 1000;
+    // During password reveal, refresh when the reveal expires
+    if (_state == STATE_PASSWORD_ENTRY && _lastCharAt > 0 && (millis() - _lastCharAt) < 800) {
+      return _lastCharAt + 800 - millis() + 50;  // refresh shortly after reveal ends
+    }
+    return 5000;
+  }
+
+  bool handleInput(char c) override {
+    switch (_state) {
+      case STATE_PASSWORD_ENTRY:
+        return handlePasswordInput(c);
+      case STATE_LOGGING_IN:
+      case STATE_COMMAND_PENDING:
+        // Q to cancel and go back
+        if (c == 'q' || c == 'Q') {
+          _state = (_state == STATE_LOGGING_IN) ? STATE_PASSWORD_ENTRY : STATE_MENU;
+          return true;
+        }
+        return false;
+      case STATE_MENU:
+        return handleMenuInput(c);
+      case STATE_RESPONSE_VIEW:
+      case STATE_ERROR:
+        return handleResponseInput(c);
+    }
+    return false;
+  }
+
+private:
+  // --- Password Entry ---
+  void renderPasswordEntry(DisplayDriver& display, int y) {
+    display.setTextSize(1);
+    display.setColor(DisplayDriver::LIGHT);
+    display.setCursor(0, y);
+    display.print("Password:");
+
+    y += 14;
+    display.setColor(DisplayDriver::YELLOW);
+    display.setCursor(0, y);
+
+    // Show asterisks for password characters, with brief reveal of last char
+    char masked[ADMIN_PASSWORD_MAX];
+    int i;
+    bool revealing = (_pwdLen > 0 && (millis() - _lastCharAt) < 800);
+    int revealIdx = revealing ? _pwdLen - 1 : -1;
+    for (i = 0; i < _pwdLen && i < ADMIN_PASSWORD_MAX - 1; i++) {
+      masked[i] = (i == revealIdx) ? _password[i] : '*';
+    }
+    masked[i] = '\0';
+    display.print(masked);
+
+    // Cursor indicator
+    display.print("_");
+  }
+
+  bool handlePasswordInput(char c) {
+    // Q without any password typed = go back (return false to signal "not handled")
+    if ((c == 'q' || c == 'Q') && _pwdLen == 0) {
+      return false;
+    }
+
+    // Enter to submit
+    if (c == '\r' || c == '\n' || c == KEY_ENTER) {
+      if (_pwdLen > 0) {
+        return doLogin();
+      }
+      return true;
+    }
+
+    // Backspace
+    if (c == 0x08 || c == 0x7F) {
+      if (_pwdLen > 0) {
+        _pwdLen--;
+        _password[_pwdLen] = '\0';
+        _lastCharAt = 0;  // no reveal after delete
+      }
+      return true;
+    }
+
+    // Printable character
+    if (c >= 32 && c < 127 && _pwdLen < ADMIN_PASSWORD_MAX - 1) {
+      _password[_pwdLen++] = c;
+      _password[_pwdLen] = '\0';
+      _lastCharAt = millis();  // start brief reveal
+      return true;
+    }
+
+    return false;
+  }
+
+  bool doLogin();  // Defined below, calls into MyMesh
+
+  // --- Menu ---
+  void renderMenu(DisplayDriver& display, int y, int bodyHeight) {
+    display.setTextSize(0);  // tiny font for compact rows
+    int lineHeight = 9;
+
+    // Show server time comparison if available
+    if (_serverTime > 0) {
+      char ourTime[12], srvTime[12];
+      uint32_t now = _rtc->getCurrentTime();
+      formatTime(ourTime, sizeof(ourTime), now);
+      formatTime(srvTime, sizeof(srvTime), _serverTime);
+      
+      int drift = (int)(now - _serverTime);
+      char driftStr[24];
+      if (abs(drift) < 2) {
+        snprintf(driftStr, sizeof(driftStr), "Synced");
+      } else {
+        snprintf(driftStr, sizeof(driftStr), "Drift:%+ds", drift);
+      }
+      
+      display.setColor(DisplayDriver::LIGHT);
+      display.setCursor(0, y);
+      char info[48];
+      snprintf(info, sizeof(info), "Rpt:%s Us:%s %s", srvTime, ourTime, driftStr);
+      display.print(info);
+      y += lineHeight + 2;
+    }
+
+    // Menu items
+    for (int i = 0; i < MENU_COUNT && y + lineHeight <= display.height() - 16; i++) {
+      bool selected = (i == _menuSel);
+
+      if (selected) {
+        display.setColor(DisplayDriver::LIGHT);
+        display.fillRect(0, y + 5, display.width(), lineHeight);
+        display.setColor(DisplayDriver::DARK);
+      } else {
+        display.setColor(DisplayDriver::LIGHT);
+      }
+
+      display.setCursor(2, y);
+      char label[32];
+      snprintf(label, sizeof(label), "%s %s", selected ? ">" : " ", menuLabel((MenuItem)i));
+      display.print(label);
+
+      y += lineHeight;
+    }
+
+    display.setTextSize(1);
+  }
+
+  bool handleMenuInput(char c) {
+    // W/up - scroll up
+    if (c == 'w' || c == 'W' || c == 0xF2) {
+      if (_menuSel > 0) _menuSel--;
+      return true;
+    }
+    // S/down - scroll down
+    if (c == 's' || c == 'S' || c == 0xF1) {
+      if (_menuSel < MENU_COUNT - 1) _menuSel++;
+      return true;
+    }
+    // Enter - execute selected command
+    if (c == '\r' || c == '\n' || c == KEY_ENTER) {
+      return executeMenuCommand((MenuItem)_menuSel);
+    }
+    // Q - back to contacts
+    if (c == 'q' || c == 'Q') {
+      return false;  // let UITask handle back navigation
+    }
+    // Number keys for quick selection
+    if (c >= '1' && c <= '0' + MENU_COUNT) {
+      _menuSel = c - '1';
+      return executeMenuCommand((MenuItem)_menuSel);
+    }
+    return false;
+  }
+
+  bool executeMenuCommand(MenuItem item);  // Defined below, calls into MyMesh
+
+  // --- Response View ---
+  void renderResponse(DisplayDriver& display, int y, int bodyHeight) {
+    display.setTextSize(0);  // tiny font for more content
+    int lineHeight = 9;
+
+    display.setColor((_state == STATE_ERROR) ? DisplayDriver::YELLOW : DisplayDriver::LIGHT);
+
+    // Render response text with word wrapping and scroll support
+    int maxLines = bodyHeight / lineHeight;
+    int lineCount = 0;
+    int skipLines = _responseScroll;
+    
+    const char* p = _response;
+    char lineBuf[80];
+    int lineWidth = display.width() - 4;
+
+    while (*p && lineCount < maxLines + skipLines) {
+      // Extract next line (up to newline or screen width)
+      int i = 0;
+      while (*p && *p != '\n' && i < 79) {
+        lineBuf[i++] = *p++;
+      }
+      lineBuf[i] = '\0';
+      if (*p == '\n') p++;
+
+      if (lineCount >= skipLines && lineCount < skipLines + maxLines) {
+        display.setCursor(2, y);
+        display.print(lineBuf);
+        y += lineHeight;
+      }
+      lineCount++;
+    }
+
+    display.setTextSize(1);
+  }
+
+  bool handleResponseInput(char c) {
+    // W/up - scroll up
+    if (c == 'w' || c == 'W' || c == 0xF2) {
+      if (_responseScroll > 0) {
+        _responseScroll--;
+        return true;
+      }
+    }
+    // S/down - scroll down
+    if (c == 's' || c == 'S' || c == 0xF1) {
+      _responseScroll++;
+      return true;
+    }
+    // Q - back to menu (or back to password on error)
+    if (c == 'q' || c == 'Q') {
+      if (_state == STATE_ERROR && _permissions == 0) {
+        // Not yet logged in, go back to password
+        _state = STATE_PASSWORD_ENTRY;
+      } else {
+        _state = STATE_MENU;
+      }
+      return true;
+    }
+    // Enter - also go back to menu
+    if (c == '\r' || c == '\n' || c == KEY_ENTER) {
+      _state = STATE_MENU;
+      return true;
+    }
+    return false;
+  }
+
+  // --- Waiting spinner ---
+  void renderWaiting(DisplayDriver& display, int y, const char* msg) {
+    display.setTextSize(1);
+    display.setColor(DisplayDriver::YELLOW);
+
+    int cx = (display.width() - display.getTextWidth(msg)) / 2;
+    int cy = y + 20;
+    display.setCursor(cx, cy);
+    display.print(msg);
+
+    // Show elapsed time
+    if (_cmdSentAt > 0) {
+      char elapsed[16];
+      unsigned long secs = (millis() - _cmdSentAt) / 1000;
+      snprintf(elapsed, sizeof(elapsed), "%lus", secs);
+      display.setColor(DisplayDriver::LIGHT);
+      display.setCursor((display.width() - display.getTextWidth(elapsed)) / 2, cy + 14);
+      display.print(elapsed);
+    }
+  }
+};
+
+// --- Implementations that require MyMesh (the_mesh is declared extern above) ---
+
+inline bool RepeaterAdminScreen::doLogin() {
+  if (_contactIdx < 0 || _pwdLen == 0) return false;
+
+  if (the_mesh.uiLoginToRepeater(_contactIdx, _password)) {
+    _state = STATE_LOGGING_IN;
+    _cmdSentAt = millis();
+    _waitingForLogin = true;
+    return true;
+  } else {
+    snprintf(_response, sizeof(_response), "Send failed.\nCheck contact path.");
+    _responseLen = strlen(_response);
+    _state = STATE_ERROR;
+    return true;
+  }
+}
+
+inline bool RepeaterAdminScreen::executeMenuCommand(MenuItem item) {
+  if (_contactIdx < 0) return false;
+
+  const char* cmd = menuCommand(item);
+  if (cmd[0] == '\0') return false;
+
+  if (the_mesh.uiSendCliCommand(_contactIdx, cmd)) {
+    _state = STATE_COMMAND_PENDING;
+    _cmdSentAt = millis();
+    _response[0] = '\0';
+    _responseLen = 0;
+    _responseScroll = 0;
+    return true;
+  } else {
+    snprintf(_response, sizeof(_response), "Send failed.");
+    _responseLen = strlen(_response);
+    _state = STATE_ERROR;
+    return true;
+  }
+}
--- a/examples/companion_radio/ui-new/Textreaderscreen.h
+++ b/examples/companion_radio/ui-new/Textreaderscreen.h
--- a/examples/companion_radio/ui-new/UITask.cpp
+++ b/examples/companion_radio/ui-new/UITask.cpp
@@ -30,6 +30,9 @@
 #endif

 #include "icons.h"
+#include "ChannelScreen.h"
+#include "ContactsScreen.h"
+#include "TextReaderScreen.h"

 class SplashScreen : public UIScreen {
  UITask* _task;
@@ -99,33 +102,57 @@ class HomeScreen : public UIScreen {
  NodePrefs* _node_prefs;
  uint8_t _page;
  bool _shutdown_init;
+  bool _editing_utc;
+  int8_t _saved_utc_offset;  // for cancel/undo
  AdvertPath recent[UI_RECENT_LIST_SIZE];


-  void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts) {
-    // Convert millivolts to percentage
-    const int minMilliVolts = 3000; // Minimum voltage (e.g., 3.0V)
-    const int maxMilliVolts = 4200; // Maximum voltage (e.g., 4.2V)
-    int batteryPercentage = ((batteryMilliVolts - minMilliVolts) * 100) / (maxMilliVolts - minMilliVolts);
-    if (batteryPercentage < 0) batteryPercentage = 0; // Clamp to 0%
-    if (batteryPercentage > 100) batteryPercentage = 100; // Clamp to 100%
+void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts) {
+    // Use voltage-based estimation to match BLE app readings
+    uint8_t batteryPercentage = 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;
+    }

-    // battery icon
-    int iconWidth = 22;
-    int iconHeight = 8;
-    int iconX = display.width() - iconWidth - 5; // Position the icon near the top-right corner
-    int iconY = 0;
    display.setColor(DisplayDriver::GREEN);

+    // battery icon dimensions (smaller to match tiny percentage text)
+    int iconWidth = 16;
+    int iconHeight = 6;
+
+    // measure percentage text width to position icon + text together at right edge
+    display.setTextSize(0);
+    char pctStr[5];
+    sprintf(pctStr, "%d%%", batteryPercentage);
+    uint16_t textWidth = display.getTextWidth(pctStr);
+
+    // layout: [icon 16px][cap 2px][gap 2px][text][margin 2px]
+    int totalWidth = iconWidth + 2 + 2 + textWidth + 2;
+    int iconX = display.width() - totalWidth;
+    int iconY = 0;  // vertically align with node name text
+
    // battery outline
    display.drawRect(iconX, iconY, iconWidth, iconHeight);

    // battery "cap"
-    display.fillRect(iconX + iconWidth, iconY + (iconHeight / 4), 3, iconHeight / 2);
+    display.fillRect(iconX + iconWidth, iconY + (iconHeight / 4), 2, iconHeight / 2);

    // fill the battery based on the percentage
    int fillWidth = (batteryPercentage * (iconWidth - 4)) / 100;
    display.fillRect(iconX + 2, iconY + 2, fillWidth, iconHeight - 4);
+
+    // draw percentage text after the battery cap, offset upward to center with icon
+    // (setCursor adds +5 internally for baseline, so compensate for the tiny font)
+    int textX = iconX + iconWidth + 2 + 2;  // after cap + gap
+    int textY = iconY - 3;  // offset up to vertically center with icon
+    display.setCursor(textX, textY);
+    display.print(pctStr);
+    display.setTextSize(1);  // restore default text size
  }

  CayenneLPP sensors_lpp;
@@ -158,7 +185,15 @@ class HomeScreen : public UIScreen {
 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), sensors_lpp(200) {  }
+       _shutdown_init(false), _editing_utc(false), _saved_utc_offset(0), sensors_lpp(200) {  }
+
+  bool isEditingUTC() const { return _editing_utc; }
+  void cancelEditUTC() { 
+    if (_editing_utc) {
+      _node_prefs->utc_offset_hours = _saved_utc_offset;
+      _editing_utc = false;
+    }
+  }

  void poll() override {
    if (_shutdown_init && !_task->isButtonPressed()) {  // must wait for USR button to be released
@@ -179,6 +214,29 @@ public:
    // battery voltage
    renderBatteryIndicator(display, _task->getBattMilliVolts());

+    // centered clock (tinyfont) - only show when time is valid
+    {
+      uint32_t now = _rtc->getCurrentTime();
+      if (now > 1700000000) {  // valid timestamp (after ~Nov 2023)
+        // Apply UTC offset from prefs
+        int32_t local = (int32_t)now + ((int32_t)_node_prefs->utc_offset_hours * 3600);
+        int hrs = (local / 3600) % 24;
+        if (hrs < 0) hrs += 24;
+        int mins = (local / 60) % 60;
+        if (mins < 0) mins += 60;
+
+        char timeBuf[6];
+        sprintf(timeBuf, "%02d:%02d", hrs, mins);
+
+        display.setTextSize(0);  // tinyfont
+        display.setColor(DisplayDriver::LIGHT);
+        uint16_t tw = display.getTextWidth(timeBuf);
+        int clockX = (display.width() - tw) / 2;
+        display.setCursor(clockX, -3);  // align with battery text Y
+        display.print(timeBuf);
+        display.setTextSize(1);  // restore
+      }
+    }
    // curr page indicator
    int y = 14;
    int x = display.width() / 2 - 5 * (HomePage::Count-1);
@@ -306,6 +364,42 @@ public:
        display.drawTextRightAlign(display.width()-1, y, buf);
        y = y + 12;
      }
+      // Show RTC time and UTC offset on GPS page
+      {
+        uint32_t now = _rtc->getCurrentTime();
+        if (now > 1700000000) {
+          int32_t local = (int32_t)now + ((int32_t)_node_prefs->utc_offset_hours * 3600);
+          int hrs = (local / 3600) % 24;
+          if (hrs < 0) hrs += 24;
+          int mins = (local / 60) % 60;
+          if (mins < 0) mins += 60;
+          display.drawTextLeftAlign(0, y, "time(U)");
+          sprintf(buf, "%02d:%02d UTC%+d", hrs, mins, _node_prefs->utc_offset_hours);
+          display.drawTextRightAlign(display.width()-1, y, buf);
+        } else {
+          display.drawTextLeftAlign(0, y, "time(U)");
+          display.drawTextRightAlign(display.width()-1, y, "no sync");
+        }
+      }
+      // UTC offset editor overlay
+      if (_editing_utc) {
+        // Draw background box
+        int bx = 4, by = 20, bw = display.width() - 8, bh = 40;
+        display.setColor(DisplayDriver::DARK);
+        display.fillRect(bx, by, bw, bh);
+        display.setColor(DisplayDriver::LIGHT);
+        display.drawRect(bx, by, bw, bh);
+
+        // Show current offset value
+        display.setTextSize(2);
+        sprintf(buf, "UTC%+d", _node_prefs->utc_offset_hours);
+        display.drawTextCentered(display.width() / 2, by + 4, buf);
+
+        // Show controls hint
+        display.setTextSize(0);
+        display.drawTextCentered(display.width() / 2, by + bh - 10, "W/S:adj Enter:ok Q:cancel");
+        display.setTextSize(1);
+      }
 #endif
 #if UI_SENSORS_PAGE == 1
    } else if (_page == HomePage::SENSORS) {
@@ -389,10 +483,44 @@ public:
        display.drawTextCentered(display.width() / 2, 64 - 11, "hibernate:" PRESS_LABEL);
      }
    }
-    return 5000;   // next render after 5000 ms
+    return _editing_utc ? 700 : 5000;   // match e-ink refresh cycle while editing UTC
  }

  bool handleInput(char c) override {
+    // UTC offset editing mode - intercept all keys
+    if (_editing_utc) {
+      if (c == 'w' || c == KEY_PREV) {
+        // Increment offset
+        if (_node_prefs->utc_offset_hours < 14) {
+          _node_prefs->utc_offset_hours++;
+        }
+        return true;
+      }
+      if (c == 's' || c == KEY_NEXT) {
+        // Decrement offset
+        if (_node_prefs->utc_offset_hours > -12) {
+          _node_prefs->utc_offset_hours--;
+        }
+        return true;
+      }
+      if (c == KEY_ENTER) {
+        // Save and exit
+        Serial.printf("UTC offset saving: %d\n", _node_prefs->utc_offset_hours);
+        the_mesh.savePrefs();
+        _editing_utc = false;
+        _task->showAlert("UTC offset saved", 800);
+        Serial.println("UTC offset save complete");
+        return true;
+      }
+      if (c == 'q' || c == 'u') {
+        // Cancel - restore original value
+        _node_prefs->utc_offset_hours = _saved_utc_offset;
+        _editing_utc = false;
+        return true;
+      }
+      return true;  // Consume all other keys while editing
+    }
+
    if (c == KEY_LEFT || c == KEY_PREV) {
      _page = (_page + HomePage::Count - 1) % HomePage::Count;
      return true;
@@ -426,6 +554,11 @@ public:
      _task->toggleGPS();
      return true;
    }
+    if (c == 'u' && _page == HomePage::GPS) {
+      _editing_utc = true;
+      _saved_utc_offset = _node_prefs->utc_offset_hours;
+      return true;
+    }
 #endif
 #if UI_SENSORS_PAGE == 1
    if (c == KEY_ENTER && _page == HomePage::SENSORS) {
@@ -580,12 +713,16 @@ void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* no
  splash = new SplashScreen(this);
  home = new HomeScreen(this, &rtc_clock, sensors, node_prefs);
  msg_preview = new MsgPreviewScreen(this, &rtc_clock);
+  channel_screen = new ChannelScreen(this, &rtc_clock);
+  contacts_screen = new ContactsScreen(this, &rtc_clock);
+  text_reader = new TextReaderScreen(this);
  setCurrScreen(splash);
 }

 void UITask::showAlert(const char* text, int duration_millis) {
  strcpy(_alert, text);
  _alert_expiry = millis() + duration_millis;
+  _next_refresh = millis() + 100;  // trigger re-render to show updated text
 }

 void UITask::notify(UIEventType t) {
@@ -628,8 +765,34 @@ void UITask::msgRead(int msgcount) {
 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)
  ((MsgPreviewScreen *) msg_preview)->addPreview(path_len, from_name, text);
+  
+  // Determine channel index by looking up the channel name
+  // For channel messages, from_name is the channel name
+  // For contact messages, from_name is the contact name (channel_idx = 0xFF)
+  uint8_t channel_idx = 0xFF;  // Default: unknown/contact message
+  for (uint8_t i = 0; i < MAX_GROUP_CHANNELS; i++) {
+    ChannelDetails ch;
+    if (the_mesh.getChannel(i, ch) && strcmp(ch.name, from_name) == 0) {
+      channel_idx = i;
+      break;
+    }
+  }
+  
+  // 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
+  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);
+#endif

  if (_display != NULL) {
    if (!_display->isOn() && !hasConnection()) {
@@ -922,3 +1085,85 @@ void UITask::toggleBuzzer() {
    _next_refresh = 0;  // trigger refresh
  #endif
 }
+
+void UITask::injectKey(char c) {
+  if (c != 0 && curr) {
+    // Turn on display if it's off
+    if (_display != NULL && !_display->isOn()) {
+      _display->turnOn();
+    }
+    curr->handleInput(c);
+    _auto_off = millis() + AUTO_OFF_MILLIS;   // extend auto-off timer
+    // Debounce refresh when editing UTC offset - e-ink takes 644ms per refresh
+    // so don't queue another render until the current one could have finished
+    if (isEditingHomeScreen()) {
+      unsigned long earliest = millis() + 700;
+      if (_next_refresh < earliest) {
+        _next_refresh = earliest;
+      }
+    } else {
+      _next_refresh = 100;  // trigger refresh
+    }
+  }
+}
+
+void UITask::gotoHomeScreen() {
+  // Cancel any active editing state when navigating to home
+  ((HomeScreen *) home)->cancelEditUTC();
+  setCurrScreen(home);
+  if (_display != NULL && !_display->isOn()) {
+    _display->turnOn();
+  }
+  _auto_off = millis() + AUTO_OFF_MILLIS;
+  _next_refresh = 100;
+}
+
+bool UITask::isEditingHomeScreen() const {
+  return curr == home && ((HomeScreen *) home)->isEditingUTC();
+}
+
+void UITask::gotoChannelScreen() {
+  ((ChannelScreen *) channel_screen)->resetScroll();
+  setCurrScreen(channel_screen);
+  if (_display != NULL && !_display->isOn()) {
+    _display->turnOn();
+  }
+  _auto_off = millis() + AUTO_OFF_MILLIS;
+  _next_refresh = 100;
+}
+
+void UITask::gotoContactsScreen() {
+  ((ContactsScreen *) contacts_screen)->resetScroll();
+  setCurrScreen(contacts_screen);
+  if (_display != NULL && !_display->isOn()) {
+    _display->turnOn();
+  }
+  _auto_off = millis() + AUTO_OFF_MILLIS;
+  _next_refresh = 100;
+}
+
+void UITask::gotoTextReader() {
+  TextReaderScreen* reader = (TextReaderScreen*)text_reader;
+  if (_display != NULL) {
+    reader->enter(*_display);
+  }
+  setCurrScreen(text_reader);
+  if (_display != NULL && !_display->isOn()) {
+    _display->turnOn();
+  }
+  _auto_off = millis() + AUTO_OFF_MILLIS;
+  _next_refresh = 100;
+}
+
+uint8_t UITask::getChannelScreenViewIdx() const {
+  return ((ChannelScreen *) channel_screen)->getViewChannelIdx();
+}
+
+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];
+  snprintf(formattedMsg, sizeof(formattedMsg), "%s: %s", sender, text);
+  
+  // Add to channel history with path_len=0 (local message)
+  ((ChannelScreen *) channel_screen)->addMessage(channel_idx, 0, sender, formattedMsg);
+}
--- a/examples/companion_radio/ui-new/UITask.h
+++ b/examples/companion_radio/ui-new/UITask.h
@@ -51,6 +51,9 @@ class UITask : public AbstractUITask {
  UIScreen* splash;
  UIScreen* home;
  UIScreen* msg_preview;
+  UIScreen* channel_screen;  // Channel message history screen
+  UIScreen* contacts_screen; // Contacts list screen
+  UIScreen* text_reader;     // *** NEW: Text reader screen ***
  UIScreen* curr;

  void userLedHandler();
@@ -72,16 +75,36 @@ public:
  }
  void begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* node_prefs);

-  void gotoHomeScreen() { setCurrScreen(home); }
-  void showAlert(const char* text, int duration_millis);
+  void gotoHomeScreen();
+  void gotoChannelScreen();  // Navigate to channel message screen
+  void gotoContactsScreen(); // Navigate to contacts list
+  void gotoTextReader();     // *** NEW: Navigate to text reader ***
+  void showAlert(const char* text, int duration_millis) override;
+  void forceRefresh() override { _next_refresh = 100; }
  int  getMsgCount() const { return _msgcount; }
  bool hasDisplay() const { return _display != NULL; }
  bool isButtonPressed() const;
+  bool isOnChannelScreen() const { return curr == channel_screen; }
+  bool isOnContactsScreen() const { return curr == contacts_screen; }
+  bool isOnTextReader() const { return curr == text_reader; }  // *** NEW ***
+  bool isEditingHomeScreen() const;  // UTC offset editing on GPS page
+  uint8_t getChannelScreenViewIdx() const;

  void toggleBuzzer();
  bool getGPSState();
  void toggleGPS();

+  // Inject a key press from external source (e.g., keyboard)
+  void injectKey(char c);
+  
+  // Add a sent message to the channel screen history
+  void addSentChannelMessage(uint8_t channel_idx, const char* sender, const char* text) override;
+  
+  // Get current screen for checking state
+  UIScreen* getCurrentScreen() const { return curr; }
+  UIScreen* getMsgPreviewScreen() const { return msg_preview; }
+  UIScreen* getTextReaderScreen() const { return text_reader; }  // *** NEW ***
+  UIScreen* getContactsScreen() const { return contacts_screen; }

  // from AbstractUITask
  void msgRead(int msgcount) override;
@@ -90,4 +113,4 @@ public:
  void loop() override;

  void shutdown(bool restart = false);
-};
+};
--- a/examples/companion_radio/ui-new/emojipicker.h
+++ b/examples/companion_radio/ui-new/emojipicker.h
@@ -0,0 +1,197 @@
+#pragma once
+
+// Emoji Picker with scrolling grid and scroll bar
+// 5 columns, 4 visible rows, scrollable through all 46 emoji
+// WASD navigation, Enter to select, $/Q/Backspace to cancel
+
+#include <helpers/ui/DisplayDriver.h>
+#include "EmojiSprites.h"
+
+#define EMOJI_PICKER_COLS 5
+#define EMOJI_PICKER_VISIBLE_ROWS 4
+#define EMOJI_PICKER_TOTAL_ROWS ((EMOJI_COUNT + EMOJI_PICKER_COLS - 1) / EMOJI_PICKER_COLS)
+
+static const char* EMOJI_LABELS[EMOJI_COUNT] = {
+  "Lol",    // 0  joy
+  "Like",   // 1  thumbsup
+  "Sad",    // 2  frown
+  "WiFi",   // 3  wireless
+  "Inf",    // 4  infinity
+  "Rex",    // 5  trex
+  "Skul",   // 6  skull
+  "Cros",   // 7  cross
+  "Bolt",   // 8  lightning
+  "Hat",    // 9  tophat
+  "Moto",   // 10 motorcycle
+  "Leaf",   // 11 seedling
+  "AU",     // 12 flag_au
+  "Umbr",   // 13 umbrella
+  "Eye",    // 14 nazar
+  "Glob",   // 15 globe
+  "Rad",    // 16 radioactive
+  "Cow",    // 17 cow
+  "ET",     // 18 alien
+  "Inv",    // 19 invader
+  "Dagr",   // 20 dagger
+  "Grim",   // 21 grimace
+  "Mtn",    // 22 mountain
+  "End",    // 23 end_arrow
+  "Ring",   // 24 hollow_circle
+  "Drag",   // 25 dragon
+  "Web",    // 26 globe_meridians
+  "Eggp",   // 27 eggplant
+  "Shld",   // 28 shield
+  "Gogl",   // 29 goggles
+  "Lzrd",   // 30 lizard
+  "Zany",   // 31 zany_face
+  "Roo",    // 32 kangaroo
+  "Fthr",   // 33 feather
+  "Sun",    // 34 bright
+  "Wave",   // 35 part_alt
+  "Boat",   // 36 motorboat
+  "Domi",   // 37 domino
+  "Dish",   // 38 satellite
+  "Pass",   // 39 customs
+  "Cowb",   // 40 cowboy
+  "Whl",    // 41 wheel
+  "Koal",   // 42 koala
+  "Knob",   // 43 control_knobs
+  "Pch",    // 44 peach
+  "Race",   // 45 racing_car
+};
+
+struct EmojiPicker {
+  int cursor;
+  int scrollRow;
+  
+  EmojiPicker() : cursor(0), scrollRow(0) {}
+  
+  void reset() { cursor = 0; scrollRow = 0; }
+  
+  void ensureVisible() {
+    int cursorRow = cursor / EMOJI_PICKER_COLS;
+    if (cursorRow < scrollRow) scrollRow = cursorRow;
+    else if (cursorRow >= scrollRow + EMOJI_PICKER_VISIBLE_ROWS)
+      scrollRow = cursorRow - EMOJI_PICKER_VISIBLE_ROWS + 1;
+    int maxScroll = EMOJI_PICKER_TOTAL_ROWS - EMOJI_PICKER_VISIBLE_ROWS;
+    if (maxScroll < 0) maxScroll = 0;
+    if (scrollRow > maxScroll) scrollRow = maxScroll;
+    if (scrollRow < 0) scrollRow = 0;
+  }
+  
+  // Returns emoji escape byte, 0xFF for cancel, 0 for no action
+  uint8_t handleInput(char key) {
+    int row = cursor / EMOJI_PICKER_COLS;
+    int col = cursor % EMOJI_PICKER_COLS;
+    
+    switch (key) {
+      case 'w': case 'W': case 0xF2:
+        if (row > 0) cursor -= EMOJI_PICKER_COLS;
+        break;
+      case 's': case 'S': case 0xF1:
+        if (cursor + EMOJI_PICKER_COLS < EMOJI_COUNT)
+          cursor += EMOJI_PICKER_COLS;
+        else if (row < EMOJI_PICKER_TOTAL_ROWS - 1)
+          cursor = EMOJI_COUNT - 1;
+        break;
+      case 'a': case 'A':
+        if (cursor > 0) cursor--;
+        break;
+      case 'd': case 'D':
+        if (cursor + 1 < EMOJI_COUNT) cursor++;
+        break;
+      case '\r':
+        ensureVisible();
+        return (uint8_t)(EMOJI_ESCAPE_START + cursor);
+      case '\b': case 'q': case 'Q': case KB_KEY_EMOJI:
+        return 0xFF;
+      default:
+        return 0;
+    }
+    ensureVisible();
+    return 0;
+  }
+  
+  void draw(DisplayDriver& display) {
+    display.setTextSize(1);
+    display.setCursor(0, 0);
+    display.setColor(DisplayDriver::GREEN);
+    display.print("Select Emoji");
+    
+    display.setColor(DisplayDriver::LIGHT);
+    display.drawRect(0, 11, display.width(), 1);
+    
+    display.setTextSize(0);
+    
+    int startY = 14;
+    int scrollBarW = 4;
+    int gridW = display.width() - scrollBarW - 1;
+    int cellW = gridW / EMOJI_PICKER_COLS;
+    int footerHeight = 14;
+    int gridH = display.height() - startY - footerHeight;
+    int cellH = gridH / EMOJI_PICKER_VISIBLE_ROWS;
+    
+    for (int vr = 0; vr < EMOJI_PICKER_VISIBLE_ROWS; vr++) {
+      int absRow = scrollRow + vr;
+      if (absRow >= EMOJI_PICKER_TOTAL_ROWS) break;
+      
+      for (int col = 0; col < EMOJI_PICKER_COLS; col++) {
+        int idx = absRow * EMOJI_PICKER_COLS + col;
+        if (idx >= EMOJI_COUNT) break;
+        
+        int cx = col * cellW;
+        int cy = startY + vr * cellH;
+        
+        if (idx == cursor) {
+          display.setColor(DisplayDriver::LIGHT);
+          display.drawRect(cx, cy, cellW, cellH);
+          display.drawRect(cx + 1, cy + 1, cellW - 2, cellH - 2);
+        }
+        
+        display.setColor(DisplayDriver::LIGHT);
+        const uint8_t* sprite = (const uint8_t*)pgm_read_ptr(&EMOJI_SPRITES_LG[idx]);
+        if (sprite) {
+          int spriteX = cx + (cellW - EMOJI_LG_W) / 2;
+          int spriteY = cy + 1;
+          display.drawXbm(spriteX, spriteY, sprite, EMOJI_LG_W, EMOJI_LG_H);
+        }
+        
+        display.setColor(DisplayDriver::YELLOW);
+        uint16_t labelW = display.getTextWidth(EMOJI_LABELS[idx]);
+        int labelX = cx + (cellW - (int)labelW) / 2;
+        if (labelX < cx) labelX = cx;
+        display.setCursor(labelX, cy + 14);
+        display.print(EMOJI_LABELS[idx]);
+      }
+    }
+    
+    // Scroll bar
+    int sbX = display.width() - scrollBarW;
+    display.setColor(DisplayDriver::LIGHT);
+    display.drawRect(sbX, startY, scrollBarW, gridH);
+    
+    if (EMOJI_PICKER_TOTAL_ROWS > EMOJI_PICKER_VISIBLE_ROWS) {
+      int thumbH = (EMOJI_PICKER_VISIBLE_ROWS * gridH) / EMOJI_PICKER_TOTAL_ROWS;
+      if (thumbH < 4) thumbH = 4;
+      int maxScroll = EMOJI_PICKER_TOTAL_ROWS - EMOJI_PICKER_VISIBLE_ROWS;
+      int thumbY = startY + (scrollRow * (gridH - thumbH)) / maxScroll;
+      for (int y = thumbY + 1; y < thumbY + thumbH - 1; y++)
+        display.drawRect(sbX + 1, y, scrollBarW - 2, 1);
+    } else {
+      for (int y = startY + 1; y < startY + gridH - 1; y++)
+        display.drawRect(sbX + 1, y, scrollBarW - 2, 1);
+    }
+    
+    // Footer
+    display.setTextSize(1);
+    int footerY = display.height() - 12;
+    display.setColor(DisplayDriver::LIGHT);
+    display.drawRect(0, footerY - 2, display.width(), 1);
+    display.setCursor(0, footerY);
+    display.setColor(DisplayDriver::YELLOW);
+    display.print("WASD:Nav Ent:Pick");
+    const char* ct = "$:Back";
+    display.setCursor(display.width() - display.getTextWidth(ct) - 2, footerY);
+    display.print(ct);
+  }
+};
--- a/examples/simple_repeater/MyMesh.cpp
+++ b/examples/simple_repeater/MyMesh.cpp
--- a/src/helpers/ui/GxEPDDisplay.cpp
+++ b/src/helpers/ui/GxEPDDisplay.cpp
@@ -84,6 +84,10 @@ void GxEPDDisplay::startFrame(Color bkg) {
 void GxEPDDisplay::setTextSize(int sz) {
  display_crc.update<int>(sz);
  switch(sz) {
+    case 0:  // Tiny - built-in 6x8 pixel font
+      display.setFont(NULL);
+      display.setTextSize(1);
+      break;
    case 1:  // Small - use 9pt (was 9pt)
      display.setFont(&FreeSans9pt7b);
      break;
--- a/variants/lilygo_tdeck_pro/EpubZipReader.h
+++ b/variants/lilygo_tdeck_pro/EpubZipReader.h
@@ -0,0 +1,538 @@
+#pragma once
+// =============================================================================
+// EpubZipReader.h - Minimal ZIP reader for EPUB files on ESP32-S3
+//
+// Parses ZIP archives directly from SD card File objects.
+// Uses the ESP32 ROM's built-in tinfl decompressor for DEFLATE.
+// No external library dependencies.
+//
+// Supports:
+//   - STORED (method 0) entries - direct copy
+//   - DEFLATED (method 8) entries - ROM tinfl decompression
+//   - ZIP64 is NOT supported (EPUBs don't need it)
+//
+// Memory: Allocates decompression buffers from PSRAM when available.
+// Typical EPUB chapter is 5-50KB, well within ESP32-S3's 8MB PSRAM.
+// =============================================================================
+
+#include <SD.h>
+#include <FS.h>
+
+// ROM tinfl decompressor - built into ESP32/ESP32-S3 ROM
+// If this include fails on your platform, see the fallback note at bottom
+#if __has_include(<rom/miniz.h>)
+  #include <rom/miniz.h>
+  #define HAS_ROM_TINFL 1
+#elif __has_include(<esp32s3/rom/miniz.h>)
+  #include <esp32s3/rom/miniz.h>
+  #define HAS_ROM_TINFL 1
+#elif __has_include(<esp32/rom/miniz.h>)
+  #include <esp32/rom/miniz.h>
+  #define HAS_ROM_TINFL 1
+#else
+  #warning "ROM miniz not found - DEFLATED entries will not be supported"
+  #define HAS_ROM_TINFL 0
+#endif
+
+// ---- ZIP format constants ----
+#define ZIP_LOCAL_FILE_HEADER_SIG   0x04034b50
+#define ZIP_CENTRAL_DIR_SIG         0x02014b50
+#define ZIP_END_OF_CENTRAL_DIR_SIG  0x06054b50
+
+#define ZIP_METHOD_STORED   0
+#define ZIP_METHOD_DEFLATED 8
+
+// Maximum files we track in a ZIP (EPUBs typically have 20-100 files)
+#define ZIP_MAX_ENTRIES 128
+
+// Maximum filename length within the ZIP
+#define ZIP_MAX_FILENAME 128
+
+// ---- Data structures ----
+
+struct ZipEntry {
+  char     filename[ZIP_MAX_FILENAME];
+  uint16_t compressionMethod;   // 0=STORED, 8=DEFLATED
+  uint32_t compressedSize;
+  uint32_t uncompressedSize;
+  uint32_t localHeaderOffset;   // Offset to local file header in ZIP
+  uint32_t crc32;
+};
+
+// ---- Helper: read little-endian values from a byte buffer ----
+
+static inline uint16_t zipRead16(const uint8_t* p) {
+  return (uint16_t)p[0] | ((uint16_t)p[1] << 8);
+}
+
+static inline uint32_t zipRead32(const uint8_t* p) {
+  return (uint32_t)p[0] | ((uint32_t)p[1] << 8) |
+         ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
+}
+
+// =============================================================================
+// EpubZipReader class
+// =============================================================================
+
+class EpubZipReader {
+public:
+  EpubZipReader() : _entryCount(0), _isOpen(false), _entries(nullptr) {
+    // Allocate entries array from PSRAM to avoid stack overflow
+    // (128 entries × ~146 bytes = ~19KB — too large for 8KB loopTask stack)
+#ifdef BOARD_HAS_PSRAM
+    _entries = (ZipEntry*)ps_malloc(ZIP_MAX_ENTRIES * sizeof(ZipEntry));
+#endif
+    if (!_entries) {
+      _entries = (ZipEntry*)malloc(ZIP_MAX_ENTRIES * sizeof(ZipEntry));
+    }
+    if (!_entries) {
+      Serial.println("ZipReader: FATAL - failed to allocate entry table");
+    }
+  }
+
+  ~EpubZipReader() {
+    if (_entries) {
+      free(_entries);
+      _entries = nullptr;
+    }
+  }
+
+  // ----------------------------------------------------------
+  // Open a ZIP file and parse its central directory.
+  // Returns true on success, false on error.
+  // After open(), entries are available via getEntryCount()/getEntry().
+  // ----------------------------------------------------------
+  bool open(File& zipFile) {
+    _isOpen = false;
+    _entryCount = 0;
+
+    if (!_entries) {
+      Serial.println("ZipReader: entry table not allocated");
+      return false;
+    }
+
+    if (!zipFile || !zipFile.available()) {
+      Serial.println("ZipReader: file not valid");
+      return false;
+    }
+
+    _file = zipFile;
+    uint32_t fileSize = _file.size();
+
+    if (fileSize < 22) {
+      Serial.println("ZipReader: file too small for ZIP");
+      return false;
+    }
+
+    // ---- Step 1: Find the End of Central Directory record ----
+    // EOCD is at least 22 bytes, at end of file.
+    // Search backwards from end for the EOCD signature.
+    // Comment can be up to 65535 bytes, but EPUBs typically have none.
+    uint32_t searchStart = (fileSize > 65557) ? (fileSize - 65557) : 0;
+    uint32_t eocdOffset = 0;
+    bool foundEocd = false;
+
+    // Read the last chunk into a buffer to search for EOCD signature
+    uint32_t searchLen = fileSize - searchStart;
+    // Cap search buffer to a reasonable size
+    if (searchLen > 1024) {
+      searchStart = fileSize - 1024;
+      searchLen = 1024;
+    }
+
+    uint8_t* searchBuf = (uint8_t*)_allocBuffer(searchLen);
+    if (!searchBuf) {
+      Serial.println("ZipReader: failed to alloc search buffer");
+      return false;
+    }
+
+    _file.seek(searchStart);
+    if (_file.read(searchBuf, searchLen) != (int)searchLen) {
+      free(searchBuf);
+      Serial.println("ZipReader: failed to read EOCD area");
+      return false;
+    }
+
+    // Scan backwards for EOCD signature (0x06054b50)
+    for (int i = (int)searchLen - 22; i >= 0; i--) {
+      if (zipRead32(&searchBuf[i]) == ZIP_END_OF_CENTRAL_DIR_SIG) {
+        eocdOffset = searchStart + i;
+        // Parse EOCD fields
+        uint16_t totalEntries = zipRead16(&searchBuf[i + 10]);
+        uint32_t cdSize       = zipRead32(&searchBuf[i + 12]);
+        uint32_t cdOffset     = zipRead32(&searchBuf[i + 16]);
+
+        _cdOffset = cdOffset;
+        _cdSize = cdSize;
+        _totalEntries = totalEntries;
+        foundEocd = true;
+        break;
+      }
+    }
+    free(searchBuf);
+
+    if (!foundEocd) {
+      Serial.println("ZipReader: EOCD not found - not a valid ZIP");
+      return false;
+    }
+
+    Serial.printf("ZipReader: EOCD found at %u, %u entries, CD at %u (%u bytes)\n",
+                  eocdOffset, _totalEntries, _cdOffset, _cdSize);
+
+    // ---- Step 2: Parse Central Directory entries ----
+    if (_cdSize == 0 || _cdSize > 512 * 1024) {
+      Serial.println("ZipReader: central directory size unreasonable");
+      return false;
+    }
+
+    uint8_t* cdBuf = (uint8_t*)_allocBuffer(_cdSize);
+    if (!cdBuf) {
+      Serial.printf("ZipReader: failed to alloc %u bytes for central directory\n", _cdSize);
+      return false;
+    }
+
+    _file.seek(_cdOffset);
+    if (_file.read(cdBuf, _cdSize) != (int)_cdSize) {
+      free(cdBuf);
+      Serial.println("ZipReader: failed to read central directory");
+      return false;
+    }
+
+    uint32_t pos = 0;
+    _entryCount = 0;
+
+    while (pos + 46 <= _cdSize && _entryCount < ZIP_MAX_ENTRIES) {
+      if (zipRead32(&cdBuf[pos]) != ZIP_CENTRAL_DIR_SIG) {
+        break;  // No more central directory entries
+      }
+
+      uint16_t method       = zipRead16(&cdBuf[pos + 10]);
+      uint32_t crc          = zipRead32(&cdBuf[pos + 16]);
+      uint32_t compSize     = zipRead32(&cdBuf[pos + 20]);
+      uint32_t uncompSize   = zipRead32(&cdBuf[pos + 24]);
+      uint16_t fnLen        = zipRead16(&cdBuf[pos + 28]);
+      uint16_t extraLen     = zipRead16(&cdBuf[pos + 30]);
+      uint16_t commentLen   = zipRead16(&cdBuf[pos + 32]);
+      uint32_t localOffset  = zipRead32(&cdBuf[pos + 42]);
+
+      // Copy filename (truncate if necessary)
+      int copyLen = (fnLen < ZIP_MAX_FILENAME - 1) ? fnLen : ZIP_MAX_FILENAME - 1;
+      memcpy(_entries[_entryCount].filename, &cdBuf[pos + 46], copyLen);
+      _entries[_entryCount].filename[copyLen] = '\0';
+
+      _entries[_entryCount].compressionMethod = method;
+      _entries[_entryCount].compressedSize = compSize;
+      _entries[_entryCount].uncompressedSize = uncompSize;
+      _entries[_entryCount].localHeaderOffset = localOffset;
+      _entries[_entryCount].crc32 = crc;
+
+      // Skip directories (filenames ending with '/')
+      if (copyLen > 0 && _entries[_entryCount].filename[copyLen - 1] != '/') {
+        _entryCount++;
+      }
+
+      // Advance past this central directory entry
+      pos += 46 + fnLen + extraLen + commentLen;
+    }
+
+    free(cdBuf);
+
+    Serial.printf("ZipReader: parsed %d file entries\n", _entryCount);
+    _isOpen = true;
+    return true;
+  }
+
+  // ----------------------------------------------------------
+  // Close the reader (does not close the underlying File).
+  // ----------------------------------------------------------
+  void close() {
+    _isOpen = false;
+    _entryCount = 0;
+  }
+
+  // ----------------------------------------------------------
+  // Get entry count and entries
+  // ----------------------------------------------------------
+  int getEntryCount() const { return _entryCount; }
+
+  const ZipEntry* getEntry(int index) const {
+    if (index < 0 || index >= _entryCount) return nullptr;
+    return &_entries[index];
+  }
+
+  // ----------------------------------------------------------
+  // Find an entry by filename (case-sensitive).
+  // Returns index, or -1 if not found.
+  // ----------------------------------------------------------
+  int findEntry(const char* filename) const {
+    for (int i = 0; i < _entryCount; i++) {
+      if (strcmp(_entries[i].filename, filename) == 0) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  // ----------------------------------------------------------
+  // Find an entry by filename suffix (e.g., ".opf", ".ncx").
+  // Returns index of first match, or -1 if not found.
+  // ----------------------------------------------------------
+  int findEntryBySuffix(const char* suffix) const {
+    int suffixLen = strlen(suffix);
+    for (int i = 0; i < _entryCount; i++) {
+      int fnLen = strlen(_entries[i].filename);
+      if (fnLen >= suffixLen &&
+          strcasecmp(&_entries[i].filename[fnLen - suffixLen], suffix) == 0) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  // ----------------------------------------------------------
+  // Find entries matching a path prefix (e.g., "OEBPS/").
+  // Fills matchIndices[] up to maxMatches. Returns count found.
+  // ----------------------------------------------------------
+  int findEntriesByPrefix(const char* prefix, int* matchIndices, int maxMatches) const {
+    int count = 0;
+    int prefixLen = strlen(prefix);
+    for (int i = 0; i < _entryCount && count < maxMatches; i++) {
+      if (strncmp(_entries[i].filename, prefix, prefixLen) == 0) {
+        matchIndices[count++] = i;
+      }
+    }
+    return count;
+  }
+
+  // ----------------------------------------------------------
+  // Extract a file entry to a newly allocated buffer.
+  //
+  // On success, returns a malloc'd buffer (caller must free!)
+  // and sets *outSize to the uncompressed size.
+  //
+  // On failure, returns nullptr.
+  //
+  // The buffer is allocated from PSRAM if available.
+  // ----------------------------------------------------------
+  uint8_t* extractEntry(int index, uint32_t* outSize) {
+    if (!_isOpen || index < 0 || index >= _entryCount) {
+      return nullptr;
+    }
+
+    const ZipEntry& entry = _entries[index];
+
+    // ---- Read the local file header to get actual data offset ----
+    // Local header: 30 bytes fixed + variable filename + extra field
+    uint8_t localHeader[30];
+    _file.seek(entry.localHeaderOffset);
+    if (_file.read(localHeader, 30) != 30) {
+      Serial.println("ZipReader: failed to read local header");
+      return nullptr;
+    }
+
+    if (zipRead32(localHeader) != ZIP_LOCAL_FILE_HEADER_SIG) {
+      Serial.println("ZipReader: bad local header signature");
+      return nullptr;
+    }
+
+    uint16_t localFnLen    = zipRead16(&localHeader[26]);
+    uint16_t localExtraLen = zipRead16(&localHeader[28]);
+    uint32_t dataOffset = entry.localHeaderOffset + 30 + localFnLen + localExtraLen;
+
+    // ---- Handle based on compression method ----
+    if (entry.compressionMethod == ZIP_METHOD_STORED) {
+      return _extractStored(dataOffset, entry.uncompressedSize, outSize);
+    }
+    else if (entry.compressionMethod == ZIP_METHOD_DEFLATED) {
+      return _extractDeflated(dataOffset, entry.compressedSize,
+                              entry.uncompressedSize, outSize);
+    }
+    else {
+      Serial.printf("ZipReader: unsupported compression method %d for %s\n",
+                    entry.compressionMethod, entry.filename);
+      return nullptr;
+    }
+  }
+
+  // ----------------------------------------------------------
+  // Extract a file entry by filename.
+  // Convenience wrapper around findEntry() + extractEntry().
+  // ----------------------------------------------------------
+  uint8_t* extractByName(const char* filename, uint32_t* outSize) {
+    int idx = findEntry(filename);
+    if (idx < 0) return nullptr;
+    return extractEntry(idx, outSize);
+  }
+
+  // ----------------------------------------------------------
+  // Check if reader is open and valid
+  // ----------------------------------------------------------
+  bool isOpen() const { return _isOpen; }
+
+  // ----------------------------------------------------------
+  // Debug: print all entries
+  // ----------------------------------------------------------
+  void printEntries() const {
+    Serial.printf("ZIP contains %d files:\n", _entryCount);
+    for (int i = 0; i < _entryCount; i++) {
+      const ZipEntry& e = _entries[i];
+      Serial.printf("  [%d] %s (%s, %u -> %u bytes)\n",
+                    i, e.filename,
+                    e.compressionMethod == 0 ? "STORED" : "DEFLATED",
+                    e.compressedSize, e.uncompressedSize);
+    }
+  }
+
+private:
+  File       _file;
+  ZipEntry*  _entries;           // Heap-allocated (PSRAM) entry table
+  int        _entryCount;
+  bool       _isOpen;
+  uint32_t   _cdOffset;
+  uint32_t   _cdSize;
+  uint16_t   _totalEntries;
+
+  // ----------------------------------------------------------
+  // Allocate buffer, preferring PSRAM if available
+  // ----------------------------------------------------------
+  void* _allocBuffer(size_t size) {
+    void* buf = nullptr;
+#ifdef BOARD_HAS_PSRAM
+    buf = ps_malloc(size);
+#endif
+    if (!buf) {
+      buf = malloc(size);
+    }
+    return buf;
+  }
+
+  // ----------------------------------------------------------
+  // Extract a STORED (uncompressed) entry
+  // ----------------------------------------------------------
+  uint8_t* _extractStored(uint32_t dataOffset, uint32_t size, uint32_t* outSize) {
+    uint8_t* buf = (uint8_t*)_allocBuffer(size + 1);  // +1 for null terminator
+    if (!buf) {
+      Serial.printf("ZipReader: failed to alloc %u bytes for stored entry\n", size);
+      return nullptr;
+    }
+
+    _file.seek(dataOffset);
+    uint32_t bytesRead = _file.read(buf, size);
+    if (bytesRead != size) {
+      Serial.printf("ZipReader: short read (got %u, expected %u)\n", bytesRead, size);
+      free(buf);
+      return nullptr;
+    }
+
+    buf[size] = '\0';  // Null-terminate for text files
+    *outSize = size;
+
+    // Release SD CS pin for other SPI users
+    digitalWrite(SDCARD_CS, HIGH);
+
+    return buf;
+  }
+
+  // ----------------------------------------------------------
+  // Extract a DEFLATED entry using ROM tinfl
+  // ----------------------------------------------------------
+  uint8_t* _extractDeflated(uint32_t dataOffset, uint32_t compSize,
+                            uint32_t uncompSize, uint32_t* outSize) {
+#if HAS_ROM_TINFL
+    // Allocate compressed data buffer (from PSRAM)
+    uint8_t* compBuf = (uint8_t*)_allocBuffer(compSize);
+    if (!compBuf) {
+      Serial.printf("ZipReader: failed to alloc %u bytes for compressed data\n", compSize);
+      return nullptr;
+    }
+
+    // Allocate output buffer (+1 for null terminator)
+    uint8_t* outBuf = (uint8_t*)_allocBuffer(uncompSize + 1);
+    if (!outBuf) {
+      Serial.printf("ZipReader: failed to alloc %u bytes for decompressed data\n", uncompSize);
+      free(compBuf);
+      return nullptr;
+    }
+
+    // Heap-allocate the decompressor (~11KB struct - too large for 8KB loopTask stack!)
+    tinfl_decompressor* decomp = (tinfl_decompressor*)_allocBuffer(sizeof(tinfl_decompressor));
+    if (!decomp) {
+      Serial.printf("ZipReader: failed to alloc tinfl_decompressor (%u bytes)\n",
+                    (uint32_t)sizeof(tinfl_decompressor));
+      free(compBuf);
+      free(outBuf);
+      return nullptr;
+    }
+
+    // Read compressed data from file
+    _file.seek(dataOffset);
+    if (_file.read(compBuf, compSize) != (int)compSize) {
+      Serial.println("ZipReader: failed to read compressed data");
+      free(decomp);
+      free(compBuf);
+      free(outBuf);
+      return nullptr;
+    }
+
+    // Release SD CS pin for other SPI users
+    digitalWrite(SDCARD_CS, HIGH);
+
+    // Decompress using ROM tinfl (low-level API to avoid stack allocation)
+    // ZIP DEFLATE is raw deflate (no zlib header).
+    tinfl_init(decomp);
+
+    size_t inBytes = compSize;
+    size_t outBytes = uncompSize;
+    tinfl_status status = tinfl_decompress(
+      decomp,
+      (const mz_uint8*)compBuf,    // compressed input
+      &inBytes,                     // in: available, out: consumed
+      outBuf,                       // output buffer base
+      outBuf,                       // current output position
+      &outBytes,                    // in: available, out: produced
+      TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF  // raw deflate, single-shot
+    );
+
+    free(decomp);
+    free(compBuf);
+
+    if (status != TINFL_STATUS_DONE) {
+      Serial.printf("ZipReader: DEFLATE failed (status %d)\n", (int)status);
+      free(outBuf);
+      return nullptr;
+    }
+
+    outBuf[outBytes] = '\0';  // Null-terminate for text files
+    *outSize = (uint32_t)outBytes;
+
+    if (outBytes != uncompSize) {
+      Serial.printf("ZipReader: decompressed %u bytes, expected %u\n",
+                    (uint32_t)outBytes, uncompSize);
+    }
+
+    return outBuf;
+
+#else
+    // No ROM tinfl available
+    Serial.println("ZipReader: DEFLATE not supported (no ROM tinfl)");
+    *outSize = 0;
+    return nullptr;
+#endif
+  }
+};
+
+// =============================================================================
+// FALLBACK NOTE:
+//
+// If the ROM tinfl includes fail to compile on your ESP32 variant, you have
+// two options:
+//
+// 1. Install lbernstone/miniz-esp32 from PlatformIO:
+//      lib_deps = https://github.com/lbernstone/miniz-esp32.git
+//    Then change the includes above to: #include <miniz.h>
+//
+// 2. Copy just the tinfl source (~550 lines) from:
+//      https://github.com/richgel999/miniz/blob/master/miniz_tinfl.c
+//    into your project. Only tinfl_decompress_mem_to_mem() is needed.
+//
+// =============================================================================
--- a/variants/lilygo_tdeck_pro/Epubprocessor.h
+++ b/variants/lilygo_tdeck_pro/Epubprocessor.h
@@ -0,0 +1,841 @@
+#pragma once
+// =============================================================================
+// EpubProcessor.h - Convert EPUB files to plain text for TextReaderScreen
+//
+// Pipeline: EPUB (ZIP) → container.xml → OPF spine → extract chapters →
+//           strip XHTML tags → concatenated plain text → cached .txt on SD
+//
+// The resulting .txt file is placed in /books/ and picked up automatically
+// by TextReaderScreen's existing pagination, indexing, and bookmarking.
+//
+// Dependencies: EpubZipReader.h (for ZIP extraction)
+// =============================================================================
+
+#include <SD.h>
+#include <FS.h>
+#include "EpubZipReader.h"
+
+// Maximum chapters in spine (most novels have 20-80)
+#define EPUB_MAX_CHAPTERS 200
+
+// Maximum manifest items we track
+#define EPUB_MAX_MANIFEST 256
+
+// Buffer size for reading OPF/container XML
+// (These are small files, typically 1-20KB)
+#define EPUB_XML_BUF_SIZE 64
+
+class EpubProcessor {
+public:
+
+  // ----------------------------------------------------------
+  // Process an EPUB file: extract text and write to SD cache.
+  //
+  // epubPath:  source, e.g. "/books/The Iliad.epub"
+  // txtPath:   output, e.g. "/books/The Iliad by Homer.txt"
+  //
+  // Returns true if the .txt file was written successfully.
+  // If txtPath already exists, returns true immediately (cached).
+  // ----------------------------------------------------------
+  static bool processToText(const char* epubPath, const char* txtPath) {
+    // Check if already cached
+    if (SD.exists(txtPath)) {
+      Serial.printf("EpubProc: '%s' already cached\n", txtPath);
+      return true;
+    }
+
+    Serial.printf("EpubProc: Processing '%s'\n", epubPath);
+    unsigned long t0 = millis();
+
+    // Open the EPUB (ZIP archive)
+    File epubFile = SD.open(epubPath, FILE_READ);
+    if (!epubFile) {
+      Serial.println("EpubProc: Cannot open EPUB file");
+      return false;
+    }
+
+    // Heap-allocate zip reader (entries table is ~19KB)
+    EpubZipReader* zip = new EpubZipReader();
+    if (!zip) {
+      epubFile.close();
+      Serial.println("EpubProc: Cannot allocate ZipReader");
+      return false;
+    }
+
+    if (!zip->open(epubFile)) {
+      delete zip;
+      epubFile.close();
+      Serial.println("EpubProc: Cannot parse ZIP structure");
+      return false;
+    }
+
+    // Step 1: Find OPF path from container.xml
+    char opfPath[EPUB_XML_BUF_SIZE];
+    opfPath[0] = '\0';
+    if (!_findOpfPath(zip, opfPath, sizeof(opfPath))) {
+      delete zip;
+      epubFile.close();
+      Serial.println("EpubProc: Cannot find OPF path");
+      return false;
+    }
+    Serial.printf("EpubProc: OPF at '%s'\n", opfPath);
+
+    // Determine the content base directory (e.g., "OEBPS/")
+    char baseDir[EPUB_XML_BUF_SIZE];
+    _getDirectory(opfPath, baseDir, sizeof(baseDir));
+
+    // Step 2: Parse OPF to get title and spine chapter order
+    char title[128];
+    title[0] = '\0';
+
+    // Chapter paths in spine order
+    char** chapterPaths = nullptr;
+    int chapterCount = 0;
+
+    if (!_parseOpf(zip, opfPath, baseDir, title, sizeof(title),
+                   &chapterPaths, &chapterCount)) {
+      delete zip;
+      epubFile.close();
+      Serial.println("EpubProc: Cannot parse OPF");
+      return false;
+    }
+
+    Serial.printf("EpubProc: Title='%s', %d chapters\n", title, chapterCount);
+
+    // Step 3: Extract each chapter, strip XHTML, write to output .txt
+    File outFile = SD.open(txtPath, FILE_WRITE);
+    if (!outFile) {
+      _freeChapterPaths(chapterPaths, chapterCount);
+      delete zip;
+      epubFile.close();
+      Serial.printf("EpubProc: Cannot create '%s'\n", txtPath);
+      return false;
+    }
+
+    // Write title as first line
+    if (title[0]) {
+      outFile.println(title);
+      outFile.println();
+    }
+
+    int chaptersWritten = 0;
+    uint32_t totalBytes = 0;
+
+    for (int i = 0; i < chapterCount; i++) {
+      int entryIdx = zip->findEntry(chapterPaths[i]);
+      if (entryIdx < 0) {
+        Serial.printf("EpubProc: Chapter not found: '%s'\n", chapterPaths[i]);
+        continue;
+      }
+
+      uint32_t rawSize = 0;
+      uint8_t* rawData = zip->extractEntry(entryIdx, &rawSize);
+      if (!rawData || rawSize == 0) {
+        Serial.printf("EpubProc: Failed to extract chapter %d\n", i);
+        if (rawData) free(rawData);
+        continue;
+      }
+
+      // Strip XHTML tags and write plain text
+      uint32_t textLen = 0;
+      uint8_t* plainText = _stripXhtml(rawData, rawSize, &textLen);
+      free(rawData);
+
+      if (plainText && textLen > 0) {
+        outFile.write(plainText, textLen);
+        // Add chapter separator
+        outFile.print("\n\n");
+        totalBytes += textLen + 2;
+        chaptersWritten++;
+      }
+      if (plainText) free(plainText);
+    }
+
+    outFile.flush();
+    outFile.close();
+
+    // Release SD CS for other SPI users
+    digitalWrite(SDCARD_CS, HIGH);
+
+    _freeChapterPaths(chapterPaths, chapterCount);
+    delete zip;
+    epubFile.close();
+
+    unsigned long elapsed = millis() - t0;
+    Serial.printf("EpubProc: Done! %d chapters, %u bytes in %lu ms -> '%s'\n",
+                  chaptersWritten, totalBytes, elapsed, txtPath);
+
+    return chaptersWritten > 0;
+  }
+
+  // ----------------------------------------------------------
+  // Extract just the title from an EPUB (for display in file list).
+  // Returns false if it can't be determined.
+  // ----------------------------------------------------------
+  static bool getTitle(const char* epubPath, char* titleBuf, int titleBufSize) {
+    File epubFile = SD.open(epubPath, FILE_READ);
+    if (!epubFile) return false;
+
+    EpubZipReader* zip = new EpubZipReader();
+    if (!zip) { epubFile.close(); return false; }
+
+    if (!zip->open(epubFile)) {
+      delete zip; epubFile.close(); return false;
+    }
+
+    char opfPath[EPUB_XML_BUF_SIZE];
+    if (!_findOpfPath(zip, opfPath, sizeof(opfPath))) {
+      delete zip; epubFile.close(); return false;
+    }
+
+    // Extract OPF and find <dc:title>
+    int opfIdx = zip->findEntry(opfPath);
+    if (opfIdx < 0) { delete zip; epubFile.close(); return false; }
+
+    uint32_t opfSize = 0;
+    uint8_t* opfData = zip->extractEntry(opfIdx, &opfSize);
+    delete zip;
+    epubFile.close();
+
+    if (!opfData) return false;
+
+    bool found = _extractTagContent((const char*)opfData, opfSize,
+                                     "dc:title", titleBuf, titleBufSize);
+    free(opfData);
+    return found;
+  }
+
+  // ----------------------------------------------------------
+  // Build a cache .txt path from an .epub path.
+  // e.g., "/books/mybook.epub" -> "/books/.epub_cache/mybook.txt"
+  // ----------------------------------------------------------
+  static void buildCachePath(const char* epubPath, char* cachePath, int cachePathSize) {
+    // Extract filename without extension
+    const char* lastSlash = strrchr(epubPath, '/');
+    const char* filename = lastSlash ? lastSlash + 1 : epubPath;
+    
+    // Find the directory part
+    char dir[128];
+    if (lastSlash) {
+      int dirLen = lastSlash - epubPath;
+      if (dirLen >= (int)sizeof(dir)) dirLen = sizeof(dir) - 1;
+      strncpy(dir, epubPath, dirLen);
+      dir[dirLen] = '\0';
+    } else {
+      strcpy(dir, "/books");
+    }
+
+    // Create cache directory if needed
+    char cacheDir[160];
+    snprintf(cacheDir, sizeof(cacheDir), "%s/.epub_cache", dir);
+    if (!SD.exists(cacheDir)) {
+      SD.mkdir(cacheDir);
+    }
+
+    // Strip .epub extension
+    char baseName[128];
+    strncpy(baseName, filename, sizeof(baseName) - 1);
+    baseName[sizeof(baseName) - 1] = '\0';
+    char* dot = strrchr(baseName, '.');
+    if (dot) *dot = '\0';
+
+    snprintf(cachePath, cachePathSize, "%s/%s.txt", cacheDir, baseName);
+  }
+
+private:
+
+  // ----------------------------------------------------------
+  // Parse container.xml to find the OPF file path.
+  // Returns true if found.
+  // ----------------------------------------------------------
+  static bool _findOpfPath(EpubZipReader* zip, char* opfPath, int opfPathSize) {
+    int idx = zip->findEntry("META-INF/container.xml");
+    if (idx < 0) {
+      // Fallback: find any .opf file directly
+      idx = zip->findEntryBySuffix(".opf");
+      if (idx >= 0) {
+        const ZipEntry* e = zip->getEntry(idx);
+        strncpy(opfPath, e->filename, opfPathSize - 1);
+        opfPath[opfPathSize - 1] = '\0';
+        return true;
+      }
+      return false;
+    }
+
+    uint32_t size = 0;
+    uint8_t* data = zip->extractEntry(idx, &size);
+    if (!data) return false;
+
+    // Find: full-path="OEBPS/content.opf"
+    bool found = _extractAttribute((const char*)data, size,
+                                    "full-path", opfPath, opfPathSize);
+    free(data);
+    return found;
+  }
+
+  // ----------------------------------------------------------
+  // Parse OPF to extract title, build manifest, and resolve spine.
+  //
+  // Populates chapterPaths (heap-allocated array of strings) with
+  // full ZIP paths for each chapter in spine order.
+  // Caller must free with _freeChapterPaths().
+  // ----------------------------------------------------------
+  static bool _parseOpf(EpubZipReader* zip, const char* opfPath,
+                         const char* baseDir, char* title, int titleSize,
+                         char*** outChapterPaths, int* outChapterCount) {
+    int opfIdx = zip->findEntry(opfPath);
+    if (opfIdx < 0) return false;
+
+    uint32_t opfSize = 0;
+    uint8_t* opfData = zip->extractEntry(opfIdx, &opfSize);
+    if (!opfData) return false;
+
+    const char* xml = (const char*)opfData;
+
+    // Extract title
+    _extractTagContent(xml, opfSize, "dc:title", title, titleSize);
+
+    // Build manifest: map id -> href
+    // We use two parallel arrays to avoid complex data structures
+    struct ManifestItem {
+      char id[64];
+      char href[128];
+      bool isContent;  // has media-type containing "html" or "xml"
+    };
+
+    // Heap-allocate manifest (could be large)
+    ManifestItem* manifest = (ManifestItem*)ps_malloc(
+        EPUB_MAX_MANIFEST * sizeof(ManifestItem));
+    if (!manifest) {
+      manifest = (ManifestItem*)malloc(EPUB_MAX_MANIFEST * sizeof(ManifestItem));
+    }
+    if (!manifest) {
+      free(opfData);
+      return false;
+    }
+    int manifestCount = 0;
+
+    // Parse <item> elements from <manifest>
+    const char* manifestStart = _findTag(xml, opfSize, "<manifest");
+    const char* manifestEnd = manifestStart ?
+        _findTag(manifestStart, opfSize - (manifestStart - xml), "</manifest") : nullptr;
+    if (!manifestEnd) manifestEnd = xml + opfSize;
+
+    if (manifestStart) {
+      const char* pos = manifestStart;
+      while (pos < manifestEnd && manifestCount < EPUB_MAX_MANIFEST) {
+        pos = _findTag(pos, manifestEnd - pos, "<item");
+        if (!pos || pos >= manifestEnd) break;
+
+        // Find the closing > of this <item ... />
+        const char* tagEnd = (const char*)memchr(pos, '>', manifestEnd - pos);
+        if (!tagEnd) break;
+        tagEnd++;
+
+        ManifestItem& item = manifest[manifestCount];
+        item.id[0] = '\0';
+        item.href[0] = '\0';
+        item.isContent = false;
+
+        _extractAttributeFromTag(pos, tagEnd - pos, "id",
+                                  item.id, sizeof(item.id));
+        _extractAttributeFromTag(pos, tagEnd - pos, "href",
+                                  item.href, sizeof(item.href));
+
+        // Check media-type for content files
+        char mediaType[64];
+        mediaType[0] = '\0';
+        _extractAttributeFromTag(pos, tagEnd - pos, "media-type",
+                                  mediaType, sizeof(mediaType));
+        item.isContent = (strstr(mediaType, "html") != nullptr ||
+                          strstr(mediaType, "xml") != nullptr);
+
+        if (item.id[0] && item.href[0]) {
+          manifestCount++;
+        }
+
+        pos = tagEnd;
+      }
+    }
+
+    Serial.printf("EpubProc: Manifest has %d items\n", manifestCount);
+
+    // Parse <spine> to get reading order
+    // Spine contains <itemref idref="..."/> elements
+    const char* spineStart = _findTag(xml, opfSize, "<spine");
+    const char* spineEnd = spineStart ?
+        _findTag(spineStart, opfSize - (spineStart - xml), "</spine") : nullptr;
+    if (!spineEnd) spineEnd = xml + opfSize;
+
+    // Collect spine idrefs
+    char** chapterPaths = (char**)ps_malloc(EPUB_MAX_CHAPTERS * sizeof(char*));
+    if (!chapterPaths) chapterPaths = (char**)malloc(EPUB_MAX_CHAPTERS * sizeof(char*));
+    if (!chapterPaths) {
+      free(manifest);
+      free(opfData);
+      return false;
+    }
+    int chapterCount = 0;
+
+    if (spineStart) {
+      const char* pos = spineStart;
+      while (pos < spineEnd && chapterCount < EPUB_MAX_CHAPTERS) {
+        pos = _findTag(pos, spineEnd - pos, "<itemref");
+        if (!pos || pos >= spineEnd) break;
+
+        const char* tagEnd = (const char*)memchr(pos, '>', spineEnd - pos);
+        if (!tagEnd) break;
+        tagEnd++;
+
+        char idref[64];
+        idref[0] = '\0';
+        _extractAttributeFromTag(pos, tagEnd - pos, "idref",
+                                  idref, sizeof(idref));
+
+        if (idref[0]) {
+          // Look up in manifest
+          for (int m = 0; m < manifestCount; m++) {
+            if (strcmp(manifest[m].id, idref) == 0 && manifest[m].isContent) {
+              // Build full path: baseDir + href
+              int pathLen = strlen(baseDir) + strlen(manifest[m].href) + 1;
+              char* fullPath = (char*)malloc(pathLen);
+              if (fullPath) {
+                snprintf(fullPath, pathLen, "%s%s", baseDir, manifest[m].href);
+                chapterPaths[chapterCount++] = fullPath;
+              }
+              break;
+            }
+          }
+        }
+
+        pos = tagEnd;
+      }
+    }
+
+    free(manifest);
+    free(opfData);
+
+    *outChapterPaths = chapterPaths;
+    *outChapterCount = chapterCount;
+
+    return chapterCount > 0;
+  }
+
+  // ----------------------------------------------------------
+  // Strip XHTML/HTML tags from raw content, producing plain text.
+  //
+  // Handles:
+  //   - Tag removal (everything between < and >)
+  //   - <p>, <br>, <div>, <h1>-<h6> → newlines
+  //   - HTML entity decoding (&amp; &lt; &gt; &quot; &apos; &#NNN; &#xHH;)
+  //   - Collapse multiple whitespace/newlines
+  //   - Skip <head>, <style>, <script> content entirely
+  //
+  // Returns heap-allocated buffer (caller must free).
+  // ----------------------------------------------------------
+  static uint8_t* _stripXhtml(const uint8_t* input, uint32_t inputLen,
+                               uint32_t* outLen) {
+    // Output can't be larger than input
+    uint8_t* output = (uint8_t*)ps_malloc(inputLen + 1);
+    if (!output) output = (uint8_t*)malloc(inputLen + 1);
+    if (!output) { *outLen = 0; return nullptr; }
+
+    uint32_t outPos = 0;
+    bool inTag = false;
+    bool skipContent = false;  // Inside <head>, <style>, <script>
+    char tagName[32];
+    int tagNamePos = 0;
+    bool tagNameDone = false;
+    bool isClosingTag = false;
+    bool lastWasNewline = false;
+    bool lastWasSpace = false;
+
+    // Skip to <body> if present (ignore everything before it)
+    const uint8_t* start = input;
+    const uint8_t* inputEnd = input + inputLen;
+    const char* bodyStart = _findTagCI((const char*)input, inputLen, "<body");
+    if (bodyStart) {
+      const char* bodyTagEnd = (const char*)memchr(bodyStart, '>', 
+          inputEnd - (const uint8_t*)bodyStart);
+      if (bodyTagEnd) {
+        start = (const uint8_t*)(bodyTagEnd + 1);
+      }
+    }
+    const uint8_t* end = inputEnd;
+
+    for (const uint8_t* p = start; p < end; p++) {
+      char c = (char)*p;
+
+      if (inTag) {
+        // Collecting tag name
+        if (!tagNameDone) {
+          if (tagNamePos == 0 && c == '/') {
+            isClosingTag = true;
+            continue;
+          }
+          if (c == '>' || c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '/') {
+            tagName[tagNamePos] = '\0';
+            tagNameDone = true;
+          } else if (tagNamePos < (int)sizeof(tagName) - 1) {
+            tagName[tagNamePos++] = (c >= 'A' && c <= 'Z') ? (c + 32) : c;
+          }
+        }
+
+        if (c == '>') {
+          inTag = false;
+
+          // Handle skip regions
+          if (!isClosingTag) {
+            if (strcmp(tagName, "head") == 0 ||
+                strcmp(tagName, "style") == 0 ||
+                strcmp(tagName, "script") == 0) {
+              skipContent = true;
+            }
+          } else {
+            if (strcmp(tagName, "head") == 0 ||
+                strcmp(tagName, "style") == 0 ||
+                strcmp(tagName, "script") == 0) {
+              skipContent = false;
+            }
+          }
+
+          if (!skipContent) {
+            // Block-level elements produce newlines
+            if (strcmp(tagName, "p") == 0 ||
+                strcmp(tagName, "div") == 0 ||
+                strcmp(tagName, "br") == 0 ||
+                strcmp(tagName, "h1") == 0 ||
+                strcmp(tagName, "h2") == 0 ||
+                strcmp(tagName, "h3") == 0 ||
+                strcmp(tagName, "h4") == 0 ||
+                strcmp(tagName, "h5") == 0 ||
+                strcmp(tagName, "h6") == 0 ||
+                strcmp(tagName, "li") == 0 ||
+                strcmp(tagName, "tr") == 0 ||
+                strcmp(tagName, "blockquote") == 0 ||
+                strcmp(tagName, "hr") == 0) {
+              if (outPos > 0 && !lastWasNewline) {
+                output[outPos++] = '\n';
+                lastWasNewline = true;
+                lastWasSpace = false;
+              }
+            }
+          }
+
+          continue;
+        }
+        continue;
+      }
+
+      // Not in a tag
+      if (c == '<') {
+        inTag = true;
+        tagNamePos = 0;
+        tagNameDone = false;
+        isClosingTag = false;
+        continue;
+      }
+
+      if (skipContent) continue;
+
+      // Handle HTML entities
+      if (c == '&') {
+        char decoded = _decodeEntity(p, end, &p);
+        if (decoded) {
+          c = decoded;
+          // p now points to the ';' or last char of entity; loop will increment
+        }
+      }
+
+      // Handle UTF-8 multi-byte sequences (smart quotes, em dashes, etc.)
+      // These appear as raw bytes in XHTML and must be mapped to ASCII
+      // since the e-ink font only supports ASCII characters.
+      if ((uint8_t)c >= 0xC0) {
+        uint32_t codepoint = 0;
+        int extraBytes = 0;
+
+        if (((uint8_t)c & 0xE0) == 0xC0) {
+          // 2-byte sequence: 110xxxxx 10xxxxxx
+          codepoint = (uint8_t)c & 0x1F;
+          extraBytes = 1;
+        } else if (((uint8_t)c & 0xF0) == 0xE0) {
+          // 3-byte sequence: 1110xxxx 10xxxxxx 10xxxxxx
+          codepoint = (uint8_t)c & 0x0F;
+          extraBytes = 2;
+        } else if (((uint8_t)c & 0xF8) == 0xF0) {
+          // 4-byte sequence: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+          codepoint = (uint8_t)c & 0x07;
+          extraBytes = 3;
+        }
+
+        // Read continuation bytes
+        bool valid = true;
+        for (int b = 0; b < extraBytes && p + 1 + b < end; b++) {
+          uint8_t cb = *(p + 1 + b);
+          if ((cb & 0xC0) != 0x80) { valid = false; break; }
+          codepoint = (codepoint << 6) | (cb & 0x3F);
+        }
+
+        if (valid && extraBytes > 0) {
+          p += extraBytes;  // Skip continuation bytes (loop increments past lead byte)
+
+          // Map Unicode codepoints to ASCII equivalents
+          char mapped = 0;
+          switch (codepoint) {
+            case 0x2018: case 0x2019: mapped = '\''; break;  // Smart single quotes
+            case 0x201C: case 0x201D: mapped = '"';  break;  // Smart double quotes
+            case 0x2013: case 0x2014: mapped = '-';  break;  // En/em dash
+            case 0x2026:             mapped = '.';  break;  // Ellipsis
+            case 0x2022:             mapped = '*';  break;  // Bullet
+            case 0x00A0:             mapped = ' ';  break;  // Non-breaking space
+            case 0x00AB: case 0x00BB: mapped = '"'; break;  // Guillemets
+            case 0x2032:             mapped = '\''; break;  // Prime
+            case 0x2033:             mapped = '"';  break;  // Double prime
+            case 0x2010: case 0x2011: mapped = '-'; break;  // Hyphens
+            case 0x2012:             mapped = '-';  break;  // Figure dash
+            case 0x2015:             mapped = '-';  break;  // Horizontal bar
+            case 0x2039: case 0x203A: mapped = '\''; break; // Single guillemets
+            default:
+              if (codepoint >= 0x20 && codepoint < 0x7F) {
+                mapped = (char)codepoint;  // Basic ASCII range
+              } else {
+                continue;  // Skip unmappable characters
+              }
+              break;
+          }
+          c = mapped;
+        } else {
+          continue;  // Skip malformed UTF-8
+        }
+      } else if ((uint8_t)c >= 0x80) {
+        // Stray continuation byte (0x80-0xBF) — skip
+        continue;
+      }
+
+      // Whitespace collapsing
+      if (c == '\n' || c == '\r') {
+        if (!lastWasNewline && outPos > 0) {
+          output[outPos++] = '\n';
+          lastWasNewline = true;
+          lastWasSpace = false;
+        }
+        continue;
+      }
+
+      if (c == ' ' || c == '\t') {
+        if (!lastWasSpace && !lastWasNewline && outPos > 0) {
+          output[outPos++] = ' ';
+          lastWasSpace = true;
+        }
+        continue;
+      }
+
+      // Regular character
+      output[outPos++] = c;
+      lastWasNewline = false;
+      lastWasSpace = false;
+    }
+
+    // Trim trailing whitespace
+    while (outPos > 0 && (output[outPos-1] == '\n' || output[outPos-1] == ' ')) {
+      outPos--;
+    }
+
+    output[outPos] = '\0';
+    *outLen = outPos;
+    return output;
+  }
+
+  // ----------------------------------------------------------
+  // Decode an HTML entity starting at '&'.
+  // Advances *pos to the last character consumed.
+  // Returns the decoded character, or '&' if not recognized.
+  // ----------------------------------------------------------
+  static char _decodeEntity(const uint8_t* p, const uint8_t* end,
+                             const uint8_t** outPos) {
+    // Look for ';' within a reasonable range
+    const uint8_t* semi = p + 1;
+    int maxLen = 10;
+    while (semi < end && semi < p + maxLen && *semi != ';') semi++;
+
+    if (*semi != ';' || semi >= end) {
+      *outPos = p;  // Not an entity, return '&' literal
+      return '&';
+    }
+
+    int entityLen = semi - p - 1;  // Length between & and ;
+    const char* entity = (const char*)(p + 1);
+
+    *outPos = semi;  // Skip past ';'
+
+    // Named entities
+    if (entityLen == 3 && strncmp(entity, "amp", 3) == 0) return '&';
+    if (entityLen == 2 && strncmp(entity, "lt", 2) == 0) return '<';
+    if (entityLen == 2 && strncmp(entity, "gt", 2) == 0) return '>';
+    if (entityLen == 4 && strncmp(entity, "quot", 4) == 0) return '"';
+    if (entityLen == 4 && strncmp(entity, "apos", 4) == 0) return '\'';
+    if (entityLen == 4 && strncmp(entity, "nbsp", 4) == 0) return ' ';
+    if (entityLen == 5 && strncmp(entity, "mdash", 5) == 0) return '-';
+    if (entityLen == 5 && strncmp(entity, "ndash", 5) == 0) return '-';
+    if (entityLen == 6 && strncmp(entity, "hellip", 6) == 0) return '.';
+    if (entityLen == 5 && strncmp(entity, "lsquo", 5) == 0) return '\'';
+    if (entityLen == 5 && strncmp(entity, "rsquo", 5) == 0) return '\'';
+    if (entityLen == 5 && strncmp(entity, "ldquo", 5) == 0) return '"';
+    if (entityLen == 5 && strncmp(entity, "rdquo", 5) == 0) return '"';
+
+    // Numeric entities: &#NNN; or &#xHH;
+    if (entityLen >= 2 && entity[0] == '#') {
+      int codepoint = 0;
+      if (entity[1] == 'x' || entity[1] == 'X') {
+        // Hex
+        for (int i = 2; i < entityLen; i++) {
+          char ch = entity[i];
+          if (ch >= '0' && ch <= '9') codepoint = codepoint * 16 + (ch - '0');
+          else if (ch >= 'a' && ch <= 'f') codepoint = codepoint * 16 + (ch - 'a' + 10);
+          else if (ch >= 'A' && ch <= 'F') codepoint = codepoint * 16 + (ch - 'A' + 10);
+        }
+      } else {
+        // Decimal
+        for (int i = 1; i < entityLen; i++) {
+          char ch = entity[i];
+          if (ch >= '0' && ch <= '9') codepoint = codepoint * 10 + (ch - '0');
+        }
+      }
+      // Map to ASCII (best effort - e-ink font is ASCII only)
+      if (codepoint >= 32 && codepoint < 127) return (char)codepoint;
+      if (codepoint == 160) return ' ';   // non-breaking space
+      if (codepoint == 8211 || codepoint == 8212) return '-';  // en/em dash
+      if (codepoint == 8216 || codepoint == 8217) return '\''; // smart quotes
+      if (codepoint == 8220 || codepoint == 8221) return '"';  // smart quotes
+      if (codepoint == 8230) return '.';   // ellipsis
+      if (codepoint == 8226) return '*';   // bullet
+      // Unknown codepoint > 127: skip it
+      return ' ';
+    }
+
+    // Unknown entity - output as space
+    return ' ';
+  }
+
+  // ----------------------------------------------------------
+  // Find a tag in XML data (case-sensitive, e.g., "<manifest").
+  // Returns pointer to '<' of found tag, or nullptr.
+  // ----------------------------------------------------------
+  static const char* _findTag(const char* data, int dataLen, const char* tag) {
+    int tagLen = strlen(tag);
+    const char* end = data + dataLen - tagLen;
+    for (const char* p = data; p <= end; p++) {
+      if (memcmp(p, tag, tagLen) == 0) return p;
+    }
+    return nullptr;
+  }
+
+  // ----------------------------------------------------------
+  // Find a tag case-insensitively (for <body>, <BODY>, etc.).
+  // ----------------------------------------------------------
+  static const char* _findTagCI(const char* data, int dataLen, const char* tag) {
+    int tagLen = strlen(tag);
+    const char* end = data + dataLen - tagLen;
+    for (const char* p = data; p <= end; p++) {
+      if (strncasecmp(p, tag, tagLen) == 0) return p;
+    }
+    return nullptr;
+  }
+
+  // ----------------------------------------------------------
+  // Extract an attribute value from a region of XML.
+  // Scans for attr="value" and copies value to outBuf.
+  // ----------------------------------------------------------
+  static bool _extractAttribute(const char* data, int dataLen,
+                                 const char* attrName, char* outBuf, int outBufSize) {
+    int nameLen = strlen(attrName);
+    const char* end = data + dataLen;
+    for (const char* p = data; p < end - nameLen - 2; p++) {
+      if (strncmp(p, attrName, nameLen) == 0 && p[nameLen] == '=') {
+        p += nameLen + 1;
+        char quote = *p;
+        if (quote != '"' && quote != '\'') continue;
+        p++;
+        const char* valEnd = (const char*)memchr(p, quote, end - p);
+        if (!valEnd) continue;
+        int valLen = valEnd - p;
+        if (valLen >= outBufSize) valLen = outBufSize - 1;
+        memcpy(outBuf, p, valLen);
+        outBuf[valLen] = '\0';
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // ----------------------------------------------------------
+  // Extract an attribute value from within a single tag string.
+  // (More targeted version for parsing <item id="x" href="y"/>)
+  // ----------------------------------------------------------
+  static bool _extractAttributeFromTag(const char* tag, int tagLen,
+                                        const char* attrName,
+                                        char* outBuf, int outBufSize) {
+    return _extractAttribute(tag, tagLen, attrName, outBuf, outBufSize);
+  }
+
+  // ----------------------------------------------------------
+  // Extract text content between <tagName>...</tagName>.
+  // Works for simple cases like <dc:title>The Iliad</dc:title>.
+  // ----------------------------------------------------------
+  static bool _extractTagContent(const char* data, int dataLen,
+                                  const char* tagName, char* outBuf, int outBufSize) {
+    // Build open tag pattern: "<dc:title" (without >)
+    char openTag[64];
+    snprintf(openTag, sizeof(openTag), "<%s", tagName);
+
+    const char* start = _findTag(data, dataLen, openTag);
+    if (!start) return false;
+
+    // Find the > that closes the opening tag
+    const char* end = data + dataLen;
+    const char* contentStart = (const char*)memchr(start, '>', end - start);
+    if (!contentStart) return false;
+    contentStart++;  // Skip past '>'
+
+    // Find closing tag
+    char closeTag[64];
+    snprintf(closeTag, sizeof(closeTag), "</%s>", tagName);
+    const char* contentEnd = _findTag(contentStart, end - contentStart, closeTag);
+    if (!contentEnd) return false;
+
+    int len = contentEnd - contentStart;
+    if (len >= outBufSize) len = outBufSize - 1;
+    memcpy(outBuf, contentStart, len);
+    outBuf[len] = '\0';
+    return true;
+  }
+
+  // ----------------------------------------------------------
+  // Get directory portion of a path.
+  // "OEBPS/content.opf" -> "OEBPS/"
+  // "content.opf" -> ""
+  // ----------------------------------------------------------
+  static void _getDirectory(const char* path, char* dirBuf, int dirBufSize) {
+    const char* lastSlash = strrchr(path, '/');
+    if (lastSlash) {
+      int len = lastSlash - path + 1;  // Include trailing /
+      if (len >= dirBufSize) len = dirBufSize - 1;
+      memcpy(dirBuf, path, len);
+      dirBuf[len] = '\0';
+    } else {
+      dirBuf[0] = '\0';
+    }
+  }
+
+  // ----------------------------------------------------------
+  // Free the chapter paths array allocated by _parseOpf().
+  // ----------------------------------------------------------
+  static void _freeChapterPaths(char** paths, int count) {
+    if (paths) {
+      for (int i = 0; i < count; i++) {
+        if (paths[i]) free(paths[i]);
+      }
+      free(paths);
+    }
+  }
+};
--- a/variants/lilygo_tdeck_pro/TDeckBoard.cpp
+++ b/variants/lilygo_tdeck_pro/TDeckBoard.cpp
@@ -1,24 +1,25 @@
 #include <Arduino.h>
 #include "variant.h"
 #include "TDeckBoard.h"
+#include <Mesh.h>  // For MESH_DEBUG_PRINTLN

 uint32_t deviceOnline = 0x00;

 void TDeckBoard::begin() {
  
-  Serial.println("TDeckBoard::begin() - starting");
+  MESH_DEBUG_PRINTLN("TDeckBoard::begin() - starting");
  
  // Enable peripheral power (keyboard, sensors, etc.) FIRST
  // This powers the BQ27220 fuel gauge and other I2C devices
  pinMode(PIN_PERF_POWERON, OUTPUT);
  digitalWrite(PIN_PERF_POWERON, HIGH);
  delay(50);  // Allow peripherals to power up before I2C init
-  Serial.println("TDeckBoard::begin() - peripheral power enabled");
+  MESH_DEBUG_PRINTLN("TDeckBoard::begin() - peripheral power enabled");

  // Initialize I2C with correct pins for T-Deck Pro
  Wire.begin(I2C_SDA, I2C_SCL);
  Wire.setClock(100000);  // 100kHz for reliable fuel gauge communication
-  Serial.println("TDeckBoard::begin() - I2C initialized");
+  MESH_DEBUG_PRINTLN("TDeckBoard::begin() - I2C initialized");
  
  // Now call parent class begin (after power and I2C are ready)
  ESP32Board::begin();
@@ -28,7 +29,7 @@ void TDeckBoard::begin() {
    pinMode(P_LORA_EN, OUTPUT);
    digitalWrite(P_LORA_EN, HIGH);
    delay(10);  // Allow module to power up
-    Serial.println("TDeckBoard::begin() - LoRa power enabled");
+    MESH_DEBUG_PRINTLN("TDeckBoard::begin() - LoRa power enabled");
  #endif

  // Enable GPS module power and initialize Serial2
@@ -37,14 +38,20 @@ void TDeckBoard::begin() {
      pinMode(PIN_GPS_EN, OUTPUT);
      digitalWrite(PIN_GPS_EN, GPS_EN_ACTIVE);  // GPS_EN_ACTIVE is 1 (HIGH)
      delay(100);  // Allow GPS to power up
-      Serial.println("TDeckBoard::begin() - GPS power enabled");
+      MESH_DEBUG_PRINTLN("TDeckBoard::begin() - GPS power enabled");
    #endif
    
    // Initialize Serial2 for GPS with correct pins
    Serial2.begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
-    Serial.print("TDeckBoard::begin() - GPS Serial2 initialized at ");
-    Serial.print(GPS_BAUDRATE);
-    Serial.println(" baud");
+    MESH_DEBUG_PRINTLN("TDeckBoard::begin() - GPS Serial2 initialized at %d baud", GPS_BAUDRATE);
+  #endif
+
+  // Disable 4G modem power (only present on 4G version, not audio version)
+  // This turns off the red status LED on the modem module
+  #ifdef MODEM_POWER_EN
+    pinMode(MODEM_POWER_EN, OUTPUT);
+    digitalWrite(MODEM_POWER_EN, LOW);  // Cut power to modem
+    MESH_DEBUG_PRINTLN("TDeckBoard::begin() - 4G modem power disabled");
  #endif

  // Configure user button
@@ -68,12 +75,10 @@ void TDeckBoard::begin() {
  // Test BQ27220 communication
  #if HAS_BQ27220
    uint16_t voltage = getBattMilliVolts();
-    Serial.print("TDeckBoard::begin() - Battery voltage: ");
-    Serial.print(voltage);
-    Serial.println(" mV");
+    MESH_DEBUG_PRINTLN("TDeckBoard::begin() - Battery voltage: %d mV", voltage);
  #endif
  
-  Serial.println("TDeckBoard::begin() - complete");
+  MESH_DEBUG_PRINTLN("TDeckBoard::begin() - complete");
 }

 uint16_t TDeckBoard::getBattMilliVolts() {
@@ -81,13 +86,13 @@ uint16_t TDeckBoard::getBattMilliVolts() {
    Wire.beginTransmission(BQ27220_I2C_ADDR);
    Wire.write(BQ27220_REG_VOLTAGE);
    if (Wire.endTransmission(false) != 0) {
-      Serial.println("BQ27220: I2C error reading voltage");
+      MESH_DEBUG_PRINTLN("BQ27220: I2C error reading voltage");
      return 0;
    }
    
    uint8_t count = Wire.requestFrom((uint8_t)BQ27220_I2C_ADDR, (uint8_t)2);
    if (count != 2) {
-      Serial.println("BQ27220: Read error - wrong byte count");
+      MESH_DEBUG_PRINTLN("BQ27220: Read error - wrong byte count");
      return 0;
    }
    
--- a/variants/lilygo_tdeck_pro/TDeckBoard.h
+++ b/variants/lilygo_tdeck_pro/TDeckBoard.h
@@ -16,6 +16,13 @@ class TDeckBoard : public ESP32Board {
 public:
  void begin();

+  void powerOff() override {
+    // Stop Bluetooth before power off
+    btStop();
+    // Don't call parent or enterDeepSleep - let normal shutdown continue
+    // Display will show "hibernating..." text
+  }
+
  void enterDeepSleep(uint32_t secs, int pin_wake_btn) {
    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);

--- a/variants/lilygo_tdeck_pro/Tca8418keyboard.h
+++ b/variants/lilygo_tdeck_pro/Tca8418keyboard.h
@@ -0,0 +1,297 @@
+#pragma once
+
+#include <Arduino.h>
+#include <Wire.h>
+
+// TCA8418 Register addresses
+#define TCA8418_REG_CFG         0x01
+#define TCA8418_REG_INT_STAT    0x02
+#define TCA8418_REG_KEY_LCK_EC  0x03
+#define TCA8418_REG_KEY_EVENT_A 0x04
+#define TCA8418_REG_KP_GPIO1    0x1D
+#define TCA8418_REG_KP_GPIO2    0x1E
+#define TCA8418_REG_KP_GPIO3    0x1F
+#define TCA8418_REG_DEBOUNCE    0x29
+#define TCA8418_REG_GPI_EM1     0x20
+#define TCA8418_REG_GPI_EM2     0x21
+#define TCA8418_REG_GPI_EM3     0x22
+
+// Key codes for special keys
+#define KB_KEY_NONE      0
+#define KB_KEY_BACKSPACE '\b'
+#define KB_KEY_ENTER     '\r'
+#define KB_KEY_SPACE     ' '
+#define KB_KEY_EMOJI     0x01   // Non-printable code for $ key (emoji picker)
+
+class TCA8418Keyboard {
+private:
+  uint8_t _addr;
+  TwoWire* _wire;
+  bool _initialized;
+  bool _shiftActive;   // Sticky shift (one-shot)
+  bool _altActive;     // Sticky alt (one-shot)
+  bool _symActive;     // Sticky sym (one-shot)
+  unsigned long _lastShiftTime;  // For Shift+key combos
+
+  uint8_t readReg(uint8_t reg) {
+    _wire->beginTransmission(_addr);
+    _wire->write(reg);
+    _wire->endTransmission();
+    _wire->requestFrom(_addr, (uint8_t)1);
+    return _wire->available() ? _wire->read() : 0;
+  }
+
+  void writeReg(uint8_t reg, uint8_t val) {
+    _wire->beginTransmission(_addr);
+    _wire->write(reg);
+    _wire->write(val);
+    _wire->endTransmission();
+  }
+
+  // Map raw key codes to characters (from working reader firmware)
+  char getKeyChar(uint8_t keyCode) {
+    switch (keyCode) {
+      // Row 1 - QWERTYUIOP
+      case 10: return 'q';   // Q (was 97 on different hardware)
+      case 9:  return 'w';
+      case 8:  return 'e';
+      case 7:  return 'r';
+      case 6:  return 't';
+      case 5:  return 'y';
+      case 4:  return 'u';
+      case 3:  return 'i';
+      case 2:  return 'o';
+      case 1:  return 'p';
+      
+      // Row 2 - ASDFGHJKL + Backspace
+      case 20: return 'a';   // A (was 98 on different hardware)
+      case 19: return 's';
+      case 18: return 'd';
+      case 17: return 'f';
+      case 16: return 'g';
+      case 15: return 'h';
+      case 14: return 'j';
+      case 13: return 'k';
+      case 12: return 'l';
+      case 11: return '\b'; // Backspace
+      
+      // Row 3 - Alt ZXCVBNM Sym Enter
+      case 30: return 0;    // Alt - handled separately
+      case 29: return 'z';
+      case 28: return 'x';
+      case 27: return 'c';
+      case 26: return 'v';
+      case 25: return 'b';
+      case 24: return 'n';
+      case 23: return 'm';
+      case 22: return 0;    // Symbol key - handled separately
+      case 21: return '\r'; // Enter
+      
+      // Row 4 - Shift Mic Space Sym Shift
+      case 35: return 0;    // Left shift - handled separately
+      case 34: return 0;    // Mic
+      case 33: return ' ';  // Space
+      case 32: return 0;    // Sym - handled separately
+      case 31: return 0;    // Right shift - handled separately
+      
+      default: return 0;
+    }
+  }
+
+  // Map key with Alt modifier - same as Sym for this keyboard
+  char getAltChar(uint8_t keyCode) {
+    return getSymChar(keyCode);  // Alt does same as Sym
+  }
+
+  // Map key with Sym modifier - based on actual T-Deck Pro keyboard silk-screen
+  char getSymChar(uint8_t keyCode) {
+    switch (keyCode) {
+      // Row 1: Q W E R T Y U I O P
+      case 10: return '#';  // Q -> #
+      case 9:  return '1';  // W -> 1
+      case 8:  return '2';  // E -> 2
+      case 7:  return '3';  // R -> 3
+      case 6:  return '(';  // T -> (
+      case 5:  return ')';  // Y -> )
+      case 4:  return '_';  // U -> _
+      case 3:  return '-';  // I -> -
+      case 2:  return '+';  // O -> +
+      case 1:  return '@';  // P -> @
+      
+      // Row 2: A S D F G H J K L
+      case 20: return '*';  // A -> *
+      case 19: return '4';  // S -> 4
+      case 18: return '5';  // D -> 5
+      case 17: return '6';  // F -> 6
+      case 16: return '/';  // G -> /
+      case 15: return ':';  // H -> :
+      case 14: return ';';  // J -> ;
+      case 13: return '\''; // K -> '
+      case 12: return '"';  // L -> "
+      
+      // Row 3: Z X C V B N M
+      case 29: return '7';  // Z -> 7
+      case 28: return '8';  // X -> 8
+      case 27: return '9';  // C -> 9
+      case 26: return '?';  // V -> ?
+      case 25: return '!';  // B -> !
+      case 24: return ',';  // N -> ,
+      case 23: return '.';  // M -> .
+      
+      // Row 4: Mic key -> 0
+      case 34: return '0';  // Mic -> 0
+      
+      default: return 0;
+    }
+  }
+
+public:
+  TCA8418Keyboard(uint8_t addr = 0x34, TwoWire* wire = &Wire) 
+    : _addr(addr), _wire(wire), _initialized(false), 
+      _shiftActive(false), _altActive(false), _symActive(false), _lastShiftTime(0) {}
+
+  bool begin() {
+    // Check if device responds
+    _wire->beginTransmission(_addr);
+    if (_wire->endTransmission() != 0) {
+      Serial.println("TCA8418: Device not found");
+      return false;
+    }
+
+    // Configure keyboard matrix (8 rows x 10 cols)
+    writeReg(TCA8418_REG_KP_GPIO1, 0xFF);  // Rows 0-7 as keypad
+    writeReg(TCA8418_REG_KP_GPIO2, 0xFF);  // Cols 0-7 as keypad
+    writeReg(TCA8418_REG_KP_GPIO3, 0x03);  // Cols 8-9 as keypad
+
+    // Enable keypad with FIFO overflow detection
+    writeReg(TCA8418_REG_CFG, 0x11);  // KE_IEN + INT_CFG
+
+    // Set debounce
+    writeReg(TCA8418_REG_DEBOUNCE, 0x03);
+
+    // Clear any pending interrupts
+    writeReg(TCA8418_REG_INT_STAT, 0x1F);
+
+    // Flush the FIFO
+    while (readReg(TCA8418_REG_KEY_LCK_EC) & 0x0F) {
+      readReg(TCA8418_REG_KEY_EVENT_A);
+    }
+
+    _initialized = true;
+    Serial.println("TCA8418: Keyboard initialized OK");
+    return true;
+  }
+
+  // Read a key press - returns character or 0 if no key
+  char readKey() {
+    if (!_initialized) return 0;
+
+    // Check for key events in FIFO
+    uint8_t keyCount = readReg(TCA8418_REG_KEY_LCK_EC) & 0x0F;
+    if (keyCount == 0) return 0;
+
+    // Read key event from FIFO
+    uint8_t keyEvent = readReg(TCA8418_REG_KEY_EVENT_A);
+
+    // Bit 7: 1 = press, 0 = release
+    bool pressed = (keyEvent & 0x80) != 0;
+    uint8_t keyCode = keyEvent & 0x7F;
+
+    // Clear interrupt
+    writeReg(TCA8418_REG_INT_STAT, 0x1F);
+
+    Serial.printf("KB raw: event=0x%02X code=%d pressed=%d count=%d\n", 
+                  keyEvent, keyCode, pressed, keyCount);
+
+    // Only act on key press, not release
+    if (!pressed || keyCode == 0) {
+      return 0;
+    }
+
+    // Handle modifier keys - set sticky state and return 0
+    if (keyCode == 35 || keyCode == 31) {  // Shift keys
+      _shiftActive = true;
+      _lastShiftTime = millis();
+      Serial.println("KB: Shift activated");
+      return 0;
+    }
+    if (keyCode == 30) {  // Alt key
+      _altActive = true;
+      Serial.println("KB: Alt activated");
+      return 0;
+    }
+    if (keyCode == 32) {  // Sym key (bottom row)
+      _symActive = true;
+      Serial.println("KB: Sym activated");
+      return 0;
+    }
+    
+    // Handle dedicated $ key (key code 22, next to M)
+    // Bare press = emoji picker, Sym+$ = literal '$'
+    if (keyCode == 22) {
+      if (_symActive) {
+        _symActive = false;
+        Serial.println("KB: Sym+$ -> '$'");
+        return '$';
+      }
+      Serial.println("KB: $ key -> emoji");
+      return KB_KEY_EMOJI;
+    }
+    
+    // Handle Mic key - produces 0 with Sym, otherwise ignore
+    if (keyCode == 34) {
+      if (_symActive) {
+        _symActive = false;
+        Serial.println("KB: Sym+Mic -> '0'");
+        return '0';
+      }
+      return 0;  // Ignore mic without Sym
+    }
+
+    // Get the character
+    char c = 0;
+    
+    if (_altActive) {
+      c = getAltChar(keyCode);
+      _altActive = false;  // Reset sticky alt
+      if (c != 0) {
+        Serial.printf("KB: Alt+key -> '%c'\n", c);
+        return c;
+      }
+    }
+    
+    if (_symActive) {
+      c = getSymChar(keyCode);
+      _symActive = false;  // Reset sticky sym
+      if (c != 0) {
+        Serial.printf("KB: Sym+key -> '%c'\n", c);
+        return c;
+      }
+    }
+    
+    c = getKeyChar(keyCode);
+    
+    if (c != 0 && _shiftActive) {
+      // Apply shift - uppercase letters
+      if (c >= 'a' && c <= 'z') {
+        c = c - 'a' + 'A';
+      }
+      _shiftActive = false;  // Reset sticky shift
+    }
+    
+    if (c != 0) {
+      Serial.printf("KB: code %d -> '%c' (0x%02X)\n", keyCode, c >= 32 ? c : '?', c);
+    } else {
+      Serial.printf("KB: code %d -> UNMAPPED\n", keyCode);
+    }
+    
+    return c;
+  }
+
+  bool isReady() const { return _initialized; }
+  
+  // Check if shift was pressed within the last N milliseconds
+  bool wasShiftRecentlyPressed(unsigned long withinMs = 500) const {
+    return (millis() - _lastShiftTime) < withinMs;
+  }
+};
--- a/variants/lilygo_tdeck_pro/platformio.ini
+++ b/variants/lilygo_tdeck_pro/platformio.ini
@@ -113,9 +113,9 @@ extends = LilyGo_TDeck_Pro
 build_flags =
  ${LilyGo_TDeck_Pro.build_flags}
  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=350
-  -D MAX_GROUP_CHANNELS=40
-  -D BLE_PIN_CODE=234567
+  -D MAX_CONTACTS=400
+  -D MAX_GROUP_CHANNELS=20
+  -D BLE_PIN_CODE=123456
  -D OFFLINE_QUEUE_SIZE=256
 build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
  +<helpers/esp32/*.cpp>
--- a/variants/lilygo_tdeck_pro/target.cpp
+++ b/variants/lilygo_tdeck_pro/target.cpp
@@ -19,10 +19,8 @@ AutoDiscoverRTCClock rtc_clock(fallback_clock);
 #if HAS_GPS
  MicroNMEALocationProvider gps(Serial2, &rtc_clock);
  EnvironmentSensorManager sensors(gps);
-  #pragma message "GPS enabled - using EnvironmentSensorManager with MicroNMEALocationProvider"
 #else
  SensorManager sensors;
-  #pragma message "GPS disabled - using basic SensorManager"
 #endif

 #ifdef DISPLAY_CLASS
@@ -31,38 +29,37 @@ AutoDiscoverRTCClock rtc_clock(fallback_clock);
 #endif

 bool radio_init() {
-  Serial.println("radio_init() - starting");
+  MESH_DEBUG_PRINTLN("radio_init() - starting");
  
  // NOTE: board.begin() is called by main.cpp setup() before radio_init()
  // I2C is already initialized there with correct pins
  
  fallback_clock.begin();
-  Serial.println("radio_init() - fallback_clock started");
+  MESH_DEBUG_PRINTLN("radio_init() - fallback_clock started");
  
  // Wire already initialized in board.begin() - just use it for RTC
  rtc_clock.begin(Wire);
-  Serial.println("radio_init() - rtc_clock started");
-
-  // Debug GPS status
-  #if HAS_GPS
-    Serial.println("radio_init() - HAS_GPS is defined");
-    Serial.print("radio_init() - gps object address: ");
-    Serial.println((uint32_t)&gps, HEX);
-  #else
-    Serial.println("radio_init() - HAS_GPS is NOT defined");
-  #endif
+  MESH_DEBUG_PRINTLN("radio_init() - rtc_clock started");

 #if defined(P_LORA_SCLK)
-  Serial.println("radio_init() - initializing LoRa SPI...");
+  MESH_DEBUG_PRINTLN("radio_init() - initializing LoRa SPI...");
  loraSpi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI, P_LORA_NSS);
-  Serial.println("radio_init() - SPI initialized, calling radio.std_init()...");
+  MESH_DEBUG_PRINTLN("radio_init() - SPI initialized, calling radio.std_init()...");
  bool result = radio.std_init(&loraSpi);
-  Serial.print("radio_init() - radio.std_init() returned: ");
-  Serial.println(result ? "SUCCESS" : "FAILED");
+  if (result) {
+    radio.setPreambleLength(32);
+    MESH_DEBUG_PRINTLN("radio_init() - preamble set to 32 symbols");
+  }
+  MESH_DEBUG_PRINTLN("radio_init() - radio.std_init() returned: %s", result ? "SUCCESS" : "FAILED");
  return result;
 #else
-  Serial.println("radio_init() - calling radio.std_init() without custom SPI...");
-  return radio.std_init();
+  MESH_DEBUG_PRINTLN("radio_init() - calling radio.std_init() without custom SPI...");
+  bool result = radio.std_init();
+  if (result) {
+    radio.setPreambleLength(32);
+    MESH_DEBUG_PRINTLN("radio_init() - preamble set to 32 symbols");
+  }
+  return result;
 #endif
 }

@@ -84,4 +81,8 @@ void radio_set_tx_power(uint8_t dbm) {
 mesh::LocalIdentity radio_new_identity() {
  RadioNoiseListener rng(radio);
  return mesh::LocalIdentity(&rng);
+}
+
+void radio_reset_agc() {
+  radio.setRxBoostedGainMode(true);
 }
--- a/variants/lilygo_tdeck_pro/target.h
+++ b/variants/lilygo_tdeck_pro/target.h
@@ -41,4 +41,5 @@ bool radio_init();
 uint32_t radio_get_rng_seed();
 void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
 void radio_set_tx_power(uint8_t dbm);
-mesh::LocalIdentity radio_new_identity();
+mesh::LocalIdentity radio_new_identity();
+void radio_reset_agc();
--- a/variants/lilygo_techo_lite/TechoBoard.cpp
+++ b/variants/lilygo_techo_lite/TechoBoard.cpp
@@ -1,31 +0,0 @@
-#include <Arduino.h>
-#include <Wire.h>
-
-#include "TechoBoard.h"
-
-#ifdef LILYGO_TECHO
-
-void TechoBoard::begin() {
-  NRF52Board::begin();
-
-  Wire.begin();
-
-  pinMode(SX126X_POWER_EN, OUTPUT);
-  digitalWrite(SX126X_POWER_EN, HIGH);
-  delay(10);   // give sx1262 some time to power up
-}
-
-uint16_t TechoBoard::getBattMilliVolts() {
-  int adcvalue = 0;
-
-  analogReference(AR_INTERNAL_3_0);
-  analogReadResolution(12);
-  delay(10);
-
-  // ADC range is 0..3000mV and resolution is 12-bit (0..4095)
-  adcvalue = analogRead(PIN_VBAT_READ);
-  // Convert the raw value to compensated mv, taking the resistor-
-  // divider into account (providing the actual LIPO voltage)
-  return (uint16_t)((float)adcvalue * REAL_VBAT_MV_PER_LSB);
-}
-#endif
--- a/variants/lilygo_techo_lite/TechoBoard.h
+++ b/variants/lilygo_techo_lite/TechoBoard.h
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <MeshCore.h>
-#include <Arduino.h>
-#include <helpers/NRF52Board.h>
-
-// built-ins
-#define VBAT_MV_PER_LSB   (0.73242188F)   // 3.0V ADC range and 12-bit ADC resolution = 3000mV/4096
-
-#define VBAT_DIVIDER      (0.5F)          // 150K + 150K voltage divider on VBAT
-#define VBAT_DIVIDER_COMP (2.0F)          // Compensation factor for the VBAT divider
-
-#define PIN_VBAT_READ     (4)
-#define REAL_VBAT_MV_PER_LSB (VBAT_DIVIDER_COMP * VBAT_MV_PER_LSB)
-
-class TechoBoard : public NRF52BoardOTA {
-public:
-  TechoBoard() : NRF52BoardOTA("TECHO_OTA") {}
-  void begin();
-  uint16_t getBattMilliVolts() override;
-
-  const char* getManufacturerName() const override {
-    return "LilyGo T-Echo";
-  }
-
-  void powerOff() override {
-    #ifdef LED_RED
-    digitalWrite(LED_RED, LOW);
-    #endif
-    #ifdef LED_GREEN
-    digitalWrite(LED_GREEN, LOW);
-    #endif
-    #ifdef LED_BLUE
-    digitalWrite(LED_BLUE, LOW);
-    #endif
-    #ifdef DISP_BACKLIGHT
-    digitalWrite(DISP_BACKLIGHT, LOW);
-    #endif
-    #ifdef PIN_PWR_EN
-    digitalWrite(PIN_PWR_EN, LOW);
-    #endif
-    sd_power_system_off();
-  }
-};
--- a/variants/lilygo_techo_lite/platformio.ini
+++ b/variants/lilygo_techo_lite/platformio.ini
@@ -1,98 +0,0 @@
-[LilyGo_T-Echo-Lite]
-extends = nrf52_base
-board = t-echo
-board_build.ldscript = boards/nrf52840_s140_v6.ld
-build_flags = ${nrf52_base.build_flags}
-  -I variants/lilygo_techo_lite
-  -I src/helpers/nrf52
-  -I lib/nrf52/s140_nrf52_6.1.1_API/include
-  -I lib/nrf52/s140_nrf52_6.1.1_API/include/nrf52
-  -D LILYGO_TECHO
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-  -D SX126X_POWER_EN=30
-  -D SX126X_CURRENT_LIMIT=140
-  -D SX126X_RX_BOOSTED_GAIN=1
-  -D P_LORA_TX_LED=LED_GREEN
-  -D DISABLE_DIAGNOSTIC_OUTPUT
-  -D ENV_INCLUDE_GPS=1
-  -D GPS_BAUD_RATE=9600
-  -D PIN_GPS_EN=GPS_EN
-  -D DISPLAY_CLASS=GxEPDDisplay
-  -D EINK_DISPLAY_MODEL=GxEPD2_122_T61
-  -D EINK_SCALE_X=1.5f
-  -D EINK_SCALE_Y=2.0f
-  -D EINK_X_OFFSET=0
-  -D EINK_Y_OFFSET=10
-  -D DISPLAY_ROTATION=4
-  -D AUTO_OFF_MILLIS=0
-build_src_filter = ${nrf52_base.build_src_filter}
-  +<helpers/*.cpp>
-  +<TechoBoard.cpp>
-  +<helpers/sensors/EnvironmentSensorManager.cpp>
-  +<helpers/ui/GxEPDDisplay.cpp>
-  +<helpers/ui/MomentaryButton.cpp>
-  +<../variants/lilygo_techo_lite>
-lib_deps =
-  ${nrf52_base.lib_deps}
-  stevemarple/MicroNMEA @ ^2.0.6
-  adafruit/Adafruit BME280 Library @ ^2.3.0
-  https://github.com/SoulOfNoob/GxEPD2.git
-  bakercp/CRC32 @ ^2.0.0
-debug_tool = jlink
-upload_protocol = nrfutil
-
-[env:LilyGo_T-Echo-Lite_repeater]
-extends = LilyGo_T-Echo-Lite
-build_src_filter = ${LilyGo_T-Echo-Lite.build_src_filter}
-  +<../examples/simple_repeater>
-build_flags =
-  ${LilyGo_T-Echo-Lite.build_flags}
-  -D ADVERT_NAME='"T-Echo-Lite Repeater"'
-  -D ADVERT_LAT=0.0
-  -D ADVERT_LON=0.0
-  -D ADMIN_PASSWORD='"password"'
-  -D MAX_NEIGHBOURS=50
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:LilyGo_T-Echo-Lite_room_server]
-extends = LilyGo_T-Echo-Lite
-build_src_filter = ${LilyGo_T-Echo-Lite.build_src_filter}
-  +<../examples/simple_room_server>
-build_flags =
-  ${LilyGo_T-Echo-Lite.build_flags}
-  -D ADVERT_NAME='"T-Echo-Lite Room"'
-  -D ADVERT_LAT=0.0
-  -D ADVERT_LON=0.0
-  -D ADMIN_PASSWORD='"password"'
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:LilyGo_T-Echo-Lite_companion_radio_ble]
-extends = LilyGo_T-Echo-Lite
-board_build.ldscript = boards/nrf52840_s140_v6_extrafs.ld
-board_upload.maximum_size = 712704
-build_flags =
-  ${LilyGo_T-Echo-Lite.build_flags}
-  -I src/helpers/ui
-  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=350
-  -D MAX_GROUP_CHANNELS=40
-  ; -D QSPIFLASH=1
-  -D BLE_PIN_CODE=123456
-  ; -D BLE_DEBUG_LOGGING=1
-  -D OFFLINE_QUEUE_SIZE=256
-  -D UI_RECENT_LIST_SIZE=9
-  -D UI_SENSORS_PAGE=1
-  ; -D MESH_PACKET_LOGGING=1
-  ; -D MESH_DEBUG=1
-  -D AUTO_SHUTDOWN_MILLIVOLTS=3300
-build_src_filter = ${LilyGo_T-Echo-Lite.build_src_filter}
-  +<helpers/nrf52/SerialBLEInterface.cpp>
-  +<../examples/companion_radio/*.cpp>
-  +<../examples/companion_radio/ui-new/*.cpp>
-lib_deps =
-  ${LilyGo_T-Echo-Lite.lib_deps}
-  densaugeo/base64 @ ~1.4.0
--- a/variants/lilygo_techo_lite/target.cpp
+++ b/variants/lilygo_techo_lite/target.cpp
@@ -1,52 +0,0 @@
-#include <Arduino.h>
-#include "target.h"
-#include <helpers/ArduinoHelpers.h>
-#include <helpers/sensors/MicroNMEALocationProvider.h>
-
-TechoBoard board;
-
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
-
-WRAPPER_CLASS radio_driver(radio, board);
-
-VolatileRTCClock fallback_clock;
-AutoDiscoverRTCClock rtc_clock(fallback_clock);
-
-#ifdef ENV_INCLUDE_GPS
-MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1, &rtc_clock);
-EnvironmentSensorManager sensors = EnvironmentSensorManager(nmea);
-#else
-EnvironmentSensorManager sensors = EnvironmentSensorManager();
-#endif
-
-#ifdef DISPLAY_CLASS
-  DISPLAY_CLASS display;
-  MomentaryButton user_btn(PIN_USER_BTN, 1000, true);
-#endif
-
-bool radio_init() {
-  rtc_clock.begin(Wire);
-
-  return radio.std_init(&SPI);
-}
-
-uint32_t radio_get_rng_seed() {
-  return radio.random(0x7FFFFFFF);
-}
-
-void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
-  radio.setFrequency(freq);
-  radio.setSpreadingFactor(sf);
-  radio.setBandwidth(bw);
-  radio.setCodingRate(cr);
-}
-
-void radio_set_tx_power(uint8_t dbm) {
-  radio.setOutputPower(dbm);
-}
-
-mesh::LocalIdentity radio_new_identity() {
-  RadioNoiseListener rng(radio);
-  return mesh::LocalIdentity(&rng);  // create new random identity
-}
-
--- a/variants/lilygo_techo_lite/target.h
+++ b/variants/lilygo_techo_lite/target.h
@@ -1,31 +0,0 @@
-#pragma once
-
-#define RADIOLIB_STATIC_ONLY 1
-#include <RadioLib.h>
-#include <helpers/radiolib/RadioLibWrappers.h>
-#include <TechoBoard.h>
-#include <helpers/radiolib/CustomSX1262Wrapper.h>
-#include <helpers/AutoDiscoverRTCClock.h>
-#include <helpers/SensorManager.h>
-#include <helpers/sensors/EnvironmentSensorManager.h>
-#include <helpers/sensors/LocationProvider.h>
-#ifdef DISPLAY_CLASS
-  #include <helpers/ui/GxEPDDisplay.h>
-  #include <helpers/ui/MomentaryButton.h>
-#endif
-
-extern TechoBoard board;
-extern WRAPPER_CLASS radio_driver;
-extern AutoDiscoverRTCClock rtc_clock;
-extern EnvironmentSensorManager sensors;
-
-#ifdef DISPLAY_CLASS
-  extern DISPLAY_CLASS display;
-  extern MomentaryButton user_btn;
-#endif
-
-bool radio_init();
-uint32_t radio_get_rng_seed();
-void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
-void radio_set_tx_power(uint8_t dbm);
-mesh::LocalIdentity radio_new_identity();
--- a/variants/lilygo_techo_lite/variant.cpp
+++ b/variants/lilygo_techo_lite/variant.cpp
@@ -1,39 +0,0 @@
-#include "variant.h"
-#include "wiring_constants.h"
-#include "wiring_digital.h"
-
-const int MISO = PIN_SPI1_MISO;
-const int MOSI = PIN_SPI1_MOSI;
-const int SCK = PIN_SPI1_SCK;
-
-const uint32_t g_ADigitalPinMap[] = {
-  0xff, 0xff, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
-  14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
-  27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
-  40, 41, 42, 43, 44, 45, 46, 47
-};
-
-void initVariant() {
-  pinMode(PIN_PWR_EN, OUTPUT);
-  digitalWrite(PIN_PWR_EN, HIGH);
-
-  pinMode(PIN_BUTTON1, INPUT_PULLUP);
-  pinMode(PIN_BUTTON2, INPUT_PULLUP);
-
-  pinMode(LED_RED, OUTPUT);
-  pinMode(LED_GREEN, OUTPUT);
-  pinMode(LED_BLUE, OUTPUT);
-  digitalWrite(LED_BLUE, HIGH);
-  digitalWrite(LED_GREEN, HIGH);
-  digitalWrite(LED_RED, HIGH);
-
-  // pinMode(PIN_TXCO, OUTPUT);
-  // digitalWrite(PIN_TXCO, HIGH);
-
-  pinMode(DISP_POWER, OUTPUT);
-  digitalWrite(DISP_POWER, LOW);
-
-  // shutdown gps
-  pinMode(GPS_EN, OUTPUT);
-  digitalWrite(GPS_EN, LOW);
-}
--- a/variants/lilygo_techo_lite/variant.h
+++ b/variants/lilygo_techo_lite/variant.h
@@ -1,158 +0,0 @@
-/*
- * variant.h
- * Copyright (C) 2023 Seeed K.K.
- * MIT License
- */
-
-#pragma once
-
-#define _PINNUM(port, pin) ((port) * 32 + (pin))
-
-#include "WVariant.h"
-
-////////////////////////////////////////////////////////////////////////////////
-// Low frequency clock source
-
-#define USE_LFXO    // 32.768 kHz crystal oscillator
-#define VARIANT_MCK (64000000ul)
-
-#define WIRE_INTERFACES_COUNT   (1)
-
-////////////////////////////////////////////////////////////////////////////////
-// Power
-
-#define PIN_PWR_EN              _PINNUM(0, 30) // RT9080_EN
-
-#define BATTERY_PIN             _PINNUM(0, 2)
-#define ADC_MULTIPLIER          (4.90F)
-
-#define ADC_RESOLUTION          (14)
-#define BATTERY_SENSE_RES       (12)
-
-#define AREF_VOLTAGE            (3.0)
-
-////////////////////////////////////////////////////////////////////////////////
-// Number of pins
-
-#define PINS_COUNT              (48)
-#define NUM_DIGITAL_PINS        (48)
-#define NUM_ANALOG_INPUTS       (1)
-#define NUM_ANALOG_OUTPUTS      (0)
-
-////////////////////////////////////////////////////////////////////////////////
-// UART pin definition
-
-#define PIN_SERIAL1_RX          PIN_GPS_TX
-#define PIN_SERIAL1_TX          PIN_GPS_RX
-////////////////////////////////////////////////////////////////////////////////
-// I2C pin definition
-
-#define PIN_WIRE_SDA            _PINNUM(0, 4) // (SDA)
-#define PIN_WIRE_SCL            _PINNUM(0, 2) // (SCL)
-
-////////////////////////////////////////////////////////////////////////////////
-// SPI pin definition
-
-#define SPI_INTERFACES_COUNT    _PINNUM(0, 2)
-
-#define PIN_SPI_MISO            _PINNUM(0, 17) // (MISO)
-#define PIN_SPI_MOSI            _PINNUM(0, 15) // (MOSI)
-#define PIN_SPI_SCK             _PINNUM(0, 13) // (SCK)
-#define PIN_SPI_NSS             (-1)
-
-////////////////////////////////////////////////////////////////////////////////
-// QSPI FLASH
-
-#define PIN_QSPI_SCK            _PINNUM(0, 4)
-#define PIN_QSPI_CS             _PINNUM(0, 12)
-#define PIN_QSPI_IO0            _PINNUM(0, 6)
-#define PIN_QSPI_IO1            _PINNUM(0, 8)
-#define PIN_QSPI_IO2            _PINNUM(1, 9)
-#define PIN_QSPI_IO3            _PINNUM(0, 26)
-
-#define EXTERNAL_FLASH_DEVICES ZD25WQ32CEIGR
-#define EXTERNAL_FLASH_USE_QSPI
-
-////////////////////////////////////////////////////////////////////////////////
-// Builtin LEDs
-
-#define LED_RED                 _PINNUM(1, 14) // LED_3
-#define LED_BLUE                _PINNUM(1, 5)  // LED_2
-#define LED_GREEN               _PINNUM(1, 7)  // LED_1
-
-//#define PIN_STATUS_LED          LED_BLUE
-#define LED_BUILTIN             (-1)
-#define LED_PIN                 LED_BUILTIN
-#define LED_STATE_ON            LOW
-
-////////////////////////////////////////////////////////////////////////////////
-// Builtin buttons
-
-#define PIN_BUTTON1             _PINNUM(0, 24) // BOOT
-#define BUTTON_PIN              PIN_BUTTON1
-#define PIN_USER_BTN            BUTTON_PIN
-
-#define PIN_BUTTON2             _PINNUM(0, 18)
-#define BUTTON_PIN2             PIN_BUTTON2
-
-#define EXTERNAL_FLASH_DEVICES MX25R1635F
-#define EXTERNAL_FLASH_USE_QSPI
-
-////////////////////////////////////////////////////////////////////////////////
-// Lora
-
-#define USE_SX1262
-#define LORA_CS                 _PINNUM(0, 11)
-#define SX126X_POWER_EN         _PINNUM(0, 30)
-#define SX126X_DIO1             _PINNUM(1, 8)
-#define SX126X_BUSY             _PINNUM(0, 14)
-#define SX126X_RESET            _PINNUM(0, 7)
-#define SX126X_RF_VC1           _PINNUM(0, 27)
-#define SX126X_RF_VC2           _PINNUM(0, 33)
-
-#define P_LORA_DIO_1            SX126X_DIO1
-#define P_LORA_NSS              LORA_CS
-#define P_LORA_RESET            SX126X_RESET
-#define P_LORA_BUSY             SX126X_BUSY
-#define P_LORA_SCLK             PIN_SPI_SCK
-#define P_LORA_MISO             PIN_SPI_MISO
-#define P_LORA_MOSI             PIN_SPI_MOSI
-
-////////////////////////////////////////////////////////////////////////////////
-// SPI1
-
-#define PIN_SPI1_MISO           (-1)            // Not used for Display
-#define PIN_SPI1_MOSI           _PINNUM(0, 20)
-#define PIN_SPI1_SCK            _PINNUM(0, 19)
-
-// GxEPD2 needs that for a panel that is not even used !
-extern const int MISO;
-extern const int MOSI;
-extern const int SCK;
-
-////////////////////////////////////////////////////////////////////////////////
-// Display
-
-// #define DISP_MISO               (-1)         // Not used for Display
-#define DISP_MOSI               _PINNUM(0, 20)
-#define DISP_SCLK               _PINNUM(0, 19)
-#define DISP_CS                 _PINNUM(0, 22)
-#define DISP_DC                 _PINNUM(0, 21)
-#define DISP_RST                _PINNUM(0, 28)
-#define DISP_BUSY               _PINNUM(0, 3)
-#define DISP_POWER              _PINNUM(1, 12)
-// #define DISP_BACKLIGHT          (-1)         // Display has no backlight
-
-#define PIN_DISPLAY_CS          DISP_CS
-#define PIN_DISPLAY_DC          DISP_DC
-#define PIN_DISPLAY_RST         DISP_RST
-#define PIN_DISPLAY_BUSY        DISP_BUSY
-
-////////////////////////////////////////////////////////////////////////////////
-// GPS
-
-#define PIN_GPS_RX              _PINNUM(1, 13) // RXD
-#define PIN_GPS_TX              _PINNUM(1, 15) // TXD
-#define GPS_EN                  _PINNUM(1, 11) // POWER_RT9080_EN
-#define PIN_GPS_STANDBY         _PINNUM(1, 10)
-#define PIN_GPS_PPS             _PINNUM(0, 29) // 1PPS
Author	SHA1	Message	Date
pelgraine	33c2758a87	updated readme	2026-02-10 16:04:03 +11:00
pelgraine	f644892b07	standalone device phase 1 complete - utc offset from gps homepage and gps timesync without ble enabled	2026-02-10 15:59:34 +11:00
pelgraine	8f558b130f	repeater admin password persistence after successful login enabled	2026-02-10 15:12:29 +11:00
pelgraine	04462b93bc	Removed unnecessary t-echo lite variant	2026-02-10 15:10:59 +11:00
pelgraine	d42c283fb4	fixed repeater admin password entry display mode and updated readme	2026-02-10 15:06:48 +11:00
pelgraine	87a5f185d3	fix message popup accidental navigation bug	2026-02-10 14:59:30 +11:00
pelgraine	2972d1ffb4	updated mymesh to v0.8.1 now repeater admin stage 1 implemented	2026-02-10 14:56:31 +11:00
pelgraine	fe1c1931ab	Limited repeater admin function stage 1 implemented - login, clock sync, advert, neighbors list	2026-02-10 14:55:47 +11:00
pelgraine	3af2770af2	updated readme	2026-02-10 14:11:43 +11:00
pelgraine	e030a61244	DMs now available - select contact in contacts list view by pressing Enter	2026-02-10 13:59:15 +11:00
pelgraine	f630cf3a5a	Contacts now in - press N to access	2026-02-10 13:45:41 +11:00
pelgraine	ac3fb337e2	updated readme to incorporate v0.8 changes	2026-02-10 12:56:08 +11:00
pelgraine	1d4555a064	increased preamble length from 16 to 32	2026-02-10 12:51:13 +11:00
pelgraine	3d716605dc	made agc.reset.interval 500 the default	2026-02-10 12:42:26 +11:00
pelgraine	500f59abca	fixed buffer flutter overflow issue	2026-02-10 03:23:20 +11:00
pelgraine	6e60c56d48	fixed apparent $ regression	2026-02-10 03:09:28 +11:00
pelgraine	b9a68f0f99	Amended so sym plus $ prints the dollar sign now	2026-02-10 02:28:34 +11:00
pelgraine	a8675ceda9	updated emoji picker	2026-02-10 02:18:22 +11:00
pelgraine	f20435329b	updated Claude AI drawn emoji sprites list	2026-02-10 02:10:53 +11:00
pelgraine	33304c7bec	updated emoji sprites, ui word wrapping and formatting	2026-02-10 01:44:54 +11:00
pelgraine	cca984be08	First limited emoji support!	2026-02-10 00:30:03 +11:00
pelgraine	a0fef8a970	fixed epub processor so it renders " ' correctly	2026-02-09 13:57:51 +11:00
pelgraine	9e70630727	Updated ereader guide now that we've got epub conversion functionality	2026-02-09 09:25:57 +11:00
pelgraine	54e74caa96	updated mymesh version and date	2026-02-09 09:09:26 +11:00
pelgraine	69e73440db	Epub and Epub3 converter now working	2026-02-09 09:08:48 +11:00
pelgraine	4c4a218b32	adusted line spacing in channel view so that timestamp and hop count are in line with message	2026-02-08 01:53:39 +11:00
pelgraine	c719df5737	fixed mymsesh cpp error	2026-02-08 01:04:54 +11:00
pelgraine	57e13ecfa8	Implementing sent message ack functionality into txt-reader branch	2026-02-08 01:00:12 +11:00
pelgraine	39b43bde11	Much faster pre-indexing of txt files	2026-02-07 22:09:44 +11:00
pelgraine	89d24662ff	Fixed battery indicator so it uses same linear mapping as BLE app	2026-02-07 20:41:29 +11:00
pelgraine	abafefb3f7	Updated guide to txt reader incorporation	2026-02-07 18:24:34 +11:00
pelgraine	0b94a56fae	Fix indexing screen	2026-02-07 18:09:09 +11:00
pelgraine	8f1a936c39	updated version in mymesh	2026-02-07 17:46:34 +11:00
pelgraine	9eadb0a3fe	First functioning text reader and guide added	2026-02-07 17:41:11 +11:00
pelgraine	6f23cd612c	tiny text view testing	2026-02-07 16:35:02 +11:00
pelgraine	af9f41a541	Updated version and date in mymesh	2026-02-07 16:24:10 +11:00
pelgraine	0a746cdca5	Merge branch 'main' into dev	2026-02-07 16:22:51 +11:00
pelgraine	3a5c48f440	"Battery UI changes - percentage display and icon size"	2026-02-07 16:20:33 +11:00
pelgraine	e40d9ced4a	Merge branch 'dev'	2026-02-04 12:45:42 +11:00
pelgraine	b8de2d0d16	"updated mymesh h with firmware version details"	2026-02-04 12:45:06 +11:00
pelgraine	9fbc3202f6	"fixed reocurring BLE queue bug that popped up in v0.6.1. Improved keyboard responsiveness"	2026-02-04 12:44:17 +11:00
pelgraine	9d91f48797	Merge branch 'dev'	2026-02-02 21:28:48 +11:00
pelgraine	21eb385763	"Updated version date on mymesh.h and fixed modem_power_EN so 4G modem made inactive and annoying red LED Status light disabled when using firmware via Launcher mode"	2026-02-02 21:28:08 +11:00
pelgraine	4b81e596d2	"Fixed the queueSentChannelMessage BLE history ommission"	2026-02-01 20:26:27 +11:00
pelgraine	a5f2e8d055	"updated readme.md roadmap details"	2026-02-01 19:52:42 +11:00
pelgraine	462b1cb642	"Removed Preview Message overlay in favour of short popup that shows you which channel you've received a new message in"	2026-02-01 19:49:30 +11:00
pelgraine	0b270c0e1a	"Changed word wrapping in channel view screen to boundary wrapping"	2026-02-01 19:38:26 +11:00
pelgraine	2730c05329	"Updated readme and firmware version"	2026-02-01 18:18:21 +11:00
pelgraine	02d2fb08fb	"Added symbol capability"	2026-02-01 18:09:24 +11:00
pelgraine	b0003e1896	"Added additional channel compose functionality - can switch channels now. Minor ui changes for nav bar"	2026-02-01 17:51:17 +11:00
pelgraine	0be77ef759	"updated firmware version on mymesh"	2026-01-29 22:06:41 +11:00
pelgraine	c5df40cefd	Added basic Public channel only view message history and compose - bugs still present	2026-01-29 21:33:14 +11:00
pelgraine	5bdcbb25b6	"Fix fix BLE shutdown on hibernate, update version in mymesh"	2026-01-29 19:01:38 +11:00
pelgraine	53fe89b216	"updated mymesh.h version type and date details"	2026-01-29 18:31:15 +11:00
pelgraine	e194c2c48c	Replace Serial.print with MESH_DEBUG macros for cleaner debug output in main cpp, tdeckboard cpp and target cpp	2026-01-29 18:28:19 +11:00
pelgraine	9d401f76d3	Updated readme.md Revised Roadmap / To-Do to goals specific to this repo	2026-01-28 21:43:41 +11:00
pelgraine	15f392c80e	Update readme.md Removed specific references to v1.1 now that I've confirmed it works on my T-Deck v1.0 (audio only) as well	2026-01-28 21:13:31 +11:00
pelgraine	621f9f9568	"added line to readme about purchase date of v1.1"	2026-01-28 20:18:34 +11:00
pelgraine	8c9106ca86	"update readme"	2026-01-28 20:16:57 +11:00
pelgraine	f4b9c89d9f	"added and removed emoji variously to readme"	2026-01-28 20:15:44 +11:00
pelgraine	a4f5328113	"Updated readme"	2026-01-28 20:12:53 +11:00
pelgraine	2ad02f49e6	“Fixed the max contacts 400, max channels 20, pin back to 123456 for randomisation that somehow got lost in the merge from dev to main”	2026-01-28 20:05:19 +11:00