fix: remote deletions not mirrored when file has no state record

When a file was uploaded before state-tracking worked (getFileMetadata was
broken), its SyncFileStateEntity was never saved. On next sync the engine
saw !local + remote + known=null and downloaded it back instead of deleting
it remotely, creating an infinite re-download loop.

Fix: syncDecide() now accepts hasPriorSyncState (derived from whether the
pair has any known states at all). On initial sync (no prior state) unknown
remote files are downloaded as before. Once the pair has been synced, unknown
remote-only files are treated as mirror-eligible deletions — same as if known
state existed — so locally-deleted files propagate to the remote correctly.

Verified live: 3 remote-only orphan files deleted from Nextcloud on sync.
Bump version to 1.0.12 (code 13).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/src/main/kotlin/com/syncflow/MainActivity.kt

@@ -7,6 +7,7 @@ import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_STRONG
+import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_WEAK
 import androidx.biometric.BiometricManager.Authenticators.DEVICE_CREDENTIAL
 import androidx.biometric.BiometricPrompt
 import androidx.compose.foundation.background
@@ -16,6 +17,7 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material3.Button
@@ -45,6 +47,7 @@ class MainActivity : AppCompatActivity() {
     @Inject lateinit var appPreferences: AppPreferences
 
     private var isLocked by mutableStateOf(false)
+    private var showRetry by mutableStateOf(false)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         installSplashScreen()
@@ -56,81 +59,81 @@ class MainActivity : AppCompatActivity() {
                     SyncFlowNavGraph(rememberNavController())
                 }
                 if (isLocked) {
-                    var showRetry by remember { mutableStateOf(false) }
                     LockOverlay(
                         showRetry = showRetry,
-                        onRetry = {
-                            showRetry = false
-                            showBiometricPrompt(
-                                onSuccess = { isLocked = false },
-                                onFailed = { showRetry = true },
-                            )
-                        },
+                        onRetry = { triggerBiometric() },
                     )
-                    LaunchedEffect(Unit) {
-                        showBiometricPrompt(
-                            onSuccess = { isLocked = false },
-                            onFailed = { showRetry = true },
-                        )
-                    }
                 }
             }
         }
     }
 
+    override fun onResume() {
+        super.onResume()
+        if (isLocked) triggerBiometric()
+    }
+
     override fun onStop() {
         super.onStop()
         if (isChangingConfigurations) return
         lifecycleScope.launch {
             if (appPreferences.biometricLockEnabled.first() && canAuthenticate()) {
                 isLocked = true
+                showRetry = false
             }
         }
     }
 
-    private fun canAuthenticate(): Boolean {
-        val authenticators = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
-            BIOMETRIC_STRONG or DEVICE_CREDENTIAL
-        else
-            BIOMETRIC_STRONG
-        return BiometricManager.from(this).canAuthenticate(authenticators) ==
-            BiometricManager.BIOMETRIC_SUCCESS
-    }
-
-    private fun showBiometricPrompt(onSuccess: () -> Unit, onFailed: () -> Unit) {
+    private fun triggerBiometric() {
+        showRetry = false
+        val authenticators = bestAuthenticators()
         val executor = ContextCompat.getMainExecutor(this)
         val prompt = BiometricPrompt(this, executor, object : BiometricPrompt.AuthenticationCallback() {
             override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
-                onSuccess()
+                isLocked = false
+                showRetry = false
             }
             override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
-                // User cancelled or lockout — re-show the prompt so they can retry
-                if (errorCode != BiometricPrompt.ERROR_USER_CANCELED &&
-                    errorCode != BiometricPrompt.ERROR_NEGATIVE_BUTTON) {
-                    showBiometricPrompt(onSuccess, onFailed)
-                } else {
-                    onFailed()
-                }
+                // Show the Unlock button so the user can tap to retry manually
+                showRetry = true
             }
             override fun onAuthenticationFailed() {
-                // Wrong finger/face — BiometricPrompt handles retries internally, no action needed
+                // Wrong biometric — BiometricPrompt retries automatically
             }
         })
         val promptInfo = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
             BiometricPrompt.PromptInfo.Builder()
                 .setTitle("Unlock SyncFlow")
-                .setSubtitle("Use fingerprint or device PIN")
-                .setAllowedAuthenticators(BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
+                .setSubtitle("Use fingerprint or PIN")
+                .setAllowedAuthenticators(authenticators)
                 .build()
         } else {
             BiometricPrompt.PromptInfo.Builder()
                 .setTitle("Unlock SyncFlow")
-                .setSubtitle("Use fingerprint to continue")
-                .setNegativeButtonText("Use PIN")
+                .setSubtitle("Use fingerprint")
+                .setNegativeButtonText("Cancel")
                 .build()
         }
         prompt.authenticate(promptInfo)
     }
+
+    private fun bestAuthenticators(): Int {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return BIOMETRIC_STRONG
+        val bm = BiometricManager.from(this)
+        // Prefer strong+credential; fall back to weak+credential so side-sensor phones work
+        return if (bm.canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL) == BiometricManager.BIOMETRIC_SUCCESS)
+            BIOMETRIC_STRONG or DEVICE_CREDENTIAL
+        else
+            BIOMETRIC_WEAK or DEVICE_CREDENTIAL
+    }
+
+    private fun canAuthenticate(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R)
+            return BiometricManager.from(this).canAuthenticate(BIOMETRIC_STRONG) == BiometricManager.BIOMETRIC_SUCCESS
+        val bm = BiometricManager.from(this)
+        return bm.canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL) == BiometricManager.BIOMETRIC_SUCCESS ||
+            bm.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL) == BiometricManager.BIOMETRIC_SUCCESS
+    }
 }
 
 @Composable
@@ -143,18 +146,18 @@ private fun LockOverlay(showRetry: Boolean, onRetry: () -> Unit) {
     ) {
         Column(
             horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center,
+            verticalArrangement = Arrangement.spacedBy(12.dp),
         ) {
-            Icon(Icons.Default.Lock, null, modifier = Modifier.height(48.dp), tint = MaterialTheme.colorScheme.primary)
-            Spacer(Modifier.height(16.dp))
+            Icon(Icons.Default.Lock, null, modifier = Modifier.size(56.dp), tint = MaterialTheme.colorScheme.primary)
             Text("SyncFlow is locked", style = MaterialTheme.typography.titleMedium)
-            Spacer(Modifier.height(8.dp))
             if (showRetry) {
-                Spacer(Modifier.height(8.dp))
                 Button(onClick = onRetry) { Text("Unlock") }
             } else {
-                Text("Use fingerprint or PIN to unlock", style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant)
+                Text(
+                    "Use fingerprint or PIN to unlock",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
             }
         }
     }

app/src/main/kotlin/com/syncflow/data/db/DbConverters.kt

@@ -4,6 +4,6 @@ import androidx.room.TypeConverter
 import java.time.Instant
 
 class DbConverters {
-    @TypeConverter fun fromInstant(v: Instant?): Long? = v?.epochSecond
-    @TypeConverter fun toInstant(v: Long?): Instant? = v?.let { Instant.ofEpochSecond(it) }
+    @TypeConverter fun fromInstant(v: Instant?): Long? = v?.toEpochMilli()
+    @TypeConverter fun toInstant(v: Long?): Instant? = v?.let { Instant.ofEpochMilli(it) }
 }

app/src/main/kotlin/com/syncflow/data/db/SyncDatabase.kt

@@ -3,6 +3,8 @@ package com.syncflow.data.db
 import androidx.room.Database
 import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
 import com.syncflow.data.db.entities.*
 
 @Database(
@@ -13,11 +15,21 @@ import com.syncflow.data.db.entities.*
         SyncConflictEntity::class,
         SyncEventEntity::class,
     ],
-    version = 2,
+    version = 3,
     exportSchema = true,
 )
 @TypeConverters(DbConverters::class)
 abstract class SyncDatabase : RoomDatabase() {
+
+    companion object {
+        // Wipe file states: timestamps were stored as epoch-seconds, now epoch-millis.
+        // All previously saved states are wrong so we drop and re-learn on next sync.
+        val MIGRATION_2_3 = object : Migration(2, 3) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL("DELETE FROM sync_file_states")
+            }
+        }
+    }
     abstract fun cloudAccountDao(): CloudAccountDao
     abstract fun syncPairDao(): SyncPairDao
     abstract fun syncFileStateDao(): SyncFileStateDao

app/src/main/kotlin/com/syncflow/data/providers/webdav/WebDavProvider.kt

@@ -132,7 +132,10 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
             val req = Request.Builder().url(url(remotePath)).method("PROPFIND", PROPFIND_BODY).header("Depth", "0").build()
             client.newCall(req).execute().use { resp ->
                 if (resp.code != 207) throw Exception("HTTP ${resp.code}")
-                parsePropfind(resp.body?.string() ?: "", remotePath.substringBeforeLast('/'))
+                // Depth:0 returns exactly the requested resource as the single response entry.
+                // parsePropfind normally drops the first entry (the parent dir) for Depth:1
+                // directory listings, so pass dropFirst=false here.
+                parsePropfind(resp.body?.string() ?: "", remotePath.substringBeforeLast('/'), dropFirst = false)
                     .firstOrNull() ?: throw Exception("File not found")
             }
         }
@@ -153,7 +156,7 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
 
     protected fun url(path: String) = "$baseUrl/${path.trimStart('/')}"
 
-    private fun parsePropfind(xml: String, parentPath: String): List<RemoteFile> {
+    private fun parsePropfind(xml: String, parentPath: String, dropFirst: Boolean = true): List<RemoteFile> {
         val results = mutableListOf<RemoteFile>()
         try {
             val factory = XmlPullParserFactory.newInstance()
@@ -192,7 +195,7 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
                 eventType = parser.next()
             }
         } catch (_: Exception) {}
-        return results.drop(1) // drop the parent folder itself
+        return if (dropFirst) results.drop(1) else results
     }
 
     private fun parseHttpDate(value: String): Instant = try {

app/src/main/kotlin/com/syncflow/di/AppModule.kt

@@ -21,9 +21,8 @@ object AppModule {
     @Provides @Singleton
     fun provideDatabase(@ApplicationContext ctx: Context): SyncDatabase =
         Room.databaseBuilder(ctx, SyncDatabase::class.java, "syncflow.db")
-            // Only fall back to destructive migration for very old dev builds (v1).
-            // All future version bumps must include a proper Migration object.
             .fallbackToDestructiveMigrationFrom(1)
+            .addMigrations(SyncDatabase.MIGRATION_2_3)
             .build()
 
     @Provides fun provideCloudAccountDao(db: SyncDatabase): CloudAccountDao = db.cloudAccountDao()

app/src/main/kotlin/com/syncflow/domain/sync/LocalAccessor.kt

@@ -63,7 +63,13 @@ sealed class LocalAccessor {
 
     class Saf(private val treeUri: Uri, private val resolver: ContentResolver) : LocalAccessor() {
 
+        // Populated by walkFiles so openInputStream can skip the re-query for files that
+        // already exist locally (uploads). Root-level files are the common failure case
+        // when findDocUri re-queries: the cache sidesteps the issue entirely.
+        private val docIdCache = mutableMapOf<String, String>()
+
         override fun walkFiles(pair: SyncPair): Map<String, LocalFileInfo> {
+            docIdCache.clear()
             val rootDocId = DocumentsContract.getTreeDocumentId(treeUri)
             val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, rootDocId)
             return cursorWalk(childrenUri, "", pair)
@@ -110,6 +116,7 @@ sealed class LocalAccessor {
                         if (ext in excludeExts) continue
                         if (size !in minBytes..maxBytes) continue
                         result[rel] = LocalFileInfo(rel, size, modified)
+                        docIdCache[rel] = docId
                     }
                 }
             }
@@ -117,7 +124,10 @@ sealed class LocalAccessor {
         }
 
         override fun openInputStream(relativePath: String): InputStream? {
-            val docUri = findDocUri(relativePath) ?: return null
+            val docUri = docIdCache[relativePath]
+                ?.let { DocumentsContract.buildDocumentUriUsingTree(treeUri, it) }
+                ?: findDocUri(relativePath)
+                ?: return null
             return resolver.openInputStream(docUri)
         }
 
@@ -155,8 +165,15 @@ sealed class LocalAccessor {
         }
 
         override fun delete(relativePath: String): Boolean {
-            val docUri = findDocUri(relativePath) ?: return false
-            return DocumentsContract.deleteDocument(resolver, docUri)
+            val docUri = docIdCache[relativePath]
+                ?.let { DocumentsContract.buildDocumentUriUsingTree(treeUri, it) }
+                ?: findDocUri(relativePath)
+                ?: return false
+            return try {
+                DocumentsContract.deleteDocument(resolver, docUri)
+            } catch (e: Exception) {
+                false
+            }
         }
 
         override fun lastModifiedMs(relativePath: String): Long {

app/src/main/kotlin/com/syncflow/domain/sync/SyncEngine.kt

@@ -8,6 +8,7 @@ import com.syncflow.data.db.SyncFileStateDao
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.data.db.entities.SyncConflictEntity
 import com.syncflow.data.db.entities.SyncEventEntity
+import com.syncflow.data.db.entities.SyncFileStateEntity
 import com.syncflow.data.providers.CloudProvider
 import com.syncflow.domain.model.ConflictStrategy
 import com.syncflow.domain.model.DeleteBehavior
@@ -69,6 +70,7 @@ class SyncEngine @Inject constructor(
         val localFiles = accessor.walkFiles(pair)
 
         val allPaths = (localFiles.keys + remoteFiles.keys + knownStates.keys).toSet()
+        val hasPriorSyncState = knownStates.isNotEmpty()
         val semaphore = Semaphore(4)
 
         // Each async block returns its outcome; no shared mutable state across coroutines.
@@ -76,7 +78,7 @@ class SyncEngine @Inject constructor(
             val uploaded: Int = 0, val downloaded: Int = 0, val deleted: Int = 0,
             val skipped: Int = 0, val failed: Int = 0, val conflicts: Int = 0,
             val bytesTransferred: Long = 0L,
-            val newState: com.syncflow.data.db.entities.SyncFileStateEntity? = null,
+            val newState: SyncFileStateEntity? = null,
         )
 
         val outcomes: List<FileOutcome> = coroutineScope {
@@ -86,13 +88,15 @@ class SyncEngine @Inject constructor(
                         val local = localFiles[rel]
                         val remote = remoteFiles[rel]
                         val known = knownStates[rel]
-                        val decision = decide(pair.syncDirection, pair.conflictStrategy, pair.deleteBehavior, local, remote, known)
+                        val decision = syncDecide(pair.syncDirection, pair.conflictStrategy, pair.deleteBehavior, local, remote, known, hasPriorSyncState)
 
                         when (decision) {
                             SyncDecision.UPLOAD -> {
+                                var uploadedRemoteFile: RemoteFile? = null
                                 val bytes = runCatching {
+                                    ensureRemoteDirs(provider, pair.remotePath, rel)
                                     accessor.openInputStream(rel)?.use { stream ->
-                                        provider.uploadFile(stream, "${pair.remotePath}/$rel", local!!.sizeBytes) { }
+                                        uploadedRemoteFile = provider.uploadFile(stream, "${pair.remotePath}/$rel", local!!.sizeBytes) { }.getOrThrow()
                                     }
                                     local!!.sizeBytes
                                 }.getOrElse { e ->
@@ -101,7 +105,8 @@ class SyncEngine @Inject constructor(
                                     return@withPermit FileOutcome(failed = 1)
                                 }
                                 logEvent(pair.id, SyncEventType.FILE_UPLOADED, rel, null, bytes)
-                                FileOutcome(uploaded = 1, bytesTransferred = bytes, newState = buildState(pair.id, rel, local!!, remote))
+                                FileOutcome(uploaded = 1, bytesTransferred = bytes,
+                                    newState = buildState(pair.id, rel, local!!, remoteAfterTransfer = uploadedRemoteFile))
                             }
                             SyncDecision.DOWNLOAD -> {
                                 val bytes = runCatching {
@@ -114,8 +119,14 @@ class SyncEngine @Inject constructor(
                                     logEvent(pair.id, SyncEventType.FILE_SKIPPED, rel, e.message, 0)
                                     return@withPermit FileOutcome(failed = 1)
                                 }
+                                // Read the actual local mtime written by the OS/SAF after download.
+                                val localMtime = runCatching { accessor.lastModifiedMs(rel) }
+                                    .getOrDefault(System.currentTimeMillis()).takeIf { it > 0L }
+                                    ?: System.currentTimeMillis()
                                 logEvent(pair.id, SyncEventType.FILE_DOWNLOADED, rel, null, bytes)
-                                FileOutcome(downloaded = 1, bytesTransferred = bytes, newState = buildState(pair.id, rel, null, remote))
+                                FileOutcome(downloaded = 1, bytesTransferred = bytes,
+                                    newState = buildState(pair.id, rel,
+                                        LocalFileInfo(rel, remote!!.sizeBytes, localMtime), remoteAfterTransfer = remote))
                             }
                             SyncDecision.DELETE_LOCAL -> {
                                 accessor.delete(rel)
@@ -143,7 +154,21 @@ class SyncEngine @Inject constructor(
                                 logEvent(pair.id, SyncEventType.CONFLICT_DETECTED, rel, null, 0)
                                 FileOutcome(conflicts = 1)
                             }
-                            SyncDecision.SKIP -> FileOutcome(skipped = 1)
+                            SyncDecision.SKIP -> {
+                                // Save state whenever both sides are present and state is absent or
+                                // incomplete (post-upload null metadata). Without a baseline record,
+                                // a subsequent local deletion would look like an unseen remote file
+                                // and be re-downloaded instead of triggering DELETE_REMOTE.
+                                val saveState = local != null && remote != null && (
+                                    known == null ||
+                                    known.remoteModifiedAt == null || known.localModifiedAt == null
+                                )
+                                if (saveState) {
+                                    FileOutcome(skipped = 1, newState = buildState(pair.id, rel, local, remoteAfterTransfer = remote))
+                                } else {
+                                    FileOutcome(skipped = 1)
+                                }
+                            }
                         }
                     }
                 }
@@ -162,69 +187,14 @@ class SyncEngine @Inject constructor(
         )
     }
 
-    private fun decide(
-        direction: SyncDirection,
-        conflictStrategy: ConflictStrategy,
-        deleteBehavior: DeleteBehavior,
-        local: LocalFileInfo?,
-        remote: RemoteFile?,
-        known: com.syncflow.data.db.entities.SyncFileStateEntity?,
-    ): SyncDecision {
-        val localExists = local != null
-        val remoteExists = remote != null
-
-        val localChanged = known == null || (localExists && local!!.lastModifiedMs != known.localModifiedAt?.toEpochMilli())
-        val remoteChanged = known == null || (remoteExists && (remote!!.etag != known.remoteEtag || remote.modifiedAt != known.remoteModifiedAt))
-
-        return when {
-            !localExists && !remoteExists -> SyncDecision.SKIP
-
-            localExists && !remoteExists -> when {
-                known == null -> when (direction) {
-                    SyncDirection.UPLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.UPLOAD
-                    else -> SyncDecision.SKIP
-                }
-                else -> when {
-                    deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
-                    direction == SyncDirection.DOWNLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_LOCAL
-                    else -> SyncDecision.SKIP
-                }
+    private suspend fun ensureRemoteDirs(provider: CloudProvider, remotePairPath: String, rel: String) {
+        val parts = rel.replace('\\', '/').split('/')
+        var currentPath = remotePairPath
+        for (part in parts.dropLast(1)) {
+            currentPath = "$currentPath/$part"
+            provider.createDirectory(currentPath).onFailure { e ->
+                Timber.w("MKCOL $currentPath: ${e.message}")
             }
-
-            !localExists && remoteExists -> when {
-                known == null -> when (direction) {
-                    SyncDirection.DOWNLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.DOWNLOAD
-                    else -> SyncDecision.SKIP
-                }
-                else -> when {
-                    deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
-                    direction == SyncDirection.UPLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_REMOTE
-                    else -> SyncDecision.SKIP
-                }
-            }
-
-            localChanged && remoteChanged -> when (direction) {
-                SyncDirection.UPLOAD_ONLY -> SyncDecision.UPLOAD
-                SyncDirection.DOWNLOAD_ONLY -> SyncDecision.DOWNLOAD
-                SyncDirection.TWO_WAY -> when (conflictStrategy) {
-                    ConflictStrategy.KEEP_LOCAL -> SyncDecision.UPLOAD
-                    ConflictStrategy.KEEP_REMOTE -> SyncDecision.DOWNLOAD
-                    ConflictStrategy.KEEP_NEWEST -> if ((local?.lastModifiedMs ?: 0L) >= (remote?.modifiedAt?.toEpochMilli() ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
-                    ConflictStrategy.KEEP_LARGEST -> if ((local?.sizeBytes ?: 0L) >= (remote?.sizeBytes ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
-                    ConflictStrategy.KEEP_BOTH -> SyncDecision.CONFLICT
-                    ConflictStrategy.ASK -> SyncDecision.CONFLICT
-                }
-            }
-
-            localChanged -> when (direction) {
-                SyncDirection.UPLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.UPLOAD
-                else -> SyncDecision.SKIP
-            }
-            remoteChanged -> when (direction) {
-                SyncDirection.DOWNLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.DOWNLOAD
-                else -> SyncDecision.SKIP
-            }
-            else -> SyncDecision.SKIP
         }
     }
 
@@ -232,16 +202,16 @@ class SyncEngine @Inject constructor(
         pairId: Long,
         rel: String,
         local: LocalFileInfo?,
-        remote: RemoteFile?,
-    ) = com.syncflow.data.db.entities.SyncFileStateEntity(
+        remoteAfterTransfer: RemoteFile?,
+    ) = SyncFileStateEntity(
         syncPairId = pairId,
         relativePath = rel,
         localModifiedAt = local?.lastModifiedMs?.let { Instant.ofEpochMilli(it) },
         localSizeBytes = local?.sizeBytes ?: 0L,
         localHash = null,
-        remoteModifiedAt = remote?.modifiedAt,
-        remoteSizeBytes = remote?.sizeBytes ?: 0L,
-        remoteEtag = remote?.etag,
+        remoteModifiedAt = remoteAfterTransfer?.modifiedAt,
+        remoteSizeBytes = remoteAfterTransfer?.sizeBytes ?: 0L,
+        remoteEtag = remoteAfterTransfer?.etag,
         lastSyncedAt = Instant.now(),
         syncedHash = null,
     )
@@ -251,6 +221,92 @@ class SyncEngine @Inject constructor(
     }
 }
 
+// Top-level so unit tests can call it directly without instantiating SyncEngine.
+internal fun syncDecide(
+    direction: SyncDirection,
+    conflictStrategy: ConflictStrategy,
+    deleteBehavior: DeleteBehavior,
+    local: LocalFileInfo?,
+    remote: RemoteFile?,
+    known: SyncFileStateEntity?,
+    hasPriorSyncState: Boolean = false,
+): SyncDecision {
+    val localExists = local != null
+    val remoteExists = remote != null
+
+    // Treat null known timestamps as "not yet recorded" — don't treat as changed.
+    // The SKIP reconciliation pass will fill them in on the next sync.
+    val localChanged = known == null ||
+        (localExists && known.localModifiedAt != null &&
+            local!!.lastModifiedMs != known.localModifiedAt.toEpochMilli())
+    val remoteChanged = known == null ||
+        (remoteExists && known.remoteModifiedAt != null &&
+            (remote!!.etag != known.remoteEtag || remote.modifiedAt != known.remoteModifiedAt))
+
+    return when {
+        !localExists && !remoteExists -> SyncDecision.SKIP
+
+        localExists && !remoteExists -> when {
+            known == null -> when (direction) {
+                SyncDirection.UPLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.UPLOAD
+                else -> SyncDecision.SKIP
+            }
+            else -> when {
+                deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
+                direction == SyncDirection.DOWNLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_LOCAL
+                else -> SyncDecision.SKIP
+            }
+        }
+
+        !localExists && remoteExists -> when {
+            known == null -> if (!hasPriorSyncState) {
+                // Initial sync: no history at all — remote files are new, download them.
+                when (direction) {
+                    SyncDirection.DOWNLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.DOWNLOAD
+                    else -> SyncDecision.SKIP
+                }
+            } else {
+                // Pair has been synced before but this file has no state record
+                // (e.g. uploaded before state-tracking was fixed). Treat the same
+                // as a known remote-deletion: apply mirror/keep behavior.
+                when {
+                    deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
+                    direction == SyncDirection.UPLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_REMOTE
+                    else -> SyncDecision.SKIP
+                }
+            }
+            else -> when {
+                deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
+                direction == SyncDirection.UPLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_REMOTE
+                else -> SyncDecision.SKIP
+            }
+        }
+
+        localChanged && remoteChanged -> when (direction) {
+            SyncDirection.UPLOAD_ONLY -> SyncDecision.UPLOAD
+            SyncDirection.DOWNLOAD_ONLY -> SyncDecision.DOWNLOAD
+            SyncDirection.TWO_WAY -> when (conflictStrategy) {
+                ConflictStrategy.KEEP_LOCAL -> SyncDecision.UPLOAD
+                ConflictStrategy.KEEP_REMOTE -> SyncDecision.DOWNLOAD
+                ConflictStrategy.KEEP_NEWEST -> if ((local?.lastModifiedMs ?: 0L) >= (remote?.modifiedAt?.toEpochMilli() ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
+                ConflictStrategy.KEEP_LARGEST -> if ((local?.sizeBytes ?: 0L) >= (remote?.sizeBytes ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
+                ConflictStrategy.KEEP_BOTH -> SyncDecision.CONFLICT
+                ConflictStrategy.ASK -> SyncDecision.CONFLICT
+            }
+        }
+
+        localChanged -> when (direction) {
+            SyncDirection.UPLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.UPLOAD
+            else -> SyncDecision.SKIP
+        }
+        remoteChanged -> when (direction) {
+            SyncDirection.DOWNLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.DOWNLOAD
+            else -> SyncDecision.SKIP
+        }
+        else -> SyncDecision.SKIP
+    }
+}
+
 enum class SyncDecision { UPLOAD, DOWNLOAD, DELETE_LOCAL, DELETE_REMOTE, CONFLICT, SKIP }
 
 data class SyncResult(

app/src/test/kotlin/com/syncflow/domain/sync/SyncDecideTest.kt

@@ -0,0 +1,164 @@
+package com.syncflow.domain.sync
+
+import com.syncflow.data.db.entities.SyncFileStateEntity
+import com.syncflow.domain.model.*
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.time.Instant
+
+class SyncDecideTest {
+
+    private val MS  = 1_716_000_000_000L
+    private val MS2 = MS + 5_000L
+
+    private fun local(ms: Long = MS, size: Long = 100L) = LocalFileInfo("test.txt", size, ms)
+
+    private fun remote(ms: Long = MS, etag: String? = "abc", size: Long = 100L) =
+        RemoteFile(
+            path = "path/test.txt", name = "test.txt", isDirectory = false,
+            sizeBytes = size, modifiedAt = Instant.ofEpochMilli(ms),
+            etag = etag, mimeType = null,
+        )
+
+    private fun state(localMs: Long? = MS, remoteMs: Long? = MS, etag: String? = "abc") =
+        SyncFileStateEntity(
+            syncPairId = 1L, relativePath = "test.txt",
+            localModifiedAt  = localMs?.let  { Instant.ofEpochMilli(it) },
+            localSizeBytes   = 100L, localHash = null,
+            remoteModifiedAt = remoteMs?.let { Instant.ofEpochMilli(it) },
+            remoteSizeBytes  = 100L, remoteEtag = etag,
+            lastSyncedAt = Instant.now(), syncedHash = null,
+        )
+
+    private fun decide(
+        local: LocalFileInfo?, remote: RemoteFile?, known: SyncFileStateEntity? = null,
+        dir: SyncDirection = SyncDirection.TWO_WAY,
+        conflict: ConflictStrategy = ConflictStrategy.KEEP_NEWEST,
+        delete: DeleteBehavior = DeleteBehavior.MIRROR,
+        hasPriorState: Boolean = known != null,
+    ) = syncDecide(dir, conflict, delete, local, remote, known, hasPriorState)
+
+    // ── first sync (no known state) ───────────────────────────────────────────
+
+    @Test fun `first sync both exist local newer uploads`() =
+        assertEquals(SyncDecision.UPLOAD, decide(local(MS2), remote(MS)))
+
+    @Test fun `first sync both exist remote newer downloads`() =
+        assertEquals(SyncDecision.DOWNLOAD, decide(local(MS), remote(MS2)))
+
+    @Test fun `first sync local only TWO_WAY uploads`() =
+        assertEquals(SyncDecision.UPLOAD, decide(local(), null))
+
+    @Test fun `first sync remote only TWO_WAY downloads`() =
+        assertEquals(SyncDecision.DOWNLOAD, decide(null, remote()))
+
+    // ── after upload: remote metadata null in state ───────────────────────────
+
+    @Test fun `second sync after upload remote metadata null skips`() {
+        // State saved after upload: local mtime known, remote unknown (null).
+        val known = state(localMs = MS, remoteMs = null, etag = null)
+        // Remote listing shows a new mtime (server assigned), but we treat null as "no change".
+        assertEquals(SyncDecision.SKIP, decide(local(MS), remote(MS2), known))
+    }
+
+    @Test fun `after upload local changed again re-uploads`() {
+        val known = state(localMs = MS, remoteMs = null, etag = null)
+        assertEquals(SyncDecision.UPLOAD, decide(local(MS2), remote(MS2), known))
+    }
+
+    // ── after download: local mtime recorded ─────────────────────────────────
+
+    @Test fun `second sync fully recorded skips`() {
+        val known = state(localMs = MS, remoteMs = MS, etag = "abc")
+        assertEquals(SyncDecision.SKIP, decide(local(MS), remote(MS, etag = "abc"), known))
+    }
+
+    @Test fun `remote changed after download downloads`() {
+        val known = state(localMs = MS, remoteMs = MS, etag = "abc")
+        assertEquals(SyncDecision.DOWNLOAD, decide(local(MS), remote(MS2, etag = "xyz"), known))
+    }
+
+    @Test fun `local changed after download uploads`() {
+        val known = state(localMs = MS, remoteMs = MS, etag = "abc")
+        assertEquals(SyncDecision.UPLOAD, decide(local(MS2), remote(MS, etag = "abc"), known))
+    }
+
+    // ── epoch-millis precision ────────────────────────────────────────────────
+
+    @Test fun `same millisecond timestamp treated as unchanged`() {
+        val ts = 1_716_393_136_789L
+        assertEquals(SyncDecision.SKIP,
+            decide(local(ts), remote(ts, etag = "e"), state(localMs = ts, remoteMs = ts, etag = "e")))
+    }
+
+    @Test fun `1ms difference detected as local change`() {
+        val ts = 1_716_393_136_789L
+        assertEquals(SyncDecision.UPLOAD,
+            decide(local(ts + 1), remote(ts, etag = "e"), state(localMs = ts, remoteMs = ts, etag = "e")))
+    }
+
+    @Test fun `epoch-second stored value differs from millis comparison`() {
+        // If we stored 1716393136 (seconds) and compare to 1716393136000 (millis) they differ →
+        // This was the original bug — now we store millis so they should match.
+        val ms = 1_716_393_136_000L   // exact second boundary, no sub-second component
+        assertEquals(SyncDecision.SKIP,
+            decide(local(ms), remote(ms, etag = "e"), state(localMs = ms, remoteMs = ms, etag = "e")))
+    }
+
+    // ── delete behaviour ──────────────────────────────────────────────────────
+
+    @Test fun `local exists remote deleted TWO_WAY MIRROR deletes local`() =
+        assertEquals(SyncDecision.DELETE_LOCAL, decide(local(), null, state(), delete = DeleteBehavior.MIRROR))
+
+    @Test fun `local exists remote deleted KEEP skips`() =
+        assertEquals(SyncDecision.SKIP, decide(local(), null, state(), delete = DeleteBehavior.KEEP))
+
+    @Test fun `remote deleted UPLOAD_ONLY skips local deletion`() =
+        assertEquals(SyncDecision.SKIP,
+            decide(local(), null, state(), dir = SyncDirection.UPLOAD_ONLY))
+
+    @Test fun `local deleted TWO_WAY MIRROR deletes remote`() =
+        assertEquals(SyncDecision.DELETE_REMOTE, decide(null, remote(), state(), delete = DeleteBehavior.MIRROR))
+
+    @Test fun `local deleted TWO_WAY KEEP skips`() =
+        assertEquals(SyncDecision.SKIP, decide(null, remote(), state(), delete = DeleteBehavior.KEEP))
+
+    @Test fun `local deleted DOWNLOAD_ONLY skips remote deletion`() =
+        assertEquals(SyncDecision.SKIP,
+            decide(null, remote(), state(), dir = SyncDirection.DOWNLOAD_ONLY))
+
+    // ── local deleted, no state record (uploaded in broken version) ──────────
+
+    @Test fun `local deleted no known state but pair has prior history deletes remote`() =
+        // hasPriorState=true means the pair has been synced before; file has no state
+        // because it was uploaded when getFileMetadata was broken. Should still mirror deletion.
+        assertEquals(SyncDecision.DELETE_REMOTE,
+            decide(null, remote(), known = null, delete = DeleteBehavior.MIRROR, hasPriorState = true))
+
+    @Test fun `initial sync remote only no prior state downloads`() =
+        assertEquals(SyncDecision.DOWNLOAD,
+            decide(null, remote(), known = null, hasPriorState = false))
+
+    // ── first-seen SKIP saves baseline so later deletions are detected ────────
+
+    @Test fun `first sync both exist same mtime uploads local wins tie`() =
+        assertEquals(SyncDecision.UPLOAD, decide(local(MS), remote(MS, etag = "abc")))
+
+    @Test fun `after first-seen skip local deleted deletes remote`() {
+        // Simulate: first sync saw both sides identical → SKIP (state saved by engine).
+        // Then local file deleted → known is now present → DELETE_REMOTE.
+        val known = state(localMs = MS, remoteMs = MS, etag = "abc")
+        assertEquals(SyncDecision.DELETE_REMOTE,
+            decide(null, remote(MS, etag = "abc"), known, delete = DeleteBehavior.MIRROR))
+    }
+
+    // ── directions ────────────────────────────────────────────────────────────
+
+    @Test fun `UPLOAD_ONLY ignores remote changes`() =
+        assertEquals(SyncDecision.SKIP,
+            decide(local(MS), remote(MS2, etag = "new"), state(), dir = SyncDirection.UPLOAD_ONLY))
+
+    @Test fun `DOWNLOAD_ONLY ignores local changes`() =
+        assertEquals(SyncDecision.SKIP,
+            decide(local(MS2), remote(MS, etag = "abc"), state(), dir = SyncDirection.DOWNLOAD_ONLY))
+}

version.properties

@@ -1,2 +1,2 @@
-VERSION_NAME=1.0.4
-VERSION_CODE=5
+VERSION_NAME=1.0.12
+VERSION_CODE=13