Fix geohash UX: rising-edge notify, correct teleport, sort timeline

- Remove "new chats!" background nudge; notify only when a regional geohash goes from 0 participants to activity, with content preview and cooldown.\n- Do not mark teleported when selected geohash is in regional channel list; clear persisted teleport when in-region; avoid self teleported state from historical tags; deep links don’t mark teleported for regional geohashes or during cold start.\n- Sort per-geohash timelines chronologically on re-entry and trim whitespace-only content to prevent blank lines.\n- Trim inbound public content and ignore whitespace-only sends.

README.md

@@ -2,59 +2,108 @@
 
 ## bitchat
 
-A decentralized peer-to-peer messaging app that works over Bluetooth mesh networks. No internet required, no servers, no phone numbers. It's the side-groupchat. 
+A decentralized peer-to-peer messaging app with dual transport architecture: local Bluetooth mesh networks for offline communication and internet-based Nostr protocol for global reach. No accounts, no phone numbers, no central servers. It's the side-groupchat.
 
 [bitchat.free](http://bitchat.free)
 
 📲 [App Store](https://apps.apple.com/us/app/bitchat-mesh/id6748219622)
 
 > [!WARNING]
-> Private messages have not received external security review and may contain vulnerabilities. Do not use for sensitive use cases, and do not rely on its security until it has been reviewed. Now uses the [Noise Protocol](http://www.noiseprotocol.org) for identity and encryption. Public local chat (the main feature) has no security concerns. 
-
+> Private messages have not received external security review and may contain vulnerabilities. Do not use for sensitive use cases, and do not rely on its security until it has been reviewed. Now uses the [Noise Protocol](http://www.noiseprotocol.org) for identity and encryption. Public local chat (the main feature) has no security concerns.
 
 ## License
 
 This project is released into the public domain. See the [LICENSE](LICENSE) file for details.
 
-
 ## Features
 
+- **Dual Transport Architecture**: Bluetooth mesh for offline + Nostr protocol for internet-based messaging
+- **Location-Based Channels**: Geographic chat rooms using geohash coordinates over global Nostr relays
+- **Intelligent Message Routing**: Automatically chooses best transport (Bluetooth → Nostr fallback)
 - **Decentralized Mesh Network**: Automatic peer discovery and multi-hop message relay over Bluetooth LE
 - **Privacy First**: No accounts, no phone numbers, no persistent identifiers
-- **Private Message End-to-End Encryption**: [Noise Protocol](http://noiseprotocol.org)
+- **Private Message End-to-End Encryption**: [Noise Protocol](http://noiseprotocol.org) for mesh, NIP-17 for Nostr
 - **IRC-Style Commands**: Familiar `/slap`, `/msg`, `/who` style interface
 - **Universal App**: Native support for iOS and macOS
 - **Emergency Wipe**: Triple-tap to instantly clear all data
 - **Performance Optimizations**: LZ4 message compression, adaptive battery modes, and optimized networking
 
-
 ## [Technical Architecture](https://deepwiki.com/permissionlesstech/bitchat)
 
-### Binary Protocol
-bitchat uses an efficient binary protocol optimized for Bluetooth LE:
-- Compact packet format with 1-byte type field
-- TTL-based message routing (max 7 hops)
-- Automatic fragmentation for large messages
-- Message deduplication via unique IDs
+BitChat uses a **hybrid messaging architecture** with two complementary transport layers:
 
-### Mesh Networking
-- Each device acts as both client and peripheral
-- Automatic peer discovery and connection management
-- Adaptive duty cycling for battery optimization
+### Bluetooth Mesh Network (Offline)
+
+- **Local Communication**: Direct peer-to-peer within Bluetooth range
+- **Multi-hop Relay**: Messages route through nearby devices (max 7 hops)
+- **No Internet Required**: Works completely offline in disaster scenarios
+- **Noise Protocol Encryption**: End-to-end encryption with forward secrecy
+- **Binary Protocol**: Compact packet format optimized for Bluetooth LE constraints
+- **Automatic Discovery**: Peer discovery and connection management
+- **Adaptive Power**: Battery-optimized duty cycling
+
+### Nostr Protocol (Internet)
+
+- **Global Reach**: Connect with users worldwide via internet relays
+- **Location Channels**: Geographic chat rooms using geohash coordinates
+- **290+ Relay Network**: Distributed across the globe for reliability
+- **NIP-17 Encryption**: Gift-wrapped private messages for internet privacy
+- **Ephemeral Keys**: Fresh cryptographic identity per geohash area
+
+### Channel Types
+
+#### `mesh #bluetooth`
+
+- **Transport**: Bluetooth Low Energy mesh network
+- **Scope**: Local devices within multi-hop range
+- **Internet**: Not required
+- **Use Case**: Offline communication, protests, disasters, remote areas
+
+#### Location Channels (`block #dr5rsj7`, `neighborhood #dr5rs`, `country #dr`)
+
+- **Transport**: Nostr protocol over internet
+- **Scope**: Geographic areas defined by geohash precision
+  - `block` (7 chars): City block level
+  - `neighborhood` (6 chars): District/neighborhood
+  - `city` (5 chars): City level
+  - `province` (4 chars): State/province
+  - `region` (2 chars): Country/large region
+- **Internet**: Required (connects to Nostr relays)
+- **Use Case**: Location-based community chat, local events, regional discussions
+
+### Direct Message Routing
+
+Private messages use **intelligent transport selection**:
+
+1. **Bluetooth First** (preferred when available)
+
+   - Direct connection with established Noise session
+   - Fastest and most private option
+
+2. **Nostr Fallback** (when Bluetooth unavailable)
+
+   - Uses recipient's Nostr public key
+   - NIP-17 gift-wrapping for privacy
+   - Routes through global relay network
+
+3. **Smart Queuing** (when neither available)
+   - Messages queued until transport becomes available
+   - Automatic delivery when connection established
 
 For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.md).
 
-
 ## Setup
 
 ### Option 1: Using XcodeGen (Recommended)
 
 1. Install XcodeGen if you haven't already:
+
    ```bash
    brew install xcodegen
    ```
 
 2. Generate the Xcode project:
+
    ```bash
    cd bitchat
    xcodegen generate
@@ -68,6 +117,7 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 ### Option 2: Using Swift Package Manager
 
 1. Open the project in Xcode:
+
    ```bash
    cd bitchat
    open Package.swift
@@ -84,5 +134,5 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 
 ### Option 4: just
 
-Want to try this on macos: `just run` will set it up and run from source. 
+Want to try this on macos: `just run` will set it up and run from source.
 Run `just clean` afterwards to restore things to original state for mobile app building and development.

bitchat/BitchatApp.swift

@@ -173,6 +173,14 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
                 }
             }
         }
+        // Handle deeplink (e.g., geohash activity)
+        if let deep = userInfo["deeplink"] as? String, let url = URL(string: deep) {
+            #if os(iOS)
+            DispatchQueue.main.async { UIApplication.shared.open(url) }
+            #else
+            DispatchQueue.main.async { NSWorkspace.shared.open(url) }
+            #endif
+        }
         
         completionHandler()
     }
@@ -192,6 +200,15 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
                 }
             }
         }
+        // Suppress geohash activity notification if we're already in that geohash channel
+        if identifier.hasPrefix("geo-activity-"),
+           let deep = userInfo["deeplink"] as? String,
+           let gh = deep.components(separatedBy: "/").last {
+            if case .location(let ch) = LocationChannelManager.shared.selectedChannel, ch.geohash == gh {
+                completionHandler([])
+                return
+            }
+        }
         
         // Show notification in all other cases
         completionHandler([.banner, .sound])

bitchat/Services/LocationChannelManager.swift

@@ -50,10 +50,8 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
            let arr = try? JSONDecoder().decode([String].self, from: data) {
             teleportedSet = Set(arr)
         }
-        // Initialize teleported flag from persisted state if a location channel is selected
-        if case .location(let ch) = selectedChannel {
-            teleported = teleportedSet.contains(ch.geohash)
-        }
+        // Do not eagerly mark teleported on startup; wait for location to compute regional set.
+        // This avoids showing teleported for in-region channels during cold start.
         let status: CLAuthorizationStatus
         if #available(iOS 14.0, macOS 11.0, *) {
             status = cl.authorizationStatus
@@ -61,6 +59,15 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
             status = CLLocationManager.authorizationStatus()
         }
         updatePermissionState(from: status)
+        // If we don't have location authorization at startup, fall back to persisted teleport state
+        switch status {
+        case .authorizedAlways, .authorizedWhenInUse, .authorized:
+            break // will compute from location
+        default:
+            if case .location(let ch) = selectedChannel {
+                teleported = teleportedSet.contains(ch.geohash)
+            }
+        }
     }
 
     // MARK: - Public API
@@ -92,23 +99,30 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         }
     }
 
-    /// Begin periodic one-shot location refreshes while a selector UI is visible.
+    /// Begin continuous, distance-filtered updates while the channel sheet is visible.
+    /// Uses a 21m filter (configurable) to only refresh on meaningful movement.
     func beginLiveRefresh(interval: TimeInterval = TransportConfig.locationLiveRefreshInterval) {
         guard permissionState == .authorized else { return }
-        // Switch to a lightweight periodic one-shot request (polling) while the sheet is open
+        // Stop any previous polling timer
         refreshTimer?.invalidate()
-        refreshTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
-            self?.requestOneShotLocation()
-        }
-        // Kick off immediately
+        refreshTimer = nil
+        // Tighten accuracy and distance filter for live view
+        cl.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterLiveMeters
+        // Start continuous updates
+        cl.startUpdatingLocation()
+        // Request an immediate fix to populate UI without waiting for movement
         requestOneShotLocation()
     }
 
-    /// Stop periodic refreshes when selector UI is dismissed.
+    /// Stop continuous refreshes when selector UI is dismissed.
     func endLiveRefresh() {
         refreshTimer?.invalidate()
         refreshTimer = nil
         cl.stopUpdatingLocation()
+        // Restore more relaxed defaults for background/idle state
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
     }
 
     func select(_ channel: ChannelID) {
@@ -122,7 +136,21 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
             case .mesh:
                 self.teleported = false
             case .location(let ch):
-                self.teleported = self.teleportedSet.contains(ch.geohash)
+                // If this geohash is in our current regional set, do NOT mark teleported.
+                let inRegional = self.availableChannels.contains { $0.geohash == ch.geohash }
+                if inRegional {
+                    self.teleported = false
+                    // Clear persisted teleport for this geohash to keep future selections clean
+                    if self.teleportedSet.contains(ch.geohash) {
+                        self.teleportedSet.remove(ch.geohash)
+                        if let data = try? JSONEncoder().encode(Array(self.teleportedSet)) {
+                            UserDefaults.standard.set(data, forKey: self.teleportedStoreKey)
+                        }
+                    }
+                } else {
+                    // Fall back to persisted mark (set by deep link or manual teleport)
+                    self.teleported = self.teleportedSet.contains(ch.geohash)
+                }
             }
         }
     }
@@ -195,14 +223,25 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         }
         Task { @MainActor in
             self.availableChannels = result
-            // Recompute teleported status based on persisted state OR current location vs selected channel
+            // Recompute teleported status based on whether the selected geohash is in our regional set
             switch self.selectedChannel {
             case .mesh:
                 self.teleported = false
             case .location(let ch):
-                let persisted = self.teleportedSet.contains(ch.geohash)
-                let currentGH = Geohash.encode(latitude: coord.latitude, longitude: coord.longitude, precision: ch.level.precision)
-                self.teleported = persisted || (currentGH != ch.geohash)
+                // Membership check using freshly computed regional channels; avoids precision/rename drift
+                let inRegional = result.contains { $0.geohash == ch.geohash }
+                if inRegional {
+                    self.teleported = false
+                    // Clear persisted teleport flag if present
+                    if self.teleportedSet.contains(ch.geohash) {
+                        self.teleportedSet.remove(ch.geohash)
+                        if let data = try? JSONEncoder().encode(Array(self.teleportedSet)) {
+                            UserDefaults.standard.set(data, forKey: self.teleportedStoreKey)
+                        }
+                    }
+                } else {
+                    self.teleported = true
+                }
             }
         }
     }

bitchat/Services/NotificationService.swift

@@ -90,6 +90,15 @@ class NotificationService {
         }
     }
     
+    // Geohash public chat notification with deep link to a specific geohash
+    func sendGeohashActivityNotification(geohash: String, titlePrefix: String = "#", bodyPreview: String) {
+        let title = "\(titlePrefix)\(geohash)"
+        let identifier = "geo-activity-\(geohash)-\(Date().timeIntervalSince1970)"
+        let deeplink = "bitchat://geohash/\(geohash)"
+        let userInfo: [String: Any] = ["deeplink": deeplink]
+        sendLocalNotification(title: title, body: bodyPreview, identifier: identifier, userInfo: userInfo)
+    }
+
     func sendNetworkAvailableNotification(peerCount: Int) {
         let title = "👥 bitchatters nearby!"
         let body = peerCount == 1 ? "1 person around" : "\(peerCount) people around"

bitchat/Services/TransportConfig.swift

@@ -100,8 +100,14 @@ enum TransportConfig {
 
     // Location
     static let locationDistanceFilterMeters: Double = 1000
+    // Live (channel sheet open) distance threshold for meaningful updates
+    static let locationDistanceFilterLiveMeters: Double = 21.0
     static let locationLiveRefreshInterval: TimeInterval = 5.0
 
+    // Notifications (geohash)
+    static let uiGeoNotifyCooldownSeconds: TimeInterval = 60.0
+    static let uiGeoNotifySnippetMaxLen: Int = 80
+
     // Nostr geohash
     static let nostrGeohashInitialLookbackSeconds: TimeInterval = 3600
     static let nostrGeohashInitialLimit: Int = 200
@@ -169,6 +175,10 @@ enum TransportConfig {
     // UI color tuning
     static let uiColorHueAvoidanceDelta: Double = 0.05
     static let uiColorHueOffset: Double = 0.12
+    // Peer list palette
+    static let uiPeerPaletteSlots: Int = 36
+    static let uiPeerPaletteRingBrightnessDeltaLight: Double = 0.07
+    static let uiPeerPaletteRingBrightnessDeltaDark: Double = -0.07
 
     // UI windowing (infinite scroll)
     static let uiWindowInitialCountPublic: Int = 300

bitchat/ViewModels/ChatViewModel.swift

@@ -402,6 +402,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     @Published private(set) var teleportedGeo: Set<String> = []  // lowercased pubkey hex
     // Sampling subscriptions for multiple geohashes (when channel sheet is open)
     private var geoSamplingSubs: [String: String] = [:] // subID -> geohash
+    private var lastGeoNotificationAt: [String: Date] = [:] // geohash -> last notify time
     
     // MARK: - Message Delivery Tracking
     
@@ -609,6 +610,50 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         Task { @MainActor in
             self.switchLocationChannel(to: LocationChannelManager.shared.selectedChannel)
         }
+
+        // Background: keep sampling nearby geohashes for notifications even when sheet is closed
+        LocationChannelManager.shared.$availableChannels
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] channels in
+                guard let self = self else { return }
+                let ghs = channels.map { $0.geohash }
+                Task { @MainActor in
+                    self.beginGeohashSampling(for: ghs)
+                }
+            }
+            .store(in: &cancellables)
+        // Kick off initial sampling if we already have channels
+        if !LocationChannelManager.shared.availableChannels.isEmpty {
+            let ghs = LocationChannelManager.shared.availableChannels.map { $0.geohash }
+            Task { @MainActor in self.beginGeohashSampling(for: ghs) }
+        }
+        // Refresh channels once when authorized to seed sampling
+        LocationChannelManager.shared.$permissionState
+            .receive(on: DispatchQueue.main)
+            .sink { state in
+                if state == .authorized { LocationChannelManager.shared.refreshChannels() }
+            }
+            .store(in: &cancellables)
+
+        // Track teleport flag changes to keep our own teleported marker in sync with regional status
+        LocationChannelManager.shared.$teleported
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] isTeleported in
+                guard let self = self else { return }
+                Task { @MainActor in
+                    guard case .location(let ch) = self.activeChannel,
+                          let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) else { return }
+                    let key = id.publicKeyHex.lowercased()
+                    let hasRegional = !LocationChannelManager.shared.availableChannels.isEmpty
+                    let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == ch.geohash }
+                    if isTeleported && hasRegional && !inRegional {
+                        self.teleportedGeo = self.teleportedGeo.union([key])
+                    } else {
+                        self.teleportedGeo.remove(key)
+                    }
+                }
+            }
+            .store(in: &cancellables)
         
         // Request notification permission
         NotificationService.shared.requestAuthorization()
@@ -747,10 +792,19 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             })
             if hasTeleportTag {
                 let key = event.pubkey.lowercased()
-                Task { @MainActor in self.teleportedGeo = self.teleportedGeo.union([key]) }
+                // Do not mark our own key from historical events; rely on manager.teleported for self
+                let isSelf: Bool = {
+                    if let gh = self.currentGeohash, let my = try? NostrIdentityBridge.deriveIdentity(forGeohash: gh) {
+                        return my.publicKeyHex.lowercased() == key
+                    }
+                    return false
+                }()
+                if !isSelf {
+                    Task { @MainActor in self.teleportedGeo = self.teleportedGeo.union([key]) }
+                }
             }
             let senderName = self.displayNameForNostrPubkey(event.pubkey)
-            let content = event.content
+            let content = event.content.trimmingCharacters(in: .whitespacesAndNewlines)
             let timestamp = Date(timeIntervalSince1970: TimeInterval(event.created_at))
             let mentions = self.parseMentions(from: content)
             let msg = BitchatMessage(
@@ -1192,7 +1246,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     ///         Routes to private chat if one is selected, otherwise broadcasts
     @MainActor
     func sendMessage(_ content: String) {
-        guard !content.isEmpty else { return }
+        // Ignore messages that are empty or whitespace-only to prevent blank lines
+        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
         
         // Check for commands
         if content.hasPrefix("/") {
@@ -1212,7 +1268,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             } else {
             }
         } else {
-            // Parse mentions from the content
+            // Parse mentions from the content (use original content for user intent)
             let mentions = parseMentions(from: content)
             
             // Add message to local display
@@ -1227,7 +1283,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
             let message = BitchatMessage(
                 sender: displaySender,
-                content: content,
+                content: trimmed,
                 timestamp: Date(),
                 isRelay: false,
                 originalSender: nil,
@@ -1272,7 +1328,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                     do {
                         let identity = try NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash)
                         let event = try NostrProtocol.createEphemeralGeohashEvent(
-                            content: content,
+                            content: trimmed,
                             geohash: ch.geohash,
                             senderIdentity: identity,
                             nickname: self.nickname,
@@ -1292,7 +1348,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                         SecureLogger.log("GeoTeleport: sent geo message pub=\(identity.publicKeyHex.prefix(8))… teleported=\(LocationChannelManager.shared.teleported)",
                                         category: SecureLogger.session, level: .debug)
                         // If we tagged this as teleported, also mark our pubkey in teleportedGeo for UI
-                        if LocationChannelManager.shared.teleported {
+                        // Only when not in our regional set (and regional list is known)
+                        let hasRegional = !LocationChannelManager.shared.availableChannels.isEmpty
+                        let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == ch.geohash }
+                        if LocationChannelManager.shared.teleported && hasRegional && !inRegional {
                             let key = identity.publicKeyHex.lowercased()
                             self.teleportedGeo = self.teleportedGeo.union([key])
                             SecureLogger.log("GeoTeleport: mark self teleported key=\(key.prefix(8))… total=\(self.teleportedGeo.count)",
@@ -1329,9 +1388,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         case .location(let ch):
             // Sanitize existing timeline (filter any prior empty-content entries)
             var arr = geoTimelines[ch.geohash] ?? []
-            let before = arr.count
             arr.removeAll { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
-            if arr.count != before { geoTimelines[ch.geohash] = arr }
+            // Ensure chronological order when returning to a geohash
+            if arr.count > 1 {
+                arr.sort { $0.timestamp < $1.timestamp }
+            }
+            // Persist the cleaned/sorted timeline for this geohash
+            geoTimelines[ch.geohash] = arr
             messages = arr
         }
         // Unsubscribe previous
@@ -1350,14 +1413,18 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         
         guard case .location(let ch) = channel else { return }
         currentGeohash = ch.geohash
-        // Ensure self appears immediately in the people list; mark teleported state if applicable
+        // Ensure self appears immediately in the people list; mark teleported state only when truly teleported
         if let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
             self.recordGeoParticipant(pubkeyHex: id.publicKeyHex)
-            if LocationChannelManager.shared.teleported {
-                let key = id.publicKeyHex.lowercased()
+            let hasRegional = !LocationChannelManager.shared.availableChannels.isEmpty
+            let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == ch.geohash }
+            let key = id.publicKeyHex.lowercased()
+            if LocationChannelManager.shared.teleported && hasRegional && !inRegional {
                 teleportedGeo = teleportedGeo.union([key])
                 SecureLogger.log("GeoTeleport: channel switch mark self teleported key=\(key.prefix(8))… total=\(teleportedGeo.count)",
                                 category: SecureLogger.session, level: .info)
+            } else {
+                teleportedGeo.remove(key)
             }
         }
         let subID = "geo-\(ch.geohash)"
@@ -1386,10 +1453,19 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             })
             if hasTeleportTag {
                 let key = event.pubkey.lowercased()
-                Task { @MainActor in
-                    self.teleportedGeo = self.teleportedGeo.union([key])
-                    SecureLogger.log("GeoTeleport: mark peer teleported key=\(key.prefix(8))… total=\(self.teleportedGeo.count)",
-                                    category: SecureLogger.session, level: .info)
+                // Avoid marking our own key from historical events; rely on manager.teleported for self
+                let isSelf: Bool = {
+                    if let gh = self.currentGeohash, let my = try? NostrIdentityBridge.deriveIdentity(forGeohash: gh) {
+                        return my.publicKeyHex.lowercased() == key
+                    }
+                    return false
+                }()
+                if !isSelf {
+                    Task { @MainActor in
+                        self.teleportedGeo = self.teleportedGeo.union([key])
+                        SecureLogger.log("GeoTeleport: mark peer teleported key=\(key.prefix(8))… total=\(self.teleportedGeo.count)",
+                                        category: SecureLogger.session, level: .info)
+                    }
                 }
             }
             // Skip only very recent self-echo from relay; include older self events for hydration
@@ -1741,8 +1817,52 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: subRelays) { [weak self] event in
                 guard let self = self else { return }
                 guard event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue else { return }
+                // Compute current participant count (5-minute window) BEFORE updating with this event
+                let cutoff = Date().addingTimeInterval(-TransportConfig.uiRecentCutoffFiveMinutesSeconds)
+                let existingCount: Int = {
+                    let map = self.geoParticipants[gh] ?? [:]
+                    return map.values.filter { $0 >= cutoff }.count
+                }()
                 // Update participants for this specific geohash
                 self.recordGeoParticipant(pubkeyHex: event.pubkey, geohash: gh)
+                // Notify only on rising-edge: previously zero people, now someone sends a chat
+                let content = event.content.trimmingCharacters(in: .whitespacesAndNewlines)
+                guard !content.isEmpty else { return }
+                // Respect geohash blocks
+                if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: event.pubkey.lowercased()) { return }
+                // Skip self identity for this geohash
+                if let my = try? NostrIdentityBridge.deriveIdentity(forGeohash: gh), my.publicKeyHex.lowercased() == event.pubkey.lowercased() { return }
+                // Only trigger when there were zero participants in this geohash recently
+                guard existingCount == 0 else { return }
+                // Avoid notifications for old sampled events when launching or (re)subscribing
+                let eventTime = Date(timeIntervalSince1970: TimeInterval(event.created_at))
+                if Date().timeIntervalSince(eventTime) > 30 { return }
+                // Foreground policy: allow if it's a different geohash than the one currently open
+                // Suppress only when app is active AND we're already in this same geohash channel
+                #if os(iOS)
+                if UIApplication.shared.applicationState == .active {
+                    if case .location(let ch) = self.activeChannel, ch.geohash == gh { return }
+                }
+                #elseif os(macOS)
+                if NSApplication.shared.isActive {
+                    if case .location(let ch) = self.activeChannel, ch.geohash == gh { return }
+                }
+                #endif
+                // Cooldown per geohash
+                let now = Date()
+                let last = self.lastGeoNotificationAt[gh] ?? .distantPast
+                if now.timeIntervalSince(last) < TransportConfig.uiGeoNotifyCooldownSeconds { return }
+                // Compose a short preview
+                let preview: String = {
+                    let maxLen = TransportConfig.uiGeoNotifySnippetMaxLen
+                    if content.count <= maxLen { return content }
+                    let idx = content.index(content.startIndex, offsetBy: maxLen)
+                    return String(content[..<idx]) + "…"
+                }()
+                Task { @MainActor in
+                    self.lastGeoNotificationAt[gh] = now
+                    NotificationService.shared.sendGeohashActivityNotification(geohash: gh, bodyPreview: preview)
+                }
             }
         }
     }
@@ -3035,8 +3155,29 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 for mr in mentionRanges { if NSIntersectionRange(r, mr).length > 0 { return true } }
                 return false
             }
+            // Helper: check if a hashtag is immediately attached to a preceding @mention (e.g., @name#abcd)
+            func attachedToMention(_ r: NSRange) -> Bool {
+                if let nsRange = Range(r, in: content), nsRange.lowerBound > content.startIndex {
+                    var i = content.index(before: nsRange.lowerBound)
+                    while true {
+                        let ch = content[i]
+                        if ch.isWhitespace || ch.isNewline { break }
+                        if ch == "@" { return true }
+                        if i == content.startIndex { break }
+                        i = content.index(before: i)
+                    }
+                }
+                return false
+            }
+            // Helper: ensure '#' starts a new token (start-of-line or whitespace before '#')
+            func isStandaloneHashtag(_ r: NSRange) -> Bool {
+                guard let nsRange = Range(r, in: content) else { return false }
+                if nsRange.lowerBound == content.startIndex { return true }
+                let prev = content.index(before: nsRange.lowerBound)
+                return content[prev].isWhitespace || content[prev].isNewline
+            }
             var allMatches: [(range: NSRange, type: String)] = []
-            for match in hashtagMatches where !overlapsMention(match.range(at: 0)) {
+            for match in hashtagMatches where !overlapsMention(match.range(at: 0)) && !attachedToMention(match.range(at: 0)) && isStandaloneHashtag(match.range(at: 0)) {
                 allMatches.append((match.range(at: 0), "hashtag"))
             }
             for match in mentionMatches {
@@ -3144,12 +3285,18 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                                 }
                                 return false
                             }()
+                            // Also require the '#' to start a new token (whitespace or start-of-line before '#')
+                            let standalone: Bool = {
+                                if nsRange.lowerBound == content.startIndex { return true }
+                                let prev = content.index(before: nsRange.lowerBound)
+                                return content[prev].isWhitespace || content[prev].isNewline
+                            }()
                             var tagStyle = AttributeContainer()
                             tagStyle.font = isSelf
                                 ? .system(size: 14, weight: .bold, design: .monospaced)
                                 : .system(size: 14, design: .monospaced)
                             tagStyle.foregroundColor = baseColor
-                            if isGeohash && !attachedToMention, let url = URL(string: "bitchat://geohash/\(token)") {
+                            if isGeohash && !attachedToMention && standalone, let url = URL(string: "bitchat://geohash/\(token)") {
                                 tagStyle.link = url
                                 tagStyle.underlineStyle = .single
                             }
@@ -3488,14 +3635,20 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     func colorForPeerSeed(_ seed: String, isDark: Bool) -> Color {
         let cacheKey = seed + (isDark ? "|dark" : "|light")
         if let cached = peerColorCache[cacheKey] { return cached }
-        var hue = Double(djb2(seed) % 360) / 360.0
-        // Avoid orange (~30°) reserved for self
+        let h = djb2(seed)
+        var hue = Double(h % 1000) / 1000.0
         let orange = 30.0 / 360.0
         if abs(hue - orange) < TransportConfig.uiColorHueAvoidanceDelta {
             hue = fmod(hue + TransportConfig.uiColorHueOffset, 1.0)
         }
-        let saturation: Double = isDark ? 0.80 : 0.70
-        let brightness: Double = isDark ? 0.75 : 0.45
+        let sRand = Double((h >> 17) & 0x3FF) / 1023.0
+        let bRand = Double((h >> 27) & 0x3FF) / 1023.0
+        let sBase: Double = isDark ? 0.80 : 0.70
+        let sRange: Double = 0.20
+        let bBase: Double = isDark ? 0.75 : 0.45
+        let bRange: Double = isDark ? 0.16 : 0.14
+        let saturation = min(1.0, max(0.50, sBase + (sRand - 0.5) * sRange))
+        let brightness = min(1.0, max(0.35, bBase + (bRand - 0.5) * bRange))
         let c = Color(hue: hue, saturation: saturation, brightness: brightness)
         peerColorCache[cacheKey] = c
         return c
@@ -3503,41 +3656,35 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
     @MainActor
     private func peerColor(for message: BitchatMessage, isDark: Bool) -> Color {
-        var seed: String
         if let spid = message.senderPeerID {
             if spid.hasPrefix("nostr:") || spid.hasPrefix("nostr_") {
-                // Normalize to the bare short id, then prefer full mapping when available
                 let bare: String = {
                     if spid.hasPrefix("nostr:") { return String(spid.dropFirst(6)) }
                     if spid.hasPrefix("nostr_") { return String(spid.dropFirst(6)) }
                     return spid
                 }()
                 let full = nostrKeyMapping[spid]?.lowercased() ?? bare.lowercased()
-                seed = "nostr:" + full
-            } else if spid.count == 16, let full = getNoiseKeyForShortID(spid)?.lowercased() {
-                seed = "noise:" + full
+                return getNostrPaletteColor(for: full, isDark: isDark)
+            } else if spid.count == 16 {
+                // Mesh short ID
+                return getPeerPaletteColor(for: spid, isDark: isDark)
             } else {
-                seed = spid.lowercased()
+                return getPeerPaletteColor(for: spid.lowercased(), isDark: isDark)
             }
-        } else {
-            seed = message.sender.lowercased()
         }
-        return colorForPeerSeed(seed, isDark: isDark)
+        // Fallback when we only have a display name
+        return colorForPeerSeed(message.sender.lowercased(), isDark: isDark)
     }
 
     // Public helpers for views to color peers consistently in lists
     @MainActor
     func colorForNostrPubkey(_ pubkeyHexLowercased: String, isDark: Bool) -> Color {
-        return colorForPeerSeed("nostr:" + pubkeyHexLowercased.lowercased(), isDark: isDark)
+        return getNostrPaletteColor(for: pubkeyHexLowercased.lowercased(), isDark: isDark)
     }
 
     @MainActor
     func colorForMeshPeer(id peerID: String, isDark: Bool) -> Color {
-        // Mirror message coloring: prefer stable full noise key mapping when available, else short ID
-        if let full = getNoiseKeyForShortID(peerID)?.lowercased() {
-            return colorForPeerSeed("noise:" + full, isDark: isDark)
-        }
-        return colorForPeerSeed(peerID.lowercased(), isDark: isDark)
+        return getPeerPaletteColor(for: peerID, isDark: isDark)
     }
 
     private func trimMeshTimelineIfNeeded() {
@@ -3546,6 +3693,276 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         }
     }
 
+    // MARK: - Peer List Minimal-Distance Palette
+    private var peerPaletteLight: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var peerPaletteDark: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var peerPaletteSeeds: [String: String] = [:] // peerID -> seed used
+
+    @MainActor
+    private func meshSeed(for peerID: String) -> String {
+        if let full = getNoiseKeyForShortID(peerID)?.lowercased() {
+            return "noise:" + full
+        }
+        return peerID.lowercased()
+    }
+
+    @MainActor
+    private func getPeerPaletteColor(for peerID: String, isDark: Bool) -> Color {
+        // Ensure palette up to date for current peer set and seeds
+        rebuildPeerPaletteIfNeeded()
+
+        let entry = (isDark ? peerPaletteDark[peerID] : peerPaletteLight[peerID])
+        let orange = Color.orange
+        if peerID == meshService.myPeerID { return orange }
+        let saturation: Double = isDark ? 0.80 : 0.70
+        let baseBrightness: Double = isDark ? 0.75 : 0.45
+        let ringDelta = isDark ? TransportConfig.uiPeerPaletteRingBrightnessDeltaDark : TransportConfig.uiPeerPaletteRingBrightnessDeltaLight
+        if let e = entry {
+            let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(e.ring)))
+            return Color(hue: e.hue, saturation: saturation, brightness: brightness)
+        }
+        // Fallback to seed color if not in palette (e.g., transient)
+        let seed = meshSeed(for: peerID)
+        return colorForPeerSeed(seed, isDark: isDark)
+    }
+
+    @MainActor
+    private func rebuildPeerPaletteIfNeeded() {
+        // Build current peer->seed map (excluding self)
+        let myID = meshService.myPeerID
+        var currentSeeds: [String: String] = [:]
+        for p in allPeers where p.id != myID {
+            currentSeeds[p.id] = meshSeed(for: p.id)
+        }
+        // If seeds unchanged and palette exists for both themes, skip
+        if currentSeeds == peerPaletteSeeds,
+           peerPaletteLight.keys.count == currentSeeds.count,
+           peerPaletteDark.keys.count == currentSeeds.count {
+            return
+        }
+        peerPaletteSeeds = currentSeeds
+
+        // Generate evenly spaced hue slots avoiding self-orange range
+        let slotCount = max(8, TransportConfig.uiPeerPaletteSlots)
+        let avoidCenter = 30.0 / 360.0
+        let avoidDelta = TransportConfig.uiColorHueAvoidanceDelta
+        var slots: [Double] = []
+        for i in 0..<slotCount {
+            let hue = Double(i) / Double(slotCount)
+            if abs(hue - avoidCenter) < avoidDelta { continue }
+            slots.append(hue)
+        }
+        if slots.isEmpty {
+            // Safety: if avoidance consumed all (shouldn't happen), fall back to full slots
+            for i in 0..<slotCount { slots.append(Double(i) / Double(slotCount)) }
+        }
+
+        // Helper to compute circular distance
+        func circDist(_ a: Double, _ b: Double) -> Double {
+            let d = abs(a - b)
+            return d > 0.5 ? 1.0 - d : d
+        }
+
+        // Assign slots to peers to maximize minimal distance, deterministically
+        let peers = currentSeeds.keys.sorted() // stable order
+        // Preferred slot index by seed (wrapping to available slots)
+        let prefIndex: [String: Int] = Dictionary(uniqueKeysWithValues: peers.map { id in
+            let h = djb2(currentSeeds[id] ?? id)
+            // Map to available slot range deterministically
+            let idx = Int(h % UInt64(slots.count))
+            return (id, idx)
+        })
+
+        func assign(for seeds: [String: String]) -> [String: (slot: Int, ring: Int, hue: Double)] {
+            var mapping: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+            var usedSlots = Set<Int>()
+            var usedHues: [Double] = []
+
+            // Keep previous assignments if still valid to minimize churn
+            let prev = peerPaletteLight.isEmpty ? peerPaletteDark : peerPaletteLight
+            for (id, entry) in prev {
+                if seeds.keys.contains(id), entry.slot < slots.count { // slot index still valid
+                    mapping[id] = (entry.slot, entry.ring, slots[entry.slot])
+                    usedSlots.insert(entry.slot)
+                    usedHues.append(slots[entry.slot])
+                }
+            }
+
+            // First ring assignment using free slots
+            let unassigned = peers.filter { mapping[$0] == nil }
+            for id in unassigned {
+                // If a preferred slot free, take it
+                let preferred = prefIndex[id] ?? 0
+                if !usedSlots.contains(preferred) && preferred < slots.count {
+                    mapping[id] = (preferred, 0, slots[preferred])
+                    usedSlots.insert(preferred)
+                    usedHues.append(slots[preferred])
+                    continue
+                }
+                // Choose free slot maximizing minimal distance to used hues
+                var bestSlot: Int? = nil
+                var bestScore: Double = -1
+                for sIdx in 0..<slots.count where !usedSlots.contains(sIdx) {
+                    let hue = slots[sIdx]
+                    let minDist = usedHues.isEmpty ? 1.0 : usedHues.map { circDist(hue, $0) }.min() ?? 1.0
+                    // Bias toward preferred index for stability
+                    let bias = 1.0 - (Double((abs(sIdx - (prefIndex[id] ?? 0)) % slots.count)) / Double(slots.count))
+                    let score = minDist + 0.05 * bias
+                    if score > bestScore { bestScore = score; bestSlot = sIdx }
+                }
+                if let s = bestSlot {
+                    mapping[id] = (s, 0, slots[s])
+                    usedSlots.insert(s)
+                    usedHues.append(slots[s])
+                }
+            }
+
+            // Overflow peers: assign additional rings by reusing slots with stable preference
+            let stillUnassigned = peers.filter { mapping[$0] == nil }
+            if !stillUnassigned.isEmpty {
+                for (idx, id) in stillUnassigned.enumerated() {
+                    let preferred = prefIndex[id] ?? 0
+                    // Spread over slots by rotating from preferred with a golden-step
+                    let goldenStep = 7 // small prime step for dispersion
+                    let s = (preferred + idx * goldenStep) % slots.count
+                    mapping[id] = (s, 1, slots[s])
+                }
+            }
+
+            return mapping
+        }
+
+        let mapping = assign(for: currentSeeds)
+        peerPaletteLight = mapping
+        peerPaletteDark = mapping
+    }
+
+    // MARK: - Nostr People Minimal-Distance Palette (same algo)
+    private var nostrPaletteLight: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var nostrPaletteDark: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var nostrPaletteSeeds: [String: String] = [:] // pubkey -> seed used
+
+    @MainActor
+    private func getNostrPaletteColor(for pubkeyHexLowercased: String, isDark: Bool) -> Color {
+        rebuildNostrPaletteIfNeeded()
+        let entry = (isDark ? nostrPaletteDark[pubkeyHexLowercased] : nostrPaletteLight[pubkeyHexLowercased])
+        let myHex: String? = {
+            if case .location(let ch) = LocationChannelManager.shared.selectedChannel,
+               let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
+                return id.publicKeyHex.lowercased()
+            }
+            return nil
+        }()
+        if let me = myHex, pubkeyHexLowercased == me { return .orange }
+        let saturation: Double = isDark ? 0.80 : 0.70
+        let baseBrightness: Double = isDark ? 0.75 : 0.45
+        let ringDelta = isDark ? TransportConfig.uiPeerPaletteRingBrightnessDeltaDark : TransportConfig.uiPeerPaletteRingBrightnessDeltaLight
+        if let e = entry {
+            let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(e.ring)))
+            return Color(hue: e.hue, saturation: saturation, brightness: brightness)
+        }
+        // Fallback to seed color if not in palette (e.g., transient)
+        return colorForPeerSeed("nostr:" + pubkeyHexLowercased, isDark: isDark)
+    }
+
+    @MainActor
+    private func rebuildNostrPaletteIfNeeded() {
+        // Build seeds map from currently visible geohash people (excluding self)
+        let myHex: String? = {
+            if case .location(let ch) = LocationChannelManager.shared.selectedChannel,
+               let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
+                return id.publicKeyHex.lowercased()
+            }
+            return nil
+        }()
+        let people = visibleGeohashPeople()
+        var currentSeeds: [String: String] = [:]
+        for p in people where p.id != myHex { currentSeeds[p.id] = "nostr:" + p.id }
+
+        if currentSeeds == nostrPaletteSeeds,
+           nostrPaletteLight.keys.count == currentSeeds.count,
+           nostrPaletteDark.keys.count == currentSeeds.count {
+            return
+        }
+        nostrPaletteSeeds = currentSeeds
+
+        let slotCount = max(8, TransportConfig.uiPeerPaletteSlots)
+        let avoidCenter = 30.0 / 360.0
+        let avoidDelta = TransportConfig.uiColorHueAvoidanceDelta
+        var slots: [Double] = []
+        for i in 0..<slotCount {
+            let hue = Double(i) / Double(slotCount)
+            if abs(hue - avoidCenter) < avoidDelta { continue }
+            slots.append(hue)
+        }
+        if slots.isEmpty {
+            for i in 0..<slotCount { slots.append(Double(i) / Double(slotCount)) }
+        }
+
+        func circDist(_ a: Double, _ b: Double) -> Double {
+            let d = abs(a - b)
+            return d > 0.5 ? 1.0 - d : d
+        }
+
+        let peers = currentSeeds.keys.sorted()
+        let prefIndex: [String: Int] = Dictionary(uniqueKeysWithValues: peers.map { id in
+            let h = djb2(currentSeeds[id] ?? id)
+            let idx = Int(h % UInt64(slots.count))
+            return (id, idx)
+        })
+
+        var mapping: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+        var usedSlots = Set<Int>()
+        var usedHues: [Double] = []
+
+        let prev = nostrPaletteLight.isEmpty ? nostrPaletteDark : nostrPaletteLight
+        for (id, entry) in prev {
+            if peers.contains(id), entry.slot < slots.count {
+                mapping[id] = (entry.slot, entry.ring, slots[entry.slot])
+                usedSlots.insert(entry.slot)
+                usedHues.append(slots[entry.slot])
+            }
+        }
+
+        let unassigned = peers.filter { mapping[$0] == nil }
+        for id in unassigned {
+            let preferred = prefIndex[id] ?? 0
+            if !usedSlots.contains(preferred) && preferred < slots.count {
+                mapping[id] = (preferred, 0, slots[preferred])
+                usedSlots.insert(preferred)
+                usedHues.append(slots[preferred])
+                continue
+            }
+            var bestSlot: Int? = nil
+            var bestScore: Double = -1
+            for sIdx in 0..<slots.count where !usedSlots.contains(sIdx) {
+                let hue = slots[sIdx]
+                let minDist = usedHues.isEmpty ? 1.0 : usedHues.map { circDist(hue, $0) }.min() ?? 1.0
+                let bias = 1.0 - (Double((abs(sIdx - (prefIndex[id] ?? 0)) % slots.count)) / Double(slots.count))
+                let score = minDist + 0.05 * bias
+                if score > bestScore { bestScore = score; bestSlot = sIdx }
+            }
+            if let s = bestSlot {
+                mapping[id] = (s, 0, slots[s])
+                usedSlots.insert(s)
+                usedHues.append(slots[s])
+            }
+        }
+
+        let stillUnassigned = peers.filter { mapping[$0] == nil }
+        if !stillUnassigned.isEmpty {
+            for (idx, id) in stillUnassigned.enumerated() {
+                let preferred = prefIndex[id] ?? 0
+                let goldenStep = 7
+                let s = (preferred + idx * goldenStep) % slots.count
+                mapping[id] = (s, 1, slots[s])
+            }
+        }
+
+        nostrPaletteLight = mapping
+        nostrPaletteDark = mapping
+    }
+
     // Clear the current public channel's timeline (visible + persistent buffer)
     @MainActor
     func clearCurrentPublicTimeline() {
@@ -3933,11 +4350,12 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
     func didReceivePublicMessage(from peerID: String, nickname: String, content: String, timestamp: Date) {
         Task { @MainActor in
-            let publicMentions = parseMentions(from: content)
+            let normalized = content.trimmingCharacters(in: .whitespacesAndNewlines)
+            let publicMentions = parseMentions(from: normalized)
             let msg = BitchatMessage(
                 id: UUID().uuidString,
                 sender: nickname,
-                content: content,
+                content: normalized,
                 timestamp: timestamp,
                 isRelay: false,
                 originalSender: nil,
@@ -4106,9 +4524,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 // Cancel any pending reset if peers are back
                 self.networkResetTimer?.invalidate()
                 self.networkResetTimer = nil
-                // Only count mesh peers (actually connected via Bluetooth)
+                // Count mesh peers that are connected OR recently reachable via mesh relays
                 let meshPeers = peers.filter { peerID in
-                    self.meshService.isPeerConnected(peerID)
+                    self.meshService.isPeerConnected(peerID) || self.meshService.isPeerReachable(peerID)
                 }
                 
                 // Check if we have new mesh peers we haven't seen recently
@@ -5322,29 +5740,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
         guard channelMatches else { return }
 
-        // Background nudge: notify on new activity after inactivity threshold in current channel
-        #if os(iOS)
-        if UIApplication.shared.applicationState != .active {
-            let channelKey: String = {
-                switch activeChannel {
-                case .mesh: return "mesh"
-                case .location(let ch): return "geo:\(ch.geohash)"
-                }
-            }()
-            let now = Date()
-            if let last = lastPublicActivityAt[channelKey], now.timeIntervalSince(last) >= channelInactivityThreshold {
-                // Optional: simple cooldown to avoid duplicate bursts
-                let lastNotified = lastPublicActivityNotifyAt[channelKey] ?? .distantPast
-                if now.timeIntervalSince(lastNotified) >= 60 {
-                    let title = activeChannelDisplayName()
-                    let body = "new chats!"
-                    NotificationService.shared.sendLocalNotification(title: title, body: body, identifier: "channel-activity-\(channelKey)-\(now.timeIntervalSince1970)")
-                    lastPublicActivityNotifyAt[channelKey] = now
-                }
-            }
-            lastPublicActivityAt[channelKey] = now
-        }
-        #endif
+        
 
         // Append via batching buffer (skip empty content)
         if !finalMessage.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {

bitchat/Views/ContentView.swift

@@ -459,7 +459,13 @@ struct ContentView: View {
                 }
                 let level = levelForLength(gh.count)
                 let ch = GeohashChannel(level: level, geohash: gh)
-                LocationChannelManager.shared.markTeleported(for: gh, true)
+                // Do not mark teleported when opening a geohash that is in our regional set.
+                // If availableChannels is empty (e.g., cold start), defer marking and let
+                // LocationChannelManager compute teleported based on actual location.
+                let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == gh }
+                if !inRegional && !LocationChannelManager.shared.availableChannels.isEmpty {
+                    LocationChannelManager.shared.markTeleported(for: gh, true)
+                }
                 LocationChannelManager.shared.select(ChannelID.location(ch))
             }
             .onTapGesture(count: 3) {

bitchat/Views/LocationChannelsSheet.swift

@@ -83,24 +83,17 @@ struct LocationChannelsSheet: View {
             }
             // Begin periodic refresh while sheet is open
             manager.beginLiveRefresh()
-            // Begin multi-channel sampling for counts
-            let ghs = manager.availableChannels.map { $0.geohash }
-            viewModel.beginGeohashSampling(for: ghs)
+            // Geohash sampling is now managed by ChatViewModel globally
         }
         .onDisappear {
             manager.endLiveRefresh()
-            viewModel.endGeohashSampling()
         }
         .onChange(of: manager.permissionState) { newValue in
             if newValue == LocationChannelManager.PermissionState.authorized {
                 manager.refreshChannels()
             }
         }
-        .onChange(of: manager.availableChannels) { newValue in
-            // Keep sampling list in sync with available channels as they refresh live
-            let ghs = newValue.map { $0.geohash }
-            viewModel.beginGeohashSampling(for: ghs)
-        }
+        .onChange(of: manager.availableChannels) { _ in }
     }
 
     private var channelList: some View {
@@ -289,9 +282,10 @@ struct LocationChannelsSheet: View {
     }
 
     private func meshCount() -> Int {
+        // Count mesh-connected OR mesh-reachable peers (exclude self)
         let myID = viewModel.meshService.myPeerID
         return viewModel.allPeers.reduce(0) { acc, peer in
-            if peer.id != myID && peer.isConnected { return acc + 1 }
+            if peer.id != myID && (peer.isConnected || peer.isReachable) { return acc + 1 }
             return acc
         }
     }