@rejourneyco/react-native 1.0.0

package/android/src/main/java/com/rejourney/RejourneyModuleImpl.kt

@@ -0,0 +1,2981 @@
+/**
+ * Shared implementation for Rejourney React Native module.
+ * 
+ * This class contains all the business logic shared between:
+ * - Old Architecture (Bridge) module
+ * - New Architecture (TurboModules) module
+ * 
+ * The actual RejourneyModule classes in oldarch/ and newarch/ are thin wrappers
+ * that delegate to this implementation.
+ */
+package com.rejourney
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+import android.provider.Settings
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import com.rejourney.lifecycle.SessionLifecycleService
+import com.rejourney.lifecycle.TaskRemovedListener
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rejourney.capture.CaptureEngine
+import com.rejourney.capture.CaptureEngineDelegate
+import com.rejourney.capture.CrashHandler
+import com.rejourney.capture.ANRHandler
+import com.rejourney.core.Constants
+import com.rejourney.core.EventType
+import com.rejourney.core.Logger
+import com.rejourney.core.SDKMetrics
+import com.rejourney.network.AuthFailureListener
+import com.rejourney.network.DeviceAuthManager
+import com.rejourney.network.NetworkMonitor
+import com.rejourney.network.NetworkMonitorListener
+import com.rejourney.network.UploadManager
+import com.rejourney.network.UploadWorker
+import com.rejourney.touch.KeyboardTracker
+import com.rejourney.touch.KeyboardTrackerListener
+import com.rejourney.touch.TextInputTracker
+import com.rejourney.touch.TextInputTrackerListener
+import com.rejourney.touch.TouchInterceptor
+import com.rejourney.touch.TouchInterceptorDelegate
+import com.rejourney.utils.EventBuffer
+import com.rejourney.utils.OEMDetector
+import com.rejourney.utils.Telemetry
+import com.rejourney.utils.WindowUtils
+import kotlinx.coroutines.*
+import java.security.MessageDigest
+import java.io.File
+import java.util.*
+import java.util.concurrent.CopyOnWriteArrayList
+
+// Enum for session end reasons
+enum class EndReason {
+    SESSION_TIMEOUT,
+    MANUAL_STOP,
+    DURATION_LIMIT,
+    REMOTE_DISABLE
+}
+
+class RejourneyModuleImpl(
+    private val reactContext: ReactApplicationContext,
+    private val isNewArchitecture: Boolean
+) : Application.ActivityLifecycleCallbacks, 
+    TouchInterceptorDelegate, 
+    NetworkMonitorListener, 
+    DefaultLifecycleObserver,
+    KeyboardTrackerListener,
+    TextInputTrackerListener,
+    ANRHandler.ANRListener,
+    CaptureEngineDelegate,
+    AuthFailureListener {
+
+    companion object {
+        const val NAME = "Rejourney"
+        const val BACKGROUND_RESUME_TIMEOUT_MS = 30_000L // 30 seconds
+        
+        // Auth retry constants
+        private const val MAX_AUTH_RETRIES = 5
+        private const val AUTH_RETRY_BASE_DELAY_MS = 2000L  // 2 seconds base
+        private const val AUTH_RETRY_MAX_DELAY_MS = 60000L  // 1 minute max
+        private const val AUTH_BACKGROUND_RETRY_DELAY_MS = 300000L  // 5 minutes
+        
+        // Store process start time at class load for accurate app startup measurement
+        @JvmStatic
+        private val processStartTimeMs: Long = run {
+            try {
+                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
+                    // API 24+: Use Process.getStartElapsedRealtime() for accurate measurement
+                    val startElapsed = android.os.Process.getStartElapsedRealtime()
+                    val nowElapsed = android.os.SystemClock.elapsedRealtime()
+                    System.currentTimeMillis() - (nowElapsed - startElapsed)
+                } else {
+                    // Fallback for older devices: use current time (less accurate)
+                    System.currentTimeMillis()
+                }
+            } catch (e: Exception) {
+                System.currentTimeMillis()
+            }
+        }
+    }
+
+    // Core components
+    private var captureEngine: CaptureEngine? = null
+    private var uploadManager: UploadManager? = null
+    private var touchInterceptor: TouchInterceptor? = null
+    private var deviceAuthManager: DeviceAuthManager? = null
+    private var networkMonitor: NetworkMonitor? = null
+    private var keyboardTracker: KeyboardTracker? = null
+    private var textInputTracker: TextInputTracker? = null
+
+    // Session state
+    private var currentSessionId: String? = null
+    private var userId: String? = null
+    @Volatile private var isRecording: Boolean = false
+    @Volatile private var remoteRejourneyEnabled: Boolean = true
+    @Volatile private var remoteRecordingEnabled: Boolean = true
+    @Volatile private var recordingEnabledByConfig: Boolean = true
+    @Volatile private var sessionSampled: Boolean = true
+    @Volatile private var hasSampleDecision: Boolean = false
+    @Volatile private var hasProjectConfig: Boolean = false
+    private var projectSampleRate: Int = 100
+    private var sessionStartTime: Long = 0
+    private var totalBackgroundTimeMs: Long = 0
+    private var backgroundEntryTime: Long = 0
+    private var wasInBackground: Boolean = false
+    private var maxRecordingMinutes: Int = 10
+    @Volatile private var sessionEndSent: Boolean = false
+    
+    // Keyboard state
+    private var keyPressCount: Int = 0
+    private var isKeyboardVisible: Boolean = false
+    private var lastKeyboardHeight: Int = 0
+    
+    // Session state saved on background - used to restore on foreground if within timeout
+    private var savedApiUrl: String = ""
+    private var savedPublicKey: String = ""
+    private var savedDeviceHash: String = ""
+
+    // Events buffer
+    private val sessionEvents = CopyOnWriteArrayList<Map<String, Any?>>()
+
+    // Throttle immediate upload kicks (ms)
+    @Volatile private var lastImmediateUploadKickMs: Long = 0
+    
+    // Write-first event buffer for crash-safe persistence
+    private var eventBuffer: EventBuffer? = null
+
+    // Coroutine scope for async operations
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    
+    // Dedicated scope for background flush - survives independently of main scope
+    // This prevents cancellation when app goes to background
+    private val backgroundScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+    // Timer jobs
+    private var batchUploadJob: Job? = null
+    private var durationLimitJob: Job? = null
+    
+    // Main thread handler for posting delayed tasks
+    private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
+
+    // Debounced background detection (prevents transient pauses from ending sessions)
+    private var scheduledBackgroundRunnable: Runnable? = null
+    private var backgroundScheduled: Boolean = false
+
+    // Safety flag
+    @Volatile private var isShuttingDown = false
+
+    // Auth resilience - retry mechanism
+    private var authRetryCount = 0
+    private var authPermanentlyFailed = false
+    private var authRetryJob: Job? = null
+
+    init {
+        // DO NOT initialize anything here that could throw exceptions
+        // React Native needs the module constructor to complete cleanly
+        // All initialization will happen lazily on first method call
+        Logger.debug("RejourneyModuleImpl constructor completed")
+    }
+    
+    // Lazy initialization flag
+    @Volatile
+    private var isInitialized = false
+    private val initLock = Any()
+    
+    /**
+     * Lazy initialization - called on first method invocation.
+     * This ensures the module constructor completes successfully for React Native.
+     */
+    private fun ensureInitialized() {
+        if (isInitialized) return
+        
+        synchronized(initLock) {
+            if (isInitialized) return
+            
+            try {
+                logReactNativeArchitecture()
+                setupComponents()
+                registerActivityLifecycleCallbacks()
+                registerProcessLifecycleObserver()
+                
+                // Start crash handler, ANR handler, and network monitor with error handling
+                try {
+                    CrashHandler.getInstance(reactContext).startMonitoring()
+                } catch (e: Exception) {
+                    Logger.error("Failed to start crash handler (non-critical)", e)
+                }
+                
+                try {
+                    ANRHandler.getInstance(reactContext).apply {
+                        listener = this@RejourneyModuleImpl
+                        startMonitoring()
+                    }
+                } catch (e: Exception) {
+                    Logger.error("Failed to start ANR handler (non-critical)", e)
+                }
+                
+                try {
+                    NetworkMonitor.getInstance(reactContext).startMonitoring()
+                } catch (e: Exception) {
+                    Logger.error("Failed to start network monitor (non-critical)", e)
+                }
+                
+                // Schedule recovery of any pending uploads from previous sessions
+                // This handles cases where the app was killed before uploads completed
+                try {
+                    UploadWorker.scheduleRecoveryUpload(reactContext)
+                } catch (e: Exception) {
+                    Logger.error("Failed to schedule recovery upload (non-critical)", e)
+                }
+                
+                // Check if app was killed in previous session (Android 11+)
+                try {
+                    checkPreviousAppKill()
+                } catch (e: Exception) {
+                    Logger.error("Failed to check previous app kill (non-critical)", e)
+                }
+                
+                // Check for unclosed sessions from previous launch
+                try {
+                    checkForUnclosedSessions()
+                } catch (e: Exception) {
+                    Logger.error("Failed to check for unclosed sessions (non-critical)", e)
+                }
+                
+                // Log OEM information for debugging
+                val oem = OEMDetector.getOEM()
+                Logger.debug("Device OEM: $oem")
+                Logger.debug("OEM Recommendations: ${OEMDetector.getRecommendations()}")
+                Logger.debug("onTaskRemoved() reliable: ${OEMDetector.isTaskRemovedReliable()}")
+                
+                // Set up SessionLifecycleService listener to detect app termination
+                try {
+                    SessionLifecycleService.taskRemovedListener = object : TaskRemovedListener {
+                        override fun onTaskRemoved() {
+                            Logger.debug("[Rejourney] App terminated via swipe-away - SYNCHRONOUS session end (OEM: $oem)")
+                            
+                            // CRITICAL: Use runBlocking to ensure session end completes BEFORE process death
+                            // The previous async implementation using scope.launch would not complete in time
+                            // because the process would be killed before the coroutine executed.
+                            if (isRecording && !sessionEndSent) {
+                                try {
+                                    // Use runBlocking with a timeout to ensure we don't block indefinitely
+                                    // but still give enough time for critical operations (HTTP calls)
+                                    runBlocking {
+                                        withTimeout(5000L) { // 5 second timeout
+                                            Logger.debug("[Rejourney] Starting synchronous session end...")
+                                            endSessionSynchronous()
+                                            Logger.debug("[Rejourney] Synchronous session end completed")
+                                        }
+                                    }
+                                } catch (e: TimeoutCancellationException) {
+                                    Logger.warning("[Rejourney] Session end timed out after 5s - WorkManager will recover")
+                                } catch (e: Exception) {
+                                    Logger.error("[Rejourney] Failed to end session on task removed", e)
+                                }
+                            } else {
+                                Logger.debug("[Rejourney] Session already ended or not recording - skipping")
+                            }
+                        }
+                    }
+                } catch (e: Exception) {
+                    Logger.error("Failed to set up task removed listener (non-critical)", e)
+                }
+                
+                // Use lifecycle log - only shown in debug builds
+                Logger.logInitSuccess(Constants.SDK_VERSION)
+                
+                isInitialized = true
+            } catch (e: Exception) {
+                Logger.logInitFailure("${e.javaClass.simpleName}: ${e.message}")
+                // Mark as initialized anyway to prevent retry loops
+                isInitialized = true
+            }
+        }
+    }
+    
+    /**
+     * Adds an event with immediate disk persistence for crash safety.
+     * This is the industry-standard approach for volume control.
+     */
+    private fun addEventWithPersistence(event: Map<String, Any?>) {
+        val eventType = event["type"]?.toString() ?: "unknown"
+        val sessionId = currentSessionId ?: "no-session"
+        
+        Logger.debug("[Rejourney] addEventWithPersistence: type=$eventType, sessionId=$sessionId, inMemoryCount=${sessionEvents.size + 1}")
+        
+        // CRITICAL: Write to disk immediately for crash safety
+        // This ensures events are never lost even if app is force-killed
+        val bufferSuccess = eventBuffer?.appendEvent(event) ?: false
+        if (!bufferSuccess) {
+            Logger.warning("[Rejourney] addEventWithPersistence: Failed to append event to buffer: type=$eventType")
+        } else {
+            Logger.debug("[Rejourney] addEventWithPersistence: Event appended to buffer: type=$eventType")
+        }
+
+        // Also add to in-memory buffer for batched upload
+        sessionEvents.add(event)
+        Logger.debug("[Rejourney] addEventWithPersistence: Event added to in-memory list: type=$eventType, totalInMemory=${sessionEvents.size}")
+    }
+    
+    /**
+     * Register with ProcessLifecycleOwner for reliable app foreground/background detection.
+     * This is more reliable than Activity lifecycle callbacks.
+     */
+    private fun registerProcessLifecycleObserver() {
+        // Must run on main thread
+        Handler(Looper.getMainLooper()).post {
+            try {
+                ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+                Logger.debug("ProcessLifecycleOwner observer registered")
+            } catch (e: Exception) {
+                Logger.error("Failed to register ProcessLifecycleOwner observer (non-critical)", e)
+                // This is non-critical - we can still use Activity lifecycle callbacks as fallback
+            }
+        }
+    }
+
+    /**
+     * Log which React Native architecture is being used.
+     */
+    private fun logReactNativeArchitecture() {
+        val archType = if (isNewArchitecture) "New Architecture (TurboModules)" else "Old Architecture (Bridge)"
+        Logger.logArchitectureInfo(isNewArchitecture, archType)
+    }
+
+    private fun setupComponents() {
+        try {
+            // Initialize capture engine with video segment mode
+            captureEngine = CaptureEngine(reactContext).apply {
+                captureScale = Constants.DEFAULT_CAPTURE_SCALE
+                minFrameInterval = Constants.DEFAULT_MIN_FRAME_INTERVAL
+                maxFramesPerMinute = Constants.DEFAULT_MAX_FRAMES_PER_MINUTE
+                targetBitrate = Constants.DEFAULT_VIDEO_BITRATE
+                targetFps = Constants.DEFAULT_VIDEO_FPS
+                framesPerSegment = Constants.DEFAULT_FRAMES_PER_SEGMENT
+                delegate = this@RejourneyModuleImpl
+            }
+            Logger.debug("CaptureEngine initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize CaptureEngine", e)
+            captureEngine = null
+        }
+
+        try {
+            // Initialize upload manager
+            uploadManager = UploadManager(reactContext, "https://api.rejourney.co")
+            Logger.debug("UploadManager initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize UploadManager", e)
+            uploadManager = null
+        }
+
+        try {
+            // Initialize touch interceptor
+            touchInterceptor = TouchInterceptor.getInstance(reactContext).apply {
+                delegate = this@RejourneyModuleImpl
+            }
+            Logger.debug("TouchInterceptor initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize TouchInterceptor", e)
+            touchInterceptor = null
+        }
+
+        try {
+            // Initialize device auth manager
+            deviceAuthManager = DeviceAuthManager.getInstance(reactContext).apply {
+                authFailureListener = this@RejourneyModuleImpl
+            }
+            Logger.debug("DeviceAuthManager initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize DeviceAuthManager", e)
+            deviceAuthManager = null
+        }
+
+        try {
+            // Initialize network monitor
+            networkMonitor = NetworkMonitor.getInstance(reactContext).apply {
+                listener = this@RejourneyModuleImpl
+            }
+            Logger.debug("NetworkMonitor initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize NetworkMonitor", e)
+            networkMonitor = null
+        }
+        
+        try {
+            // Initialize keyboard tracker (for keyboard show/hide events)
+            keyboardTracker = KeyboardTracker.getInstance(reactContext).apply {
+                listener = this@RejourneyModuleImpl
+            }
+            Logger.debug("KeyboardTracker initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize KeyboardTracker", e)
+            keyboardTracker = null
+        }
+        
+        try {
+            // Initialize text input tracker (for key press counting)
+            textInputTracker = TextInputTracker.getInstance(reactContext).apply {
+                listener = this@RejourneyModuleImpl
+            }
+            Logger.debug("TextInputTracker initialized")
+        } catch (e: Exception) {
+            Logger.error("Failed to initialize TextInputTracker", e)
+            textInputTracker = null
+        }
+    }
+
+    private fun registerActivityLifecycleCallbacks() {
+        try {
+            val application = reactContext.applicationContext as? Application
+            if (application != null) {
+                application.registerActivityLifecycleCallbacks(this)
+                Logger.debug("Activity lifecycle callbacks registered")
+            } else {
+                Logger.error("Failed to register activity lifecycle callbacks - application context is not Application type")
+            }
+        } catch (e: Exception) {
+            Logger.error("Failed to register activity lifecycle callbacks", e)
+        }
+    }
+
+    fun invalidate() {
+        isShuttingDown = true
+        scope.cancel()
+        stopBatchUploadTimer()
+        stopDurationLimitTimer()
+        touchInterceptor?.disableGlobalTracking()
+        keyboardTracker?.stopTracking()
+        textInputTracker?.stopTracking()
+        networkMonitor?.stopMonitoring()
+        
+        val application = reactContext.applicationContext as? Application
+        application?.unregisterActivityLifecycleCallbacks(this)
+        
+        // Unregister from ProcessLifecycleOwner
+        Handler(Looper.getMainLooper()).post {
+            try {
+                ProcessLifecycleOwner.get().lifecycle.removeObserver(this)
+            } catch (e: Exception) {
+                // Ignore
+            }
+        }
+    }
+
+    // ==================== React Native Methods ====================
+
+    fun startSession(userId: String, apiUrl: String, publicKey: String, promise: Promise) {
+        ensureInitialized() // Lazy init on first call
+        
+        if (isShuttingDown) {
+            promise.resolve(createResultMap(false, "", "Module is shutting down"))
+            return
+        }
+
+        // Optimistically allow start; remote config will shut down if disabled.
+        remoteRejourneyEnabled = true
+
+        scope.launch {
+            try {
+                if (isRecording) {
+                    promise.resolve(createResultMap(true, currentSessionId ?: ""))
+                    return@launch
+                }
+
+                val safeUserId = userId.ifEmpty { "anonymous" }
+                val safeApiUrl = apiUrl.ifEmpty { "https://api.rejourney.co" }
+                val safePublicKey = publicKey.ifEmpty { "" }
+
+                // Generate device hash
+                val androidId = Settings.Secure.getString(
+                    reactContext.contentResolver,
+                    Settings.Secure.ANDROID_ID
+                ) ?: "unknown"
+                val deviceHash = generateSHA256Hash(androidId)
+
+                // Setup session
+                this@RejourneyModuleImpl.userId = safeUserId
+                currentSessionId = WindowUtils.generateSessionId()
+                sessionStartTime = System.currentTimeMillis()
+                totalBackgroundTimeMs = 0
+                sessionEndSent = false
+                sessionEvents.clear()
+
+                // Reset remote recording flag for this session until config says otherwise
+                remoteRecordingEnabled = true
+                recordingEnabledByConfig = true
+                projectSampleRate = 100
+                hasProjectConfig = false
+                resetSamplingDecision()
+
+                // Save session ID for crash handler
+                reactContext.getSharedPreferences("rejourney", 0)
+                    .edit()
+                    .putString("rj_current_session_id", currentSessionId)
+                    .apply()
+
+                // Configure upload manager
+                uploadManager?.apply {
+                    this.apiUrl = safeApiUrl
+                    this.publicKey = safePublicKey
+                    this.deviceHash = deviceHash
+                    // NUCLEAR FIX: Use setActiveSessionId() to protect from recovery corruption
+                    setActiveSessionId(currentSessionId!!)
+                    this.userId = safeUserId
+                    this.sessionStartTime = this@RejourneyModuleImpl.sessionStartTime
+                    resetForNewSession()
+                }
+
+                // Mark session active for crash recovery (disk-backed)
+                currentSessionId?.let { sid ->
+                    uploadManager?.markSessionActive(sid, sessionStartTime)
+                    
+                    // Also save to SharedPreferences for unclosed session detection
+                    reactContext.getSharedPreferences("rejourney", 0)
+                        .edit()
+                        .putString("rj_current_session_id", sid)
+                        .putLong("rj_session_start_time", sessionStartTime)
+                        .apply()
+                }
+                
+                // Initialize write-first event buffer for crash-safe persistence
+                val pendingDir = java.io.File(reactContext.cacheDir, "rj_pending")
+                currentSessionId?.let { sid ->
+                    eventBuffer = EventBuffer(reactContext, sid, pendingDir)
+                }
+                
+                // Save config for auto-resume on quick background return
+                savedApiUrl = safeApiUrl
+                savedPublicKey = safePublicKey
+                savedDeviceHash = deviceHash
+
+                // Start capture engine only if recording is enabled remotely
+                if (remoteRecordingEnabled) {
+                    captureEngine?.startSession(currentSessionId!!)
+                }
+
+                // Enable touch tracking
+                touchInterceptor?.enableGlobalTracking()
+                
+                // Start keyboard and text input tracking
+                keyboardTracker?.startTracking()
+                textInputTracker?.startTracking()
+
+                // Mark as recording
+                isRecording = true
+                
+                // Start SessionLifecycleService to detect app termination
+                try {
+                    val serviceIntent = Intent(reactContext, SessionLifecycleService::class.java)
+                    reactContext.startService(serviceIntent)
+                    Logger.debug("SessionLifecycleService started")
+                } catch (e: Exception) {
+                    Logger.warning("Failed to start SessionLifecycleService: ${e.message}")
+                }
+
+                // Start batch uploads
+                startBatchUploadTimer()
+                startDurationLimitTimer()
+                
+                // Emit app_startup event with startup duration
+                // This is the time from process start to session start
+                val nowMs = System.currentTimeMillis()
+                val startupDurationMs = nowMs - processStartTimeMs
+                if (startupDurationMs > 0 && startupDurationMs < 60000) { // Sanity check: < 60s
+                    val startupEvent = mapOf(
+                        "type" to "app_startup",
+                        "timestamp" to nowMs,
+                        "durationMs" to startupDurationMs,
+                        "platform" to "android"
+                    )
+                    addEventWithPersistence(startupEvent)
+                    Logger.debug("Recorded app startup time: ${startupDurationMs}ms")
+                }
+
+                // Fetch project config
+                fetchProjectConfig(safePublicKey, safeApiUrl)
+
+                // Register device
+                registerDevice(safePublicKey, safeApiUrl)
+
+                // Use lifecycle log for session start - only shown in debug builds
+                Logger.logSessionStart(currentSessionId ?: "")
+
+                promise.resolve(createResultMap(true, currentSessionId ?: ""))
+            } catch (e: Exception) {
+                Logger.error("Failed to start session", e)
+                isRecording = false
+                promise.resolve(createResultMap(false, "", e.message))
+            }
+        }
+    }
+
+    fun stopSession(promise: Promise) {
+        if (isShuttingDown) {
+            promise.resolve(createStopResultMap(false, "", false, null, "Module is shutting down"))
+            return
+        }
+
+        scope.launch {
+            try {
+                if (!isRecording) {
+                    promise.resolve(createStopResultMap(false, "", false, "Not recording", null))
+                    return@launch
+                }
+
+                val sessionId = currentSessionId ?: ""
+
+                // Stop timers
+                stopBatchUploadTimer()
+                stopDurationLimitTimer()
+
+                // Force final capture
+                if (remoteRecordingEnabled) {
+                    captureEngine?.forceCaptureWithReason("session_end")
+                }
+
+                // Stop capture engine (triggers final segment upload via delegate)
+                captureEngine?.stopSession()
+
+                // Disable touch tracking
+                touchInterceptor?.disableGlobalTracking()
+
+                // Build metrics for promotion evaluation
+                var crashCount = 0
+                var anrCount = 0
+                var errorCount = 0
+                for (event in sessionEvents) {
+                    when (event["type"]) {
+                        "crash" -> crashCount++
+                        "anr" -> anrCount++
+                        "error" -> errorCount++
+                    }
+                }
+                val durationSeconds = ((System.currentTimeMillis() - sessionStartTime) / 1000).toInt()
+                
+                val metrics = mapOf(
+                    "crashCount" to crashCount,
+                    "anrCount" to anrCount,
+                    "errorCount" to errorCount,
+                    "durationSeconds" to durationSeconds
+                )
+
+                // Evaluate replay promotion
+                val promotionResult = uploadManager?.evaluateReplayPromotion(metrics)
+                val isPromoted = promotionResult?.first ?: false
+                val reason = promotionResult?.second ?: "unknown"
+
+                if (isPromoted) {
+                    Logger.debug("Session promoted (reason: $reason)")
+                } else {
+                    Logger.debug("Session not promoted (reason: $reason)")
+                }
+
+                // Upload remaining events (video segments uploaded via delegate callbacks)
+                val uploadSuccess = uploadManager?.uploadBatch(sessionEvents.toList(), isFinal = true) ?: false
+
+                // Send session end signal if not already sent
+                var endSessionSuccess = sessionEndSent // Already sent counts as success
+                if (!sessionEndSent) {
+                    sessionEndSent = true
+                    endSessionSuccess = uploadManager?.endSession() ?: false
+                    if (!endSessionSuccess) {
+                        Logger.warning("Session end signal may have failed")
+                    }
+                }
+
+                // Clear crash recovery markers only if the session is actually closed
+                if (endSessionSuccess) {
+                    currentSessionId?.let { sid ->
+                        uploadManager?.clearSessionRecovery(sid)
+                        
+                        // Mark session as closed in SharedPreferences
+                        reactContext.getSharedPreferences("rejourney", 0)
+                            .edit()
+                            .putLong("rj_session_end_time_$sid", System.currentTimeMillis())
+                            .remove("rj_current_session_id")
+                            .remove("rj_session_start_time")
+                            .apply()
+                    }
+                }
+
+                // Clear state
+                isRecording = false
+                currentSessionId = null
+                this@RejourneyModuleImpl.userId = null
+                sessionEvents.clear()
+                
+                // Stop SessionLifecycleService
+                try {
+                    val serviceIntent = Intent(reactContext, SessionLifecycleService::class.java)
+                    reactContext.stopService(serviceIntent)
+                    Logger.debug("SessionLifecycleService stopped")
+                } catch (e: Exception) {
+                    Logger.warning("Failed to stop SessionLifecycleService: ${e.message}")
+                }
+
+                // Use lifecycle log for session end - only shown in debug builds
+                Logger.logSessionEnd(sessionId)
+
+                promise.resolve(createStopResultMap(true, sessionId, uploadSuccess && endSessionSuccess, null, null))
+            } catch (e: Exception) {
+                Logger.error("Failed to stop session", e)
+                isRecording = false
+                promise.resolve(createStopResultMap(false, currentSessionId ?: "", false, null, e.message))
+            }
+        }
+    }
+
+    fun logEvent(eventType: String, details: ReadableMap, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            val event = mapOf(
+                "type" to eventType,
+                "timestamp" to System.currentTimeMillis(),
+                "details" to details.toHashMap()
+            )
+            addEventWithPersistence(event)
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            Logger.error("Failed to log event", e)
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun screenChanged(screenName: String, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            Logger.debug("Screen changed to: $screenName")
+            
+            val event = mapOf(
+                "type" to EventType.NAVIGATION,
+                "timestamp" to System.currentTimeMillis(),
+                "screenName" to screenName
+            )
+            addEventWithPersistence(event)
+
+            // Notify capture engine with delay for render
+            scope.launch {
+                delay(100)
+                captureEngine?.notifyNavigationToScreen(screenName)
+                captureEngine?.notifyReactNativeCommit()
+            }
+
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            Logger.error("Failed to handle screen change", e)
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun onScroll(offsetY: Double, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            captureEngine?.notifyScrollOffset(offsetY.toFloat())
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun markVisualChange(reason: String, importance: String, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(false)
+            return
+        }
+
+        try {
+            val importanceLevel = when (importance.lowercase()) {
+                "low" -> com.rejourney.core.CaptureImportance.LOW
+                "medium" -> com.rejourney.core.CaptureImportance.MEDIUM
+                "high" -> com.rejourney.core.CaptureImportance.HIGH
+                "critical" -> com.rejourney.core.CaptureImportance.CRITICAL
+                else -> com.rejourney.core.CaptureImportance.MEDIUM
+            }
+            captureEngine?.notifyVisualChange(reason, importanceLevel)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    fun onExternalURLOpened(urlScheme: String, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            val event = mapOf(
+                "type" to EventType.EXTERNAL_URL_OPENED,
+                "timestamp" to System.currentTimeMillis(),
+                "urlScheme" to urlScheme
+            )
+            addEventWithPersistence(event)
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun onOAuthStarted(provider: String, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            val event = mapOf(
+                "type" to EventType.OAUTH_STARTED,
+                "timestamp" to System.currentTimeMillis(),
+                "provider" to provider
+            )
+            addEventWithPersistence(event)
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun onOAuthCompleted(provider: String, success: Boolean, promise: Promise) {
+        if (!isRecording || isShuttingDown) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            val event = mapOf(
+                "type" to EventType.OAUTH_COMPLETED,
+                "timestamp" to System.currentTimeMillis(),
+                "provider" to provider,
+                "success" to success
+            )
+            addEventWithPersistence(event)
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun getSDKMetrics(promise: Promise) {
+        try {
+            val metrics = Telemetry.getInstance().currentMetrics()
+            val map = Arguments.createMap().apply {
+                putInt("uploadSuccessCount", metrics.uploadSuccessCount)
+                putInt("uploadFailureCount", metrics.uploadFailureCount)
+                putInt("retryAttemptCount", metrics.retryAttemptCount)
+                putInt("circuitBreakerOpenCount", metrics.circuitBreakerOpenCount)
+                putInt("memoryEvictionCount", metrics.memoryEvictionCount)
+                putInt("offlinePersistCount", metrics.offlinePersistCount)
+                putInt("sessionStartCount", metrics.sessionStartCount)
+                putInt("crashCount", metrics.crashCount)
+                putInt("anrCount", metrics.anrCount)
+                putDouble("uploadSuccessRate", metrics.uploadSuccessRate.toDouble())
+                putDouble("avgUploadDurationMs", metrics.avgUploadDurationMs.toDouble())
+                putInt("currentQueueDepth", metrics.currentQueueDepth)
+                metrics.lastUploadTime?.let { value -> putDouble("lastUploadTime", value.toDouble()) }
+                metrics.lastRetryTime?.let { value -> putDouble("lastRetryTime", value.toDouble()) }
+                putDouble("totalBytesUploaded", metrics.totalBytesUploaded.toDouble())
+                putDouble("totalBytesEvicted", metrics.totalBytesEvicted.toDouble())
+            }
+            promise.resolve(map)
+        } catch (e: Exception) {
+            Logger.error("Failed to get SDK metrics", e)
+            promise.resolve(Arguments.createMap())
+        }
+    }
+
+    fun setDebugMode(enabled: Boolean, promise: Promise) {
+        try {
+            Logger.setDebugMode(enabled)
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun debugCrash() {
+        Logger.debug("Triggering debug crash...")
+        scope.launch(Dispatchers.Main) {
+            throw RuntimeException("This is a test crash triggered from React Native")
+        }
+    }
+
+    fun debugTriggerANR(durationMs: Double) {
+        Logger.debug("Triggering debug ANR for ${durationMs.toLong()}ms...")
+        // Post to main looper to block the main thread
+        Handler(Looper.getMainLooper()).post {
+            try {
+                Thread.sleep(durationMs.toLong())
+            } catch (e: InterruptedException) {
+                e.printStackTrace()
+            }
+        }
+    }
+
+    fun getSessionId(promise: Promise) {
+        promise.resolve(currentSessionId)
+    }
+
+    // ==================== Privacy / View Masking ====================
+
+    fun maskViewByNativeID(nativeID: String, promise: Promise) {
+        if (nativeID.isEmpty()) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            // Add nativeID to the privacy mask set - will be checked during capture
+            // This is robust because we don't need to find the view immediately
+            com.rejourney.privacy.PrivacyMask.addMaskedNativeID(nativeID)
+            Logger.debug("Masked nativeID: $nativeID")
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            Logger.warning("maskViewByNativeID failed: ${e.message}")
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    fun unmaskViewByNativeID(nativeID: String, promise: Promise) {
+        if (nativeID.isEmpty()) {
+            promise.resolve(createSuccessMap(false))
+            return
+        }
+
+        try {
+            // Remove nativeID from the privacy mask set
+            com.rejourney.privacy.PrivacyMask.removeMaskedNativeID(nativeID)
+            Logger.debug("Unmasked nativeID: $nativeID")
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            Logger.warning("unmaskViewByNativeID failed: ${e.message}")
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    /**
+     * Recursively find a view with a given nativeID.
+     * In React Native, nativeID is typically stored in the view's tag or as a resource ID.
+     */
+    private fun findViewByNativeID(view: android.view.View, nativeID: String): android.view.View? {
+        // Check if view has matching tag (common RN pattern)
+        val viewTag = view.getTag(com.facebook.react.R.id.view_tag_native_id)
+        if (viewTag is String && viewTag == nativeID) {
+            return view
+        }
+
+        // Recurse into ViewGroup children
+        if (view is android.view.ViewGroup) {
+            for (i in 0 until view.childCount) {
+                val child = view.getChildAt(i)
+                val found = findViewByNativeID(child, nativeID)
+                if (found != null) return found
+            }
+        }
+
+        return null
+    }
+
+    // ==================== User Identity ====================
+
+    fun setUserIdentity(userId: String, promise: Promise) {
+        try {
+            val safeUserId = userId.ifEmpty { "anonymous" }
+            
+            // Update userId
+            this.userId = safeUserId
+            
+            // Update upload manager
+            uploadManager?.userId = safeUserId
+            
+            Logger.debug("User identity updated: $safeUserId")
+            
+            // Log event for tracking
+            if (isRecording) {
+                val event = mapOf(
+                    "type" to "user_identity_changed",
+                    "timestamp" to System.currentTimeMillis(),
+                    "userId" to safeUserId
+                )
+                addEventWithPersistence(event)
+            }
+            
+            promise.resolve(createSuccessMap(true))
+        } catch (e: Exception) {
+            Logger.warning("setUserIdentity failed: ${e.message}")
+            promise.resolve(createSuccessMap(false))
+        }
+    }
+
+    // ==================== Helper Methods ====================
+
+    private fun createResultMap(success: Boolean, sessionId: String, error: String? = null): WritableMap {
+        return Arguments.createMap().apply {
+            putBoolean("success", success)
+            putString("sessionId", sessionId)
+            error?.let { putString("error", it) }
+        }
+    }
+
+    private fun createStopResultMap(
+        success: Boolean, 
+        sessionId: String, 
+        uploadSuccess: Boolean,
+        warning: String?,
+        error: String?
+    ): WritableMap {
+        return Arguments.createMap().apply {
+            putBoolean("success", success)
+            putString("sessionId", sessionId)
+            putBoolean("uploadSuccess", uploadSuccess)
+            warning?.let { putString("warning", it) }
+            error?.let { putString("error", it) }
+        }
+    }
+
+    private fun createSuccessMap(success: Boolean): WritableMap {
+        return Arguments.createMap().apply {
+            putBoolean("success", success)
+        }
+    }
+
+    private fun generateSHA256Hash(input: String): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        val hash = digest.digest(input.toByteArray())
+        return hash.joinToString("") { "%02x".format(it) }
+    }
+
+    private fun resetSamplingDecision() {
+        sessionSampled = true
+        hasSampleDecision = false
+    }
+
+    private fun shouldSampleSession(sampleRate: Int): Boolean {
+        val clampedRate = sampleRate.coerceIn(0, 100)
+        if (clampedRate >= 100) return true
+        if (clampedRate <= 0) return false
+        return Random().nextInt(100) < clampedRate
+    }
+
+    private fun updateRecordingEligibility(sampleRate: Int = projectSampleRate): Boolean {
+        val clampedRate = sampleRate.coerceIn(0, 100)
+        projectSampleRate = clampedRate
+
+        val decidedSample = if (!hasSampleDecision) {
+            sessionSampled = shouldSampleSession(clampedRate)
+            hasSampleDecision = true
+            true
+        } else {
+            false
+        }
+
+        val shouldRecord = recordingEnabledByConfig && sessionSampled
+        remoteRecordingEnabled = shouldRecord
+
+        if (!shouldRecord && captureEngine?.isRecording == true) {
+            captureEngine?.stopSession()
+        }
+
+        if (decidedSample && recordingEnabledByConfig && !sessionSampled) {
+            Logger.warning("Session skipped by sample rate (${clampedRate}%)")
+        }
+
+        return shouldRecord
+    }
+
+    private fun startBatchUploadTimer() {
+        stopBatchUploadTimer()
+        batchUploadJob = scope.launch {
+            delay((Constants.INITIAL_UPLOAD_DELAY * 1000).toLong())
+            while (isActive && isRecording) {
+                performBatchUpload()
+                delay((Constants.BATCH_UPLOAD_INTERVAL * 1000).toLong())
+            }
+        }
+    }
+
+    /**
+     * Best-effort: trigger an upload/persist attempt soon after a keyframe is captured.
+     * This materially improves crash sessions (more frames make it to disk quickly).
+     */
+    private fun scheduleImmediateUploadKick() {
+        if (!isRecording || isShuttingDown) return
+
+        val now = System.currentTimeMillis()
+        if (now - lastImmediateUploadKickMs < 1_000L) return
+        lastImmediateUploadKickMs = now
+
+        scope.launch {
+            try {
+                performBatchUpload()
+            } catch (_: Exception) {
+                // Best-effort only
+            }
+        }
+    }
+
+    private fun stopBatchUploadTimer() {
+        batchUploadJob?.cancel()
+        batchUploadJob = null
+    }
+
+    private fun startDurationLimitTimer() {
+        stopDurationLimitTimer()
+        val maxMs = maxRecordingMinutes * 60 * 1000L
+        val elapsed = System.currentTimeMillis() - sessionStartTime
+        val remaining = maxMs - elapsed
+        
+        if (remaining > 0) {
+            durationLimitJob = scope.launch {
+                delay(remaining)
+                if (isRecording) {
+                    Logger.warning("Recording duration limit reached, stopping session")
+                    stopSessionInternal()
+                }
+            }
+        }
+    }
+
+    private fun stopDurationLimitTimer() {
+        durationLimitJob?.cancel()
+        durationLimitJob = null
+    }
+
+    private suspend fun performBatchUpload() {
+        if (!isRecording || isShuttingDown) return
+
+        try {
+            // Video segments are uploaded via CaptureEngineDelegate callbacks.
+            // This timer now only handles event uploads.
+
+            val eventsToUpload = sessionEvents.toList()
+
+            if (eventsToUpload.isEmpty()) return
+
+            // Upload events only (video segments uploaded via delegate)
+            val ok = uploadManager?.uploadBatch(eventsToUpload) ?: false
+
+            if (ok) {
+                // Only clear events after data is safely uploaded
+                sessionEvents.clear()
+            }
+        } catch (e: CancellationException) {
+            // Normal cancellation (e.g., app going to background) - not an error
+            // WorkManager will handle the upload instead
+            Logger.debug("Batch upload cancelled (coroutine cancelled)")
+            throw e // Re-throw to propagate cancellation
+        } catch (e: Exception) {
+            Logger.error("Batch upload failed", e)
+        }
+    }
+
+    private suspend fun stopSessionInternal() {
+        if (!isRecording) return
+
+        try {
+            stopBatchUploadTimer()
+            stopDurationLimitTimer()
+            captureEngine?.stopSession()
+            isRecording = false
+            currentSessionId = null
+            userId = null
+            sessionEvents.clear()
+        } catch (e: Exception) {
+            Logger.error("Failed to stop session internally", e)
+        }
+    }
+
+    /**
+     * End the current session with a specific reason.
+     */
+    private fun endSession(reason: EndReason, promise: Promise?) {
+        scope.launch {
+            try {
+                if (!isRecording) {
+                    promise?.resolve(createStopResultMap(false, "", false, "Not recording", null))
+                    return@launch
+                }
+
+                val sessionId = currentSessionId ?: ""
+                Logger.debug("Ending session due to: $reason")
+
+                // Stop timers
+                stopBatchUploadTimer()
+                stopDurationLimitTimer()
+
+                // Force final capture
+                if (remoteRecordingEnabled) {
+                    captureEngine?.forceCaptureWithReason("session_end_${reason.name.lowercase()}")
+                }
+
+                // Stop capture engine
+                captureEngine?.stopSession()
+
+                // Disable touch tracking
+                touchInterceptor?.disableGlobalTracking()
+                keyboardTracker?.stopTracking()
+                textInputTracker?.stopTracking()
+
+                // Build metrics
+                var crashCount = 0
+                var anrCount = 0
+                var errorCount = 0
+                for (event in sessionEvents) {
+                    when (event["type"]) {
+                        "crash" -> crashCount++
+                        "anr" -> anrCount++
+                        "error" -> errorCount++
+                    }
+                }
+                val durationSeconds = ((System.currentTimeMillis() - sessionStartTime) / 1000).toInt()
+                
+                val metrics = mapOf(
+                    "crashCount" to crashCount,
+                    "anrCount" to anrCount,
+                    "errorCount" to errorCount,
+                    "durationSeconds" to durationSeconds
+                )
+
+                // Evaluate promotion
+                val promotionResult = uploadManager?.evaluateReplayPromotion(metrics)
+                val isPromoted = promotionResult?.first ?: false
+                val promotionReason = promotionResult?.second ?: "unknown"
+
+                if (isPromoted) {
+                    Logger.debug("Session promoted (reason: $promotionReason)")
+                }
+
+                // Upload remaining events
+                val uploadSuccess = uploadManager?.uploadBatch(sessionEvents.toList(), isFinal = true) ?: false
+
+                // Send session end signal
+                var endSessionSuccess = sessionEndSent
+                if (!sessionEndSent) {
+                    sessionEndSent = true
+                    endSessionSuccess = uploadManager?.endSession() ?: false
+                }
+
+                // Clear recovery markers
+                if (endSessionSuccess) {
+                    currentSessionId?.let { sid ->
+                        uploadManager?.clearSessionRecovery(sid)
+                        
+                        // Mark session as closed in SharedPreferences
+                        reactContext.getSharedPreferences("rejourney", 0)
+                            .edit()
+                            .putLong("rj_session_end_time_$sid", System.currentTimeMillis())
+                            .remove("rj_current_session_id")
+                            .remove("rj_session_start_time")
+                            .apply()
+                    }
+                }
+
+                // Clear state
+                isRecording = false
+                currentSessionId = null
+                userId = null
+                sessionEvents.clear()
+                
+                // Stop SessionLifecycleService
+                try {
+                    val serviceIntent = Intent(reactContext, SessionLifecycleService::class.java)
+                    reactContext.stopService(serviceIntent)
+                    Logger.debug("SessionLifecycleService stopped")
+                } catch (e: Exception) {
+                    Logger.warning("Failed to stop SessionLifecycleService: ${e.message}")
+                }
+
+                Logger.logSessionEnd(sessionId)
+                promise?.resolve(createStopResultMap(true, sessionId, uploadSuccess && endSessionSuccess, null, null))
+            } catch (e: Exception) {
+                Logger.error("Failed to end session", e)
+                isRecording = false
+                promise?.resolve(createStopResultMap(false, currentSessionId ?: "", false, null, e.message))
+            }
+        }
+    }
+
+    /**
+     * Synchronous session end for use with runBlocking when app is being killed.
+     * 
+     * This is called from onTaskRemoved where we need to complete session end
+     * BEFORE the process is killed. Unlike endSession() which uses scope.launch,
+     * this is a suspend function that runs in the calling coroutine context.
+     */
+    private suspend fun endSessionSynchronous() {
+        if (!isRecording) {
+            Logger.debug("[Rejourney] endSessionSynchronous: Not recording, skipping")
+            return
+        }
+
+        val sessionId = currentSessionId ?: ""
+        Logger.debug("[Rejourney] endSessionSynchronous: Starting for session $sessionId")
+
+        try {
+            // Stop timers (synchronous)
+            stopBatchUploadTimer()
+            stopDurationLimitTimer()
+
+            // Force final capture
+            if (remoteRecordingEnabled) {
+                try {
+                    captureEngine?.forceCaptureWithReason("session_end_kill")
+                } catch (e: Exception) {
+                    Logger.warning("[Rejourney] Final capture failed: ${e.message}")
+                }
+            }
+
+            // Stop capture engine
+            try {
+                captureEngine?.stopSession()
+            } catch (e: Exception) {
+                Logger.warning("[Rejourney] Stop capture failed: ${e.message}")
+            }
+
+            // Disable tracking
+            try {
+                touchInterceptor?.disableGlobalTracking()
+                keyboardTracker?.stopTracking()
+                textInputTracker?.stopTracking()
+            } catch (e: Exception) {
+                Logger.warning("[Rejourney] Stop tracking failed: ${e.message}")
+            }
+
+            // Build metrics
+            var crashCount = 0
+            var anrCount = 0
+            var errorCount = 0
+            for (event in sessionEvents) {
+                when (event["type"]) {
+                    "crash" -> crashCount++
+                    "anr" -> anrCount++
+                    "error" -> errorCount++
+                }
+            }
+            val durationSeconds = ((System.currentTimeMillis() - sessionStartTime) / 1000).toInt()
+
+            // Upload remaining events - THIS IS THE CRITICAL HTTP CALL
+            Logger.debug("[Rejourney] endSessionSynchronous: Uploading final events (count=${sessionEvents.size})")
+            val uploadSuccess = try {
+                uploadManager?.uploadBatch(sessionEvents.toList(), isFinal = true) ?: false
+            } catch (e: Exception) {
+                Logger.warning("[Rejourney] Final upload failed: ${e.message}")
+                false
+            }
+            Logger.debug("[Rejourney] endSessionSynchronous: Upload result=$uploadSuccess")
+
+            // Send session end signal - THIS IS THE CRITICAL /session/end CALL
+            if (!sessionEndSent) {
+                sessionEndSent = true
+                Logger.debug("[Rejourney] endSessionSynchronous: Calling /session/end... (sessionId=$sessionId)")
+                
+                // CRITICAL: Ensure uploadManager has the correct sessionId
+                // Prior handleAppBackground may have cleared it, so we restore it here
+                if (sessionId.isNotEmpty()) {
+                    uploadManager?.sessionId = sessionId
+                }
+                
+                val endSuccess = try {
+                    uploadManager?.endSession() ?: false
+                } catch (e: Exception) {
+                    Logger.warning("[Rejourney] Session end API call failed: ${e.message}")
+                    false
+                }
+                Logger.debug("[Rejourney] endSessionSynchronous: /session/end result=$endSuccess")
+
+                // Clear recovery markers if successful
+                if (endSuccess) {
+                    try {
+                        uploadManager?.clearSessionRecovery(sessionId)
+                        reactContext.getSharedPreferences("rejourney", 0)
+                            .edit()
+                            .putLong("rj_session_end_time_$sessionId", System.currentTimeMillis())
+                            .remove("rj_current_session_id")
+                            .remove("rj_session_start_time")
+                            .apply()
+                    } catch (e: Exception) {
+                        Logger.warning("[Rejourney] Clear recovery failed: ${e.message}")
+                    }
+                }
+            }
+
+            // Clear state
+            isRecording = false
+            currentSessionId = null
+            userId = null
+            sessionEvents.clear()
+
+            Logger.debug("[Rejourney] endSessionSynchronous: Completed successfully")
+        } catch (e: Exception) {
+            Logger.error("[Rejourney] endSessionSynchronous: Error", e)
+            isRecording = false
+        }
+    }
+
+    /**
+     * Internal method to start recording with options.
+     */
+    private suspend fun startRecordingInternal(
+        options: Map<String, Any?>?,
+        sessionId: String,
+        source: String
+    ) {
+        if (isRecording) {
+            Logger.debug("Already recording, ignoring start request from $source")
+            return
+        }
+
+        // Use saved config from previous session
+        val safeUserId = userId ?: "anonymous"
+        val safeApiUrl = savedApiUrl.ifEmpty { "https://api.rejourney.co" }
+        val safePublicKey = savedPublicKey.ifEmpty { "" }
+        val deviceHash = savedDeviceHash
+
+        // Setup session
+        this.userId = safeUserId
+        currentSessionId = sessionId
+        sessionStartTime = System.currentTimeMillis()
+        totalBackgroundTimeMs = 0
+        sessionEndSent = false
+        sessionEvents.clear()
+        resetSamplingDecision()
+        remoteRecordingEnabled = recordingEnabledByConfig
+        if (hasProjectConfig) {
+            updateRecordingEligibility(projectSampleRate)
+        }
+
+        // Save session ID for crash handler
+        reactContext.getSharedPreferences("rejourney", 0)
+            .edit()
+            .putString("rj_current_session_id", currentSessionId)
+            .apply()
+
+        // Configure upload manager
+        uploadManager?.apply {
+            this.apiUrl = safeApiUrl
+            this.publicKey = safePublicKey
+            this.deviceHash = deviceHash
+            // NUCLEAR FIX: Use setActiveSessionId() to protect from recovery corruption
+            setActiveSessionId(currentSessionId!!)
+            this.userId = safeUserId
+            this.sessionStartTime = this@RejourneyModuleImpl.sessionStartTime
+            resetForNewSession()
+        }
+
+        // Mark session active
+        currentSessionId?.let { sid ->
+            uploadManager?.markSessionActive(sid, sessionStartTime)
+        }
+
+        // Initialize event buffer
+        val pendingDir = File(reactContext.cacheDir, "rj_pending")
+        currentSessionId?.let { sid ->
+            eventBuffer = EventBuffer(reactContext, sid, pendingDir)
+        }
+
+        // Start capture
+        if (remoteRecordingEnabled) {
+            captureEngine?.startSession(currentSessionId!!)
+        }
+
+        // Enable tracking
+        touchInterceptor?.enableGlobalTracking()
+        keyboardTracker?.startTracking()
+        textInputTracker?.startTracking()
+
+        isRecording = true
+        startBatchUploadTimer()
+        startDurationLimitTimer()
+
+        Logger.logSessionStart(currentSessionId ?: "")
+    }
+
+    private fun fetchProjectConfig(publicKey: String, apiUrl: String) {
+        scope.launch(Dispatchers.IO) {
+            try {
+                uploadManager?.fetchProjectConfig { success, config ->
+                    if (success && config != null) {
+                        hasProjectConfig = true
+
+                        config["maxRecordingMinutes"]?.let { maxMinutes ->
+                            scope.launch(Dispatchers.Main) {
+                                maxRecordingMinutes = (maxMinutes as? Number)?.toInt() ?: 10
+                                startDurationLimitTimer()
+                            }
+                        }
+
+                        val sampleRate = (config["sampleRate"] as? Number)?.toInt()
+                        if (sampleRate != null) {
+                            projectSampleRate = sampleRate.coerceIn(0, 100)
+                        }
+
+                        val recordingEnabled = (config["recordingEnabled"] as? Boolean) != false
+                        scope.launch(Dispatchers.Main) {
+                            recordingEnabledByConfig = recordingEnabled
+                            if (!recordingEnabled) {
+                                Logger.warning("Recording disabled by remote config, stopping capture only")
+                            }
+                            updateRecordingEligibility(projectSampleRate)
+                        }
+                         
+                        config["rejourneyEnabled"]?.let { enabled ->
+                            if (enabled == false) {
+                                scope.launch(Dispatchers.Main) {
+                                    Logger.warning("Rejourney disabled by remote config, stopping session")
+                                    remoteRejourneyEnabled = false
+                                    stopSessionInternal()
+                                }
+                            } else {
+                                remoteRejourneyEnabled = true
+                            }
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                Logger.error("Failed to fetch project config", e)
+            }
+        }
+    }
+
+    private fun registerDevice(publicKey: String, apiUrl: String) {
+        scope.launch(Dispatchers.IO) {
+            try {
+                val bundleId = reactContext.packageName
+                deviceAuthManager?.registerDevice(
+                    projectKey = publicKey,
+                    bundleId = bundleId,
+                    platform = "android",
+                    sdkVersion = Constants.SDK_VERSION,
+                    apiUrl = apiUrl
+                ) { success, credentialId, error ->
+                    if (success) {
+                        Logger.debug("Device registered: $credentialId")
+                        
+                        // Auth succeeded - reset retry state
+                        resetAuthRetryState()
+                        
+                        // Get upload token
+                        deviceAuthManager?.getUploadToken { tokenSuccess, token, expiresIn, tokenError ->
+                            if (tokenSuccess) {
+                                // NOTE: Session recovery is now handled EXCLUSIVELY by WorkManager
+                                // The old recoverPendingSessions() approach held a mutex that blocked
+                                // all current session uploads. WorkManager.scheduleRecoveryUpload()
+                                // runs independently without blocking the current session.
+                                // Recovery is already scheduled in onLifecycleStart via UploadWorker.scheduleRecoveryUpload()
+
+                                // Check for pending crash reports
+                                val crashHandler = CrashHandler.getInstance(reactContext)
+                                if (crashHandler.hasPendingCrashReport()) {
+                                    crashHandler.loadAndPurgePendingCrashReport()?.let { crashReport ->
+                                        scope.launch(Dispatchers.IO) {
+                                            uploadManager?.uploadCrashReport(crashReport)
+                                        }
+                                    }
+                                }
+                                
+                                // Check for pending ANR reports
+                                val anrHandler = ANRHandler.getInstance(reactContext)
+                                if (anrHandler.hasPendingANRReport()) {
+                                    anrHandler.loadAndPurgePendingANRReport()?.let { anrReport ->
+                                        scope.launch(Dispatchers.IO) {
+                                            uploadManager?.uploadANRReport(anrReport)
+                                        }
+                                    }
+                                }
+                            } else {
+                                Logger.warning("Failed to get upload token: $tokenError")
+                            }
+                        }
+                    } else {
+                        Logger.warning("Device registration failed: $error")
+                    }
+                }
+            } catch (e: Exception) {
+                Logger.error("Device registration error", e)
+            }
+        }
+    }
+
+    // ==================== Activity Lifecycle Callbacks ====================
+    // Note: We prioritize ProcessLifecycleOwner for foreground/background, 
+    // but onActivityStopped is critical for immediate background detection.
+
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+
+    override fun onActivityResumed(activity: Activity) {
+        // CRASH PREVENTION: Wrap in try-catch to never crash host app
+        try {
+            Logger.debug("Activity resumed")
+            cancelScheduledBackground()
+            // Backup foreground detection - ProcessLifecycleOwner may not always fire
+            if (wasInBackground) {
+                handleAppForeground("Activity.onResume")
+            }
+        } catch (e: Exception) {
+            Logger.error("SDK error in onActivityResumed (non-fatal)", e)
+        }
+    }
+    
+    override fun onActivityPaused(activity: Activity) {
+        // CRASH PREVENTION: Wrap in try-catch to never crash host app
+        try {
+            Logger.debug("Activity paused (isFinishing=${activity.isFinishing})")
+            
+            // Force capture immediately in case app is killed from recents
+            if (remoteRecordingEnabled) {
+                try {
+                    captureEngine?.forceCaptureWithReason("app_pausing")
+                } catch (e: Exception) {
+                    Logger.warning("Pre-background capture failed: ${e.message}")
+                }
+            }
+            
+            // LIGHTWEIGHT BACKGROUND PREP for recents detection
+            // DO NOT call full handleAppBackground here - that stops the capture engine
+            // which causes VideoEncoder race conditions (IllegalStateException: dequeue pending)
+            // 
+            // Instead, we:
+            // 1. Set backgroundEntryTime (for 60s timeout calculation)
+            // 2. Flush events to disk (so they're persisted if user swipes to kill)
+            // 
+            // Full background handling (stopping capture engine) happens in onActivityStopped/onActivityDestroyed
+            if (!wasInBackground && isRecording) {
+                Logger.debug("[BG] Activity.onPause: Setting background entry time (capture engine still running)")
+                backgroundEntryTime = System.currentTimeMillis()
+                
+                // Flush events to disk asynchronously
+                eventBuffer?.flush()
+                Logger.debug("[BG] Activity.onPause: Events flushed to disk, backgroundEntryTime=$backgroundEntryTime")
+            }
+        } catch (e: Exception) {
+            Logger.error("SDK error in onActivityPaused (non-fatal)", e)
+        }
+    }
+
+    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+
+    // ==================== DefaultLifecycleObserver (ProcessLifecycleOwner) ====================
+    
+    override fun onStart(owner: LifecycleOwner) {
+        // Backup: if Activity callbacks failed/missed, this catches the app start
+        try {
+            Logger.debug("ProcessLifecycleOwner: onStart")
+            cancelScheduledBackground()
+            if (wasInBackground) {
+                handleAppForeground("ProcessLifecycle.onStart")
+            }
+        } catch (e: Exception) {
+            Logger.error("SDK error in ProcessLifecycleOwner.onStart", e)
+        }
+    }
+
+    override fun onStop(owner: LifecycleOwner) {
+        // Backup: catch app background if Activity callbacks missed it
+        try {
+            Logger.debug("ProcessLifecycleOwner: onStop")
+            if (isRecording && !wasInBackground) {
+                // If we're recording and haven't detected background yet, do it now
+                // ProcessLifecycleOwner is already debounced by AndroidX (700ms), so no extra delay needed
+                handleAppBackground("ProcessLifecycle.onStop")
+            }
+        } catch (e: Exception) {
+            Logger.error("SDK error in ProcessLifecycleOwner.onStop", e)
+        }
+    }
+
+    // ==================== ActivityLifecycleCallbacks (Backup/Early Detection) ====================
+
+    override fun onActivityStarted(activity: Activity) {
+        // CRASH PREVENTION: Wrap in try-catch to never crash host app
+        try {
+            Logger.debug("Activity started")
+            cancelScheduledBackground()
+            if (wasInBackground) {
+                handleAppForeground("Activity.onStart")
+            }
+        } catch (e: Exception) {
+            Logger.error("SDK error in onActivityStarted (non-fatal)", e)
+        }
+    }
+
+    override fun onActivityStopped(activity: Activity) {
+        // CRASH PREVENTION: Wrap in try-catch to never crash host app
+        try {
+            if (activity.isChangingConfigurations) {
+                Logger.debug("Activity stopped but changing configurations - skipping background")
+                return
+            }
+
+            if (activity.isFinishing) {
+                // App is closing/killed - IMMEDIATE background handling + FORCE SESSION END
+                // Do not use debounce (scheduleBackground) because app kills (swipes) can terminate process instantly
+                Logger.debug("Activity stopped and finishing - triggering IMMEDIATE background and ENDING SESSION")
+                cancelScheduledBackground()
+                handleAppBackground("Activity.onStop:finishing", shouldEndSession = true)
+            } else {
+                // Normal background - immediate handling (no debounce needed for single activity)
+                // BUT do NOT end session (just flush)
+                Logger.debug("Activity stopped - triggering IMMEDIATE background")
+                cancelScheduledBackground()
+                handleAppBackground("Activity.onStop", shouldEndSession = false)
+            }
+
+        } catch (e: Exception) {
+            Logger.error("SDK error in onActivityStopped (non-fatal)", e)
+        }
+    }
+    
+    override fun onActivityDestroyed(activity: Activity) {
+        // CRASH PREVENTION: Wrap in try-catch to never crash host app
+        try {
+            if (activity.isChangingConfigurations) return
+
+            // Redundant backup: ensure background triggered if somehow missed in onStop
+            // FORCE SESSION END
+            Logger.debug("Activity destroyed (isFinishing=${activity.isFinishing}) - triggering IMMEDIATE background")
+            handleAppBackground("Activity.onDestroy", shouldEndSession = true)
+            
+        } catch (e: Exception) {
+            Logger.error("SDK error in onActivityDestroyed (non-fatal)", e)
+        }
+    }
+
+    private fun scheduleBackground(source: String) {
+        if (wasInBackground || backgroundScheduled) return
+
+        // NOTE: This method is now kept mainly for onPause if we decide to use it,
+        // or for legacy debounce logic. Currently onActivityStopped uses immediate handling.
+        backgroundScheduled = true
+        backgroundEntryTime = System.currentTimeMillis()
+
+        Logger.debug("Scheduling background in 50ms (source=$source)")
+
+        val runnable = Runnable {
+            backgroundScheduled = false
+            handleAppBackground("$source:debounced")
+        }
+
+        scheduledBackgroundRunnable = runnable
+        mainHandler.postDelayed(runnable, 50L) // Reduced to 50ms
+    }
+
+    private fun cancelScheduledBackground() {
+        if (!backgroundScheduled) return
+        scheduledBackgroundRunnable?.let { mainHandler.removeCallbacks(it) }
+        scheduledBackgroundRunnable = null
+        backgroundScheduled = false
+        if (!wasInBackground) {
+            backgroundEntryTime = 0L
+        }
+    }
+
+    /**
+     * Foreground handler - handles return from background with session timeout logic.
+     *
+     * Session Behavior (matching iOS):
+     * - Background < 60s: Resume same session, accumulate background time for billing exclusion
+     * - Background >= 60s: End old session, start new session
+     * - App killed in background: Auto-finalized by backend worker after 60s
+     */
+    private fun handleAppForeground(source: String) {
+        if (!wasInBackground || backgroundEntryTime == 0L) {
+            Logger.debug("[FG] Not returning from background, skipping")
+            return
+        }
+        
+        val bgDurationMs = System.currentTimeMillis() - backgroundEntryTime
+        val bgDurationSec = bgDurationMs / 1000.0
+        val sessionTimeoutMs = (Constants.BACKGROUND_SESSION_TIMEOUT * 1000).toLong()
+        val thresholdSec = Constants.BACKGROUND_SESSION_TIMEOUT
+        
+        Logger.debug("[FG] === APP FOREGROUND ($source) ===")
+        Logger.debug("[FG] Was in background for ${String.format("%.1f", bgDurationSec)}s")
+        Logger.debug("[FG] Session timeout threshold: ${thresholdSec}s")
+        Logger.debug("[FG] Current totalBackgroundTimeMs: $totalBackgroundTimeMs")
+        
+        // Reset background tracking state immediately (like iOS)
+        wasInBackground = false
+        backgroundEntryTime = 0
+        
+        if (bgDurationMs >= sessionTimeoutMs) {
+            // === TIMEOUT CASE: End old session, start new one ===
+            Logger.debug("[FG] TIMEOUT: ${bgDurationSec}s >= ${thresholdSec}s → Creating NEW session")
+            handleSessionTimeoutOnForeground(bgDurationMs, source)
+        } else {
+            // === SHORT BACKGROUND: Resume same session ===
+            Logger.debug("[FG] SHORT BACKGROUND: ${bgDurationSec}s < ${thresholdSec}s → Resuming SAME session")
+            handleShortBackgroundResume(bgDurationMs, source)
+        }
+    }
+    
+    /**
+     * Handle session timeout after extended background (>= 60s).
+     * Ends the old session and starts a fresh one.
+     * 
+     * CRITICAL: Uses backgroundScope + NonCancellable to ensure recovery completes
+     * even if the app goes to background again during this process.
+     */
+    private fun handleSessionTimeoutOnForeground(bgDurationMs: Long, source: String) {
+        val oldSessionId = currentSessionId ?: return
+        val wasRecording = isRecording
+        
+        if (!wasRecording) {
+            Logger.debug("Session timeout but wasn't recording - ignoring")
+            return
+        }
+        
+        Logger.debug("SESSION TIMEOUT: Ending session $oldSessionId after ${bgDurationMs/1000}s in background")
+        
+        // Add final background time to accumulated total before ending
+        totalBackgroundTimeMs += bgDurationMs
+        uploadManager?.totalBackgroundTimeMs = totalBackgroundTimeMs
+        
+        // Stop all capture/tracking immediately (synchronous, like iOS)
+        try {
+            stopBatchUploadTimer()
+            stopDurationLimitTimer()
+            captureEngine?.stopSession()
+            touchInterceptor?.disableGlobalTracking()
+            keyboardTracker?.stopTracking()
+            textInputTracker?.stopTracking()
+        } catch (e: Exception) {
+            Logger.warning("Error stopping capture during session timeout: ${e.message}")
+        }
+        
+        // Mark as not recording to prevent race conditions
+        isRecording = false
+        
+        // Handle old session end and new session start asynchronously using backgroundScope
+        // which survives independently of the main scope and won't be cancelled on background
+        backgroundScope.launch {
+            // Use NonCancellable context to ensure critical recovery operations complete
+            // even if the coroutine is cancelled (app goes to background again)
+            withContext(NonCancellable) {
+                try {
+                    // CRITICAL: Ensure auth token is valid before uploading
+                    // Token may have expired during the 60+ seconds in background
+                    try {
+                        DeviceAuthManager.getInstance(reactContext).ensureValidToken()
+                    } catch (e: Exception) {
+                        Logger.warning("Failed to refresh auth token during session timeout: ${e.message}")
+                    }
+                    
+                    // Add session_timeout event to old session's events
+                    val timeoutEvent = mapOf(
+                        "type" to EventType.SESSION_TIMEOUT,
+                        "timestamp" to System.currentTimeMillis(),
+                        "backgroundDuration" to bgDurationMs,
+                        "timeoutThreshold" to (Constants.BACKGROUND_SESSION_TIMEOUT * 1000).toLong(),
+                        "reason" to "background_timeout"
+                    )
+                    sessionEvents.add(timeoutEvent)
+                    
+                    // Upload old session's events as final and call session/end
+                    val finalEvents = sessionEvents.toList()
+                    sessionEvents.clear()
+                    
+                    if (finalEvents.isNotEmpty()) {
+                        try {
+                            uploadManager?.uploadBatch(finalEvents, isFinal = true)
+                        } catch (e: Exception) {
+                            Logger.warning("Failed to upload final events during session timeout: ${e.message}")
+                        }
+                    }
+                    
+                    // End the old session (calls /session/end which triggers promotion)
+                    // CRITICAL: Pass oldSessionId explicitly since uploadManager.sessionId may be reset
+                    var endSessionSuccess = false
+                    if (!sessionEndSent) {
+                        sessionEndSent = true
+                        try {
+                            endSessionSuccess = uploadManager?.endSession(sessionIdOverride = oldSessionId) ?: false
+                        } catch (e: Exception) {
+                            Logger.warning("Failed to end old session: ${e.message}")
+                        }
+                    }
+                    
+                    // Clear recovery markers for old session
+                    try {
+                        uploadManager?.clearSessionRecovery(oldSessionId)
+                    } catch (e: Exception) {
+                        Logger.warning("Failed to clear session recovery: ${e.message}")
+                    }
+                    
+                    if (endSessionSuccess) {
+                        Logger.debug("Old session $oldSessionId ended successfully")
+                    } else {
+                        Logger.warning("Old session $oldSessionId end signal failed - will be recovered on next launch")
+                    }
+                    
+                    // === START NEW SESSION ===
+                    val timestamp = System.currentTimeMillis()
+                    val shortUuid = UUID.randomUUID().toString().take(8).uppercase()
+                    val newSessionId = "session_${timestamp}_$shortUuid"
+                    
+                    // Reset state for new session
+                    currentSessionId = newSessionId
+                    sessionStartTime = timestamp
+                    totalBackgroundTimeMs = 0
+                    sessionEndSent = false
+                    
+                    // Reset upload manager for new session
+                    uploadManager?.let { um ->
+                        // NUCLEAR FIX: Use setActiveSessionId() to update both sessionId AND activeSessionId
+                        // This ensures the new session doesn't get merged into the old one's recovery path
+                        um.setActiveSessionId(newSessionId)
+                        
+                        um.sessionStartTime = timestamp
+                        um.totalBackgroundTimeMs = 0
+                        
+                        // FIX: Synchronize user identity and config to UploadManager
+                        // This matches iOS behavior and ensures robustness if memory was cleared
+                        um.userId = userId ?: "anonymous"
+                        
+                        // Restore saved config if available
+                        if (savedDeviceHash.isNotEmpty()) um.deviceHash = savedDeviceHash
+                        if (savedPublicKey.isNotEmpty()) um.publicKey = savedPublicKey
+                        if (savedApiUrl.isNotEmpty()) um.apiUrl = savedApiUrl
+
+                        // CRITICAL: Create session metadata file for crash recovery
+                        um.markSessionActive(newSessionId, timestamp)
+                    }
+                    
+                    // CRITICAL: Save new session ID to SharedPreferences for unclosed session detection
+                    // Use commit() instead of apply() to ensure synchronous write before app kill
+                    reactContext.getSharedPreferences("rejourney", 0)
+                        .edit()
+                        .putString("rj_current_session_id", newSessionId)
+                        .putLong("rj_session_start_time", timestamp)
+                        .commit()
+                    
+                    // CRITICAL: Re-initialize EventBuffer for new session
+                    // Without this, events are written to wrong session's file
+                    val pendingDir = java.io.File(reactContext.cacheDir, "rj_pending")
+                    eventBuffer = EventBuffer(reactContext, newSessionId, pendingDir)
+                    
+                    // Start capture for new session (run on main thread for UI safety)
+                    withContext(Dispatchers.Main) {
+                        try {
+                            resetSamplingDecision()
+                            remoteRecordingEnabled = recordingEnabledByConfig
+                            if (hasProjectConfig) {
+                                updateRecordingEligibility(projectSampleRate)
+                            }
+
+                            if (remoteRecordingEnabled) {
+                                captureEngine?.startSession(newSessionId)
+                            }
+                            
+                            // Re-enable tracking
+                            touchInterceptor?.enableGlobalTracking()
+                            keyboardTracker?.startTracking()
+                            textInputTracker?.startTracking()
+                            
+                            // CRITICAL: Restart SessionLifecycleService for the new session
+                            // The system destroys it after ~60 seconds in background
+                            // Without this, onTaskRemoved won't be called and session won't end properly
+                            try {
+                                val serviceIntent = Intent(reactContext, SessionLifecycleService::class.java)
+                                reactContext.startService(serviceIntent)
+                                Logger.debug("SessionLifecycleService restarted for new session after timeout")
+                            } catch (e: Exception) {
+                                Logger.warning("Failed to restart SessionLifecycleService: ${e.message}")
+                            }
+                        } catch (e: Exception) {
+                            Logger.warning("Error starting capture for new session: ${e.message}")
+                        }
+                    }
+                    
+                    isRecording = true
+                    
+                    // Add session_start event for new session
+                    val sessionStartEvent = mapOf(
+                        "type" to EventType.SESSION_START,
+                        "timestamp" to System.currentTimeMillis(),
+                        "previousSessionId" to oldSessionId,
+                        "backgroundDuration" to bgDurationMs,
+                        "reason" to "resumed_after_background_timeout",
+                        "userId" to (userId ?: "anonymous")
+                    )
+                    addEventWithPersistence(sessionStartEvent)
+                    
+                    // Start timers for new session
+                    startBatchUploadTimer()
+                    startDurationLimitTimer()
+                    
+                    // Trigger immediate upload to register new session
+                    delay(100)
+                    try {
+                        performBatchUpload()
+                    } catch (e: Exception) {
+                        Logger.warning("Failed to perform immediate batch upload: ${e.message}")
+                    }
+                    
+                    Logger.debug("New session $newSessionId started (previous: $oldSessionId)")
+                    
+                } catch (e: CancellationException) {
+                    // Coroutine was cancelled but NonCancellable should prevent this
+                    // Log as warning, not error - this is expected if app is killed
+                    Logger.warning("Session timeout recovery interrupted: ${e.message}")
+                    // Ensure recording state is consistent
+                    isRecording = true
+                    startBatchUploadTimer()
+                } catch (e: Exception) {
+                    Logger.error("Failed to handle session timeout", e)
+                    // Attempt recovery - restart recording
+                    isRecording = true
+                    startBatchUploadTimer()
+                }
+            }
+        }
+    }
+    
+    /**
+     * Handle short background return (< 60s) - resume same session.
+     */
+    private fun handleShortBackgroundResume(bgDurationMs: Long, source: String) {
+        // Accumulate background time for billing exclusion
+        val previousBgTime = totalBackgroundTimeMs
+        totalBackgroundTimeMs += bgDurationMs
+        uploadManager?.totalBackgroundTimeMs = totalBackgroundTimeMs
+        currentSessionId?.let { sid ->
+            uploadManager?.updateSessionRecoveryMeta(sid)
+        }
+        
+        Logger.debug("[FG] Background time: $previousBgTime + $bgDurationMs = $totalBackgroundTimeMs ms")
+        Logger.debug("[FG] Resuming session: $currentSessionId")
+        
+        if (!isRecording || currentSessionId.isNullOrEmpty()) {
+            Logger.debug("[FG] Not recording or no session - skipping resume")
+            return
+        }
+        
+        // Log foreground event for replay player
+        addEventWithPersistence(
+            mapOf(
+                "type" to EventType.APP_FOREGROUND,
+                "timestamp" to System.currentTimeMillis(),
+                "backgroundDurationMs" to bgDurationMs,
+                "totalBackgroundTimeMs" to totalBackgroundTimeMs,
+                "source" to source
+            )
+        )
+        
+        // Resume capture and tracking
+        if (remoteRecordingEnabled) {
+            try {
+                captureEngine?.startSession(currentSessionId!!)
+                captureEngine?.forceCaptureWithReason("app_foreground")
+            } catch (e: Exception) {
+                Logger.warning("Foreground capture resume failed: ${e.message}")
+            }
+        }
+        
+        touchInterceptor?.enableGlobalTracking()
+        keyboardTracker?.startTracking()
+        textInputTracker?.startTracking()
+        
+        startBatchUploadTimer()
+        startDurationLimitTimer()
+    }
+
+    /**
+     * Background handler (aligned with iOS + replay player expectations).
+     *
+     * We treat background as a pause:
+     * - log app_background
+     * - flush pending data (NOT final)
+     * - stop capture/tracking while backgrounded
+     *
+     * If the process is killed (shouldEndSession=true), crash-safe persistence + next-launch recovery will
+     * upload remaining pending data and close the session via session/end.
+     */
+    private fun handleAppBackground(source: String, shouldEndSession: Boolean = false) {
+        // Prevent duplicate background handling (unless forcing end)
+        if (wasInBackground && !shouldEndSession) {
+            Logger.debug("[BG] Already in background, skipping duplicate handling")
+            return
+        }
+        
+        Logger.debug("[BG] === APP BACKGROUND ($source) ===")
+        Logger.debug("[BG] isRecording=$isRecording, isShuttingDown=$isShuttingDown, sessionId=$currentSessionId, shouldEndSession=$shouldEndSession")
+        
+        if (isRecording && !isShuttingDown) {
+            wasInBackground = true
+            // backgroundEntryTime is already set by debounce scheduling
+            if (backgroundEntryTime == 0L) {
+                backgroundEntryTime = System.currentTimeMillis()
+            }
+            Logger.debug("[BG] backgroundEntryTime set to $backgroundEntryTime")
+            Logger.debug("[BG] Current totalBackgroundTimeMs=$totalBackgroundTimeMs")
+            
+            // Stop timers (but don't cancel in-progress uploads)
+            stopBatchUploadTimer()
+            stopDurationLimitTimer()
+            
+            // Stop tracking
+            keyboardTracker?.stopTracking()
+            textInputTracker?.stopTracking()
+            touchInterceptor?.disableGlobalTracking()
+            
+            // Add background event
+            val event = mapOf(
+                "type" to EventType.APP_BACKGROUND,
+                "timestamp" to System.currentTimeMillis()
+            )
+            addEventWithPersistence(event)
+            
+            // CRITICAL: Ensure all in-memory events are written to disk before scheduling upload
+            // EventBuffer uses async writes, so we need to flush to ensure all writes complete
+            Logger.debug("[BG] ===== ENSURING ALL EVENTS ARE PERSISTED TO DISK =====")
+            Logger.debug("[BG] In-memory events count: ${sessionEvents.size}")
+            Logger.debug("[BG] Event types in memory: ${sessionEvents.map { it["type"] }.joinToString(", ")}")
+            
+            // Log event buffer state before flush
+            eventBuffer?.let { buffer ->
+                Logger.debug("[BG] EventBuffer state: eventCount=${buffer.eventCount}, fileExists=${File(reactContext.cacheDir, "rj_pending/$currentSessionId/events.jsonl").exists()}")
+            } ?: Logger.warning("[BG] EventBuffer is NULL - cannot flush events!")
+            
+            // Flush all pending writes to disk
+            // This drains the async write queue and ensures all events are on disk
+            val flushStartTime = System.currentTimeMillis()
+            val flushSuccess = eventBuffer?.flush() ?: false
+            val flushDuration = System.currentTimeMillis() - flushStartTime
+            
+            if (flushSuccess) {
+                Logger.debug("[BG] ✅ Events flushed to disk successfully in ${flushDuration}ms")
+                Logger.debug("[BG] In-memory events: ${sessionEvents.size}, EventBuffer eventCount: ${eventBuffer?.eventCount ?: 0}")
+                
+                // Verify file exists and has content
+                val eventsFile = File(reactContext.cacheDir, "rj_pending/$currentSessionId/events.jsonl")
+                if (eventsFile.exists()) {
+                    val fileSize = eventsFile.length()
+                    Logger.debug("[BG] Events file exists: size=$fileSize bytes, path=${eventsFile.absolutePath}")
+                } else {
+                    Logger.error("[BG] ⚠️ Events file does NOT exist after flush! path=${eventsFile.absolutePath}")
+                }
+            } else {
+                Logger.error("[BG] ❌ FAILED to flush events to disk - some events may be lost!")
+                Logger.error("[BG] Flush duration: ${flushDuration}ms")
+            }
+            Logger.debug("[BG] ===== EVENT PERSISTENCE CHECK COMPLETE =====")
+            
+            // Stop capture engine while backgrounded (triggers final segment flush and hierarchy upload)
+            if (remoteRecordingEnabled) {
+                Logger.debug("[BG] ===== STOPPING CAPTURE ENGINE =====")
+                
+                if (shouldEndSession) {
+                    // Kill scenario: use emergency flush to save crash metadata and stop ASAP
+                    Logger.debug("[BG] Force kill detected - using emergency flush")
+                    captureEngine?.emergencyFlush()
+                    // Continue to stopSession for hierarchy upload and other cleanup
+                }
+                
+                Logger.debug("[BG] Stopping capture engine for background (sessionId=$currentSessionId)")
+                captureEngine?.stopSession()
+                Logger.debug("[BG] Capture engine stopSession() called")
+            }
+            
+            // Update session recovery meta so WorkManager can find the session
+            currentSessionId?.let { sid ->
+                uploadManager?.updateSessionRecoveryMeta(sid)
+                Logger.debug("[BG] Session recovery metadata updated for: $sid")
+            }
+            
+            // ===== SIMPLIFIED UPLOAD: WorkManager Only =====
+            // Industry-standard approach: persist first (done above), then schedule background worker.
+            // NO synchronous uploads - they cause ANRs and mutex contention with recovery.
+            // WorkManager is reliable for background uploads when properly configured.
+            currentSessionId?.let { sid ->
+                Logger.debug("[BG] ===== SCHEDULING WORKMANAGER UPLOAD =====")
+                Logger.debug("[BG] Session: $sid, Events persisted: ${eventBuffer?.eventCount ?: 0}, isFinal: $shouldEndSession")
+                
+                // Clear in-memory events since they're persisted to disk
+                // WorkManager will read from disk
+                sessionEvents.clear()
+                
+                // Schedule expedited upload via WorkManager
+                UploadWorker.scheduleUpload(
+                    context = reactContext,
+                    sessionId = sid,
+                    isFinal = shouldEndSession, // Pass shouldEndSession as isFinal
+                    expedited = true  // Request expedited execution
+                )
+                Logger.debug("[BG] ✅ WorkManager upload scheduled for session: $sid")
+
+                // NEW: Best-effort immediate upload (Fire-and-Forget)
+                // Try to upload immediately while app is still alive in memory.
+                // If this succeeds, WorkManager will find nothing to do (which is fine).
+                // If this fails/gets killed, WorkManager will pick it up.
+                // This mimics iOS "beginBackgroundTask" pattern.
+                scope.launch(Dispatchers.IO) {
+                    try {
+                        Logger.debug("[BG] 🚀 Attempting immediate best-effort upload for $sid")
+                        
+                        // Create a temporary UploadManager because the main one's state is complex
+                        // We use the same parameters as WorkManager creates
+                        val authManager = DeviceAuthManager.getInstance(reactContext)
+                        val apiUrl = authManager.getCurrentApiUrl() ?: "https://api.rejourney.co"
+                        
+                        val bgUploader = com.rejourney.network.UploadManager(reactContext, apiUrl).apply {
+                            this.sessionId = sid
+                            this.setActiveSessionId(sid) // CRITICAL: Set active session ID
+                            this.publicKey = authManager.getCurrentPublicKey() ?: ""
+                            this.deviceHash = authManager.getCurrentDeviceHash() ?: ""
+                            this.sessionStartTime = uploadManager?.sessionStartTime ?: 0L
+                            this.totalBackgroundTimeMs = uploadManager?.totalBackgroundTimeMs ?: 0L
+                        }
+                        
+                        // Read events from disk since we flushed them
+                        val eventBufferDir = File(reactContext.cacheDir, "rj_pending/$sid")
+                        val eventsFile = File(eventBufferDir, "events.jsonl")
+                        
+                        if (eventsFile.exists()) {
+                            // Read events - duplicated logic from UploadWorker but necessary for successful off-main-thread upload
+                            val events = mutableListOf<Map<String, Any?>>()
+                            eventsFile.bufferedReader().useLines { lines ->
+                                lines.forEach { line ->
+                                    if (line.isNotBlank()) {
+                                        try {
+                                            val json = org.json.JSONObject(line)
+                                            val map = mutableMapOf<String, Any?>()
+                                            json.keys().forEach { key ->
+                                                map[key] = json.opt(key)
+                                            }
+                                            events.add(map)
+                                        } catch (e: Exception) { }
+                                    }
+                                }
+                            }
+                            
+                            if (events.isNotEmpty()) {
+                                Logger.debug("[BG] Immediate upload: found ${events.size} events")
+                                val success = bgUploader.uploadBatch(events, isFinal = shouldEndSession)
+                                if (success) {
+                                    Logger.debug("[BG] ✅ Immediate upload SUCCESS! Cleaning up disk...")
+                                    // Clean up so WorkManager doesn't re-upload
+                                    eventsFile.delete()
+                                    File(eventBufferDir, "buffer_meta.json").delete()
+                                    
+                                    // IF FINAL, END SESSION IMMEDIATELY
+                                    if (shouldEndSession) {
+                                         Logger.debug("[BG] Immediate upload was final, ending session...")
+                                         bgUploader.endSession()
+                                    }
+                                } else {
+                                    Logger.warning("[BG] Immediate upload failed - leaving for WorkManager")
+                                }
+                            } else if (shouldEndSession) {
+                                // Even if no events, if it's final, we should try to end session
+                                Logger.debug("[BG] No events but shouldEndSession=true, ending session...")
+                                bgUploader.endSession()
+                            }
+                        } else if (shouldEndSession) {
+                            // Even if no event file, if it's final, we should try to end session
+                             Logger.debug("[BG] No event file but shouldEndSession=true, ending session...")
+                             bgUploader.endSession()
+                        }
+                    } catch (e: Exception) {
+                        Logger.error("[BG] Immediate upload error: ${e.message} - WorkManager will handle it")
+                    }
+                }
+            } // End of currentSessionId?.let
+        } else {
+            Logger.debug("[BG] Skipping background handling (isRecording=$isRecording, isShuttingDown=$isShuttingDown)")
+        }
+    }
+
+    // ==================== TouchInterceptorDelegate ====================
+
+    override fun onTouchEvent(event: MotionEvent, gestureType: String?) {
+        // We rely primarily on onGestureRecognized, but can add raw touches if needed.
+        // For now, to match iOS "touches visited", we can treat simple taps here if needed,
+        // but gestureClassifier usually handles it.
+    }
+
+    override fun onGestureRecognized(gestureType: String, x: Float, y: Float, details: Map<String, Any?>) {
+        if (!isRecording) return
+
+        try {
+            val timestamp = System.currentTimeMillis()
+            
+            // Build touches array matching iOS format for web player compatibility
+            // Web player filters events without touches array (e.touches.length > 0)
+            val touchPoint = mapOf(
+                "x" to x,
+                "y" to y,
+                "timestamp" to timestamp,
+                "force" to (details["force"] ?: 0f)
+            )
+            
+            val eventMap = mapOf(
+                "type" to EventType.GESTURE,
+                "timestamp" to timestamp,
+                "gestureType" to gestureType,
+                "touches" to listOf(touchPoint),  // Required by web player TouchOverlay
+                "duration" to (details["duration"] ?: 0),
+                "targetLabel" to details["targetLabel"],
+                "x" to x,  // Keep for backwards compatibility
+                "y" to y,
+                "details" to details
+            )
+            
+            // Debug logging to verify touch events are captured correctly for web overlay
+            Logger.debug("[TOUCH] Gesture recorded: type=$gestureType, x=$x, y=$y, touches=${listOf(touchPoint)}")
+            
+            addEventWithPersistence(eventMap)
+        } catch (e: Exception) {
+            Logger.error("Failed to record gesture", e)
+        }
+    }
+
+    override fun onGestureWithTouchPath(
+        gestureType: String,
+        touches: List<Map<String, Any>>,
+        duration: Long,
+        targetLabel: String?
+    ) {
+        if (!isRecording) return
+
+        try {
+            val timestamp = System.currentTimeMillis()
+            val firstTouch = touches.firstOrNull()
+            val x = (firstTouch?.get("x") as? Number)?.toFloat() ?: 0f
+            val y = (firstTouch?.get("y") as? Number)?.toFloat() ?: 0f
+
+            val eventMap = mapOf(
+                "type" to EventType.GESTURE,
+                "timestamp" to timestamp,
+                "gestureType" to gestureType,
+                "touches" to touches,
+                "duration" to duration,
+                "targetLabel" to targetLabel,
+                "x" to x,
+                "y" to y,
+                "details" to mapOf(
+                    "duration" to duration,
+                    "targetLabel" to targetLabel
+                )
+            )
+
+            Logger.debug("[TOUCH] Gesture recorded: type=$gestureType, touches=${touches.size}")
+            addEventWithPersistence(eventMap)
+        } catch (e: Exception) {
+            Logger.error("Failed to record gesture", e)
+        }
+    }
+
+    override fun onRageTap(tapCount: Int, x: Float, y: Float) {
+        if (!isRecording) return
+
+        try {
+            val timestamp = System.currentTimeMillis()
+            
+            // Build touches array matching iOS format for web player compatibility
+            val touchPoint = mapOf(
+                "x" to x,
+                "y" to y,
+                "timestamp" to timestamp,
+                "force" to 0f
+            )
+            
+            val eventMap = mapOf(
+                "type" to EventType.GESTURE,  // Use gesture type for web player compatibility
+                "timestamp" to timestamp,
+                "gestureType" to "rage_tap",
+                "touches" to listOf(touchPoint),  // Required by web player TouchOverlay
+                "tapCount" to tapCount,
+                "x" to x,
+                "y" to y
+            )
+            addEventWithPersistence(eventMap)
+        } catch (e: Exception) {
+            Logger.error("Failed to record rage tap", e)
+        }
+    }
+
+    override fun isCurrentlyRecording(): Boolean = isRecording
+
+    override fun isKeyboardCurrentlyVisible(): Boolean = isKeyboardVisible
+
+    override fun currentKeyboardHeight(): Int = lastKeyboardHeight
+
+    // ==================== NetworkMonitorListener ====================
+
+    override fun onNetworkChanged(quality: com.rejourney.network.NetworkQuality) {
+        if (!isRecording) return
+
+        val qualityMap = quality.toMap()
+        val networkType = qualityMap["networkType"] as? String ?: "none"
+        val cellularGeneration = qualityMap["cellularGeneration"] as? String ?: "unknown"
+
+        val eventMap = mutableMapOf<String, Any?>(
+            "type" to "network_change",
+            "timestamp" to System.currentTimeMillis(),
+            "status" to if (networkType == "none") "disconnected" else "connected",
+            "networkType" to networkType,
+            "isConstrained" to (qualityMap["isConstrained"] as? Boolean ?: false),
+            "isExpensive" to (qualityMap["isExpensive"] as? Boolean ?: false)
+        )
+
+        if (cellularGeneration != "unknown") {
+            eventMap["cellularGeneration"] = cellularGeneration
+        }
+
+        addEventWithPersistence(eventMap)
+    }
+    
+    // ==================== KeyboardTrackerListener ====================
+    
+    override fun onKeyboardShown(keyboardHeight: Int) {
+        if (!isRecording) return
+        
+        Logger.debug("[KEYBOARD] Keyboard shown (height=$keyboardHeight)")
+        isKeyboardVisible = true
+        lastKeyboardHeight = keyboardHeight
+        
+        val eventMap = mapOf(
+            "type" to EventType.KEYBOARD_SHOW,
+            "timestamp" to System.currentTimeMillis(),
+            "keyboardHeight" to keyboardHeight
+        )
+        addEventWithPersistence(eventMap)
+        
+        // Schedule capture after keyboard settles
+        captureEngine?.notifyKeyboardEvent("keyboard_shown")
+    }
+    
+    override fun onKeyboardHidden() {
+        if (!isRecording) return
+        
+        Logger.debug("[KEYBOARD] Keyboard hidden (keyPresses=$keyPressCount)")
+        isKeyboardVisible = false
+
+        // Match iOS/player behavior: emit a recent typing signal if we recorded keypresses
+        if (keyPressCount > 0) {
+            addEventWithPersistence(
+                mapOf(
+                    "type" to EventType.KEYBOARD_TYPING,
+                    "timestamp" to System.currentTimeMillis(),
+                    "keyPressCount" to keyPressCount
+                )
+            )
+        }
+        
+        val eventMap = mapOf(
+            "type" to EventType.KEYBOARD_HIDE,
+            "timestamp" to System.currentTimeMillis(),
+            "keyPressCount" to keyPressCount
+        )
+        addEventWithPersistence(eventMap)
+        
+        // Reset key press count when keyboard hides
+        keyPressCount = 0
+        
+        // Schedule capture after keyboard settles
+        captureEngine?.notifyKeyboardEvent("keyboard_hidden")
+    }
+    
+    override fun onKeyPress() {
+        keyPressCount++
+    }
+    
+    // ==================== TextInputTrackerListener ====================
+    
+    override fun onTextChanged(characterCount: Int) {
+        if (!isRecording) return
+        if (characterCount <= 0) return
+
+        // Accumulate key presses
+        keyPressCount += characterCount
+
+        // Emit typing events so the player can animate typing indicators.
+        // (No actual text content is captured.)
+        if (isKeyboardVisible) {
+            addEventWithPersistence(
+                mapOf(
+                    "type" to EventType.KEYBOARD_TYPING,
+                    "timestamp" to System.currentTimeMillis(),
+                    "keyPressCount" to characterCount
+                )
+            )
+        }
+    }
+    
+    // ==================== ANRHandler.ANRListener ====================
+    
+    override fun onANRDetected(durationMs: Long, threadState: String?) {
+        // CRASH PREVENTION: Wrap in try-catch to never crash host app
+        try {
+            if (!isRecording) return
+            
+            Logger.debug("ANR callback: duration=${durationMs}ms")
+            
+            // Log ANR as an event for timeline display
+            val eventMap = mutableMapOf<String, Any?>(
+                "type" to "anr",
+                "timestamp" to System.currentTimeMillis(),
+                "durationMs" to durationMs
+            )
+            threadState?.let { eventMap["threadState"] = it }
+            addEventWithPersistence(eventMap)
+            
+            // Increment telemetry counter
+            Telemetry.getInstance().recordANR()
+        } catch (e: Exception) {
+            Logger.error("SDK error in onANRDetected (non-fatal)", e)
+        }
+    }
+    
+    // ==================== CaptureEngineDelegate ====================
+    
+    override fun onSegmentReady(segmentFile: File, startTime: Long, endTime: Long, frameCount: Int) {
+        // CRITICAL FIX: Do NOT delete segment if shutting down - we want to persist it for recovery!
+        if (!isRecording && !isShuttingDown) {
+            // Clean up the segment file if we're not recording (and not shutting down)
+            try {
+                segmentFile.delete()
+            } catch (_: Exception) {}
+            return
+        }
+        
+        if (isShuttingDown) {
+            Logger.debug("Segment ready during shutdown - preserving file for recovery: ${segmentFile.name}")
+            // Do not attempt upload now as scope is cancelled. WorkManager/Recovery will handle it.
+            return
+        }
+
+        if (!remoteRecordingEnabled) {
+            try {
+                segmentFile.delete()
+            } catch (_: Exception) {}
+            Logger.debug("Segment upload skipped - recording disabled")
+            return
+        }
+        
+        Logger.debug("Segment ready: frames=$frameCount, file=${segmentFile.absolutePath}")
+        
+        scope.launch(Dispatchers.IO) {
+            try {
+                val success = uploadManager?.uploadVideoSegment(
+                    segmentFile = segmentFile,
+                    startTime = startTime,
+                    endTime = endTime,
+                    frameCount = frameCount
+                ) ?: false
+                
+                if (success) {
+                    Logger.debug("Segment uploaded successfully")
+                } else {
+                    Logger.warning("Segment upload failed")
+                }
+            } catch (e: Exception) {
+                Logger.error("Failed to upload segment", e)
+            }
+        }
+    }
+    
+    override fun onCaptureError(error: Exception) {
+        Logger.error("Capture error: ${error.message}", error)
+        
+        // Log capture error as an event
+        val eventMap = mutableMapOf<String, Any?>(
+            "type" to "capture_error",
+            "timestamp" to System.currentTimeMillis(),
+            "error" to error.message
+        )
+        addEventWithPersistence(eventMap)
+    }
+    
+    override fun onHierarchySnapshotsReady(snapshotsJson: ByteArray, timestamp: Long) {
+        Logger.debug("[HIERARCHY] onHierarchySnapshotsReady: START (size=${snapshotsJson.size} bytes, timestamp=$timestamp)")
+        Logger.debug("[HIERARCHY] isRecording=$isRecording, isShuttingDown=$isShuttingDown, currentSessionId=$currentSessionId")
+        
+        if (!isRecording || isShuttingDown) {
+            Logger.warning("[HIERARCHY] onHierarchySnapshotsReady: Skipping - isRecording=$isRecording, isShuttingDown=$isShuttingDown")
+            return
+        }
+
+        if (!remoteRecordingEnabled) {
+            Logger.debug("[HIERARCHY] Skipping upload - recording disabled")
+            return
+        }
+        
+        // CRITICAL FIX: Capture current session ID at callback time
+        // This prevents stale session ID issues where UploadManager.sessionId
+        // may still reference a previous session
+        val sid = currentSessionId ?: run {
+            Logger.error("[HIERARCHY] onHierarchySnapshotsReady: No current session ID, cannot upload hierarchy")
+            return
+        }
+        
+        Logger.debug("[HIERARCHY] onHierarchySnapshotsReady: Hierarchy snapshots ready for session: $sid")
+        Logger.debug("[HIERARCHY] JSON size: ${snapshotsJson.size} bytes, uploadManager=${uploadManager != null}")
+        
+        scope.launch(Dispatchers.IO) {
+            try {
+                Logger.debug("[HIERARCHY] Starting hierarchy upload (sessionId=$sid)")
+                val uploadStartTime = System.currentTimeMillis()
+                
+                val success = uploadManager?.uploadHierarchy(
+                    hierarchyData = snapshotsJson,
+                    timestamp = timestamp,
+                    sessionId = sid  // Pass session ID explicitly
+                ) ?: false
+                
+                val uploadDuration = System.currentTimeMillis() - uploadStartTime
+                
+                if (success) {
+                    Logger.debug("[HIERARCHY] ✅ Hierarchy snapshots uploaded successfully in ${uploadDuration}ms (sessionId=$sid)")
+                } else {
+                    Logger.error("[HIERARCHY] ❌ Hierarchy snapshots upload FAILED after ${uploadDuration}ms (sessionId=$sid)")
+                }
+            } catch (e: Exception) {
+                Logger.error("[HIERARCHY] ❌ Exception during hierarchy upload (sessionId=$sid): ${e.message}", e)
+            }
+        }
+    }
+    
+    // ==================== AuthFailureListener ====================
+    
+    /**
+     * Called when authentication fails due to security errors (403/404).
+     * 
+     * - 403 (security): Stop immediately and permanently (package name mismatch)
+     * - 404 (not found): Retry with exponential backoff (could be temporary)
+     */
+    override fun onAuthenticationFailure(errorCode: Int, errorMessage: String, domain: String) {
+        Logger.error("Authentication failure: code=$errorCode, message=$errorMessage, domain=$domain")
+        
+        when (errorCode) {
+            403 -> {
+                // SECURITY: Package name mismatch or access forbidden - PERMANENT failure
+                Logger.error("SECURITY: Access forbidden - stopping recording permanently")
+                authPermanentlyFailed = true
+                handleAuthenticationFailurePermanent(errorCode, errorMessage, domain)
+            }
+            else -> {
+                // 404 and other errors - retry with exponential backoff
+                // Recording continues locally, events queued for later upload
+                scheduleAuthRetry(errorCode, errorMessage, domain)
+            }
+        }
+    }
+    
+    /**
+     * Schedule auth retry with exponential backoff.
+     * Recording continues locally while retrying.
+     */
+    private fun scheduleAuthRetry(errorCode: Int, errorMessage: String, domain: String) {
+        if (authPermanentlyFailed || isShuttingDown) {
+            return
+        }
+        
+        authRetryCount++
+        
+        // Check max retries
+        if (authRetryCount > MAX_AUTH_RETRIES) {
+            Logger.error("Auth failed after $MAX_AUTH_RETRIES retries. Recording continues locally.")
+            
+            // Emit warning (not error) - recording continues
+            emitAuthWarningEvent(errorCode, "Auth failed after max retries. Recording locally.", authRetryCount)
+            
+            // Schedule long background retry (5 minutes)
+            scheduleBackgroundAuthRetry(AUTH_BACKGROUND_RETRY_DELAY_MS)
+            return
+        }
+        
+        // Calculate exponential backoff: 2s, 4s, 8s, 16s, 32s, capped at 60s
+        val delay = minOf(
+            AUTH_RETRY_BASE_DELAY_MS * (1L shl (authRetryCount - 1)),
+            AUTH_RETRY_MAX_DELAY_MS
+        )
+        
+        Logger.info("Auth failed (attempt $authRetryCount/$MAX_AUTH_RETRIES), retrying in ${delay}ms. " +
+                   "Recording continues locally. Error: $errorMessage")
+        
+        // After 2 failed attempts, clear cached auth data and re-register fresh
+        if (authRetryCount >= 2) {
+            Logger.info("Clearing cached auth data and re-registering fresh...")
+            deviceAuthManager?.clearCredentials()
+        }
+        
+        scheduleBackgroundAuthRetry(delay)
+    }
+    
+    /**
+     * Schedule a background auth retry after specified delay.
+     */
+    private fun scheduleBackgroundAuthRetry(delayMs: Long) {
+        // Cancel any existing retry job
+        authRetryJob?.cancel()
+        
+        authRetryJob = scope.launch {
+            delay(delayMs)
+            if (!authPermanentlyFailed && !isShuttingDown) {
+                Logger.info("Retrying auth (attempt ${authRetryCount + 1})...")
+                performAuthRetry()
+            }
+        }
+    }
+    
+    /**
+     * Perform the auth retry - re-initialize device auth.
+     */
+    private fun performAuthRetry() {
+        if (savedApiUrl.isNotEmpty() && savedPublicKey.isNotEmpty()) {
+            deviceAuthManager?.registerDevice(
+                projectKey = savedPublicKey,
+                bundleId = reactContext.packageName,
+                platform = "android",
+                sdkVersion = Constants.SDK_VERSION,
+                apiUrl = savedApiUrl
+            ) { success, credentialId, error ->
+                if (success) {
+                    Logger.debug("Auth retry successful: device registered: $credentialId")
+                    resetAuthRetryState()
+                    // Get upload token after successful registration
+                    deviceAuthManager?.getUploadToken { tokenSuccess, token, expiresIn, tokenError ->
+                        if (tokenSuccess) {
+                            Logger.debug("Upload token obtained after auth retry")
+                        } else {
+                            Logger.warning("Failed to get upload token after auth retry: $tokenError")
+                        }
+                    }
+                } else {
+                    Logger.warning("Auth retry failed: $error")
+                }
+            }
+        }
+    }
+    
+    /**
+     * Reset auth retry state (called when auth succeeds).
+     */
+    private fun resetAuthRetryState() {
+        authRetryCount = 0
+        authPermanentlyFailed = false
+        authRetryJob?.cancel()
+        authRetryJob = null
+    }
+    
+    /**
+     * Handle PERMANENT authentication failure (403 security errors only).
+     * Stops recording, clears credentials, and emits error event to JS.
+     */
+    private fun handleAuthenticationFailurePermanent(errorCode: Int, errorMessage: String, domain: String) {
+        // Must run on main thread for React Native event emission
+        Handler(Looper.getMainLooper()).post {
+            try {
+                // Stop recording immediately
+                if (isRecording) {
+                    Logger.warning("Stopping recording due to security authentication failure")
+                    
+                    // Stop capture engine
+                    captureEngine?.stopSession()
+                    
+                    // Disable touch tracking
+                    touchInterceptor?.disableGlobalTracking()
+                    
+                    // Stop keyboard and text input tracking
+                    keyboardTracker?.stopTracking()
+                    textInputTracker?.stopTracking()
+                    
+                    // Stop timers
+                    stopBatchUploadTimer()
+                    stopDurationLimitTimer()
+                    
+                    // Clear session state
+                    isRecording = false
+                    currentSessionId = null
+                    userId = null
+                    sessionEvents.clear()
+                }
+                
+                // Clear stored credentials
+                deviceAuthManager?.clearCredentials()
+                
+                // Emit error event to JavaScript layer
+                emitAuthErrorEvent(errorCode, errorMessage, domain)
+                
+            } catch (e: Exception) {
+                Logger.error("Error handling authentication failure", e)
+            }
+        }
+    }
+    
+    /**
+     * Emit auth warning event (for retryable failures).
+     */
+    private fun emitAuthWarningEvent(errorCode: Int, errorMessage: String, retryCount: Int) {
+        try {
+            val params = Arguments.createMap().apply {
+                putInt("code", errorCode)
+                putString("message", errorMessage)
+                putInt("retryCount", retryCount)
+            }
+            
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit("rejourneyAuthWarning", params)
+                
+            Logger.debug("Emitted rejourneyAuthWarning event to JS: code=$errorCode, retryCount=$retryCount")
+        } catch (e: Exception) {
+            Logger.error("Failed to emit auth warning event", e)
+        }
+    }
+    
+    /**
+     * Emit rejourneyAuthError event to JavaScript layer.
+     */
+    private fun emitAuthErrorEvent(errorCode: Int, errorMessage: String, domain: String) {
+        try {
+            val params = Arguments.createMap().apply {
+                putInt("code", errorCode)
+                putString("message", errorMessage)
+                putString("domain", domain)
+            }
+            
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit("rejourneyAuthError", params)
+                
+            Logger.debug("Emitted rejourneyAuthError event to JS: code=$errorCode")
+        } catch (e: Exception) {
+            Logger.error("Failed to emit auth error event", e)
+        }
+    }
+    
+    /**
+     * Check if the app was killed in the previous session using ApplicationExitInfo (Android 11+).
+     * This is a fallback mechanism when onTaskRemoved() doesn't fire.
+     */
+    private fun checkPreviousAppKill() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            // ApplicationExitInfo is only available on Android 11+ (API 30)
+            return
+        }
+        
+        try {
+            val activityManager = reactContext.getSystemService(Context.ACTIVITY_SERVICE) as? android.app.ActivityManager
+            if (activityManager == null) {
+                Logger.debug("ActivityManager not available for exit info check")
+                return
+            }
+            
+            // Get historical exit reasons for this process
+            val exitReasons = activityManager.getHistoricalProcessExitReasons(null, 0, 1)
+            
+            if (exitReasons.isNotEmpty()) {
+                val exitInfo = exitReasons[0]
+                val reason = exitInfo.reason
+                val timestamp = exitInfo.timestamp
+                
+                Logger.debug("Previous app exit: reason=$reason, timestamp=$timestamp")
+                
+                // Check if app was killed by user (swipe away, force stop, etc.)
+                // REASON_USER_REQUESTED includes swipe-away from recent apps
+                if (reason == android.app.ApplicationExitInfo.REASON_USER_REQUESTED) {
+                    Logger.debug("App was killed by user (likely swipe-away) - checking for unclosed session")
+                    // This will be handled by checkForUnclosedSessions()
+                }
+            }
+        } catch (e: Exception) {
+            Logger.warning("Failed to check previous app kill: ${e.message}")
+        }
+    }
+    
+    /**
+     * Check for unclosed sessions from previous app launch.
+     * If a session was active but never properly ended, end it now.
+     */
+    private fun checkForUnclosedSessions() {
+        try {
+            val prefs = reactContext.getSharedPreferences("rejourney", Context.MODE_PRIVATE)
+            val lastSessionId = prefs.getString("rj_current_session_id", null)
+            val lastSessionStartTime = prefs.getLong("rj_session_start_time", 0)
+            
+            if (lastSessionId != null && lastSessionStartTime > 0) {
+                // Check if session was never closed (no end timestamp stored)
+                val sessionEndTime = prefs.getLong("rj_session_end_time_$lastSessionId", 0)
+                
+                if (sessionEndTime == 0L) {
+                    Logger.debug("Found unclosed session: $lastSessionId (started at $lastSessionStartTime)")
+                    
+                    // Session was never properly closed - likely app was killed
+                    // End the session asynchronously using the upload manager
+                    backgroundScope.launch {
+                        try {
+                            // Reconstruct upload manager state if needed
+                            uploadManager?.let { um ->
+                                // Set the session ID temporarily to allow endSession to work
+                                val originalSessionId = um.sessionId
+                                um.sessionId = lastSessionId
+                                
+                                // Try to end the session with the last known timestamp
+                                // Use a timestamp slightly before now to account for the gap
+                                val estimatedEndTime = System.currentTimeMillis() - 1000 // 1 second before now
+                                
+                                Logger.debug("Ending unclosed session: $lastSessionId at $estimatedEndTime")
+                                
+                                // Use the upload manager's endSession with override timestamp
+                                val success = um.endSession(endedAtOverride = estimatedEndTime)
+                                
+                                // Restore original session ID
+                                um.sessionId = originalSessionId
+                                
+                                if (success) {
+                                    Logger.debug("Successfully ended unclosed session: $lastSessionId")
+                                    // Clear the session markers
+                                    um.clearSessionRecovery(lastSessionId)
+                                    
+                                    // Update prefs to mark session as closed
+                                    prefs.edit()
+                                        .putLong("rj_session_end_time_$lastSessionId", estimatedEndTime)
+                                        .remove("rj_current_session_id")
+                                        .remove("rj_session_start_time")
+                                        .apply()
+                                } else {
+                                    Logger.warning("Failed to end unclosed session: $lastSessionId")
+                                }
+                            }
+                        } catch (e: Exception) {
+                            Logger.error("Error ending unclosed session: ${e.message}", e)
+                        }
+                    }
+                } else {
+                    // Session was properly closed, clear old markers
+                    prefs.edit()
+                        .remove("rj_current_session_id")
+                        .remove("rj_session_start_time")
+                        .apply()
+                }
+            }
+        } catch (e: Exception) {
+            Logger.error("Failed to check for unclosed sessions: ${e.message}", e)
+        }
+    }
+}