feat(upload): schedule a 60s follow-up sweep after trip finalize

The immediate post-finalize enqueue can hit a transient failure (server
burp, BLE radio kicked the WiFi for a moment) and then sit on
WorkManager's exponential backoff. A second swing 60s later, on a
separate unique-work name so it doesn't REPLACE the immediate one,
catches that case before the trip falls off into the next-ride / next-
launch path. Both workers no-op on empty pending, so when the first
attempt already drained the queue this costs nothing.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: eried

app/src/main/java/com/eried/eucplanet/data/repository/TripRepository.kt

@@ -54,6 +54,11 @@ class TripRepository @Inject constructor(
         // Without a sync folder there's nothing to defer, the trip just stays in
         // the local DB regardless, so the grace window is skipped entirely.
         private const val FINALIZE_GRACE_MS = 15_000L
+        // Delay before the post-finalize follow-up upload sweep fires. Catches the
+        // case where the immediate worker run hit a transient failure and was
+        // parked on backoff; gives one extra swing without waiting for the next
+        // ride or app launch.
+        private const val FOLLOWUP_DELAY_SECONDS = 60L
     }
 
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
@@ -464,14 +469,20 @@ class TripRepository @Inject constructor(
         _pendingTripId.value = null
         pendingFinalizeJob = null
         Log.i(TAG, "Trip finalized: ${trip.fileName} (sync=$willSync, eucstats=$willEucstats)")
-        if (willSync) syncManager.enqueueTripUpload(appSettings)
+        if (willSync) {
+            syncManager.enqueueTripUpload(appSettings)
+            // One free second swing 60s later in case the first attempt failed
+            // transiently. Worker no-ops on empty pending.
+            syncManager.enqueueTripUploadDelayed(appSettings, FOLLOWUP_DELAY_SECONDS)
+        }
         // Eucstats: enqueue ANY time the rider has it on, not only when this
         // specific trip needs uploading. The worker walks every trip eligible
         // for upload (pending=1 / failed=3 / orphaned=0), so this is also the
         // automatic retry path: a trip that failed last ride gets one more
         // shot the next time the rider finishes a ride.
         if (appSettings.onlineUploadEnabled && syncManager.riderStoreId.value != null) {
             syncManager.enqueueEucStatsUpload(appSettings)
+            syncManager.enqueueEucStatsUploadDelayed(appSettings, FOLLOWUP_DELAY_SECONDS)
             Log.i(TAG, "Eucstats upload enqueued (incl. retry sweep for prior failures)")
         }
     }

app/src/main/java/com/eried/eucplanet/data/sync/SyncManager.kt

@@ -68,6 +68,8 @@ class SyncManager @Inject constructor(
         const val TRIPS_SUBFOLDER = "trips"
         const val UPLOAD_WORK_NAME = "trip_upload"
         const val EUCSTATS_UPLOAD_WORK_NAME = "eucstats_upload"
+        const val UPLOAD_FOLLOWUP_WORK_NAME = "trip_upload_followup"
+        const val EUCSTATS_UPLOAD_FOLLOWUP_WORK_NAME = "eucstats_upload_followup"
     }
 
     // App-scoped so trip sync survives settings screen navigation.
@@ -659,6 +661,42 @@ class SyncManager @Inject constructor(
         )
     }
 
+    /**
+     * Schedule a delayed follow-up sweep on a SEPARATE unique work name so it does
+     * not REPLACE the immediate enqueue. Both workers exit instantly on empty
+     * pending, so this is a no-op when the first attempt already drained the queue
+     * (the "unless all was sync" branch). When the first attempt failed transiently
+     * (no network, server burp), this is a free second swing outside WorkManager's
+     * exponential backoff curve.
+     */
+    fun enqueueTripUploadDelayed(settings: AppSettings, delaySeconds: Long) {
+        if (settings.syncFolderUri == null) return
+        val request = OneTimeWorkRequestBuilder<TripUploadWorker>()
+            .setInitialDelay(delaySeconds, TimeUnit.SECONDS)
+            .build()
+        WorkManager.getInstance(context).enqueueUniqueWork(
+            UPLOAD_FOLLOWUP_WORK_NAME,
+            ExistingWorkPolicy.REPLACE,
+            request
+        )
+    }
+
+    fun enqueueEucStatsUploadDelayed(settings: AppSettings, delaySeconds: Long) {
+        val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+        val request = OneTimeWorkRequestBuilder<EucStatsUploadWorker>()
+            .setConstraints(constraints)
+            .setInitialDelay(delaySeconds, TimeUnit.SECONDS)
+            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
+            .build()
+        WorkManager.getInstance(context).enqueueUniqueWork(
+            EUCSTATS_UPLOAD_FOLLOWUP_WORK_NAME,
+            ExistingWorkPolicy.REPLACE,
+            request
+        )
+    }
+
     /**
      * List CSV filenames in the trips subfolder. Returns null if the folder
      * is unavailable, empty list if the folder exists but has no trips yet.