Phase 4 §1/§5: notif banner detection on API <33 + chat-delivery WS→FCM lifecycle

§1 notif banner: permission_handler v11 returns granted unconditionally
for Permission.notification on Android <13 because POST_NOTIFICATIONS
didn't exist as a runtime permission. Result: SHome1st amber "notifikasi
off" banner never showed on API 24-32 even when the user toggled
notifications off in Settings → Apps. Add a
NotificationManagerCompat.areNotificationsEnabled() pre-check via
flutter_local_notifications (works from API 19+) so the banner reflects
the real OS state on older Android.

§5 chat delivery: the contract is "WS when foreground, FCM when
background", but the previous build only honoured (1) — Android keeps
the TCP socket alive after the Dart isolate is paused, so backend's
`socket.readyState === 1` check returned true and FCM never fired.
Fix has five parts (all required together):

 1. Customer-side lifecycle observer in client_app/main.dart closes
    chatProvider's WS on paused/detached, reconnects on resumed.
 2. `_appPaused` gate in main.dart suppresses the activeSessionProvider
    listener's auto-reconnect (15s poll in active_session_notifier
    would otherwise re-open the WS the next tick after the observer
    closed it — defeating the fallback).
 3. Mitra-side lifecycle observer in mitra_app/main.dart stashes
    `_pausedChatSessionId`, calls mitraChatProvider.disconnect(), and
    re-issues connect(saved) on resumed.
 4. MitraChat gains a `_connectedSessionId` field + getter so the
    observer in step 3 can read it back across disconnect (disconnect
    clears it; the next connect overwrites it).
 5. SearchingScreen resets pairingProvider when entering with a new
    draft.paymentId — previously it retained PairingActiveData with
    the *old* sessionId after a session ended, and the next pairing
    flow navigated straight to that completed session showing
    "Sesi sudah berakhir".

Backend additions under /internal/_test/* for assertion harness:
inspectSessionWsState + GET /ws-connection-state,
POST /send-chat-message-as-mitra (with delivered_via),
POST /send-chat-message-as-customer (with delivered_via),
POST /send-fcm-chat-message (raw FCM dispatch).

Maestro coverage:
 - ts-customer-05-01: mitra → customer message when customer is
   backgrounded → delivered_via=fcm.
 - ts-customer-05-02: customer → mitra message when mitra is
   backgrounded → delivered_via=fcm.
 - ts-customer-01-01: §1 notif-denied banner on home. Documented
   precondition: mitra must be force-stopped or backgrounded on the
   chat screen before 05-02 runs (Maestro can only drive one --udid
   per run; mitra-side lifecycle observer end-to-end is deferred).

Helper scripts under client_app/.maestro/scripts/:
inspect_ws_state.js, assert_ws_state.js,
send_chat_message_as_mitra.js, assert_delivered_via.js (takes
SENDER=mitra|customer to route to the matching backend endpoint).

README_section_05.md documents the test plan, helper scripts, and the
deferred mitra-side maestro driving. Both apps tested manually on
API 28 AVDs where FCM delivery is sub-second; API 24 has 5-30 min
heartbeats that make it impractical for FCM-related testing.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

mitra_app/lib/core/chat/mitra_chat_notifier.dart

@@ -143,6 +143,13 @@ class MitraChat extends _$MitraChat {
   WebSocketChannel? _channel;
   StreamSubscription? _wsSubscription;
   Timer? _typingTimer;
+  // Survives `disconnect()` so a later `didChangeAppLifecycleState(resumed)`
+  // can re-issue `connect(sessionId)` with the right session — disconnect()
+  // resets `state` to MitraChatInitialData, which is otherwise the only
+  // record of which chat we were attached to.
+  String? _connectedSessionId;
+
+  String? get connectedSessionId => _connectedSessionId;
 
   ApiClient get _apiClient => ref.read(apiClientProvider);
 
@@ -150,6 +157,7 @@ class MitraChat extends _$MitraChat {
   MitraChatData build() => const MitraChatInitialData();
 
   Future<void> connect(String sessionId) async {
+    _connectedSessionId = sessionId;
     state = const MitraChatConnectingData();
     try {
       final sessionInfo = await _apiClient.get('/api/shared/chat/$sessionId/info');
@@ -222,6 +230,7 @@ class MitraChat extends _$MitraChat {
 
   void disconnect() {
     _cleanup();
+    _connectedSessionId = null;
     // State reset is deferred to post-frame: disconnect() is called from
     // mitra_chat_screen's deactivate() during back-nav, and a synchronous
     // `state =` here notifies watchers while the chat screen's widget tree is

mitra_app/lib/main.dart

@@ -4,6 +4,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'core/api/api_client_provider.dart';
 import 'core/auth/auth_notifier.dart';
+import 'core/chat/mitra_chat_notifier.dart';
 import 'core/status/status_notifier.dart';
 import 'core/chat/chat_request_notifier.dart';
 import 'core/chat/widgets/chat_request_overlay.dart';
@@ -30,6 +31,13 @@ class App extends ConsumerStatefulWidget {
 
 class _AppState extends ConsumerState<App> with WidgetsBindingObserver {
   bool _fcmRegistered = false;
+  // Session the chat WS was on at the moment we backgrounded. Restored on
+  // resume so a backgrounded mitra reconnects to the same chat once they
+  // foreground the app. Mirrors the customer-app fix (main.dart on the
+  // client side) — backend's sendMessage checks recipient WS readyState
+  // before falling back to FCM, so leaving the WS open while paused makes
+  // FCM never fire and the mitra misses customer messages in background.
+  String? _pausedChatSessionId;
 
   @override
   void initState() {
@@ -47,8 +55,24 @@ class _AppState extends ConsumerState<App> with WidgetsBindingObserver {
   void didChangeAppLifecycleState(AppLifecycleState state) {
     if (state == AppLifecycleState.paused || state == AppLifecycleState.detached) {
       ref.read(onlineStatusProvider.notifier).onAppPaused();
+      // Close the chat WS so backend `sendMessage` falls back to FCM when
+      // the customer sends a message. Stash the active session_id so we
+      // can rejoin it on resume.
+      final chatNotifier = ref.read(mitraChatProvider.notifier);
+      final sid = chatNotifier.connectedSessionId;
+      if (sid != null) {
+        _pausedChatSessionId = sid;
+        chatNotifier.disconnect();
+      }
     } else if (state == AppLifecycleState.resumed) {
       ref.read(onlineStatusProvider.notifier).onAppResumed();
+      // Reconnect to the chat we backgrounded out of, if any.
+      final saved = _pausedChatSessionId;
+      _pausedChatSessionId = null;
+      if (saved != null) {
+        // ignore: discarded_futures
+        ref.read(mitraChatProvider.notifier).connect(saved);
+      }
     }
   }