@rejourneyco/react-native 1.0.8 → 1.0.9

package/android/src/main/java/com/rejourney/recording/ReplayOrchestrator.kt

@@ -40,20 +40,20 @@ import java.util.*
  * Android implementation aligned with iOS ReplayOrchestrator.swift
  */
 class ReplayOrchestrator private constructor(private val context: Context) {
-    
+
     companion object {
         @Volatile
         private var instance: ReplayOrchestrator? = null
-        
+
         fun getInstance(context: Context): ReplayOrchestrator {
             return instance ?: synchronized(this) {
                 instance ?: ReplayOrchestrator(context.applicationContext).also { instance = it }
             }
         }
-        
+
         val shared: ReplayOrchestrator?
             get() = instance
-        
+
         // Process start time for app startup tracking
         private val processStartTime: Long by lazy {
             try {
@@ -72,13 +72,13 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             }
         }
     }
-    
+
     var apiToken: String? = null
     var replayId: String? = null
     var replayStartMs: Long = 0
     var deferredUploadMode = false
     var frameBundleSize: Int = 5
-    
+
     var serverEndpoint: String
         get() = TelemetryPipeline.shared?.endpoint ?: "https://api.rejourney.co"
         set(value) {
@@ -86,7 +86,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             SegmentDispatcher.shared.endpoint = value
             DeviceRegistrar.shared?.endpoint = value
         }
-    
+
     var snapshotInterval: Double = 1.0
     var compressionLevel: Double = 0.5
     var visualCaptureEnabled: Boolean = true
@@ -99,7 +99,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     var hierarchyCaptureInterval: Double = 2.0
     var currentScreenName: String? = null
         private set
-    
+
     // Remote config from backend (set via setRemoteConfig before session start)
     var remoteRejourneyEnabled: Boolean = true
         private set
@@ -109,7 +109,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         private set
     var remoteMaxRecordingMinutes: Int = 10
         private set
-    
+
     // Network state tracking
     var currentNetworkType: String = "unknown"
         private set
@@ -119,11 +119,11 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         private set
     var networkIsExpensive: Boolean = false
         private set
-    
+
     private var networkCallback: ConnectivityManager.NetworkCallback? = null
     private var netReady = false
     private var live = false
-    
+
     private var crashCount = 0
     private var freezeCount = 0
     private var errorCount = 0
@@ -140,20 +140,21 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     private var hierarchyRunnable: Runnable? = null
     private var lastHierarchyHash: String? = null
     private var durationLimitRunnable: Runnable? = null
-    
+    private val lifecycleContractVersion = 2
+
     private val mainHandler = Handler(Looper.getMainLooper())
-    
+
     /**
      * Fast session start using existing credentials - skips credential fetch for faster restart
      */
     fun beginReplayFast(apiToken: String, serverEndpoint: String, credential: String, captureSettings: Map<String, Any>? = null) {
         val perf = PerformanceSnapshot.capture()
         DiagnosticLog.debugSessionCreate("ORCHESTRATOR_FAST_INIT", "beginReplayFast with existing credential", perf)
-        
+
         this.apiToken = apiToken
         this.serverEndpoint = serverEndpoint
         applySettings(captureSettings)
-        
+
         // Set credentials AND endpoint directly without network fetch
         TelemetryPipeline.shared?.apiToken = apiToken
         TelemetryPipeline.shared?.credential = credential
@@ -161,26 +162,26 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         SegmentDispatcher.shared.apiToken = apiToken
         SegmentDispatcher.shared.credential = credential
         SegmentDispatcher.shared.endpoint = serverEndpoint
-        
+
         // Skip network monitoring, assume network is available since we just came from background
         mainHandler.post {
             beginRecording(apiToken)
         }
     }
-    
+
     fun beginReplay(apiToken: String, serverEndpoint: String, captureSettings: Map<String, Any>? = null) {
         DiagnosticLog.trace("[ReplayOrchestrator] beginReplay v2")
         val perf = PerformanceSnapshot.capture()
         DiagnosticLog.debugSessionCreate("ORCHESTRATOR_INIT", "beginReplay", perf)
         DiagnosticLog.trace("[ReplayOrchestrator] beginReplay called, endpoint=$serverEndpoint")
-        
+
         this.apiToken = apiToken
         this.serverEndpoint = serverEndpoint
         applySettings(captureSettings)
-        
+
         DiagnosticLog.debugSessionCreate("CREDENTIAL_START", "Requesting device credential")
         DiagnosticLog.trace("[ReplayOrchestrator] Requesting credential from DeviceRegistrar.shared=${DeviceRegistrar.shared != null}")
-        
+
         DeviceRegistrar.shared?.obtainCredential(apiToken) { ok, cred ->
             DiagnosticLog.trace("[ReplayOrchestrator] Credential callback: ok=$ok, cred=${cred?.take(20) ?: "null"}...")
             if (!ok) {
@@ -188,24 +189,24 @@ class ReplayOrchestrator private constructor(private val context: Context) {
                 DiagnosticLog.caution("[ReplayOrchestrator] Credential fetch FAILED - recording cannot start")
                 return@obtainCredential
             }
-            
+
             TelemetryPipeline.shared?.apiToken = apiToken
             TelemetryPipeline.shared?.credential = cred
             SegmentDispatcher.shared.apiToken = apiToken
             SegmentDispatcher.shared.credential = cred
-            
+
             DiagnosticLog.trace("[ReplayOrchestrator] Credential OK, calling monitorNetwork")
             monitorNetwork(apiToken)
         }
     }
-    
+
     fun beginDeferredReplay(apiToken: String, serverEndpoint: String, captureSettings: Map<String, Any>? = null) {
         this.apiToken = apiToken
         this.serverEndpoint = serverEndpoint
         deferredUploadMode = true
-        
+
         applySettings(captureSettings)
-        
+
         DeviceRegistrar.shared?.obtainCredential(apiToken) { ok, cred ->
             if (!ok) return@obtainCredential
             TelemetryPipeline.shared?.apiToken = apiToken
@@ -213,47 +214,55 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             SegmentDispatcher.shared.apiToken = apiToken
             SegmentDispatcher.shared.credential = cred
         }
-        
+
         initSession()
         TelemetryPipeline.shared?.activateDeferredMode()
-        
+
         val renderCfg = computeRender(1, "standard")
-        
+
         if (visualCaptureEnabled) {
             VisualCapture.shared?.configure(renderCfg.first, renderCfg.second)
             VisualCapture.shared?.beginCapture(replayStartMs)
             VisualCapture.shared?.activateDeferredMode()
         }
-        
+
         if (interactionCaptureEnabled) InteractionRecorder.shared?.activate()
         if (faultTrackingEnabled) StabilityMonitor.shared?.activate()
-        
+
         live = true
     }
-    
+
     fun commitDeferredReplay() {
         deferredUploadMode = false
         TelemetryPipeline.shared?.commitDeferredData()
         VisualCapture.shared?.commitDeferredData()
         TelemetryPipeline.shared?.activate()
     }
-    
+
     fun endReplay(completion: ((Boolean, Boolean) -> Unit)? = null) {
+        endReplayInternal("unspecified", completion)
+    }
+
+    fun endReplayWithReason(endReason: String, completion: ((Boolean, Boolean) -> Unit)? = null) {
+        endReplayInternal(endReason, completion)
+    }
+
+    private fun endReplayInternal(endReason: String, completion: ((Boolean, Boolean) -> Unit)? = null) {
         if (!live) {
             completion?.invoke(false, false)
             return
         }
         live = false
-        
+
         val sid = replayId ?: ""
         val termMs = System.currentTimeMillis()
         val elapsed = ((termMs - replayStartMs) / 1000).toInt()
-        
+
         unregisterNetworkCallback()
         stopHierarchyCapture()
         stopDurationLimitTimer()
         detachLifecycle()
-        
+
         val metrics = mapOf(
             "crashCount" to crashCount,
             "anrCount" to freezeCount,
@@ -268,40 +277,49 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             "screenCount" to visitedScreens.toSet().size
         )
         val queueDepthAtFinalize = TelemetryPipeline.shared?.getQueueDepth() ?: 0
-        
-        SegmentDispatcher.shared.evaluateReplayRetention(sid, metrics) { retain, reason ->
-            // UI operations MUST run on main thread
-            mainHandler.post {
-                TelemetryPipeline.shared?.shutdown()
-                VisualCapture.shared?.halt()
-                InteractionRecorder.shared?.deactivate()
-                StabilityMonitor.shared?.deactivate()
-                AnrSentinel.shared?.deactivate()
-            }
-            
-            SegmentDispatcher.shared.shipPending()
-            
-            if (finalized) {
-                clearRecovery()
-                completion?.invoke(true, true)
-                return@evaluateReplayRetention
-            }
-            finalized = true
-            
-            SegmentDispatcher.shared.concludeReplay(sid, termMs, bgTimeMs, metrics, queueDepthAtFinalize) { ok ->
+
+        // Do local teardown immediately so lifecycle rollover never depends on network latency.
+        mainHandler.post {
+            TelemetryPipeline.shared?.shutdown()
+            VisualCapture.shared?.halt()
+            InteractionRecorder.shared?.deactivate()
+            StabilityMonitor.shared?.deactivate()
+            AnrSentinel.shared?.deactivate()
+        }
+        SegmentDispatcher.shared.shipPending()
+
+        if (finalized) {
+            clearRecovery()
+            completion?.invoke(true, true)
+            replayId = null
+            replayStartMs = 0
+            return
+        }
+        finalized = true
+
+        SegmentDispatcher.shared.evaluateReplayRetention(sid, metrics) { _, _ ->
+            SegmentDispatcher.shared.concludeReplay(
+                sid,
+                termMs,
+                bgTimeMs,
+                metrics,
+                queueDepthAtFinalize,
+                endReason = endReason,
+                lifecycleVersion = lifecycleContractVersion
+            ) { ok ->
                 if (ok) clearRecovery()
                 completion?.invoke(true, ok)
             }
         }
-        
+
         replayId = null
         replayStartMs = 0
     }
-    
+
     fun redactView(view: View) {
         VisualCapture.shared?.registerRedaction(view)
     }
-    
+
     /**
      * Set remote configuration from backend
      * Called by JS side before startSession to apply server-side settings
@@ -316,89 +334,142 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         this.remoteRecordingEnabled = recordingEnabled
         this.remoteSampleRate = sampleRate
         this.remoteMaxRecordingMinutes = maxRecordingMinutes
-        
+
         // Set isSampledIn for server-side enforcement
         // recordingEnabled=false means either dashboard disabled OR session sampled out by JS
         TelemetryPipeline.shared?.isSampledIn = recordingEnabled
-        
+
         // Apply recording settings immediately
         // If recording is disabled, disable visual capture
         if (!recordingEnabled) {
             visualCaptureEnabled = false
             DiagnosticLog.trace("[ReplayOrchestrator] Visual capture disabled by remote config (recordingEnabled=false)")
         }
-        
+
         // If already recording, restart the duration limit timer with updated config
         if (live) {
             startDurationLimitTimer()
         }
-        
+
         DiagnosticLog.trace("[ReplayOrchestrator] Remote config applied: rejourneyEnabled=$rejourneyEnabled, recordingEnabled=$recordingEnabled, sampleRate=$sampleRate%, maxRecording=${maxRecordingMinutes}min, isSampledIn=$recordingEnabled")
     }
-    
+
     fun unredactView(view: View) {
         VisualCapture.shared?.unregisterRedaction(view)
     }
-    
+
     fun attachAttribute(key: String, value: String) {
         TelemetryPipeline.shared?.recordAttribute(key, value)
     }
-    
+
     fun recordCustomEvent(name: String, payload: String?) {
         TelemetryPipeline.shared?.recordCustomEvent(name, payload ?: "")
     }
-    
+
     fun associateUser(userId: String) {
         TelemetryPipeline.shared?.recordUserAssociation(userId)
     }
-    
+
     fun currentReplayId(): String {
         return replayId ?: ""
     }
-    
+
     fun activateGestureRecording() {
         // Gesture recording activation - handled by InteractionRecorder
     }
-    
+
     fun recoverInterruptedReplay(completion: (String?) -> Unit) {
         val recoveryFile = File(context.filesDir, "rejourney_recovery.json")
-        
+
         if (!recoveryFile.exists()) {
             completion(null)
             return
         }
-        
+
         try {
             val data = recoveryFile.readText()
             val checkpoint = JSONObject(data)
             val recId = checkpoint.optString("replayId", null)
-            
+
             if (recId == null) {
+                clearRecovery()
                 completion(null)
                 return
             }
-            
+
             val origStart = checkpoint.optLong("startMs", 0)
             val nowMs = System.currentTimeMillis()
-            
+
+            DiagnosticLog.notice("[ReplayOrchestrator] Recovering interrupted session: $recId")
+
             checkpoint.optString("apiToken", null)?.let { SegmentDispatcher.shared.apiToken = it }
             checkpoint.optString("endpoint", null)?.let { SegmentDispatcher.shared.endpoint = it }
-            
-            val crashMetrics = mapOf(
-                "crashCount" to 1,
-                "durationSeconds" to ((nowMs - origStart) / 1000).toInt()
-            )
-            val queueDepthAtFinalize = TelemetryPipeline.shared?.getQueueDepth() ?: 0
-            
-            SegmentDispatcher.shared.concludeReplay(recId, nowMs, 0, crashMetrics, queueDepthAtFinalize) { ok ->
-                clearRecovery()
-                completion(if (ok) recId else null)
+            checkpoint.optString("credential", null)?.let { SegmentDispatcher.shared.credential = it }
+            SegmentDispatcher.shared.currentReplayId = recId
+            SegmentDispatcher.shared.activate()
+            TelemetryPipeline.shared?.currentReplayId = recId
+            val hasCrashIncident = hasStoredCrashIncidentForSession(recId)
+
+            val finalizeRecoveredSession = {
+                val crashMetrics = mapOf(
+                    "crashCount" to if (hasCrashIncident) 1 else 0,
+                    "durationSeconds" to ((nowMs - origStart) / 1000).toInt()
+                )
+                val queueDepthAtFinalize = TelemetryPipeline.shared?.getQueueDepth() ?: 0
+
+                SegmentDispatcher.shared.concludeReplay(
+                    recId,
+                    nowMs,
+                    0,
+                    crashMetrics,
+                    queueDepthAtFinalize,
+                    endReason = "recovery_finalize",
+                    lifecycleVersion = lifecycleContractVersion
+                ) { ok ->
+                    DiagnosticLog.notice("[ReplayOrchestrator] Crash recovery finalize: success=$ok, sessionId=$recId")
+                    if (ok) {
+                        clearRecovery()
+                    }
+                    completion(if (ok) recId else null)
+                }
+            }
+
+            val visualCapture = VisualCapture.shared
+            if (visualCapture == null) {
+                finalizeRecoveredSession()
+            } else {
+                visualCapture.uploadPendingFrames(recId) { framesUploaded ->
+                    if (!framesUploaded) {
+                        DiagnosticLog.caution("[ReplayOrchestrator] Crash recovery postponed: pending frame upload failed for session $recId")
+                        completion(null)
+                        return@uploadPendingFrames
+                    }
+                    finalizeRecoveredSession()
+                }
             }
         } catch (e: Exception) {
+            DiagnosticLog.fault("[ReplayOrchestrator] Crash recovery failed: ${e.message}")
             completion(null)
         }
     }
-    
+
+    private fun hasStoredCrashIncidentForSession(sessionId: String): Boolean {
+        val incidentFile = File(context.cacheDir, "rj_incidents.json")
+        if (!incidentFile.exists()) return false
+
+        return try {
+            val incident = JSONObject(incidentFile.readText())
+            val incidentSessionId = incident.optString("sessionId", "")
+            val category = incident.optString("category", "").lowercase()
+            val crashLikeCategory = category == "signal" || category == "exception" || category == "crash"
+            val hasSignalDetail = incident.optString("identifier", "").isNotBlank()
+                || incident.optString("detail", "").isNotBlank()
+            crashLikeCategory && incidentSessionId == sessionId && hasSignalDetail
+        } catch (_: Exception) {
+            false
+        }
+    }
+
     // Tally methods
     fun incrementFaultTally() { crashCount++ }
     fun incrementStalledTally() { freezeCount++ }
@@ -408,21 +479,21 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     fun incrementGestureTally() { gestureCount++ }
     fun incrementRageTapTally() { rageCount++ }
     fun incrementDeadTapTally() { deadTapCount++ }
-    
+
     fun logScreenView(screenId: String) {
         if (screenId.isEmpty()) return
         visitedScreens.add(screenId)
         currentScreenName = screenId
         if (hierarchyCaptureEnabled) captureHierarchy()
     }
-    
+
     private fun initSession() {
         replayStartMs = System.currentTimeMillis()
         // Always generate a fresh session ID - never reuse stale IDs
         val uuidPart = UUID.randomUUID().toString().replace("-", "").lowercase()
         replayId = "session_${replayStartMs}_$uuidPart"
         finalized = false
-        
+
         crashCount = 0
         freezeCount = 0
         errorCount = 0
@@ -434,27 +505,27 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         visitedScreens.clear()
         bgTimeMs = 0
         bgStartMs = null
-        
+
         TelemetryPipeline.shared?.currentReplayId = replayId
         SegmentDispatcher.shared.currentReplayId = replayId
         StabilityMonitor.shared?.currentSessionId = replayId
-        
+
         attachLifecycle()
         saveRecovery()
-        
+
         recordAppStartup()
     }
-    
+
     private fun recordAppStartup() {
         val nowMs = System.currentTimeMillis()
         val startupDurationMs = nowMs - processStartTime
-        
+
         // Only record if it's a reasonable startup time (> 0 and < 60 seconds)
         if (startupDurationMs > 0 && startupDurationMs < 60000) {
             TelemetryPipeline.shared?.recordAppStartup(startupDurationMs)
         }
     }
-    
+
     private fun applySettings(cfg: Map<String, Any>?) {
         if (cfg == null) return
         snapshotInterval = (cfg["captureRate"] as? Double) ?: 0.33
@@ -467,7 +538,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         wifiRequired = (cfg["wifiOnly"] as? Boolean) ?: false
         frameBundleSize = (cfg["screenshotBatchSize"] as? Int) ?: 5
     }
-    
+
     private fun monitorNetwork(token: String) {
         DiagnosticLog.trace("[ReplayOrchestrator] monitorNetwork called")
         val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
@@ -476,25 +547,25 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             beginRecording(token)
             return
         }
-        
+
         networkCallback = object : ConnectivityManager.NetworkCallback() {
             override fun onCapabilitiesChanged(network: Network, capabilities: NetworkCapabilities) {
                 handleNetworkChange(capabilities, token)
             }
-            
+
             override fun onLost(network: Network) {
                 currentNetworkType = "none"
                 netReady = false
             }
         }
-        
+
         val request = NetworkRequest.Builder()
             .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
             .build()
-        
+
         try {
             connectivityManager.registerNetworkCallback(request, networkCallback!!)
-            
+
             // Check current network state immediately (callback only fires on CHANGES)
             val activeNetwork = connectivityManager.activeNetwork
             val capabilities = activeNetwork?.let { connectivityManager.getNetworkCapabilities(it) }
@@ -511,31 +582,31 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             beginRecording(token)
         }
     }
-    
+
     private fun handleNetworkChange(capabilities: NetworkCapabilities, token: String) {
         val isWifi = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
         val isCellular = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
         val isEthernet = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
-        
+
         networkIsExpensive = !isWifi && !isEthernet
         networkIsConstrained = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
         } else {
             networkIsExpensive
         }
-        
+
         currentNetworkType = when {
             isWifi -> "wifi"
             isCellular -> "cellular"
             isEthernet -> "wired"
             else -> "other"
         }
-        
+
         val canProceed = when {
             wifiRequired && !isWifi -> false
             else -> true
         }
-        
+
         mainHandler.post {
             netReady = canProceed
             if (canProceed && !live) {
@@ -543,7 +614,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             }
         }
     }
-    
+
     private fun beginRecording(token: String) {
         DiagnosticLog.trace("[ReplayOrchestrator] beginRecording called, live=$live")
         if (live) {
@@ -551,19 +622,19 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             return
         }
         live = true
-        
+
         this.apiToken = token
         initSession()
         DiagnosticLog.trace("[ReplayOrchestrator] Session initialized: replayId=$replayId")
-        
+
         // Reactivate the dispatcher in case it was halted from a previous session
         SegmentDispatcher.shared.activate()
         TelemetryPipeline.shared?.activate()
-        
+
         val renderCfg = computeRender(1, "standard")
         DiagnosticLog.trace("[ReplayOrchestrator] VisualCapture.shared=${VisualCapture.shared != null}, visualCaptureEnabled=$visualCaptureEnabled")
         VisualCapture.shared?.configure(renderCfg.first, renderCfg.second)
-        
+
         if (visualCaptureEnabled) {
             DiagnosticLog.trace("[ReplayOrchestrator] Starting VisualCapture")
             VisualCapture.shared?.beginCapture(replayStartMs)
@@ -572,79 +643,80 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         if (faultTrackingEnabled) StabilityMonitor.shared?.activate()
         if (responsivenessCaptureEnabled) AnrSentinel.shared?.activate()
         if (hierarchyCaptureEnabled) startHierarchyCapture()
-        
+
         // Start duration limit timer based on remote config
         startDurationLimitTimer()
-        
+
         DiagnosticLog.trace("[ReplayOrchestrator] beginRecording completed")
     }
-    
+
     // MARK: - Duration Limit Timer
-    
+
     private fun startDurationLimitTimer() {
         stopDurationLimitTimer()
-        
+
         val maxMinutes = remoteMaxRecordingMinutes
         if (maxMinutes <= 0) return
-        
+
         val maxMs = maxMinutes.toLong() * 60 * 1000
         val now = System.currentTimeMillis()
         val elapsed = now - replayStartMs
         val remaining = if (maxMs > elapsed) maxMs - elapsed else 0L
-        
+
         if (remaining <= 0) {
             DiagnosticLog.trace("[ReplayOrchestrator] Duration limit already exceeded, stopping session")
-            endReplay()
+            endReplayWithReason("duration_limit")
             return
         }
-        
+
         durationLimitRunnable = Runnable {
             if (!live) return@Runnable
             DiagnosticLog.trace("[ReplayOrchestrator] Recording duration limit reached (${maxMinutes}min), stopping session")
-            endReplay()
+            endReplayWithReason("duration_limit")
         }
         mainHandler.postDelayed(durationLimitRunnable!!, remaining)
-        
+
         DiagnosticLog.trace("[ReplayOrchestrator] Duration limit timer set: ${remaining / 1000}s remaining (max ${maxMinutes}min)")
     }
-    
+
     private fun stopDurationLimitTimer() {
         durationLimitRunnable?.let { mainHandler.removeCallbacks(it) }
         durationLimitRunnable = null
     }
-    
+
     private fun saveRecovery() {
         val sid = replayId ?: return
         val token = apiToken ?: return
-        
+
         val checkpoint = JSONObject().apply {
             put("replayId", sid)
             put("apiToken", token)
             put("startMs", replayStartMs)
             put("endpoint", serverEndpoint)
+            SegmentDispatcher.shared.credential?.let { put("credential", it) }
         }
-        
+
         try {
             File(context.filesDir, "rejourney_recovery.json").writeText(checkpoint.toString())
         } catch (_: Exception) { }
     }
-    
+
     private fun clearRecovery() {
         try {
             File(context.filesDir, "rejourney_recovery.json").delete()
         } catch (_: Exception) { }
     }
-    
+
     private fun attachLifecycle() {
         val app = context as? Application ?: return
         app.registerActivityLifecycleCallbacks(lifecycleCallbacks)
     }
-    
+
     private fun detachLifecycle() {
         val app = context as? Application ?: return
         app.unregisterActivityLifecycleCallbacks(lifecycleCallbacks)
     }
-    
+
     private val lifecycleCallbacks = object : Application.ActivityLifecycleCallbacks {
         override fun onActivityResumed(activity: Activity) {
             bgStartMs?.let { start ->
@@ -652,19 +724,24 @@ class ReplayOrchestrator private constructor(private val context: Context) {
                 bgTimeMs += (now - start)
             }
             bgStartMs = null
+
+            if (responsivenessCaptureEnabled) {
+                AnrSentinel.shared.activate()
+            }
         }
-        
+
         override fun onActivityPaused(activity: Activity) {
             bgStartMs = System.currentTimeMillis()
+            AnrSentinel.shared.deactivate()
         }
-        
+
         override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
         override fun onActivityStarted(activity: Activity) {}
         override fun onActivityStopped(activity: Activity) {}
         override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
         override fun onActivityDestroyed(activity: Activity) {}
     }
-    
+
     private fun unregisterNetworkCallback() {
         networkCallback?.let { callback ->
             try {
@@ -674,10 +751,10 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         }
         networkCallback = null
     }
-    
+
     private fun startHierarchyCapture() {
         stopHierarchyCapture()
-        
+
         hierarchyHandler = Handler(Looper.getMainLooper())
         hierarchyRunnable = object : Runnable {
             override fun run() {
@@ -686,45 +763,45 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             }
         }
         hierarchyHandler?.postDelayed(hierarchyRunnable!!, (hierarchyCaptureInterval * 1000).toLong())
-        
+
         // Initial capture after 500ms
         hierarchyHandler?.postDelayed({ captureHierarchy() }, 500)
     }
-    
+
     private fun stopHierarchyCapture() {
         hierarchyRunnable?.let { hierarchyHandler?.removeCallbacks(it) }
         hierarchyHandler = null
         hierarchyRunnable = null
     }
-    
+
     private fun captureHierarchy() {
         if (!live) return
         val sid = replayId ?: return
-        
+
         if (Looper.myLooper() != Looper.getMainLooper()) {
             mainHandler.post { captureHierarchy() }
             return
         }
-        
+
         // Throttle hierarchy capture when map is visible and animating —
         // ViewHierarchyScanner traverses the full view tree including map's
         // deep SurfaceView/TextureView children, adding main-thread pressure.
         if (SpecialCases.shared.mapVisible && !SpecialCases.shared.mapIdle) {
             return
         }
-        
+
         val hierarchy = ViewHierarchyScanner.shared?.captureHierarchy() ?: return
-        
+
         val hash = hierarchyHash(hierarchy)
         if (hash == lastHierarchyHash) return
         lastHierarchyHash = hash
-        
+
         val json = JSONObject(hierarchy).toString().toByteArray(Charsets.UTF_8)
         val ts = System.currentTimeMillis()
-        
+
         SegmentDispatcher.shared.transmitHierarchy(sid, json, ts, null)
     }
-    
+
     private fun hierarchyHash(h: Map<String, Any>): String {
         val screen = currentScreenName ?: "unknown"
         var childCount = 0