Merge branch 'main' of https://github.com/pelgraine/Meck

updated readme with new changes and quicklinks
Update key mapping for opening text reader
2026-02-10 20:51:11 +11:00 · 2026-02-10 20:49:35 +11:00 · 2026-02-10 20:45:19 +11:00 · 2026-02-10 20:33:50 +11:00 · 2026-02-10 20:27:20 +11:00 · 2026-02-10 20:18:13 +11:00
32 changed files with 9548 additions and 1954 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
@@ -3,6 +3,32 @@ This fork was created specifically to focus on enabling BLE companion firmware f

 ⭐ ***Please note as of 1 Feb 2026, the T-Deck Pro repeater & usb firmware has not been finalised nor confirmed as functioning.*** ⭐

+### Contents
+- [T-Deck Pro Keyboard Controls](#t-deck-pro-keyboard-controls)
+  - [Navigation (Home Screen)](#navigation-home-screen)
+  - [Bluetooth (BLE)](#bluetooth-ble)
+  - [Clock & Timezone](#clock--timezone)
+  - [Channel Message Screen](#channel-message-screen)
+  - [Contacts Screen](#contacts-screen)
+  - [Sending a Direct Message](#sending-a-direct-message)
+  - [Repeater Admin Screen](#repeater-admin-screen)
+  - [Settings Screen](#settings-screen)
+  - [Compose Mode](#compose-mode)
+  - [Symbol Entry (Sym Key)](#symbol-entry-sym-key)
+  - [Emoji Picker](#emoji-picker)
+- [About MeshCore](#about-meshcore)
+- [What is MeshCore?](#what-is-meshcore)
+- [Key Features](#key-features)
+- [What Can You Use MeshCore For?](#what-can-you-use-meshcore-for)
+- [How to Get Started](#how-to-get-started)
+- [MeshCore Flasher](#meshcore-flasher)
+- [MeshCore Clients](#meshcore-clients)
+- [Hardware Compatibility](#-hardware-compatibility)
+- [License](#-license)
+- [Contributing](#contributing)
+- [Road-Map / To-Do](#road-map--to-do)
+- [Get Support](#-get-support)
+
 ## T-Deck Pro Keyboard Controls

 The T-Deck Pro BLE companion firmware includes full keyboard support for standalone messaging without a phone.
@@ -12,25 +38,123 @@ The T-Deck Pro BLE companion firmware includes full keyboard support for standal
 | Key | Action |
 |-----|--------|
 | W / A | Previous page |
-| S / D | Next page |
+| D | Next page |
 | Enter | Select / Confirm |
 | M | Open channel messages |
+| C | Open contacts list |
+| E | Open e-book reader |
+| S | Open settings |
 | 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:**
+
+The UTC offset can be set from the **Settings** screen (press **S** from the home screen), or from the **GPS** home page by pressing **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 |
+| Enter | Compose new message |
 | Q | Back to home screen |

+### Contacts Screen
+
+Press **C** 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) |
+| Q | Back to home screen |
+
+### Sending a Direct Message
+
+Select a **Chat** contact in the contacts list and press **Enter** to start composing a direct message. The compose screen will show `DM: ContactName` in the header. Type your message and press **Enter** to send. The DM is sent encrypted directly to that contact (or flooded if no direct path is known). After sending or cancelling, you're returned to the contacts list.
+
+### 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 |
+| 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.
+
+### Settings Screen
+
+Press **S** from the home screen to open settings. On first boot (when the device name is still the default hex ID), the settings screen launches automatically as an onboarding wizard to set your device name and radio preset.
+
+| Key | Action |
+|-----|--------|
+| W / S | Navigate up / down through settings |
+| Enter | Edit selected setting |
+| Q | Back to home screen |
+
+**Available settings:**
+
+| Setting | Edit Method |
+|---------|-------------|
+| Device Name | Text entry — type a name, Enter to confirm |
+| Radio Preset | A / D to cycle presets (MeshCore Default, Long Range, Fast/Short, EU Default), Enter to apply |
+| Frequency | W / S to adjust, Enter to confirm |
+| Bandwidth | W / S to cycle standard values (31.25 / 62.5 / 125 / 250 / 500 kHz), Enter to confirm |
+| Spreading Factor | W / S to adjust (5–12), Enter to confirm |
+| Coding Rate | W / S to adjust (5–8), Enter to confirm |
+| TX Power | W / S to adjust (1–20 dBm), Enter to confirm |
+| UTC Offset | W / S to adjust (-12 to +14), Enter to confirm |
+| Channels | View existing channels, add hashtag channels, or delete non-primary channels (X) |
+| Device Info | Public key and firmware version (read-only) |
+
+When adding a hashtag channel, type the channel name and press Enter. The channel secret is automatically derived from the name via SHA-256, matching the standard MeshCore hashtag convention.
+
+If you've changed radio parameters, pressing Q will prompt you to apply changes before exiting.
+
 ### Compose Mode

 | Key | Action |
 |-----|--------|
-| A / D | Switch destination channel (when message is empty) |
+| 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 |
@@ -49,7 +173,7 @@ Press the **Sym** key then the letter key to enter numbers and symbols:
 | Y | ) | | H | : | | N | , |
 | U | _ | | J | ; | | M | . |
 | I | - | | K | ' | | Mic | 0 |
-| O | + | | L | " | | $ | (dedicated) |
+| O | + | | L | " | | $ | Emoji picker (Sym+$ for literal $) |
 | P | @ | | | | | | |

 ### Other Keys
@@ -60,6 +184,17 @@ Press the **Sym** key then the letter key to enter numbers and symbols:
 | 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.
@@ -118,6 +253,8 @@ Download a copy of the Meck firmware bin from https://github.com/pelgraine/Meck/

 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
 - iOS: https://apps.apple.com/us/app/meshcore/id6742354151?platform=iphone
@@ -148,7 +285,11 @@ There are a number of fairly major features in the pipeline, with no particular
 - [X] Companion radio: BLE
 - [X] Text entry for Public channel messages Companion BLE firmware
 - [X] View and compose all channel messages Companion BLE firmware
- [ ] Standalone DM functionality for 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
+- [X] Settings screen with radio presets, channel management, and first-boot onboarding
 - [ ] 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
--- a/Guide.md
+++ b/Guide.md
@@ -0,0 +1,116 @@
+# 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
+
+**Key Mapping:**
+| Context | Key | Action |
+|---------|-----|--------|
+| Home screen | E | 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);
@@ -581,6 +620,36 @@ void MyMesh::queueSentChannelMessage(uint8_t channel_idx, uint32_t timestamp, co
  }
 }

+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) {
@@ -826,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));
@@ -879,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) {
@@ -1662,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);
--- 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 "7 Feb 2026"
+#define FIRMWARE_BUILD_DATE "10 Feb 2026"
 #endif

 #ifndef FIRMWARE_VERSION
-#define FIRMWARE_VERSION "Meck v0.6.3"
+#define FIRMWARE_VERSION "Meck v0.8.3"
 #endif

 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
@@ -72,6 +72,11 @@

 /* -------------------------------------------------------------------------------------- */

+// SD-backed settings persistence (defined in main.cpp for T-Deck Pro)
+#if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
+  extern void backupSettingsToSD();
+#endif
+
 #define REQ_TYPE_GET_STATUS             0x01 // same as _GET_STATS
 #define REQ_TYPE_KEEP_ALIVE             0x02
 #define REQ_TYPE_GET_TELEMETRY_DATA     0x03
@@ -105,6 +110,15 @@ public:
  // 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;
  int getInterferenceThreshold() const override;
@@ -160,7 +174,24 @@ protected:
  }

 public:
-  void savePrefs() { _store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon); }
+  void savePrefs() {
+    _store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon);
+    #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
+      backupSettingsToSD();
+    #endif
+  }
+  void saveChannels() {
+    _store->saveChannels(this);
+    #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
+      backupSettingsToSD();
+    #endif
+  }
+  void saveContacts() {
+    _store->saveContacts(this);
+    #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
+      backupSettingsToSD();
+    #endif
+  }

 private:
  void writeOKFrame();
@@ -180,10 +211,6 @@ private:
  void checkCLIRescueCmd();
  void checkSerialInterface();

-  // helpers, short-cuts
-  void saveChannels() { _store->saveChannels(this); }
-  void saveContacts() { _store->saveContacts(this); }
-
  DataStore* _store;
  NodePrefs _prefs;
  uint32_t pending_login;
@@ -231,6 +258,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;
--- 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
@@ -7,21 +7,144 @@
 // T-Deck Pro Keyboard support
 #if defined(LilyGo_TDeck_Pro)
  #include "TCA8418Keyboard.h"
+  #include <SD.h>
+  #include "TextReaderScreen.h"
+  #include "ContactsScreen.h"
+  #include "ChannelScreen.h"
+  #include "SettingsScreen.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 chars max + null terminator
-  static int composePos = 0;
-  static uint8_t composeChannelIdx = 0;  // Which channel to send to
+  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();
+
+  // SD-backed persistence state
+  static bool sdCardReady = false;
+
+  // ---------------------------------------------------------------------------
+  // SD Settings Backup / Restore
+  // ---------------------------------------------------------------------------
+  // Copies a file byte-for-byte between two filesystem objects.
+  // Works across SPIFFS <-> SD because both use the Arduino File API.
+  static bool copyFile(fs::FS& srcFS, const char* srcPath,
+                       fs::FS& dstFS, const char* dstPath) {
+    File src = srcFS.open(srcPath, "r");
+    if (!src) return false;
+    File dst = dstFS.open(dstPath, "w", true);
+    if (!dst) { src.close(); return false; }
+
+    uint8_t buf[128];
+    while (src.available()) {
+      int n = src.read(buf, sizeof(buf));
+      if (n > 0) dst.write(buf, n);
+    }
+    src.close();
+    dst.close();
+    return true;
+  }
+
+  // Backup prefs, channels, and identity from SPIFFS to SD card.
+  // Called after any savePrefs() to keep the SD mirror current.
+  void backupSettingsToSD() {
+    if (!sdCardReady) return;
+
+    if (!SD.exists("/meshcore")) SD.mkdir("/meshcore");
+
+    if (SPIFFS.exists("/new_prefs")) {
+      copyFile(SPIFFS, "/new_prefs", SD, "/meshcore/prefs.bin");
+    }
+    // Channels may live on SPIFFS or ExtraFS - on ESP32 they are on SPIFFS
+    if (SPIFFS.exists("/channels2")) {
+      copyFile(SPIFFS, "/channels2", SD, "/meshcore/channels.bin");
+    }
+    // Identity
+    if (SPIFFS.exists("/identity/_main.id")) {
+      if (!SD.exists("/meshcore/identity")) SD.mkdir("/meshcore/identity");
+      copyFile(SPIFFS, "/identity/_main.id", SD, "/meshcore/identity/_main.id");
+    }
+    // Contacts
+    if (SPIFFS.exists("/contacts3")) {
+      copyFile(SPIFFS, "/contacts3", SD, "/meshcore/contacts.bin");
+    }
+
+    digitalWrite(SDCARD_CS, HIGH);  // Release SD CS
+    Serial.println("Settings backed up to SD");
+  }
+
+  // Restore prefs, channels, and identity from SD card to SPIFFS.
+  // Called at boot if SPIFFS prefs file is missing (e.g. after a fresh flash).
+  // Returns true if anything was restored.
+  bool restoreSettingsFromSD() {
+    if (!sdCardReady) return false;
+    
+    bool restored = false;
+
+    // Only restore if SPIFFS is missing the prefs file (fresh flash)
+    if (!SPIFFS.exists("/new_prefs") && SD.exists("/meshcore/prefs.bin")) {
+      if (copyFile(SD, "/meshcore/prefs.bin", SPIFFS, "/new_prefs")) {
+        Serial.println("Restored prefs from SD");
+        restored = true;
+      }
+    }
+
+    if (!SPIFFS.exists("/channels2") && SD.exists("/meshcore/channels.bin")) {
+      if (copyFile(SD, "/meshcore/channels.bin", SPIFFS, "/channels2")) {
+        Serial.println("Restored channels from SD");
+        restored = true;
+      }
+    }
+
+    // Identity - most critical; keeps the same device pub key across reflashes
+    if (!SPIFFS.exists("/identity/_main.id") && SD.exists("/meshcore/identity/_main.id")) {
+      SPIFFS.mkdir("/identity");
+      if (copyFile(SD, "/meshcore/identity/_main.id", SPIFFS, "/identity/_main.id")) {
+        Serial.println("Restored identity from SD");
+        restored = true;
+      }
+    }
+
+    if (!SPIFFS.exists("/contacts3") && SD.exists("/meshcore/contacts.bin")) {
+      if (copyFile(SD, "/meshcore/contacts.bin", SPIFFS, "/contacts3")) {
+        Serial.println("Restored contacts from SD");
+        restored = true;
+      }
+    }
+
+    if (restored) {
+      Serial.println("=== Settings restored from SD card backup ===");
+    }
+    digitalWrite(SDCARD_CS, HIGH);
+    return restored;
+  }
 #endif

 // Believe it or not, this std C function is busted on some platforms!
@@ -267,7 +390,31 @@ void setup() {
  MESH_DEBUG_PRINTLN("setup() - ESP32 filesystem init - calling SPIFFS.begin()");
  SPIFFS.begin(true);
  MESH_DEBUG_PRINTLN("setup() - SPIFFS.begin() done");
-  
+
+  // ---------------------------------------------------------------------------
+  // Early SD card init — needed BEFORE the_mesh.begin() so we can restore
+  // settings from a previous firmware flash.  The display SPI bus is already
+  // up (display.begin() ran earlier), so SD can share it now.
+  // ---------------------------------------------------------------------------
+  #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)) {
+      sdCardReady = true;
+      MESH_DEBUG_PRINTLN("setup() - SD card initialized (early)");
+
+      // If SPIFFS was wiped (fresh flash), restore settings from SD backup
+      if (restoreSettingsFromSD()) {
+        MESH_DEBUG_PRINTLN("setup() - Settings restored from SD backup");
+      }
+    } else {
+      MESH_DEBUG_PRINTLN("setup() - SD card not available");
+    }
+  }
+  #endif
+
  MESH_DEBUG_PRINTLN("setup() - about to call store.begin()");
  store.begin();
  MESH_DEBUG_PRINTLN("setup() - store.begin() done");
@@ -301,6 +448,12 @@ void setup() {
  the_mesh.startInterface(serial_interface);
  MESH_DEBUG_PRINTLN("setup() - the_mesh.startInterface() done");

+  // T-Deck Pro: default BLE to OFF on boot (user can toggle with Bluetooth page)
+  #if defined(LilyGo_TDeck_Pro)
+    serial_interface.disable();
+    MESH_DEBUG_PRINTLN("setup() - BLE disabled by default (toggle via home screen)");
+  #endif
+
 #else
  #error "need to define filesystem"
 #endif
@@ -328,12 +481,58 @@ void setup() {
    initKeyboard();
  #endif

+  // ---------------------------------------------------------------------------
+  // SD card is already initialized (early init above).
+  // Now set up SD-dependent features: message history + text reader.
+  // ---------------------------------------------------------------------------
+  #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
+  if (sdCardReady) {
+    // Load persisted channel messages from SD
+    ChannelScreen* chanScr = (ChannelScreen*)ui_task.getChannelScreen();
+    if (chanScr) {
+      chanScr->setSDReady(true);
+      if (chanScr->loadFromSD()) {
+        MESH_DEBUG_PRINTLN("setup() - Message history loaded from SD");
+      }
+    }
+
+    // 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);
+      }
+    }
+
+    // Do an initial settings backup to SD (captures any first-boot defaults)
+    backupSettingsToSD();
+  }
+  #endif
+
+  // ---------------------------------------------------------------------------
+  // First-boot onboarding detection
+  // Check if node name is still the default hex prefix (first 4 bytes of pub key)
+  // If so, launch onboarding wizard to set name and radio preset
+  // ---------------------------------------------------------------------------
+  #if defined(LilyGo_TDeck_Pro)
+  {
+    char defaultName[10];
+    mesh::Utils::toHex(defaultName, the_mesh.self_id.pub_key, 4);
+    NodePrefs* prefs = the_mesh.getNodePrefs();
+    if (strcmp(prefs->node_name, defaultName) == 0) {
+      MESH_DEBUG_PRINTLN("setup() - Default node name detected, launching onboarding");
+      ui_task.gotoOnboarding();
+    }
+  }
+  #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();
+    the_mesh.savePrefs();  // SD backup triggered automatically
    MESH_DEBUG_PRINTLN("setup() - GPS enabled by default");
  #endif

@@ -349,19 +548,29 @@ void loop() {
  if (!composeMode) {
    ui_task.loop();
  } else {
-    // Handle debounced compose screen refresh
+    // Handle debounced compose/emoji picker screen refresh
    if (composeNeedsRefresh && (millis() - lastComposeRefresh) >= COMPOSE_REFRESH_INTERVAL) {
-      drawComposeScreen();
+      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();
@@ -398,6 +607,37 @@ void handleKeyboardInput() {
                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
@@ -405,10 +645,18 @@ void handleKeyboardInput() {
      if (composePos > 0) {
        sendComposedMessage();
      }
+      bool wasDM = composeDM;
      composeMode = false;
+      emojiPickerMode = false;
+      composeDM = false;
+      composeDMContactIdx = -1;
      composeBuffer[0] = '\0';
      composePos = 0;
-      ui_task.gotoHomeScreen();
+      if (wasDM) {
+        ui_task.gotoContactsScreen();
+      } else {
+        ui_task.gotoHomeScreen();
+      }
      return;
    }
    
@@ -417,24 +665,39 @@ void handleKeyboardInput() {
      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;
-        ui_task.gotoHomeScreen();
+        if (wasDM) {
+          ui_task.gotoContactsScreen();
+        } else {
+          ui_task.gotoHomeScreen();
+        }
        return;
      }
-      // Regular backspace - delete last character
+      // Regular backspace - delete last character (or entire emoji including pads)
      if (composePos > 0) {
-        composePos--;
+        // 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 now %d\n", composePos);
+        Serial.printf("Compose: Backspace, pos=%d\n", composePos);
        composeNeedsRefresh = true;  // Use debounced refresh
      }
      return;
    }
    
-    // A/D keys switch channels (only when buffer is empty or as special function)
-    if ((key == 'a' || key == 'A') && composePos == 0) {
+    // 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--;
@@ -449,11 +712,11 @@ void handleKeyboardInput() {
        }
      }
      Serial.printf("Compose: Channel switched to %d\n", composeChannelIdx);
-      drawComposeScreen();
+      composeNeedsRefresh = true;  // Debounced refresh
      return;
    }
    
-    if ((key == 'd' || key == 'D') && composePos == 0) {
+    if ((key == 'd' || key == 'D') && composePos == 0 && !composeDM) {
      // Next channel
      ChannelDetails ch;
      uint8_t nextIdx = composeChannelIdx + 1;
@@ -463,7 +726,17 @@ void handleKeyboardInput() {
        composeChannelIdx = 0;  // Wrap to first channel
      }
      Serial.printf("Compose: Channel switched to %d\n", composeChannelIdx);
-      drawComposeScreen();
+      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;
    }
    
@@ -471,28 +744,66 @@ void handleKeyboardInput() {
    if (key >= 32 && key < 127 && composePos < 137) {
      composeBuffer[composePos++] = key;
      composeBuffer[composePos] = '\0';
-      Serial.printf("Compose: Added '%c', pos now %d\n", key, composePos);
+      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;
+    }
+    
+    // All other keys pass through to the reader screen
+    ui_task.injectKey(key);
+    return;
+  }
+
+  // *** SETTINGS MODE ***
+  if (ui_task.isOnSettingsScreen()) {
+    SettingsScreen* settings = (SettingsScreen*)ui_task.getSettingsScreen();
+
+    // Q key: exit settings (when not editing)
+    if (!settings->isEditing() && (key == 'q' || key == 'Q')) {
+      if (settings->hasRadioChanges()) {
+        // Let settings show "apply changes?" confirm dialog
+        ui_task.injectKey(key);
+      } else {
+        Serial.println("Exiting settings");
+        ui_task.gotoHomeScreen();
+      }
+      return;
+    }
+
+    // All other keys → settings screen via injectKey (no forceRefresh)
+    ui_task.injectKey(key);
+    return;
+  }
+
  // Normal mode - not composing
  switch (key) {
    case 'c':
    case 'C':
-      // Enter compose mode
-      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();
+      // Open contacts list
+      Serial.println("Opening contacts");
+      ui_task.gotoContactsScreen();
      break;
-    
+
    case 'm':
    case 'M':
      // Go to channel message screen
@@ -500,33 +811,40 @@ void handleKeyboardInput() {
      ui_task.gotoChannelScreen();
      break;
    
+    case 'e':
+    case 'E':
+      // Open text reader (ebooks)
+      Serial.println("Opening text reader");
+      ui_task.gotoTextReader();
+      break;
+    
+    case 's':
+    case 'S':
+      // Open settings (from home), or navigate down on channel/contacts
+      if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
+        ui_task.injectKey('s');  // Pass directly for channel/contacts scrolling
+      } else {
+        Serial.println("Opening settings");
+        ui_task.gotoSettingsScreen();
+      }
+      break;
+    
    case 'w':
    case 'W':
      // Navigate up/previous (scroll on channel screen)
-      if (ui_task.isOnChannelScreen()) {
-        ui_task.injectKey('w');  // Pass directly for channel switching
+      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.injectKey('s');  // Pass directly for channel 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.injectKey('a');  // Pass directly for channel switching
+      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
@@ -536,8 +854,8 @@ void handleKeyboardInput() {
    case 'd':
    case 'D':
      // Navigate right or switch channel (on channel screen)
-      if (ui_task.isOnChannelScreen()) {
-        ui_task.injectKey('d');  // Pass directly for channel switching
+      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
@@ -545,9 +863,38 @@ void handleKeyboardInput() {
      break;
      
    case '\r':
-      // Select/Enter
-      Serial.println("Nav: Enter/Select");
-      ui_task.injectKey(13);  // KEY_ENTER
+      // Enter = compose (only from channel or contacts screen)
+      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) {
+          Serial.printf("Selected non-chat contact type=%d idx=%d\n", ctype, idx);
+        }
+      } else if (ui_task.isOnChannelScreen()) {
+        composeDM = false;
+        composeDMContactIdx = -1;
+        composeChannelIdx = ui_task.getChannelScreenViewIdx();
+        composeMode = true;
+        composeBuffer[0] = '\0';
+        composePos = 0;
+        Serial.printf("Entering compose mode, channel %d\n", composeChannelIdx);
+        drawComposeScreen();
+        lastComposeRefresh = millis();
+      } else {
+        // Other screens: pass Enter as generic select
+        ui_task.injectKey(13);
+      }
      break;
      
    case 'q':
@@ -578,12 +925,16 @@ void drawComposeScreen() {
  display.setCursor(0, 0);
  
  // Get the channel name for display
-  ChannelDetails channel;
  char headerBuf[40];
-  if (the_mesh.getChannel(composeChannelIdx, channel)) {
-    snprintf(headerBuf, sizeof(headerBuf), "To: %s", channel.name);
+  if (composeDM) {
+    snprintf(headerBuf, sizeof(headerBuf), "DM: %s", composeDMName);
  } else {
-    snprintf(headerBuf, sizeof(headerBuf), "To: Channel %d", composeChannelIdx);
+    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);
  
@@ -593,27 +944,81 @@ void drawComposeScreen() {
  display.setCursor(0, 14);
  display.setColor(DisplayDriver::LIGHT);
  
-  // Word wrap the compose buffer - calculate chars per line based on actual font width
-  int x = 0;
+  // 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;
-  uint16_t testWidth = display.getTextWidth("MMMMMMMMMM");  // 10 wide chars
-  int charsPerLine = (testWidth > 0) ? (display.width() * 10) / testWidth : 20;
-  if (charsPerLine < 12) charsPerLine = 12;
-  if (charsPerLine > 40) charsPerLine = 40;
-  char charStr[2] = {0, 0};  // Buffer for single character as string
+  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++) {
-    charStr[0] = composeBuffer[i];
-    display.print(charStr);
-    x++;
-    if (x >= charsPerLine) {
-      x = 0;
-      y += 11;
-      display.setCursor(0, y);
+    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
@@ -626,13 +1031,13 @@ void drawComposeScreen() {
  char status[40];
  if (composePos == 0) {
    // Empty buffer - show channel switching hint
-    display.print("A/D:Ch");
+    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 Ent:Send", composePos);
+    sprintf(status, "%d/137 $:Emj", composePos);
    display.print(status);
    sprintf(status, "Sh+Del:X");
    display.setCursor(display.width() - display.getTextWidth(status) - 2, statusY);
@@ -643,27 +1048,51 @@ void drawComposeScreen() {
  #endif
 }

+void drawEmojiPicker() {
+  #ifdef DISPLAY_CLASS
+  display.startFrame();
+  emojiPicker.draw(display);
+  display.endFrame();
+  #endif
+}
+
 void sendComposedMessage() {
  if (composePos == 0) return;
  
-  // Get the selected channel
+  // 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);
    
-    // Send to channel
    if (the_mesh.sendGroupMessage(timestamp, channel.channel, 
                                   the_mesh.getNodePrefs()->node_name, 
-                                   composeBuffer, composePos)) {
-      // Add the sent message to local channel history so we can see what we sent
+                                   utf8Buf, utf8Len)) {
      ui_task.addSentChannelMessage(composeChannelIdx, 
                                     the_mesh.getNodePrefs()->node_name, 
-                                     composeBuffer);
+                                     utf8Buf);
      
-      // Queue message for BLE app sync (so sent messages appear in companion app)
      the_mesh.queueSentChannelMessage(composeChannelIdx, timestamp,
                                        the_mesh.getNodePrefs()->node_name,
-                                        composeBuffer);
+                                        utf8Buf);
      
      ui_task.showAlert("Sent!", 1500);
    } else {
--- a/examples/companion_radio/ui-new/ChannelScreen.h
+++ b/examples/companion_radio/ui-new/ChannelScreen.h
@@ -4,15 +4,47 @@
 #include <helpers/ui/DisplayDriver.h>
 #include <helpers/ChannelDetails.h>
 #include <MeshCore.h>
+#include "EmojiSprites.h"
+
+// SD card message persistence
+#if defined(HAS_SDCARD) && defined(ESP32)
+  #include <SD.h>
+#endif

 // Maximum messages to store in history
-#define CHANNEL_MSG_HISTORY_SIZE 20
+#define CHANNEL_MSG_HISTORY_SIZE 300
 #define CHANNEL_MSG_TEXT_LEN 160

 #ifndef MAX_GROUP_CHANNELS
  #define MAX_GROUP_CHANNELS 20
 #endif

+// ---------------------------------------------------------------------------
+// On-disk format for message persistence (SD card)
+// ---------------------------------------------------------------------------
+#define MSG_FILE_MAGIC   0x4D434853  // "MCHS" - MeshCore History Store
+#define MSG_FILE_VERSION 1
+#define MSG_FILE_PATH    "/meshcore/messages.bin"
+
+struct __attribute__((packed)) MsgFileHeader {
+  uint32_t magic;
+  uint16_t version;
+  uint16_t capacity;
+  uint16_t count;
+  int16_t  newestIdx;
+  // 12 bytes total
+};
+
+struct __attribute__((packed)) MsgFileRecord {
+  uint32_t timestamp;
+  uint8_t  path_len;
+  uint8_t  channel_idx;
+  uint8_t  valid;
+  uint8_t  reserved;
+  char     text[CHANNEL_MSG_TEXT_LEN];
+  // 168 bytes total
+};
+
 class UITask;  // Forward declaration
 class MyMesh;  // Forward declaration
 extern MyMesh the_mesh;
@@ -37,17 +69,20 @@ private:
  int _scrollPos;     // Current scroll position (0 = newest)
  int _msgsPerPage;   // Messages that fit on screen
  uint8_t _viewChannelIdx;  // Which channel we're currently viewing
+  bool _sdReady;      // SD card is available for persistence
  
 public:
  ChannelScreen(UITask* task, mesh::RTCClock* rtc) 
    : _task(task), _rtc(rtc), _msgCount(0), _newestIdx(-1), _scrollPos(0), 
-      _msgsPerPage(3), _viewChannelIdx(0) {
+      _msgsPerPage(CHANNEL_MSG_HISTORY_SIZE), _viewChannelIdx(0), _sdReady(false) {
    // Initialize all messages as invalid
    for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
      _messages[i].valid = false;
    }
  }

+  void setSDReady(bool ready) { _sdReady = ready; }
+
  // Add a new message to the history
  void addMessage(uint8_t channel_idx, uint8_t path_len, const char* sender, const char* text) {
    // Move to next slot in circular buffer
@@ -59,9 +94,9 @@ public:
    msg->channel_idx = channel_idx;
    msg->valid = true;
    
-    // The text already contains "Sender: message" format, just store it
-    strncpy(msg->text, text, CHANNEL_MSG_TEXT_LEN - 1);
-    msg->text[CHANNEL_MSG_TEXT_LEN - 1] = '\0';
+    // 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++;
@@ -69,6 +104,9 @@ public:
    
    // Reset scroll to show newest message
    _scrollPos = 0;
+
+    // Persist to SD card
+    saveToSD();
  }

  // Get count of messages for the currently viewed channel
@@ -87,6 +125,135 @@ public:
  uint8_t getViewChannelIdx() const { return _viewChannelIdx; }
  void setViewChannelIdx(uint8_t idx) { _viewChannelIdx = idx; _scrollPos = 0; }

+  // -----------------------------------------------------------------------
+  // SD card persistence
+  // -----------------------------------------------------------------------
+
+  // Save the entire message buffer to SD card.
+  // File: /meshcore/messages.bin  (~50 KB for 300 messages)
+  void saveToSD() {
+#if defined(HAS_SDCARD) && defined(ESP32)
+    if (!_sdReady) return;
+
+    // Ensure directory exists
+    if (!SD.exists("/meshcore")) {
+      SD.mkdir("/meshcore");
+    }
+
+    File f = SD.open(MSG_FILE_PATH, "w", true);
+    if (!f) {
+      Serial.println("ChannelScreen: SD save failed - can't open file");
+      return;
+    }
+
+    // Write header
+    MsgFileHeader hdr;
+    hdr.magic    = MSG_FILE_MAGIC;
+    hdr.version  = MSG_FILE_VERSION;
+    hdr.capacity = CHANNEL_MSG_HISTORY_SIZE;
+    hdr.count    = (uint16_t)_msgCount;
+    hdr.newestIdx = (int16_t)_newestIdx;
+    f.write((uint8_t*)&hdr, sizeof(hdr));
+
+    // Write all message slots (including invalid ones - preserves circular buffer layout)
+    for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
+      MsgFileRecord rec;
+      rec.timestamp   = _messages[i].timestamp;
+      rec.path_len    = _messages[i].path_len;
+      rec.channel_idx = _messages[i].channel_idx;
+      rec.valid       = _messages[i].valid ? 1 : 0;
+      rec.reserved    = 0;
+      memcpy(rec.text, _messages[i].text, CHANNEL_MSG_TEXT_LEN);
+      f.write((uint8_t*)&rec, sizeof(rec));
+    }
+
+    f.close();
+    digitalWrite(SDCARD_CS, HIGH);  // Release SD CS
+#endif
+  }
+
+  // Load message buffer from SD card.  Returns true if messages were loaded.
+  bool loadFromSD() {
+#if defined(HAS_SDCARD) && defined(ESP32)
+    if (!_sdReady) return false;
+
+    if (!SD.exists(MSG_FILE_PATH)) {
+      Serial.println("ChannelScreen: No saved messages on SD");
+      return false;
+    }
+
+    File f = SD.open(MSG_FILE_PATH, "r");
+    if (!f) {
+      Serial.println("ChannelScreen: SD load failed - can't open file");
+      return false;
+    }
+
+    // Read and validate header
+    MsgFileHeader hdr;
+    if (f.read((uint8_t*)&hdr, sizeof(hdr)) != sizeof(hdr)) {
+      Serial.println("ChannelScreen: SD load failed - short header");
+      f.close();
+      return false;
+    }
+
+    if (hdr.magic != MSG_FILE_MAGIC) {
+      Serial.printf("ChannelScreen: SD load failed - bad magic 0x%08X\n", hdr.magic);
+      f.close();
+      return false;
+    }
+
+    if (hdr.version != MSG_FILE_VERSION) {
+      Serial.printf("ChannelScreen: SD load failed - version %d (expected %d)\n",
+                    hdr.version, MSG_FILE_VERSION);
+      f.close();
+      return false;
+    }
+
+    if (hdr.capacity != CHANNEL_MSG_HISTORY_SIZE) {
+      Serial.printf("ChannelScreen: SD load failed - capacity %d (expected %d)\n",
+                    hdr.capacity, CHANNEL_MSG_HISTORY_SIZE);
+      f.close();
+      return false;
+    }
+
+    // Read message records
+    int loaded = 0;
+    for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
+      MsgFileRecord rec;
+      if (f.read((uint8_t*)&rec, sizeof(rec)) != sizeof(rec)) {
+        Serial.printf("ChannelScreen: SD load - short read at record %d\n", i);
+        break;
+      }
+      _messages[i].timestamp   = rec.timestamp;
+      _messages[i].path_len    = rec.path_len;
+      _messages[i].channel_idx = rec.channel_idx;
+      _messages[i].valid       = (rec.valid != 0);
+      memcpy(_messages[i].text, rec.text, CHANNEL_MSG_TEXT_LEN);
+      if (_messages[i].valid) loaded++;
+    }
+
+    _msgCount   = (int)hdr.count;
+    _newestIdx  = (int)hdr.newestIdx;
+    _scrollPos  = 0;
+
+    // Sanity-check restored state
+    if (_newestIdx < -1 || _newestIdx >= CHANNEL_MSG_HISTORY_SIZE) _newestIdx = -1;
+    if (_msgCount < 0 || _msgCount > CHANNEL_MSG_HISTORY_SIZE) _msgCount = loaded;
+
+    f.close();
+    digitalWrite(SDCARD_CS, HIGH);  // Release SD CS
+    Serial.printf("ChannelScreen: Loaded %d messages from SD (count=%d, newest=%d)\n",
+                  loaded, _msgCount, _newestIdx);
+    return loaded > 0;
+#else
+    return false;
+#endif
+  }
+
+  // -----------------------------------------------------------------------
+  // Rendering
+  // -----------------------------------------------------------------------
+
  int render(DisplayDriver& display) override {
    char tmp[40];
    
@@ -114,24 +281,23 @@ public:
    display.drawRect(0, 11, display.width(), 1);
    
    if (channelMsgCount == 0) {
-      display.setCursor(0, 25);
+      display.setTextSize(0);  // Tiny font for body text
+      display.setCursor(0, 20);
      display.setColor(DisplayDriver::LIGHT);
      display.print("No messages yet");
-      display.setCursor(0, 40);
+      display.setCursor(0, 30);
      display.print("A/D: Switch channel");
-      display.setCursor(0, 52);
+      display.setCursor(0, 40);
      display.print("C: Compose message");
+      display.setTextSize(1);  // Restore for footer
    } else {
-      int lineHeight = 10;
+      display.setTextSize(0);  // Tiny font for message body
+      int lineHeight = 9;   // 8px font + 1px spacing
      int headerHeight = 14;
      int footerHeight = 14;
-      
-      // Calculate chars per line based on actual font width (not assumed 6px)
-      // Measure a test string and scale accordingly
-      uint16_t testWidth = display.getTextWidth("MMMMMMMMMM");  // 10 wide chars
-      int charsPerLine = (testWidth > 0) ? (display.width() * 10) / testWidth : 20;
-      if (charsPerLine < 12) charsPerLine = 12;  // Minimum reasonable
-      if (charsPerLine > 40) charsPerLine = 40;  // Maximum reasonable
+      // 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;
      
@@ -149,66 +315,159 @@ public:
        }
      }
      
-      // Display messages from scroll position
+      // 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 = _scrollPos; i < numChannelMsgs && y < display.height() - footerHeight - lineHeight; i++) {
+      bool screenFull = false;
+      for (int i = startIdx; i < numChannelMsgs && y + lineHeight <= maxY; i++) {
        int idx = channelMsgs[i];
        ChannelMessage* msg = &_messages[idx];
        
-        // Time indicator with hop count
+        // 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);
+          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);
+          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);
+          sprintf(tmp, "(%d) %dh ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 3600);
        } else {
-          sprintf(tmp, "(%d) %dd", msg->path_len == 0xFF ? 0 : msg->path_len, age / 86400);
+          sprintf(tmp, "(%d) %dd ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 86400);
        }
        display.print(tmp);
-        y += lineHeight;
+        // DO NOT advance y - message text continues on the same line
        
-        // Message text with character wrapping (like compose screen - fills full width)
+        // 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 = 6;  // Allow more lines per message
-        int x = 0;
+        int maxLinesPerMsg = 8;
        char charStr[2] = {0, 0};
        
-        display.setCursor(0, y);
+        // 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 < display.height() - footerHeight - 2) {
-          charStr[0] = msg->text[pos];
-          display.print(charStr);
-          x++;
-          pos++;
+        while (pos < textLen && linesForThisMsg < maxLinesPerMsg && y + lineHeight <= maxY) {
+          uint8_t b = (uint8_t)msg->text[pos];
          
-          if (x >= charsPerLine) {
-            x = 0;
-            linesForThisMsg++;
-            y += lineHeight;
-            if (linesForThisMsg < maxLinesPerMsg && y < display.height() - footerHeight - 2) {
-              display.setCursor(0, y);
+          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 (x > 0) {
+        if (px > 0) {
          y += lineHeight;
        }
        
-        y += 2;
+        y += 2;  // Small gap between messages
        msgsDrawn++;
+        if (y + lineHeight > maxY) screenFull = true;
+      }
+      
+      // Only update _msgsPerPage when the screen actually filled up.
+      // If we ran out of messages before filling the screen, keep the
+      // previous (higher) value so startIdx doesn't under-count.
+      if (screenFull && msgsDrawn > 0) {
        _msgsPerPage = msgsDrawn;
      }
+      
+      display.setTextSize(1);  // Restore for footer
    }
    
    // Footer with controls
@@ -220,8 +479,8 @@ public:
    // Left side: Q:Back A/D:Ch
    display.print("Q:Back A/D:Ch");
    
-    // Right side: C:New
-    const char* rightText = "C:New";
+    // Right side: Entr:New
+    const char* rightText = "Entr:New";
    display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
    display.print(rightText);

--- a/examples/companion_radio/ui-new/Contactsscreen.h
+++ b/examples/companion_radio/ui-new/Contactsscreen.h
@@ -0,0 +1,348 @@
+#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: All → total/max, filtered → matched/total
+    if (_filter == FILTER_ALL) {
+      snprintf(tmp, sizeof(tmp), "%d/%d", (int)the_mesh.getNumContacts(), MAX_CONTACTS);
+    } else {
+      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
+  { 0x1F030, 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/Settingsscreen.h
+++ b/examples/companion_radio/ui-new/Settingsscreen.h
@@ -0,0 +1,849 @@
+#pragma once
+
+#include <helpers/ui/UIScreen.h>
+#include <helpers/ui/DisplayDriver.h>
+#include <helpers/ChannelDetails.h>
+#include <MeshCore.h>
+#include "../NodePrefs.h"
+
+// Forward declarations
+class UITask;
+class MyMesh;
+extern MyMesh the_mesh;
+
+// ---------------------------------------------------------------------------
+// Radio presets
+// ---------------------------------------------------------------------------
+struct RadioPreset {
+  const char* name;
+  float freq;
+  float bw;
+  uint8_t sf;
+  uint8_t cr;
+  uint8_t tx_power;
+};
+
+static const RadioPreset RADIO_PRESETS[] = {
+  { "MeshCore Default", 915.0f, 250.0f, 10, 5, 20 },
+  { "Long Range",       915.0f, 125.0f, 12, 8, 20 },
+  { "Fast/Short",       915.0f, 500.0f,  7, 5, 20 },
+  { "EU Default",       869.4f, 250.0f, 10, 5, 14 },
+};
+#define NUM_RADIO_PRESETS (sizeof(RADIO_PRESETS) / sizeof(RADIO_PRESETS[0]))
+
+// ---------------------------------------------------------------------------
+// Settings row types
+// ---------------------------------------------------------------------------
+enum SettingsRowType : uint8_t {
+  ROW_NAME,           // Device name (text editor)
+  ROW_RADIO_PRESET,   // Radio preset picker
+  ROW_FREQ,           // Frequency (float)
+  ROW_BW,             // Bandwidth (float)
+  ROW_SF,             // Spreading factor (5-12)
+  ROW_CR,             // Coding rate (5-8)
+  ROW_TX_POWER,       // TX power (1-20 dBm)
+  ROW_UTC_OFFSET,     // UTC offset (-12 to +14)
+  ROW_CH_HEADER,      // "--- Channels ---" separator
+  ROW_CHANNEL,        // A channel entry (dynamic, index stored separately)
+  ROW_ADD_CHANNEL,    // "+ Add Hashtag Channel"
+  ROW_INFO_HEADER,    // "--- Info ---" separator
+  ROW_PUB_KEY,        // Public key display
+  ROW_FIRMWARE,       // Firmware version
+};
+
+// ---------------------------------------------------------------------------
+// Editing modes
+// ---------------------------------------------------------------------------
+enum EditMode : uint8_t {
+  EDIT_NONE,         // Just browsing
+  EDIT_TEXT,         // Typing into a text buffer (name, channel name)
+  EDIT_PICKER,       // A/D cycles options (radio preset)
+  EDIT_NUMBER,       // W/S adjusts value (freq, BW, SF, CR, TX, UTC)
+  EDIT_CONFIRM,      // Confirmation dialog (delete channel, apply radio)
+};
+
+// Max rows in the settings list
+#define SETTINGS_MAX_ROWS 40
+#define SETTINGS_TEXT_BUF  33  // 32 chars + null
+
+class SettingsScreen : public UIScreen {
+private:
+  UITask* _task;
+  mesh::RTCClock* _rtc;
+  NodePrefs* _prefs;
+
+  // Row table — rebuilt whenever channels change
+  struct Row {
+    SettingsRowType type;
+    uint8_t param;       // channel index for ROW_CHANNEL, preset index for ROW_RADIO_PRESET
+  };
+  Row _rows[SETTINGS_MAX_ROWS];
+  int _numRows;
+
+  // Cursor & scroll
+  int _cursor;        // selected row
+  int _scrollTop;     // first visible row
+
+  // Editing state
+  EditMode _editMode;
+  char _editBuf[SETTINGS_TEXT_BUF];
+  int _editPos;
+  int _editPickerIdx;       // for preset picker
+  float _editFloat;         // for freq/BW editing
+  int _editInt;             // for SF/CR/TX/UTC editing
+  int _confirmAction;       // 0=none, 1=delete channel, 2=apply radio
+
+  // Onboarding mode
+  bool _onboarding;
+
+  // Dirty flag for radio params — prompt to apply
+  bool _radioChanged;
+
+  // ---------------------------------------------------------------------------
+  // Row table management
+  // ---------------------------------------------------------------------------
+
+  void rebuildRows() {
+    _numRows = 0;
+
+    addRow(ROW_NAME);
+    addRow(ROW_RADIO_PRESET);
+    addRow(ROW_FREQ);
+    addRow(ROW_BW);
+    addRow(ROW_SF);
+    addRow(ROW_CR);
+    addRow(ROW_TX_POWER);
+    addRow(ROW_UTC_OFFSET);
+    addRow(ROW_CH_HEADER);
+
+    // Enumerate current channels
+    for (uint8_t i = 0; i < MAX_GROUP_CHANNELS; i++) {
+      ChannelDetails ch;
+      if (the_mesh.getChannel(i, ch) && ch.name[0] != '\0') {
+        addRow(ROW_CHANNEL, i);
+      } else {
+        break;  // channels are contiguous
+      }
+    }
+
+    addRow(ROW_ADD_CHANNEL);
+    addRow(ROW_INFO_HEADER);
+    addRow(ROW_PUB_KEY);
+    addRow(ROW_FIRMWARE);
+
+    // Clamp cursor
+    if (_cursor >= _numRows) _cursor = _numRows - 1;
+    if (_cursor < 0) _cursor = 0;
+    skipNonSelectable(1);
+  }
+
+  void addRow(SettingsRowType type, uint8_t param = 0) {
+    if (_numRows < SETTINGS_MAX_ROWS) {
+      _rows[_numRows].type = type;
+      _rows[_numRows].param = param;
+      _numRows++;
+    }
+  }
+
+  bool isSelectable(int idx) const {
+    if (idx < 0 || idx >= _numRows) return false;
+    SettingsRowType t = _rows[idx].type;
+    return t != ROW_CH_HEADER && t != ROW_INFO_HEADER;
+  }
+
+  void skipNonSelectable(int dir) {
+    while (_cursor >= 0 && _cursor < _numRows && !isSelectable(_cursor)) {
+      _cursor += dir;
+    }
+    if (_cursor < 0) _cursor = 0;
+    if (_cursor >= _numRows) _cursor = _numRows - 1;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Radio preset detection
+  // ---------------------------------------------------------------------------
+
+  int detectCurrentPreset() const {
+    for (int i = 0; i < (int)NUM_RADIO_PRESETS; i++) {
+      const RadioPreset& p = RADIO_PRESETS[i];
+      if (fabsf(_prefs->freq - p.freq) < 0.01f &&
+          fabsf(_prefs->bw - p.bw) < 0.01f &&
+          _prefs->sf == p.sf &&
+          _prefs->cr == p.cr &&
+          _prefs->tx_power_dbm == p.tx_power) {
+        return i;
+      }
+    }
+    return -1;  // Custom
+  }
+
+  // ---------------------------------------------------------------------------
+  // Hashtag channel creation
+  // ---------------------------------------------------------------------------
+
+  void createHashtagChannel(const char* name) {
+    // Build channel name with # prefix if not already present
+    char chanName[32];
+    if (name[0] == '#') {
+      strncpy(chanName, name, sizeof(chanName));
+    } else {
+      chanName[0] = '#';
+      strncpy(&chanName[1], name, sizeof(chanName) - 1);
+    }
+    chanName[31] = '\0';
+
+    // Generate 128-bit PSK from SHA-256 of channel name
+    ChannelDetails newCh;
+    memset(&newCh, 0, sizeof(newCh));
+    strncpy(newCh.name, chanName, sizeof(newCh.name));
+    newCh.name[31] = '\0';
+
+    // SHA-256 the channel name → first 16 bytes become the secret
+    uint8_t hash[32];
+    mesh::Utils::sha256(hash, 32, (const uint8_t*)chanName, strlen(chanName));
+    memcpy(newCh.channel.secret, hash, 16);
+    // Upper 16 bytes left as zero → setChannel uses 128-bit mode
+
+    // Find next empty slot
+    for (uint8_t i = 0; i < MAX_GROUP_CHANNELS; i++) {
+      ChannelDetails existing;
+      if (!the_mesh.getChannel(i, existing) || existing.name[0] == '\0') {
+        if (the_mesh.setChannel(i, newCh)) {
+          the_mesh.saveChannels();
+          Serial.printf("Settings: Created hashtag channel '%s' at idx %d\n", chanName, i);
+        }
+        break;
+      }
+    }
+  }
+
+  void deleteChannel(uint8_t idx) {
+    // Clear the channel by writing an empty ChannelDetails
+    // Then compact: shift all channels above it down by one
+    ChannelDetails empty;
+    memset(&empty, 0, sizeof(empty));
+
+    // Find total channel count
+    int total = 0;
+    for (uint8_t i = 0; i < MAX_GROUP_CHANNELS; i++) {
+      ChannelDetails ch;
+      if (the_mesh.getChannel(i, ch) && ch.name[0] != '\0') {
+        total = i + 1;
+      } else {
+        break;
+      }
+    }
+
+    // Shift channels down
+    for (int i = idx; i < total - 1; i++) {
+      ChannelDetails next;
+      if (the_mesh.getChannel(i + 1, next)) {
+        the_mesh.setChannel(i, next);
+      }
+    }
+    // Clear the last slot
+    the_mesh.setChannel(total - 1, empty);
+    the_mesh.saveChannels();
+    Serial.printf("Settings: Deleted channel at idx %d, compacted %d channels\n", idx, total);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Apply radio parameters live
+  // ---------------------------------------------------------------------------
+
+  void applyRadioParams() {
+    radio_set_params(_prefs->freq, _prefs->bw, _prefs->sf, _prefs->cr);
+    radio_set_tx_power(_prefs->tx_power_dbm);
+    the_mesh.savePrefs();
+    _radioChanged = false;
+    Serial.printf("Settings: Radio params applied - %.3f/%g/%d/%d TX:%d\n",
+                  _prefs->freq, _prefs->bw, _prefs->sf, _prefs->cr, _prefs->tx_power_dbm);
+  }
+
+public:
+  SettingsScreen(UITask* task, mesh::RTCClock* rtc, NodePrefs* prefs)
+    : _task(task), _rtc(rtc), _prefs(prefs),
+      _numRows(0), _cursor(0), _scrollTop(0),
+      _editMode(EDIT_NONE), _editPos(0), _editPickerIdx(0),
+      _editFloat(0), _editInt(0), _confirmAction(0),
+      _onboarding(false), _radioChanged(false) {
+    memset(_editBuf, 0, sizeof(_editBuf));
+  }
+
+  void enter() {
+    _editMode = EDIT_NONE;
+    _cursor = 0;
+    _scrollTop = 0;
+    _radioChanged = false;
+    rebuildRows();
+  }
+
+  void enterOnboarding() {
+    enter();
+    _onboarding = true;
+    // Start editing the device name immediately
+    _cursor = 0;  // ROW_NAME
+    startEditText(_prefs->node_name);
+  }
+
+  bool isOnboarding() const { return _onboarding; }
+  bool isEditing() const { return _editMode != EDIT_NONE; }
+  bool hasRadioChanges() const { return _radioChanged; }
+
+  // ---------------------------------------------------------------------------
+  // Edit mode starters
+  // ---------------------------------------------------------------------------
+
+  void startEditText(const char* initial) {
+    _editMode = EDIT_TEXT;
+    strncpy(_editBuf, initial, SETTINGS_TEXT_BUF - 1);
+    _editBuf[SETTINGS_TEXT_BUF - 1] = '\0';
+    _editPos = strlen(_editBuf);
+  }
+
+  void startEditPicker(int initialIdx) {
+    _editMode = EDIT_PICKER;
+    _editPickerIdx = initialIdx;
+  }
+
+  void startEditFloat(float initial) {
+    _editMode = EDIT_NUMBER;
+    _editFloat = initial;
+  }
+
+  void startEditInt(int initial) {
+    _editMode = EDIT_NUMBER;
+    _editInt = initial;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Rendering
+  // ---------------------------------------------------------------------------
+
+  int render(DisplayDriver& display) override {
+    char tmp[64];
+
+    // === Header ===
+    display.setTextSize(1);
+    display.setColor(DisplayDriver::GREEN);
+    display.setCursor(0, 0);
+    if (_onboarding) {
+      display.print("Welcome! Setup");
+    } else {
+      display.print("Settings");
+    }
+
+    // Right side: row indicator
+    snprintf(tmp, sizeof(tmp), "%d/%d", _cursor + 1, _numRows);
+    display.setCursor(display.width() - display.getTextWidth(tmp) - 2, 0);
+    display.print(tmp);
+
+    display.drawRect(0, 11, display.width(), 1);
+
+    // === Body ===
+    display.setTextSize(0);  // tiny font
+    int lineHeight = 9;
+    int headerH = 14;
+    int footerH = 14;
+    int maxY = display.height() - footerH;
+
+    // Center scroll window around cursor
+    int maxVisible = (maxY - headerH) / lineHeight;
+    if (maxVisible < 3) maxVisible = 3;
+    _scrollTop = max(0, min(_cursor - maxVisible / 2, _numRows - maxVisible));
+    int endIdx = min(_numRows, _scrollTop + maxVisible);
+
+    int y = headerH;
+
+    for (int i = _scrollTop; i < endIdx && y + lineHeight <= maxY; i++) {
+      bool selected = (i == _cursor);
+      bool editing = selected && (_editMode != EDIT_NONE);
+
+      // Selection highlight
+      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(0, y);
+
+      switch (_rows[i].type) {
+        case ROW_NAME:
+          if (editing && _editMode == EDIT_TEXT) {
+            snprintf(tmp, sizeof(tmp), "Name: %s_", _editBuf);
+          } else {
+            snprintf(tmp, sizeof(tmp), "Name: %s", _prefs->node_name);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_RADIO_PRESET: {
+          int preset = detectCurrentPreset();
+          if (editing && _editMode == EDIT_PICKER) {
+            if (_editPickerIdx >= 0 && _editPickerIdx < (int)NUM_RADIO_PRESETS) {
+              snprintf(tmp, sizeof(tmp), "< %s >", RADIO_PRESETS[_editPickerIdx].name);
+            } else {
+              strcpy(tmp, "< Custom >");
+            }
+          } else {
+            if (preset >= 0) {
+              snprintf(tmp, sizeof(tmp), "Preset: %s", RADIO_PRESETS[preset].name);
+            } else {
+              strcpy(tmp, "Preset: Custom");
+            }
+          }
+          display.print(tmp);
+          break;
+        }
+
+        case ROW_FREQ:
+          if (editing && _editMode == EDIT_NUMBER) {
+            snprintf(tmp, sizeof(tmp), "Freq: %.3f <W/S>", _editFloat);
+          } else {
+            snprintf(tmp, sizeof(tmp), "Freq: %.3f MHz", _prefs->freq);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_BW:
+          if (editing && _editMode == EDIT_NUMBER) {
+            snprintf(tmp, sizeof(tmp), "BW: %.1f <W/S>", _editFloat);
+          } else {
+            snprintf(tmp, sizeof(tmp), "BW: %.1f kHz", _prefs->bw);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_SF:
+          if (editing && _editMode == EDIT_NUMBER) {
+            snprintf(tmp, sizeof(tmp), "SF: %d <W/S>", _editInt);
+          } else {
+            snprintf(tmp, sizeof(tmp), "SF: %d", _prefs->sf);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_CR:
+          if (editing && _editMode == EDIT_NUMBER) {
+            snprintf(tmp, sizeof(tmp), "CR: %d <W/S>", _editInt);
+          } else {
+            snprintf(tmp, sizeof(tmp), "CR: %d", _prefs->cr);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_TX_POWER:
+          if (editing && _editMode == EDIT_NUMBER) {
+            snprintf(tmp, sizeof(tmp), "TX: %d dBm <W/S>", _editInt);
+          } else {
+            snprintf(tmp, sizeof(tmp), "TX: %d dBm", _prefs->tx_power_dbm);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_UTC_OFFSET:
+          if (editing && _editMode == EDIT_NUMBER) {
+            snprintf(tmp, sizeof(tmp), "UTC: %+d <W/S>", _editInt);
+          } else {
+            snprintf(tmp, sizeof(tmp), "UTC Offset: %+d", _prefs->utc_offset_hours);
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_CH_HEADER:
+          display.setColor(DisplayDriver::YELLOW);
+          display.print("--- Channels ---");
+          break;
+
+        case ROW_CHANNEL: {
+          uint8_t chIdx = _rows[i].param;
+          ChannelDetails ch;
+          if (the_mesh.getChannel(chIdx, ch)) {
+            if (chIdx == 0) {
+              // Public channel - not deletable
+              snprintf(tmp, sizeof(tmp), " %s", ch.name);
+            } else {
+              snprintf(tmp, sizeof(tmp), " %s", ch.name);
+              if (selected) {
+                // Show delete hint on right
+                const char* hint = "Del:X";
+                int hintW = display.getTextWidth(hint);
+                display.setCursor(display.width() - hintW - 2, y);
+                display.print(hint);
+                display.setCursor(0, y);
+              }
+            }
+          } else {
+            snprintf(tmp, sizeof(tmp), " (empty)");
+          }
+          display.print(tmp);
+          break;
+        }
+
+        case ROW_ADD_CHANNEL:
+          if (editing && _editMode == EDIT_TEXT) {
+            snprintf(tmp, sizeof(tmp), "# %s_", _editBuf);
+          } else {
+            display.setColor(selected ? DisplayDriver::DARK : DisplayDriver::GREEN);
+            strcpy(tmp, "+ Add Hashtag Channel");
+          }
+          display.print(tmp);
+          break;
+
+        case ROW_INFO_HEADER:
+          display.setColor(DisplayDriver::YELLOW);
+          display.print("--- Device Info ---");
+          break;
+
+        case ROW_PUB_KEY: {
+          // Show first 8 bytes of pub key as hex (16 chars)
+          char hexBuf[17];
+          mesh::Utils::toHex(hexBuf, the_mesh.self_id.pub_key, 8);
+          snprintf(tmp, sizeof(tmp), "ID: %s", hexBuf);
+          display.print(tmp);
+          break;
+        }
+
+        case ROW_FIRMWARE:
+          snprintf(tmp, sizeof(tmp), "FW: %s", FIRMWARE_VERSION);
+          display.print(tmp);
+          break;
+      }
+
+      y += lineHeight;
+    }
+
+    display.setTextSize(1);
+
+    // === Confirmation overlay ===
+    if (_editMode == EDIT_CONFIRM) {
+      int bx = 4, by = 30, bw = display.width() - 8, bh = 36;
+      display.setColor(DisplayDriver::DARK);
+      display.fillRect(bx, by, bw, bh);
+      display.setColor(DisplayDriver::LIGHT);
+      display.drawRect(bx, by, bw, bh);
+
+      display.setTextSize(0);
+      if (_confirmAction == 1) {
+        uint8_t chIdx = _rows[_cursor].param;
+        ChannelDetails ch;
+        the_mesh.getChannel(chIdx, ch);
+        snprintf(tmp, sizeof(tmp), "Delete %s?", ch.name);
+        display.drawTextCentered(display.width() / 2, by + 4, tmp);
+      } else if (_confirmAction == 2) {
+        display.drawTextCentered(display.width() / 2, by + 4, "Apply radio changes?");
+      }
+      display.drawTextCentered(display.width() / 2, by + bh - 14, "Enter:Yes  Q:No");
+      display.setTextSize(1);
+    }
+
+    // === Footer ===
+    int footerY = display.height() - 12;
+    display.drawRect(0, footerY - 2, display.width(), 1);
+    display.setColor(DisplayDriver::YELLOW);
+    display.setCursor(0, footerY);
+
+    if (_editMode == EDIT_TEXT) {
+      display.print("Type, Enter:Ok Q:Cancel");
+    } else if (_editMode == EDIT_PICKER) {
+      display.print("A/D:Choose Enter:Ok");
+    } else if (_editMode == EDIT_NUMBER) {
+      display.print("W/S:Adj Enter:Ok Q:Cancel");
+    } else if (_editMode == EDIT_CONFIRM) {
+      // Footer already covered by overlay
+    } else {
+      display.print("Q:Bck");
+      const char* r = "W/S:Up/Dwn Entr:Chng";
+      display.setCursor(display.width() - display.getTextWidth(r) - 2, footerY);
+      display.print(r);
+    }
+
+    return _editMode != EDIT_NONE ? 700 : 1000;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Input handling
+  // ---------------------------------------------------------------------------
+
+  // Handle a keyboard character. Returns true if the screen consumed the input.
+  bool handleKeyInput(char c) {
+    // --- Confirmation dialog ---
+    if (_editMode == EDIT_CONFIRM) {
+      if (c == '\r' || c == 13) {
+        if (_confirmAction == 1) {
+          // Delete channel
+          uint8_t chIdx = _rows[_cursor].param;
+          deleteChannel(chIdx);
+          rebuildRows();
+        } else if (_confirmAction == 2) {
+          applyRadioParams();
+        }
+        _editMode = EDIT_NONE;
+        _confirmAction = 0;
+        return true;
+      }
+      if (c == 'q' || c == 'Q') {
+        _editMode = EDIT_NONE;
+        _confirmAction = 0;
+        return true;
+      }
+      return true;  // consume all keys in confirm mode
+    }
+
+    // --- Text editing mode ---
+    if (_editMode == EDIT_TEXT) {
+      if (c == '\r' || c == 13) {
+        // Confirm text edit
+        SettingsRowType type = _rows[_cursor].type;
+        if (type == ROW_NAME) {
+          if (_editPos > 0) {
+            strncpy(_prefs->node_name, _editBuf, sizeof(_prefs->node_name));
+            _prefs->node_name[31] = '\0';
+            the_mesh.savePrefs();
+            Serial.printf("Settings: Name set to '%s'\n", _prefs->node_name);
+          }
+          _editMode = EDIT_NONE;
+          if (_onboarding) {
+            // Move to radio preset selection
+            _cursor = 1;  // ROW_RADIO_PRESET
+            startEditPicker(max(0, detectCurrentPreset()));
+          }
+        } else if (type == ROW_ADD_CHANNEL) {
+          if (_editPos > 0) {
+            createHashtagChannel(_editBuf);
+            rebuildRows();
+          }
+          _editMode = EDIT_NONE;
+        }
+        return true;
+      }
+      if (c == 'q' || c == 'Q' || c == 27) {
+        _editMode = EDIT_NONE;
+        return true;
+      }
+      if (c == '\b') {
+        if (_editPos > 0) {
+          _editPos--;
+          _editBuf[_editPos] = '\0';
+        }
+        return true;
+      }
+      // Printable character
+      if (c >= 32 && c < 127 && _editPos < SETTINGS_TEXT_BUF - 1) {
+        _editBuf[_editPos++] = c;
+        _editBuf[_editPos] = '\0';
+        return true;
+      }
+      return true;  // consume all keys in text edit
+    }
+
+    // --- Picker mode (radio preset) ---
+    if (_editMode == EDIT_PICKER) {
+      if (c == 'a' || c == 'A') {
+        _editPickerIdx--;
+        if (_editPickerIdx < 0) _editPickerIdx = (int)NUM_RADIO_PRESETS - 1;
+        return true;
+      }
+      if (c == 'd' || c == 'D') {
+        _editPickerIdx++;
+        if (_editPickerIdx >= (int)NUM_RADIO_PRESETS) _editPickerIdx = 0;
+        return true;
+      }
+      if (c == '\r' || c == 13) {
+        // Apply preset
+        if (_editPickerIdx >= 0 && _editPickerIdx < (int)NUM_RADIO_PRESETS) {
+          const RadioPreset& p = RADIO_PRESETS[_editPickerIdx];
+          _prefs->freq = p.freq;
+          _prefs->bw = p.bw;
+          _prefs->sf = p.sf;
+          _prefs->cr = p.cr;
+          _prefs->tx_power_dbm = p.tx_power;
+          _radioChanged = true;
+        }
+        _editMode = EDIT_NONE;
+        if (_onboarding) {
+          // Apply and finish onboarding
+          applyRadioParams();
+          _onboarding = false;
+        }
+        return true;
+      }
+      if (c == 'q' || c == 'Q') {
+        _editMode = EDIT_NONE;
+        return true;
+      }
+      return true;
+    }
+
+    // --- Number editing mode ---
+    if (_editMode == EDIT_NUMBER) {
+      SettingsRowType type = _rows[_cursor].type;
+
+      if (c == 'w' || c == 'W') {
+        switch (type) {
+          case ROW_FREQ:    _editFloat += 0.1f; break;
+          case ROW_BW:
+            // Cycle through common bandwidths
+            if (_editFloat < 31.25f) _editFloat = 31.25f;
+            else if (_editFloat < 62.5f) _editFloat = 62.5f;
+            else if (_editFloat < 125.0f) _editFloat = 125.0f;
+            else if (_editFloat < 250.0f) _editFloat = 250.0f;
+            else _editFloat = 500.0f;
+            break;
+          case ROW_SF:      if (_editInt < 12) _editInt++; break;
+          case ROW_CR:      if (_editInt < 8)  _editInt++; break;
+          case ROW_TX_POWER: if (_editInt < MAX_LORA_TX_POWER) _editInt++; break;
+          case ROW_UTC_OFFSET: if (_editInt < 14) _editInt++; break;
+          default: break;
+        }
+        return true;
+      }
+      if (c == 's' || c == 'S') {
+        switch (type) {
+          case ROW_FREQ:    _editFloat -= 0.1f; break;
+          case ROW_BW:
+            if (_editFloat > 250.0f) _editFloat = 250.0f;
+            else if (_editFloat > 125.0f) _editFloat = 125.0f;
+            else if (_editFloat > 62.5f) _editFloat = 62.5f;
+            else _editFloat = 31.25f;
+            break;
+          case ROW_SF:      if (_editInt > 5)  _editInt--; break;
+          case ROW_CR:      if (_editInt > 5)  _editInt--; break;
+          case ROW_TX_POWER: if (_editInt > 1)  _editInt--; break;
+          case ROW_UTC_OFFSET: if (_editInt > -12) _editInt--; break;
+          default: break;
+        }
+        return true;
+      }
+      if (c == '\r' || c == 13) {
+        // Confirm number edit
+        switch (type) {
+          case ROW_FREQ:
+            _prefs->freq = constrain(_editFloat, 400.0f, 2500.0f);
+            _radioChanged = true;
+            break;
+          case ROW_BW:
+            _prefs->bw = _editFloat;
+            _radioChanged = true;
+            break;
+          case ROW_SF:
+            _prefs->sf = (uint8_t)constrain(_editInt, 5, 12);
+            _radioChanged = true;
+            break;
+          case ROW_CR:
+            _prefs->cr = (uint8_t)constrain(_editInt, 5, 8);
+            _radioChanged = true;
+            break;
+          case ROW_TX_POWER:
+            _prefs->tx_power_dbm = (uint8_t)constrain(_editInt, 1, MAX_LORA_TX_POWER);
+            _radioChanged = true;
+            break;
+          case ROW_UTC_OFFSET:
+            _prefs->utc_offset_hours = (int8_t)constrain(_editInt, -12, 14);
+            the_mesh.savePrefs();
+            break;
+          default: break;
+        }
+        _editMode = EDIT_NONE;
+        return true;
+      }
+      if (c == 'q' || c == 'Q') {
+        _editMode = EDIT_NONE;
+        return true;
+      }
+      return true;
+    }
+
+    // --- Normal browsing mode ---
+
+    // W/S: navigate
+    if (c == 'w' || c == 'W') {
+      if (_cursor > 0) {
+        _cursor--;
+        skipNonSelectable(-1);
+      }
+      Serial.printf("Settings: cursor=%d/%d row=%d\n", _cursor, _numRows, _rows[_cursor].type);
+      return true;
+    }
+    if (c == 's' || c == 'S') {
+      if (_cursor < _numRows - 1) {
+        _cursor++;
+        skipNonSelectable(1);
+      }
+      Serial.printf("Settings: cursor=%d/%d row=%d\n", _cursor, _numRows, _rows[_cursor].type);
+      return true;
+    }
+
+    // Enter: start editing the selected row
+    if (c == '\r' || c == 13) {
+      SettingsRowType type = _rows[_cursor].type;
+      switch (type) {
+        case ROW_NAME:
+          startEditText(_prefs->node_name);
+          break;
+        case ROW_RADIO_PRESET:
+          startEditPicker(max(0, detectCurrentPreset()));
+          break;
+        case ROW_FREQ:
+          startEditFloat(_prefs->freq);
+          break;
+        case ROW_BW:
+          startEditFloat(_prefs->bw);
+          break;
+        case ROW_SF:
+          startEditInt(_prefs->sf);
+          break;
+        case ROW_CR:
+          startEditInt(_prefs->cr);
+          break;
+        case ROW_TX_POWER:
+          startEditInt(_prefs->tx_power_dbm);
+          break;
+        case ROW_UTC_OFFSET:
+          startEditInt(_prefs->utc_offset_hours);
+          break;
+        case ROW_ADD_CHANNEL:
+          startEditText("");
+          break;
+        case ROW_CHANNEL:
+        case ROW_PUB_KEY:
+        case ROW_FIRMWARE:
+          // Not directly editable on Enter
+          break;
+        default:
+          break;
+      }
+      return true;
+    }
+
+    // X: delete channel (when on a channel row, idx > 0)
+    if (c == 'x' || c == 'X') {
+      if (_rows[_cursor].type == ROW_CHANNEL && _rows[_cursor].param > 0) {
+        _editMode = EDIT_CONFIRM;
+        _confirmAction = 1;
+        return true;
+      }
+    }
+
+    // Q: back — if radio changed, prompt to apply first
+    if (c == 'q' || c == 'Q') {
+      if (_radioChanged) {
+        _editMode = EDIT_CONFIRM;
+        _confirmAction = 2;
+        return true;
+      }
+      _onboarding = false;
+      return false;  // Let the caller handle navigation back
+    }
+
+    return true;  // Consume all other keys (don't let caller exit)
+  }
+
+  // Override handleInput for UIScreen compatibility (used by injectKey)
+  bool handleInput(char c) override {
+    return handleKeyInput(c);
+  }
+};
--- 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
@@ -31,6 +31,9 @@

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

 class SplashScreen : public UIScreen {
  UITask* _task;
@@ -100,15 +103,15 @@ 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) {
-    // Try to get accurate SOC from BQ27220 fuel gauge first
-    uint8_t batteryPercentage = board.getBatteryPercent();
-
-    // Fall back to voltage-based estimation if fuel gauge returns 0
-    if (batteryPercentage == 0 && batteryMilliVolts > 0) {
+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);
@@ -183,7 +186,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
@@ -204,6 +215,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);
@@ -331,6 +365,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) {
@@ -414,10 +484,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;
@@ -451,6 +555,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) {
@@ -606,12 +715,16 @@ void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* no
  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);
+  settings_screen = new SettingsScreen(this, &rtc_clock, node_prefs);
  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) {
@@ -983,10 +1096,34 @@ void UITask::injectKey(char c) {
    }
    curr->handleInput(c);
    _auto_off = millis() + AUTO_OFF_MILLIS;   // extend auto-off timer
-    _next_refresh = 100;  // trigger refresh
+    // 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);
@@ -997,6 +1134,49 @@ void UITask::gotoChannelScreen() {
  _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;
+}
+
+void UITask::gotoSettingsScreen() {
+  ((SettingsScreen*)settings_screen)->enter();
+  setCurrScreen(settings_screen);
+  if (_display != NULL && !_display->isOn()) {
+    _display->turnOn();
+  }
+  _auto_off = millis() + AUTO_OFF_MILLIS;
+  _next_refresh = 100;
+}
+
+void UITask::gotoOnboarding() {
+  ((SettingsScreen*)settings_screen)->enterOnboarding();
+  setCurrScreen(settings_screen);
+  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();
 }
--- a/examples/companion_radio/ui-new/UITask.h
+++ b/examples/companion_radio/ui-new/UITask.h
@@ -52,6 +52,9 @@ class UITask : public AbstractUITask {
  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* settings_screen; // Settings/onboarding screen
  UIScreen* curr;

  void userLedHandler();
@@ -73,28 +76,43 @@ public:
  }
  void begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* node_prefs);

-  void gotoHomeScreen() { setCurrScreen(home); }
+  void gotoHomeScreen();
  void gotoChannelScreen();  // Navigate to channel message screen
-  void showAlert(const char* text, int duration_millis);
+  void gotoContactsScreen(); // Navigate to contacts list
+  void gotoTextReader();     // *** NEW: Navigate to text reader ***
+  void gotoSettingsScreen(); // Navigate to settings
+  void gotoOnboarding();     // Navigate to settings in onboarding mode
+  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 isOnSettingsScreen() const { return curr == settings_screen; }
  uint8_t getChannelScreenViewIdx() const;

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

+  // Check if home screen is in an editing mode (e.g. UTC offset editor)
+  bool isEditingHomeScreen() const;
+
  // 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);
+  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; }
+  UIScreen* getChannelScreen() const { return channel_screen; }
+  UIScreen* getSettingsScreen() const { return settings_screen; }

  // from AbstractUITask
  void msgRead(int msgcount) override;
--- 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/companion_radio/ui-orig/UITask.cpp
+++ b/examples/companion_radio/ui-orig/UITask.cpp
--- a/examples/simple_repeater/MyMesh.cpp
+++ b/examples/simple_repeater/MyMesh.cpp
--- 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/Tca8418keyboard.h
+++ b/variants/lilygo_tdeck_pro/Tca8418keyboard.h
@@ -21,6 +21,7 @@
 #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:
@@ -226,9 +227,15 @@ public:
    }
    
    // Handle dedicated $ key (key code 22, next to M)
+    // Bare press = emoji picker, Sym+$ = literal '$'
    if (keyCode == 22) {
-      Serial.println("KB: $ key pressed");
-      return '$';
+      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
--- a/variants/lilygo_tdeck_pro/target.cpp
+++ b/variants/lilygo_tdeck_pro/target.cpp
@@ -46,11 +46,20 @@ bool radio_init() {
  loraSpi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI, P_LORA_NSS);
  MESH_DEBUG_PRINTLN("radio_init() - SPI initialized, calling radio.std_init()...");
  bool result = radio.std_init(&loraSpi);
+  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
  MESH_DEBUG_PRINTLN("radio_init() - calling radio.std_init() without custom SPI...");
-  return radio.std_init();
+  bool result = radio.std_init();
+  if (result) {
+    radio.setPreambleLength(32);
+    MESH_DEBUG_PRINTLN("radio_init() - preamble set to 32 symbols");
+  }
+  return result;
 #endif
 }

@@ -72,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	a23b65730a	Merge branch 'main' of https://github.com/pelgraine/Meck	2026-02-10 20:51:11 +11:00
pelgraine	569794d2fe	updated readme with new changes and quicklinks	2026-02-10 20:49:35 +11:00
pelgraine	ea1ca315b8	Update key mapping for opening text reader	2026-02-10 20:45:19 +11:00
pelgraine	83b3ea6275	increase on-device message history buffer from 20 to 300 messages	2026-02-10 20:33:50 +11:00
pelgraine	9c6d5138b0	fixed domino emoji sprite utf codepoint	2026-02-10 20:27:20 +11:00
pelgraine	15165bb429	New settings screen and key remapping for menu screens	2026-02-10 20:18:13 +11:00
pelgraine	c4b9952d95	updated contacts all view to display max contacts etc	2026-02-10 19:06:37 +11:00
pelgraine	ce37bf6b90	settings persistance backup to sd after saveprefs	2026-02-10 19:02:58 +11:00
pelgraine	8e98132506	Channel message view retains history after reboot	2026-02-10 18:56:53 +11:00
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