updated readme to accommodate the several new changes in v0.9.5

README.md

@@ -14,6 +14,8 @@ This fork was created specifically to focus on enabling BLE companion firmware f
   - [Compose Mode](#compose-mode)
   - [Symbol Entry (Sym Key)](#symbol-entry-sym-key)
   - [Emoji Picker](#emoji-picker)
+  - [SMS & Phone App (4G only)](#sms--phone-app-4g-only)
+  - [Web Browser & IRC](#web-browser--irc)
 - [About MeshCore](#about-meshcore)
 - [What is MeshCore?](#what-is-meshcore)
 - [Key Features](#key-features)
@@ -42,7 +44,11 @@ The T-Deck Pro BLE companion firmware includes full keyboard support for standal
 | M | Open channel messages |
 | C | Open contacts list |
 | E | Open e-book reader |
+| N | Open notes |
 | S | Open settings |
+| B | Open web browser (BLE and 4G variants only) |
+| T | Open SMS & Phone app (4G variant only) |
+| P | Open audiobook player (audio variant only) |
 | Q | Back to home screen |
 
 ### Bluetooth (BLE)
@@ -80,6 +86,8 @@ The GPS page also shows the current time, satellite count, position, altitude, a
 | W / S | Scroll messages up/down |
 | A / D | Switch between channels |
 | Enter | Compose new message |
+| R | Reply to a message — enter reply select mode, scroll to a message with W/S, then press Enter to compose a reply with an @mention |
+| V | View relay path of the last received message (scrollable, up to 20 hops) |
 | Q | Back to home screen |
 
 ### Contacts Screen
@@ -89,10 +97,14 @@ Press **C** from the home screen to open the contacts list. All known mesh conta
 | Key | Action |
 |-----|--------|
 | W / S | Scroll up / down through contacts |
-| A / D | Cycle filter: All → Chat → Repeater → Room → Sensor |
+| A / D | Cycle filter: All → Chat → Repeater → Room → Sensor → Favourites |
 | Enter | Open DM compose (Chat contact) or repeater admin (Repeater contact) |
+| X | Export contacts to SD card (wait 5–10 seconds for confirmation popup) |
+| R | Import contacts from SD card (wait 5–10 seconds for confirmation popup) |
 | Q | Back to home screen |
 
+**Contact limits:** Standalone variants support up to 1,500 contacts (stored in PSRAM). BLE variants (both Audio-BLE and 4G-BLE) are limited to 500 contacts due to BLE protocol constraints.
+
 ### Sending a Direct Message
 
 Select a **Chat** contact in the contacts list and press **Enter** to start composing a direct message. The compose screen will show `DM: ContactName` in the header. Type your message and press **Enter** to send. The DM is sent encrypted directly to that contact (or flooded if no direct path is known). After sending or cancelling, you're returned to the contacts list.
@@ -145,6 +157,8 @@ Press **S** from the home screen to open settings. On first boot (when the devic
 | Channels | View existing channels, add hashtag channels, or delete non-primary channels (X) |
 | Device Info | Public key and firmware version (read-only) |
 
+The bottom of the settings screen also displays your node ID and firmware version. On the 4G variant, IMEI, carrier name, and APN details are shown here as well.
+
 When adding a hashtag channel, type the channel name and press Enter. The channel secret is automatically derived from the name via SHA-256, matching the standard MeshCore hashtag convention.
 
 If you've changed radio parameters, pressing Q will prompt you to apply changes before exiting.
@@ -194,6 +208,22 @@ While in compose mode, press the **$** key to open the emoji picker. A scrollabl
 | Enter | Insert selected emoji |
 | $ / Q / Backspace | Cancel and return to compose |
 
+### SMS & Phone App (4G only)
+
+Press **T** from the home screen to open the SMS & Phone app. The app opens to a menu screen where you can choose between the **Phone** dialer (for calling any number) or the **SMS Inbox** (for messaging and calling saved contacts).
+
+For full documentation including key mappings, dialpad usage, contacts management, and troubleshooting, see the [SMS & Phone App Guide](SMS%20%26%20Phone%20App%20Guide.md).
+
+### Web Browser & IRC
+
+Press **B** from the home screen to open the web reader. This is available on the BLE and 4G variants (not the standalone audio variant, which excludes WiFi to preserve lowest-battery-usage design).
+
+The web reader home screen provides access to the **IRC client**, the **URL bar**, and your **bookmarks** and **history**. Select IRC Chat and press Enter to configure and connect to an IRC server. Select the URL bar to enter a web address, or scroll down to open a bookmark or history entry.
+
+The browser is a text-centric reader best suited to text-heavy websites. It also includes basic web search via DuckDuckGo Lite, and can download EPUB files — follow a link to an `.epub` and it will be saved to the books folder on your SD card for reading later in the e-book reader.
+
+For full documentation including key mappings, WiFi setup, bookmarks, IRC configuration, and SD card structure, see the [Web App Guide](Web%20App%20Guide.md).
+
 ## About MeshCore
 
 MeshCore is a lightweight, portable C++ library that enables multi-hop packet routing for embedded projects using LoRa and other packet radios. It is designed for developers who want to create resilient, decentralized communication networks that work without the internet.
@@ -285,12 +315,13 @@ There are a number of fairly major features in the pipeline, with no particular
 - [X] Standalone repeater admin access for Companion BLE firmware
 - [X] GPS time sync with on-device timezone setting
 - [X] Settings screen with radio presets, channel management, and first-boot onboarding
+- [X] Expand SMS app to enable phone calls
+- [X] Basic web reader app for text-centric websites
 - [ ] Fix M4B rendering to enable chaptered audiobook playback
-- [ ] Expand SMS app to enable phone calls
 - [ ] Better JPEG and PNG decoding
 - [ ] Improve EPUB rendering and EPUB format handling
 - [ ] Map support with GPS
-- [ ] Basic web reader app for text-centric websites
+- [ ] WiFi companion environment
 
 ## 📞 Get Support
 

examples/companion_radio/MyMesh.cpp

@@ -1043,6 +1043,7 @@ void MyMesh::begin(bool has_display) {
   _active_ble_pin = 0;
 #endif
 
+  initContacts();    // allocate contacts array from PSRAM (deferred from constructor)
   resetContacts();
   _store->loadContacts(this);
   bootstrapRTCfromContacts();

examples/companion_radio/MyMesh.h

@@ -8,11 +8,11 @@
 #define FIRMWARE_VER_CODE 8
 
 #ifndef FIRMWARE_BUILD_DATE
-#define FIRMWARE_BUILD_DATE "24 Feb 2026"
+#define FIRMWARE_BUILD_DATE "27 Feb 2026"
 #endif
 
 #ifndef FIRMWARE_VERSION
-#define FIRMWARE_VERSION "Meck v0.9.3"
+#define FIRMWARE_VERSION "Meck v0.9.5"
 #endif
 
 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)

examples/companion_radio/main.cpp

@@ -33,6 +33,11 @@
   static bool composeNeedsRefresh = false;
   #define COMPOSE_REFRESH_INTERVAL 100  // ms before starting e-ink refresh after keypress (refresh itself takes ~644ms)
 
+  // Phone dialer debounce — independent from compose/smsSuppressLoop to avoid
+  // interfering with call view rendering and alert display
+  static bool dialerNeedsRefresh = false;
+  static unsigned long lastDialerRefresh = 0;
+
   // DM compose mode (direct message to a specific contact)
   static bool composeDM = false;
   static int composeDMContactIdx = -1;
@@ -77,6 +82,12 @@
     static bool smsMode = false;
   #endif
 
+  // Touch input (for phone dialer numpad)
+  #ifdef HAS_TOUCHSCREEN
+    #include "TouchInput.h"
+    TouchInput touchInput(&Wire);
+  #endif
+
   // Power management
   #if HAS_GPS
     GPSDutyCycle gpsDuty;
@@ -187,6 +198,135 @@
     digitalWrite(SDCARD_CS, HIGH);
     return restored;
   }
+
+  // -----------------------------------------------------------------------
+  // On-demand export: save current contacts to SD card.
+  // Writes binary backup + human-readable listing.
+  // Returns number of contacts exported, or -1 on error.
+  // -----------------------------------------------------------------------
+  int exportContactsToSD() {
+    if (!sdCardReady) return -1;
+
+    // Ensure in-memory contacts are flushed to SPIFFS first
+    the_mesh.saveContacts();
+
+    if (!SD.exists("/meshcore")) SD.mkdir("/meshcore");
+
+    // 1) Binary backup: SPIFFS /contacts3 → SD /meshcore/contacts.bin
+    if (!SPIFFS.exists("/contacts3")) return -1;
+    if (!copyFile(SPIFFS, "/contacts3", SD, "/meshcore/contacts.bin")) return -1;
+
+    // 2) Human-readable listing for inspection on a computer
+    int count = 0;
+    File txt = SD.open("/meshcore/contacts_export.txt", "w", true);
+    if (txt) {
+      txt.printf("Meck Contacts Export  (%d total)\n", (int)the_mesh.getNumContacts());
+      txt.printf("========================================\n");
+      txt.printf("%-5s  %-30s  %s\n", "Type", "Name", "PubKey (prefix)");
+      txt.printf("----------------------------------------\n");
+
+      ContactInfo c;
+      for (uint32_t i = 0; i < (uint32_t)the_mesh.getNumContacts(); i++) {
+        if (the_mesh.getContactByIdx(i, c)) {
+          const char* typeStr = "???";
+          switch (c.type) {
+            case ADV_TYPE_CHAT:     typeStr = "Chat"; break;
+            case ADV_TYPE_REPEATER: typeStr = "Rptr"; break;
+            case ADV_TYPE_ROOM:     typeStr = "Room"; break;
+          }
+          // First 8 bytes of pub key as hex identifier
+          char hexBuf[20];
+          mesh::Utils::toHex(hexBuf, c.id.pub_key, 8);
+          txt.printf("%-5s  %-30s  %s\n", typeStr, c.name, hexBuf);
+          count++;
+        }
+      }
+
+      txt.printf("========================================\n");
+      txt.printf("Total: %d contacts\n", count);
+      txt.close();
+    }
+
+    digitalWrite(SDCARD_CS, HIGH);
+    Serial.printf("Contacts exported to SD: %d contacts\n", count);
+    return count;
+  }
+
+  // -----------------------------------------------------------------------
+  // On-demand import: merge contacts from SD backup into live table.
+  //
+  // Reads /meshcore/contacts.bin from SD and for each contact:
+  //   - If already in memory (matching pub_key) → skip (keep current)
+  //   - If NOT in memory → addContact (append to table)
+  //
+  // This is a non-destructive merge: you never lose contacts already in
+  // memory, and you gain any that were only in the backup.
+  //
+  // After merging, saves the combined set back to SPIFFS so it persists.
+  // Returns number of NEW contacts added, or -1 on error.
+  // -----------------------------------------------------------------------
+  int importContactsFromSD() {
+    if (!sdCardReady) return -1;
+    if (!SD.exists("/meshcore/contacts.bin")) return -1;
+
+    File file = SD.open("/meshcore/contacts.bin", "r");
+    if (!file) return -1;
+
+    int added = 0;
+    int skipped = 0;
+
+    while (true) {
+      ContactInfo c;
+      uint8_t pub_key[32];
+      uint8_t unused;
+
+      // Parse one contact record (same binary format as DataStore::loadContacts)
+      bool success = (file.read(pub_key, 32) == 32);
+      success = success && (file.read((uint8_t *)&c.name, 32) == 32);
+      success = success && (file.read(&c.type, 1) == 1);
+      success = success && (file.read(&c.flags, 1) == 1);
+      success = success && (file.read(&unused, 1) == 1);
+      success = success && (file.read((uint8_t *)&c.sync_since, 4) == 4);
+      success = success && (file.read((uint8_t *)&c.out_path_len, 1) == 1);
+      success = success && (file.read((uint8_t *)&c.last_advert_timestamp, 4) == 4);
+      success = success && (file.read(c.out_path, 64) == 64);
+      success = success && (file.read((uint8_t *)&c.lastmod, 4) == 4);
+      success = success && (file.read((uint8_t *)&c.gps_lat, 4) == 4);
+      success = success && (file.read((uint8_t *)&c.gps_lon, 4) == 4);
+
+      if (!success) break;  // EOF or read error
+
+      c.id = mesh::Identity(pub_key);
+      c.shared_secret_valid = false;
+
+      // Check if this contact already exists in the live table
+      if (the_mesh.lookupContactByPubKey(pub_key, PUB_KEY_SIZE) != NULL) {
+        skipped++;
+        continue;  // Already have this contact, skip
+      }
+
+      // New contact — add to the live table
+      if (the_mesh.addContact(c)) {
+        added++;
+      } else {
+        // Table is full, stop importing
+        Serial.printf("Import: table full after adding %d contacts\n", added);
+        break;
+      }
+    }
+
+    file.close();
+    digitalWrite(SDCARD_CS, HIGH);
+
+    // Persist the merged set to SPIFFS
+    if (added > 0) {
+      the_mesh.saveContacts();
+    }
+
+    Serial.printf("Contacts import: %d added, %d already present, %d total\n",
+                  added, skipped, (int)the_mesh.getNumContacts());
+    return added;
+  }
 #endif
 
 // Believe it or not, this std C function is busted on some platforms!
@@ -548,6 +688,15 @@ void setup() {
     initKeyboard();
   #endif
 
+  // Initialize touch input (CST328)
+  #ifdef HAS_TOUCHSCREEN
+    if (touchInput.begin(CST328_PIN_INT)) {
+      MESH_DEBUG_PRINTLN("setup() - Touch input initialized");
+    } else {
+      MESH_DEBUG_PRINTLN("setup() - Touch input FAILED");
+    }
+  #endif
+
   // ---------------------------------------------------------------------------
   // SD card is already initialized (early init above).
   // Now set up SD-dependent features: message history + text reader.
@@ -743,6 +892,19 @@ void loop() {
       } else if (callEvt.type == CallEventType::ENDED) {
         Serial.printf("[Call] Ended (%lus) with %s\n",
                       (unsigned long)callEvt.duration, callEvt.phone);
+        // Show alert with duration (supplements the immediate alert from Q hangup;
+        // this catches remote hangups and network drops)
+        {
+          char alertBuf[48];
+          if (callEvt.duration > 0) {
+            snprintf(alertBuf, sizeof(alertBuf), "Call Ended  %lu:%02lu",
+                     (unsigned long)(callEvt.duration / 60),
+                     (unsigned long)(callEvt.duration % 60));
+          } else {
+            snprintf(alertBuf, sizeof(alertBuf), "Call Ended");
+          }
+          ui_task.showAlert(alertBuf, 2000);
+        }
         ui_task.forceRefresh();
       } else if (callEvt.type == CallEventType::MISSED) {
         char alertBuf[48];
@@ -787,7 +949,7 @@ void loop() {
     webReaderNeedsRefresh = false;
   }
   #endif
-  if (!composeMode && !notesSuppressLoop && !smsSuppressLoop
+  if (!composeMode && !notesSuppressLoop && !smsSuppressLoop && !dialerNeedsRefresh
   #ifdef MECK_WEB_READER
       && !webReaderTextEntry
   #endif
@@ -817,6 +979,21 @@ void loop() {
       lastComposeRefresh = millis();
       composeNeedsRefresh = false;
     }
+    // Phone dialer debounced render (separate from compose debounce)
+    #ifdef HAS_4G_MODEM
+    if (dialerNeedsRefresh && (millis() - lastDialerRefresh) >= COMPOSE_REFRESH_INTERVAL) {
+      if (smsMode) {
+        SMSScreen* dialScr = (SMSScreen*)ui_task.getSMSScreen();
+        if (dialScr && dialScr->getSubView() == SMSScreen::PHONE_DIALER) {
+          display.startFrame();
+          dialScr->render(display);
+          display.endFrame();
+        }
+      }
+      dialerNeedsRefresh = false;
+      lastDialerRefresh = millis();
+    }
+    #endif
     #ifdef MECK_WEB_READER
     if (webReaderNeedsRefresh && (millis() - lastWebReaderRefresh) >= COMPOSE_REFRESH_INTERVAL) {
       WebReaderScreen* wr2 = (WebReaderScreen*)ui_task.getWebReaderScreen();
@@ -861,6 +1038,44 @@ void loop() {
   #if defined(LilyGo_TDeck_Pro)
     handleKeyboardInput();
   #endif
+
+  // Poll touch input for phone dialer numpad
+  // Hybrid debounce: finger-up detection + 150ms minimum between accepted taps.
+  // The CST328 INT pin is pulse-based (not level), so getPoint() can return
+  // false intermittently during a hold. Time guard prevents that from
+  // causing repeat fires.
+  #if defined(HAS_TOUCHSCREEN) && defined(HAS_4G_MODEM)
+  {
+    static bool touchFingerDown = false;
+    static unsigned long lastTouchAccepted = 0;
+
+    if (smsMode) {
+      SMSScreen* smsScr = (SMSScreen*)ui_task.getSMSScreen();
+      if (smsScr && smsScr->getSubView() == SMSScreen::PHONE_DIALER) {
+        int16_t tx, ty;
+        if (touchInput.getPoint(tx, ty)) {
+          unsigned long now = millis();
+          if (!touchFingerDown && (now - lastTouchAccepted >= 150)) {
+            touchFingerDown = true;
+            lastTouchAccepted = now;
+            if (smsScr->handleTouch(tx, ty)) {
+              dialerNeedsRefresh = true;
+              lastDialerRefresh = millis();
+            }
+          }
+        } else {
+          // Only allow finger-up after 100ms from last acceptance
+          // (prevents INT pulse misses from resetting state mid-hold)
+          if (touchFingerDown && (millis() - lastTouchAccepted >= 100)) {
+            touchFingerDown = false;
+          }
+        }
+      } else {
+        touchFingerDown = false;
+      }
+    }
+  }
+  #endif
 }
 
 // ============================================================================
@@ -1307,21 +1522,46 @@ void handleKeyboardInput() {
   if (smsMode) {
     SMSScreen* smsScr = (SMSScreen*)ui_task.getSMSScreen();
     if (smsScr) {
-      // During active call views, route all keys directly to the screen
-      // and force a refresh after each keypress (no debounce needed)
+      // Keep display alive — SMS routes many keys via handleInput() directly,
+      // bypassing injectKey() which normally extends the auto-off timer.
+      ui_task.keepAlive();
       if (smsScr->isInCallView()) {
         smsScr->handleInput(key);
+        if (!smsScr->isInCallView()) {
+          // Hangup just happened — show "Call Ended" alert immediately
+          ui_task.showAlert("Call Ended", 2000);
+        }
+        // Force immediate render (call screen updates or return-to-dialer)
         ui_task.forceRefresh();
+        ui_task.loop();
         return;
       }
 
-      // Q from inbox → go home; Q from inner views is handled by SMSScreen
-      if ((key == 'q' || key == '\b') && smsScr->getSubView() == SMSScreen::INBOX) {
+      // Q from app menu → go home; Q from inner views is handled by SMSScreen
+      if ((key == 'q' || key == '\b') && smsScr->getSubView() == SMSScreen::APP_MENU) {
         Serial.println("Nav: SMS -> Home");
         ui_task.gotoHomeScreen();
         return;
       }
 
+      // Phone dialer: debounced refresh for digit entry, immediate render for
+      // view transitions (Enter=call, Q=back). This avoids the 686ms e-ink
+      // block per keypress while ensuring call/back screens render instantly.
+      if (smsScr->getSubView() == SMSScreen::PHONE_DIALER) {
+        smsScr->handleInput(key);
+        if (smsScr->getSubView() == SMSScreen::PHONE_DIALER) {
+          // Still on dialer (digit/backspace) — debounced refresh
+          dialerNeedsRefresh = true;
+          lastDialerRefresh = millis();
+        } else {
+          // View changed (startCall or Q back) — render immediately
+          dialerNeedsRefresh = false;
+          ui_task.forceRefresh();
+          ui_task.loop();
+        }
+        return;
+      }
+
       if (smsScr->isComposing()) {
         // Composing/text input: route directly to screen, bypass injectKey()
         // to avoid UITask scheduling its own competing refresh
@@ -1354,12 +1594,13 @@ void handleKeyboardInput() {
     bool urlEdit = wr ? wr->isUrlEditing() : false;
     bool passEdit = wr ? wr->isPasswordEntry() : false;
     bool formEdit = wr ? wr->isFormFilling() : false;
-    if (wr && (urlEdit || passEdit || formEdit)) {
+    bool searchEdit = wr ? wr->isSearchEditing() : false;
+    if (wr && (urlEdit || passEdit || formEdit || searchEdit)) {
       webReaderTextEntry = true;  // Suppress ui_task.loop() in main loop
       wr->handleInput(key);       // Updates buffer instantly, no render
       
       // Check if text entry ended (submitted, cancelled, etc.)
-      if (!wr->isUrlEditing() && !wr->isPasswordEntry() && !wr->isFormFilling()) {
+      if (!wr->isUrlEditing() && !wr->isPasswordEntry() && !wr->isFormFilling() && !wr->isSearchEditing()) {
         // Text entry ended
         webReaderTextEntry = false;
         webReaderNeedsRefresh = false;
@@ -1376,7 +1617,7 @@ void handleKeyboardInput() {
       webReaderTextEntry = false;
 
       // Q from HOME mode exits the web reader entirely (like text reader)
-      if ((key == 'q' || key == 'Q') && wr && wr->isHome() && !wr->isUrlEditing()) {
+      if ((key == 'q' || key == 'Q') && wr && wr->isHome() && !wr->isUrlEditing() && !wr->isSearchEditing()) {
         Serial.println("Exiting web reader");
         ui_task.gotoHomeScreen();
         return;
@@ -1568,18 +1809,51 @@ void handleKeyboardInput() {
           Serial.printf("Selected contact type=%d idx=%d\n", ctype, idx);
         }
       } else if (ui_task.isOnChannelScreen()) {
-        // Don't enter compose if path overlay is showing
+        // If path overlay is showing, Enter copies path text to compose buffer
         ChannelScreen* chScr2 = (ChannelScreen*)ui_task.getChannelScreen();
         if (chScr2 && chScr2->isShowingPathOverlay()) {
+          char pathText[138];
+          int pathLen = chScr2->formatPathAsText(pathText, sizeof(pathText));
+          if (pathLen > 0) {
+            int copyLen = pathLen < 137 ? pathLen : 137;
+            memcpy(composeBuffer, pathText, copyLen);
+            composeBuffer[copyLen] = '\0';
+            composePos = copyLen;
+          } else {
+            composeBuffer[0] = '\0';
+            composePos = 0;
+          }
+          composeDM = false;
+          composeDMContactIdx = -1;
+          composeChannelIdx = ui_task.getChannelScreenViewIdx();
+          composeMode = true;
+          chScr2->dismissPathOverlay();
+          Serial.printf("Compose with path, channel %d, prefill %d chars\n", composeChannelIdx, composePos);
+          drawComposeScreen();
+          lastComposeRefresh = millis();
           break;
         }
         composeDM = false;
         composeDMContactIdx = -1;
         composeChannelIdx = ui_task.getChannelScreenViewIdx();
         composeMode = true;
-        composeBuffer[0] = '\0';
-        composePos = 0;
-        Serial.printf("Entering compose mode, channel %d\n", composeChannelIdx);
+
+        // If reply select mode is active, pre-fill @SenderName
+        char replySender[32];
+        if (chScr2 && chScr2->isReplySelectMode()
+            && chScr2->getReplySelectSender(replySender, sizeof(replySender))) {
+          int prefixLen = snprintf(composeBuffer, sizeof(composeBuffer),
+                                   "@%s ", replySender);
+          composePos = prefixLen;
+          chScr2->exitReplySelect();
+          Serial.printf("Reply compose to @%s, channel %d\n",
+                        replySender, composeChannelIdx);
+        } else {
+          composeBuffer[0] = '\0';
+          composePos = 0;
+          if (chScr2) chScr2->exitReplySelect();  // Clean up if somehow active
+          Serial.printf("Entering compose mode, channel %d\n", composeChannelIdx);
+        }
         drawComposeScreen();
         lastComposeRefresh = millis();
       } else {
@@ -1588,11 +1862,53 @@ void handleKeyboardInput() {
       }
       break;
       
+    case 'x':
+      // Export contacts to SD card (contacts screen only)
+      if (ui_task.isOnContactsScreen()) {
+        Serial.println("Contacts: Exporting to SD...");
+        int exported = exportContactsToSD();
+        if (exported >= 0) {
+          char alertBuf[48];
+          snprintf(alertBuf, sizeof(alertBuf), "Exported %d to SD", exported);
+          ui_task.showAlert(alertBuf, 2000);
+        } else {
+          ui_task.showAlert("Export failed (no SD?)", 2000);
+        }
+      }
+      break;
+
+    case 'r':
+      // Reply select mode (channel screen) or import contacts (contacts screen)
+      if (ui_task.isOnChannelScreen()) {
+        ui_task.injectKey('r');
+      } else if (ui_task.isOnContactsScreen()) {
+        Serial.println("Contacts: Importing from SD...");
+        int added = importContactsFromSD();
+        if (added > 0) {
+          // Invalidate the contacts screen cache so it rebuilds
+          ContactsScreen* cs2 = (ContactsScreen*)ui_task.getContactsScreen();
+          if (cs2) cs2->invalidateCache();
+          char alertBuf[48];
+          snprintf(alertBuf, sizeof(alertBuf), "+%d imported (%d total)",
+                   added, (int)the_mesh.getNumContacts());
+          ui_task.showAlert(alertBuf, 2500);
+        } else if (added == 0) {
+          ui_task.showAlert("No new contacts to add", 2000);
+        } else {
+          ui_task.showAlert("Import failed (no backup?)", 2000);
+        }
+      }
+      break;
+
     case 'q':
     case '\b':
-      // If channel screen path overlay is showing, dismiss it instead of going home
+      // If channel screen reply select or path overlay is showing, dismiss it
       if (ui_task.isOnChannelScreen()) {
         ChannelScreen* chScr = (ChannelScreen*)ui_task.getChannelScreen();
+        if (chScr && chScr->isReplySelectMode()) {
+          ui_task.injectKey('q');
+          break;
+        }
         if (chScr && chScr->isShowingPathOverlay()) {
           ui_task.injectKey('q');
           break;

examples/companion_radio/ui-new/ApnDatabase.h

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

examples/companion_radio/ui-new/ChannelScreen.h

@@ -24,7 +24,7 @@
 // On-disk format for message persistence (SD card)
 // ---------------------------------------------------------------------------
 #define MSG_FILE_MAGIC   0x4D434853  // "MCHS" - MeshCore History Store
-#define MSG_FILE_VERSION 3
+#define MSG_FILE_VERSION 3           // v3: MSG_PATH_MAX increased to 20
 #define MSG_FILE_PATH    "/meshcore/messages.bin"
 
 struct __attribute__((packed)) MsgFileHeader {
@@ -74,17 +74,31 @@ private:
   uint8_t _viewChannelIdx;  // Which channel we're currently viewing
   bool _sdReady;      // SD card is available for persistence
   bool _showPathOverlay;  // Show path detail overlay for last received msg
-  int _pathOverlayScroll; // Scroll offset for hop list in path overlay
+  int _pathScrollPos;     // Scroll offset within path overlay hop list
+  int _pathHopsVisible;   // Hops that fit on screen (set during render)
+
+  // Reply select mode — press R to pick a message and reply with @mention
+  bool _replySelectMode;       // True when user is picking a message to reply to
+  int  _replySelectPos;        // Index into chronological channelMsgs[] (0=oldest)
+  int  _replyChannelMsgCount;  // Cached count from last render (for input bounds)
+
+  // Per-channel unread message counts (standalone mode)
+  // Index 0..MAX_GROUP_CHANNELS-1 for channel messages
+  // Index MAX_GROUP_CHANNELS for DMs (channel_idx == 0xFF)
+  int _unread[MAX_GROUP_CHANNELS + 1];
   
 public:
   ChannelScreen(UITask* task, mesh::RTCClock* rtc) 
     : _task(task), _rtc(rtc), _msgCount(0), _newestIdx(-1), _scrollPos(0), 
-      _msgsPerPage(6), _viewChannelIdx(0), _sdReady(false), _showPathOverlay(false), _pathOverlayScroll(0) {
+      _msgsPerPage(6), _viewChannelIdx(0), _sdReady(false), _showPathOverlay(false), _pathScrollPos(0), _pathHopsVisible(20),
+      _replySelectMode(false), _replySelectPos(-1), _replyChannelMsgCount(0) {
     // Initialize all messages as invalid
     for (int i = 0; i < CHANNEL_MSG_HISTORY_SIZE; i++) {
       _messages[i].valid = false;
       memset(_messages[i].path, 0, MSG_PATH_MAX);
     }
+    // Initialize unread counts
+    memset(_unread, 0, sizeof(_unread));
   }
 
   void setSDReady(bool ready) { _sdReady = ready; }
@@ -119,7 +133,18 @@ public:
     // Reset scroll to show newest message
     _scrollPos = 0;
     _showPathOverlay = false;  // Dismiss overlay on new message
-    _pathOverlayScroll = 0;
+    _pathScrollPos = 0;
+    _replySelectMode = false;  // Dismiss reply select on new message
+    _replySelectPos = -1;
+
+    // Track unread count for this channel (only for received messages, not sent)
+    // path_len == 0 means locally sent
+    if (path_len != 0) {
+      int unreadSlot = (channel_idx == 0xFF) ? MAX_GROUP_CHANNELS : channel_idx;
+      if (unreadSlot >= 0 && unreadSlot <= MAX_GROUP_CHANNELS) {
+        _unread[unreadSlot]++;
+      }
+    }
 
     // Persist to SD card
     saveToSD();
@@ -139,8 +164,107 @@ public:
   int getMessageCount() const { return _msgCount; }
   
   uint8_t getViewChannelIdx() const { return _viewChannelIdx; }
-  void setViewChannelIdx(uint8_t idx) { _viewChannelIdx = idx; _scrollPos = 0; _showPathOverlay = false; _pathOverlayScroll = 0; }
+  void setViewChannelIdx(uint8_t idx) {
+    _viewChannelIdx = idx;
+    _scrollPos = 0;
+    _showPathOverlay = false;
+    _pathScrollPos = 0;
+    markChannelRead(idx);
+  }
   bool isShowingPathOverlay() const { return _showPathOverlay; }
+  void dismissPathOverlay() { _showPathOverlay = false; _pathScrollPos = 0; }
+
+  // --- Reply select mode (R key → pick a message → Enter to @mention reply) ---
+  bool isReplySelectMode() const { return _replySelectMode; }
+  void exitReplySelect() { _replySelectMode = false; _replySelectPos = -1; }
+
+  // Extract sender name from a "Sender: message" formatted text.
+  // Returns true if a sender was found, fills senderBuf (null-terminated).
+  static bool extractSenderName(const char* msgText, char* senderBuf, int bufLen) {
+    const char* colon = strstr(msgText, ": ");
+    if (!colon || colon == msgText) return false;
+    int nameLen = colon - msgText;
+    if (nameLen >= bufLen) nameLen = bufLen - 1;
+    memcpy(senderBuf, msgText, nameLen);
+    senderBuf[nameLen] = '\0';
+    return true;
+  }
+
+  // Get the sender name of the currently selected message in reply select mode.
+  // Returns true and fills senderBuf if valid selection exists.
+  bool getReplySelectSender(char* senderBuf, int bufLen) {
+    if (!_replySelectMode || _replySelectPos < 0) return false;
+
+    // Rebuild the channel message list (same logic as render)
+    static int rsMsgs[CHANNEL_MSG_HISTORY_SIZE];
+    int count = 0;
+    for (int i = 0; i < _msgCount && count < CHANNEL_MSG_HISTORY_SIZE; i++) {
+      int idx = _newestIdx - i;
+      while (idx < 0) idx += CHANNEL_MSG_HISTORY_SIZE;
+      idx = idx % CHANNEL_MSG_HISTORY_SIZE;
+      if (_messages[idx].valid && _messages[idx].channel_idx == _viewChannelIdx) {
+        rsMsgs[count++] = idx;
+      }
+    }
+    // Reverse to chronological (oldest first)
+    for (int l = 0, r = count - 1; l < r; l++, r--) {
+      int t = rsMsgs[l]; rsMsgs[l] = rsMsgs[r]; rsMsgs[r] = t;
+    }
+
+    if (_replySelectPos >= count) return false;
+    int idx = rsMsgs[_replySelectPos];
+    return extractSenderName(_messages[idx].text, senderBuf, bufLen);
+  }
+
+  // Get the ChannelMessage pointer for the currently selected reply message.
+  ChannelMessage* getReplySelectMsg() {
+    if (!_replySelectMode || _replySelectPos < 0) return nullptr;
+
+    static int rsMsgs[CHANNEL_MSG_HISTORY_SIZE];
+    int count = 0;
+    for (int i = 0; i < _msgCount && count < CHANNEL_MSG_HISTORY_SIZE; i++) {
+      int idx = _newestIdx - i;
+      while (idx < 0) idx += CHANNEL_MSG_HISTORY_SIZE;
+      idx = idx % CHANNEL_MSG_HISTORY_SIZE;
+      if (_messages[idx].valid && _messages[idx].channel_idx == _viewChannelIdx) {
+        rsMsgs[count++] = idx;
+      }
+    }
+    for (int l = 0, r = count - 1; l < r; l++, r--) {
+      int t = rsMsgs[l]; rsMsgs[l] = rsMsgs[r]; rsMsgs[r] = t;
+    }
+
+    if (_replySelectPos >= count) return nullptr;
+    return &_messages[rsMsgs[_replySelectPos]];
+  }
+
+  // --- Unread message tracking (standalone mode) ---
+
+  // Mark all messages for a channel as read
+  void markChannelRead(uint8_t channel_idx) {
+    int slot = (channel_idx == 0xFF) ? MAX_GROUP_CHANNELS : channel_idx;
+    if (slot >= 0 && slot <= MAX_GROUP_CHANNELS) {
+      _unread[slot] = 0;
+    }
+  }
+
+  // Get unread count for a specific channel
+  int getUnreadForChannel(uint8_t channel_idx) const {
+    int slot = (channel_idx == 0xFF) ? MAX_GROUP_CHANNELS : channel_idx;
+    if (slot >= 0 && slot <= MAX_GROUP_CHANNELS) {
+      return _unread[slot];
+    }
+    return 0;
+  }
+
+  // Get total unread across all channels
+  int getTotalUnread() const {
+    int total = 0;
+    for (int i = 0; i <= MAX_GROUP_CHANNELS; i++) {
+      total += _unread[i];
+    }
+    return total;
+  }
 
   // Find the newest RECEIVED message for the current channel
   // (path_len != 0 means received, path_len 0 = locally sent)
@@ -157,12 +281,30 @@ public:
     return nullptr;
   }
 
+  // Format the path of the newest received message as paste-ready text
+  // Output: comma-separated hex prefixes e.g. "30, 3b, 9b, 05, e8, 36"
+  // Returns length written (0 if no path available)
+  int formatPathAsText(char* buf, int bufLen) {
+    ChannelMessage* msg = getNewestReceivedMsg();
+    if (!msg || msg->path_len == 0 || msg->path_len == 0xFF) return 0;
+    
+    int pos = 0;
+    int plen = msg->path_len < MSG_PATH_MAX ? msg->path_len : MSG_PATH_MAX;
+    
+    for (int h = 0; h < plen && pos < bufLen - 1; h++) {
+      if (h > 0) pos += snprintf(buf + pos, bufLen - pos, ", ");
+      pos += snprintf(buf + pos, bufLen - pos, "%02x", msg->path[h]);
+    }
+    
+    return pos;
+  }
+
   // -----------------------------------------------------------------------
   // SD card persistence
   // -----------------------------------------------------------------------
 
   // Save the entire message buffer to SD card.
-  // File: /meshcore/messages.bin  (~56 KB for 300 messages)
+  // File: /meshcore/messages.bin  (~50 KB for 300 messages)
   void saveToSD() {
 #if defined(HAS_SDCARD) && defined(ESP32)
     if (!_sdReady) return;
@@ -365,29 +507,43 @@ public:
         // Show each hop resolved against contacts (scrollable)
         if (plen > 0 && plen != 0xFF) {
           int displayHops = plen < MSG_PATH_MAX ? plen : MSG_PATH_MAX;
-          int footerHeight = 14;
+          int footerReserve = 26;  // footer + divider
           int scrollBarW = 4;
-          int maxY = display.height() - footerHeight;
+          int maxY = display.height() - footerReserve;
+          int hopAreaTop = y;
           
           // Calculate how many hops fit in the visible area
-          int hopsAreaTop = y;
-          int visibleHops = (maxY - y) / lineH;
-          if (visibleHops < 1) visibleHops = 1;
+          int hopsVisible = (maxY - hopAreaTop) / lineH;
+          if (hopsVisible < 1) hopsVisible = 1;
+          _pathHopsVisible = hopsVisible;  // Cache for input handler
+          bool needsScroll = displayHops > hopsVisible;
           
           // Clamp scroll position
-          int maxScroll = displayHops > visibleHops ? displayHops - visibleHops : 0;
-          if (_pathOverlayScroll > maxScroll) _pathOverlayScroll = maxScroll;
+          int maxScroll = displayHops - hopsVisible;
+          if (maxScroll < 0) maxScroll = 0;
+          if (_pathScrollPos > maxScroll) _pathScrollPos = maxScroll;
           
-          int startHop = _pathOverlayScroll;
+          // Available text width (narrower if scroll bar present)
+          int textRight = needsScroll ? display.width() - scrollBarW - 2 : display.width();
+          (void)textRight;  // reserved for future truncation
           
-          for (int h = startHop; h < displayHops && y + lineH <= maxY; h++) {
+          int startHop = _pathScrollPos;
+          int endHop = startHop + hopsVisible;
+          if (endHop > displayHops) endHop = displayHops;
+          
+          for (int h = startHop; h < endHop && y + lineH <= maxY; h++) {
             uint8_t hopHash = msg->path[h];
             display.setCursor(0, y);
             display.setColor(DisplayDriver::LIGHT);
             sprintf(tmp, " %d: ", h + 1);
             display.print(tmp);
             
-            // Try to resolve: prefer repeaters, then any contact
+            // Always show hex prefix first
+            display.setColor(DisplayDriver::LIGHT);
+            sprintf(tmp, "%02X ", hopHash);
+            display.print(tmp);
+            
+            // Try to resolve name: prefer repeaters, then any contact
             bool resolved = false;
             int numContacts = the_mesh.getNumContacts();
             ContactInfo contact;
@@ -415,29 +571,29 @@ public:
                 }
               }
             }
-            // Fallback: show hex hash
+            // No name resolved - hex prefix already shown, add "?" marker
             if (!resolved) {
               display.setColor(DisplayDriver::LIGHT);
-              sprintf(tmp, "?%02X", hopHash);
-              display.print(tmp);
+              display.print("?");
             }
             y += lineH;
           }
           
-          // --- Scroll bar for hop list ---
-          if (displayHops > visibleHops) {
+          // Scroll bar (right edge) when hops exceed visible area
+          if (needsScroll) {
             int sbX = display.width() - scrollBarW;
-            int sbTop = hopsAreaTop;
-            int sbHeight = maxY - hopsAreaTop;
+            int sbTop = hopAreaTop;
+            int sbHeight = maxY - hopAreaTop;
             
-            // Draw track outline
+            // Outline
             display.setColor(DisplayDriver::LIGHT);
             display.drawRect(sbX, sbTop, scrollBarW, sbHeight);
             
-            // Draw proportional thumb
-            int thumbH = (visibleHops * sbHeight) / displayHops;
+            // Proportional thumb
+            int thumbH = (hopsVisible * sbHeight) / displayHops;
             if (thumbH < 4) thumbH = 4;
-            int thumbY = sbTop + (_pathOverlayScroll * (sbHeight - thumbH)) / maxScroll;
+            int thumbY = sbTop + (_pathScrollPos * (sbHeight - thumbH)) / maxScroll;
+            display.setColor(DisplayDriver::GREEN);
             for (int ty = thumbY + 1; ty < thumbY + thumbH - 1; ty++)
               display.drawRect(sbX + 1, ty, scrollBarW - 2, 1);
           }
@@ -450,7 +606,17 @@ public:
       display.drawRect(0, footerY - 2, display.width(), 1);
       display.setCursor(0, footerY);
       display.setColor(DisplayDriver::YELLOW);
-      display.print("Q:Back W/S:Scroll");
+      display.print("Q:Back");
+      // Show scroll hint if path is scrollable
+      if (msg && msg->path_len > _pathHopsVisible && msg->path_len != 0xFF) {
+        const char* scrollHint = "W/S:Scrl";
+        int scrollW = display.getTextWidth(scrollHint);
+        display.setCursor((display.width() - scrollW) / 2, footerY);
+        display.print(scrollHint);
+      }
+      const char* copyHint = "Ent:Copy";
+      display.setCursor(display.width() - display.getTextWidth(copyHint) - 2, footerY);
+      display.print(copyHint);
 
 #if AUTO_OFF_MILLIS == 0
       return 5000;
@@ -501,6 +667,9 @@ public:
         int tmp = channelMsgs[l]; channelMsgs[l] = channelMsgs[r]; channelMsgs[r] = tmp;
       }
       
+      // Cache for reply select input bounds
+      _replyChannelMsgCount = numChannelMsgs;
+      
       // Clamp scroll position to valid range
       int maxScroll = numChannelMsgs > _msgsPerPage ? numChannelMsgs - _msgsPerPage : 0;
       if (_scrollPos > maxScroll) _scrollPos = maxScroll;
@@ -513,35 +682,66 @@ public:
       // Display messages oldest-to-newest (top to bottom)
       int msgsDrawn = 0;
       bool screenFull = false;
+      bool lastMsgTruncated = false;  // Did the last message get clipped by footer?
       for (int i = startIdx; i < numChannelMsgs && y + lineHeight <= maxY; i++) {
         int idx = channelMsgs[i];
         ChannelMessage* msg = &_messages[idx];
         
+        // Reply select: is this the currently selected message?
+        bool isSelected = (_replySelectMode && i == _replySelectPos);
+        
+        // Highlight: single fillRect for the entire message area, then
+        // draw DARK text on top (same pattern as web reader bookmarks).
+        // Because message height depends on word-wrap, we fill a generous
+        // area up-front and erase the excess after rendering.
+        int yStart = y;
+        int contentW = display.width();
+        int maxLinesPerMsg = 8;
+        if (isSelected) {
+          int maxFillH = (maxLinesPerMsg + 1) * lineHeight + 2;
+          int availH = maxY - y;
+          if (maxFillH > availH) maxFillH = availH;
+          display.setColor(DisplayDriver::LIGHT);
+          display.fillRect(0, y + 5, contentW, maxFillH);
+        }
+        
         // Time indicator with hop count - inline on same line as message start
         display.setCursor(0, y);
-        display.setColor(DisplayDriver::YELLOW);
+        display.setColor(isSelected ? DisplayDriver::DARK : DisplayDriver::YELLOW);
         
         uint32_t age = _rtc->getCurrentTime() - msg->timestamp;
-        if (age < 60) {
-          sprintf(tmp, "(%d) %ds ", msg->path_len == 0xFF ? 0 : msg->path_len, age);
-        } else if (age < 3600) {
-          sprintf(tmp, "(%d) %dm ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 60);
-        } else if (age < 86400) {
-          sprintf(tmp, "(%d) %dh ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 3600);
+        if (isSelected) {
+          // Show > marker for selected message, replacing the hop count
+          if (age < 60) {
+            sprintf(tmp, ">%ds ", age);
+          } else if (age < 3600) {
+            sprintf(tmp, ">%dm ", age / 60);
+          } else if (age < 86400) {
+            sprintf(tmp, ">%dh ", age / 3600);
+          } else {
+            sprintf(tmp, ">%dd ", age / 86400);
+          }
         } else {
-          sprintf(tmp, "(%d) %dd ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 86400);
+          if (age < 60) {
+            sprintf(tmp, "(%d) %ds ", msg->path_len == 0xFF ? 0 : msg->path_len, age);
+          } else if (age < 3600) {
+            sprintf(tmp, "(%d) %dm ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 60);
+          } else if (age < 86400) {
+            sprintf(tmp, "(%d) %dh ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 3600);
+          } else {
+            sprintf(tmp, "(%d) %dd ", msg->path_len == 0xFF ? 0 : msg->path_len, age / 86400);
+          }
         }
         display.print(tmp);
         // DO NOT advance y - message text continues on the same line
         
         // Message text with character wrapping and inline emoji support
         // (continues after timestamp on first line)
-        display.setColor(DisplayDriver::LIGHT);
+        display.setColor(isSelected ? DisplayDriver::DARK : DisplayDriver::LIGHT);
         
         int textLen = strlen(msg->text);
         int pos = 0;
         int linesForThisMsg = 0;
-        int maxLinesPerMsg = 8;
         char charStr[2] = {0, 0};
         
         // Track position in pixels for emoji placement
@@ -635,12 +835,30 @@ public:
           }
         }
         
+        // Check if this message was clipped (not all text rendered)
+        lastMsgTruncated = (pos < textLen);
+        
         // If we didn't end on a full line, still count it
         if (px > 0) {
           y += lineHeight;
         }
         
         y += 2;  // Small gap between messages
+        
+        // Erase excess highlight below the actual message.
+        // The upfront fillRect covered a max area; restore the unused
+        // portion back to background so subsequent messages render cleanly.
+        if (isSelected) {
+          int usedH = y - yStart;
+          int maxFillH = (maxLinesPerMsg + 1) * lineHeight + 2;
+          int availH = maxY - yStart;
+          if (maxFillH > availH) maxFillH = availH;
+          if (usedH < maxFillH) {
+            display.setColor(DisplayDriver::DARK);
+            display.fillRect(0, y + 5, contentW, maxFillH - usedH);
+          }
+        }
+        
         msgsDrawn++;
         if (y + lineHeight > maxY) screenFull = true;
       }
@@ -650,7 +868,12 @@ public:
       // prevents a feedback loop where variable-height messages cause
       // msgsPerPage to oscillate, shifting startIdx every render (flicker).
       if (screenFull && msgsDrawn > 0 && _scrollPos == 0) {
-        _msgsPerPage = msgsDrawn;
+        // If the last message was truncated (text clipped by footer), exclude it
+        // from the page count so next render starts one message later and the
+        // bottom message fits completely.
+        int effectiveDrawn = lastMsgTruncated ? msgsDrawn - 1 : msgsDrawn;
+        if (effectiveDrawn < 1) effectiveDrawn = 1;
+        _msgsPerPage = effectiveDrawn;
       }
       
       // --- Scroll bar (emoji picker style) ---
@@ -688,12 +911,17 @@ public:
     display.setColor(DisplayDriver::YELLOW);
     
     // Left side: abbreviated controls
-    display.print("Q:Bck A/D:Ch V:Pth");
-    
-    // Right side: Ent:New
-    const char* rightText = "Ent:New";
-    display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
-    display.print(rightText);
+    if (_replySelectMode) {
+      display.print("W/S:Sel V:Pth Q:X");
+      const char* rightText = "Ent:Reply";
+      display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
+      display.print(rightText);
+    } else {
+      display.print("Q:Bck A/D:Ch R:Rply");
+      const char* rightText = "Ent:New";
+      display.setCursor(display.width() - display.getTextWidth(rightText) - 2, footerY);
+      display.print(rightText);
+    }
 
 #if AUTO_OFF_MILLIS == 0  // e-ink
     return 5000;
@@ -703,34 +931,107 @@ public:
   }
 
   bool handleInput(char c) override {
-    // If overlay is showing, only handle dismiss
+    // If overlay is showing, handle scroll and dismiss
     if (_showPathOverlay) {
       if (c == 'q' || c == 'Q' || c == '\b' || c == 'v' || c == 'V') {
         _showPathOverlay = false;
+        _pathScrollPos = 0;
         return true;
       }
+      if (c == '\r' || c == 13) {
+        return false;  // Let main.cpp handle Enter for copy-to-compose
+      }
       // W - scroll up in hop list
       if (c == 'w' || c == 'W' || c == 0xF2) {
-        if (_pathOverlayScroll > 0) {
-          _pathOverlayScroll--;
-          return true;
+        if (_pathScrollPos > 0) {
+          _pathScrollPos--;
         }
+        return true;
       }
       // S - scroll down in hop list
       if (c == 's' || c == 'S' || c == 0xF1) {
-        _pathOverlayScroll++;  // Clamped during render
+        ChannelMessage* msg = getNewestReceivedMsg();
+        if (msg && msg->path_len > 0 && msg->path_len != 0xFF) {
+          int totalHops = msg->path_len < MSG_PATH_MAX ? msg->path_len : MSG_PATH_MAX;
+          if (_pathScrollPos < totalHops - _pathHopsVisible) {
+            _pathScrollPos++;
+          }
+        }
         return true;
       }
-      return true;  // Consume all keys while overlay is up
+      return true;  // Consume all other keys while overlay is up
     }
-    
+
+    // --- Reply select mode ---
+    if (_replySelectMode) {
+      // Q - exit reply select
+      if (c == 'q' || c == 'Q' || c == '\b') {
+        _replySelectMode = false;
+        _replySelectPos = -1;
+        return true;
+      }
+      // W - select older message (lower index in chronological order)
+      if (c == 'w' || c == 'W' || c == 0xF2) {
+        if (_replySelectPos > 0) {
+          _replySelectPos--;
+          // Auto-scroll to keep selection visible
+          int startIdx = _replyChannelMsgCount - _msgsPerPage - _scrollPos;
+          if (startIdx < 0) startIdx = 0;
+          if (_replySelectPos < startIdx) {
+            _scrollPos++;
+          }
+        }
+        return true;
+      }
+      // S - select newer message (higher index in chronological order)
+      if (c == 's' || c == 'S' || c == 0xF1) {
+        if (_replySelectPos < _replyChannelMsgCount - 1) {
+          _replySelectPos++;
+          // Auto-scroll to keep selection visible
+          int endIdx = _replyChannelMsgCount - _scrollPos;
+          if (_replySelectPos >= endIdx) {
+            if (_scrollPos > 0) _scrollPos--;
+          }
+        }
+        return true;
+      }
+      // V - view path for the SELECTED message (not just newest received)
+      if (c == 'v' || c == 'V') {
+        // Path overlay will use getNewestReceivedMsg() — for v1 this is fine.
+        // The user can see the selected message's hop count in the > marker.
+        ChannelMessage* selMsg = getReplySelectMsg();
+        if (selMsg && selMsg->path_len != 0) {
+          _showPathOverlay = true;
+          _pathScrollPos = 0;
+        }
+        return true;
+      }
+      // Enter - let main.cpp handle (enters compose with @mention)
+      if (c == '\r' || c == 13) {
+        return false;
+      }
+      return true;  // Consume all other keys in reply select
+    }
+
     int channelMsgCount = getMessageCountForChannel();
+
+    // R - enter reply select mode
+    if (c == 'r' || c == 'R') {
+      if (channelMsgCount > 0) {
+        _replySelectMode = true;
+        // Start with newest message selected
+        _replySelectPos = _replyChannelMsgCount > 0
+                            ? _replyChannelMsgCount - 1 : channelMsgCount - 1;
+        return true;
+      }
+      return false;
+    }
     
     // V - show path detail for last received message
     if (c == 'v' || c == 'V') {
       if (getNewestReceivedMsg() != nullptr) {
         _showPathOverlay = true;
-        _pathOverlayScroll = 0;
+        _pathScrollPos = 0;
         return true;
       }
       return false;  // No received messages to show
@@ -754,6 +1055,8 @@ public:
     
     // A - previous channel
     if (c == 'a' || c == 'A') {
+      _replySelectMode = false;
+      _replySelectPos = -1;
       if (_viewChannelIdx > 0) {
         _viewChannelIdx--;
       } else {
@@ -767,11 +1070,14 @@ public:
         }
       }
       _scrollPos = 0;
+      markChannelRead(_viewChannelIdx);
       return true;
     }
     
     // D - next channel
     if (c == 'd' || c == 'D') {
+      _replySelectMode = false;
+      _replySelectPos = -1;
       ChannelDetails ch;
       uint8_t nextIdx = _viewChannelIdx + 1;
       if (the_mesh.getChannel(nextIdx, ch) && ch.name[0] != '\0') {
@@ -780,6 +1086,7 @@ public:
         _viewChannelIdx = 0;
       }
       _scrollPos = 0;
+      markChannelRead(_viewChannelIdx);
       return true;
     }
     

examples/companion_radio/ui-new/Contactsscreen.h

@@ -18,6 +18,7 @@ public:
     FILTER_REPEATER,
     FILTER_ROOM,       // Room servers
     FILTER_SENSOR,
+    FILTER_FAVOURITE,  // Contacts marked as favourite (any type)
     FILTER_COUNT       // keep last
   };
 
@@ -30,9 +31,9 @@ private:
 
   // 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
+  // Arrays allocated in PSRAM when available (supports 1000+ contacts)
+  uint16_t* _filteredIdx;    // indices into contact table
+  uint32_t* _filteredTs;     // cached last_advert_timestamp for sorting
   int _filteredCount;                  // how many contacts match current filter
   bool _cacheValid;
 
@@ -48,6 +49,7 @@ private:
       case FILTER_REPEATER:  return "Rptr";
       case FILTER_ROOM:      return "Room";
       case FILTER_SENSOR:    return "Sens";
+      case FILTER_FAVOURITE: return "Fav";
       default:               return "?";
     }
   }
@@ -61,7 +63,7 @@ private:
     }
   }
 
-  bool matchesFilter(uint8_t adv_type) const {
+  bool matchesFilter(uint8_t adv_type, uint8_t flags = 0) const {
     switch (_filter) {
       case FILTER_ALL:       return true;
       case FILTER_CHAT:      return adv_type == ADV_TYPE_CHAT;
@@ -70,6 +72,7 @@ private:
       case FILTER_SENSOR:    return (adv_type != ADV_TYPE_CHAT &&
                                      adv_type != ADV_TYPE_REPEATER &&
                                      adv_type != ADV_TYPE_ROOM);
+      case FILTER_FAVOURITE: return (flags & 0x01) != 0;
       default:               return true;
     }
   }
@@ -78,9 +81,9 @@ private:
     _filteredCount = 0;
     uint32_t numContacts = the_mesh.getNumContacts();
     ContactInfo contact;
-    for (uint32_t i = 0; i < numContacts && _filteredCount < MAX_VISIBLE; i++) {
+    for (uint32_t i = 0; i < numContacts && _filteredCount < MAX_CONTACTS; i++) {
       if (the_mesh.getContactByIdx(i, contact)) {
-        if (matchesFilter(contact.type)) {
+        if (matchesFilter(contact.type, contact.flags)) {
           _filteredIdx[_filteredCount] = (uint16_t)i;
           _filteredTs[_filteredCount] = contact.last_advert_timestamp;
           _filteredCount++;
@@ -88,7 +91,7 @@ private:
       }
     }
     // Sort by last_advert_timestamp descending (most recently seen first)
-    // Simple insertion sort — fine for up to 400 entries on ESP32
+    // Insertion sort — fine for up to ~1000 entries on ESP32
     for (int i = 1; i < _filteredCount; i++) {
       uint16_t tmpIdx = _filteredIdx[i];
       uint32_t tmpTs  = _filteredTs[i];
@@ -130,7 +133,15 @@ private:
 public:
   ContactsScreen(UITask* task, mesh::RTCClock* rtc)
     : _task(task), _rtc(rtc), _scrollPos(0), _filter(FILTER_ALL),
-      _filteredCount(0), _cacheValid(false), _rowsPerPage(5) {}
+      _filteredCount(0), _cacheValid(false), _rowsPerPage(5) {
+  #if defined(ESP32) && defined(BOARD_HAS_PSRAM)
+    _filteredIdx = (uint16_t*)ps_calloc(MAX_CONTACTS, sizeof(uint16_t));
+    _filteredTs = (uint32_t*)ps_calloc(MAX_CONTACTS, sizeof(uint32_t));
+  #else
+    _filteredIdx = new uint16_t[MAX_CONTACTS]();
+    _filteredTs = new uint32_t[MAX_CONTACTS]();
+  #endif
+  }
 
   void invalidateCache() { _cacheValid = false; }
 

examples/companion_radio/ui-new/Emojisprites.h

@@ -3,7 +3,7 @@
 // Emoji sprites for e-ink display - dual size
 // Large (12x12) for compose/picker, Small (10x10) for channel view
 // MSB-first, 2 bytes per row
-// 46 total emoji: joy/thumbsup/frown first, then 43 original (telephone removed)
+// 65 total emoji: joy/thumbsup/frown first, then 43 original, then 19 new
 
 #include <stdint.h>
 #ifdef ESP32
@@ -15,11 +15,11 @@
 #define EMOJI_SM_W 10
 #define EMOJI_SM_H 10
 
-#define EMOJI_COUNT 46
+#define EMOJI_COUNT 65
 
 // 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_ESCAPE_END   0xC0   // 0x80 + 64
 #define EMOJI_PAD_BYTE     0x7F   // DEL, not typeable (key < 127 guard)
 
 // ======== LARGE 12x12 SPRITES ========
@@ -208,6 +208,82 @@ static const uint8_t emoji_lg_peach[] PROGMEM = {
 static const uint8_t emoji_lg_racing_car[] PROGMEM = {
   0x00,0x00, 0x00,0x00, 0x00,0x00, 0x07,0x80, 0x0F,0xC0, 0x7F,0xE0, 0xFF,0xF0, 0xFF,0xF0, 0x6F,0x60, 0x49,0x20, 0x00,0x00, 0x00,0x00,
 };
+// [46] mouse 🐭
+static const uint8_t emoji_lg_mouse[] PROGMEM = {
+  0x30,0xC0, 0x79,0xE0, 0x79,0xE0, 0x3F,0xC0, 0x49,0x20, 0x80,0x10, 0x86,0x10, 0x89,0x10, 0x40,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [47] mushroom 🍄
+static const uint8_t emoji_lg_mushroom[] PROGMEM = {
+  0x1F,0x80, 0x3F,0xC0, 0x7F,0xE0, 0xE6,0x70, 0xE6,0x70, 0x7F,0xE0, 0x3F,0xC0, 0x0F,0x00, 0x0F,0x00, 0x0F,0x00, 0x1F,0x80, 0x00,0x00,
+};
+// [48] biohazard ☣️
+static const uint8_t emoji_lg_biohazard[] PROGMEM = {
+  0x0F,0x00, 0x1F,0x80, 0x3F,0xC0, 0x1F,0x80, 0x0F,0x00, 0x66,0x60, 0x76,0xE0, 0x70,0xE0, 0x79,0xE0, 0x39,0xC0, 0x19,0x80, 0x00,0x00,
+};
+// [49] panda 🐼
+static const uint8_t emoji_lg_panda[] PROGMEM = {
+  0x00,0x00, 0x60,0x60, 0xF0,0xF0, 0xF0,0xF0, 0x7F,0xE0, 0x59,0xA0, 0x59,0xA0, 0x40,0x20, 0x46,0x20, 0x20,0x40, 0x1F,0x80, 0x00,0x00,
+};
+// [50] anger 💢
+static const uint8_t emoji_lg_anger[] PROGMEM = {
+  0x00,0x00, 0x3C,0xC0, 0x3C,0xC0, 0x30,0xC0, 0x30,0x00, 0x00,0x00, 0x00,0x00, 0x00,0xC0, 0x30,0xC0, 0x33,0xC0, 0x33,0xC0, 0x00,0x00,
+};
+// [51] dragon_face 🐲
+static const uint8_t emoji_lg_dragon_face[] PROGMEM = {
+  0xC0,0x30, 0xE0,0x70, 0x76,0xE0, 0x3F,0xC0, 0x69,0x60, 0x40,0x20, 0x4F,0x20, 0x29,0x40, 0x30,0xC0, 0x1F,0x80, 0x00,0x00, 0x00,0x00,
+};
+// [52] pager 📟
+static const uint8_t emoji_lg_pager[] PROGMEM = {
+  0x00,0x00, 0x7F,0xE0, 0x40,0x20, 0x5F,0xA0, 0x5F,0xA0, 0x40,0x20, 0x5B,0x20, 0x5B,0x20, 0x40,0x20, 0x7F,0xE0, 0x00,0x00, 0x00,0x00,
+};
+// [53] bee 🐝
+static const uint8_t emoji_lg_bee[] PROGMEM = {
+  0x00,0x00, 0x19,0x80, 0x19,0x80, 0x3F,0x80, 0x7F,0xC0, 0x7F,0xE0, 0x7F,0xE0, 0x7F,0xC0, 0x3F,0x80, 0x1F,0x40, 0x0A,0x00, 0x00,0x00,
+};
+// [54] bulb 💡
+static const uint8_t emoji_lg_bulb[] PROGMEM = {
+  0x1F,0x80, 0x20,0x40, 0x40,0x20, 0x40,0x20, 0x40,0x20, 0x20,0x40, 0x30,0xC0, 0x1F,0x80, 0x16,0x80, 0x1F,0x80, 0x0F,0x00, 0x00,0x00,
+};
+// [55] cat 🐱
+static const uint8_t emoji_lg_cat[] PROGMEM = {
+  0x40,0x20, 0x60,0x60, 0x70,0xE0, 0x3F,0xC0, 0x59,0xA0, 0x40,0x20, 0x40,0x20, 0x46,0x20, 0x29,0x40, 0x30,0xC0, 0x1F,0x80, 0x00,0x00,
+};
+// [56] fleur ⚜️
+static const uint8_t emoji_lg_fleur[] PROGMEM = {
+  0x06,0x00, 0x06,0x00, 0x0F,0x00, 0x6F,0x60, 0xF6,0xF0, 0xF6,0xF0, 0x76,0xE0, 0x3F,0xC0, 0x1F,0x80, 0x0F,0x00, 0x19,0x80, 0x00,0x00,
+};
+// [57] moon 🌔
+static const uint8_t emoji_lg_moon[] PROGMEM = {
+  0x1F,0x80, 0x3F,0xC0, 0x7F,0xE0, 0x7F,0x80, 0xFF,0x80, 0xFF,0x00, 0xFF,0x00, 0xFF,0x80, 0x7F,0x80, 0x7F,0xE0, 0x3F,0xC0, 0x1F,0x80,
+};
+// [58] coffee ☕
+static const uint8_t emoji_lg_coffee[] PROGMEM = {
+  0x24,0x80, 0x12,0x40, 0x00,0x00, 0x7F,0xC0, 0x40,0x70, 0x40,0x50, 0x40,0x50, 0x40,0x70, 0x7F,0xC0, 0x00,0x00, 0xFF,0xC0, 0x00,0x00,
+};
+// [59] tooth 🦷
+static const uint8_t emoji_lg_tooth[] PROGMEM = {
+  0x3F,0xC0, 0x7F,0xE0, 0xFF,0xF0, 0xFF,0xF0, 0xFF,0xF0, 0x7F,0xE0, 0x3F,0xC0, 0x3F,0xC0, 0x39,0xC0, 0x39,0xC0, 0x30,0xC0, 0x20,0x40,
+};
+// [60] pretzel 🥨
+static const uint8_t emoji_lg_pretzel[] PROGMEM = {
+  0x39,0xC0, 0x46,0x20, 0x80,0x20, 0x86,0x10, 0x49,0x20, 0x30,0xC0, 0x30,0xC0, 0x49,0x20, 0x86,0x10, 0x80,0x10, 0x46,0x20, 0x39,0xC0,
+};
+// [61] abacus 🧮
+static const uint8_t emoji_lg_abacus[] PROGMEM = {
+  0xFF,0xF0, 0x80,0x10, 0xB6,0x50, 0x80,0x10, 0xA6,0x90, 0x80,0x10, 0x94,0xD0, 0x80,0x10, 0xB2,0x50, 0x80,0x10, 0xFF,0xF0, 0x00,0x00,
+};
+// [62] moai 🗿
+static const uint8_t emoji_lg_moai[] PROGMEM = {
+  0x3F,0xC0, 0x7F,0xC0, 0x7F,0xC0, 0x39,0xC0, 0x39,0xC0, 0x3F,0xC0, 0x27,0x40, 0x3F,0x80, 0x2F,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00,
+};
+// [63] tipping 💁
+static const uint8_t emoji_lg_tipping[] PROGMEM = {
+  0x1E,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00, 0x0C,0x00, 0x1E,0x00, 0x3F,0x00, 0x7F,0x80, 0x0C,0xE0, 0x0D,0xE0, 0x12,0xE0, 0x33,0x00,
+};
+// [64] hedgehog 🦔
+static const uint8_t emoji_lg_hedgehog[] PROGMEM = {
+  0x00,0x00, 0x0A,0x80, 0x15,0x40, 0x2A,0xA0, 0x55,0x60, 0x7E,0xF0, 0xDB,0x90, 0xFF,0xD0, 0x7F,0xE0, 0x3F,0xC0, 0x24,0x80, 0x00,0x00,
+};
 
 static const uint8_t* const EMOJI_SPRITES_LG[] PROGMEM = {
   emoji_lg_joy, emoji_lg_thumbsup, emoji_lg_frown,
@@ -220,6 +296,11 @@ static const uint8_t* const EMOJI_SPRITES_LG[] PROGMEM = {
   emoji_lg_kangaroo, emoji_lg_feather, emoji_lg_bright, emoji_lg_part_alt, emoji_lg_motorboat,
   emoji_lg_domino, emoji_lg_satellite, emoji_lg_customs, emoji_lg_cowboy, emoji_lg_wheel,
   emoji_lg_koala, emoji_lg_control_knobs, emoji_lg_peach, emoji_lg_racing_car,
+  emoji_lg_mouse, emoji_lg_mushroom, emoji_lg_biohazard, emoji_lg_panda,
+  emoji_lg_anger, emoji_lg_dragon_face, emoji_lg_pager, emoji_lg_bee,
+  emoji_lg_bulb, emoji_lg_cat, emoji_lg_fleur, emoji_lg_moon,
+  emoji_lg_coffee, emoji_lg_tooth, emoji_lg_pretzel, emoji_lg_abacus,
+  emoji_lg_moai, emoji_lg_tipping, emoji_lg_hedgehog,
 };
 
 // ======== SMALL 10x10 SPRITES ========
@@ -362,6 +443,82 @@ static const uint8_t emoji_sm_peach[] PROGMEM = {
 static const uint8_t emoji_sm_racing_car[] PROGMEM = {
   0x00,0x00, 0x00,0x00, 0x0E,0x00, 0x1F,0x00, 0x7F,0x80, 0xFF,0xC0, 0xFF,0xC0, 0x5E,0x80, 0x00,0x00, 0x00,0x00,
 };
+// [46] mouse 🐭
+static const uint8_t emoji_sm_mouse[] PROGMEM = {
+  0x61,0x80, 0xF3,0xC0, 0x7F,0x80, 0x92,0x40, 0x80,0x40, 0x8C,0x40, 0x52,0x80, 0x40,0x80, 0x3F,0x00, 0x00,0x00,
+};
+// [47] mushroom 🍄
+static const uint8_t emoji_sm_mushroom[] PROGMEM = {
+  0x3F,0x00, 0x7F,0x80, 0xED,0xC0, 0xED,0xC0, 0x7F,0x80, 0x3F,0x00, 0x1E,0x00, 0x1E,0x00, 0x3F,0x00, 0x00,0x00,
+};
+// [48] biohazard ☣️
+static const uint8_t emoji_sm_biohazard[] PROGMEM = {
+  0x1E,0x00, 0x3F,0x00, 0x3F,0x00, 0x1E,0x00, 0x6D,0x80, 0x73,0x80, 0x73,0x80, 0x7B,0x80, 0x33,0x00, 0x00,0x00,
+};
+// [49] panda 🐼
+static const uint8_t emoji_sm_panda[] PROGMEM = {
+  0xC0,0xC0, 0xF3,0xC0, 0x7F,0x80, 0xB3,0x40, 0xB3,0x40, 0x80,0x40, 0x4C,0x80, 0x21,0x00, 0x3F,0x00, 0x00,0x00,
+};
+// [50] anger 💢
+static const uint8_t emoji_sm_anger[] PROGMEM = {
+  0x00,0x00, 0x73,0x00, 0x73,0x00, 0x63,0x00, 0x60,0x00, 0x01,0x80, 0x63,0x00, 0x67,0x00, 0x67,0x00, 0x00,0x00,
+};
+// [51] dragon_face 🐲
+static const uint8_t emoji_sm_dragon_face[] PROGMEM = {
+  0xC0,0xC0, 0xED,0xC0, 0x7F,0x80, 0x52,0x80, 0x40,0x80, 0x4C,0x80, 0x33,0x00, 0x2D,0x00, 0x1E,0x00, 0x00,0x00,
+};
+// [52] pager 📟
+static const uint8_t emoji_sm_pager[] PROGMEM = {
+  0x00,0x00, 0x7F,0x80, 0x40,0x80, 0x5E,0x80, 0x40,0x80, 0x5A,0x80, 0x5A,0x80, 0x40,0x80, 0x7F,0x80, 0x00,0x00,
+};
+// [53] bee 🐝
+static const uint8_t emoji_sm_bee[] PROGMEM = {
+  0x33,0x00, 0x33,0x00, 0x7F,0x00, 0xFF,0x80, 0xFF,0xC0, 0xFF,0x80, 0x7F,0x00, 0x3E,0x80, 0x14,0x00, 0x00,0x00,
+};
+// [54] bulb 💡
+static const uint8_t emoji_sm_bulb[] PROGMEM = {
+  0x3F,0x00, 0x40,0x80, 0x80,0x40, 0x80,0x40, 0x40,0x80, 0x33,0x00, 0x3F,0x00, 0x1E,0x00, 0x1E,0x00, 0x00,0x00,
+};
+// [55] cat 🐱
+static const uint8_t emoji_sm_cat[] PROGMEM = {
+  0x80,0x40, 0xC0,0xC0, 0x7F,0x80, 0xB3,0x40, 0x80,0x40, 0x8C,0x40, 0x52,0x80, 0x61,0x80, 0x3F,0x00, 0x00,0x00,
+};
+// [56] fleur ⚜️
+static const uint8_t emoji_sm_fleur[] PROGMEM = {
+  0x0C,0x00, 0x0C,0x00, 0x6D,0x80, 0xED,0xC0, 0xED,0xC0, 0x6D,0x80, 0x3F,0x00, 0x1E,0x00, 0x33,0x00, 0x00,0x00,
+};
+// [57] moon 🌔
+static const uint8_t emoji_sm_moon[] PROGMEM = {
+  0x3F,0x00, 0x7F,0x80, 0xFF,0x80, 0xFE,0x00, 0xFE,0x00, 0xFE,0x00, 0xFE,0x00, 0xFF,0x80, 0x7F,0x80, 0x3F,0x00,
+};
+// [58] coffee ☕
+static const uint8_t emoji_sm_coffee[] PROGMEM = {
+  0x49,0x00, 0x24,0x80, 0x00,0x00, 0xFF,0x00, 0x81,0xC0, 0x81,0x40, 0x81,0xC0, 0xFF,0x00, 0x00,0x00, 0xFE,0x00,
+};
+// [59] tooth 🦷
+static const uint8_t emoji_sm_tooth[] PROGMEM = {
+  0x7F,0x80, 0xFF,0xC0, 0xFF,0xC0, 0xFF,0xC0, 0x7F,0x80, 0x3F,0x00, 0x3B,0x80, 0x31,0x80, 0x20,0x80, 0x00,0x00,
+};
+// [60] pretzel 🥨
+static const uint8_t emoji_sm_pretzel[] PROGMEM = {
+  0x73,0x80, 0x9E,0x40, 0x8C,0x40, 0x52,0x80, 0x33,0x00, 0x33,0x00, 0x52,0x80, 0x8C,0x40, 0x9E,0x40, 0x73,0x80,
+};
+// [61] abacus 🧮
+static const uint8_t emoji_sm_abacus[] PROGMEM = {
+  0xFF,0xC0, 0x80,0x40, 0xB5,0x40, 0x80,0x40, 0xAD,0x40, 0x80,0x40, 0xAB,0x40, 0x80,0x40, 0xFF,0xC0, 0x00,0x00,
+};
+// [62] moai 🗿
+static const uint8_t emoji_sm_moai[] PROGMEM = {
+  0x7F,0x00, 0x7F,0x00, 0x33,0x00, 0x33,0x00, 0x3F,0x00, 0x2E,0x00, 0x3E,0x00, 0x3E,0x00, 0x3E,0x00, 0x1C,0x00,
+};
+// [63] tipping 💁
+static const uint8_t emoji_sm_tipping[] PROGMEM = {
+  0x3C,0x00, 0x7E,0x00, 0x7E,0x00, 0x3C,0x00, 0x18,0x00, 0x3C,0x00, 0x7E,0x00, 0x1B,0x80, 0x1B,0x80, 0x36,0x00,
+};
+// [64] hedgehog 🦔
+static const uint8_t emoji_sm_hedgehog[] PROGMEM = {
+  0x15,0x00, 0x2A,0x80, 0x55,0x40, 0xFF,0xC0, 0xDB,0x40, 0xFF,0x80, 0x7F,0x80, 0x3F,0x00, 0x24,0x00, 0x00,0x00,
+};
 
 static const uint8_t* const EMOJI_SPRITES_SM[] PROGMEM = {
   emoji_sm_joy, emoji_sm_thumbsup, emoji_sm_frown,
@@ -374,6 +531,11 @@ static const uint8_t* const EMOJI_SPRITES_SM[] PROGMEM = {
   emoji_sm_kangaroo, emoji_sm_feather, emoji_sm_bright, emoji_sm_part_alt, emoji_sm_motorboat,
   emoji_sm_domino, emoji_sm_satellite, emoji_sm_customs, emoji_sm_cowboy, emoji_sm_wheel,
   emoji_sm_koala, emoji_sm_control_knobs, emoji_sm_peach, emoji_sm_racing_car,
+  emoji_sm_mouse, emoji_sm_mushroom, emoji_sm_biohazard, emoji_sm_panda,
+  emoji_sm_anger, emoji_sm_dragon_face, emoji_sm_pager, emoji_sm_bee,
+  emoji_sm_bulb, emoji_sm_cat, emoji_sm_fleur, emoji_sm_moon,
+  emoji_sm_coffee, emoji_sm_tooth, emoji_sm_pretzel, emoji_sm_abacus,
+  emoji_sm_moai, emoji_sm_tipping, emoji_sm_hedgehog,
 };
 
 // ---- Codepoint lookup for UTF-8 conversion ----
@@ -426,10 +588,37 @@ static const EmojiCodepoint EMOJI_CODEPOINTS[EMOJI_COUNT] = {
   { 0x1F39B, 0x0000, 0xAB }, // control_knobs
   { 0x1F351, 0x0000, 0xAC }, // peach
   { 0x1F3CE, 0x0000, 0xAD }, // racing_car
+  { 0x1F42D, 0x0000, 0xAE }, // mouse
+  { 0x1F344, 0x0000, 0xAF }, // mushroom
+  { 0x2623,  0x0000, 0xB0 }, // biohazard
+  { 0x1F43C, 0x0000, 0xB1 }, // panda
+  { 0x1F4A2, 0x0000, 0xB2 }, // anger
+  { 0x1F432, 0x0000, 0xB3 }, // dragon_face
+  { 0x1F4DF, 0x0000, 0xB4 }, // pager
+  { 0x1F41D, 0x0000, 0xB5 }, // bee
+  { 0x1F4A1, 0x0000, 0xB6 }, // bulb
+  { 0x1F431, 0x0000, 0xB7 }, // cat
+  { 0x269C,  0x0000, 0xB8 }, // fleur
+  { 0x1F314, 0x0000, 0xB9 }, // moon
+  { 0x2615,  0x0000, 0xBA }, // coffee
+  { 0x1F9B7, 0x0000, 0xBB }, // tooth
+  { 0x1F968, 0x0000, 0xBC }, // pretzel
+  { 0x1F9EE, 0x0000, 0xBD }, // abacus
+  { 0x1F5FF, 0x0000, 0xBE }, // moai
+  { 0x1F481, 0x0000, 0xBF }, // tipping
+  { 0x1F994, 0x0000, 0xC0 }, // hedgehog
 };
 
 // ---- Helper functions ----
 
+// Alias table: extra codepoints that map to existing emoji escape bytes.
+// Used for variant codepoints (e.g. MWD node identifier 🂎 U+1F08E -> domino sprite)
+struct EmojiAlias { uint32_t cp; uint8_t escape; };
+#define EMOJI_ALIAS_COUNT 1
+static const EmojiAlias EMOJI_ALIASES[EMOJI_ALIAS_COUNT] = {
+  { 0x1F08E, 0xA5 }, // domino tile (MWD node signifier) -> domino sprite
+};
+
 static uint32_t emojiDecodeUtf8(const uint8_t* s, int remaining, int* bytes_consumed) {
   uint8_t b0 = s[0];
   if (b0 < 0x80) { *bytes_consumed = 1; return b0; }
@@ -483,6 +672,18 @@ static void emojiSanitize(const char* src, char* dst, int dstLen) {
           found = true; break;
         }
       }
+      if (!found) {
+        // Check alias table for variant codepoints
+        for (int a = 0; a < EMOJI_ALIAS_COUNT; a++) {
+          if (EMOJI_ALIASES[a].cp == cp) {
+            dst[di++] = EMOJI_ALIASES[a].escape;
+            si += consumed;
+            // Skip trailing variation selector U+FE0F
+            if (si + 2 < srcLen && s[si] == 0xEF && s[si+1] == 0xB8 && s[si+2] == 0x8F) si += 3;
+            found = true; break;
+          }
+        }
+      }
       if (!found) si += consumed;  // Skip unknown multi-byte chars
     } else {
       dst[di++] = (char)b;

examples/companion_radio/ui-new/ModemManager.cpp

@@ -17,6 +17,10 @@ ModemManager modemManager;
 #define AT_BUF_SIZE  512
 static char _atBuf[AT_BUF_SIZE];
 
+// Config file paths
+#define MODEM_CONFIG_FILE "/sms/modem.cfg"
+#define APN_CONFIG_FILE   "/sms/apn.cfg"
+
 // ---------------------------------------------------------------------------
 // Public API - SMS (unchanged)
 // ---------------------------------------------------------------------------
@@ -30,6 +34,10 @@ void ModemManager::begin() {
   _callPhone[0] = '\0';
   _callStartTime = 0;
   _urcPos = 0;
+  _imei[0] = '\0';
+  _imsi[0] = '\0';
+  _apn[0] = '\0';
+  strcpy(_apnSource, "none");
 
   // Create FreeRTOS primitives
   _sendQueue   = xQueueCreate(MODEM_SEND_QUEUE_SIZE, sizeof(SMSOutgoing));
@@ -192,8 +200,6 @@ const char* ModemManager::stateToString(ModemState s) {
 // Persistent modem enable/disable config
 // ---------------------------------------------------------------------------
 
-#define MODEM_CONFIG_FILE "/sms/modem.cfg"
-
 bool ModemManager::loadEnabledConfig() {
   File f = SD.open(MODEM_CONFIG_FILE, FILE_READ);
   if (!f) {
@@ -217,6 +223,112 @@ void ModemManager::saveEnabledConfig(bool enabled) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// APN Configuration
+// ---------------------------------------------------------------------------
+
+void ModemManager::setAPN(const char* apn) {
+  strncpy(_apn, apn, sizeof(_apn) - 1);
+  _apn[sizeof(_apn) - 1] = '\0';
+  strcpy(_apnSource, "user");
+  saveAPNConfig(apn);
+  MESH_DEBUG_PRINTLN("[Modem] APN set by user: %s", _apn);
+}
+
+bool ModemManager::loadAPNConfig(char* apnOut, int maxLen) {
+  File f = SD.open(APN_CONFIG_FILE, FILE_READ);
+  if (!f) { return false; }
+  String line = f.readStringUntil('\n');
+  f.close();
+  line.trim();
+  if (line.length() == 0) return false;
+  strncpy(apnOut, line.c_str(), maxLen - 1);
+  apnOut[maxLen - 1] = '\0';
+  return true;
+}
+
+void ModemManager::saveAPNConfig(const char* apn) {
+  if (!SD.exists("/sms")) SD.mkdir("/sms");
+  File f = SD.open(APN_CONFIG_FILE, FILE_WRITE);
+  if (f) {
+    f.println(apn);
+    f.close();
+    Serial.printf("[Modem] APN config saved: %s\n", apn);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// APN Resolution — called during init after network registration
+//
+// Priority:
+//   1. User-configured APN (from /sms/apn.cfg)
+//   2. Network-provisioned APN (AT+CGDCONT? — modem already has one)
+//   3. Auto-detected from IMSI via embedded ApnDatabase
+//   4. Blank (some carriers work with empty APN)
+// ---------------------------------------------------------------------------
+
+void ModemManager::resolveAPN() {
+  // 1. Check for user-configured APN on SD card
+  char userApn[64];
+  if (loadAPNConfig(userApn, sizeof(userApn))) {
+    strncpy(_apn, userApn, sizeof(_apn) - 1);
+    strcpy(_apnSource, "user");
+    MESH_DEBUG_PRINTLN("[Modem] APN from user config: %s", _apn);
+
+    // Apply to modem
+    char cmd[80];
+    snprintf(cmd, sizeof(cmd), "AT+CGDCONT=1,\"IP\",\"%s\"", _apn);
+    sendAT(cmd, "OK", 3000);
+    return;
+  }
+
+  // 2. Check if modem already has a network-provisioned APN
+  if (sendAT("AT+CGDCONT?", "OK", 3000)) {
+    // Response: +CGDCONT: 1,"IP","telstra.internet",,0,0
+    char* p = strstr(_atBuf, "+CGDCONT:");
+    if (p) {
+      char* q1 = strchr(p, '"');     // first quote (before IP)
+      if (q1) q1 = strchr(q1 + 1, '"');  // close quote of IP
+      if (q1) q1 = strchr(q1 + 1, '"');  // open quote of APN
+      if (q1) {
+        q1++;
+        char* q2 = strchr(q1, '"');
+        if (q2 && q2 > q1) {
+          int len = q2 - q1;
+          if (len > 0 && len < (int)sizeof(_apn)) {
+            memcpy(_apn, q1, len);
+            _apn[len] = '\0';
+            strcpy(_apnSource, "network");
+            MESH_DEBUG_PRINTLN("[Modem] APN from network/modem: %s", _apn);
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Auto-detect from IMSI using embedded database
+  if (_imsi[0]) {
+    const ApnEntry* entry = apnLookupFromIMSI(_imsi);
+    if (entry) {
+      strncpy(_apn, entry->apn, sizeof(_apn) - 1);
+      strcpy(_apnSource, "auto");
+      MESH_DEBUG_PRINTLN("[Modem] APN auto-detected: %s (%s)", _apn, entry->carrier);
+
+      // Apply to modem
+      char cmd[80];
+      snprintf(cmd, sizeof(cmd), "AT+CGDCONT=1,\"IP\",\"%s\"", _apn);
+      sendAT(cmd, "OK", 3000);
+      return;
+    }
+  }
+
+  // 4. No APN found — leave blank
+  _apn[0] = '\0';
+  strcpy(_apnSource, "none");
+  MESH_DEBUG_PRINTLN("[Modem] APN: none detected (IMSI=%s)", _imsi[0] ? _imsi : "unknown");
+}
+
 // ---------------------------------------------------------------------------
 // URC (Unsolicited Result Code) Handling
 // ---------------------------------------------------------------------------
@@ -537,6 +649,28 @@ restart:
   // Disable echo
   sendAT("ATE0", "OK");
 
+  // --- Query device identity ---
+  // IMEI (International Mobile Equipment Identity)
+  if (sendAT("AT+GSN", "OK", 3000)) {
+    // Response is just the IMEI number on its own line
+    char* p = _atBuf;
+    while (*p && !isdigit(*p)) p++;  // skip to first digit
+    int i = 0;
+    while (isdigit(p[i]) && i < 19) { _imei[i] = p[i]; i++; }
+    _imei[i] = '\0';
+    MESH_DEBUG_PRINTLN("[Modem] IMEI: %s", _imei);
+  }
+
+  // IMSI (International Mobile Subscriber Identity) — for APN auto-detection
+  if (sendAT("AT+CIMI", "OK", 3000)) {
+    char* p = _atBuf;
+    while (*p && !isdigit(*p)) p++;
+    int i = 0;
+    while (isdigit(p[i]) && i < 19) { _imsi[i] = p[i]; i++; }
+    _imsi[i] = '\0';
+    MESH_DEBUG_PRINTLN("[Modem] IMSI: %s", _imsi);
+  }
+
   // Set SMS text mode
   sendAT("AT+CMGF=1", "OK");
 
@@ -589,6 +723,10 @@ restart:
   }
 
   // Query operator name
+  // AT+COPS=3,0 sets the format to "long alphanumeric" so AT+COPS?
+  // returns "Optus" instead of "50502"
+  sendAT("AT+COPS=3,0", "OK", 2000);
+
   if (sendAT("AT+COPS?", "OK", 5000)) {
     char* p = strchr(_atBuf, '"');
     if (p) {
@@ -604,9 +742,28 @@ restart:
     }
   }
 
+  // If operator is still numeric (all digits), look up friendly name from IMSI
+  if (_operator[0] && isdigit(_operator[0])) {
+    bool allDigits = true;
+    for (int i = 0; _operator[i]; i++) {
+      if (!isdigit(_operator[i])) { allDigits = false; break; }
+    }
+    if (allDigits && _imsi[0]) {
+      const ApnEntry* entry = apnLookupFromIMSI(_imsi);
+      if (entry && entry->carrier) {
+        strncpy(_operator, entry->carrier, sizeof(_operator) - 1);
+        _operator[sizeof(_operator) - 1] = '\0';
+        MESH_DEBUG_PRINTLN("[Modem] operator (from IMSI lookup): %s", _operator);
+      }
+    }
+  }
+
   // Initial signal query
   pollCSQ();
 
+  // Resolve APN (user config → network provisioned → IMSI auto-detect)
+  resolveAPN();
+
   // Sync ESP32 system clock from modem network time
   bool clockSet = false;
   for (int attempt = 0; attempt < 5 && !clockSet; attempt++) {
@@ -653,7 +810,8 @@ restart:
   sendAT("AT+CMGD=1,4", "OK", 5000);
 
   _state = ModemState::READY;
-  MESH_DEBUG_PRINTLN("[Modem] READY (CSQ=%d, operator=%s)", _csq, _operator);
+  MESH_DEBUG_PRINTLN("[Modem] READY (CSQ=%d, operator=%s, APN=%s [%s], IMEI=%s)",
+                     _csq, _operator, _apn[0] ? _apn : "(none)", _apnSource, _imei);
 
   // ---- Phase 4: Main loop ----
   unsigned long lastCSQPoll = 0;
@@ -715,8 +873,10 @@ restart:
     // Primary detection is via "VOICE CALL: BEGIN" URC (handled by
     // drainURCs/processURCLine above). CLCC polling is a safety net
     // in case the URC is missed or delayed.
+    // Skip when paused to avoid Core 0 contention with WiFi TLS.
     // ================================================================
-    if (_state == ModemState::DIALING &&
+    if (!_paused &&
+        _state == ModemState::DIALING &&
         millis() - lastCLCCPoll > CLCC_POLL_INTERVAL) {
       if (sendAT("AT+CLCC", "OK", 2000)) {
         // +CLCC: 1,0,0,0,0,"number",129   — stat field:
@@ -747,8 +907,11 @@ restart:
 
     // ================================================================
     // Step 4: SMS and signal polling (only when not in a call)
+    // Skip when paused to avoid Core 0 contention with WiFi/TLS.
+    // The modem task's sendAT() calls (AT+CMGL 5s, AT+CSQ 2s) do
+    // tight UART poll loops that disrupt WiFi packet timing.
     // ================================================================
-    if (!isCallActive()) {
+    if (!_paused && !isCallActive()) {
       // Check for outgoing SMS in queue
       SMSOutgoing outMsg;
       if (xQueueReceive(_sendQueue, &outMsg, 0) == pdTRUE) {
@@ -766,7 +929,7 @@ restart:
     }
 
     // Periodic signal strength update (always, even during calls)
-    if (millis() - lastCSQPoll > CSQ_POLL_INTERVAL) {
+    if (!_paused && millis() - lastCSQPoll > CSQ_POLL_INTERVAL) {
       // Only poll CSQ if not actively in a call (avoid interrupting audio)
       if (!isCallActive()) {
         pollCSQ();

examples/companion_radio/ui-new/ModemManager.h

@@ -22,6 +22,7 @@
 #include <freertos/queue.h>
 #include <freertos/semphr.h>
 #include "variant.h"
+#include "ApnDatabase.h"
 
 // ---------------------------------------------------------------------------
 // Modem pins (from variant.h, always defined for reference)
@@ -158,6 +159,28 @@ public:
   const char* getCallPhone() const { return _callPhone; }
   uint32_t getCallStartTime() const { return _callStartTime; }
 
+  // --- Device info (populated during init) ---
+  const char* getIMEI() const { return _imei; }
+  const char* getIMSI() const { return _imsi; }
+  const char* getAPN() const { return _apn; }
+  const char* getAPNSource() const { return _apnSource; }  // "auto", "network", "user", "none"
+
+  // --- APN configuration ---
+  // Set APN manually (overrides auto-detection). Persists to SD.
+  void setAPN(const char* apn);
+  // Load user-configured APN from SD card. Returns true if found.
+  static bool loadAPNConfig(char* apnOut, int maxLen);
+  // Save user-configured APN to SD card.
+  static void saveAPNConfig(const char* apn);
+
+  // Pause/resume polling — used by web reader to avoid Core 0 contention
+  // during WiFi TLS handshakes.  While paused, the task skips AT commands
+  // (SMS poll, CSQ poll) but still drains URCs and handles call commands
+  // so incoming calls aren't missed.
+  void pausePolling()  { _paused = true; }
+  void resumePolling() { _paused = false; }
+  bool isPaused() const { return _paused; }
+
   static const char* stateToString(ModemState s);
 
   // Persistent enable/disable config (SD file /sms/modem.cfg)
@@ -167,8 +190,15 @@ public:
 private:
   volatile ModemState _state = ModemState::OFF;
   volatile int _csq = 99;    // 99 = unknown
+  volatile bool _paused = false;  // Suppresses AT polling when true
   char _operator[24] = {0};
 
+  // Device identity (populated during Phase 2 init)
+  char _imei[20] = {0};      // IMEI from AT+GSN
+  char _imsi[20] = {0};      // IMSI from AT+CIMI (for APN lookup)
+  char _apn[64] = {0};       // Active APN
+  char _apnSource[8] = {0};  // "auto", "network", "user", "none"
+
   // Call state (written by modem task, read by main loop)
   char _callPhone[SMS_PHONE_LEN] = {0};  // Current call number
   volatile uint32_t _callStartTime = 0;    // millis() when call connected
@@ -202,6 +232,9 @@ private:
   void drainURCs();                // Read available UART data, process complete lines
   void processURCLine(const char* line);  // Handle a single URC line
 
+  // APN resolution (called from modem task during init)
+  void resolveAPN();              // Auto-detect APN from network/IMSI/user config
+
   // Call control (called from modem task)
   bool doDialCall(const char* phone);
   bool doAnswerCall();

examples/companion_radio/ui-new/Settingsscreen.h

@@ -69,6 +69,11 @@ enum SettingsRowType : uint8_t {
   ROW_INFO_HEADER,    // "--- Info ---" separator
   ROW_PUB_KEY,        // Public key display
   ROW_FIRMWARE,       // Firmware version
+  #ifdef HAS_4G_MODEM
+  ROW_IMEI,           // IMEI display (read-only)
+  ROW_OPERATOR_INFO,  // Carrier/operator display (read-only)
+  ROW_APN,            // APN setting (editable)
+  #endif
 };
 
 // ---------------------------------------------------------------------------
@@ -83,7 +88,11 @@ enum EditMode : uint8_t {
 };
 
 // Max rows in the settings list
+#ifdef HAS_4G_MODEM
+#define SETTINGS_MAX_ROWS 46  // Extra rows for IMEI, Carrier, APN
+#else
 #define SETTINGS_MAX_ROWS 40
+#endif
 #define SETTINGS_TEXT_BUF  33  // 32 chars + null
 
 class SettingsScreen : public UIScreen {
@@ -160,6 +169,12 @@ private:
     addRow(ROW_PUB_KEY);
     addRow(ROW_FIRMWARE);
 
+    #ifdef HAS_4G_MODEM
+    addRow(ROW_IMEI);
+    addRow(ROW_OPERATOR_INFO);
+    addRow(ROW_APN);
+    #endif
+
     // Clamp cursor
     if (_cursor >= _numRows) _cursor = _numRows - 1;
     if (_cursor < 0) _cursor = 0;
@@ -177,7 +192,11 @@ private:
   bool isSelectable(int idx) const {
     if (idx < 0 || idx >= _numRows) return false;
     SettingsRowType t = _rows[idx].type;
-    return t != ROW_CH_HEADER && t != ROW_INFO_HEADER;
+    return t != ROW_CH_HEADER && t != ROW_INFO_HEADER
+    #ifdef HAS_4G_MODEM
+      && t != ROW_IMEI && t != ROW_OPERATOR_INFO
+    #endif
+    ;
   }
 
   void skipNonSelectable(int dir) {
@@ -548,7 +567,7 @@ public:
           // Show first 8 bytes of pub key as hex (16 chars)
           char hexBuf[17];
           mesh::Utils::toHex(hexBuf, the_mesh.self_id.pub_key, 8);
-          snprintf(tmp, sizeof(tmp), "ID: %s", hexBuf);
+          snprintf(tmp, sizeof(tmp), "Node ID: %s", hexBuf);
           display.print(tmp);
           break;
         }
@@ -557,6 +576,53 @@ public:
           snprintf(tmp, sizeof(tmp), "FW: %s", FIRMWARE_VERSION);
           display.print(tmp);
           break;
+
+        #ifdef HAS_4G_MODEM
+        case ROW_IMEI: {
+          const char* imei = modemManager.getIMEI();
+          snprintf(tmp, sizeof(tmp), "IMEI: %s", imei[0] ? imei : "(unavailable)");
+          display.print(tmp);
+          break;
+        }
+
+        case ROW_OPERATOR_INFO: {
+          const char* op = modemManager.getOperator();
+          int bars = modemManager.getSignalBars();
+          if (op[0]) {
+            // Show carrier name with signal bar count
+            snprintf(tmp, sizeof(tmp), "Carrier: %s (%d/5)", op, bars);
+          } else {
+            snprintf(tmp, sizeof(tmp), "Carrier: (searching)");
+          }
+          display.print(tmp);
+          break;
+        }
+
+        case ROW_APN: {
+          if (editing && _editMode == EDIT_TEXT) {
+            snprintf(tmp, sizeof(tmp), "APN: %s_", _editBuf);
+          } else {
+            const char* apn = modemManager.getAPN();
+            const char* src = modemManager.getAPNSource();
+            if (apn[0]) {
+              // Truncate APN to fit: "APN: " (5) + apn (max 28) + " [x]" (4) = ~37 chars
+              char apnShort[29];
+              strncpy(apnShort, apn, 28);
+              apnShort[28] = '\0';
+              // Abbreviate source: auto→A, network→N, user→U, none→?
+              char srcChar = '?';
+              if (strcmp(src, "auto") == 0) srcChar = 'A';
+              else if (strcmp(src, "network") == 0) srcChar = 'N';
+              else if (strcmp(src, "user") == 0) srcChar = 'U';
+              snprintf(tmp, sizeof(tmp), "APN: %s [%c]", apnShort, srcChar);
+            } else {
+              snprintf(tmp, sizeof(tmp), "APN: (none)");
+            }
+          }
+          display.print(tmp);
+          break;
+        }
+        #endif
       }
 
       y += lineHeight;
@@ -673,6 +739,20 @@ public:
           }
           _editMode = EDIT_NONE;
         }
+        #ifdef HAS_4G_MODEM
+        else if (type == ROW_APN) {
+          // Save the edited APN (even if empty — clears user override)
+          if (_editPos > 0) {
+            modemManager.setAPN(_editBuf);
+            Serial.printf("Settings: APN set to '%s'\n", _editBuf);
+          } else {
+            // Empty APN: remove user override, revert to auto-detection
+            ModemManager::saveAPNConfig("");
+            Serial.println("Settings: APN cleared (will auto-detect on next boot)");
+          }
+          _editMode = EDIT_NONE;
+        }
+        #endif
         return true;
       }
       if (c == 'q' || c == 'Q' || c == 27) {
@@ -876,6 +956,12 @@ public:
             Serial.println("Settings: 4G modem DISABLED (shutdown)");
           }
           break;
+        case ROW_APN: {
+          // Start text editing with current APN as initial value
+          const char* currentApn = modemManager.getAPN();
+          startEditText(currentApn);
+          break;
+        }
         #endif
         case ROW_ADD_CHANNEL:
           startEditText("");

examples/companion_radio/ui-new/Touchinput.h

@@ -0,0 +1,128 @@
+#pragma once
+
+// =============================================================================
+// TouchInput - Minimal CST328/CST3530 touch driver for T-Deck Pro
+//
+// Uses raw I2C reads on the shared Wire bus. No external library needed.
+// Protocol confirmed via raw serial capture from actual hardware:
+//
+//   Register 0xD000, 7 bytes:
+//   buf[0]: event flags (0xAB = idle/no touch, other = active touch)
+//   buf[1]: X coordinate high data
+//   buf[2]: Y coordinate high data
+//   buf[3]: X low nibble (bits 7:4) | Y low nibble (bits 3:0)
+//   buf[4]: pressure
+//   buf[5]: touch count (& 0x7F), typically 0x01 for single touch
+//   buf[6]: 0xAB always (check byte, ignore)
+//
+//   Coordinate formula:
+//     x = (buf[1] << 4) | ((buf[3] >> 4) & 0x0F)   → 0..239
+//     y = (buf[2] << 4) | (buf[3] & 0x0F)           → 0..319
+//
+// Hardware: CST328 at 0x1A, INT=GPIO12, RST=GPIO38 (V1.1)
+//
+// Guard: HAS_TOUCHSCREEN
+// =============================================================================
+
+#ifdef HAS_TOUCHSCREEN
+
+#ifndef TOUCH_INPUT_H
+#define TOUCH_INPUT_H
+
+#include <Arduino.h>
+#include <Wire.h>
+
+class TouchInput {
+public:
+  static const uint8_t TOUCH_ADDR = 0x1A;
+
+  TouchInput(TwoWire* wire = &Wire)
+    : _wire(wire), _intPin(-1), _initialized(false), _debugCount(0), _lastPoll(0) {}
+
+  bool begin(int intPin) {
+    _intPin = intPin;
+    pinMode(_intPin, INPUT);
+
+    // Verify the touch controller is present on the bus
+    _wire->beginTransmission(TOUCH_ADDR);
+    uint8_t err = _wire->endTransmission();
+    if (err != 0) {
+      Serial.printf("[Touch] CST328 not found at 0x%02X (err=%d)\n", TOUCH_ADDR, err);
+      return false;
+    }
+
+    Serial.printf("[Touch] CST328 found at 0x%02X, INT=GPIO%d\n", TOUCH_ADDR, _intPin);
+    _initialized = true;
+    return true;
+  }
+
+  bool isReady() const { return _initialized; }
+
+  // Poll for touch. Returns true if a finger is down, fills x and y.
+  // Coordinates are in physical display space (0-239 X, 0-319 Y).
+  // NOTE: CST328 INT pin is pulse-based, not level. We cannot rely on
+  // digitalRead(INT) for touch state. Instead, always read and check buf[0].
+  bool getPoint(int16_t &x, int16_t &y) {
+    if (!_initialized) return false;
+
+    // Rate limit: poll at most every 20ms (50 Hz) to avoid I2C bus congestion
+    unsigned long now = millis();
+    if (now - _lastPoll < 20) return false;
+    _lastPoll = now;
+
+    uint8_t buf[7];
+    memset(buf, 0, sizeof(buf));
+
+    // Write register address 0xD000
+    _wire->beginTransmission(TOUCH_ADDR);
+    _wire->write(0xD0);
+    _wire->write(0x00);
+    if (_wire->endTransmission(false) != 0) return false;
+
+    // Read 7 bytes of touch data
+    uint8_t received = _wire->requestFrom(TOUCH_ADDR, (uint8_t)7);
+    if (received < 7) return false;
+    for (int i = 0; i < 7; i++) buf[i] = _wire->read();
+
+    // buf[0] == 0xAB means idle (no touch active)
+    if (buf[0] == 0xAB) return false;
+
+    // buf[0] == 0x00 can appear on finger-up transition — ignore
+    if (buf[0] == 0x00) return false;
+
+    // Touch count from buf[5]
+    uint8_t count = buf[5] & 0x7F;
+    if (count == 0 || count > 5) return false;
+
+    // Parse coordinates (CST226/CST328 format confirmed by hardware capture)
+    //   x = (buf[1] << 4) | high nibble of buf[3]
+    //   y = (buf[2] << 4) | low nibble of buf[3]
+    int16_t tx = ((int16_t)buf[1] << 4) | ((buf[3] >> 4) & 0x0F);
+    int16_t ty = ((int16_t)buf[2] << 4) | (buf[3] & 0x0F);
+
+    // Sanity check (panel is 240x320)
+    if (tx < 0 || tx > 260 || ty < 0 || ty > 340) return false;
+
+    // Debug: log first 20 touch events with parsed coordinates
+    if (_debugCount < 50) {
+      Serial.printf("[Touch] Raw: %02X %02X %02X %02X %02X %02X %02X → x=%d y=%d\n",
+                    buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6],
+                    tx, ty);
+      _debugCount++;
+    }
+
+    x = tx;
+    y = ty;
+    return true;
+  }
+
+private:
+  TwoWire* _wire;
+  int _intPin;
+  bool _initialized;
+  int _debugCount;
+  unsigned long _lastPoll;
+};
+
+#endif // TOUCH_INPUT_H
+#endif // HAS_TOUCHSCREEN

examples/companion_radio/ui-new/UITask.cpp

@@ -297,7 +297,7 @@ public:
       int y = 20;
       display.setColor(DisplayDriver::YELLOW);
       display.setTextSize(2);
-      sprintf(tmp, "MSG: %d", _task->getMsgCount());
+      sprintf(tmp, "MSG: %d", _task->getUnreadMsgCount());
       display.drawTextCentered(display.width() / 2, y, tmp);
       y += 18;
 
@@ -336,7 +336,7 @@ public:
       display.drawTextCentered(display.width() / 2, y, "[N] Notes       [S] Settings  ");
       y += 10;
 #ifdef HAS_4G_MODEM
-      display.drawTextCentered(display.width() / 2, y, "[E] Reader      [T] Phone       ");
+      display.drawTextCentered(display.width() / 2, y, "[E] Reader      [T] Phone     ");
 #elif defined(MECK_AUDIO_VARIANT)
       display.drawTextCentered(display.width() / 2, y, "[E] Reader      [P] Audiobooks");
 #else
@@ -642,8 +642,11 @@ public:
       display.drawTextRightAlign(display.width()-1, y, buf);
       y += 10;
 
-      // Remaining capacity
+      // Remaining capacity (clamped to design capacity — gauge FCC may be
+      // stale from factory defaults until a full charge cycle re-learns it)
       uint16_t remCap = board.getRemainingCapacity();
+      uint16_t desCap = board.getDesignCapacity();
+      if (desCap > 0 && remCap > desCap) remCap = desCap;
       display.drawTextLeftAlign(0, y, "remaining cap");
       sprintf(buf, "%d mAh", remCap);
       display.drawTextRightAlign(display.width()-1, y, buf);
@@ -982,6 +985,13 @@ void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, i
   // Add to channel history screen with channel index and path data
   ((ChannelScreen *) channel_screen)->addMessage(channel_idx, path_len, from_name, text, path);
   
+  // If user is currently viewing this channel, mark it as read immediately
+  // (they can see the message arrive in real-time)
+  if (isOnChannelScreen() && 
+      ((ChannelScreen *) channel_screen)->getViewChannelIdx() == channel_idx) {
+    ((ChannelScreen *) channel_screen)->markChannelRead(channel_idx);
+  }
+  
 #if defined(LilyGo_TDeck_Pro)
   // T-Deck Pro: Don't interrupt user with popup - just show brief notification
   // Messages are stored in channel history, accessible via 'M' key
@@ -1362,6 +1372,10 @@ bool UITask::isEditingHomeScreen() const {
 
 void UITask::gotoChannelScreen() {
   ((ChannelScreen *) channel_screen)->resetScroll();
+  // Mark the currently viewed channel as read
+  ((ChannelScreen *) channel_screen)->markChannelRead(
+    ((ChannelScreen *) channel_screen)->getViewChannelIdx()
+  );
   setCurrScreen(channel_screen);
   if (_display != NULL && !_display->isOn()) {
     _display->turnOn();
@@ -1459,6 +1473,10 @@ uint8_t UITask::getChannelScreenViewIdx() const {
   return ((ChannelScreen *) channel_screen)->getViewChannelIdx();
 }
 
+int UITask::getUnreadMsgCount() const {
+  return ((ChannelScreen *) channel_screen)->getTotalUnread();
+}
+
 void UITask::addSentChannelMessage(uint8_t channel_idx, const char* sender, const char* text) {
   // Format the message as "Sender: message"
   char formattedMsg[CHANNEL_MSG_TEXT_LEN];
@@ -1506,6 +1524,9 @@ void UITask::gotoWebReader() {
   if (_display != NULL) {
     wr->enter(*_display);
   }
+  // Heap diagnostic — check state after web reader entry (WiFi connects later)
+  Serial.printf("[HEAP] WebReader enter - free: %u, largest: %u, PSRAM: %u\n",
+      ESP.getFreeHeap(), ESP.getMaxAllocHeap(), ESP.getFreePsram());
   setCurrScreen(web_reader);
   if (_display != NULL && !_display->isOn()) {
     _display->turnOn();

examples/companion_radio/ui-new/UITask.h

@@ -114,7 +114,14 @@ public:
 #endif
   void showAlert(const char* text, int duration_millis) override;
   void forceRefresh() override { _next_refresh = 100; }
+  // Wake display and extend auto-off timer. Call this when handling keys
+  // outside of injectKey() to prevent display auto-off during direct input.
+  void keepAlive() {
+    if (_display != NULL && !_display->isOn()) _display->turnOn();
+    _auto_off = millis() + 15000;  // matches AUTO_OFF_MILLIS default
+  }
   int  getMsgCount() const { return _msgcount; }
+  int  getUnreadMsgCount() const;  // Per-channel unread tracking (standalone)
   bool hasDisplay() const { return _display != NULL; }
   bool isButtonPressed() const;
   bool isOnChannelScreen() const { return curr == channel_screen; }

examples/companion_radio/ui-new/emojipicker.h

@@ -1,7 +1,7 @@
 #pragma once
 
 // Emoji Picker with scrolling grid and scroll bar
-// 5 columns, 4 visible rows, scrollable through all 46 emoji
+// 5 columns, 4 visible rows, scrollable through all 65 emoji
 // WASD navigation, Enter to select, $/Q/Backspace to cancel
 
 #include <helpers/ui/DisplayDriver.h>
@@ -58,6 +58,25 @@ static const char* EMOJI_LABELS[EMOJI_COUNT] = {
   "Knob",   // 43 control_knobs
   "Pch",    // 44 peach
   "Race",   // 45 racing_car
+  "Mous",   // 46 mouse
+  "Shrm",   // 47 mushroom
+  "Bio",    // 48 biohazard
+  "Pnda",   // 49 panda
+  "Bang",   // 50 anger
+  "DrgF",   // 51 dragon_face
+  "Pagr",   // 52 pager
+  "Bee",    // 53 bee
+  "Bulb",   // 54 bulb
+  "Cat",    // 55 cat
+  "Flur",   // 56 fleur
+  "Moon",   // 57 moon
+  "Cafe",   // 58 coffee
+  "Toth",   // 59 tooth
+  "Prtz",   // 60 pretzel
+  "Abac",   // 61 abacus
+  "Moai",   // 62 moai
+  "Hiii",   // 63 tipping
+  "Hedg",   // 64 hedgehog
 };
 
 struct EmojiPicker {

src/helpers/BaseChatMesh.h

@@ -58,9 +58,9 @@ class BaseChatMesh : public mesh::Mesh {
 
   friend class ContactsIterator;
 
-  ContactInfo contacts[MAX_CONTACTS];
+  ContactInfo* contacts;
   int num_contacts;
-  int sort_array[MAX_CONTACTS];
+  int* sort_array;
   int matching_peer_indexes[MAX_SEARCH_RESULTS];
   unsigned long txt_send_timeout;
 #ifdef MAX_GROUP_CHANNELS
@@ -78,6 +78,8 @@ protected:
   BaseChatMesh(mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::PacketManager& mgr, mesh::MeshTables& tables)
       : mesh::Mesh(radio, ms, rng, rtc, mgr, tables)
   { 
+    contacts = NULL;
+    sort_array = NULL;
     num_contacts = 0;
   #ifdef MAX_GROUP_CHANNELS
     memset(channels, 0, sizeof(channels));
@@ -90,6 +92,19 @@ protected:
 
   void bootstrapRTCfromContacts();
   void resetContacts() { num_contacts = 0; }
+
+  // Must be called from begin() before loadContacts/bootstrapRTCfromContacts.
+  // Deferred from constructor because PSRAM is not available during global init.
+  void initContacts() {
+    if (contacts != NULL) return;  // already initialized
+  #if defined(ESP32) && defined(BOARD_HAS_PSRAM)
+    contacts = (ContactInfo*)ps_calloc(MAX_CONTACTS, sizeof(ContactInfo));
+    sort_array = (int*)ps_calloc(MAX_CONTACTS, sizeof(int));
+  #else
+    contacts = new ContactInfo[MAX_CONTACTS]();
+    sort_array = new int[MAX_CONTACTS]();
+  #endif
+  }
   void populateContactFromAdvert(ContactInfo& ci, const mesh::Identity& id, const AdvertDataParser& parser, uint32_t timestamp);
   ContactInfo* allocateContactSlot(); // helper to find slot for new contact
 
@@ -169,4 +184,4 @@ public:
   int findChannelIdx(const mesh::GroupChannel& ch);
 
   void loop();
-};
+};

src/helpers/esp32/SerialBLEInterface.cpp

@@ -147,15 +147,21 @@ void SerialBLEInterface::enable() {
 }
 
 void SerialBLEInterface::disable() {
+  bool wasEnabled = _isEnabled;
   _isEnabled = false;
 
   BLE_DEBUG_PRINTLN("SerialBLEInterface::disable");
 
-  pServer->getAdvertising()->stop();
-  pServer->disconnect(last_conn_id);
-  pService->stop();
+  // Only try BLE operations if we were previously enabled
+  // (avoids accessing dead BLE objects after btStop/mem_release)
+  if (wasEnabled && pServer) {
+    pServer->getAdvertising()->stop();
+    pServer->disconnect(last_conn_id);
+    pService->stop();
+  }
   oldDeviceConnected = deviceConnected = false;
   adv_restart_time = 0;
+  clearBuffers();
 }
 
 size_t SerialBLEInterface::writeFrame(const uint8_t src[], size_t len) {
@@ -186,6 +192,8 @@ bool SerialBLEInterface::isWriteBusy() const {
 }
 
 size_t SerialBLEInterface::checkRecvFrame(uint8_t dest[]) {
+  if (!_isEnabled) return 0;  // BLE disabled — skip all BLE operations
+
   if (send_queue_len > 0   // first, check send queue
     && millis() >= _last_write + BLE_WRITE_MIN_INTERVAL    // space the writes apart
   ) {

variants/lilygo_tdeck_pro/TDeckBoard.cpp

@@ -177,7 +177,85 @@ bool TDeckBoard::configureFuelGauge(uint16_t designCapacity_mAh) {
   Serial.printf("BQ27220: Design Capacity = %d mAh (target %d)\n", currentDC, designCapacity_mAh);
 
   if (currentDC == designCapacity_mAh) {
-    Serial.println("BQ27220: Design Capacity already correct, skipping");
+    // Design Capacity correct, but check if Full Charge Capacity is sane.
+    // After a Design Capacity change, FCC may still hold the old factory
+    // value (e.g. 3000 mAh) until a RESET forces reinitialization.
+    uint16_t fcc = bq27220_read16(BQ27220_REG_FULL_CAP);
+    Serial.printf("BQ27220: Design Capacity already correct, FCC=%d mAh\n", fcc);
+    if (fcc >= designCapacity_mAh * 3 / 2) {
+      // FCC is >=150% of design — stale from factory defaults.
+      // The gauge derives FCC from Design Energy (not just Design Capacity).
+      // Design Energy = capacity × nominal voltage (3.7V for LiPo).
+      // If Design Energy still reflects 3000 mAh, FCC stays at 3000.
+      // Fix: enter CFG_UPDATE and write correct Design Energy.
+      Serial.printf("BQ27220: FCC %d >> DC %d, updating Design Energy\n",
+                    fcc, designCapacity_mAh);
+
+      uint16_t designEnergy = (uint16_t)((uint32_t)designCapacity_mAh * 37 / 10);
+      Serial.printf("BQ27220: Target Design Energy = %d mWh\n", designEnergy);
+
+      // Unseal
+      bq27220_writeControl(0x0414); delay(2);
+      bq27220_writeControl(0x3672); delay(2);
+      // Full Access
+      bq27220_writeControl(0xFFFF); delay(2);
+      bq27220_writeControl(0xFFFF); delay(2);
+      // Enter CFG_UPDATE
+      bq27220_writeControl(0x0090);
+      bool ready = false;
+      for (int i = 0; i < 50; i++) {
+        delay(20);
+        uint16_t opSt = bq27220_read16(BQ27220_REG_OP_STATUS);
+        if (opSt & 0x0400) { ready = true; break; }
+      }
+      if (ready) {
+        // Design Energy is at data memory address 0x92A1 (2 bytes after DC at 0x929F)
+        // Read old values for checksum calculation
+        Wire.beginTransmission(BQ27220_I2C_ADDR);
+        Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
+        Wire.endTransmission();
+        delay(10);
+        uint8_t oldMSB = bq27220_read8(0x40);
+        uint8_t oldLSB = bq27220_read8(0x41);
+        uint8_t oldChk = bq27220_read8(0x60);
+        uint8_t dLen   = bq27220_read8(0x61);
+
+        uint8_t newMSB = (designEnergy >> 8) & 0xFF;
+        uint8_t newLSB = designEnergy & 0xFF;
+        uint8_t temp = (255 - oldChk - oldMSB - oldLSB);
+        uint8_t newChk = 255 - ((temp + newMSB + newLSB) & 0xFF);
+
+        Serial.printf("BQ27220: DE old=0x%02X%02X new=0x%02X%02X chk=0x%02X\n",
+                      oldMSB, oldLSB, newMSB, newLSB, newChk);
+
+        // Write new Design Energy
+        Wire.beginTransmission(BQ27220_I2C_ADDR);
+        Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
+        Wire.write(newMSB); Wire.write(newLSB);
+        Wire.endTransmission();
+        delay(5);
+        // Write checksum
+        Wire.beginTransmission(BQ27220_I2C_ADDR);
+        Wire.write(0x60); Wire.write(newChk); Wire.write(dLen);
+        Wire.endTransmission();
+        delay(10);
+
+        // Exit CFG_UPDATE with reinit
+        bq27220_writeControl(0x0091);
+        delay(200);
+        Serial.println("BQ27220: Design Energy updated, exited CFG_UPDATE");
+      } else {
+        Serial.println("BQ27220: Failed to enter CFG_UPDATE for DE fix");
+        bq27220_writeControl(0x0092);  // Exit cleanly
+      }
+
+      // Seal
+      bq27220_writeControl(0x0030);
+      delay(5);
+
+      fcc = bq27220_read16(BQ27220_REG_FULL_CAP);
+      Serial.printf("BQ27220: FCC after Design Energy update: %d mAh\n", fcc);
+    }
     return true;
   }
 
@@ -281,6 +359,39 @@ bool TDeckBoard::configureFuelGauge(uint16_t designCapacity_mAh) {
   Serial.printf("BQ27220: Verify in CFGUPDATE: DC bytes=0x%02X 0x%02X (%d mAh)\n",
                      verMSB, verLSB, (verMSB << 8) | verLSB);
 
+  // Step 4g: Also update Design Energy (address 0x92A1) while in CFG_UPDATE.
+  // Design Energy = capacity × 3.7V (nominal LiPo voltage).
+  // The gauge uses both DC and DE to compute Full Charge Capacity.
+  {
+    uint16_t designEnergy = (uint16_t)((uint32_t)designCapacity_mAh * 37 / 10);
+    Wire.beginTransmission(BQ27220_I2C_ADDR);
+    Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
+    Wire.endTransmission();
+    delay(10);
+    uint8_t deOldMSB = bq27220_read8(0x40);
+    uint8_t deOldLSB = bq27220_read8(0x41);
+    uint8_t deOldChk = bq27220_read8(0x60);
+    uint8_t deLen    = bq27220_read8(0x61);
+
+    uint8_t deNewMSB = (designEnergy >> 8) & 0xFF;
+    uint8_t deNewLSB = designEnergy & 0xFF;
+    uint8_t deTemp = (255 - deOldChk - deOldMSB - deOldLSB);
+    uint8_t deNewChk = 255 - ((deTemp + deNewMSB + deNewLSB) & 0xFF);
+
+    Serial.printf("BQ27220: Design Energy: old=%d new=%d mWh\n",
+                  (deOldMSB << 8) | deOldLSB, designEnergy);
+
+    Wire.beginTransmission(BQ27220_I2C_ADDR);
+    Wire.write(0x3E); Wire.write(0xA1); Wire.write(0x92);
+    Wire.write(deNewMSB); Wire.write(deNewLSB);
+    Wire.endTransmission();
+    delay(5);
+    Wire.beginTransmission(BQ27220_I2C_ADDR);
+    Wire.write(0x60); Wire.write(deNewChk); Wire.write(deLen);
+    Wire.endTransmission();
+    delay(10);
+  }
+
   // Step 5: Exit CFG_UPDATE (with reinit to apply changes immediately)
   bq27220_writeControl(0x0091);  // EXIT_CFG_UPDATE_REINIT
   Serial.println("BQ27220: Sent EXIT_CFG_UPDATE_REINIT, waiting...");
@@ -291,13 +402,16 @@ bool TDeckBoard::configureFuelGauge(uint16_t designCapacity_mAh) {
   Serial.printf("BQ27220: Design Capacity now reads %d mAh (expected %d)\n",
                      verifyDC, designCapacity_mAh);
 
+  uint16_t newFCC = bq27220_read16(BQ27220_REG_FULL_CAP);
+  Serial.printf("BQ27220: Full Charge Capacity: %d mAh\n", newFCC);
+
   if (verifyDC == designCapacity_mAh) {
     Serial.println("BQ27220: Configuration SUCCESS");
   } else {
     Serial.println("BQ27220: Configuration FAILED");
   }
 
-  // Step 7: Seal the device
+  // Step 6: Seal the device
   bq27220_writeControl(0x0030);
   delay(5);
 

variants/lilygo_tdeck_pro/Tca8418keyboard.h

@@ -256,14 +256,12 @@ public:
       return KB_KEY_EMOJI;
     }
     
-    // Handle Mic key - produces 0 with Sym, otherwise ignore
+    // Handle Mic key - always produces '0' (silk-screened on key)
+    // Sym+Mic also produces '0' (consumes sym so it doesn't leak)
     if (keyCode == 34) {
-      if (_symActive) {
-        _symActive = false;
-        Serial.println("KB: Sym+Mic -> '0'");
-        return '0';
-      }
-      return 0;  // Ignore mic without Sym
+      _symActive = false;
+      Serial.println("KB: Mic -> '0'");
+      return '0';
     }
 
     // Get the character

variants/lilygo_tdeck_pro/platformio.ini

@@ -80,7 +80,6 @@ build_flags =
   -D PIN_DISPLAY_BL=45
   -D PIN_USER_BTN=0
   -D CST328_PIN_RST=38
-  -D FIRMWARE_VERSION='"Meck v0.9.3A"'
   -D ARDUINO_LOOP_STACK_SIZE=32768
 build_src_filter = ${esp32_base.build_src_filter}
   +<../variants/LilyGo_TDeck_Pro>
@@ -97,17 +96,18 @@ lib_deps =
 ; ---------------------------------------------------------------------------
 
 ; Audio + BLE companion (audio-player hardware with BLE phone bridging)
+; MAX_CONTACTS=500 is near BLE protocol ceiling (MAX_CONTACTS/2 sent as uint8_t, max 510)
 [env:meck_audio_ble]
 extends = LilyGo_TDeck_Pro
 build_flags =
   ${LilyGo_TDeck_Pro.build_flags}
   -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=400
+  -D MAX_CONTACTS=500
   -D MAX_GROUP_CHANNELS=20
   -D BLE_PIN_CODE=123456
   -D OFFLINE_QUEUE_SIZE=256
   -D MECK_AUDIO_VARIANT
-; -D MECK_WEB_READER=1
+  -D MECK_WEB_READER=1
 build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
   +<helpers/esp32/*.cpp>
   +<helpers/ui/MomentaryButton.cpp>
@@ -122,13 +122,14 @@ lib_deps =
 
 ; Audio standalone (audio-player hardware, no BLE/WiFi — maximum battery life)
 ; No MECK_WEB_READER: WiFi power draw conflicts with zero-radio-power design.
+; Contacts and sort arrays allocated in PSRAM — 1500 contacts uses ~290KB of 8MB.
 [env:meck_audio_standalone]
 extends = LilyGo_TDeck_Pro
 build_flags =
   ${LilyGo_TDeck_Pro.build_flags}
   -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=350
-  -D MAX_GROUP_CHANNELS=40
+  -D MAX_CONTACTS=1500
+  -D MAX_GROUP_CHANNELS=20
   -D OFFLINE_QUEUE_SIZE=256
   -D MECK_AUDIO_VARIANT
 build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
@@ -144,18 +145,45 @@ lib_deps =
   bitbank2/JPEGDEC
 
 ; 4G + BLE companion (4G modem hardware, no audio — GPIO conflict with PCM5102A)
+; MAX_CONTACTS=500 is near BLE protocol ceiling (MAX_CONTACTS/2 sent as uint8_t, max 510)
 [env:meck_4g_ble]
 extends = LilyGo_TDeck_Pro
 build_flags =
   ${LilyGo_TDeck_Pro.build_flags}
   -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=400
+  -D MAX_CONTACTS=500
   -D MAX_GROUP_CHANNELS=20
   -D BLE_PIN_CODE=123456
   -D OFFLINE_QUEUE_SIZE=256
   -D HAS_4G_MODEM=1
-;  -D MECK_WEB_READER=1
-  -D FIRMWARE_VERSION='"Meck v0.9.3-4G"'
+  -D MECK_WEB_READER=1
+  -D FIRMWARE_VERSION='"Meck v0.9.5.4G"'
+build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/MomentaryButton.cpp>
+  +<../examples/companion_radio/*.cpp>
+  +<../examples/companion_radio/ui-new/*.cpp>
+  +<helpers/ui/GxEPDDisplay.cpp>
+lib_deps =
+  ${LilyGo_TDeck_Pro.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+; 4G standalone (4G modem hardware, no BLE — maximum battery + cellular features)
+; No BLE_PIN_CODE: BLE never initializes, saving ~30KB heap + radio power.
+; MECK_WEB_READER enabled: works better without BLE (no teardown dance needed,
+; more free heap from boot). WiFi-first with cellular PPP fallback (future).
+; Contacts and sort arrays allocated in PSRAM — 1500 contacts uses ~290KB of 8MB.
+[env:meck_4g_standalone]
+extends = LilyGo_TDeck_Pro
+build_flags =
+  ${LilyGo_TDeck_Pro.build_flags}
+  -I examples/companion_radio/ui-new
+  -D MAX_CONTACTS=1500
+  -D MAX_GROUP_CHANNELS=20
+  -D OFFLINE_QUEUE_SIZE=256
+  -D HAS_4G_MODEM=1
+  -D MECK_WEB_READER=1
+  -D FIRMWARE_VERSION='"Meck v0.9.5.4G.SA"'
 build_src_filter = ${LilyGo_TDeck_Pro.build_src_filter}
   +<helpers/esp32/*.cpp>
   +<helpers/ui/MomentaryButton.cpp>