@@ -31,12 +31,37 @@ class AnalyticsService(private val context: Context) {
                 instance ?: AnalyticsService(context.applicationContext).also { instance = it }
             }
         }
+
+        /**
+         * The streak as Home's Study Streak card shows it: from the progress
+         * document (users/{username}/data/progress) that LearningPathFragment's
+         * saveStreak keeps, with the same defaults when there is none yet. Null
+         * when the read failed. Analytics used to read users/{username}/progress/
+         * current, which nothing writes, so the streak and pace were always 0.
+         */
+        internal fun streakFrom(load: UserProgressSyncService.ProgressLoad): Streak? = when (load) {
+            is UserProgressSyncService.ProgressLoad.Loaded -> Streak(load.progress.streak, load.progress.bestStreak)
+            UserProgressSyncService.ProgressLoad.Absent ->
+                UserProgressSyncService.UserProgress().let { Streak(it.streak, it.bestStreak) }
+            is UserProgressSyncService.ProgressLoad.Failed -> null
+        }
+
+        /** Learning pace from the current streak. */
+        internal fun paceFor(streak: Int): String = when {
+            streak >= 5 -> "fast"
+            streak >= 3 -> "steady"
+            else -> "slow"
+        }
     }
 
     private val geminiService = OllamaService.getInstance(context)
     private val firestoreManager = FirestoreManager.getInstance(context)
+    private val progressSyncService = UserProgressSyncService(context)
     private val gson = Gson()
 
+    /** The streak figures analytics uses. */
+    internal data class Streak(val current: Int, val best: Int)
+
     /**
      * Learning analytics summary
      */
@@ -83,11 +108,21 @@ class AnalyticsService(private val context: Context) {
             callback.onProgress("Analyzing your progress...")
 
             // Collect data
-            val stages = firestoreManager.getStagesWithProgress().getOrNull() ?: emptyList()
+            val stages = when (val read = firestoreManager.readPath()) {
+                is PathRead.Path -> read.stages
+                PathRead.NoPath -> {
+                    callback.onError("No learning path found. Please complete the assessment first.")
+                    return@withContext
+                }
+                is PathRead.Failed -> {
+                    Log.w(TAG, "Could not read the learning path", read.cause)
+                    callback.onError(FirestoreManager.PROGRESS_LOAD_FAILED_MESSAGE)
+                    return@withContext
+                }
+            }
             val progress = firestoreManager.getProgress().getOrNull()
-
-            if (stages.isEmpty()) {
-                callback.onError("No learning path found. Please complete the assessment first.")
+            val streak = streakFrom(progressSyncService.loadProgressResult()) ?: run {
+                callback.onError(FirestoreManager.PROGRESS_LOAD_FAILED_MESSAGE)
                 return@withContext
             }
 
@@ -108,19 +143,19 @@ class AnalyticsService(private val context: Context) {
             val (strongTopics, weakTopics) = categorizeTopics(stages)
 
             // Estimate completion time
-            val estimatedDays = estimateCompletionDays(stages, completedStages, progress)
+            val estimatedDays = estimateCompletionDays(stages, completedStages, streak.current)
 
             // Determine learning pace
-            val learningPace = determinePace(progress)
+            val learningPace = paceFor(streak.current)
 
             val analytics = LearningAnalytics(
                 totalXP = totalXP,
                 totalStages = totalStages,
                 completedStages = completedStages,
                 averageStars = averageStars,
                 totalTimeMinutes = 0,  // Would need to track this separately
-                currentStreak = progress?.currentStreak ?: 0,
-                longestStreak = progress?.longestStreak ?: 0,
+                currentStreak = streak.current,
+                longestStreak = streak.best,
                 strongTopics = strongTopics,
                 weakTopics = weakTopics,
                 progressPercentage = progressPercentage,
@@ -196,31 +231,20 @@ class AnalyticsService(private val context: Context) {
     private fun estimateCompletionDays(
         stages: List<PersonalizedStage>,
         completedStages: Int,
-        progress: UserProgress?
+        currentStreak: Int
     ): Int {
         val remainingStages = stages.size - completedStages
 
         // Assume average of 1-2 stages per day based on pace
         val stagesPerDay = when {
             completedStages == 0 -> 1
-            progress?.currentStreak ?: 0 >= 7 -> 2
+            currentStreak >= 7 -> 2
             else -> 1
         }
 
         return (remainingStages / stagesPerDay.coerceAtLeast(1)).coerceAtLeast(1)
     }
 
-    /**
-     * Determine learning pace based on activity
-     */
-    private fun determinePace(progress: UserProgress?): String {
-        return when {
-            progress?.currentStreak ?: 0 >= 5 -> "fast"
-            progress?.currentStreak ?: 0 >= 3 -> "steady"
-            else -> "slow"
-        }
-    }
-
     /**
      * Generate AI-powered recommendations
      */
@@ -379,12 +403,18 @@ class AnalyticsService(private val context: Context) {
     }
 
     /**
-     * Get quick stats for dashboard display
+     * Get quick stats for dashboard display. A failed read is a failure, not zeros.
      */
-    suspend fun getQuickStats(): LearningAnalytics = withContext(Dispatchers.IO) {
+    suspend fun getQuickStats(): Result<LearningAnalytics> = withContext(Dispatchers.IO) {
         try {
-            val stages = firestoreManager.getStagesWithProgress().getOrNull() ?: emptyList()
+            val stages = when (val read = firestoreManager.readPath()) {
+                is PathRead.Path -> read.stages
+                PathRead.NoPath -> emptyList()
+                is PathRead.Failed -> return@withContext Result.failure(read.cause)
+            }
             val progress = firestoreManager.getProgress().getOrNull()
+            val streak = streakFrom(progressSyncService.loadProgressResult())
+                ?: return@withContext Result.failure(IllegalStateException(FirestoreManager.PROGRESS_LOAD_FAILED_MESSAGE))
 
             val completedStages = stages.count { it.isCompleted }
             val totalStages = stages.size
@@ -393,18 +423,18 @@ class AnalyticsService(private val context: Context) {
                 stages.sumOf { it.starsEarned }.toFloat() / completedStages
             } else 0f
 
-            LearningAnalytics(
+            Result.success(LearningAnalytics(
                 totalXP = totalXP,
                 totalStages = totalStages,
                 completedStages = completedStages,
                 averageStars = averageStars,
-                currentStreak = progress?.currentStreak ?: 0,
-                longestStreak = progress?.longestStreak ?: 0,
+                currentStreak = streak.current,
+                longestStreak = streak.best,
                 progressPercentage = (completedStages * 100) / totalStages.coerceAtLeast(1)
-            )
+            ))
         } catch (e: Exception) {
             Log.e(TAG, "Error getting quick stats", e)
-            LearningAnalytics()
+            Result.failure(e)
         }
     }
 }
@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.Log
 import com.google.gson.Gson
 import com.google.gson.JsonObject
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
@@ -36,10 +37,16 @@ class DailyTipService(private val context: Context) {
     private val firestoreManager = FirestoreManager.getInstance(context)
     private val gson = Gson()
 
+    /** Tips from [generateTips], and whether [getTodaysTip] may store them as the day's tips. */
+    internal data class Tips(val tips: List<DailyTip>, val store: Boolean)
+
     /**
      * Get today's tip, generating new ones if needed
      */
-    suspend fun getTodaysTip(): Result<DailyTip> = withContext(Dispatchers.IO) {
+    suspend fun getTodaysTip(): Result<DailyTip> = getTodaysTip(save = { firestoreManager.saveDailyTip(it) })
+
+    /** [getTodaysTip] with the write passed in. */
+    internal suspend fun getTodaysTip(save: suspend (DailyTip) -> Unit): Result<DailyTip> = withContext(Dispatchers.IO) {
         try {
             val todayDate = getTodayDateString()
 
@@ -55,17 +62,19 @@ class DailyTipService(private val context: Context) {
             Log.d(TAG, "No tip for today, generating new tips")
             val newTips = generateTips()
 
-            if (newTips.isNotEmpty()) {
+            if (newTips.tips.isNotEmpty()) {
                 // Save all generated tips
-                newTips.forEach { tip ->
-                    firestoreManager.saveDailyTip(tip)
+                if (newTips.store) {
+                    newTips.tips.forEach { tip ->
+                        save(tip)
+                    }
                 }
-                return@withContext Result.success(newTips.first())
+                return@withContext Result.success(newTips.tips.first())
             }
 
             // Fallback tip
             val fallbackTip = createFallbackTip(todayDate)
-            firestoreManager.saveDailyTip(fallbackTip)
+            save(fallbackTip)
             Result.success(fallbackTip)
 
         } catch (e: Exception) {
@@ -77,10 +86,19 @@ class DailyTipService(private val context: Context) {
     /**
      * Generate tips based on user's current progress
      */
-    internal suspend fun generateTips(): List<DailyTip> {
+    internal suspend fun generateTips(): Tips {
         try {
             // Get user context for personalization
-            val stages = firestoreManager.getStagesWithProgress().getOrNull() ?: emptyList()
+            val stages = when (val read = firestoreManager.readPath()) {
+                is PathRead.Path -> read.stages
+                PathRead.NoPath -> emptyList()
+                is PathRead.Failed -> {
+                    // A stored tip is served all day without asking again, and this one
+                    // knows nothing about where the student is - so show it, don't store it.
+                    Log.w(TAG, "Could not read the learning path; using a generic tip for now", read.cause)
+                    return Tips(createFallbackTips(), store = false)
+                }
+            }
             val currentStage = FirestoreManager.currentStageOf(stages)
             val completedTopics = stages.filter { it.isCompleted }.map { it.title }
 
@@ -94,15 +112,17 @@ class DailyTipService(private val context: Context) {
 
             if (result.isFailure) {
                 Log.e(TAG, "API call failed: ${result.exceptionOrNull()?.message}")
-                return createFallbackTips()
+                return Tips(createFallbackTips(), store = true)
             }
 
             val responseText = result.getOrNull() ?: ""
-            return parseTipsFromResponse(responseText)
+            return Tips(parseTipsFromResponse(responseText), store = true)
 
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             Log.e(TAG, "Error generating tips", e)
-            return createFallbackTips()
+            return Tips(createFallbackTips(), store = true)
         }
     }
 
 
@@ -54,6 +54,12 @@ class FirestoreManager private constructor(private val context: Context) {
         const val COLLECTION_PROJECTS = "projects"
         const val COLLECTION_INTERVIEW_PREP = "interview_prep"
         const val COLLECTION_DAILY_TIPS = "daily_tips"
+
+        /** Firestore's limit on the writes in one WriteBatch. */
+        internal const val MAX_BATCH_WRITES = 500
+
+        /** Shown wherever the student's path or progress could not be read. */
+        const val PROGRESS_LOAD_FAILED_MESSAGE = "Couldn't load your progress. Check your connection and try again."
 
         // Singleton instance
         @Volatile
@@ -105,6 +111,37 @@ class FirestoreManager private constructor(private val context: Context) {
         internal fun currentStageOf(stages: List<PersonalizedStage>): PersonalizedStage? =
             stages.firstOrNull { !it.isCompleted } ?: stages.lastOrNull()
 
+        /**
+         * Keeps a failed read apart from an empty path. Callers used to turn a failure
+         * into an empty list, so a network or permission error told the student to
+         * take the assessment.
+         */
+        /**
+         * Every write a retake makes, for one WriteBatch: reset the stage progress,
+         * delete the old stages the new path doesn't reuse, save the new stages. A set
+         * without merge replaces the whole document, so an old stage whose id comes
+         * back is overwritten rather than deleted first.
+         */
+        internal fun retakeWrites(
+            oldStageIds: List<String>,
+            newStages: List<PersonalizedStage>,
+            now: Long
+        ): List<RetakeWrite> {
+            val newIds = newStages.map { it.id.toString() }.toSet()
+            return listOf<RetakeWrite>(RetakeWrite.ResetProgress(UserProgressSyncService.stageResetFields(now))) +
+                oldStageIds.filter { it !in newIds }.map { RetakeWrite.DeleteStage(it) } +
+                newStages.map { RetakeWrite.SaveStage(it) }
+        }
+
+        internal fun pathReadOf(read: Result<List<PersonalizedStage>>): PathRead {
+            val stages = read.getOrElse {
+                // getPersonalizedStages hands a cancellation back as a failed Result.
+                if (it is CancellationException) throw it
+                return PathRead.Failed(it)
+            }
+            return if (stages.isEmpty()) PathRead.NoPath else PathRead.Path(stages)
+        }
+
         /**
          * [getStagesWithProgress] with its two reads passed in. A missing progress
          * document (nothing completed yet) is an empty map; a failed read is a failure,
@@ -327,6 +364,45 @@ class FirestoreManager private constructor(private val context: Context) {
         }
     )
 
+    /** [getStagesWithProgress], with "no path yet" and "couldn't read" kept apart. */
+    internal suspend fun readPath(): PathRead = pathReadOf(getStagesWithProgress())
+
+    /**
+     * A retake's path swap as one WriteBatch ([retakeWrites]), so Firestore applies
+     * all of it or none of it. The reset and the save used to be separate writes,
+     * and a failed save after a successful reset left the old path with its
+     * progress wiped.
+     */
+    suspend fun replacePathForRetake(stages: List<PersonalizedStage>): Result<Unit> = withContext(Dispatchers.IO) {
+        try {
+            val username = getCurrentUsername()
+            val stagesRef = getStagesDocRef(username).collection(COLLECTION_PERSONALIZED_STAGES)
+            val progressRef = getUserDocRef(username).collection(COLLECTION_DATA).document("progress")
+            val oldIds = stagesRef.get().await().documents.map { it.id }
+            val writes = retakeWrites(oldIds, stages, System.currentTimeMillis())
+            check(writes.size <= MAX_BATCH_WRITES) {
+                "A retake needs ${writes.size} writes; one batch holds $MAX_BATCH_WRITES"
+            }
+
+            val batch = firestore.batch()
+            writes.forEach { write ->
+                when (write) {
+                    is RetakeWrite.ResetProgress -> batch.set(progressRef, write.fields, SetOptions.merge())
+                    is RetakeWrite.DeleteStage -> batch.delete(stagesRef.document(write.stageId))
+                    is RetakeWrite.SaveStage -> batch.set(stagesRef.document(write.stage.id.toString()), write.stage)
+                }
+            }
+            batch.commit().await()
+            Log.d(TAG, "Retake path saved: ${stages.size} stages in ${writes.size} writes")
+            Result.success(Unit)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            Log.e(TAG, "Error replacing the path for a retake", e)
+            Result.failure(e)
+        }
+    }
+
     /**
      * Check if user has personalized stages
      */
@@ -905,6 +981,23 @@ data class UserProfile(
     val assessmentScore: Int = 0
 )
 
+/** What [FirestoreManager.readPath] found. */
+internal sealed class PathRead {
+    /** The student's path, with completion from the progress document. Never empty. */
+    data class Path(val stages: List<PersonalizedStage>) : PathRead()
+    /** The read succeeded and there is no path yet: the student takes the assessment. */
+    object NoPath : PathRead()
+    /** The read failed. Not a missing path: never send the student to the assessment for it. */
+    data class Failed(val cause: Throwable) : PathRead()
+}
+
+/** One write in [FirestoreManager.retakeWrites]. */
+internal sealed class RetakeWrite {
+    data class ResetProgress(val fields: Map<String, Any>) : RetakeWrite()
+    data class DeleteStage(val stageId: String) : RetakeWrite()
+    data class SaveStage(val stage: PersonalizedStage) : RetakeWrite()
+}
+
 /**
  * Personalized learning stage
  */
 
@@ -233,7 +233,11 @@ class FlashcardService(private val context: Context) {
     suspend fun getAllCardsNeedingReview(): Result<Map<Int, List<Flashcard>>> = 
         withContext(Dispatchers.IO) {
         try {
-            val stages = firestoreManager.getStagesWithProgress().getOrNull() ?: emptyList()
+            val stages = when (val read = firestoreManager.readPath()) {
+                is PathRead.Path -> read.stages
+                PathRead.NoPath -> emptyList()
+                is PathRead.Failed -> return@withContext Result.failure(read.cause)
+            }
             val reviewMap = mutableMapOf<Int, List<Flashcard>>()
 
             stages.filter { it.isCompleted }.forEach { stage ->