@rejourneyco/react-native 1.0.1 → 1.0.3

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

@@ -57,7 +57,6 @@ import java.io.File
 import java.util.*
 import java.util.concurrent.CopyOnWriteArrayList
 
-// Enum for session end reasons
 enum class EndReason {
     SESSION_TIMEOUT,
     MANUAL_STOP,
@@ -80,25 +79,21 @@ class RejourneyModuleImpl(
 
     companion object {
         const val NAME = "Rejourney"
-        const val BACKGROUND_RESUME_TIMEOUT_MS = 30_000L // 30 seconds
+        const val BACKGROUND_RESUME_TIMEOUT_MS = 30_000L
         
-        // 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
+        private const val AUTH_RETRY_BASE_DELAY_MS = 2000L
+        private const val AUTH_RETRY_MAX_DELAY_MS = 60000L
+        private const val AUTH_BACKGROUND_RETRY_DELAY_MS = 300000L
         
-        // 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) {
@@ -107,7 +102,6 @@ class RejourneyModuleImpl(
         }
     }
 
-    // Core components
     private var captureEngine: CaptureEngine? = null
     private var uploadManager: UploadManager? = null
     private var touchInterceptor: TouchInterceptor? = null
@@ -116,7 +110,6 @@ class RejourneyModuleImpl(
     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
@@ -134,59 +127,42 @@ class RejourneyModuleImpl(
     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()
@@ -207,7 +183,6 @@ class RejourneyModuleImpl(
                 registerActivityLifecycleCallbacks()
                 registerProcessLifecycleObserver()
                 
-                // Start crash handler, ANR handler, and network monitor with error handling
                 try {
                     CrashHandler.getInstance(reactContext).startMonitoring()
                 } catch (e: Exception) {
@@ -229,49 +204,38 @@ class RejourneyModuleImpl(
                     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
+                                        withTimeout(5000L) {
                                             Logger.debug("[Rejourney] Starting synchronous session end...")
                                             endSessionSynchronous()
                                             Logger.debug("[Rejourney] Synchronous session end completed")
@@ -291,13 +255,11 @@ class RejourneyModuleImpl(
                     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
             }
         }
@@ -313,8 +275,6 @@ class RejourneyModuleImpl(
         
         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")
@@ -322,7 +282,6 @@ class RejourneyModuleImpl(
             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}")
     }
@@ -332,14 +291,12 @@ class RejourneyModuleImpl(
      * 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
             }
         }
     }
@@ -354,7 +311,6 @@ class RejourneyModuleImpl(
 
     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
@@ -371,7 +327,6 @@ class RejourneyModuleImpl(
         }
 
         try {
-            // Initialize upload manager
             uploadManager = UploadManager(reactContext, "https://api.rejourney.co")
             Logger.debug("UploadManager initialized")
         } catch (e: Exception) {
@@ -380,7 +335,6 @@ class RejourneyModuleImpl(
         }
 
         try {
-            // Initialize touch interceptor
             touchInterceptor = TouchInterceptor.getInstance(reactContext).apply {
                 delegate = this@RejourneyModuleImpl
             }
@@ -391,7 +345,6 @@ class RejourneyModuleImpl(
         }
 
         try {
-            // Initialize device auth manager
             deviceAuthManager = DeviceAuthManager.getInstance(reactContext).apply {
                 authFailureListener = this@RejourneyModuleImpl
             }
@@ -402,7 +355,6 @@ class RejourneyModuleImpl(
         }
 
         try {
-            // Initialize network monitor
             networkMonitor = NetworkMonitor.getInstance(reactContext).apply {
                 listener = this@RejourneyModuleImpl
             }
@@ -413,7 +365,6 @@ class RejourneyModuleImpl(
         }
         
         try {
-            // Initialize keyboard tracker (for keyboard show/hide events)
             keyboardTracker = KeyboardTracker.getInstance(reactContext).apply {
                 listener = this@RejourneyModuleImpl
             }
@@ -424,7 +375,6 @@ class RejourneyModuleImpl(
         }
         
         try {
-            // Initialize text input tracker (for key press counting)
             textInputTracker = TextInputTracker.getInstance(reactContext).apply {
                 listener = this@RejourneyModuleImpl
             }
@@ -462,27 +412,57 @@ class RejourneyModuleImpl(
         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 getDeviceInfo(promise: Promise) {
+        try {
+            val map = Arguments.createMap()
+            map.putString("model", android.os.Build.MODEL)
+            map.putString("brand", android.os.Build.MANUFACTURER)
+            map.putString("systemName", "Android")
+            map.putString("systemVersion", android.os.Build.VERSION.RELEASE)
+            map.putString("bundleId", reactContext.packageName)
+            
+            try {
+                val pInfo = reactContext.packageManager.getPackageInfo(reactContext.packageName, 0)
+                map.putString("appVersion", pInfo.versionName)
+                if (android.os.Build.VERSION.SDK_INT >= 28) {
+                    map.putString("buildNumber", pInfo.longVersionCode.toString())
+                } else {
+                    @Suppress("DEPRECATION")
+                    map.putString("buildNumber", pInfo.versionCode.toString())
+                }
+            } catch (e: Exception) {
+                map.putString("appVersion", "unknown")
+            }
+            
+            map.putBoolean("isTablet", isTablet())
+            promise.resolve(map)
+        } catch (e: Exception) {
+            promise.reject("DEVICE_INFO_ERROR", e)
+        }
+    }
+
+    private fun isTablet(): Boolean {
+        val configuration = reactContext.resources.configuration
+        return (configuration.screenLayout and android.content.res.Configuration.SCREENLAYOUT_SIZE_MASK) >= 
+                android.content.res.Configuration.SCREENLAYOUT_SIZE_LARGE
+    }
 
     fun startSession(userId: String, apiUrl: String, publicKey: String, promise: Promise) {
-        ensureInitialized() // Lazy init on first call
+        ensureInitialized()
         
         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 {
@@ -496,14 +476,12 @@ class RejourneyModuleImpl(
                 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()
@@ -511,36 +489,30 @@ class RejourneyModuleImpl(
                 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)
@@ -548,33 +520,26 @@ class RejourneyModuleImpl(
                         .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)
@@ -583,15 +548,12 @@ class RejourneyModuleImpl(
                     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
+                if (startupDurationMs > 0 && startupDurationMs < 60000) {
                     val startupEvent = mapOf(
                         "type" to "app_startup",
                         "timestamp" to nowMs,
@@ -602,13 +564,10 @@ class RejourneyModuleImpl(
                     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 ?: ""))
@@ -635,22 +594,17 @@ class RejourneyModuleImpl(
 
                 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
@@ -670,7 +624,6 @@ class RejourneyModuleImpl(
                     "durationSeconds" to durationSeconds
                 )
 
-                // Evaluate replay promotion
                 val promotionResult = uploadManager?.evaluateReplayPromotion(metrics)
                 val isPromoted = promotionResult?.first ?: false
                 val reason = promotionResult?.second ?: "unknown"
@@ -681,11 +634,9 @@ class RejourneyModuleImpl(
                     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
+                var endSessionSuccess = sessionEndSent
                 if (!sessionEndSent) {
                     sessionEndSent = true
                     endSessionSuccess = uploadManager?.endSession() ?: false
@@ -694,12 +645,10 @@ class RejourneyModuleImpl(
                     }
                 }
 
-                // 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())
@@ -709,13 +658,11 @@ class RejourneyModuleImpl(
                     }
                 }
 
-                // 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)
@@ -724,7 +671,6 @@ class RejourneyModuleImpl(
                     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))
@@ -772,7 +718,6 @@ class RejourneyModuleImpl(
             )
             addEventWithPersistence(event)
 
-            // Notify capture engine with delay for render
             scope.launch {
                 delay(100)
                 captureEngine?.notifyNavigationToScreen(screenName)
@@ -925,7 +870,6 @@ class RejourneyModuleImpl(
 
     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())
@@ -939,8 +883,6 @@ class RejourneyModuleImpl(
         promise.resolve(currentSessionId)
     }
 
-    // ==================== Privacy / View Masking ====================
-
     fun maskViewByNativeID(nativeID: String, promise: Promise) {
         if (nativeID.isEmpty()) {
             promise.resolve(createSuccessMap(false))
@@ -948,8 +890,6 @@ class RejourneyModuleImpl(
         }
 
         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))
@@ -966,7 +906,6 @@ class RejourneyModuleImpl(
         }
 
         try {
-            // Remove nativeID from the privacy mask set
             com.rejourney.privacy.PrivacyMask.removeMaskedNativeID(nativeID)
             Logger.debug("Unmasked nativeID: $nativeID")
             promise.resolve(createSuccessMap(true))
@@ -981,13 +920,11 @@ class RejourneyModuleImpl(
      * 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)
@@ -999,28 +936,22 @@ class RejourneyModuleImpl(
         return null
     }
 
-    // ==================== User Identity ====================
 
     fun setUserIdentity(userId: String, promise: Promise) {
         try {
             val safeUserId = userId.ifEmpty { "anonymous" }
             
-            // KEY CHANGE: Persist directly to SharedPreferences (Native Storage)
-            // This replaces the need for async-storage on the JS side
             reactContext.getSharedPreferences("rejourney", 0)
                 .edit()
                 .putString("rj_user_identity", safeUserId)
                 .apply()
             
-            // Update in-memory state
             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",
@@ -1041,7 +972,6 @@ class RejourneyModuleImpl(
         promise.resolve(userId)
     }
 
-    // ==================== Helper Methods ====================
 
     private fun createResultMap(success: Boolean, sessionId: String, error: String? = null): WritableMap {
         return Arguments.createMap().apply {
@@ -1103,18 +1033,18 @@ class RejourneyModuleImpl(
             false
         }
 
-        val shouldRecord = recordingEnabledByConfig && sessionSampled
-        remoteRecordingEnabled = shouldRecord
+        val shouldRecordVideo = recordingEnabledByConfig && sessionSampled
+        remoteRecordingEnabled = shouldRecordVideo
 
-        if (!shouldRecord && captureEngine?.isRecording == true) {
+        if (!shouldRecordVideo && captureEngine?.isRecording == true) {
             captureEngine?.stopSession()
         }
 
         if (decidedSample && recordingEnabledByConfig && !sessionSampled) {
-            Logger.warning("Session skipped by sample rate (${clampedRate}%)")
+            Logger.info("Session sampled out for video (${clampedRate}%) - entering Data-Only Mode (Events enabled, Video disabled)")
         }
 
-        return shouldRecord
+        return shouldRecordVideo
     }
 
     private fun startBatchUploadTimer() {
@@ -1143,7 +1073,6 @@ class RejourneyModuleImpl(
             try {
                 performBatchUpload()
             } catch (_: Exception) {
-                // Best-effort only
             }
         }
     }
@@ -1179,25 +1108,18 @@ class RejourneyModuleImpl(
         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
+            throw e
         } catch (e: Exception) {
             Logger.error("Batch upload failed", e)
         }
@@ -1233,24 +1155,19 @@ class RejourneyModuleImpl(
                 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
@@ -1270,7 +1187,6 @@ class RejourneyModuleImpl(
                     "durationSeconds" to durationSeconds
                 )
 
-                // Evaluate promotion
                 val promotionResult = uploadManager?.evaluateReplayPromotion(metrics)
                 val isPromoted = promotionResult?.first ?: false
                 val promotionReason = promotionResult?.second ?: "unknown"
@@ -1279,22 +1195,18 @@ class RejourneyModuleImpl(
                     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())
@@ -1304,13 +1216,11 @@ class RejourneyModuleImpl(
                     }
                 }
 
-                // Clear state
                 isRecording = false
                 currentSessionId = null
                 userId = null
                 sessionEvents.clear()
                 
-                // Stop SessionLifecycleService
                 try {
                     val serviceIntent = Intent(reactContext, SessionLifecycleService::class.java)
                     reactContext.stopService(serviceIntent)
@@ -1346,11 +1256,10 @@ class RejourneyModuleImpl(
         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")
@@ -1358,15 +1267,16 @@ class RejourneyModuleImpl(
                     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()
@@ -1375,7 +1285,6 @@ class RejourneyModuleImpl(
                 Logger.warning("[Rejourney] Stop tracking failed: ${e.message}")
             }
 
-            // Build metrics
             var crashCount = 0
             var anrCount = 0
             var errorCount = 0
@@ -1388,52 +1297,23 @@ class RejourneyModuleImpl(
             }
             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")
+            Logger.debug("[Rejourney] endSessionSynchronous: Skipping synchronous upload - relying on EventBuffer and UploadWorker recovery")
+            
+            val uploadSuccess = true
+            Logger.debug("[Rejourney] endSessionSynchronous: Upload result=SKIPPED (persisted)")
 
-            // Send session end signal - THIS IS THE CRITICAL /session/end CALL
             if (!sessionEndSent) {
                 sessionEndSent = true
-                Logger.debug("[Rejourney] endSessionSynchronous: Calling /session/end... (sessionId=$sessionId)")
+                Logger.debug("[Rejourney] endSessionSynchronous: Skipping /session/end - UploadWorker will handle recovery (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")
+                val endSuccess = true
+                Logger.debug("[Rejourney] endSessionSynchronous: /session/end result=SKIPPED (recovery)")
 
-                // 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
@@ -1459,13 +1339,11 @@ class RejourneyModuleImpl(
             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()
@@ -1478,41 +1356,34 @@ class RejourneyModuleImpl(
             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()
@@ -1585,19 +1456,11 @@ class RejourneyModuleImpl(
                     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 ->
@@ -1607,7 +1470,6 @@ class RejourneyModuleImpl(
                                     }
                                 }
                                 
-                                // Check for pending ANR reports
                                 val anrHandler = ANRHandler.getInstance(reactContext)
                                 if (anrHandler.hasPendingANRReport()) {
                                     anrHandler.loadAndPurgePendingANRReport()?.let { anrReport ->
@@ -1630,18 +1492,13 @@ class RejourneyModuleImpl(
         }
     }
 
-    // ==================== 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")
             }
@@ -1651,11 +1508,9 @@ class RejourneyModuleImpl(
     }
     
     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")
@@ -1664,20 +1519,10 @@ class RejourneyModuleImpl(
                 }
             }
             
-            // 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")
             }
@@ -1688,10 +1533,8 @@ class RejourneyModuleImpl(
 
     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()
@@ -1704,12 +1547,9 @@ class RejourneyModuleImpl(
     }
 
     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) {
@@ -1717,10 +1557,8 @@ class RejourneyModuleImpl(
         }
     }
 
-    // ==================== 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()
@@ -1733,7 +1571,6 @@ class RejourneyModuleImpl(
     }
 
     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")
@@ -1741,14 +1578,10 @@ class RejourneyModuleImpl(
             }
 
             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)
@@ -1760,12 +1593,9 @@ class RejourneyModuleImpl(
     }
     
     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)
             
@@ -1777,8 +1607,6 @@ class RejourneyModuleImpl(
     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()
 
@@ -1790,7 +1618,7 @@ class RejourneyModuleImpl(
         }
 
         scheduledBackgroundRunnable = runnable
-        mainHandler.postDelayed(runnable, 50L) // Reduced to 50ms
+        mainHandler.postDelayed(runnable, 50L)
     }
 
     private fun cancelScheduledBackground() {
@@ -1827,16 +1655,13 @@ class RejourneyModuleImpl(
         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)
         }
@@ -1860,11 +1685,9 @@ class RejourneyModuleImpl(
         
         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()
@@ -1876,25 +1699,17 @@ class RejourneyModuleImpl(
             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(),
@@ -1904,7 +1719,6 @@ class RejourneyModuleImpl(
                     )
                     sessionEvents.add(timeoutEvent)
                     
-                    // Upload old session's events as final and call session/end
                     val finalEvents = sessionEvents.toList()
                     sessionEvents.clear()
                     
@@ -1916,8 +1730,6 @@ class RejourneyModuleImpl(
                         }
                     }
                     
-                    // 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
@@ -1928,7 +1740,6 @@ class RejourneyModuleImpl(
                         }
                     }
                     
-                    // Clear recovery markers for old session
                     try {
                         uploadManager?.clearSessionRecovery(oldSessionId)
                     } catch (e: Exception) {
@@ -1941,53 +1752,39 @@ class RejourneyModuleImpl(
                         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()
@@ -2000,14 +1797,10 @@ class RejourneyModuleImpl(
                                 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)
@@ -2022,7 +1815,6 @@ class RejourneyModuleImpl(
                     
                     isRecording = true
                     
-                    // Add session_start event for new session
                     val sessionStartEvent = mapOf(
                         "type" to EventType.SESSION_START,
                         "timestamp" to System.currentTimeMillis(),
@@ -2033,11 +1825,9 @@ class RejourneyModuleImpl(
                     )
                     addEventWithPersistence(sessionStartEvent)
                     
-                    // Start timers for new session
                     startBatchUploadTimer()
                     startDurationLimitTimer()
                     
-                    // Trigger immediate upload to register new session
                     delay(100)
                     try {
                         performBatchUpload()
@@ -2048,15 +1838,11 @@ class RejourneyModuleImpl(
                     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()
                 }
@@ -2068,7 +1854,6 @@ class RejourneyModuleImpl(
      * 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
@@ -2084,7 +1869,6 @@ class RejourneyModuleImpl(
             return
         }
         
-        // Log foreground event for replay player
         addEventWithPersistence(
             mapOf(
                 "type" to EventType.APP_FOREGROUND,
@@ -2095,7 +1879,6 @@ class RejourneyModuleImpl(
             )
         )
         
-        // Resume capture and tracking
         if (remoteRecordingEnabled) {
             try {
                 captureEngine?.startSession(currentSessionId!!)
@@ -2125,7 +1908,6 @@ class RejourneyModuleImpl(
      * 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
@@ -2136,42 +1918,33 @@ class RejourneyModuleImpl(
         
         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
@@ -2180,7 +1953,6 @@ class RejourneyModuleImpl(
                 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()
@@ -2194,15 +1966,12 @@ class RejourneyModuleImpl(
             }
             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)")
@@ -2210,62 +1979,45 @@ class RejourneyModuleImpl(
                 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
+                    isFinal = shouldEndSession,
+                    expedited = true
                 )
                 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.setActiveSessionId(sid)
                             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 ->
@@ -2287,11 +2039,9 @@ class RejourneyModuleImpl(
                                 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()
@@ -2300,12 +2050,10 @@ class RejourneyModuleImpl(
                                     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()
                         }
@@ -2313,18 +2061,14 @@ class RejourneyModuleImpl(
                         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?>) {
@@ -2333,8 +2077,6 @@ class RejourneyModuleImpl(
         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,
@@ -2346,15 +2088,14 @@ class RejourneyModuleImpl(
                 "type" to EventType.GESTURE,
                 "timestamp" to timestamp,
                 "gestureType" to gestureType,
-                "touches" to listOf(touchPoint),  // Required by web player TouchOverlay
+                "touches" to listOf(touchPoint),
                 "duration" to (details["duration"] ?: 0),
                 "targetLabel" to details["targetLabel"],
-                "x" to x,  // Keep for backwards compatibility
+                "x" to x,
                 "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)
@@ -2405,7 +2146,6 @@ class RejourneyModuleImpl(
         try {
             val timestamp = System.currentTimeMillis()
             
-            // Build touches array matching iOS format for web player compatibility
             val touchPoint = mapOf(
                 "x" to x,
                 "y" to y,
@@ -2414,10 +2154,10 @@ class RejourneyModuleImpl(
             )
             
             val eventMap = mapOf(
-                "type" to EventType.GESTURE,  // Use gesture type for web player compatibility
+                "type" to EventType.GESTURE,
                 "timestamp" to timestamp,
                 "gestureType" to "rage_tap",
-                "touches" to listOf(touchPoint),  // Required by web player TouchOverlay
+                "touches" to listOf(touchPoint),
                 "tapCount" to tapCount,
                 "x" to x,
                 "y" to y
@@ -2434,7 +2174,6 @@ class RejourneyModuleImpl(
 
     override fun currentKeyboardHeight(): Int = lastKeyboardHeight
 
-    // ==================== NetworkMonitorListener ====================
 
     override fun onNetworkChanged(quality: com.rejourney.network.NetworkQuality) {
         if (!isRecording) return
@@ -2459,7 +2198,6 @@ class RejourneyModuleImpl(
         addEventWithPersistence(eventMap)
     }
     
-    // ==================== KeyboardTrackerListener ====================
     
     override fun onKeyboardShown(keyboardHeight: Int) {
         if (!isRecording) return
@@ -2475,7 +2213,6 @@ class RejourneyModuleImpl(
         )
         addEventWithPersistence(eventMap)
         
-        // Schedule capture after keyboard settles
         captureEngine?.notifyKeyboardEvent("keyboard_shown")
     }
     
@@ -2485,7 +2222,6 @@ class RejourneyModuleImpl(
         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(
@@ -2503,10 +2239,8 @@ class RejourneyModuleImpl(
         )
         addEventWithPersistence(eventMap)
         
-        // Reset key press count when keyboard hides
         keyPressCount = 0
         
-        // Schedule capture after keyboard settles
         captureEngine?.notifyKeyboardEvent("keyboard_hidden")
     }
     
@@ -2514,17 +2248,13 @@ class RejourneyModuleImpl(
         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(
@@ -2536,16 +2266,13 @@ class RejourneyModuleImpl(
         }
     }
     
-    // ==================== 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(),
@@ -2554,19 +2281,15 @@ class RejourneyModuleImpl(
             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) {}
@@ -2575,7 +2298,6 @@ class RejourneyModuleImpl(
         
         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
         }
 
@@ -2612,7 +2334,6 @@ class RejourneyModuleImpl(
     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(),
@@ -2635,9 +2356,6 @@ class RejourneyModuleImpl(
             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
@@ -2654,7 +2372,7 @@ class RejourneyModuleImpl(
                 val success = uploadManager?.uploadHierarchy(
                     hierarchyData = snapshotsJson,
                     timestamp = timestamp,
-                    sessionId = sid  // Pass session ID explicitly
+                    sessionId = sid
                 ) ?: false
                 
                 val uploadDuration = System.currentTimeMillis() - uploadStartTime
@@ -2670,7 +2388,6 @@ class RejourneyModuleImpl(
         }
     }
     
-    // ==================== AuthFailureListener ====================
     
     /**
      * Called when authentication fails due to security errors (403/404).
@@ -2683,14 +2400,11 @@ class RejourneyModuleImpl(
         
         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)
             }
         }
@@ -2707,19 +2421,15 @@ class RejourneyModuleImpl(
         
         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
@@ -2728,7 +2438,6 @@ class RejourneyModuleImpl(
         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()
@@ -2741,7 +2450,6 @@ class RejourneyModuleImpl(
      * Schedule a background auth retry after specified delay.
      */
     private fun scheduleBackgroundAuthRetry(delayMs: Long) {
-        // Cancel any existing retry job
         authRetryJob?.cancel()
         
         authRetryJob = scope.launch {
@@ -2768,7 +2476,6 @@ class RejourneyModuleImpl(
                 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")
@@ -2798,38 +2505,29 @@ class RejourneyModuleImpl(
      * 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) {
@@ -2886,7 +2584,6 @@ class RejourneyModuleImpl(
      */
     private fun checkPreviousAppKill() {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
-            // ApplicationExitInfo is only available on Android 11+ (API 30)
             return
         }
         
@@ -2897,7 +2594,6 @@ class RejourneyModuleImpl(
                 return
             }
             
-            // Get historical exit reasons for this process
             val exitReasons = activityManager.getHistoricalProcessExitReasons(null, 0, 1)
             
             if (exitReasons.isNotEmpty()) {
@@ -2907,11 +2603,8 @@ class RejourneyModuleImpl(
                 
                 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) {
@@ -2930,40 +2623,29 @@ class RejourneyModuleImpl(
             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
+                                val estimatedEndTime = System.currentTimeMillis() - 1000
                                 
                                 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")
@@ -2978,7 +2660,6 @@ class RejourneyModuleImpl(
                         }
                     }
                 } else {
-                    // Session was properly closed, clear old markers
                     prefs.edit()
                         .remove("rj_current_session_id")
                         .remove("rj_session_start_time")