Sync bug fixes across the board!

android/app/build.gradle.kts

@@ -18,8 +18,8 @@ android {
         applicationId = "com.atridad.ascently"
         minSdk = 31
         targetSdk = 36
-        versionCode = 50
-        versionName = "2.5.0"
+        versionCode = 51
+        versionName = "2.5.1"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

android/app/src/main/java/com/atridad/ascently/data/format/BackupFormat.kt

@@ -13,7 +13,6 @@ data class ClimbDataBackup(
     val problems: List<BackupProblem>,
     val sessions: List<BackupClimbSession>,
     val attempts: List<BackupAttempt>,
-    val deletedItems: List<DeletedItem> = emptyList(),
 )
 
 @Serializable
@@ -34,6 +33,7 @@ data class BackupGym(
     @kotlinx.serialization.SerialName("customDifficultyGrades")
     val customDifficultyGrades: List<String>? = null,
     val notes: String? = null,
+    val isDeleted: Boolean = false,
     val createdAt: String,
     val updatedAt: String,
 ) {
@@ -47,10 +47,26 @@ data class BackupGym(
                 difficultySystems = gym.difficultySystems,
                 customDifficultyGrades = gym.customDifficultyGrades.ifEmpty { null },
                 notes = gym.notes,
+                isDeleted = false,
                 createdAt = gym.createdAt,
                 updatedAt = gym.updatedAt,
             )
         }
+
+        fun createTombstone(id: String, deletedAt: String): BackupGym {
+            return BackupGym(
+                id = id,
+                name = "DELETED",
+                location = null,
+                supportedClimbTypes = emptyList(),
+                difficultySystems = emptyList(),
+                customDifficultyGrades = null,
+                notes = null,
+                isDeleted = true,
+                createdAt = deletedAt,
+                updatedAt = deletedAt,
+            )
+        }
     }
 
     fun toGym(): Gym {
@@ -83,6 +99,7 @@ data class BackupProblem(
     val isActive: Boolean = true,
     val dateSet: String? = null,
     val notes: String? = null,
+    val isDeleted: Boolean = false,
     val createdAt: String,
     val updatedAt: String,
 ) {
@@ -106,10 +123,31 @@ data class BackupProblem(
                 isActive = problem.isActive,
                 dateSet = problem.dateSet,
                 notes = problem.notes,
+                isDeleted = false,
                 createdAt = problem.createdAt,
                 updatedAt = problem.updatedAt,
             )
         }
+
+        fun createTombstone(id: String, deletedAt: String): BackupProblem {
+            return BackupProblem(
+                id = id,
+                gymId = "00000000-0000-0000-0000-000000000000",
+                name = "DELETED",
+                description = null,
+                climbType = ClimbType.values().first(),
+                difficulty = DifficultyGrade(DifficultySystem.values().first(), "0"),
+                tags = null,
+                location = null,
+                imagePaths = null,
+                isActive = false,
+                dateSet = null,
+                notes = null,
+                isDeleted = true,
+                createdAt = deletedAt,
+                updatedAt = deletedAt,
+            )
+        }
     }
 
     fun toProblem(): Problem {
@@ -147,6 +185,7 @@ data class BackupClimbSession(
     val duration: Long? = null,
     val status: SessionStatus,
     val notes: String? = null,
+    val isDeleted: Boolean = false,
     val createdAt: String,
     val updatedAt: String,
 ) {
@@ -161,10 +200,27 @@ data class BackupClimbSession(
                 duration = session.duration,
                 status = session.status,
                 notes = session.notes,
+                isDeleted = false,
                 createdAt = session.createdAt,
                 updatedAt = session.updatedAt,
             )
         }
+
+        fun createTombstone(id: String, deletedAt: String): BackupClimbSession {
+            return BackupClimbSession(
+                id = id,
+                gymId = "00000000-0000-0000-0000-000000000000",
+                date = deletedAt,
+                startTime = null,
+                endTime = null,
+                duration = null,
+                status = SessionStatus.values().first(),
+                notes = null,
+                isDeleted = true,
+                createdAt = deletedAt,
+                updatedAt = deletedAt,
+            )
+        }
     }
 
     fun toClimbSession(): ClimbSession {
@@ -195,6 +251,7 @@ data class BackupAttempt(
     val duration: Long? = null,
     val restTime: Long? = null,
     val timestamp: String,
+    val isDeleted: Boolean = false,
     val createdAt: String,
     val updatedAt: String? = null,
 ) {
@@ -210,10 +267,28 @@ data class BackupAttempt(
                 duration = attempt.duration,
                 restTime = attempt.restTime,
                 timestamp = attempt.timestamp,
+                isDeleted = false,
                 createdAt = attempt.createdAt,
                 updatedAt = attempt.updatedAt,
             )
         }
+
+        fun createTombstone(id: String, deletedAt: String): BackupAttempt {
+            return BackupAttempt(
+                id = id,
+                sessionId = "00000000-0000-0000-0000-000000000000",
+                problemId = "00000000-0000-0000-0000-000000000000",
+                result = AttemptResult.values().first(),
+                highestHold = null,
+                notes = null,
+                duration = null,
+                restTime = null,
+                timestamp = deletedAt,
+                isDeleted = true,
+                createdAt = deletedAt,
+                updatedAt = deletedAt,
+            )
+        }
     }
 
     fun toAttempt(): Attempt {

android/app/src/main/java/com/atridad/ascently/data/repository/ClimbRepository.kt

@@ -19,6 +19,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.serialization.json.Json
 import java.io.File
+import java.time.Instant
 
 class ClimbRepository(database: AscentlyDatabase, private val context: Context) {
     private val gymDao = database.gymDao()
@@ -38,6 +39,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
 
     // Gym operations
     fun getAllGyms(): Flow<List<Gym>> = gymDao.getAllGyms()
+    suspend fun getAllGymsSync(): List<Gym> = gymDao.getAllGyms().first()
     suspend fun getGymById(id: String): Gym? = gymDao.getGymById(id)
     suspend fun insertGym(gym: Gym) {
         gymDao.insertGym(gym)
@@ -60,6 +62,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
 
     // Problem operations
     fun getAllProblems(): Flow<List<Problem>> = problemDao.getAllProblems()
+    suspend fun getAllProblemsSync(): List<Problem> = problemDao.getAllProblems().first()
     suspend fun getProblemById(id: String): Problem? = problemDao.getProblemById(id)
     fun getProblemsByGym(gymId: String): Flow<List<Problem>> = problemDao.getProblemsByGym(gymId)
     suspend fun insertProblem(problem: Problem) {
@@ -80,6 +83,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
 
     // Session operations
     fun getAllSessions(): Flow<List<ClimbSession>> = sessionDao.getAllSessions()
+    suspend fun getAllSessionsSync(): List<ClimbSession> = sessionDao.getAllSessions().first()
     suspend fun getSessionById(id: String): ClimbSession? = sessionDao.getSessionById(id)
     fun getSessionsByGym(gymId: String): Flow<List<ClimbSession>> =
         sessionDao.getSessionsByGym(gymId)
@@ -122,6 +126,8 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
 
     // Attempt operations
     fun getAllAttempts(): Flow<List<Attempt>> = attemptDao.getAllAttempts()
+    suspend fun getAllAttemptsSync(): List<Attempt> = attemptDao.getAllAttempts().first()
+    suspend fun getAttemptById(id: String): Attempt? = attemptDao.getAttemptById(id)
     fun getAttemptsBySession(sessionId: String): Flow<List<Attempt>> =
         attemptDao.getAttemptsBySession(sessionId)
 
@@ -273,10 +279,9 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
     }
 
     fun trackDeletion(itemId: String, itemType: String) {
-        val currentDeletions = getDeletedItems().toMutableList()
+        cleanupOldDeletions()
         val newDeletion =
             DeletedItem(id = itemId, type = itemType, deletedAt = DateFormatUtils.nowISO8601())
-        currentDeletions.add(newDeletion)
 
         val json = json.encodeToString(newDeletion)
         deletionPreferences.edit { putString("deleted_$itemId", json) }
@@ -304,6 +309,27 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         deletionPreferences.edit { clear() }
     }
 
+    private fun cleanupOldDeletions() {
+        val allPrefs = deletionPreferences.all
+        val cutoff = Instant.now().minusSeconds(90L * 24 * 60 * 60)
+
+        deletionPreferences.edit {
+            for ((key, value) in allPrefs) {
+                if (key.startsWith("deleted_") && value is String) {
+                    try {
+                        val deletion = json.decodeFromString<DeletedItem>(value)
+                        val deletedAt = Instant.parse(deletion.deletedAt)
+                        if (deletedAt.isBefore(cutoff)) {
+                            remove(key)
+                        }
+                    } catch (_: Exception) {
+                        // Ignore
+                    }
+                }
+            }
+        }
+    }
+
     private fun validateDataIntegrity(
         gyms: List<Gym>,
         problems: List<Problem>,

android/app/src/main/java/com/atridad/ascently/data/sync/DeltaSyncModels.kt

@@ -4,7 +4,6 @@ import com.atridad.ascently.data.format.BackupAttempt
 import com.atridad.ascently.data.format.BackupClimbSession
 import com.atridad.ascently.data.format.BackupGym
 import com.atridad.ascently.data.format.BackupProblem
-import com.atridad.ascently.data.format.DeletedItem
 import kotlinx.serialization.Serializable
 
 /** Request structure for delta sync - sends only changes since last sync */
@@ -15,16 +14,15 @@ data class DeltaSyncRequest(
     val problems: List<BackupProblem>,
     val sessions: List<BackupClimbSession>,
     val attempts: List<BackupAttempt>,
-    val deletedItems: List<DeletedItem>,
 )
 
 /** Response structure for delta sync - receives only changes from server */
 @Serializable
 data class DeltaSyncResponse(
     val serverTime: String,
+    val requestFullSync: Boolean = false,
     val gyms: List<BackupGym>,
     val problems: List<BackupProblem>,
     val sessions: List<BackupClimbSession>,
     val attempts: List<BackupAttempt>,
-    val deletedItems: List<DeletedItem>,
 )

android/app/src/main/java/com/atridad/ascently/data/sync/SyncException.kt

@@ -18,4 +18,6 @@ sealed class SyncException(message: String) : IOException(message), Serializable
         SyncException("Invalid server response: $details")
 
     data class NetworkError(val details: String) : SyncException("Network error: $details")
+
+    data class General(val details: String) : SyncException(details)
 }

android/app/src/main/java/com/atridad/ascently/data/sync/SyncService.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.content.SharedPreferences
 import androidx.core.content.edit
 import com.atridad.ascently.data.repository.ClimbRepository
+import com.atridad.ascently.data.state.DataStateManager
 import com.atridad.ascently.utils.AppLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -27,7 +28,7 @@ class SyncService(private val context: Context, private val repository: ClimbRep
     }
 
     // Currently we only support one provider, but this allows for future expansion
-    private val provider: SyncProvider = AscentlySyncProvider(context, repository)
+    private val provider: SyncProvider = AscentlySyncProvider(context, repository, DataStateManager(context))
 
     // State
     private val _isSyncing = MutableStateFlow(false)

ios/Ascently.xcodeproj/project.pbxproj

@@ -466,7 +466,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 43;
+				CURRENT_PROJECT_VERSION = 44;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -518,7 +518,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 43;
+				CURRENT_PROJECT_VERSION = 44;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -610,7 +610,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 43;
+				CURRENT_PROJECT_VERSION = 44;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -641,7 +641,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 43;
+				CURRENT_PROJECT_VERSION = 44;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;

ios/Ascently/Models/BackupFormat.swift

@@ -388,7 +388,7 @@ struct BackupClimbSession: Codable {
             startTime: nil,
             endTime: nil,
             duration: nil,
-            status: .finished,
+            status: .completed,
             notes: nil,
             isDeleted: true,
             createdAt: dateString,

ios/Ascently/Models/DeltaSyncFormat.swift

@@ -17,6 +17,7 @@ struct DeltaSyncRequest: Codable {
 
 struct DeltaSyncResponse: Codable {
     let serverTime: String
+    let requestFullSync: Bool?
     let gyms: [BackupGym]
     let problems: [BackupProblem]
     let sessions: [BackupClimbSession]

ios/Ascently/Services/Sync/ServerSyncProvider.swift

@@ -71,8 +71,6 @@ class ServerSyncProvider: SyncProvider {
             throw SyncError.notConnected
         }
 
-        // 1. Priority: Delta Sync
-        // If we have synced before, assume we want to continue with delta sync
         if lastSyncTime != nil {
             AppLogger.info("Last sync time found, attempting delta sync", tag: logTag)
             do {
@@ -81,18 +79,12 @@ class ServerSyncProvider: SyncProvider {
                 return
             } catch {
                 AppLogger.error("Delta sync failed, falling back to full sync check: \(error)", tag: logTag)
-                // Fallthrough to full sync logic
             }
         }
 
-        // 2. Full Sync Logic
-        // Get local backup data
         let localBackup = createBackupFromDataManager(dataManager)
-
-        // Download server data
         let serverBackup = try await downloadData()
 
-        // Check if we have any local data
         let hasLocalData =
             !dataManager.gyms.isEmpty || !dataManager.problems.isEmpty
             || !dataManager.sessions.isEmpty || !dataManager.attempts.isEmpty
@@ -219,7 +211,6 @@ class ServerSyncProvider: SyncProvider {
         let formatter = ISO8601DateFormatter()
         let lastSyncString = formatter.string(from: lastSync)
 
-        // Collect items modified since last sync
         var modifiedGyms = dataManager.gyms.filter { gym in
             gym.updatedAt > lastSync
         }.map { BackupGym(from: $0) }
@@ -249,7 +240,6 @@ class ServerSyncProvider: SyncProvider {
             !activeSessionIds.contains(attempt.sessionId) && attempt.createdAt > lastSync
         }.map { BackupAttempt(from: $0) }
 
-        // Handle deleted items as tombstones
         let deletedItems = dataManager.getDeletedItems().filter { item in
             if let deletedDate = formatter.date(from: item.deletedAt) {
                 return deletedDate > lastSync
@@ -316,6 +306,11 @@ class ServerSyncProvider: SyncProvider {
         let decoder = JSONDecoder()
         let deltaResponse = try decoder.decode(DeltaSyncResponse.self, from: data)
 
+        if let requestFullSync = deltaResponse.requestFullSync, requestFullSync {
+            AppLogger.info("Server requested full sync", tag: logTag)
+            throw SyncError.serverError(412)
+        }
+
         AppLogger.info(
             "Delta Sync: Received gyms=\(deltaResponse.gyms.count), problems=\(deltaResponse.problems.count), sessions=\(deltaResponse.sessions.count), attempts=\(deltaResponse.attempts.count)",
             tag: logTag
@@ -337,7 +332,6 @@ class ServerSyncProvider: SyncProvider {
         let formatter = ISO8601DateFormatter()
         formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
 
-        // 1. Download images for problems that are NOT deleted
         var imagePathMapping: [String: String] = [:]
         for problem in response.problems {
             if let isDeleted = problem.isDeleted, isDeleted { continue }
@@ -359,9 +353,7 @@ class ServerSyncProvider: SyncProvider {
             }
         }
 
-        // 2. Merge Gyms
         for backupGym in response.gyms {
-            // Handle Soft Delete
             if let isDeleted = backupGym.isDeleted, isDeleted {
                 if let index = dataManager.gyms.firstIndex(where: { $0.id.uuidString == backupGym.id }) {
                     let existing = dataManager.gyms[index]
@@ -373,7 +365,6 @@ class ServerSyncProvider: SyncProvider {
                 continue
             }
 
-            // Handle Update/Insert
             if let index = dataManager.gyms.firstIndex(where: { $0.id.uuidString == backupGym.id }) {
                 let existing = dataManager.gyms[index]
                 if let serverUpdate = formatter.date(from: backupGym.updatedAt),
@@ -385,7 +376,6 @@ class ServerSyncProvider: SyncProvider {
             }
         }
 
-        // 3. Merge Problems
         for backupProblem in response.problems {
             if let isDeleted = backupProblem.isDeleted, isDeleted {
                 if let index = dataManager.problems.firstIndex(where: { $0.id.uuidString == backupProblem.id }) {
@@ -415,7 +405,6 @@ class ServerSyncProvider: SyncProvider {
             }
         }
 
-        // 4. Merge Sessions
         for backupSession in response.sessions {
              if let isDeleted = backupSession.isDeleted, isDeleted {
                 if let index = dataManager.sessions.firstIndex(where: { $0.id.uuidString == backupSession.id }) {
@@ -439,7 +428,6 @@ class ServerSyncProvider: SyncProvider {
             }
         }
 
-        // 5. Merge Attempts
         for backupAttempt in response.attempts {
             if let isDeleted = backupAttempt.isDeleted, isDeleted {
                 if let index = dataManager.attempts.firstIndex(where: { $0.id.uuidString == backupAttempt.id }) {
@@ -477,7 +465,7 @@ class ServerSyncProvider: SyncProvider {
          for problem in modifiedProblems {
              guard let imagePaths = problem.imagePaths else { continue }
              for path in imagePaths {
-                 if let data = ImageManager.shared.getImageData(filename: path) {
+                 if let data = ImageManager.shared.loadImageData(fromPath: path) {
                       try await uploadImage(filename: path, imageData: data)
                  }
              }
@@ -549,7 +537,7 @@ class ServerSyncProvider: SyncProvider {
     private func syncImagesToServer(dataManager: ClimbingDataManager) async throws {
         for problem in dataManager.problems {
             for path in problem.imagePaths {
-                 if let data = ImageManager.shared.getImageData(filename: path) {
+                 if let data = ImageManager.shared.loadImageData(fromPath: path) {
                      try await uploadImage(filename: path, imageData: data)
                  }
             }
@@ -568,19 +556,15 @@ class ServerSyncProvider: SyncProvider {
             gyms: gyms,
             problems: problems,
             sessions: sessions,
-            attempts: attempts,
-            deletedItems: [] // Legacy field, empty
+            attempts: attempts
         )
     }
 
     private func mergeDataSafely(localBackup: ClimbDataBackup, serverBackup: ClimbDataBackup, dataManager: ClimbingDataManager) async throws {
-        // Basic full merge that prefers server data if newer
         let formatter = ISO8601DateFormatter()
         formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
 
-        // Merging Gyms
         for gym in serverBackup.gyms {
-            // Check for soft delete
             if let isDeleted = gym.isDeleted, isDeleted {
                 if let index = dataManager.gyms.firstIndex(where: { $0.id.uuidString == gym.id }) {
                     let existing = dataManager.gyms[index]
@@ -591,7 +575,6 @@ class ServerSyncProvider: SyncProvider {
                 continue
             }
 
-            // Update or Insert
              if let index = dataManager.gyms.firstIndex(where: { $0.id.uuidString == gym.id }) {
                  let existing = dataManager.gyms[index]
                  if let serverUpdate = formatter.date(from: gym.updatedAt), serverUpdate >= existing.updatedAt {
@@ -602,7 +585,6 @@ class ServerSyncProvider: SyncProvider {
              }
         }
 
-        // Merging Problems
         for problem in serverBackup.problems {
             if let isDeleted = problem.isDeleted, isDeleted {
                 if let index = dataManager.problems.firstIndex(where: { $0.id.uuidString == problem.id }) {
@@ -624,7 +606,6 @@ class ServerSyncProvider: SyncProvider {
              }
         }
 
-        // Merging Sessions
         for session in serverBackup.sessions {
             if let isDeleted = session.isDeleted, isDeleted {
                 if let index = dataManager.sessions.firstIndex(where: { $0.id.uuidString == session.id }) {
@@ -646,7 +627,6 @@ class ServerSyncProvider: SyncProvider {
              }
         }
 
-        // Merging Attempts
         for attempt in serverBackup.attempts {
             if let isDeleted = attempt.isDeleted, isDeleted {
                 if let index = dataManager.attempts.firstIndex(where: { $0.id.uuidString == attempt.id }) {
@@ -680,7 +660,6 @@ class ServerSyncProvider: SyncProvider {
         _ backup: ClimbDataBackup, dataManager: ClimbingDataManager,
         imagePathMapping: [String: String] = [:]
     ) throws {
-        // Logic from previous read
          let updatedProblems = backup.problems.map { problem in
             let updatedImagePaths = problem.imagePaths?.compactMap { oldPath in
                 imagePathMapping[oldPath] ?? oldPath
@@ -688,7 +667,6 @@ class ServerSyncProvider: SyncProvider {
             return problem.withUpdatedImagePaths(updatedImagePaths)
         }
 
-        // Re-construct data, filtering out deleted items (tombstones)
         dataManager.gyms = try backup.gyms.compactMap { gym in
             if let isDeleted = gym.isDeleted, isDeleted { return nil }
             return try gym.toGym()

ios/Ascently/Services/Sync/SyncMerger.swift

@@ -1,179 +0,0 @@
-import Foundation
-
-struct SyncMerger {
-    private static let logTag = "SyncMerger"
-    
-    static func mergeDataSafely(
-        localBackup: ClimbDataBackup,
-        serverBackup: ClimbDataBackup,
-        dataManager: ClimbingDataManager,
-        imagePathMapping: [String: String]
-    ) throws -> (gyms: [Gym], problems: [Problem], sessions: [ClimbSession], attempts: [Attempt], uniqueDeletions: [DeletedItem]) {
-        
-        // Merge deletion lists first to prevent resurrection of deleted items
-        let localDeletions = dataManager.getDeletedItems()
-        let allDeletions = localDeletions + serverBackup.deletedItems
-        let uniqueDeletions = Array(Set(allDeletions))
-        
-        AppLogger.info("Merging gyms...", tag: logTag)
-        let mergedGyms = mergeGyms(
-            local: dataManager.gyms,
-            server: serverBackup.gyms,
-            deletedItems: uniqueDeletions)
-        
-        AppLogger.info("Merging problems...", tag: logTag)
-        let mergedProblems = try mergeProblems(
-            local: dataManager.problems,
-            server: serverBackup.problems,
-            imagePathMapping: imagePathMapping,
-            deletedItems: uniqueDeletions)
-        
-        AppLogger.info("Merging sessions...", tag: logTag)
-        let mergedSessions = try mergeSessions(
-            local: dataManager.sessions,
-            server: serverBackup.sessions,
-            deletedItems: uniqueDeletions)
-        
-        AppLogger.info("Merging attempts...", tag: logTag)
-        let mergedAttempts = try mergeAttempts(
-            local: dataManager.attempts,
-            server: serverBackup.attempts,
-            deletedItems: uniqueDeletions)
-            
-        return (mergedGyms, mergedProblems, mergedSessions, mergedAttempts, uniqueDeletions)
-    }
-    
-    private static func mergeGyms(local: [Gym], server: [BackupGym], deletedItems: [DeletedItem]) -> [Gym] {
-        var merged = local
-        let deletedGymIds = Set(deletedItems.filter { $0.type == "gym" }.map { $0.id })
-        let localGymIds = Set(local.map { $0.id.uuidString })
-        
-        merged.removeAll { deletedGymIds.contains($0.id.uuidString) }
-        
-        // Add new items from server (excluding deleted ones)
-        for serverGym in server {
-            if let serverGymConverted = try? serverGym.toGym() {
-                let localHasGym = localGymIds.contains(serverGym.id)
-                let isDeleted = deletedGymIds.contains(serverGym.id)
-                
-                if !localHasGym && !isDeleted {
-                    merged.append(serverGymConverted)
-                }
-            }
-        }
-        
-        return merged
-    }
-    
-    private static func mergeProblems(
-        local: [Problem],
-        server: [BackupProblem],
-        imagePathMapping: [String: String],
-        deletedItems: [DeletedItem]
-    ) throws -> [Problem] {
-        var merged = local
-        let deletedProblemIds = Set(deletedItems.filter { $0.type == "problem" }.map { $0.id })
-        let localProblemIds = Set(local.map { $0.id.uuidString })
-        
-        merged.removeAll { deletedProblemIds.contains($0.id.uuidString) }
-        
-        for serverProblem in server {
-            let localHasProblem = localProblemIds.contains(serverProblem.id)
-            let isDeleted = deletedProblemIds.contains(serverProblem.id)
-            
-            if !localHasProblem && !isDeleted {
-                var problemToAdd = serverProblem
-                
-                if !imagePathMapping.isEmpty, let imagePaths = serverProblem.imagePaths, !imagePaths.isEmpty {
-                    let updatedImagePaths = imagePaths.compactMap { oldPath in
-                        imagePathMapping[oldPath] ?? oldPath
-                    }
-                    if updatedImagePaths != imagePaths {
-                        problemToAdd = BackupProblem(
-                            id: serverProblem.id,
-                            gymId: serverProblem.gymId,
-                            name: serverProblem.name,
-                            description: serverProblem.description,
-                            climbType: serverProblem.climbType,
-                            difficulty: serverProblem.difficulty,
-                            tags: serverProblem.tags,
-                            location: serverProblem.location,
-                            imagePaths: updatedImagePaths,
-                            isActive: serverProblem.isActive,
-                            dateSet: serverProblem.dateSet,
-                            notes: serverProblem.notes,
-                            createdAt: serverProblem.createdAt,
-                            updatedAt: serverProblem.updatedAt
-                        )
-                    }
-                }
-                
-                if let serverProblemConverted = try? problemToAdd.toProblem() {
-                    merged.append(serverProblemConverted)
-                }
-            }
-        }
-        
-        return merged
-    }
-    
-    private static func mergeSessions(
-        local: [ClimbSession], server: [BackupClimbSession], deletedItems: [DeletedItem]
-    ) throws -> [ClimbSession] {
-        var merged = local
-        let deletedSessionIds = Set(deletedItems.filter { $0.type == "session" }.map { $0.id })
-        let localSessionIds = Set(local.map { $0.id.uuidString })
-        
-        merged.removeAll { session in
-            deletedSessionIds.contains(session.id.uuidString) && session.status != .active
-        }
-        
-        for serverSession in server {
-            let localHasSession = localSessionIds.contains(serverSession.id)
-            let isDeleted = deletedSessionIds.contains(serverSession.id)
-            
-            if !localHasSession && !isDeleted {
-                if let serverSessionConverted = try? serverSession.toClimbSession() {
-                    merged.append(serverSessionConverted)
-                }
-            }
-        }
-        
-        return merged
-    }
-    
-    private static func mergeAttempts(
-        local: [Attempt], server: [BackupAttempt], deletedItems: [DeletedItem]
-    ) throws -> [Attempt] {
-        var merged = local
-        let deletedAttemptIds = Set(deletedItems.filter { $0.type == "attempt" }.map { $0.id })
-        let localAttemptIds = Set(local.map { $0.id.uuidString })
-        
-        // Get active session IDs to protect their attempts
-        let activeSessionIds = Set(
-            local.compactMap { attempt in
-                return attempt.sessionId
-            }.filter { _ in
-                return true
-            })
-        
-        // Remove items that were deleted on other devices (but be conservative with attempts)
-        merged.removeAll { attempt in
-            deletedAttemptIds.contains(attempt.id.uuidString)
-                && !activeSessionIds.contains(attempt.sessionId)
-        }
-        
-        for serverAttempt in server {
-            let localHasAttempt = localAttemptIds.contains(serverAttempt.id)
-            let isDeleted = deletedAttemptIds.contains(serverAttempt.id)
-            
-            if !localHasAttempt && !isDeleted {
-                if let serverAttemptConverted = try? serverAttempt.toAttempt() {
-                    merged.append(serverAttemptConverted)
-                }
-            }
-        }
-        
-        return merged
-    }
-}

ios/Ascently/ViewModels/ClimbingDataManager.swift

@@ -631,6 +631,34 @@ class ClimbingDataManager: ObservableObject {
         userDefaults.removeObject(forKey: Keys.deletedItems)
     }
 
+    func cleanupOldDeletions() {
+        guard let data = userDefaults.data(forKey: Keys.deletedItems),
+            let deletions = try? decoder.decode([DeletedItem].self, from: data)
+        else {
+            return
+        }
+
+        let cutoffDate = Date().addingTimeInterval(-90 * 24 * 60 * 60) // 90 days ago
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+        let validDeletions = deletions.filter { item in
+            if let date = formatter.date(from: item.deletedAt) {
+                return date > cutoffDate
+            }
+            return false
+        }
+
+        if validDeletions.count < deletions.count {
+            if let encodedData = try? encoder.encode(validDeletions) {
+                userDefaults.set(encodedData, forKey: Keys.deletedItems)
+                AppLogger.info(
+                    "Cleaned up \(deletions.count - validDeletions.count) old deletion records",
+                    tag: "ClimbingDataManager")
+            }
+        }
+    }
+
     func attempts(forProblem problemId: UUID) -> [Attempt] {
         return attempts.filter { $0.problemId == problemId }.sorted { $0.timestamp > $1.timestamp }
     }
@@ -669,6 +697,7 @@ class ClimbingDataManager: ObservableObject {
     }
 
     private func cleanupOrphanedData() {
+        cleanupOldDeletions()
         let validSessionIds = Set(sessions.map { $0.id })
         let validProblemIds = Set(problems.map { $0.id })
         let validGymIds = Set(gyms.map { $0.id })

sync/go.mod

@@ -1,3 +1,5 @@
 module ascently-sync
 
 go 1.25
+
+require github.com/joho/godotenv v1.5.1

sync/go.sum

@@ -0,0 +1,2 @@
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=

sync/main.go

@@ -11,16 +11,11 @@ import (
 	"path/filepath"
 	"strings"
 	"time"
+
+	"github.com/joho/godotenv"
 )
 
-const VERSION = "2.4.0"
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
+const VERSION = "2.5.0"
 
 type ClimbDataBackup struct {
 	ExportedAt    string               `json:"exportedAt"`
@@ -42,6 +37,7 @@ type DeltaSyncRequest struct {
 
 type DeltaSyncResponse struct {
 	ServerTime      string               `json:"serverTime"`
+	RequestFullSync bool                 `json:"requestFullSync,omitempty"`
 	Gyms            []BackupGym          `json:"gyms"`
 	Problems        []BackupProblem      `json:"problems"`
 	Sessions        []BackupClimbSession `json:"sessions"`
@@ -282,6 +278,81 @@ func (s *SyncServer) mergeAttempts(existing []BackupAttempt, updates []BackupAtt
 	return result
 }
 
+func (s *SyncServer) cleanupTombstones(backup *ClimbDataBackup) {
+	cutoffTime := time.Now().UTC().Add(-90 * 24 * time.Hour)
+	log.Printf("Cleaning up tombstones older than %s", cutoffTime.Format(time.RFC3339))
+
+	// Gyms
+	activeGyms := make([]BackupGym, 0, len(backup.Gyms))
+	for _, item := range backup.Gyms {
+		if !item.IsDeleted {
+			activeGyms = append(activeGyms, item)
+			continue
+		}
+		updatedAt, err := time.Parse(time.RFC3339, item.UpdatedAt)
+		if err == nil && updatedAt.After(cutoffTime) {
+			activeGyms = append(activeGyms, item)
+		} else {
+			log.Printf("Pruning deleted gym: %s", item.ID)
+		}
+	}
+	backup.Gyms = activeGyms
+
+	// Problems
+	activeProblems := make([]BackupProblem, 0, len(backup.Problems))
+	for _, item := range backup.Problems {
+		if !item.IsDeleted {
+			activeProblems = append(activeProblems, item)
+			continue
+		}
+		updatedAt, err := time.Parse(time.RFC3339, item.UpdatedAt)
+		if err == nil && updatedAt.After(cutoffTime) {
+			activeProblems = append(activeProblems, item)
+		} else {
+			log.Printf("Pruning deleted problem: %s", item.ID)
+		}
+	}
+	backup.Problems = activeProblems
+
+	// Sessions
+	activeSessions := make([]BackupClimbSession, 0, len(backup.Sessions))
+	for _, item := range backup.Sessions {
+		if !item.IsDeleted {
+			activeSessions = append(activeSessions, item)
+			continue
+		}
+		updatedAt, err := time.Parse(time.RFC3339, item.UpdatedAt)
+		if err == nil && updatedAt.After(cutoffTime) {
+			activeSessions = append(activeSessions, item)
+		} else {
+			log.Printf("Pruning deleted session: %s", item.ID)
+		}
+	}
+	backup.Sessions = activeSessions
+
+	// Attempts
+	activeAttempts := make([]BackupAttempt, 0, len(backup.Attempts))
+	for _, item := range backup.Attempts {
+		if !item.IsDeleted {
+			activeAttempts = append(activeAttempts, item)
+			continue
+		}
+
+		timeStr := item.CreatedAt
+		if item.UpdatedAt != nil {
+			timeStr = *item.UpdatedAt
+		}
+
+		updatedAt, err := time.Parse(time.RFC3339, timeStr)
+		if err == nil && updatedAt.After(cutoffTime) {
+			activeAttempts = append(activeAttempts, item)
+		} else {
+			log.Printf("Pruning deleted attempt: %s", item.ID)
+		}
+	}
+	backup.Attempts = activeAttempts
+}
+
 func (s *SyncServer) saveData(backup *ClimbDataBackup) error {
 	backup.ExportedAt = time.Now().UTC().Format(time.RFC3339)
 
@@ -339,6 +410,8 @@ func (s *SyncServer) handlePut(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	s.cleanupTombstones(&backup)
+
 	if err := s.saveData(&backup); err != nil {
 		log.Printf("Failed to save data: %v", err)
 		http.Error(w, "Failed to save data", http.StatusInternalServerError)
@@ -476,14 +549,33 @@ func (s *SyncServer) handleDeltaSync(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	clientLastSyncCheck, err := time.Parse(time.RFC3339, deltaRequest.LastSyncTime)
+	isServerEmpty := len(serverBackup.Gyms) == 0 && len(serverBackup.Problems) == 0 &&
+		len(serverBackup.Sessions) == 0 && len(serverBackup.Attempts) == 0
+
+	if err == nil && !clientLastSyncCheck.IsZero() && isServerEmpty {
+		log.Printf("Server is empty but client has sync history. Requesting full sync.")
+		response := DeltaSyncResponse{
+			ServerTime:      time.Now().UTC().Format(time.RFC3339),
+			RequestFullSync: true,
+			Gyms:            []BackupGym{},
+			Problems:        []BackupProblem{},
+			Sessions:        []BackupClimbSession{},
+			Attempts:        []BackupAttempt{},
+		}
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(response)
+		return
+	}
+
 	// Merge client changes into server data
-	// Note: We no longer need separate deletion handling as IsDeleted is part of the struct
-	// and handled by standard merge logic (latest timestamp wins)
 	serverBackup.Gyms = s.mergeGyms(serverBackup.Gyms, deltaRequest.Gyms)
 	serverBackup.Problems = s.mergeProblems(serverBackup.Problems, deltaRequest.Problems)
 	serverBackup.Sessions = s.mergeSessions(serverBackup.Sessions, deltaRequest.Sessions)
 	serverBackup.Attempts = s.mergeAttempts(serverBackup.Attempts, deltaRequest.Attempts)
 
+	s.cleanupTombstones(serverBackup)
+
 	// Save merged data
 	if err := s.saveData(serverBackup); err != nil {
 		log.Printf("Failed to save data: %v", err)
@@ -565,7 +657,9 @@ func (s *SyncServer) handleSync(w http.ResponseWriter, r *http.Request) {
 }
 
 func main() {
+    godotenv.Load()
 	authToken := os.Getenv("AUTH_TOKEN")
+	print(authToken)
 	if authToken == "" {
 		log.Fatal("AUTH_TOKEN environment variable is required")
 	}

sync/sync_test.go

@@ -1,501 +0,0 @@
-package main
-
-import (
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-// TestDeltaSyncDeletedItemResurrection verifies deleted items don't resurrect
-func TestDeltaSyncDeletedItemResurrection(t *testing.T) {
-	tempDir := t.TempDir()
-	server := &SyncServer{
-		dataFile:  filepath.Join(tempDir, "test.json"),
-		imagesDir: filepath.Join(tempDir, "images"),
-		authToken: "test-token",
-	}
-
-	// Initial state: Server has one gym, one problem, one session with 8 attempts
-	now := time.Now().UTC()
-	gymID := "gym-1"
-	problemID := "problem-1"
-	sessionID := "session-1"
-
-	initialBackup := &ClimbDataBackup{
-		Version:       "2.0",
-		FormatVersion: "2.0",
-		Gyms: []BackupGym{
-			{
-				ID:                  gymID,
-				Name:                "Test Gym",
-				SupportedClimbTypes: []string{"BOULDER"},
-				DifficultySystems:   []string{"V"},
-				CreatedAt:           now.Add(-1 * time.Hour).Format(time.RFC3339),
-				UpdatedAt:           now.Add(-1 * time.Hour).Format(time.RFC3339),
-			},
-		},
-		Problems: []BackupProblem{
-			{
-				ID:        problemID,
-				GymID:     gymID,
-				ClimbType: "BOULDER",
-				Difficulty: DifficultyGrade{
-					System:       "V",
-					Grade:        "V5",
-					NumericValue: 5,
-				},
-				IsActive:  true,
-				CreatedAt: now.Add(-1 * time.Hour).Format(time.RFC3339),
-				UpdatedAt: now.Add(-1 * time.Hour).Format(time.RFC3339),
-			},
-		},
-		Sessions: []BackupClimbSession{
-			{
-				ID:        sessionID,
-				GymID:     gymID,
-				Date:      now.Format("2006-01-02"),
-				Status:    "completed",
-				CreatedAt: now.Add(-30 * time.Minute).Format(time.RFC3339),
-				UpdatedAt: now.Add(-30 * time.Minute).Format(time.RFC3339),
-			},
-		},
-		Attempts:     []BackupAttempt{},
-		DeletedItems: []DeletedItem{},
-	}
-
-	// Add 8 attempts
-	for i := 0; i < 8; i++ {
-		attempt := BackupAttempt{
-			ID:        "attempt-" + string(rune('1'+i)),
-			SessionID: sessionID,
-			ProblemID: problemID,
-			Result:    "COMPLETED",
-			Timestamp: now.Add(time.Duration(-25+i) * time.Minute).Format(time.RFC3339),
-			CreatedAt: now.Add(time.Duration(-25+i) * time.Minute).Format(time.RFC3339),
-		}
-		initialBackup.Attempts = append(initialBackup.Attempts, attempt)
-	}
-
-	if err := server.saveData(initialBackup); err != nil {
-		t.Fatalf("Failed to save initial data: %v", err)
-	}
-
-	// Client 1 syncs - gets all data
-	client1LastSync := now.Add(-2 * time.Hour).Format(time.RFC3339)
-	deltaRequest1 := DeltaSyncRequest{
-		LastSyncTime: client1LastSync,
-		Gyms:         []BackupGym{},
-		Problems:     []BackupProblem{},
-		Sessions:     []BackupClimbSession{},
-		Attempts:     []BackupAttempt{},
-		DeletedItems: []DeletedItem{},
-	}
-
-	// Simulate delta sync for client 1
-	serverBackup, _ := server.loadData()
-	serverBackup.DeletedItems = server.mergeDeletedItems(serverBackup.DeletedItems, deltaRequest1.DeletedItems)
-	server.applyDeletions(serverBackup, serverBackup.DeletedItems)
-
-	if len(serverBackup.Sessions) != 1 {
-		t.Errorf("Expected 1 session after client1 sync, got %d", len(serverBackup.Sessions))
-	}
-	if len(serverBackup.Attempts) != 8 {
-		t.Errorf("Expected 8 attempts after client1 sync, got %d", len(serverBackup.Attempts))
-	}
-
-	// Client 1 deletes the session locally
-	deleteTime := now.Format(time.RFC3339)
-	deletions := []DeletedItem{
-		{ID: sessionID, Type: "session", DeletedAt: deleteTime},
-	}
-	// Also track attempt deletions
-	for _, attempt := range initialBackup.Attempts {
-		deletions = append(deletions, DeletedItem{
-			ID:        attempt.ID,
-			Type:      "attempt",
-			DeletedAt: deleteTime,
-		})
-	}
-
-	// Client 1 syncs deletion
-	deltaRequest2 := DeltaSyncRequest{
-		LastSyncTime: now.Add(-5 * time.Minute).Format(time.RFC3339),
-		Gyms:         []BackupGym{},
-		Problems:     []BackupProblem{},
-		Sessions:     []BackupClimbSession{},
-		Attempts:     []BackupAttempt{},
-		DeletedItems: deletions,
-	}
-
-	// Server processes deletion
-	serverBackup, _ = server.loadData()
-	serverBackup.DeletedItems = server.mergeDeletedItems(serverBackup.DeletedItems, deltaRequest2.DeletedItems)
-	server.applyDeletions(serverBackup, serverBackup.DeletedItems)
-	server.saveData(serverBackup)
-
-	// Verify deletions were applied on server
-	serverBackup, _ = server.loadData()
-	if len(serverBackup.Sessions) != 0 {
-		t.Errorf("Expected 0 sessions after deletion, got %d", len(serverBackup.Sessions))
-	}
-	if len(serverBackup.Attempts) != 0 {
-		t.Errorf("Expected 0 attempts after deletion, got %d", len(serverBackup.Attempts))
-	}
-	if len(serverBackup.DeletedItems) != 9 {
-		t.Errorf("Expected 9 deletion records, got %d", len(serverBackup.DeletedItems))
-	}
-
-	// Client does local reset and pulls from server
-	deltaRequest3 := DeltaSyncRequest{
-		LastSyncTime: time.Time{}.Format(time.RFC3339),
-		Gyms:         []BackupGym{},
-		Problems:     []BackupProblem{},
-		Sessions:     []BackupClimbSession{},
-		Attempts:     []BackupAttempt{},
-		DeletedItems: []DeletedItem{},
-	}
-
-	serverBackup, _ = server.loadData()
-	clientLastSync, _ := time.Parse(time.RFC3339, deltaRequest3.LastSyncTime)
-
-	// Build response
-	response := DeltaSyncResponse{
-		ServerTime:   time.Now().UTC().Format(time.RFC3339),
-		Gyms:         []BackupGym{},
-		Problems:     []BackupProblem{},
-		Sessions:     []BackupClimbSession{},
-		Attempts:     []BackupAttempt{},
-		DeletedItems: []DeletedItem{},
-	}
-
-	// Build deleted item map
-	deletedItemMap := make(map[string]bool)
-	for _, item := range serverBackup.DeletedItems {
-		key := item.Type + ":" + item.ID
-		deletedItemMap[key] = true
-	}
-
-	// Filter sessions (excluding deleted)
-	for _, session := range serverBackup.Sessions {
-		if deletedItemMap["session:"+session.ID] {
-			continue
-		}
-		sessionTime, _ := time.Parse(time.RFC3339, session.UpdatedAt)
-		if sessionTime.After(clientLastSync) {
-			response.Sessions = append(response.Sessions, session)
-		}
-	}
-
-	// Filter attempts (excluding deleted)
-	for _, attempt := range serverBackup.Attempts {
-		if deletedItemMap["attempt:"+attempt.ID] {
-			continue
-		}
-		attemptTime, _ := time.Parse(time.RFC3339, attempt.CreatedAt)
-		if attemptTime.After(clientLastSync) {
-			response.Attempts = append(response.Attempts, attempt)
-		}
-	}
-
-	// Send deletion records
-	for _, deletion := range serverBackup.DeletedItems {
-		deletionTime, _ := time.Parse(time.RFC3339, deletion.DeletedAt)
-		if deletionTime.After(clientLastSync) {
-			response.DeletedItems = append(response.DeletedItems, deletion)
-		}
-	}
-
-	if len(response.Sessions) != 0 {
-		t.Errorf("Deleted session was resurrected! Got %d sessions in response", len(response.Sessions))
-	}
-	if len(response.Attempts) != 0 {
-		t.Errorf("Deleted attempts were resurrected! Got %d attempts in response", len(response.Attempts))
-	}
-	if len(response.DeletedItems) < 9 {
-		t.Errorf("Expected at least 9 deletion records in response, got %d", len(response.DeletedItems))
-	}
-}
-
-// TestDeltaSyncAttemptCount verifies all attempts are preserved
-func TestDeltaSyncAttemptCount(t *testing.T) {
-	tempDir := t.TempDir()
-	server := &SyncServer{
-		dataFile:  filepath.Join(tempDir, "test.json"),
-		imagesDir: filepath.Join(tempDir, "images"),
-		authToken: "test-token",
-	}
-
-	now := time.Now().UTC()
-	gymID := "gym-1"
-	problemID := "problem-1"
-	sessionID := "session-1"
-
-	// Create session with 8 attempts
-	initialBackup := &ClimbDataBackup{
-		Version:       "2.0",
-		FormatVersion: "2.0",
-		Gyms:          []BackupGym{{ID: gymID, Name: "Test Gym", SupportedClimbTypes: []string{"BOULDER"}, DifficultySystems: []string{"V"}, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Problems:      []BackupProblem{{ID: problemID, GymID: gymID, ClimbType: "BOULDER", Difficulty: DifficultyGrade{System: "V", Grade: "V5", NumericValue: 5}, IsActive: true, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Sessions:      []BackupClimbSession{{ID: sessionID, GymID: gymID, Date: now.Format("2006-01-02"), Status: "completed", CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Attempts:      []BackupAttempt{},
-		DeletedItems:  []DeletedItem{},
-	}
-
-	// Add 8 attempts at different times
-	baseTime := now.Add(-30 * time.Minute)
-	for i := 0; i < 8; i++ {
-		attempt := BackupAttempt{
-			ID:        "attempt-" + string(rune('1'+i)),
-			SessionID: sessionID,
-			ProblemID: problemID,
-			Result:    "COMPLETED",
-			Timestamp: baseTime.Add(time.Duration(i) * time.Minute).Format(time.RFC3339),
-			CreatedAt: baseTime.Add(time.Duration(i) * time.Minute).Format(time.RFC3339),
-		}
-		initialBackup.Attempts = append(initialBackup.Attempts, attempt)
-	}
-
-	if err := server.saveData(initialBackup); err != nil {
-		t.Fatalf("Failed to save initial data: %v", err)
-	}
-
-	// Client syncs with lastSyncTime BEFORE all attempts were created
-	clientLastSync := baseTime.Add(-1 * time.Hour)
-
-	serverBackup, _ := server.loadData()
-
-	// Count attempts that should be returned
-	attemptCount := 0
-	for _, attempt := range serverBackup.Attempts {
-		attemptTime, _ := time.Parse(time.RFC3339, attempt.CreatedAt)
-		if attemptTime.After(clientLastSync) {
-			attemptCount++
-		}
-	}
-
-	if attemptCount != 8 {
-		t.Errorf("Expected all 8 attempts to be returned, got %d", attemptCount)
-	}
-
-}
-
-// TestTombstoneCleanup verifies old deletion records are cleaned up
-func TestTombstoneCleanup(t *testing.T) {
-	server := &SyncServer{}
-
-	now := time.Now().UTC()
-	oldDeletion := DeletedItem{
-		ID:        "old-item",
-		Type:      "session",
-		DeletedAt: now.Add(-31 * 24 * time.Hour).Format(time.RFC3339), // 31 days old
-	}
-	recentDeletion := DeletedItem{
-		ID:        "recent-item",
-		Type:      "session",
-		DeletedAt: now.Add(-1 * 24 * time.Hour).Format(time.RFC3339), // 1 day old
-	}
-
-	existing := []DeletedItem{oldDeletion}
-	updates := []DeletedItem{recentDeletion}
-
-	merged := server.mergeDeletedItems(existing, updates)
-
-	// Old deletion should be cleaned up, only recent one remains
-	if len(merged) != 1 {
-		t.Errorf("Expected 1 deletion record after cleanup, got %d", len(merged))
-	}
-	if len(merged) > 0 && merged[0].ID != "recent-item" {
-		t.Errorf("Expected recent deletion to remain, got %s", merged[0].ID)
-	}
-
-}
-
-// TestMergeDeletedItemsDeduplication verifies duplicate deletions are handled
-func TestMergeDeletedItemsDeduplication(t *testing.T) {
-	server := &SyncServer{}
-
-	now := time.Now().UTC()
-	deletion1 := DeletedItem{
-		ID:        "item-1",
-		Type:      "session",
-		DeletedAt: now.Add(-1 * time.Hour).Format(time.RFC3339),
-	}
-	deletion2 := DeletedItem{
-		ID:        "item-1",
-		Type:      "session",
-		DeletedAt: now.Format(time.RFC3339), // Newer timestamp
-	}
-
-	existing := []DeletedItem{deletion1}
-	updates := []DeletedItem{deletion2}
-
-	merged := server.mergeDeletedItems(existing, updates)
-
-	if len(merged) != 1 {
-		t.Errorf("Expected 1 deletion record, got %d", len(merged))
-	}
-	if len(merged) > 0 && merged[0].DeletedAt != deletion2.DeletedAt {
-		t.Errorf("Expected newer deletion timestamp to be kept")
-	}
-
-}
-
-// TestApplyDeletions verifies deletions are applied correctly
-func TestApplyDeletions(t *testing.T) {
-	server := &SyncServer{}
-
-	now := time.Now().UTC()
-	backup := &ClimbDataBackup{
-		Version:       "2.0",
-		FormatVersion: "2.0",
-		Gyms:          []BackupGym{{ID: "gym-1", Name: "Test Gym", SupportedClimbTypes: []string{}, DifficultySystems: []string{}, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Problems:      []BackupProblem{{ID: "problem-1", GymID: "gym-1", ClimbType: "BOULDER", Difficulty: DifficultyGrade{System: "V", Grade: "V5", NumericValue: 5}, IsActive: true, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Sessions:      []BackupClimbSession{{ID: "session-1", GymID: "gym-1", Date: now.Format("2006-01-02"), Status: "completed", CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Attempts:      []BackupAttempt{{ID: "attempt-1", SessionID: "session-1", ProblemID: "problem-1", Result: "COMPLETED", Timestamp: now.Format(time.RFC3339), CreatedAt: now.Format(time.RFC3339)}},
-		DeletedItems:  []DeletedItem{},
-	}
-
-	deletions := []DeletedItem{
-		{ID: "session-1", Type: "session", DeletedAt: now.Format(time.RFC3339)},
-		{ID: "attempt-1", Type: "attempt", DeletedAt: now.Format(time.RFC3339)},
-	}
-
-	server.applyDeletions(backup, deletions)
-
-	if len(backup.Sessions) != 0 {
-		t.Errorf("Expected 0 sessions after deletion, got %d", len(backup.Sessions))
-	}
-	if len(backup.Attempts) != 0 {
-		t.Errorf("Expected 0 attempts after deletion, got %d", len(backup.Attempts))
-	}
-	if len(backup.Gyms) != 1 {
-		t.Errorf("Expected gym to remain, got %d gyms", len(backup.Gyms))
-	}
-	if len(backup.Problems) != 1 {
-		t.Errorf("Expected problem to remain, got %d problems", len(backup.Problems))
-	}
-
-}
-
-// TestCascadingDeletions verifies related items are handled properly
-func TestCascadingDeletions(t *testing.T) {
-	server := &SyncServer{}
-
-	now := time.Now().UTC()
-	sessionID := "session-1"
-	backup := &ClimbDataBackup{
-		Version:       "2.0",
-		FormatVersion: "2.0",
-		Gyms:          []BackupGym{{ID: "gym-1", Name: "Test Gym", SupportedClimbTypes: []string{}, DifficultySystems: []string{}, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Problems:      []BackupProblem{{ID: "problem-1", GymID: "gym-1", ClimbType: "BOULDER", Difficulty: DifficultyGrade{System: "V", Grade: "V5", NumericValue: 5}, IsActive: true, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Sessions:      []BackupClimbSession{{ID: sessionID, GymID: "gym-1", Date: now.Format("2006-01-02"), Status: "completed", CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Attempts:      []BackupAttempt{},
-		DeletedItems:  []DeletedItem{},
-	}
-
-	// Add multiple attempts for the session
-	for i := 0; i < 5; i++ {
-		backup.Attempts = append(backup.Attempts, BackupAttempt{
-			ID:        "attempt-" + string(rune('1'+i)),
-			SessionID: sessionID,
-			ProblemID: "problem-1",
-			Result:    "COMPLETED",
-			Timestamp: now.Format(time.RFC3339),
-			CreatedAt: now.Format(time.RFC3339),
-		})
-	}
-
-	// Delete session - attempts should also be tracked as deleted
-	deletions := []DeletedItem{
-		{ID: sessionID, Type: "session", DeletedAt: now.Format(time.RFC3339)},
-	}
-	for _, attempt := range backup.Attempts {
-		deletions = append(deletions, DeletedItem{
-			ID:        attempt.ID,
-			Type:      "attempt",
-			DeletedAt: now.Format(time.RFC3339),
-		})
-	}
-
-	server.applyDeletions(backup, deletions)
-
-	if len(backup.Sessions) != 0 {
-		t.Errorf("Expected session to be deleted, got %d sessions", len(backup.Sessions))
-	}
-	if len(backup.Attempts) != 0 {
-		t.Errorf("Expected all attempts to be deleted, got %d attempts", len(backup.Attempts))
-	}
-
-}
-
-// TestFullSyncAfterReset verifies the reported user scenario
-func TestFullSyncAfterReset(t *testing.T) {
-	tempDir := t.TempDir()
-	server := &SyncServer{
-		dataFile:  filepath.Join(tempDir, "test.json"),
-		imagesDir: filepath.Join(tempDir, "images"),
-		authToken: "test-token",
-	}
-
-	now := time.Now().UTC()
-
-	// Initial sync with data
-	initialData := &ClimbDataBackup{
-		Version:       "2.0",
-		FormatVersion: "2.0",
-		Gyms:          []BackupGym{{ID: "gym-1", Name: "Test Gym", SupportedClimbTypes: []string{"BOULDER"}, DifficultySystems: []string{"V"}, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Problems:      []BackupProblem{{ID: "problem-1", GymID: "gym-1", ClimbType: "BOULDER", Difficulty: DifficultyGrade{System: "V", Grade: "V5", NumericValue: 5}, IsActive: true, CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Sessions:      []BackupClimbSession{{ID: "session-1", GymID: "gym-1", Date: now.Format("2006-01-02"), Status: "completed", CreatedAt: now.Format(time.RFC3339), UpdatedAt: now.Format(time.RFC3339)}},
-		Attempts:      []BackupAttempt{},
-		DeletedItems:  []DeletedItem{},
-	}
-	for i := 0; i < 8; i++ {
-		initialData.Attempts = append(initialData.Attempts, BackupAttempt{
-			ID:        "attempt-" + string(rune('1'+i)),
-			SessionID: "session-1",
-			ProblemID: "problem-1",
-			Result:    "COMPLETED",
-			Timestamp: now.Add(time.Duration(i) * time.Minute).Format(time.RFC3339),
-			CreatedAt: now.Add(time.Duration(i) * time.Minute).Format(time.RFC3339),
-		})
-	}
-	server.saveData(initialData)
-
-	// Client deletes everything and syncs
-	deletions := []DeletedItem{
-		{ID: "gym-1", Type: "gym", DeletedAt: now.Add(10 * time.Minute).Format(time.RFC3339)},
-		{ID: "problem-1", Type: "problem", DeletedAt: now.Add(10 * time.Minute).Format(time.RFC3339)},
-		{ID: "session-1", Type: "session", DeletedAt: now.Add(10 * time.Minute).Format(time.RFC3339)},
-	}
-	for i := 0; i < 8; i++ {
-		deletions = append(deletions, DeletedItem{
-			ID:        "attempt-" + string(rune('1'+i)),
-			Type:      "attempt",
-			DeletedAt: now.Add(10 * time.Minute).Format(time.RFC3339),
-		})
-	}
-
-	serverBackup, _ := server.loadData()
-	serverBackup.DeletedItems = server.mergeDeletedItems(serverBackup.DeletedItems, deletions)
-	server.applyDeletions(serverBackup, serverBackup.DeletedItems)
-	server.saveData(serverBackup)
-
-	// Client does local reset and pulls from server
-	serverBackup, _ = server.loadData()
-
-	if len(serverBackup.Gyms) != 0 {
-		t.Errorf("Expected 0 gyms, got %d", len(serverBackup.Gyms))
-	}
-	if len(serverBackup.Problems) != 0 {
-		t.Errorf("Expected 0 problems, got %d", len(serverBackup.Problems))
-	}
-	if len(serverBackup.Sessions) != 0 {
-		t.Errorf("Expected 0 sessions, got %d", len(serverBackup.Sessions))
-	}
-	if len(serverBackup.Attempts) != 0 {
-		t.Errorf("Expected 0 attempts, got %d", len(serverBackup.Attempts))
-	}
-	if len(serverBackup.DeletedItems) == 0 {
-		t.Errorf("Expected deletion records, got 0")
-	}
-}